diff --git a/FBXLoader.js b/FBXLoader.js
new file mode 100644
index 0000000..6a5a133
--- /dev/null
+++ b/FBXLoader.js
@@ -0,0 +1,4115 @@
+/**
+ * @author Kyle-Larson https://github.com/Kyle-Larson
+ * @author Takahiro https://github.com/takahirox
+ * @author Lewy Blue https://github.com/looeee
+ *
+ * Loader loads FBX file and generates Group representing FBX scene.
+ * Requires FBX file to be >= 7.0 and in ASCII or >= 6400 in Binary format
+ * Versions lower than this may load but will probably have errors
+ *
+ * Needs Support:
+ *  Morph normals / blend shape normals
+ *
+ * FBX format references:
+ * 	https://wiki.blender.org/index.php/User:Mont29/Foundation/FBX_File_Structure
+ * 	http://help.autodesk.com/view/FBX/2017/ENU/?guid=__cpp_ref_index_html (C++ SDK reference)
+ *
+ * 	Binary format specification:
+ *		https://code.blender.org/2013/08/fbx-binary-file-format-specification/
+ */
+
+
+THREE.FBXLoader = ( function () {
+
+	var fbxTree;
+	var connections;
+	var sceneGraph;
+
+	function FBXLoader( manager ) {
+
+		THREE.Loader.call( this, manager );
+
+	}
+
+	FBXLoader.prototype = Object.assign( Object.create( THREE.Loader.prototype ), {
+
+		constructor: FBXLoader,
+
+		load: function ( url, onLoad, onProgress, onError ) {
+
+			var self = this;
+
+			var path = ( self.path === '' ) ? THREE.LoaderUtils.extractUrlBase( url ) : self.path;
+
+			var loader = new THREE.FileLoader( this.manager );
+			loader.setPath( self.path );
+			loader.setResponseType( 'arraybuffer' );
+
+			loader.load( url, function ( buffer ) {
+
+				try {
+
+					onLoad( self.parse( buffer, path ) );
+
+				} catch ( error ) {
+
+					setTimeout( function () {
+
+						if ( onError ) onError( error );
+
+						self.manager.itemError( url );
+
+					}, 0 );
+
+				}
+
+			}, onProgress, onError );
+
+		},
+
+		parse: function ( FBXBuffer, path ) {
+
+			if ( isFbxFormatBinary( FBXBuffer ) ) {
+
+				fbxTree = new BinaryParser().parse( FBXBuffer );
+
+			} else {
+
+				var FBXText = convertArrayBufferToString( FBXBuffer );
+
+				if ( ! isFbxFormatASCII( FBXText ) ) {
+
+					throw new Error( 'THREE.FBXLoader: Unknown format.' );
+
+				}
+
+				if ( getFbxVersion( FBXText ) < 7000 ) {
+
+					throw new Error( 'THREE.FBXLoader: FBX version not supported, FileVersion: ' + getFbxVersion( FBXText ) );
+
+				}
+
+				fbxTree = new TextParser().parse( FBXText );
+
+			}
+
+			// console.log( fbxTree );
+
+			var textureLoader = new THREE.TextureLoader( this.manager ).setPath( this.resourcePath || path ).setCrossOrigin( this.crossOrigin );
+
+			return new FBXTreeParser( textureLoader, this.manager ).parse( fbxTree );
+
+		}
+
+	} );
+
+	// Parse the FBXTree object returned by the BinaryParser or TextParser and return a THREE.Group
+	function FBXTreeParser( textureLoader, manager ) {
+
+		this.textureLoader = textureLoader;
+		this.manager = manager;
+
+	}
+
+	FBXTreeParser.prototype = {
+
+		constructor: FBXTreeParser,
+
+		parse: function () {
+
+			connections = this.parseConnections();
+
+			var images = this.parseImages();
+			var textures = this.parseTextures( images );
+			var materials = this.parseMaterials( textures );
+			var deformers = this.parseDeformers();
+			var geometryMap = new GeometryParser().parse( deformers );
+
+			this.parseScene( deformers, geometryMap, materials );
+
+			return sceneGraph;
+
+		},
+
+		// Parses FBXTree.Connections which holds parent-child connections between objects (e.g. material -> texture, model->geometry )
+		// and details the connection type
+		parseConnections: function () {
+
+			var connectionMap = new Map();
+
+			if ( 'Connections' in fbxTree ) {
+
+				var rawConnections = fbxTree.Connections.connections;
+
+				rawConnections.forEach( function ( rawConnection ) {
+
+					var fromID = rawConnection[ 0 ];
+					var toID = rawConnection[ 1 ];
+					var relationship = rawConnection[ 2 ];
+
+					if ( ! connectionMap.has( fromID ) ) {
+
+						connectionMap.set( fromID, {
+							parents: [],
+							children: []
+						} );
+
+					}
+
+					var parentRelationship = { ID: toID, relationship: relationship };
+					connectionMap.get( fromID ).parents.push( parentRelationship );
+
+					if ( ! connectionMap.has( toID ) ) {
+
+						connectionMap.set( toID, {
+							parents: [],
+							children: []
+						} );
+
+					}
+
+					var childRelationship = { ID: fromID, relationship: relationship };
+					connectionMap.get( toID ).children.push( childRelationship );
+
+				} );
+
+			}
+
+			return connectionMap;
+
+		},
+
+		// Parse FBXTree.Objects.Video for embedded image data
+		// These images are connected to textures in FBXTree.Objects.Textures
+		// via FBXTree.Connections.
+		parseImages: function () {
+
+			var images = {};
+			var blobs = {};
+
+			if ( 'Video' in fbxTree.Objects ) {
+
+				var videoNodes = fbxTree.Objects.Video;
+
+				for ( var nodeID in videoNodes ) {
+
+					var videoNode = videoNodes[ nodeID ];
+
+					var id = parseInt( nodeID );
+
+					images[ id ] = videoNode.RelativeFilename || videoNode.Filename;
+
+					// raw image data is in videoNode.Content
+					if ( 'Content' in videoNode ) {
+
+						var arrayBufferContent = ( videoNode.Content instanceof ArrayBuffer ) && ( videoNode.Content.byteLength > 0 );
+						var base64Content = ( typeof videoNode.Content === 'string' ) && ( videoNode.Content !== '' );
+
+						if ( arrayBufferContent || base64Content ) {
+
+							var image = this.parseImage( videoNodes[ nodeID ] );
+
+							blobs[ videoNode.RelativeFilename || videoNode.Filename ] = image;
+
+						}
+
+					}
+
+				}
+
+			}
+
+			for ( var id in images ) {
+
+				var filename = images[ id ];
+
+				if ( blobs[ filename ] !== undefined ) images[ id ] = blobs[ filename ];
+				else images[ id ] = images[ id ].split( '\\' ).pop();
+
+			}
+
+			return images;
+
+		},
+
+		// Parse embedded image data in FBXTree.Video.Content
+		parseImage: function ( videoNode ) {
+
+			var content = videoNode.Content;
+			var fileName = videoNode.RelativeFilename || videoNode.Filename;
+			var extension = fileName.slice( fileName.lastIndexOf( '.' ) + 1 ).toLowerCase();
+
+			var type;
+
+			switch ( extension ) {
+
+				case 'bmp':
+
+					type = 'image/bmp';
+					break;
+
+				case 'jpg':
+				case 'jpeg':
+
+					type = 'image/jpeg';
+					break;
+
+				case 'png':
+
+					type = 'image/png';
+					break;
+
+				case 'tif':
+
+					type = 'image/tiff';
+					break;
+
+				case 'tga':
+
+					if ( this.manager.getHandler( '.tga' ) === null ) {
+
+						console.warn( 'FBXLoader: TGA loader not found, skipping ', fileName );
+
+					}
+
+					type = 'image/tga';
+					break;
+
+				default:
+
+					console.warn( 'FBXLoader: Image type "' + extension + '" is not supported.' );
+					return;
+
+			}
+
+			if ( typeof content === 'string' ) { // ASCII format
+
+				return 'data:' + type + ';base64,' + content;
+
+			} else { // Binary Format
+
+				var array = new Uint8Array( content );
+				return window.URL.createObjectURL( new Blob( [ array ], { type: type } ) );
+
+			}
+
+		},
+
+		// Parse nodes in FBXTree.Objects.Texture
+		// These contain details such as UV scaling, cropping, rotation etc and are connected
+		// to images in FBXTree.Objects.Video
+		parseTextures: function ( images ) {
+
+			var textureMap = new Map();
+
+			if ( 'Texture' in fbxTree.Objects ) {
+
+				var textureNodes = fbxTree.Objects.Texture;
+				for ( var nodeID in textureNodes ) {
+
+					var texture = this.parseTexture( textureNodes[ nodeID ], images );
+					textureMap.set( parseInt( nodeID ), texture );
+
+				}
+
+			}
+
+			return textureMap;
+
+		},
+
+		// Parse individual node in FBXTree.Objects.Texture
+		parseTexture: function ( textureNode, images ) {
+
+			var texture = this.loadTexture( textureNode, images );
+
+			texture.ID = textureNode.id;
+
+			texture.name = textureNode.attrName;
+
+			var wrapModeU = textureNode.WrapModeU;
+			var wrapModeV = textureNode.WrapModeV;
+
+			var valueU = wrapModeU !== undefined ? wrapModeU.value : 0;
+			var valueV = wrapModeV !== undefined ? wrapModeV.value : 0;
+
+			// http://download.autodesk.com/us/fbx/SDKdocs/FBX_SDK_Help/files/fbxsdkref/class_k_fbx_texture.html#889640e63e2e681259ea81061b85143a
+			// 0: repeat(default), 1: clamp
+
+			texture.wrapS = valueU === 0 ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
+			texture.wrapT = valueV === 0 ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping;
+
+			if ( 'Scaling' in textureNode ) {
+
+				var values = textureNode.Scaling.value;
+
+				texture.repeat.x = values[ 0 ];
+				texture.repeat.y = values[ 1 ];
+
+			}
+
+			return texture;
+
+		},
+
+		// load a texture specified as a blob or data URI, or via an external URL using THREE.TextureLoader
+		loadTexture: function ( textureNode, images ) {
+
+			var fileName;
+
+			var currentPath = this.textureLoader.path;
+
+			var children = connections.get( textureNode.id ).children;
+
+			if ( children !== undefined && children.length > 0 && images[ children[ 0 ].ID ] !== undefined ) {
+
+				fileName = images[ children[ 0 ].ID ];
+
+				if ( fileName.indexOf( 'blob:' ) === 0 || fileName.indexOf( 'data:' ) === 0 ) {
+
+					this.textureLoader.setPath( undefined );
+
+				}
+
+			}
+
+			var texture;
+
+			var extension = textureNode.FileName.slice( - 3 ).toLowerCase();
+
+			if ( extension === 'tga' ) {
+
+				var loader = this.manager.getHandler( '.tga' );
+
+				if ( loader === null ) {
+
+					console.warn( 'FBXLoader: TGA loader not found, creating placeholder texture for', textureNode.RelativeFilename );
+					texture = new THREE.Texture();
+
+				} else {
+
+					texture = loader.load( fileName );
+
+				}
+
+			} else if ( extension === 'psd' ) {
+
+				console.warn( 'FBXLoader: PSD textures are not supported, creating placeholder texture for', textureNode.RelativeFilename );
+				texture = new THREE.Texture();
+
+			} else {
+
+				texture = this.textureLoader.load( fileName );
+
+			}
+
+			this.textureLoader.setPath( currentPath );
+
+			return texture;
+
+		},
+
+		// Parse nodes in FBXTree.Objects.Material
+		parseMaterials: function ( textureMap ) {
+
+			var materialMap = new Map();
+
+			if ( 'Material' in fbxTree.Objects ) {
+
+				var materialNodes = fbxTree.Objects.Material;
+
+				for ( var nodeID in materialNodes ) {
+
+					var material = this.parseMaterial( materialNodes[ nodeID ], textureMap );
+
+					if ( material !== null ) materialMap.set( parseInt( nodeID ), material );
+
+				}
+
+			}
+
+			return materialMap;
+
+		},
+
+		// Parse single node in FBXTree.Objects.Material
+		// Materials are connected to texture maps in FBXTree.Objects.Textures
+		// FBX format currently only supports Lambert and Phong shading models
+		parseMaterial: function ( materialNode, textureMap ) {
+
+			var ID = materialNode.id;
+			var name = materialNode.attrName;
+			var type = materialNode.ShadingModel;
+
+			// Case where FBX wraps shading model in property object.
+			if ( typeof type === 'object' ) {
+
+				type = type.value;
+
+			}
+
+			// Ignore unused materials which don't have any connections.
+			if ( ! connections.has( ID ) ) return null;
+
+			var parameters = this.parseParameters( materialNode, textureMap, ID );
+
+			var material;
+
+			switch ( type.toLowerCase() ) {
+
+				case 'phong':
+					material = new THREE.MeshPhongMaterial();
+					break;
+				case 'lambert':
+					material = new THREE.MeshLambertMaterial();
+					break;
+				default:
+					console.warn( 'THREE.FBXLoader: unknown material type "%s". Defaulting to MeshPhongMaterial.', type );
+					material = new THREE.MeshPhongMaterial();
+					break;
+
+			}
+
+			material.setValues( parameters );
+			material.name = name;
+
+			return material;
+
+		},
+
+		// Parse FBX material and return parameters suitable for a three.js material
+		// Also parse the texture map and return any textures associated with the material
+		parseParameters: function ( materialNode, textureMap, ID ) {
+
+			var parameters = {};
+
+			if ( materialNode.BumpFactor ) {
+
+				parameters.bumpScale = materialNode.BumpFactor.value;
+
+			}
+			if ( materialNode.Diffuse ) {
+
+				parameters.color = new THREE.Color().fromArray( materialNode.Diffuse.value );
+
+			} else if ( materialNode.DiffuseColor && materialNode.DiffuseColor.type === 'Color' ) {
+
+				// The blender exporter exports diffuse here instead of in materialNode.Diffuse
+				parameters.color = new THREE.Color().fromArray( materialNode.DiffuseColor.value );
+
+			}
+
+			if ( materialNode.DisplacementFactor ) {
+
+				parameters.displacementScale = materialNode.DisplacementFactor.value;
+
+			}
+
+			if ( materialNode.Emissive ) {
+
+				parameters.emissive = new THREE.Color().fromArray( materialNode.Emissive.value );
+
+			} else if ( materialNode.EmissiveColor && materialNode.EmissiveColor.type === 'Color' ) {
+
+				// The blender exporter exports emissive color here instead of in materialNode.Emissive
+				parameters.emissive = new THREE.Color().fromArray( materialNode.EmissiveColor.value );
+
+			}
+
+			if ( materialNode.EmissiveFactor ) {
+
+				parameters.emissiveIntensity = parseFloat( materialNode.EmissiveFactor.value );
+
+			}
+
+			if ( materialNode.Opacity ) {
+
+				parameters.opacity = parseFloat( materialNode.Opacity.value );
+
+			}
+
+			if ( parameters.opacity < 1.0 ) {
+
+				parameters.transparent = true;
+
+			}
+
+			if ( materialNode.ReflectionFactor ) {
+
+				parameters.reflectivity = materialNode.ReflectionFactor.value;
+
+			}
+
+			if ( materialNode.Shininess ) {
+
+				parameters.shininess = materialNode.Shininess.value;
+
+			}
+
+			if ( materialNode.Specular ) {
+
+				parameters.specular = new THREE.Color().fromArray( materialNode.Specular.value );
+
+			} else if ( materialNode.SpecularColor && materialNode.SpecularColor.type === 'Color' ) {
+
+				// The blender exporter exports specular color here instead of in materialNode.Specular
+				parameters.specular = new THREE.Color().fromArray( materialNode.SpecularColor.value );
+
+			}
+
+			var self = this;
+			connections.get( ID ).children.forEach( function ( child ) {
+
+				var type = child.relationship;
+
+				switch ( type ) {
+
+					case 'Bump':
+						parameters.bumpMap = self.getTexture( textureMap, child.ID );
+						break;
+
+					case 'Maya|TEX_ao_map':
+						parameters.aoMap = self.getTexture( textureMap, child.ID );
+						break;
+
+					case 'DiffuseColor':
+					case 'Maya|TEX_color_map':
+						parameters.map = self.getTexture( textureMap, child.ID );
+						parameters.map.encoding = THREE.sRGBEncoding;
+						break;
+
+					case 'DisplacementColor':
+						parameters.displacementMap = self.getTexture( textureMap, child.ID );
+						break;
+
+					case 'EmissiveColor':
+						parameters.emissiveMap = self.getTexture( textureMap, child.ID );
+						parameters.emissiveMap.encoding = THREE.sRGBEncoding;
+						break;
+
+					case 'NormalMap':
+					case 'Maya|TEX_normal_map':
+						parameters.normalMap = self.getTexture( textureMap, child.ID );
+						break;
+
+					case 'ReflectionColor':
+						parameters.envMap = self.getTexture( textureMap, child.ID );
+						parameters.envMap.mapping = THREE.EquirectangularReflectionMapping;
+						parameters.envMap.encoding = THREE.sRGBEncoding;
+						break;
+
+					case 'SpecularColor':
+						parameters.specularMap = self.getTexture( textureMap, child.ID );
+						parameters.specularMap.encoding = THREE.sRGBEncoding;
+						break;
+
+					case 'TransparentColor':
+						parameters.alphaMap = self.getTexture( textureMap, child.ID );
+						parameters.transparent = true;
+						break;
+
+					case 'AmbientColor':
+					case 'ShininessExponent': // AKA glossiness map
+					case 'SpecularFactor': // AKA specularLevel
+					case 'VectorDisplacementColor': // NOTE: Seems to be a copy of DisplacementColor
+					default:
+						console.warn( 'THREE.FBXLoader: %s map is not supported in three.js, skipping texture.', type );
+						break;
+
+				}
+
+			} );
+
+			return parameters;
+
+		},
+
+		// get a texture from the textureMap for use by a material.
+		getTexture: function ( textureMap, id ) {
+
+			// if the texture is a layered texture, just use the first layer and issue a warning
+			if ( 'LayeredTexture' in fbxTree.Objects && id in fbxTree.Objects.LayeredTexture ) {
+
+				console.warn( 'THREE.FBXLoader: layered textures are not supported in three.js. Discarding all but first layer.' );
+				id = connections.get( id ).children[ 0 ].ID;
+
+			}
+
+			return textureMap.get( id );
+
+		},
+
+		// Parse nodes in FBXTree.Objects.Deformer
+		// Deformer node can contain skinning or Vertex Cache animation data, however only skinning is supported here
+		// Generates map of Skeleton-like objects for use later when generating and binding skeletons.
+		parseDeformers: function () {
+
+			var skeletons = {};
+			var morphTargets = {};
+
+			if ( 'Deformer' in fbxTree.Objects ) {
+
+				var DeformerNodes = fbxTree.Objects.Deformer;
+
+				for ( var nodeID in DeformerNodes ) {
+
+					var deformerNode = DeformerNodes[ nodeID ];
+
+					var relationships = connections.get( parseInt( nodeID ) );
+
+					if ( deformerNode.attrType === 'Skin' ) {
+
+						var skeleton = this.parseSkeleton( relationships, DeformerNodes );
+						skeleton.ID = nodeID;
+
+						if ( relationships.parents.length > 1 ) console.warn( 'THREE.FBXLoader: skeleton attached to more than one geometry is not supported.' );
+						skeleton.geometryID = relationships.parents[ 0 ].ID;
+
+						skeletons[ nodeID ] = skeleton;
+
+					} else if ( deformerNode.attrType === 'BlendShape' ) {
+
+						var morphTarget = {
+							id: nodeID,
+						};
+
+						morphTarget.rawTargets = this.parseMorphTargets( relationships, DeformerNodes );
+						morphTarget.id = nodeID;
+
+						if ( relationships.parents.length > 1 ) console.warn( 'THREE.FBXLoader: morph target attached to more than one geometry is not supported.' );
+
+						morphTargets[ nodeID ] = morphTarget;
+
+					}
+
+				}
+
+			}
+
+			return {
+
+				skeletons: skeletons,
+				morphTargets: morphTargets,
+
+			};
+
+		},
+
+		// Parse single nodes in FBXTree.Objects.Deformer
+		// The top level skeleton node has type 'Skin' and sub nodes have type 'Cluster'
+		// Each skin node represents a skeleton and each cluster node represents a bone
+		parseSkeleton: function ( relationships, deformerNodes ) {
+
+			var rawBones = [];
+
+			relationships.children.forEach( function ( child ) {
+
+				var boneNode = deformerNodes[ child.ID ];
+
+				if ( boneNode.attrType !== 'Cluster' ) return;
+
+				var rawBone = {
+
+					ID: child.ID,
+					indices: [],
+					weights: [],
+					transformLink: new THREE.Matrix4().fromArray( boneNode.TransformLink.a ),
+					// transform: new THREE.Matrix4().fromArray( boneNode.Transform.a ),
+					// linkMode: boneNode.Mode,
+
+				};
+
+				if ( 'Indexes' in boneNode ) {
+
+					rawBone.indices = boneNode.Indexes.a;
+					rawBone.weights = boneNode.Weights.a;
+
+				}
+
+				rawBones.push( rawBone );
+
+			} );
+
+			return {
+
+				rawBones: rawBones,
+				bones: []
+
+			};
+
+		},
+
+		// The top level morph deformer node has type "BlendShape" and sub nodes have type "BlendShapeChannel"
+		parseMorphTargets: function ( relationships, deformerNodes ) {
+
+			var rawMorphTargets = [];
+
+			for ( var i = 0; i < relationships.children.length; i ++ ) {
+
+				var child = relationships.children[ i ];
+
+				var morphTargetNode = deformerNodes[ child.ID ];
+
+				var rawMorphTarget = {
+
+					name: morphTargetNode.attrName,
+					initialWeight: morphTargetNode.DeformPercent,
+					id: morphTargetNode.id,
+					fullWeights: morphTargetNode.FullWeights.a
+
+				};
+
+				if ( morphTargetNode.attrType !== 'BlendShapeChannel' ) return;
+
+				rawMorphTarget.geoID = connections.get( parseInt( child.ID ) ).children.filter( function ( child ) {
+
+					return child.relationship === undefined;
+
+				} )[ 0 ].ID;
+
+				rawMorphTargets.push( rawMorphTarget );
+
+			}
+
+			return rawMorphTargets;
+
+		},
+
+		// create the main THREE.Group() to be returned by the loader
+		parseScene: function ( deformers, geometryMap, materialMap ) {
+
+			sceneGraph = new THREE.Group();
+
+			var modelMap = this.parseModels( deformers.skeletons, geometryMap, materialMap );
+
+			var modelNodes = fbxTree.Objects.Model;
+
+			var self = this;
+			modelMap.forEach( function ( model ) {
+
+				var modelNode = modelNodes[ model.ID ];
+				self.setLookAtProperties( model, modelNode );
+
+				var parentConnections = connections.get( model.ID ).parents;
+
+				parentConnections.forEach( function ( connection ) {
+
+					var parent = modelMap.get( connection.ID );
+					if ( parent !== undefined ) parent.add( model );
+
+				} );
+
+				if ( model.parent === null ) {
+
+					sceneGraph.add( model );
+
+				}
+
+
+			} );
+
+			this.bindSkeleton( deformers.skeletons, geometryMap, modelMap );
+
+			this.createAmbientLight();
+
+			this.setupMorphMaterials();
+
+			sceneGraph.traverse( function ( node ) {
+
+				if ( node.userData.transformData ) {
+
+					if ( node.parent ) node.userData.transformData.parentMatrixWorld = node.parent.matrix;
+
+					var transform = generateTransform( node.userData.transformData );
+
+					node.applyMatrix( transform );
+
+				}
+
+			} );
+
+			var animations = new AnimationParser().parse();
+
+			// if all the models where already combined in a single group, just return that
+			if ( sceneGraph.children.length === 1 && sceneGraph.children[ 0 ].isGroup ) {
+
+				sceneGraph.children[ 0 ].animations = animations;
+				sceneGraph = sceneGraph.children[ 0 ];
+
+			}
+
+			sceneGraph.animations = animations;
+
+		},
+
+		// parse nodes in FBXTree.Objects.Model
+		parseModels: function ( skeletons, geometryMap, materialMap ) {
+
+			var modelMap = new Map();
+			var modelNodes = fbxTree.Objects.Model;
+
+			for ( var nodeID in modelNodes ) {
+
+				var id = parseInt( nodeID );
+				var node = modelNodes[ nodeID ];
+				var relationships = connections.get( id );
+
+				var model = this.buildSkeleton( relationships, skeletons, id, node.attrName );
+
+				if ( ! model ) {
+
+					switch ( node.attrType ) {
+
+						case 'Camera':
+							model = this.createCamera( relationships );
+							break;
+						case 'Light':
+							model = this.createLight( relationships );
+							break;
+						case 'Mesh':
+							model = this.createMesh( relationships, geometryMap, materialMap );
+							break;
+						case 'NurbsCurve':
+							model = this.createCurve( relationships, geometryMap );
+							break;
+						case 'LimbNode':
+						case 'Root':
+							model = new THREE.Bone();
+							break;
+						case 'Null':
+						default:
+							model = new THREE.Group();
+							break;
+
+					}
+
+					model.name = node.attrName ? THREE.PropertyBinding.sanitizeNodeName( node.attrName ) : '';
+
+					model.ID = id;
+
+				}
+
+				this.getTransformData( model, node );
+				modelMap.set( id, model );
+
+			}
+
+			return modelMap;
+
+		},
+
+		buildSkeleton: function ( relationships, skeletons, id, name ) {
+
+			var bone = null;
+
+			relationships.parents.forEach( function ( parent ) {
+
+				for ( var ID in skeletons ) {
+
+					var skeleton = skeletons[ ID ];
+
+					skeleton.rawBones.forEach( function ( rawBone, i ) {
+
+						if ( rawBone.ID === parent.ID ) {
+
+							var subBone = bone;
+							bone = new THREE.Bone();
+
+							bone.matrixWorld.copy( rawBone.transformLink );
+
+							// set name and id here - otherwise in cases where "subBone" is created it will not have a name / id
+
+							bone.name = name ? THREE.PropertyBinding.sanitizeNodeName( name ) : '';
+							bone.ID = id;
+
+							skeleton.bones[ i ] = bone;
+
+							// In cases where a bone is shared between multiple meshes
+							// duplicate the bone here and and it as a child of the first bone
+							if ( subBone !== null ) {
+
+								// bone.add( subBone );
+
+							}
+
+						}
+
+					} );
+
+				}
+
+			} );
+
+			return bone;
+
+		},
+
+		// create a THREE.PerspectiveCamera or THREE.OrthographicCamera
+		createCamera: function ( relationships ) {
+
+			var model;
+			var cameraAttribute;
+
+			relationships.children.forEach( function ( child ) {
+
+				var attr = fbxTree.Objects.NodeAttribute[ child.ID ];
+
+				if ( attr !== undefined ) {
+
+					cameraAttribute = attr;
+
+				}
+
+			} );
+
+			if ( cameraAttribute === undefined ) {
+
+				model = new THREE.Object3D();
+
+			} else {
+
+				var type = 0;
+				if ( cameraAttribute.CameraProjectionType !== undefined && cameraAttribute.CameraProjectionType.value === 1 ) {
+
+					type = 1;
+
+				}
+
+				var nearClippingPlane = 1;
+				if ( cameraAttribute.NearPlane !== undefined ) {
+
+					nearClippingPlane = cameraAttribute.NearPlane.value / 1000;
+
+				}
+
+				var farClippingPlane = 1000;
+				if ( cameraAttribute.FarPlane !== undefined ) {
+
+					farClippingPlane = cameraAttribute.FarPlane.value / 1000;
+
+				}
+
+
+				var width = window.innerWidth;
+				var height = window.innerHeight;
+
+				if ( cameraAttribute.AspectWidth !== undefined && cameraAttribute.AspectHeight !== undefined ) {
+
+					width = cameraAttribute.AspectWidth.value;
+					height = cameraAttribute.AspectHeight.value;
+
+				}
+
+				var aspect = width / height;
+
+				var fov = 45;
+				if ( cameraAttribute.FieldOfView !== undefined ) {
+
+					fov = cameraAttribute.FieldOfView.value;
+
+				}
+
+				var focalLength = cameraAttribute.FocalLength ? cameraAttribute.FocalLength.value : null;
+
+				switch ( type ) {
+
+					case 0: // Perspective
+						model = new THREE.PerspectiveCamera( fov, aspect, nearClippingPlane, farClippingPlane );
+						if ( focalLength !== null ) model.setFocalLength( focalLength );
+						break;
+
+					case 1: // Orthographic
+						model = new THREE.OrthographicCamera( - width / 2, width / 2, height / 2, - height / 2, nearClippingPlane, farClippingPlane );
+						break;
+
+					default:
+						console.warn( 'THREE.FBXLoader: Unknown camera type ' + type + '.' );
+						model = new THREE.Object3D();
+						break;
+
+				}
+
+			}
+
+			return model;
+
+		},
+
+		// Create a THREE.DirectionalLight, THREE.PointLight or THREE.SpotLight
+		createLight: function ( relationships ) {
+
+			var model;
+			var lightAttribute;
+
+			relationships.children.forEach( function ( child ) {
+
+				var attr = fbxTree.Objects.NodeAttribute[ child.ID ];
+
+				if ( attr !== undefined ) {
+
+					lightAttribute = attr;
+
+				}
+
+			} );
+
+			if ( lightAttribute === undefined ) {
+
+				model = new THREE.Object3D();
+
+			} else {
+
+				var type;
+
+				// LightType can be undefined for Point lights
+				if ( lightAttribute.LightType === undefined ) {
+
+					type = 0;
+
+				} else {
+
+					type = lightAttribute.LightType.value;
+
+				}
+
+				var color = 0xffffff;
+
+				if ( lightAttribute.Color !== undefined ) {
+
+					color = new THREE.Color().fromArray( lightAttribute.Color.value );
+
+				}
+
+				var intensity = ( lightAttribute.Intensity === undefined ) ? 1 : lightAttribute.Intensity.value / 100;
+
+				// light disabled
+				if ( lightAttribute.CastLightOnObject !== undefined && lightAttribute.CastLightOnObject.value === 0 ) {
+
+					intensity = 0;
+
+				}
+
+				var distance = 0;
+				if ( lightAttribute.FarAttenuationEnd !== undefined ) {
+
+					if ( lightAttribute.EnableFarAttenuation !== undefined && lightAttribute.EnableFarAttenuation.value === 0 ) {
+
+						distance = 0;
+
+					} else {
+
+						distance = lightAttribute.FarAttenuationEnd.value;
+
+					}
+
+				}
+
+				// TODO: could this be calculated linearly from FarAttenuationStart to FarAttenuationEnd?
+				var decay = 1;
+
+				switch ( type ) {
+
+					case 0: // Point
+						model = new THREE.PointLight( color, intensity, distance, decay );
+						break;
+
+					case 1: // Directional
+						model = new THREE.DirectionalLight( color, intensity );
+						break;
+
+					case 2: // Spot
+						var angle = Math.PI / 3;
+
+						if ( lightAttribute.InnerAngle !== undefined ) {
+
+							angle = THREE.Math.degToRad( lightAttribute.InnerAngle.value );
+
+						}
+
+						var penumbra = 0;
+						if ( lightAttribute.OuterAngle !== undefined ) {
+
+							// TODO: this is not correct - FBX calculates outer and inner angle in degrees
+							// with OuterAngle > InnerAngle && OuterAngle <= Math.PI
+							// while three.js uses a penumbra between (0, 1) to attenuate the inner angle
+							penumbra = THREE.Math.degToRad( lightAttribute.OuterAngle.value );
+							penumbra = Math.max( penumbra, 1 );
+
+						}
+
+						model = new THREE.SpotLight( color, intensity, distance, angle, penumbra, decay );
+						break;
+
+					default:
+						console.warn( 'THREE.FBXLoader: Unknown light type ' + lightAttribute.LightType.value + ', defaulting to a THREE.PointLight.' );
+						model = new THREE.PointLight( color, intensity );
+						break;
+
+				}
+
+				if ( lightAttribute.CastShadows !== undefined && lightAttribute.CastShadows.value === 1 ) {
+
+					model.castShadow = true;
+
+				}
+
+			}
+
+			return model;
+
+		},
+
+		createMesh: function ( relationships, geometryMap, materialMap ) {
+
+			var model;
+			var geometry = null;
+			var material = null;
+			var materials = [];
+
+			// get geometry and materials(s) from connections
+			relationships.children.forEach( function ( child ) {
+
+				if ( geometryMap.has( child.ID ) ) {
+
+					geometry = geometryMap.get( child.ID );
+
+				}
+
+				if ( materialMap.has( child.ID ) ) {
+
+					materials.push( materialMap.get( child.ID ) );
+
+				}
+
+			} );
+
+			if ( materials.length > 1 ) {
+
+				material = materials;
+
+			} else if ( materials.length > 0 ) {
+
+				material = materials[ 0 ];
+
+			} else {
+
+				material = new THREE.MeshPhongMaterial( { color: 0xcccccc } );
+				materials.push( material );
+
+			}
+
+			if ( 'color' in geometry.attributes ) {
+
+				materials.forEach( function ( material ) {
+
+					material.vertexColors = THREE.VertexColors;
+
+				} );
+
+			}
+
+			if ( geometry.FBX_Deformer ) {
+
+				materials.forEach( function ( material ) {
+
+					material.skinning = true;
+
+				} );
+
+				model = new THREE.SkinnedMesh( geometry, material );
+				model.normalizeSkinWeights();
+
+			} else {
+
+				model = new THREE.Mesh( geometry, material );
+
+			}
+
+			return model;
+
+		},
+
+		createCurve: function ( relationships, geometryMap ) {
+
+			var geometry = relationships.children.reduce( function ( geo, child ) {
+
+				if ( geometryMap.has( child.ID ) ) geo = geometryMap.get( child.ID );
+
+				return geo;
+
+			}, null );
+
+			// FBX does not list materials for Nurbs lines, so we'll just put our own in here.
+			var material = new THREE.LineBasicMaterial( { color: 0x3300ff, linewidth: 1 } );
+			return new THREE.Line( geometry, material );
+
+		},
+
+		// parse the model node for transform data
+		getTransformData: function ( model, modelNode ) {
+
+			var transformData = {};
+
+			if ( 'InheritType' in modelNode ) transformData.inheritType = parseInt( modelNode.InheritType.value );
+
+			if ( 'RotationOrder' in modelNode ) transformData.eulerOrder = getEulerOrder( modelNode.RotationOrder.value );
+			else transformData.eulerOrder = 'ZYX';
+
+			if ( 'Lcl_Translation' in modelNode ) transformData.translation = modelNode.Lcl_Translation.value;
+
+			if ( 'PreRotation' in modelNode ) transformData.preRotation = modelNode.PreRotation.value;
+			if ( 'Lcl_Rotation' in modelNode ) transformData.rotation = modelNode.Lcl_Rotation.value;
+			if ( 'PostRotation' in modelNode ) transformData.postRotation = modelNode.PostRotation.value;
+
+			if ( 'Lcl_Scaling' in modelNode ) transformData.scale = modelNode.Lcl_Scaling.value;
+
+			if ( 'ScalingOffset' in modelNode ) transformData.scalingOffset = modelNode.ScalingOffset.value;
+			if ( 'ScalingPivot' in modelNode ) transformData.scalingPivot = modelNode.ScalingPivot.value;
+
+			if ( 'RotationOffset' in modelNode ) transformData.rotationOffset = modelNode.RotationOffset.value;
+			if ( 'RotationPivot' in modelNode ) transformData.rotationPivot = modelNode.RotationPivot.value;
+
+			model.userData.transformData = transformData;
+
+		},
+
+		setLookAtProperties: function ( model, modelNode ) {
+
+			if ( 'LookAtProperty' in modelNode ) {
+
+				var children = connections.get( model.ID ).children;
+
+				children.forEach( function ( child ) {
+
+					if ( child.relationship === 'LookAtProperty' ) {
+
+						var lookAtTarget = fbxTree.Objects.Model[ child.ID ];
+
+						if ( 'Lcl_Translation' in lookAtTarget ) {
+
+							var pos = lookAtTarget.Lcl_Translation.value;
+
+							// DirectionalLight, SpotLight
+							if ( model.target !== undefined ) {
+
+								model.target.position.fromArray( pos );
+								sceneGraph.add( model.target );
+
+							} else { // Cameras and other Object3Ds
+
+								model.lookAt( new THREE.Vector3().fromArray( pos ) );
+
+							}
+
+						}
+
+					}
+
+				} );
+
+			}
+
+		},
+
+		bindSkeleton: function ( skeletons, geometryMap, modelMap ) {
+
+			var bindMatrices = this.parsePoseNodes();
+
+			for ( var ID in skeletons ) {
+
+				var skeleton = skeletons[ ID ];
+
+				var parents = connections.get( parseInt( skeleton.ID ) ).parents;
+
+				parents.forEach( function ( parent ) {
+
+					if ( geometryMap.has( parent.ID ) ) {
+
+						var geoID = parent.ID;
+						var geoRelationships = connections.get( geoID );
+
+						geoRelationships.parents.forEach( function ( geoConnParent ) {
+
+							if ( modelMap.has( geoConnParent.ID ) ) {
+
+								var model = modelMap.get( geoConnParent.ID );
+
+								model.bind( new THREE.Skeleton( skeleton.bones ), bindMatrices[ geoConnParent.ID ] );
+
+							}
+
+						} );
+
+					}
+
+				} );
+
+			}
+
+		},
+
+		parsePoseNodes: function () {
+
+			var bindMatrices = {};
+
+			if ( 'Pose' in fbxTree.Objects ) {
+
+				var BindPoseNode = fbxTree.Objects.Pose;
+
+				for ( var nodeID in BindPoseNode ) {
+
+					if ( BindPoseNode[ nodeID ].attrType === 'BindPose' ) {
+
+						var poseNodes = BindPoseNode[ nodeID ].PoseNode;
+
+						if ( Array.isArray( poseNodes ) ) {
+
+							poseNodes.forEach( function ( poseNode ) {
+
+								bindMatrices[ poseNode.Node ] = new THREE.Matrix4().fromArray( poseNode.Matrix.a );
+
+							} );
+
+						} else {
+
+							bindMatrices[ poseNodes.Node ] = new THREE.Matrix4().fromArray( poseNodes.Matrix.a );
+
+						}
+
+					}
+
+				}
+
+			}
+
+			return bindMatrices;
+
+		},
+
+		// Parse ambient color in FBXTree.GlobalSettings - if it's not set to black (default), create an ambient light
+		createAmbientLight: function () {
+
+			if ( 'GlobalSettings' in fbxTree && 'AmbientColor' in fbxTree.GlobalSettings ) {
+
+				var ambientColor = fbxTree.GlobalSettings.AmbientColor.value;
+				var r = ambientColor[ 0 ];
+				var g = ambientColor[ 1 ];
+				var b = ambientColor[ 2 ];
+
+				if ( r !== 0 || g !== 0 || b !== 0 ) {
+
+					var color = new THREE.Color( r, g, b );
+					sceneGraph.add( new THREE.AmbientLight( color, 1 ) );
+
+				}
+
+			}
+
+		},
+
+		setupMorphMaterials: function () {
+
+			var self = this;
+			sceneGraph.traverse( function ( child ) {
+
+				if ( child.isMesh ) {
+
+					if ( child.geometry.morphAttributes.position && child.geometry.morphAttributes.position.length ) {
+
+						if ( Array.isArray( child.material ) ) {
+
+							child.material.forEach( function ( material, i ) {
+
+								self.setupMorphMaterial( child, material, i );
+
+							} );
+
+						} else {
+
+							self.setupMorphMaterial( child, child.material );
+
+						}
+
+					}
+
+				}
+
+			} );
+
+		},
+
+		setupMorphMaterial: function ( child, material, index ) {
+
+			var uuid = child.uuid;
+			var matUuid = material.uuid;
+
+			// if a geometry has morph targets, it cannot share the material with other geometries
+			var sharedMat = false;
+
+			sceneGraph.traverse( function ( node ) {
+
+				if ( node.isMesh ) {
+
+					if ( Array.isArray( node.material ) ) {
+
+						node.material.forEach( function ( mat ) {
+
+							if ( mat.uuid === matUuid && node.uuid !== uuid ) sharedMat = true;
+
+						} );
+
+					} else if ( node.material.uuid === matUuid && node.uuid !== uuid ) sharedMat = true;
+
+				}
+
+			} );
+
+			if ( sharedMat === true ) {
+
+				var clonedMat = material.clone();
+				clonedMat.morphTargets = true;
+
+				if ( index === undefined ) child.material = clonedMat;
+				else child.material[ index ] = clonedMat;
+
+			} else material.morphTargets = true;
+
+		}
+
+	};
+
+	// parse Geometry data from FBXTree and return map of BufferGeometries
+	function GeometryParser() {}
+
+	GeometryParser.prototype = {
+
+		constructor: GeometryParser,
+
+		// Parse nodes in FBXTree.Objects.Geometry
+		parse: function ( deformers ) {
+
+			var geometryMap = new Map();
+
+			if ( 'Geometry' in fbxTree.Objects ) {
+
+				var geoNodes = fbxTree.Objects.Geometry;
+
+				for ( var nodeID in geoNodes ) {
+
+					var relationships = connections.get( parseInt( nodeID ) );
+					var geo = this.parseGeometry( relationships, geoNodes[ nodeID ], deformers );
+
+					geometryMap.set( parseInt( nodeID ), geo );
+
+				}
+
+			}
+
+			return geometryMap;
+
+		},
+
+		// Parse single node in FBXTree.Objects.Geometry
+		parseGeometry: function ( relationships, geoNode, deformers ) {
+
+			switch ( geoNode.attrType ) {
+
+				case 'Mesh':
+					return this.parseMeshGeometry( relationships, geoNode, deformers );
+					break;
+
+				case 'NurbsCurve':
+					return this.parseNurbsGeometry( geoNode );
+					break;
+
+			}
+
+		},
+
+
+		// Parse single node mesh geometry in FBXTree.Objects.Geometry
+		parseMeshGeometry: function ( relationships, geoNode, deformers ) {
+
+			var skeletons = deformers.skeletons;
+			var morphTargets = [];
+
+			var modelNodes = relationships.parents.map( function ( parent ) {
+
+				return fbxTree.Objects.Model[ parent.ID ];
+
+			} );
+
+			// don't create geometry if it is not associated with any models
+			if ( modelNodes.length === 0 ) return;
+
+			var skeleton = relationships.children.reduce( function ( skeleton, child ) {
+
+				if ( skeletons[ child.ID ] !== undefined ) skeleton = skeletons[ child.ID ];
+
+				return skeleton;
+
+			}, null );
+
+			relationships.children.forEach( function ( child ) {
+
+				if ( deformers.morphTargets[ child.ID ] !== undefined ) {
+
+					morphTargets.push( deformers.morphTargets[ child.ID ] );
+
+				}
+
+			} );
+
+			// Assume one model and get the preRotation from that
+			// if there is more than one model associated with the geometry this may cause problems
+			var modelNode = modelNodes[ 0 ];
+
+			var transformData = {};
+
+			if ( 'RotationOrder' in modelNode ) transformData.eulerOrder = getEulerOrder( modelNode.RotationOrder.value );
+			if ( 'InheritType' in modelNode ) transformData.inheritType = parseInt( modelNode.InheritType.value );
+
+			if ( 'GeometricTranslation' in modelNode ) transformData.translation = modelNode.GeometricTranslation.value;
+			if ( 'GeometricRotation' in modelNode ) transformData.rotation = modelNode.GeometricRotation.value;
+			if ( 'GeometricScaling' in modelNode ) transformData.scale = modelNode.GeometricScaling.value;
+
+			var transform = generateTransform( transformData );
+
+			return this.genGeometry( geoNode, skeleton, morphTargets, transform );
+
+		},
+
+		// Generate a THREE.BufferGeometry from a node in FBXTree.Objects.Geometry
+		genGeometry: function ( geoNode, skeleton, morphTargets, preTransform ) {
+
+			var geo = new THREE.BufferGeometry();
+			if ( geoNode.attrName ) geo.name = geoNode.attrName;
+
+			var geoInfo = this.parseGeoNode( geoNode, skeleton );
+			var buffers = this.genBuffers( geoInfo );
+
+			var positionAttribute = new THREE.Float32BufferAttribute( buffers.vertex, 3 );
+
+			preTransform.applyToBufferAttribute( positionAttribute );
+
+			geo.setAttribute( 'position', positionAttribute );
+
+			if ( buffers.colors.length > 0 ) {
+
+				geo.setAttribute( 'color', new THREE.Float32BufferAttribute( buffers.colors, 3 ) );
+
+			}
+
+			if ( skeleton ) {
+
+				geo.setAttribute( 'skinIndex', new THREE.Uint16BufferAttribute( buffers.weightsIndices, 4 ) );
+
+				geo.setAttribute( 'skinWeight', new THREE.Float32BufferAttribute( buffers.vertexWeights, 4 ) );
+
+				// used later to bind the skeleton to the model
+				geo.FBX_Deformer = skeleton;
+
+			}
+
+			if ( buffers.normal.length > 0 ) {
+
+				var normalAttribute = new THREE.Float32BufferAttribute( buffers.normal, 3 );
+
+				var normalMatrix = new THREE.Matrix3().getNormalMatrix( preTransform );
+				normalMatrix.applyToBufferAttribute( normalAttribute );
+
+				geo.setAttribute( 'normal', normalAttribute );
+
+			}
+
+			buffers.uvs.forEach( function ( uvBuffer, i ) {
+
+				// subsequent uv buffers are called 'uv1', 'uv2', ...
+				var name = 'uv' + ( i + 1 ).toString();
+
+				// the first uv buffer is just called 'uv'
+				if ( i === 0 ) {
+
+					name = 'uv';
+
+				}
+
+				geo.setAttribute( name, new THREE.Float32BufferAttribute( buffers.uvs[ i ], 2 ) );
+
+			} );
+
+			if ( geoInfo.material && geoInfo.material.mappingType !== 'AllSame' ) {
+
+				// Convert the material indices of each vertex into rendering groups on the geometry.
+				var prevMaterialIndex = buffers.materialIndex[ 0 ];
+				var startIndex = 0;
+
+				buffers.materialIndex.forEach( function ( currentIndex, i ) {
+
+					if ( currentIndex !== prevMaterialIndex ) {
+
+						geo.addGroup( startIndex, i - startIndex, prevMaterialIndex );
+
+						prevMaterialIndex = currentIndex;
+						startIndex = i;
+
+					}
+
+				} );
+
+				// the loop above doesn't add the last group, do that here.
+				if ( geo.groups.length > 0 ) {
+
+					var lastGroup = geo.groups[ geo.groups.length - 1 ];
+					var lastIndex = lastGroup.start + lastGroup.count;
+
+					if ( lastIndex !== buffers.materialIndex.length ) {
+
+						geo.addGroup( lastIndex, buffers.materialIndex.length - lastIndex, prevMaterialIndex );
+
+					}
+
+				}
+
+				// case where there are multiple materials but the whole geometry is only
+				// using one of them
+				if ( geo.groups.length === 0 ) {
+
+					geo.addGroup( 0, buffers.materialIndex.length, buffers.materialIndex[ 0 ] );
+
+				}
+
+			}
+
+			this.addMorphTargets( geo, geoNode, morphTargets, preTransform );
+
+			return geo;
+
+		},
+
+		parseGeoNode: function ( geoNode, skeleton ) {
+
+			var geoInfo = {};
+
+			geoInfo.vertexPositions = ( geoNode.Vertices !== undefined ) ? geoNode.Vertices.a : [];
+			geoInfo.vertexIndices = ( geoNode.PolygonVertexIndex !== undefined ) ? geoNode.PolygonVertexIndex.a : [];
+
+			if ( geoNode.LayerElementColor ) {
+
+				geoInfo.color = this.parseVertexColors( geoNode.LayerElementColor[ 0 ] );
+
+			}
+
+			if ( geoNode.LayerElementMaterial ) {
+
+				geoInfo.material = this.parseMaterialIndices( geoNode.LayerElementMaterial[ 0 ] );
+
+			}
+
+			if ( geoNode.LayerElementNormal ) {
+
+				geoInfo.normal = this.parseNormals( geoNode.LayerElementNormal[ 0 ] );
+
+			}
+
+			if ( geoNode.LayerElementUV ) {
+
+				geoInfo.uv = [];
+
+				var i = 0;
+				while ( geoNode.LayerElementUV[ i ] ) {
+
+					geoInfo.uv.push( this.parseUVs( geoNode.LayerElementUV[ i ] ) );
+					i ++;
+
+				}
+
+			}
+
+			geoInfo.weightTable = {};
+
+			if ( skeleton !== null ) {
+
+				geoInfo.skeleton = skeleton;
+
+				skeleton.rawBones.forEach( function ( rawBone, i ) {
+
+					// loop over the bone's vertex indices and weights
+					rawBone.indices.forEach( function ( index, j ) {
+
+						if ( geoInfo.weightTable[ index ] === undefined ) geoInfo.weightTable[ index ] = [];
+
+						geoInfo.weightTable[ index ].push( {
+
+							id: i,
+							weight: rawBone.weights[ j ],
+
+						} );
+
+					} );
+
+				} );
+
+			}
+
+			return geoInfo;
+
+		},
+
+		genBuffers: function ( geoInfo ) {
+
+			var buffers = {
+				vertex: [],
+				normal: [],
+				colors: [],
+				uvs: [],
+				materialIndex: [],
+				vertexWeights: [],
+				weightsIndices: [],
+			};
+
+			var polygonIndex = 0;
+			var faceLength = 0;
+			var displayedWeightsWarning = false;
+
+			// these will hold data for a single face
+			var facePositionIndexes = [];
+			var faceNormals = [];
+			var faceColors = [];
+			var faceUVs = [];
+			var faceWeights = [];
+			var faceWeightIndices = [];
+
+			var self = this;
+			geoInfo.vertexIndices.forEach( function ( vertexIndex, polygonVertexIndex ) {
+
+				var endOfFace = false;
+
+				// Face index and vertex index arrays are combined in a single array
+				// A cube with quad faces looks like this:
+				// PolygonVertexIndex: *24 {
+				//  a: 0, 1, 3, -3, 2, 3, 5, -5, 4, 5, 7, -7, 6, 7, 1, -1, 1, 7, 5, -4, 6, 0, 2, -5
+				//  }
+				// Negative numbers mark the end of a face - first face here is 0, 1, 3, -3
+				// to find index of last vertex bit shift the index: ^ - 1
+				if ( vertexIndex < 0 ) {
+
+					vertexIndex = vertexIndex ^ - 1; // equivalent to ( x * -1 ) - 1
+					endOfFace = true;
+
+				}
+
+				var weightIndices = [];
+				var weights = [];
+
+				facePositionIndexes.push( vertexIndex * 3, vertexIndex * 3 + 1, vertexIndex * 3 + 2 );
+
+				if ( geoInfo.color ) {
+
+					var data = getData( polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.color );
+
+					faceColors.push( data[ 0 ], data[ 1 ], data[ 2 ] );
+
+				}
+
+				if ( geoInfo.skeleton ) {
+
+					if ( geoInfo.weightTable[ vertexIndex ] !== undefined ) {
+
+						geoInfo.weightTable[ vertexIndex ].forEach( function ( wt ) {
+
+							weights.push( wt.weight );
+							weightIndices.push( wt.id );
+
+						} );
+
+
+					}
+
+					if ( weights.length > 4 ) {
+
+						if ( ! displayedWeightsWarning ) {
+
+							console.warn( 'THREE.FBXLoader: Vertex has more than 4 skinning weights assigned to vertex. Deleting additional weights.' );
+							displayedWeightsWarning = true;
+
+						}
+
+						var wIndex = [ 0, 0, 0, 0 ];
+						var Weight = [ 0, 0, 0, 0 ];
+
+						weights.forEach( function ( weight, weightIndex ) {
+
+							var currentWeight = weight;
+							var currentIndex = weightIndices[ weightIndex ];
+
+							Weight.forEach( function ( comparedWeight, comparedWeightIndex, comparedWeightArray ) {
+
+								if ( currentWeight > comparedWeight ) {
+
+									comparedWeightArray[ comparedWeightIndex ] = currentWeight;
+									currentWeight = comparedWeight;
+
+									var tmp = wIndex[ comparedWeightIndex ];
+									wIndex[ comparedWeightIndex ] = currentIndex;
+									currentIndex = tmp;
+
+								}
+
+							} );
+
+						} );
+
+						weightIndices = wIndex;
+						weights = Weight;
+
+					}
+
+					// if the weight array is shorter than 4 pad with 0s
+					while ( weights.length < 4 ) {
+
+						weights.push( 0 );
+						weightIndices.push( 0 );
+
+					}
+
+					for ( var i = 0; i < 4; ++ i ) {
+
+						faceWeights.push( weights[ i ] );
+						faceWeightIndices.push( weightIndices[ i ] );
+
+					}
+
+				}
+
+				if ( geoInfo.normal ) {
+
+					var data = getData( polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.normal );
+
+					faceNormals.push( data[ 0 ], data[ 1 ], data[ 2 ] );
+
+				}
+
+				if ( geoInfo.material && geoInfo.material.mappingType !== 'AllSame' ) {
+
+					var materialIndex = getData( polygonVertexIndex, polygonIndex, vertexIndex, geoInfo.material )[ 0 ];
+
+				}
+
+				if ( geoInfo.uv ) {
+
+					geoInfo.uv.forEach( function ( uv, i ) {
+
+						var data = getData( polygonVertexIndex, polygonIndex, vertexIndex, uv );
+
+						if ( faceUVs[ i ] === undefined ) {
+
+							faceUVs[ i ] = [];
+
+						}
+
+						faceUVs[ i ].push( data[ 0 ] );
+						faceUVs[ i ].push( data[ 1 ] );
+
+					} );
+
+				}
+
+				faceLength ++;
+
+				if ( endOfFace ) {
+
+					self.genFace( buffers, geoInfo, facePositionIndexes, materialIndex, faceNormals, faceColors, faceUVs, faceWeights, faceWeightIndices, faceLength );
+
+					polygonIndex ++;
+					faceLength = 0;
+
+					// reset arrays for the next face
+					facePositionIndexes = [];
+					faceNormals = [];
+					faceColors = [];
+					faceUVs = [];
+					faceWeights = [];
+					faceWeightIndices = [];
+
+				}
+
+			} );
+
+			return buffers;
+
+		},
+
+		// Generate data for a single face in a geometry. If the face is a quad then split it into 2 tris
+		genFace: function ( buffers, geoInfo, facePositionIndexes, materialIndex, faceNormals, faceColors, faceUVs, faceWeights, faceWeightIndices, faceLength ) {
+
+			for ( var i = 2; i < faceLength; i ++ ) {
+
+				buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ 0 ] ] );
+				buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ 1 ] ] );
+				buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ 2 ] ] );
+
+				buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ ( i - 1 ) * 3 ] ] );
+				buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ ( i - 1 ) * 3 + 1 ] ] );
+				buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ ( i - 1 ) * 3 + 2 ] ] );
+
+				buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i * 3 ] ] );
+				buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i * 3 + 1 ] ] );
+				buffers.vertex.push( geoInfo.vertexPositions[ facePositionIndexes[ i * 3 + 2 ] ] );
+
+				if ( geoInfo.skeleton ) {
+
+					buffers.vertexWeights.push( faceWeights[ 0 ] );
+					buffers.vertexWeights.push( faceWeights[ 1 ] );
+					buffers.vertexWeights.push( faceWeights[ 2 ] );
+					buffers.vertexWeights.push( faceWeights[ 3 ] );
+
+					buffers.vertexWeights.push( faceWeights[ ( i - 1 ) * 4 ] );
+					buffers.vertexWeights.push( faceWeights[ ( i - 1 ) * 4 + 1 ] );
+					buffers.vertexWeights.push( faceWeights[ ( i - 1 ) * 4 + 2 ] );
+					buffers.vertexWeights.push( faceWeights[ ( i - 1 ) * 4 + 3 ] );
+
+					buffers.vertexWeights.push( faceWeights[ i * 4 ] );
+					buffers.vertexWeights.push( faceWeights[ i * 4 + 1 ] );
+					buffers.vertexWeights.push( faceWeights[ i * 4 + 2 ] );
+					buffers.vertexWeights.push( faceWeights[ i * 4 + 3 ] );
+
+					buffers.weightsIndices.push( faceWeightIndices[ 0 ] );
+					buffers.weightsIndices.push( faceWeightIndices[ 1 ] );
+					buffers.weightsIndices.push( faceWeightIndices[ 2 ] );
+					buffers.weightsIndices.push( faceWeightIndices[ 3 ] );
+
+					buffers.weightsIndices.push( faceWeightIndices[ ( i - 1 ) * 4 ] );
+					buffers.weightsIndices.push( faceWeightIndices[ ( i - 1 ) * 4 + 1 ] );
+					buffers.weightsIndices.push( faceWeightIndices[ ( i - 1 ) * 4 + 2 ] );
+					buffers.weightsIndices.push( faceWeightIndices[ ( i - 1 ) * 4 + 3 ] );
+
+					buffers.weightsIndices.push( faceWeightIndices[ i * 4 ] );
+					buffers.weightsIndices.push( faceWeightIndices[ i * 4 + 1 ] );
+					buffers.weightsIndices.push( faceWeightIndices[ i * 4 + 2 ] );
+					buffers.weightsIndices.push( faceWeightIndices[ i * 4 + 3 ] );
+
+				}
+
+				if ( geoInfo.color ) {
+
+					buffers.colors.push( faceColors[ 0 ] );
+					buffers.colors.push( faceColors[ 1 ] );
+					buffers.colors.push( faceColors[ 2 ] );
+
+					buffers.colors.push( faceColors[ ( i - 1 ) * 3 ] );
+					buffers.colors.push( faceColors[ ( i - 1 ) * 3 + 1 ] );
+					buffers.colors.push( faceColors[ ( i - 1 ) * 3 + 2 ] );
+
+					buffers.colors.push( faceColors[ i * 3 ] );
+					buffers.colors.push( faceColors[ i * 3 + 1 ] );
+					buffers.colors.push( faceColors[ i * 3 + 2 ] );
+
+				}
+
+				if ( geoInfo.material && geoInfo.material.mappingType !== 'AllSame' ) {
+
+					buffers.materialIndex.push( materialIndex );
+					buffers.materialIndex.push( materialIndex );
+					buffers.materialIndex.push( materialIndex );
+
+				}
+
+				if ( geoInfo.normal ) {
+
+					buffers.normal.push( faceNormals[ 0 ] );
+					buffers.normal.push( faceNormals[ 1 ] );
+					buffers.normal.push( faceNormals[ 2 ] );
+
+					buffers.normal.push( faceNormals[ ( i - 1 ) * 3 ] );
+					buffers.normal.push( faceNormals[ ( i - 1 ) * 3 + 1 ] );
+					buffers.normal.push( faceNormals[ ( i - 1 ) * 3 + 2 ] );
+
+					buffers.normal.push( faceNormals[ i * 3 ] );
+					buffers.normal.push( faceNormals[ i * 3 + 1 ] );
+					buffers.normal.push( faceNormals[ i * 3 + 2 ] );
+
+				}
+
+				if ( geoInfo.uv ) {
+
+					geoInfo.uv.forEach( function ( uv, j ) {
+
+						if ( buffers.uvs[ j ] === undefined ) buffers.uvs[ j ] = [];
+
+						buffers.uvs[ j ].push( faceUVs[ j ][ 0 ] );
+						buffers.uvs[ j ].push( faceUVs[ j ][ 1 ] );
+
+						buffers.uvs[ j ].push( faceUVs[ j ][ ( i - 1 ) * 2 ] );
+						buffers.uvs[ j ].push( faceUVs[ j ][ ( i - 1 ) * 2 + 1 ] );
+
+						buffers.uvs[ j ].push( faceUVs[ j ][ i * 2 ] );
+						buffers.uvs[ j ].push( faceUVs[ j ][ i * 2 + 1 ] );
+
+					} );
+
+				}
+
+			}
+
+		},
+
+		addMorphTargets: function ( parentGeo, parentGeoNode, morphTargets, preTransform ) {
+
+			if ( morphTargets.length === 0 ) return;
+
+			parentGeo.morphAttributes.position = [];
+			// parentGeo.morphAttributes.normal = []; // not implemented
+
+			 var self = this;
+			morphTargets.forEach( function ( morphTarget ) {
+
+				morphTarget.rawTargets.forEach( function ( rawTarget ) {
+
+					var morphGeoNode = fbxTree.Objects.Geometry[ rawTarget.geoID ];
+
+					if ( morphGeoNode !== undefined ) {
+
+						self.genMorphGeometry( parentGeo, parentGeoNode, morphGeoNode, preTransform, rawTarget.name );
+
+					}
+
+				} );
+
+			} );
+
+		},
+
+		// a morph geometry node is similar to a standard  node, and the node is also contained
+		// in FBXTree.Objects.Geometry, however it can only have attributes for position, normal
+		// and a special attribute Index defining which vertices of the original geometry are affected
+		// Normal and position attributes only have data for the vertices that are affected by the morph
+		genMorphGeometry: function ( parentGeo, parentGeoNode, morphGeoNode, preTransform, name ) {
+
+			var morphGeo = new THREE.BufferGeometry();
+			if ( morphGeoNode.attrName ) morphGeo.name = morphGeoNode.attrName;
+
+			var vertexIndices = ( parentGeoNode.PolygonVertexIndex !== undefined ) ? parentGeoNode.PolygonVertexIndex.a : [];
+
+			// make a copy of the parent's vertex positions
+			var vertexPositions = ( parentGeoNode.Vertices !== undefined ) ? parentGeoNode.Vertices.a.slice() : [];
+
+			var morphPositions = ( morphGeoNode.Vertices !== undefined ) ? morphGeoNode.Vertices.a : [];
+			var indices = ( morphGeoNode.Indexes !== undefined ) ? morphGeoNode.Indexes.a : [];
+
+			for ( var i = 0; i < indices.length; i ++ ) {
+
+				var morphIndex = indices[ i ] * 3;
+
+				// FBX format uses blend shapes rather than morph targets. This can be converted
+				// by additively combining the blend shape positions with the original geometry's positions
+				vertexPositions[ morphIndex ] += morphPositions[ i * 3 ];
+				vertexPositions[ morphIndex + 1 ] += morphPositions[ i * 3 + 1 ];
+				vertexPositions[ morphIndex + 2 ] += morphPositions[ i * 3 + 2 ];
+
+			}
+
+			// TODO: add morph normal support
+			var morphGeoInfo = {
+				vertexIndices: vertexIndices,
+				vertexPositions: vertexPositions,
+			};
+
+			var morphBuffers = this.genBuffers( morphGeoInfo );
+
+			var positionAttribute = new THREE.Float32BufferAttribute( morphBuffers.vertex, 3 );
+			positionAttribute.name = name || morphGeoNode.attrName;
+
+			preTransform.applyToBufferAttribute( positionAttribute );
+
+			parentGeo.morphAttributes.position.push( positionAttribute );
+
+		},
+
+		// Parse normal from FBXTree.Objects.Geometry.LayerElementNormal if it exists
+		parseNormals: function ( NormalNode ) {
+
+			var mappingType = NormalNode.MappingInformationType;
+			var referenceType = NormalNode.ReferenceInformationType;
+			var buffer = NormalNode.Normals.a;
+			var indexBuffer = [];
+			if ( referenceType === 'IndexToDirect' ) {
+
+				if ( 'NormalIndex' in NormalNode ) {
+
+					indexBuffer = NormalNode.NormalIndex.a;
+
+				} else if ( 'NormalsIndex' in NormalNode ) {
+
+					indexBuffer = NormalNode.NormalsIndex.a;
+
+				}
+
+			}
+
+			return {
+				dataSize: 3,
+				buffer: buffer,
+				indices: indexBuffer,
+				mappingType: mappingType,
+				referenceType: referenceType
+			};
+
+		},
+
+		// Parse UVs from FBXTree.Objects.Geometry.LayerElementUV if it exists
+		parseUVs: function ( UVNode ) {
+
+			var mappingType = UVNode.MappingInformationType;
+			var referenceType = UVNode.ReferenceInformationType;
+			var buffer = UVNode.UV.a;
+			var indexBuffer = [];
+			if ( referenceType === 'IndexToDirect' ) {
+
+				indexBuffer = UVNode.UVIndex.a;
+
+			}
+
+			return {
+				dataSize: 2,
+				buffer: buffer,
+				indices: indexBuffer,
+				mappingType: mappingType,
+				referenceType: referenceType
+			};
+
+		},
+
+		// Parse Vertex Colors from FBXTree.Objects.Geometry.LayerElementColor if it exists
+		parseVertexColors: function ( ColorNode ) {
+
+			var mappingType = ColorNode.MappingInformationType;
+			var referenceType = ColorNode.ReferenceInformationType;
+			var buffer = ColorNode.Colors.a;
+			var indexBuffer = [];
+			if ( referenceType === 'IndexToDirect' ) {
+
+				indexBuffer = ColorNode.ColorIndex.a;
+
+			}
+
+			return {
+				dataSize: 4,
+				buffer: buffer,
+				indices: indexBuffer,
+				mappingType: mappingType,
+				referenceType: referenceType
+			};
+
+		},
+
+		// Parse mapping and material data in FBXTree.Objects.Geometry.LayerElementMaterial if it exists
+		parseMaterialIndices: function ( MaterialNode ) {
+
+			var mappingType = MaterialNode.MappingInformationType;
+			var referenceType = MaterialNode.ReferenceInformationType;
+
+			if ( mappingType === 'NoMappingInformation' ) {
+
+				return {
+					dataSize: 1,
+					buffer: [ 0 ],
+					indices: [ 0 ],
+					mappingType: 'AllSame',
+					referenceType: referenceType
+				};
+
+			}
+
+			var materialIndexBuffer = MaterialNode.Materials.a;
+
+			// Since materials are stored as indices, there's a bit of a mismatch between FBX and what
+			// we expect.So we create an intermediate buffer that points to the index in the buffer,
+			// for conforming with the other functions we've written for other data.
+			var materialIndices = [];
+
+			for ( var i = 0; i < materialIndexBuffer.length; ++ i ) {
+
+				materialIndices.push( i );
+
+			}
+
+			return {
+				dataSize: 1,
+				buffer: materialIndexBuffer,
+				indices: materialIndices,
+				mappingType: mappingType,
+				referenceType: referenceType
+			};
+
+		},
+
+		// Generate a NurbGeometry from a node in FBXTree.Objects.Geometry
+		parseNurbsGeometry: function ( geoNode ) {
+
+			if ( THREE.NURBSCurve === undefined ) {
+
+				console.error( 'THREE.FBXLoader: The loader relies on THREE.NURBSCurve for any nurbs present in the model. Nurbs will show up as empty geometry.' );
+				return new THREE.BufferGeometry();
+
+			}
+
+			var order = parseInt( geoNode.Order );
+
+			if ( isNaN( order ) ) {
+
+				console.error( 'THREE.FBXLoader: Invalid Order %s given for geometry ID: %s', geoNode.Order, geoNode.id );
+				return new THREE.BufferGeometry();
+
+			}
+
+			var degree = order - 1;
+
+			var knots = geoNode.KnotVector.a;
+			var controlPoints = [];
+			var pointsValues = geoNode.Points.a;
+
+			for ( var i = 0, l = pointsValues.length; i < l; i += 4 ) {
+
+				controlPoints.push( new THREE.Vector4().fromArray( pointsValues, i ) );
+
+			}
+
+			var startKnot, endKnot;
+
+			if ( geoNode.Form === 'Closed' ) {
+
+				controlPoints.push( controlPoints[ 0 ] );
+
+			} else if ( geoNode.Form === 'Periodic' ) {
+
+				startKnot = degree;
+				endKnot = knots.length - 1 - startKnot;
+
+				for ( var i = 0; i < degree; ++ i ) {
+
+					controlPoints.push( controlPoints[ i ] );
+
+				}
+
+			}
+
+			var curve = new THREE.NURBSCurve( degree, knots, controlPoints, startKnot, endKnot );
+			var vertices = curve.getPoints( controlPoints.length * 7 );
+
+			var positions = new Float32Array( vertices.length * 3 );
+
+			vertices.forEach( function ( vertex, i ) {
+
+				vertex.toArray( positions, i * 3 );
+
+			} );
+
+			var geometry = new THREE.BufferGeometry();
+			geometry.setAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
+
+			return geometry;
+
+		},
+
+	};
+
+	// parse animation data from FBXTree
+	function AnimationParser() {}
+
+	AnimationParser.prototype = {
+
+		constructor: AnimationParser,
+
+		// take raw animation clips and turn them into three.js animation clips
+		parse: function () {
+
+			var animationClips = [];
+
+			var rawClips = this.parseClips();
+
+			if ( rawClips !== undefined ) {
+
+				for ( var key in rawClips ) {
+
+					var rawClip = rawClips[ key ];
+
+					var clip = this.addClip( rawClip );
+
+					animationClips.push( clip );
+
+				}
+
+			}
+
+			return animationClips;
+
+		},
+
+		parseClips: function () {
+
+			// since the actual transformation data is stored in FBXTree.Objects.AnimationCurve,
+			// if this is undefined we can safely assume there are no animations
+			if ( fbxTree.Objects.AnimationCurve === undefined ) return undefined;
+
+			var curveNodesMap = this.parseAnimationCurveNodes();
+
+			this.parseAnimationCurves( curveNodesMap );
+
+			var layersMap = this.parseAnimationLayers( curveNodesMap );
+			var rawClips = this.parseAnimStacks( layersMap );
+
+			return rawClips;
+
+		},
+
+		// parse nodes in FBXTree.Objects.AnimationCurveNode
+		// each AnimationCurveNode holds data for an animation transform for a model (e.g. left arm rotation )
+		// and is referenced by an AnimationLayer
+		parseAnimationCurveNodes: function () {
+
+			var rawCurveNodes = fbxTree.Objects.AnimationCurveNode;
+
+			var curveNodesMap = new Map();
+
+			for ( var nodeID in rawCurveNodes ) {
+
+				var rawCurveNode = rawCurveNodes[ nodeID ];
+
+				if ( rawCurveNode.attrName.match( /S|R|T|DeformPercent/ ) !== null ) {
+
+					var curveNode = {
+
+						id: rawCurveNode.id,
+						attr: rawCurveNode.attrName,
+						curves: {},
+
+					};
+
+					curveNodesMap.set( curveNode.id, curveNode );
+
+				}
+
+			}
+
+			return curveNodesMap;
+
+		},
+
+		// parse nodes in FBXTree.Objects.AnimationCurve and connect them up to
+		// previously parsed AnimationCurveNodes. Each AnimationCurve holds data for a single animated
+		// axis ( e.g. times and values of x rotation)
+		parseAnimationCurves: function ( curveNodesMap ) {
+
+			var rawCurves = fbxTree.Objects.AnimationCurve;
+
+			// TODO: Many values are identical up to roundoff error, but won't be optimised
+			// e.g. position times: [0, 0.4, 0. 8]
+			// position values: [7.23538335023477e-7, 93.67518615722656, -0.9982695579528809, 7.23538335023477e-7, 93.67518615722656, -0.9982695579528809, 7.235384487103147e-7, 93.67520904541016, -0.9982695579528809]
+			// clearly, this should be optimised to
+			// times: [0], positions [7.23538335023477e-7, 93.67518615722656, -0.9982695579528809]
+			// this shows up in nearly every FBX file, and generally time array is length > 100
+
+			for ( var nodeID in rawCurves ) {
+
+				var animationCurve = {
+
+					id: rawCurves[ nodeID ].id,
+					times: rawCurves[ nodeID ].KeyTime.a.map( convertFBXTimeToSeconds ),
+					values: rawCurves[ nodeID ].KeyValueFloat.a,
+
+				};
+
+				var relationships = connections.get( animationCurve.id );
+
+				if ( relationships !== undefined ) {
+
+					var animationCurveID = relationships.parents[ 0 ].ID;
+					var animationCurveRelationship = relationships.parents[ 0 ].relationship;
+
+					if ( animationCurveRelationship.match( /X/ ) ) {
+
+						curveNodesMap.get( animationCurveID ).curves[ 'x' ] = animationCurve;
+
+					} else if ( animationCurveRelationship.match( /Y/ ) ) {
+
+						curveNodesMap.get( animationCurveID ).curves[ 'y' ] = animationCurve;
+
+					} else if ( animationCurveRelationship.match( /Z/ ) ) {
+
+						curveNodesMap.get( animationCurveID ).curves[ 'z' ] = animationCurve;
+
+					} else if ( animationCurveRelationship.match( /d|DeformPercent/ ) && curveNodesMap.has( animationCurveID ) ) {
+
+						curveNodesMap.get( animationCurveID ).curves[ 'morph' ] = animationCurve;
+
+					}
+
+				}
+
+			}
+
+		},
+
+		// parse nodes in FBXTree.Objects.AnimationLayer. Each layers holds references
+		// to various AnimationCurveNodes and is referenced by an AnimationStack node
+		// note: theoretically a stack can have multiple layers, however in practice there always seems to be one per stack
+		parseAnimationLayers: function ( curveNodesMap ) {
+
+			var rawLayers = fbxTree.Objects.AnimationLayer;
+
+			var layersMap = new Map();
+
+			for ( var nodeID in rawLayers ) {
+
+				var layerCurveNodes = [];
+
+				var connection = connections.get( parseInt( nodeID ) );
+
+				if ( connection !== undefined ) {
+
+					// all the animationCurveNodes used in the layer
+					var children = connection.children;
+
+					children.forEach( function ( child, i ) {
+
+						if ( curveNodesMap.has( child.ID ) ) {
+
+							var curveNode = curveNodesMap.get( child.ID );
+
+							// check that the curves are defined for at least one axis, otherwise ignore the curveNode
+							if ( curveNode.curves.x !== undefined || curveNode.curves.y !== undefined || curveNode.curves.z !== undefined ) {
+
+								if ( layerCurveNodes[ i ] === undefined ) {
+
+									var modelID = connections.get( child.ID ).parents.filter( function ( parent ) {
+
+										return parent.relationship !== undefined;
+
+									} )[ 0 ].ID;
+
+									if ( modelID !== undefined ) {
+
+										var rawModel = fbxTree.Objects.Model[ modelID.toString() ];
+
+										var node = {
+
+											modelName: rawModel.attrName ? THREE.PropertyBinding.sanitizeNodeName( rawModel.attrName ) : '',
+											ID: rawModel.id,
+											initialPosition: [ 0, 0, 0 ],
+											initialRotation: [ 0, 0, 0 ],
+											initialScale: [ 1, 1, 1 ],
+
+										};
+
+										sceneGraph.traverse( function ( child ) {
+
+											if ( child.ID === rawModel.id ) {
+
+												node.transform = child.matrix;
+
+												if ( child.userData.transformData ) node.eulerOrder = child.userData.transformData.eulerOrder;
+
+											}
+
+										} );
+
+										if ( ! node.transform ) node.transform = new THREE.Matrix4();
+
+										// if the animated model is pre rotated, we'll have to apply the pre rotations to every
+										// animation value as well
+										if ( 'PreRotation' in rawModel ) node.preRotation = rawModel.PreRotation.value;
+										if ( 'PostRotation' in rawModel ) node.postRotation = rawModel.PostRotation.value;
+
+										layerCurveNodes[ i ] = node;
+
+									}
+
+								}
+
+								if ( layerCurveNodes[ i ] ) layerCurveNodes[ i ][ curveNode.attr ] = curveNode;
+
+							} else if ( curveNode.curves.morph !== undefined ) {
+
+								if ( layerCurveNodes[ i ] === undefined ) {
+
+									var deformerID = connections.get( child.ID ).parents.filter( function ( parent ) {
+
+										return parent.relationship !== undefined;
+
+									} )[ 0 ].ID;
+
+									var morpherID = connections.get( deformerID ).parents[ 0 ].ID;
+									var geoID = connections.get( morpherID ).parents[ 0 ].ID;
+
+									// assuming geometry is not used in more than one model
+									var modelID = connections.get( geoID ).parents[ 0 ].ID;
+
+									var rawModel = fbxTree.Objects.Model[ modelID ];
+
+									var node = {
+
+										modelName: rawModel.attrName ? THREE.PropertyBinding.sanitizeNodeName( rawModel.attrName ) : '',
+										morphName: fbxTree.Objects.Deformer[ deformerID ].attrName,
+
+									};
+
+									layerCurveNodes[ i ] = node;
+
+								}
+
+								layerCurveNodes[ i ][ curveNode.attr ] = curveNode;
+
+							}
+
+						}
+
+					} );
+
+					layersMap.set( parseInt( nodeID ), layerCurveNodes );
+
+				}
+
+			}
+
+			return layersMap;
+
+		},
+
+		// parse nodes in FBXTree.Objects.AnimationStack. These are the top level node in the animation
+		// hierarchy. Each Stack node will be used to create a THREE.AnimationClip
+		parseAnimStacks: function ( layersMap ) {
+
+			var rawStacks = fbxTree.Objects.AnimationStack;
+
+			// connect the stacks (clips) up to the layers
+			var rawClips = {};
+
+			for ( var nodeID in rawStacks ) {
+
+				var children = connections.get( parseInt( nodeID ) ).children;
+
+				if ( children.length > 1 ) {
+
+					// it seems like stacks will always be associated with a single layer. But just in case there are files
+					// where there are multiple layers per stack, we'll display a warning
+					console.warn( 'THREE.FBXLoader: Encountered an animation stack with multiple layers, this is currently not supported. Ignoring subsequent layers.' );
+
+				}
+
+				var layer = layersMap.get( children[ 0 ].ID );
+
+				rawClips[ nodeID ] = {
+
+					name: rawStacks[ nodeID ].attrName,
+					layer: layer,
+
+				};
+
+			}
+
+			return rawClips;
+
+		},
+
+		addClip: function ( rawClip ) {
+
+			var tracks = [];
+
+			var self = this;
+			rawClip.layer.forEach( function ( rawTracks ) {
+
+				tracks = tracks.concat( self.generateTracks( rawTracks ) );
+
+			} );
+
+			return new THREE.AnimationClip( rawClip.name, - 1, tracks );
+
+		},
+
+		generateTracks: function ( rawTracks ) {
+
+			var tracks = [];
+
+			var initialPosition = new THREE.Vector3();
+			var initialRotation = new THREE.Quaternion();
+			var initialScale = new THREE.Vector3();
+
+			if ( rawTracks.transform ) rawTracks.transform.decompose( initialPosition, initialRotation, initialScale );
+
+			initialPosition = initialPosition.toArray();
+			initialRotation = new THREE.Euler().setFromQuaternion( initialRotation, rawTracks.eulerOrder ).toArray();
+			initialScale = initialScale.toArray();
+
+			if ( rawTracks.T !== undefined && Object.keys( rawTracks.T.curves ).length > 0 ) {
+
+				var positionTrack = this.generateVectorTrack( rawTracks.modelName, rawTracks.T.curves, initialPosition, 'position' );
+				if ( positionTrack !== undefined ) tracks.push( positionTrack );
+
+			}
+
+			if ( rawTracks.R !== undefined && Object.keys( rawTracks.R.curves ).length > 0 ) {
+
+				var rotationTrack = this.generateRotationTrack( rawTracks.modelName, rawTracks.R.curves, initialRotation, rawTracks.preRotation, rawTracks.postRotation, rawTracks.eulerOrder );
+				if ( rotationTrack !== undefined ) tracks.push( rotationTrack );
+
+			}
+
+			if ( rawTracks.S !== undefined && Object.keys( rawTracks.S.curves ).length > 0 ) {
+
+				var scaleTrack = this.generateVectorTrack( rawTracks.modelName, rawTracks.S.curves, initialScale, 'scale' );
+				if ( scaleTrack !== undefined ) tracks.push( scaleTrack );
+
+			}
+
+			if ( rawTracks.DeformPercent !== undefined ) {
+
+				var morphTrack = this.generateMorphTrack( rawTracks );
+				if ( morphTrack !== undefined ) tracks.push( morphTrack );
+
+			}
+
+			return tracks;
+
+		},
+
+		generateVectorTrack: function ( modelName, curves, initialValue, type ) {
+
+			var times = this.getTimesForAllAxes( curves );
+			var values = this.getKeyframeTrackValues( times, curves, initialValue );
+
+			return new THREE.VectorKeyframeTrack( modelName + '.' + type, times, values );
+
+		},
+
+		generateRotationTrack: function ( modelName, curves, initialValue, preRotation, postRotation, eulerOrder ) {
+
+			if ( curves.x !== undefined ) {
+
+				this.interpolateRotations( curves.x );
+				curves.x.values = curves.x.values.map( THREE.Math.degToRad );
+
+			}
+			if ( curves.y !== undefined ) {
+
+				this.interpolateRotations( curves.y );
+				curves.y.values = curves.y.values.map( THREE.Math.degToRad );
+
+			}
+			if ( curves.z !== undefined ) {
+
+				this.interpolateRotations( curves.z );
+				curves.z.values = curves.z.values.map( THREE.Math.degToRad );
+
+			}
+
+			var times = this.getTimesForAllAxes( curves );
+			var values = this.getKeyframeTrackValues( times, curves, initialValue );
+
+			if ( preRotation !== undefined ) {
+
+				preRotation = preRotation.map( THREE.Math.degToRad );
+				preRotation.push( eulerOrder );
+
+				preRotation = new THREE.Euler().fromArray( preRotation );
+				preRotation = new THREE.Quaternion().setFromEuler( preRotation );
+
+			}
+
+			if ( postRotation !== undefined ) {
+
+				postRotation = postRotation.map( THREE.Math.degToRad );
+				postRotation.push( eulerOrder );
+
+				postRotation = new THREE.Euler().fromArray( postRotation );
+				postRotation = new THREE.Quaternion().setFromEuler( postRotation ).inverse();
+
+			}
+
+			var quaternion = new THREE.Quaternion();
+			var euler = new THREE.Euler();
+
+			var quaternionValues = [];
+
+			for ( var i = 0; i < values.length; i += 3 ) {
+
+				euler.set( values[ i ], values[ i + 1 ], values[ i + 2 ], eulerOrder );
+
+				quaternion.setFromEuler( euler );
+
+				if ( preRotation !== undefined ) quaternion.premultiply( preRotation );
+				if ( postRotation !== undefined ) quaternion.multiply( postRotation );
+
+				quaternion.toArray( quaternionValues, ( i / 3 ) * 4 );
+
+			}
+
+			return new THREE.QuaternionKeyframeTrack( modelName + '.quaternion', times, quaternionValues );
+
+		},
+
+		generateMorphTrack: function ( rawTracks ) {
+
+			var curves = rawTracks.DeformPercent.curves.morph;
+			var values = curves.values.map( function ( val ) {
+
+				return val / 100;
+
+			} );
+
+			var morphNum = sceneGraph.getObjectByName( rawTracks.modelName ).morphTargetDictionary[ rawTracks.morphName ];
+
+			return new THREE.NumberKeyframeTrack( rawTracks.modelName + '.morphTargetInfluences[' + morphNum + ']', curves.times, values );
+
+		},
+
+		// For all animated objects, times are defined separately for each axis
+		// Here we'll combine the times into one sorted array without duplicates
+		getTimesForAllAxes: function ( curves ) {
+
+			var times = [];
+
+			// first join together the times for each axis, if defined
+			if ( curves.x !== undefined ) times = times.concat( curves.x.times );
+			if ( curves.y !== undefined ) times = times.concat( curves.y.times );
+			if ( curves.z !== undefined ) times = times.concat( curves.z.times );
+
+			// then sort them and remove duplicates
+			times = times.sort( function ( a, b ) {
+
+				return a - b;
+
+			} ).filter( function ( elem, index, array ) {
+
+				return array.indexOf( elem ) == index;
+
+			} );
+
+			return times;
+
+		},
+
+		getKeyframeTrackValues: function ( times, curves, initialValue ) {
+
+			var prevValue = initialValue;
+
+			var values = [];
+
+			var xIndex = - 1;
+			var yIndex = - 1;
+			var zIndex = - 1;
+
+			times.forEach( function ( time ) {
+
+				if ( curves.x ) xIndex = curves.x.times.indexOf( time );
+				if ( curves.y ) yIndex = curves.y.times.indexOf( time );
+				if ( curves.z ) zIndex = curves.z.times.indexOf( time );
+
+				// if there is an x value defined for this frame, use that
+				if ( xIndex !== - 1 ) {
+
+					var xValue = curves.x.values[ xIndex ];
+					values.push( xValue );
+					prevValue[ 0 ] = xValue;
+
+				} else {
+
+					// otherwise use the x value from the previous frame
+					values.push( prevValue[ 0 ] );
+
+				}
+
+				if ( yIndex !== - 1 ) {
+
+					var yValue = curves.y.values[ yIndex ];
+					values.push( yValue );
+					prevValue[ 1 ] = yValue;
+
+				} else {
+
+					values.push( prevValue[ 1 ] );
+
+				}
+
+				if ( zIndex !== - 1 ) {
+
+					var zValue = curves.z.values[ zIndex ];
+					values.push( zValue );
+					prevValue[ 2 ] = zValue;
+
+				} else {
+
+					values.push( prevValue[ 2 ] );
+
+				}
+
+			} );
+
+			return values;
+
+		},
+
+		// Rotations are defined as Euler angles which can have values  of any size
+		// These will be converted to quaternions which don't support values greater than
+		// PI, so we'll interpolate large rotations
+		interpolateRotations: function ( curve ) {
+
+			for ( var i = 1; i < curve.values.length; i ++ ) {
+
+				var initialValue = curve.values[ i - 1 ];
+				var valuesSpan = curve.values[ i ] - initialValue;
+
+				var absoluteSpan = Math.abs( valuesSpan );
+
+				if ( absoluteSpan >= 180 ) {
+
+					var numSubIntervals = absoluteSpan / 180;
+
+					var step = valuesSpan / numSubIntervals;
+					var nextValue = initialValue + step;
+
+					var initialTime = curve.times[ i - 1 ];
+					var timeSpan = curve.times[ i ] - initialTime;
+					var interval = timeSpan / numSubIntervals;
+					var nextTime = initialTime + interval;
+
+					var interpolatedTimes = [];
+					var interpolatedValues = [];
+
+					while ( nextTime < curve.times[ i ] ) {
+
+						interpolatedTimes.push( nextTime );
+						nextTime += interval;
+
+						interpolatedValues.push( nextValue );
+						nextValue += step;
+
+					}
+
+					curve.times = inject( curve.times, i, interpolatedTimes );
+					curve.values = inject( curve.values, i, interpolatedValues );
+
+				}
+
+			}
+
+		},
+
+	};
+
+	// parse an FBX file in ASCII format
+	function TextParser() {}
+
+	TextParser.prototype = {
+
+		constructor: TextParser,
+
+		getPrevNode: function () {
+
+			return this.nodeStack[ this.currentIndent - 2 ];
+
+		},
+
+		getCurrentNode: function () {
+
+			return this.nodeStack[ this.currentIndent - 1 ];
+
+		},
+
+		getCurrentProp: function () {
+
+			return this.currentProp;
+
+		},
+
+		pushStack: function ( node ) {
+
+			this.nodeStack.push( node );
+			this.currentIndent += 1;
+
+		},
+
+		popStack: function () {
+
+			this.nodeStack.pop();
+			this.currentIndent -= 1;
+
+		},
+
+		setCurrentProp: function ( val, name ) {
+
+			this.currentProp = val;
+			this.currentPropName = name;
+
+		},
+
+		parse: function ( text ) {
+
+			this.currentIndent = 0;
+
+			this.allNodes = new FBXTree();
+			this.nodeStack = [];
+			this.currentProp = [];
+			this.currentPropName = '';
+
+			var self = this;
+
+			var split = text.split( /[\r\n]+/ );
+
+			split.forEach( function ( line, i ) {
+
+				var matchComment = line.match( /^[\s\t]*;/ );
+				var matchEmpty = line.match( /^[\s\t]*$/ );
+
+				if ( matchComment || matchEmpty ) return;
+
+				var matchBeginning = line.match( '^\\t{' + self.currentIndent + '}(\\w+):(.*){', '' );
+				var matchProperty = line.match( '^\\t{' + ( self.currentIndent ) + '}(\\w+):[\\s\\t\\r\\n](.*)' );
+				var matchEnd = line.match( '^\\t{' + ( self.currentIndent - 1 ) + '}}' );
+
+				if ( matchBeginning ) {
+
+					self.parseNodeBegin( line, matchBeginning );
+
+				} else if ( matchProperty ) {
+
+					self.parseNodeProperty( line, matchProperty, split[ ++ i ] );
+
+				} else if ( matchEnd ) {
+
+					self.popStack();
+
+				} else if ( line.match( /^[^\s\t}]/ ) ) {
+
+					// large arrays are split over multiple lines terminated with a ',' character
+					// if this is encountered the line needs to be joined to the previous line
+					self.parseNodePropertyContinued( line );
+
+				}
+
+			} );
+
+			return this.allNodes;
+
+		},
+
+		parseNodeBegin: function ( line, property ) {
+
+			var nodeName = property[ 1 ].trim().replace( /^"/, '' ).replace( /"$/, '' );
+
+			var nodeAttrs = property[ 2 ].split( ',' ).map( function ( attr ) {
+
+				return attr.trim().replace( /^"/, '' ).replace( /"$/, '' );
+
+			} );
+
+			var node = { name: nodeName };
+			var attrs = this.parseNodeAttr( nodeAttrs );
+
+			var currentNode = this.getCurrentNode();
+
+			// a top node
+			if ( this.currentIndent === 0 ) {
+
+				this.allNodes.add( nodeName, node );
+
+			} else { // a subnode
+
+				// if the subnode already exists, append it
+				if ( nodeName in currentNode ) {
+
+					// special case Pose needs PoseNodes as an array
+					if ( nodeName === 'PoseNode' ) {
+
+						currentNode.PoseNode.push( node );
+
+					} else if ( currentNode[ nodeName ].id !== undefined ) {
+
+						currentNode[ nodeName ] = {};
+						currentNode[ nodeName ][ currentNode[ nodeName ].id ] = currentNode[ nodeName ];
+
+					}
+
+					if ( attrs.id !== '' ) currentNode[ nodeName ][ attrs.id ] = node;
+
+				} else if ( typeof attrs.id === 'number' ) {
+
+					currentNode[ nodeName ] = {};
+					currentNode[ nodeName ][ attrs.id ] = node;
+
+				} else if ( nodeName !== 'Properties70' ) {
+
+					if ( nodeName === 'PoseNode' )	currentNode[ nodeName ] = [ node ];
+					else currentNode[ nodeName ] = node;
+
+				}
+
+			}
+
+			if ( typeof attrs.id === 'number' ) node.id = attrs.id;
+			if ( attrs.name !== '' ) node.attrName = attrs.name;
+			if ( attrs.type !== '' ) node.attrType = attrs.type;
+
+			this.pushStack( node );
+
+		},
+
+		parseNodeAttr: function ( attrs ) {
+
+			var id = attrs[ 0 ];
+
+			if ( attrs[ 0 ] !== '' ) {
+
+				id = parseInt( attrs[ 0 ] );
+
+				if ( isNaN( id ) ) {
+
+					id = attrs[ 0 ];
+
+				}
+
+			}
+
+			var name = '', type = '';
+
+			if ( attrs.length > 1 ) {
+
+				name = attrs[ 1 ].replace( /^(\w+)::/, '' );
+				type = attrs[ 2 ];
+
+			}
+
+			return { id: id, name: name, type: type };
+
+		},
+
+		parseNodeProperty: function ( line, property, contentLine ) {
+
+			var propName = property[ 1 ].replace( /^"/, '' ).replace( /"$/, '' ).trim();
+			var propValue = property[ 2 ].replace( /^"/, '' ).replace( /"$/, '' ).trim();
+
+			// for special case: base64 image data follows "Content: ," line
+			//	Content: ,
+			//	 "/9j/4RDaRXhpZgAATU0A..."
+			if ( propName === 'Content' && propValue === ',' ) {
+
+				propValue = contentLine.replace( /"/g, '' ).replace( /,$/, '' ).trim();
+
+			}
+
+			var currentNode = this.getCurrentNode();
+			var parentName = currentNode.name;
+
+			if ( parentName === 'Properties70' ) {
+
+				this.parseNodeSpecialProperty( line, propName, propValue );
+				return;
+
+			}
+
+			// Connections
+			if ( propName === 'C' ) {
+
+				var connProps = propValue.split( ',' ).slice( 1 );
+				var from = parseInt( connProps[ 0 ] );
+				var to = parseInt( connProps[ 1 ] );
+
+				var rest = propValue.split( ',' ).slice( 3 );
+
+				rest = rest.map( function ( elem ) {
+
+					return elem.trim().replace( /^"/, '' );
+
+				} );
+
+				propName = 'connections';
+				propValue = [ from, to ];
+				append( propValue, rest );
+
+				if ( currentNode[ propName ] === undefined ) {
+
+					currentNode[ propName ] = [];
+
+				}
+
+			}
+
+			// Node
+			if ( propName === 'Node' ) currentNode.id = propValue;
+
+			// connections
+			if ( propName in currentNode && Array.isArray( currentNode[ propName ] ) ) {
+
+				currentNode[ propName ].push( propValue );
+
+			} else {
+
+				if ( propName !== 'a' ) currentNode[ propName ] = propValue;
+				else currentNode.a = propValue;
+
+			}
+
+			this.setCurrentProp( currentNode, propName );
+
+			// convert string to array, unless it ends in ',' in which case more will be added to it
+			if ( propName === 'a' && propValue.slice( - 1 ) !== ',' ) {
+
+				currentNode.a = parseNumberArray( propValue );
+
+			}
+
+		},
+
+		parseNodePropertyContinued: function ( line ) {
+
+			var currentNode = this.getCurrentNode();
+
+			currentNode.a += line;
+
+			// if the line doesn't end in ',' we have reached the end of the property value
+			// so convert the string to an array
+			if ( line.slice( - 1 ) !== ',' ) {
+
+				currentNode.a = parseNumberArray( currentNode.a );
+
+			}
+
+		},
+
+		// parse "Property70"
+		parseNodeSpecialProperty: function ( line, propName, propValue ) {
+
+			// split this
+			// P: "Lcl Scaling", "Lcl Scaling", "", "A",1,1,1
+			// into array like below
+			// ["Lcl Scaling", "Lcl Scaling", "", "A", "1,1,1" ]
+			var props = propValue.split( '",' ).map( function ( prop ) {
+
+				return prop.trim().replace( /^\"/, '' ).replace( /\s/, '_' );
+
+			} );
+
+			var innerPropName = props[ 0 ];
+			var innerPropType1 = props[ 1 ];
+			var innerPropType2 = props[ 2 ];
+			var innerPropFlag = props[ 3 ];
+			var innerPropValue = props[ 4 ];
+
+			// cast values where needed, otherwise leave as strings
+			switch ( innerPropType1 ) {
+
+				case 'int':
+				case 'enum':
+				case 'bool':
+				case 'ULongLong':
+				case 'double':
+				case 'Number':
+				case 'FieldOfView':
+					innerPropValue = parseFloat( innerPropValue );
+					break;
+
+				case 'Color':
+				case 'ColorRGB':
+				case 'Vector3D':
+				case 'Lcl_Translation':
+				case 'Lcl_Rotation':
+				case 'Lcl_Scaling':
+					innerPropValue = parseNumberArray( innerPropValue );
+					break;
+
+			}
+
+			// CAUTION: these props must append to parent's parent
+			this.getPrevNode()[ innerPropName ] = {
+
+				'type': innerPropType1,
+				'type2': innerPropType2,
+				'flag': innerPropFlag,
+				'value': innerPropValue
+
+			};
+
+			this.setCurrentProp( this.getPrevNode(), innerPropName );
+
+		},
+
+	};
+
+	// Parse an FBX file in Binary format
+	function BinaryParser() {}
+
+	BinaryParser.prototype = {
+
+		constructor: BinaryParser,
+
+		parse: function ( buffer ) {
+
+			var reader = new BinaryReader( buffer );
+			reader.skip( 23 ); // skip magic 23 bytes
+
+			var version = reader.getUint32();
+
+			console.log( 'THREE.FBXLoader: FBX binary version: ' + version );
+
+			var allNodes = new FBXTree();
+
+			while ( ! this.endOfContent( reader ) ) {
+
+				var node = this.parseNode( reader, version );
+				if ( node !== null ) allNodes.add( node.name, node );
+
+			}
+
+			return allNodes;
+
+		},
+
+		// Check if reader has reached the end of content.
+		endOfContent: function ( reader ) {
+
+			// footer size: 160bytes + 16-byte alignment padding
+			// - 16bytes: magic
+			// - padding til 16-byte alignment (at least 1byte?)
+			//	(seems like some exporters embed fixed 15 or 16bytes?)
+			// - 4bytes: magic
+			// - 4bytes: version
+			// - 120bytes: zero
+			// - 16bytes: magic
+			if ( reader.size() % 16 === 0 ) {
+
+				return ( ( reader.getOffset() + 160 + 16 ) & ~ 0xf ) >= reader.size();
+
+			} else {
+
+				return reader.getOffset() + 160 + 16 >= reader.size();
+
+			}
+
+		},
+
+		// recursively parse nodes until the end of the file is reached
+		parseNode: function ( reader, version ) {
+
+			var node = {};
+
+			// The first three data sizes depends on version.
+			var endOffset = ( version >= 7500 ) ? reader.getUint64() : reader.getUint32();
+			var numProperties = ( version >= 7500 ) ? reader.getUint64() : reader.getUint32();
+
+			// note: do not remove this even if you get a linter warning as it moves the buffer forward
+			var propertyListLen = ( version >= 7500 ) ? reader.getUint64() : reader.getUint32();
+
+			var nameLen = reader.getUint8();
+			var name = reader.getString( nameLen );
+
+			// Regards this node as NULL-record if endOffset is zero
+			if ( endOffset === 0 ) return null;
+
+			var propertyList = [];
+
+			for ( var i = 0; i < numProperties; i ++ ) {
+
+				propertyList.push( this.parseProperty( reader ) );
+
+			}
+
+			// Regards the first three elements in propertyList as id, attrName, and attrType
+			var id = propertyList.length > 0 ? propertyList[ 0 ] : '';
+			var attrName = propertyList.length > 1 ? propertyList[ 1 ] : '';
+			var attrType = propertyList.length > 2 ? propertyList[ 2 ] : '';
+
+			// check if this node represents just a single property
+			// like (name, 0) set or (name2, [0, 1, 2]) set of {name: 0, name2: [0, 1, 2]}
+			node.singleProperty = ( numProperties === 1 && reader.getOffset() === endOffset ) ? true : false;
+
+			while ( endOffset > reader.getOffset() ) {
+
+				var subNode = this.parseNode( reader, version );
+
+				if ( subNode !== null ) this.parseSubNode( name, node, subNode );
+
+			}
+
+			node.propertyList = propertyList; // raw property list used by parent
+
+			if ( typeof id === 'number' ) node.id = id;
+			if ( attrName !== '' ) node.attrName = attrName;
+			if ( attrType !== '' ) node.attrType = attrType;
+			if ( name !== '' ) node.name = name;
+
+			return node;
+
+		},
+
+		parseSubNode: function ( name, node, subNode ) {
+
+			// special case: child node is single property
+			if ( subNode.singleProperty === true ) {
+
+				var value = subNode.propertyList[ 0 ];
+
+				if ( Array.isArray( value ) ) {
+
+					node[ subNode.name ] = subNode;
+
+					subNode.a = value;
+
+				} else {
+
+					node[ subNode.name ] = value;
+
+				}
+
+			} else if ( name === 'Connections' && subNode.name === 'C' ) {
+
+				var array = [];
+
+				subNode.propertyList.forEach( function ( property, i ) {
+
+					// first Connection is FBX type (OO, OP, etc.). We'll discard these
+					if ( i !== 0 ) array.push( property );
+
+				} );
+
+				if ( node.connections === undefined ) {
+
+					node.connections = [];
+
+				}
+
+				node.connections.push( array );
+
+			} else if ( subNode.name === 'Properties70' ) {
+
+				var keys = Object.keys( subNode );
+
+				keys.forEach( function ( key ) {
+
+					node[ key ] = subNode[ key ];
+
+				} );
+
+			} else if ( name === 'Properties70' && subNode.name === 'P' ) {
+
+				var innerPropName = subNode.propertyList[ 0 ];
+				var innerPropType1 = subNode.propertyList[ 1 ];
+				var innerPropType2 = subNode.propertyList[ 2 ];
+				var innerPropFlag = subNode.propertyList[ 3 ];
+				var innerPropValue;
+
+				if ( innerPropName.indexOf( 'Lcl ' ) === 0 ) innerPropName = innerPropName.replace( 'Lcl ', 'Lcl_' );
+				if ( innerPropType1.indexOf( 'Lcl ' ) === 0 ) innerPropType1 = innerPropType1.replace( 'Lcl ', 'Lcl_' );
+
+				if ( innerPropType1 === 'Color' || innerPropType1 === 'ColorRGB' || innerPropType1 === 'Vector' || innerPropType1 === 'Vector3D' || innerPropType1.indexOf( 'Lcl_' ) === 0 ) {
+
+					innerPropValue = [
+						subNode.propertyList[ 4 ],
+						subNode.propertyList[ 5 ],
+						subNode.propertyList[ 6 ]
+					];
+
+				} else {
+
+					innerPropValue = subNode.propertyList[ 4 ];
+
+				}
+
+				// this will be copied to parent, see above
+				node[ innerPropName ] = {
+
+					'type': innerPropType1,
+					'type2': innerPropType2,
+					'flag': innerPropFlag,
+					'value': innerPropValue
+
+				};
+
+			} else if ( node[ subNode.name ] === undefined ) {
+
+				if ( typeof subNode.id === 'number' ) {
+
+					node[ subNode.name ] = {};
+					node[ subNode.name ][ subNode.id ] = subNode;
+
+				} else {
+
+					node[ subNode.name ] = subNode;
+
+				}
+
+			} else {
+
+				if ( subNode.name === 'PoseNode' ) {
+
+					if ( ! Array.isArray( node[ subNode.name ] ) ) {
+
+						node[ subNode.name ] = [ node[ subNode.name ] ];
+
+					}
+
+					node[ subNode.name ].push( subNode );
+
+				} else if ( node[ subNode.name ][ subNode.id ] === undefined ) {
+
+					node[ subNode.name ][ subNode.id ] = subNode;
+
+				}
+
+			}
+
+		},
+
+		parseProperty: function ( reader ) {
+
+			var type = reader.getString( 1 );
+
+			switch ( type ) {
+
+				case 'C':
+					return reader.getBoolean();
+
+				case 'D':
+					return reader.getFloat64();
+
+				case 'F':
+					return reader.getFloat32();
+
+				case 'I':
+					return reader.getInt32();
+
+				case 'L':
+					return reader.getInt64();
+
+				case 'R':
+					var length = reader.getUint32();
+					return reader.getArrayBuffer( length );
+
+				case 'S':
+					var length = reader.getUint32();
+					return reader.getString( length );
+
+				case 'Y':
+					return reader.getInt16();
+
+				case 'b':
+				case 'c':
+				case 'd':
+				case 'f':
+				case 'i':
+				case 'l':
+
+					var arrayLength = reader.getUint32();
+					var encoding = reader.getUint32(); // 0: non-compressed, 1: compressed
+					var compressedLength = reader.getUint32();
+
+					if ( encoding === 0 ) {
+
+						switch ( type ) {
+
+							case 'b':
+							case 'c':
+								return reader.getBooleanArray( arrayLength );
+
+							case 'd':
+								return reader.getFloat64Array( arrayLength );
+
+							case 'f':
+								return reader.getFloat32Array( arrayLength );
+
+							case 'i':
+								return reader.getInt32Array( arrayLength );
+
+							case 'l':
+								return reader.getInt64Array( arrayLength );
+
+						}
+
+					}
+
+					if ( typeof Zlib === 'undefined' ) {
+
+						console.error( 'THREE.FBXLoader: External library Inflate.min.js required, obtain or import from https://github.com/imaya/zlib.js' );
+
+					}
+
+					var inflate = new Zlib.Inflate( new Uint8Array( reader.getArrayBuffer( compressedLength ) ) ); // eslint-disable-line no-undef
+					var reader2 = new BinaryReader( inflate.decompress().buffer );
+
+					switch ( type ) {
+
+						case 'b':
+						case 'c':
+							return reader2.getBooleanArray( arrayLength );
+
+						case 'd':
+							return reader2.getFloat64Array( arrayLength );
+
+						case 'f':
+							return reader2.getFloat32Array( arrayLength );
+
+						case 'i':
+							return reader2.getInt32Array( arrayLength );
+
+						case 'l':
+							return reader2.getInt64Array( arrayLength );
+
+					}
+
+				default:
+					throw new Error( 'THREE.FBXLoader: Unknown property type ' + type );
+
+			}
+
+		}
+
+	};
+
+	function BinaryReader( buffer, littleEndian ) {
+
+		this.dv = new DataView( buffer );
+		this.offset = 0;
+		this.littleEndian = ( littleEndian !== undefined ) ? littleEndian : true;
+
+	}
+
+	BinaryReader.prototype = {
+
+		constructor: BinaryReader,
+
+		getOffset: function () {
+
+			return this.offset;
+
+		},
+
+		size: function () {
+
+			return this.dv.buffer.byteLength;
+
+		},
+
+		skip: function ( length ) {
+
+			this.offset += length;
+
+		},
+
+		// seems like true/false representation depends on exporter.
+		// true: 1 or 'Y'(=0x59), false: 0 or 'T'(=0x54)
+		// then sees LSB.
+		getBoolean: function () {
+
+			return ( this.getUint8() & 1 ) === 1;
+
+		},
+
+		getBooleanArray: function ( size ) {
+
+			var a = [];
+
+			for ( var i = 0; i < size; i ++ ) {
+
+				a.push( this.getBoolean() );
+
+			}
+
+			return a;
+
+		},
+
+		getUint8: function () {
+
+			var value = this.dv.getUint8( this.offset );
+			this.offset += 1;
+			return value;
+
+		},
+
+		getInt16: function () {
+
+			var value = this.dv.getInt16( this.offset, this.littleEndian );
+			this.offset += 2;
+			return value;
+
+		},
+
+		getInt32: function () {
+
+			var value = this.dv.getInt32( this.offset, this.littleEndian );
+			this.offset += 4;
+			return value;
+
+		},
+
+		getInt32Array: function ( size ) {
+
+			var a = [];
+
+			for ( var i = 0; i < size; i ++ ) {
+
+				a.push( this.getInt32() );
+
+			}
+
+			return a;
+
+		},
+
+		getUint32: function () {
+
+			var value = this.dv.getUint32( this.offset, this.littleEndian );
+			this.offset += 4;
+			return value;
+
+		},
+
+		// JavaScript doesn't support 64-bit integer so calculate this here
+		// 1 << 32 will return 1 so using multiply operation instead here.
+		// There's a possibility that this method returns wrong value if the value
+		// is out of the range between Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER.
+		// TODO: safely handle 64-bit integer
+		getInt64: function () {
+
+			var low, high;
+
+			if ( this.littleEndian ) {
+
+				low = this.getUint32();
+				high = this.getUint32();
+
+			} else {
+
+				high = this.getUint32();
+				low = this.getUint32();
+
+			}
+
+			// calculate negative value
+			if ( high & 0x80000000 ) {
+
+				high = ~ high & 0xFFFFFFFF;
+				low = ~ low & 0xFFFFFFFF;
+
+				if ( low === 0xFFFFFFFF ) high = ( high + 1 ) & 0xFFFFFFFF;
+
+				low = ( low + 1 ) & 0xFFFFFFFF;
+
+				return - ( high * 0x100000000 + low );
+
+			}
+
+			return high * 0x100000000 + low;
+
+		},
+
+		getInt64Array: function ( size ) {
+
+			var a = [];
+
+			for ( var i = 0; i < size; i ++ ) {
+
+				a.push( this.getInt64() );
+
+			}
+
+			return a;
+
+		},
+
+		// Note: see getInt64() comment
+		getUint64: function () {
+
+			var low, high;
+
+			if ( this.littleEndian ) {
+
+				low = this.getUint32();
+				high = this.getUint32();
+
+			} else {
+
+				high = this.getUint32();
+				low = this.getUint32();
+
+			}
+
+			return high * 0x100000000 + low;
+
+		},
+
+		getFloat32: function () {
+
+			var value = this.dv.getFloat32( this.offset, this.littleEndian );
+			this.offset += 4;
+			return value;
+
+		},
+
+		getFloat32Array: function ( size ) {
+
+			var a = [];
+
+			for ( var i = 0; i < size; i ++ ) {
+
+				a.push( this.getFloat32() );
+
+			}
+
+			return a;
+
+		},
+
+		getFloat64: function () {
+
+			var value = this.dv.getFloat64( this.offset, this.littleEndian );
+			this.offset += 8;
+			return value;
+
+		},
+
+		getFloat64Array: function ( size ) {
+
+			var a = [];
+
+			for ( var i = 0; i < size; i ++ ) {
+
+				a.push( this.getFloat64() );
+
+			}
+
+			return a;
+
+		},
+
+		getArrayBuffer: function ( size ) {
+
+			var value = this.dv.buffer.slice( this.offset, this.offset + size );
+			this.offset += size;
+			return value;
+
+		},
+
+		getString: function ( size ) {
+
+			// note: safari 9 doesn't support Uint8Array.indexOf; create intermediate array instead
+			var a = [];
+
+			for ( var i = 0; i < size; i ++ ) {
+
+				a[ i ] = this.getUint8();
+
+			}
+
+			var nullByte = a.indexOf( 0 );
+			if ( nullByte >= 0 ) a = a.slice( 0, nullByte );
+
+			return THREE.LoaderUtils.decodeText( new Uint8Array( a ) );
+
+		}
+
+	};
+
+	// FBXTree holds a representation of the FBX data, returned by the TextParser ( FBX ASCII format)
+	// and BinaryParser( FBX Binary format)
+	function FBXTree() {}
+
+	FBXTree.prototype = {
+
+		constructor: FBXTree,
+
+		add: function ( key, val ) {
+
+			this[ key ] = val;
+
+		},
+
+	};
+
+	// ************** UTILITY FUNCTIONS **************
+
+	function isFbxFormatBinary( buffer ) {
+
+		var CORRECT = 'Kaydara FBX Binary  \0';
+
+		return buffer.byteLength >= CORRECT.length && CORRECT === convertArrayBufferToString( buffer, 0, CORRECT.length );
+
+	}
+
+	function isFbxFormatASCII( text ) {
+
+		var CORRECT = [ 'K', 'a', 'y', 'd', 'a', 'r', 'a', '\\', 'F', 'B', 'X', '\\', 'B', 'i', 'n', 'a', 'r', 'y', '\\', '\\' ];
+
+		var cursor = 0;
+
+		function read( offset ) {
+
+			var result = text[ offset - 1 ];
+			text = text.slice( cursor + offset );
+			cursor ++;
+			return result;
+
+		}
+
+		for ( var i = 0; i < CORRECT.length; ++ i ) {
+
+			var num = read( 1 );
+			if ( num === CORRECT[ i ] ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+	function getFbxVersion( text ) {
+
+		var versionRegExp = /FBXVersion: (\d+)/;
+		var match = text.match( versionRegExp );
+		if ( match ) {
+
+			var version = parseInt( match[ 1 ] );
+			return version;
+
+		}
+		throw new Error( 'THREE.FBXLoader: Cannot find the version number for the file given.' );
+
+	}
+
+	// Converts FBX ticks into real time seconds.
+	function convertFBXTimeToSeconds( time ) {
+
+		return time / 46186158000;
+
+	}
+
+	var dataArray = [];
+
+	// extracts the data from the correct position in the FBX array based on indexing type
+	function getData( polygonVertexIndex, polygonIndex, vertexIndex, infoObject ) {
+
+		var index;
+
+		switch ( infoObject.mappingType ) {
+
+			case 'ByPolygonVertex' :
+				index = polygonVertexIndex;
+				break;
+			case 'ByPolygon' :
+				index = polygonIndex;
+				break;
+			case 'ByVertice' :
+				index = vertexIndex;
+				break;
+			case 'AllSame' :
+				index = infoObject.indices[ 0 ];
+				break;
+			default :
+				console.warn( 'THREE.FBXLoader: unknown attribute mapping type ' + infoObject.mappingType );
+
+		}
+
+		if ( infoObject.referenceType === 'IndexToDirect' ) index = infoObject.indices[ index ];
+
+		var from = index * infoObject.dataSize;
+		var to = from + infoObject.dataSize;
+
+		return slice( dataArray, infoObject.buffer, from, to );
+
+	}
+
+	var tempEuler = new THREE.Euler();
+	var tempVec = new THREE.Vector3();
+
+	// generate transformation from FBX transform data
+	// ref: https://help.autodesk.com/view/FBX/2017/ENU/?guid=__files_GUID_10CDD63C_79C1_4F2D_BB28_AD2BE65A02ED_htm
+	// ref: http://docs.autodesk.com/FBX/2014/ENU/FBX-SDK-Documentation/index.html?url=cpp_ref/_transformations_2main_8cxx-example.html,topicNumber=cpp_ref__transformations_2main_8cxx_example_htmlfc10a1e1-b18d-4e72-9dc0-70d0f1959f5e
+	function generateTransform( transformData ) {
+
+		var lTranslationM = new THREE.Matrix4();
+		var lPreRotationM = new THREE.Matrix4();
+		var lRotationM = new THREE.Matrix4();
+		var lPostRotationM = new THREE.Matrix4();
+
+		var lScalingM = new THREE.Matrix4();
+		var lScalingPivotM = new THREE.Matrix4();
+		var lScalingOffsetM = new THREE.Matrix4();
+		var lRotationOffsetM = new THREE.Matrix4();
+		var lRotationPivotM = new THREE.Matrix4();
+
+		var lParentGX = new THREE.Matrix4();
+		var lGlobalT = new THREE.Matrix4();
+
+		var inheritType = ( transformData.inheritType ) ? transformData.inheritType : 0;
+
+		if ( transformData.translation ) lTranslationM.setPosition( tempVec.fromArray( transformData.translation ) );
+
+		if ( transformData.preRotation ) {
+
+			var array = transformData.preRotation.map( THREE.Math.degToRad );
+			array.push( transformData.eulerOrder );
+			lPreRotationM.makeRotationFromEuler( tempEuler.fromArray( array ) );
+
+		}
+
+		if ( transformData.rotation ) {
+
+			var array = transformData.rotation.map( THREE.Math.degToRad );
+			array.push( transformData.eulerOrder );
+			lRotationM.makeRotationFromEuler( tempEuler.fromArray( array ) );
+
+		}
+
+		if ( transformData.postRotation ) {
+
+			var array = transformData.postRotation.map( THREE.Math.degToRad );
+			array.push( transformData.eulerOrder );
+			lPostRotationM.makeRotationFromEuler( tempEuler.fromArray( array ) );
+
+		}
+
+		if ( transformData.scale ) lScalingM.scale( tempVec.fromArray( transformData.scale ) );
+
+		// Pivots and offsets
+		if ( transformData.scalingOffset ) lScalingOffsetM.setPosition( tempVec.fromArray( transformData.scalingOffset ) );
+		if ( transformData.scalingPivot ) lScalingPivotM.setPosition( tempVec.fromArray( transformData.scalingPivot ) );
+		if ( transformData.rotationOffset ) lRotationOffsetM.setPosition( tempVec.fromArray( transformData.rotationOffset ) );
+		if ( transformData.rotationPivot ) lRotationPivotM.setPosition( tempVec.fromArray( transformData.rotationPivot ) );
+
+		// parent transform
+		if ( transformData.parentMatrixWorld ) lParentGX = transformData.parentMatrixWorld;
+
+		// Global Rotation
+		var lLRM = lPreRotationM.multiply( lRotationM ).multiply( lPostRotationM );
+		var lParentGRM = new THREE.Matrix4();
+		lParentGX.extractRotation( lParentGRM );
+
+		// Global Shear*Scaling
+		var lParentTM = new THREE.Matrix4();
+		var lLSM;
+		var lParentGSM;
+		var lParentGRSM;
+
+		lParentTM.copyPosition( lParentGX );
+		lParentGRSM = lParentTM.getInverse( lParentTM ).multiply( lParentGX );
+		lParentGSM = lParentGRM.getInverse( lParentGRM ).multiply( lParentGRSM );
+		lLSM = lScalingM;
+
+		var lGlobalRS;
+		if ( inheritType === 0 ) {
+
+			lGlobalRS = lParentGRM.multiply( lLRM ).multiply( lParentGSM ).multiply( lLSM );
+
+		} else if ( inheritType === 1 ) {
+
+			lGlobalRS = lParentGRM.multiply( lParentGSM ).multiply( lLRM ).multiply( lLSM );
+
+		} else {
+
+			var lParentLSM = new THREE.Matrix4().copy( lScalingM );
+
+			var lParentGSM_noLocal = lParentGSM.multiply( lParentLSM.getInverse( lParentLSM ) );
+
+			lGlobalRS = lParentGRM.multiply( lLRM ).multiply( lParentGSM_noLocal ).multiply( lLSM );
+
+		}
+
+		// Calculate the local transform matrix
+		var lTransform = lTranslationM.multiply( lRotationOffsetM ).multiply( lRotationPivotM ).multiply( lPreRotationM ).multiply( lRotationM ).multiply( lPostRotationM ).multiply( lRotationPivotM.getInverse( lRotationPivotM ) ).multiply( lScalingOffsetM ).multiply( lScalingPivotM ).multiply( lScalingM ).multiply( lScalingPivotM.getInverse( lScalingPivotM ) );
+
+		var lLocalTWithAllPivotAndOffsetInfo = new THREE.Matrix4().copyPosition( lTransform );
+
+		var lGlobalTranslation = lParentGX.multiply( lLocalTWithAllPivotAndOffsetInfo );
+		lGlobalT.copyPosition( lGlobalTranslation );
+
+		lTransform = lGlobalT.multiply( lGlobalRS );
+
+		return lTransform;
+
+	}
+
+	// Returns the three.js intrinsic Euler order corresponding to FBX extrinsic Euler order
+	// ref: http://help.autodesk.com/view/FBX/2017/ENU/?guid=__cpp_ref_class_fbx_euler_html
+	function getEulerOrder( order ) {
+
+		order = order || 0;
+
+		var enums = [
+			'ZYX', // -> XYZ extrinsic
+			'YZX', // -> XZY extrinsic
+			'XZY', // -> YZX extrinsic
+			'ZXY', // -> YXZ extrinsic
+			'YXZ', // -> ZXY extrinsic
+			'XYZ', // -> ZYX extrinsic
+			//'SphericXYZ', // not possible to support
+		];
+
+		if ( order === 6 ) {
+
+			console.warn( 'THREE.FBXLoader: unsupported Euler Order: Spherical XYZ. Animations and rotations may be incorrect.' );
+			return enums[ 0 ];
+
+		}
+
+		return enums[ order ];
+
+	}
+
+	// Parses comma separated list of numbers and returns them an array.
+	// Used internally by the TextParser
+	function parseNumberArray( value ) {
+
+		var array = value.split( ',' ).map( function ( val ) {
+
+			return parseFloat( val );
+
+		} );
+
+		return array;
+
+	}
+
+	function convertArrayBufferToString( buffer, from, to ) {
+
+		if ( from === undefined ) from = 0;
+		if ( to === undefined ) to = buffer.byteLength;
+
+		return THREE.LoaderUtils.decodeText( new Uint8Array( buffer, from, to ) );
+
+	}
+
+	function append( a, b ) {
+
+		for ( var i = 0, j = a.length, l = b.length; i < l; i ++, j ++ ) {
+
+			a[ j ] = b[ i ];
+
+		}
+
+	}
+
+	function slice( a, b, from, to ) {
+
+		for ( var i = from, j = 0; i < to; i ++, j ++ ) {
+
+			a[ j ] = b[ i ];
+
+		}
+
+		return a;
+
+	}
+
+	// inject array a2 into array a1 at index
+	function inject( a1, index, a2 ) {
+
+		return a1.slice( 0, index ).concat( a2 ).concat( a1.slice( index ) );
+
+	}
+
+	return FBXLoader;
+
+} )();
diff --git a/HelioWebXRPolyfill.js b/HelioWebXRPolyfill.js
new file mode 100644
index 0000000..ffa81eb
--- /dev/null
+++ b/HelioWebXRPolyfill.js
@@ -0,0 +1,192 @@
+/**
+ * @author mvilledieu / http://github.com/mvilledieu
+ */
+
+if ( /(Helio)/g.test( navigator.userAgent ) && "xr" in navigator ) {
+
+	console.log( "Helio WebXR Polyfill (Lumin 0.97.0)" );
+
+	const isHelio96 = navigator.userAgent.includes("Chrome/73");
+
+	// WebXRManager - XR.supportSession() Polyfill - WebVR.js line 147
+
+	if (
+		"supportsSession" in navigator.xr === false &&
+    "supportsSessionMode" in navigator.xr
+	) {
+
+		navigator.xr.supportsSession = function ( sessionType ) {
+
+			// Force using immersive-ar
+			return navigator.xr.supportsSessionMode( 'immersive-ar' );
+
+		};
+
+	}
+
+	if ( "requestSession" in navigator.xr ) {
+
+		const tempRequestSession = navigator.xr.requestSession.bind( navigator.xr );
+
+		navigator.xr.requestSession = function ( sessionType ) {
+
+			return new Promise( function ( resolve, reject ) {
+
+				const sessionType = (isHelio96 ? {
+					mode: 'immersive-ar' // Force using immersive-ar
+				} : 'immersive-ar');
+
+				tempRequestSession( sessionType )
+					.then( function ( session ) {
+
+						// WebXRManager - xrFrame.getPose() Polyfill - line 279
+
+						const tempRequestAnimationFrame = session.requestAnimationFrame.bind(
+							session
+						);
+
+						session.requestAnimationFrame = function ( callback ) {
+
+							return tempRequestAnimationFrame( function ( time, frame ) {
+
+								// WebXRManager - xrFrame.getViewerPose() Polyfill - line 279
+								// Transforms view.viewMatrix to view.transform.inverse.matrix
+
+								const tempGetViewerPose = frame.getViewerPose.bind( frame );
+
+								frame.getViewerPose = function ( referenceSpace ) {
+
+									const pose = tempGetViewerPose( referenceSpace );
+
+									pose.views.forEach( function ( view ) {
+
+										view.transform = {
+											inverse: {
+												matrix: view.viewMatrix
+											}
+										};
+
+									} );
+
+									return pose;
+
+								};
+
+								// WebXRManager - xrFrame.getPose() Polyfill - line 259
+
+								const tempGetPose = (isHelio96 ? null : frame.getPose.bind( frame ));
+
+								frame.getPose = function ( targetRaySpace, referenceSpace ) {
+
+									if (isHelio96) {
+
+										const inputPose = frame.getInputPose(
+											targetRaySpace,
+											referenceSpace
+										);
+
+										inputPose.transform = {
+											matrix: inputPose.targetRay.transformMatrix
+										};
+
+										return inputPose;
+
+									} else {
+
+										return tempGetPose(targetRaySpace.gripSpace, referenceSpace);
+
+									}
+
+								};
+
+								callback( time, frame );
+
+							} );
+
+						};
+
+						// WebXRManager - xrFrame.getPose( inputSource.targetRaySpace, referenceSpace) Polyfill - line 279
+
+						const tempGetInputSources = session.getInputSources.bind( session );
+
+						session.getInputSources = function () {
+
+							const res = tempGetInputSources();
+
+							res.forEach( function (xrInputSource ) {
+
+                if (!('targetRaySpace' in xrInputSource)) {
+                  Object.defineProperty( xrInputSource, "targetRaySpace", {
+                    get: function () {
+
+                      return xrInputSource;
+
+                    }
+                  } );
+                }
+
+							} );
+
+							return res;
+
+						};
+
+						// WebXRManager - xrSession.getInputSources() Polyfill Line 132 - 136
+
+						/* session.inputSources = */Object.defineProperty(
+							session,
+							"inputSources",
+							{
+								get: session.getInputSources
+							}
+						);
+
+						// WebXRManager - xrSession.updateRenderState() Polyfill Line 129
+
+						if (isHelio96) {
+
+							session.updateRenderState = function ( { baseLayer } ) {
+
+								session.baseLayer = baseLayer;
+
+								// WebXRManager - xrSession.renderState.baseLayer Polyfill Line 219
+
+								session.renderState = {
+									baseLayer: baseLayer
+								};
+
+							};
+
+						}
+
+						// WebXRManager - xrSession.requestReferenceSpace() Polyfill Line 130
+
+						const tempRequestReferenceSpace = session.requestReferenceSpace.bind(
+							session
+						);
+
+						session.requestReferenceSpace = function () {
+
+							return tempRequestReferenceSpace( {
+								type: "stationary",
+								subtype: "floor-level"
+							} );
+
+						};
+
+						resolve( session );
+
+					} )
+					.catch( function ( error ) {
+
+						return reject( error );
+
+					} );
+
+			} );
+
+		};
+
+	}
+
+}
diff --git a/Reflector.js b/Reflector.js
new file mode 100644
index 0000000..6c7533a
--- /dev/null
+++ b/Reflector.js
@@ -0,0 +1,256 @@
+/**
+ * @author Slayvin / http://slayvin.net
+ */
+
+THREE.Reflector = function ( geometry, options ) {
+
+	THREE.Mesh.call( this, geometry );
+
+	this.type = 'Reflector';
+
+	var scope = this;
+
+	options = options || {};
+
+	var color = ( options.color !== undefined ) ? new THREE.Color( options.color ) : new THREE.Color( 0x7F7F7F );
+	var textureWidth = options.textureWidth || 512;
+	var textureHeight = options.textureHeight || 512;
+	var clipBias = options.clipBias || 0;
+	var shader = options.shader || THREE.Reflector.ReflectorShader;
+	var recursion = options.recursion !== undefined ? options.recursion : 0;
+
+	//
+
+	var reflectorPlane = new THREE.Plane();
+	var normal = new THREE.Vector3();
+	var reflectorWorldPosition = new THREE.Vector3();
+	var cameraWorldPosition = new THREE.Vector3();
+	var rotationMatrix = new THREE.Matrix4();
+	var lookAtPosition = new THREE.Vector3( 0, 0, - 1 );
+	var clipPlane = new THREE.Vector4();
+
+	var view = new THREE.Vector3();
+	var target = new THREE.Vector3();
+	var q = new THREE.Vector4();
+
+	var textureMatrix = new THREE.Matrix4();
+	var virtualCamera = new THREE.PerspectiveCamera();
+
+	var parameters = {
+		minFilter: THREE.LinearFilter,
+		magFilter: THREE.LinearFilter,
+		format: THREE.RGBFormat,
+		stencilBuffer: false
+	};
+
+	var renderTarget = new THREE.WebGLRenderTarget( textureWidth, textureHeight, parameters );
+
+	if ( ! THREE.Math.isPowerOfTwo( textureWidth ) || ! THREE.Math.isPowerOfTwo( textureHeight ) ) {
+
+		renderTarget.texture.generateMipmaps = false;
+
+	}
+
+	var material = new THREE.ShaderMaterial( {
+		uniforms: THREE.UniformsUtils.clone( shader.uniforms ),
+		fragmentShader: shader.fragmentShader,
+		vertexShader: shader.vertexShader,
+		transparent: options.transparent,
+	} );
+
+	material.uniforms[ "tDiffuse" ].value = renderTarget.texture;
+	material.uniforms[ "color" ].value = color;
+	material.uniforms[ "textureMatrix" ].value = textureMatrix;
+
+	this.material = material;
+
+	this.onBeforeRender = function ( renderer, scene, camera ) {
+		this.onBeforeRender2 && this.onBeforeRender2(renderer, scene, camera);
+
+		if ( 'recursion' in camera.userData ) {
+
+			if ( camera.userData.recursion === recursion ) return;
+
+			camera.userData.recursion ++;
+
+		}
+
+		reflectorWorldPosition.setFromMatrixPosition( scope.matrixWorld );
+		cameraWorldPosition.setFromMatrixPosition( camera.matrixWorld );
+
+		rotationMatrix.extractRotation( scope.matrixWorld );
+
+		normal.set( 0, 0, 1 );
+		normal.applyMatrix4( rotationMatrix );
+
+		view.subVectors( reflectorWorldPosition, cameraWorldPosition );
+
+		// Avoid rendering when reflector is facing away
+
+		if ( view.dot( normal ) > 0 ) return;
+
+		view.reflect( normal ).negate();
+		view.add( reflectorWorldPosition );
+
+		rotationMatrix.extractRotation( camera.matrixWorld );
+
+		lookAtPosition.set( 0, 0, - 1 );
+		lookAtPosition.applyMatrix4( rotationMatrix );
+		lookAtPosition.add( cameraWorldPosition );
+
+		target.subVectors( reflectorWorldPosition, lookAtPosition );
+		target.reflect( normal ).negate();
+		target.add( reflectorWorldPosition );
+
+		virtualCamera.position.copy( view );
+		virtualCamera.up.set( 0, 1, 0 );
+		virtualCamera.up.applyMatrix4( rotationMatrix );
+		virtualCamera.up.reflect( normal );
+		virtualCamera.lookAt( target );
+
+		virtualCamera.far = camera.far; // Used in WebGLBackground
+
+		virtualCamera.updateMatrixWorld();
+		virtualCamera.projectionMatrix.copy( camera.projectionMatrix );
+
+		virtualCamera.userData.recursion = 0;
+
+		// Update the texture matrix
+		textureMatrix.set(
+			0.5, 0.0, 0.0, 0.5,
+			0.0, 0.5, 0.0, 0.5,
+			0.0, 0.0, 0.5, 0.5,
+			0.0, 0.0, 0.0, 1.0
+		);
+		textureMatrix.multiply( virtualCamera.projectionMatrix );
+		textureMatrix.multiply( virtualCamera.matrixWorldInverse );
+		textureMatrix.multiply( scope.matrixWorld );
+
+		// Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html
+		// Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf
+		reflectorPlane.setFromNormalAndCoplanarPoint( normal, reflectorWorldPosition );
+		reflectorPlane.applyMatrix4( virtualCamera.matrixWorldInverse );
+
+		clipPlane.set( reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant );
+
+		var projectionMatrix = virtualCamera.projectionMatrix;
+
+		q.x = ( Math.sign( clipPlane.x ) + projectionMatrix.elements[ 8 ] ) / projectionMatrix.elements[ 0 ];
+		q.y = ( Math.sign( clipPlane.y ) + projectionMatrix.elements[ 9 ] ) / projectionMatrix.elements[ 5 ];
+		q.z = - 1.0;
+		q.w = ( 1.0 + projectionMatrix.elements[ 10 ] ) / projectionMatrix.elements[ 14 ];
+
+		// Calculate the scaled plane vector
+		clipPlane.multiplyScalar( 2.0 / clipPlane.dot( q ) );
+
+		// Replacing the third row of the projection matrix
+		projectionMatrix.elements[ 2 ] = clipPlane.x;
+		projectionMatrix.elements[ 6 ] = clipPlane.y;
+		projectionMatrix.elements[ 10 ] = clipPlane.z + 1.0 - clipBias;
+		projectionMatrix.elements[ 14 ] = clipPlane.w;
+
+		// Render
+
+		scope.visible = false;
+
+		var currentRenderTarget = renderer.getRenderTarget();
+
+		var currentVrEnabled = renderer.vr.enabled;
+		var currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+
+		renderer.vr.enabled = false; // Avoid camera modification and recursion
+		renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
+
+		renderer.setRenderTarget( renderTarget );
+		renderer.clear();
+		renderer.render( scene, virtualCamera );
+
+		renderer.vr.enabled = currentVrEnabled;
+		renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
+
+		renderer.setRenderTarget( currentRenderTarget );
+
+		// Restore viewport
+
+		var viewport = camera.viewport;
+
+		if ( viewport !== undefined ) {
+
+			renderer.state.viewport( viewport );
+
+		}
+
+		scope.visible = true;
+
+	};
+	this.onAfterRender = (renderer, scene, camera) => {
+    this.onAfterRender2 && this.onAfterRender2(renderer, scene, camera);
+	};
+
+	this.getRenderTarget = function () {
+
+		return renderTarget;
+
+	};
+
+};
+
+THREE.Reflector.prototype = Object.create( THREE.Mesh.prototype );
+THREE.Reflector.prototype.constructor = THREE.Reflector;
+
+THREE.Reflector.ReflectorShader = {
+
+	uniforms: {
+
+		'color': {
+			value: null
+		},
+
+		'tDiffuse': {
+			value: null
+		},
+
+		'textureMatrix': {
+			value: null
+		}
+
+	},
+
+	vertexShader: [
+		'uniform mat4 textureMatrix;',
+		'varying vec4 vUv;',
+
+		'void main() {',
+
+		'	vUv = textureMatrix * vec4( position, 1.0 );',
+
+		'	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+
+		'}'
+	].join( '\n' ),
+
+	fragmentShader: [
+		'uniform vec3 color;',
+		'uniform sampler2D tDiffuse;',
+		'varying vec4 vUv;',
+
+		'float blendOverlay( float base, float blend ) {',
+
+		'	return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );',
+
+		'}',
+
+		'vec3 blendOverlay( vec3 base, vec3 blend ) {',
+
+		'	return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );',
+
+		'}',
+
+		'void main() {',
+
+		'	vec4 base = texture2DProj( tDiffuse, vUv );',
+		'	gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );',
+
+		'}'
+	].join( '\n' )
+};
diff --git a/app.html b/app.html
index 4241cb1..8c48aed 100644
--- a/app.html
+++ b/app.html
@@ -9,6 +9,7 @@
     <script src="BufferGeometryUtils.js"></script>
     <script src="GLTFLoader.js"></script>
     <script src="LegacyGLTFLoader.js"></script>
+    <script src="Reflector.js"></script>
     <!-- <script src="localforage.js"></script> -->
     <script src="bmfont.js"></script>
     <script src="keycode.js"></script>
@@ -16,7 +17,7 @@
     <script src="cubicBezier.js"></script>
     <!-- <script src="sprite3d.js"></script> -->
     <script src="land.js"></script>
-    <script src="skin.js"></script>
+    <!-- <script src="skin.js"></script> -->
     <script src="parse5.js"></script>
     <script src="html-beautify.js"></script>
     <script src="file-type.js"></script>
@@ -25,6 +26,8 @@
   <body>
     <xr-site></xr-site>
     <script type=module>
+import Rig from './vrarmik/Rig.js';
+
 (async () => {
 
 let session, display, fakeXrDisplay, lastPresseds = [false, false], lastGripped = [false, false], lastPads = [false, false], lastAxes = [[0.5, 0.5], [0.5, 0.5]], lastPadToucheds = [false, false], scrollFactors = [0, 0], scaleFactors = [1, 1], menuOpen = false, orbitControls = null, transformControls, currentMoveMeshes = [null, null], moveMeshes = [], assetMeshes = [], moveLabelMeshes = [], assetLabelMeshes = [], nativeLabelMeshes = [], guardianMeshes = [], baseMeshes = [], menuAnimation = null, menuFactor = 1, keyboardFocus = null, user = null;
@@ -36,6 +39,7 @@
   default: 0x42a5f5,
   highlight: 0x9ccc65,
 };
+const clock = new THREE.Clock();
 const _rewriteUrlToRaw = u => {
   const o = new URL(u);
   const match = o.host.match(/^(.+)\.proxy\.exokit\.org$/);
@@ -352,6 +356,22 @@
   subtree: true,
 });
 
+/* class RiggedModel {
+  constructor(avatarMesh) {
+    this.avatarMesh = avatarMesh;
+  }
+  setState(hmd, gamepads) {
+    this.avatarMesh.position.fromArray(hmd.position).sub(localVector.set(0, 1.5, 0));
+    localQuaternion.fromArray(hmd.quaternion);
+    localEuler.setFromQuaternion(localQuaternion, localEuler.order);
+    localEuler.y += Math.PI;
+    localEuler.x *= -1;
+    this.avatarMesh.quaternion.setFromEuler(localEuler);
+  }
+  update() {
+    // console.log('per-frame update called');
+  }
+} */
 const _makePeerConnection = peerConnectionId => {
   const peerConnectionConfig = {
     iceServers: [
@@ -365,7 +385,7 @@
     console.log('got track', e);
   };
 
-  let skinMesh = null;
+  let avatarMesh = null;
   const sendChannel = peerConnection.createDataChannel('sendChannel');
   peerConnection.sendChannel = sendChannel;
   let pingInterval = 0;
@@ -373,9 +393,42 @@
   sendChannel.onopen = () => {
     // console.log('data channel local open');
 
-    skinMesh = _makeSkinMesh();
-    skinMesh.setSkinUrl(DEFAULT_SKIN_URL);
-    skinMeshes.push(skinMesh);
+    avatarMesh = new THREE.Object3D();
+    avatarMesh.riggedModel = null;
+    const loader = new THREE.GLTFLoader();
+    // const u = 'https://modulesio.github.io/models/miku.glb';
+    // const resource = model_patches.model4;
+    const resource = model_patches.anne;
+    loader.load(resource.url, object => {
+      if (avatarMesh) {
+        const model = object.scene;
+
+        model.traverse(o => {
+          if (o.isMesh) {
+            o.frustumCulled = false;
+          }
+        });
+
+        const group = new THREE.Group();
+        const o = {
+          url: resource.url,
+          model,
+          resource,
+          zForward: true,
+          group,
+        };
+        Object.assign(o, resource);
+        avatarMesh.riggedModel = new RiggedModel(model, o);
+        // avatarMesh.riggedModel.rebind(o.group);
+
+        console.log('got mesh', model);
+        avatarMesh.add(group);
+      }
+    }, xhr => {}, err => {
+      console.warn(err);
+    });
+    scene.add(avatarMesh);
+    avatarMeshes.push(avatarMesh);
 
     peerConnection.open = true;
 
@@ -459,9 +512,17 @@
       const data = JSON.parse(e.data);
       const {method} = data;
       if (method === 'pose') {
-        if (skinMesh) {
+        if (avatarMesh && avatarMesh.riggedModel) {
           const {hmd, gamepads} = data;
-          skinMesh.setState(hmd, gamepads);
+
+          avatarMesh.riggedModel.targets.Head.position.fromArray(hmd.position);
+          avatarMesh.riggedModel.targets.Head.quaternion.fromArray(hmd.quaternion);
+
+          const [leftGamepad, rightGamepad] = gamepads;
+          avatarMesh.riggedModel.targets.LeftHand.position.fromArray(leftGamepad.position);
+          avatarMesh.riggedModel.targets.LeftHand.quaternion.fromArray(leftGamepad.quaternion);
+          avatarMesh.riggedModel.targets.RightHand.position.fromArray(rightGamepad.position);
+          avatarMesh.riggedModel.targets.RightHand.quaternion.fromArray(rightGamepad.quaternion);
         }
       } else if (landState && method === 'initState') {
         const {state} = data;
@@ -507,10 +568,10 @@
     if (index !== -1) {
       peerConnections.splice(index, 1);
     }
-    if (skinMesh) {
-      skinMesh.destroy();
-      skinMeshes.splice(skinMeshes.indexOf(skinMesh), 1);
-      skinMesh = null;
+    if (avatarMesh) {
+      scene.remove(avatarMesh);
+      avatarMeshes.splice(avatarMeshes.indexOf(avatarMesh), 1);
+      avatarMesh = null;
     }
     if (landState) {
       // remove owned xr-iframes
@@ -5817,6 +5878,29 @@
   }
 };
 
+let avatarModel, rig;
+new THREE.GLTFLoader().load('https://exokitxr.github.io/avatar-models/model2.vrm', object => {
+  avatarModel = object.scene;
+
+  // debugger;
+
+  /* model.traverse(o => {
+    if (o.isSkinnedMesh) {
+      if (!window.skeleton) {
+        window.skeleton = o.skeleton;
+      }
+
+      // o.bind(skeleton);
+    }
+  }); */
+
+  rig = new Rig(avatarModel);
+
+  avatarModel.visible = false;
+
+  scene.add(avatarModel);
+});
+
 // let renderTarget = null;
 const startTime = Date.now();
 let lastTime = 0;
@@ -6095,12 +6179,15 @@
   };
   _updateSceneMeshes(); */
 
-  const _updateSkinMeshes = () => {
-    for (let i = 0; i < skinMeshes.length; i++) {
-      skinMeshes[i].update();
+  const _updateAvatarMeshes = () => {
+    for (let i = 0; i < avatarMeshes.length; i++) {
+      const avatarMesh = avatarMeshes[i];
+      const timeDelta = clock.getDelta() * 1000;
+      const time = clock.elapsedTime * 1000;
+      avatarMesh.riggedModel && avatarMesh.riggedModel.tick(time, timeDelta);
     }
   };
-  _updateSkinMeshes();
+  _updateAvatarMeshes();
 
   const _handleTrigger = (gamepad, i, pressed, lastPressed) => {
     const start = pressed && !lastPressed;
@@ -6598,6 +6685,24 @@
     _updateTeleportMeshes();
   }
 
+  const _updateAvatarModel = () => {
+    if (rig) {
+      const gamepads = navigator.getGamepads();
+
+      rig.inputs.hmd.position = vrCamera.position;
+      rig.inputs.hmd.rotation = vrCamera.quaternion;
+
+      rig.inputs.leftGamepad.rotation = new THREE.Quaternion().fromArray(gamepads[1].pose.orientation);
+      rig.inputs.leftGamepad.position = new THREE.Vector3().fromArray(gamepads[1].pose.position);
+
+      rig.inputs.rightGamepad.rotation = new THREE.Quaternion().fromArray(gamepads[0].pose.orientation);
+      rig.inputs.rightGamepad.position = new THREE.Vector3().fromArray(gamepads[0].pose.position);
+
+      rig.update();
+    }
+  };
+  _updateAvatarModel();
+
   const _render = () => {
     const c = renderer.vr.enabled ? renderer.vr.getCamera(camera) : camera;
 
@@ -6870,139 +6975,12 @@
     console.warn(err.stack);
   });
 
-const skinMeshes = [];
+const avatarMeshes = [];
 const _mod = (v, d) => {
   const n = v % d;
   return n < 0 ? (d + n) : n;
 };
 const _angleDiff = (a, b) => _mod((b - a) + Math.PI, Math.PI * 2) - Math.PI;
-const _makeSkinMesh = () => {
-  const object = {};
-  let onsetstate = null;
-  const uniforms = THREE.UniformsUtils.clone(skin.SKIN_SHADER.uniforms);
-  object.setSkinUrl = skinUrl => {
-    if (skinUrl) {
-      const mesh = skin({
-        limbs: true,
-      });
-      mesh.frustumCulled = false;
-
-      mesh.onBeforeRender = (onBeforeRender => function() {
-        mesh.material.uniforms.headRotation.value.copy(uniforms.headRotation.value);
-        mesh.material.uniforms.leftArmRotation.value.copy(uniforms.leftArmRotation.value);
-        mesh.material.uniforms.rightArmRotation.value.copy(uniforms.rightArmRotation.value);
-        mesh.material.uniforms.theta.value = uniforms.theta.value;
-        mesh.material.uniforms.headVisible.value = uniforms.headVisible.value;
-        mesh.material.uniforms.hit.value = uniforms.hit.value;
-
-        onBeforeRender.apply(this, arguments);
-      })(mesh.onBeforeRender);
-
-      return new Promise((accept, reject) => {
-        const skinImg = new Image();
-        skinImg.crossOrigin = 'Anonymous';
-        skinImg.src = skinUrl;
-        skinImg.onload = () => {
-          accept(skinImg);
-        };
-        skinImg.onerror = err => {
-          reject(err);
-        };
-      })
-        .then(skinImg => {
-          mesh.setImage(skinImg);
-
-          onsetstate = (hmd, gamepads) => {
-            const hmdPosition = localVector.fromArray(hmd.position);
-            const hmdQuaternion = localQuaternion.fromArray(hmd.quaternion);
-
-            const hmdEuler = localEuler.setFromQuaternion(hmdQuaternion, localEuler.order);
-            const playerEuler = localEuler2.setFromQuaternion(mesh.quaternion, localEuler2.order);
-            const angleDiff = _angleDiff(hmdEuler.y, playerEuler.y);
-            const angleDiffAbs = Math.abs(angleDiff);
-            if (angleDiffAbs > Math.PI / 2) {
-              playerEuler.y += (angleDiffAbs - (Math.PI / 2)) * (angleDiff < 0 ? 1 : -1);
-              mesh.quaternion.setFromEuler(playerEuler);
-            }
-
-            const oldWorldPosition = mesh.getWorldPosition(localVector2);
-            mesh.position.copy(hmdPosition)
-              .sub(mesh.eye.getWorldPosition(localVector3))
-              .add(oldWorldPosition);
-
-            const playerQuaternionInverse = localQuaternion2.copy(mesh.quaternion).inverse();
-            mesh.head.quaternion.copy(playerQuaternionInverse).multiply(hmdQuaternion);
-            mesh.updateMatrixWorld();
-
-            const headQuaternionInverse = localQuaternion3.copy(mesh.head.quaternion).inverse();
-            uniforms.headRotation.value.set(headQuaternionInverse.x, headQuaternionInverse.y, headQuaternionInverse.z, headQuaternionInverse.w);
-
-            for (let i = 0; i < 2; i++) {
-              const armRotation = uniforms[i === 0 ? 'leftArmRotation' : 'rightArmRotation'];
-
-              const gamepad = gamepads[i];
-              if (gamepad.visible) {
-                const gamepadPosition = localVector.fromArray(gamepad.position);
-                const gamepadQuaternion = localQuaternion.fromArray(gamepad.quaternion);
-
-                const armQuaternionInverse = localQuaternion3.setFromRotationMatrix(
-                  localMatrix.lookAt(
-                    mesh.arms[i === 0 ? 'left' : 'right']
-                      .getWorldPosition(localVector2),
-                    gamepadPosition,
-                    localVector3
-                      .set(0, 1, 0)
-                      .applyQuaternion(gamepadQuaternion)
-                  )
-                )
-                  .multiply(armQuaternionOffset)
-                  .premultiply(playerQuaternionInverse)
-                  .inverse();
-                armRotation.value.set(armQuaternionInverse.x, armQuaternionInverse.y, armQuaternionInverse.z, armQuaternionInverse.w);
-                // console.log('arm rotation', i, armRotation.value.toArray().join(','));
-              } else {
-                armRotation.value.set(0, 0, 0, 1);
-              }
-            }
-          };
-
-          if (object.skinMesh) {
-            object.skinMesh.parent.remove(object.skinMesh);
-            object.skinMesh = null;
-          }
-
-          scene.add(mesh);
-          object.skinMesh = mesh;
-        });
-    } else {
-      onsetstate = null;
-
-      if (object.skinMesh) {
-        object.skinMesh.parent.remove(object.skinMesh);
-        object.skinMesh = null;
-      }
-    }
-  };
-  object.setState = (hmd, gamepads) => {
-    onsetstate && onsetstate(hmd, gamepads);
-  };
-  object.animate = thetaValue => {
-    uniforms.theta.value = thetaValue;
-  };
-  object.update = () => {
-    // XXX
-  };
-  object.destroy = () => {
-    onsetstate = null;
-
-    if (object.skinMesh) {
-      object.skinMesh.parent.remove(object.skinMesh);
-      object.skinMesh = null;
-    }
-  };
-  object.skinMesh = null;
-  return object;
-};
 
 scene.add(defaultGltf);
 const _loadDefaultGltf = () => {
@@ -7020,6 +6998,38 @@
 };
 _loadDefaultGltf();
 
+const mirrorMesh = (() => {
+  const geometry = new THREE.PlaneBufferGeometry(1, 2);
+  const mesh = new THREE.Reflector(geometry, {
+    clipBias: 0.003,
+    textureWidth: 1024 * window.devicePixelRatio,
+    textureHeight: 2048 * window.devicePixelRatio,
+    color: 0x889999,
+    addColor: 0x300000,
+    recursion: 1
+  });
+  // mesh.position.set(-1, 1.5, -2.1);
+  mesh.position.set(0, 1, 1);
+  /* mesh.rotation.order = 'YXZ';
+  mesh.rotation.y = Math.PI; */
+  /* const material = new THREE.MeshBasicMaterial({
+    color: 0xFF0000,
+  });
+  const mesh = new THREE.Mesh(geometry, material); */
+  mesh.onBeforeRender2 = () => {
+    if (avatarModel) {
+      avatarModel.visible = true;
+    }
+  };
+  mesh.onAfterRender2 = () => {
+    if (avatarModel) {
+      avatarModel.visible = false;
+    }
+  };
+  return mesh;
+})();
+scene.add(mirrorMesh);
+
 function _updateCoord() {
   const {c} = parseQuery(window.location.search);
   let match;
diff --git a/three.js b/three.js
index 0df3d03..cfd078b 100644
--- a/three.js
+++ b/three.js
@@ -23319,7 +23319,7 @@
 
 			}
 
-			if ( onAnimationFrameCallback ) { onAnimationFrameCallback( time ); }
+			if ( onAnimationFrameCallback ) { onAnimationFrameCallback( time, frame, referenceSpace ); }
 
 		}
 
diff --git a/vrarmik.html b/vrarmik.html
new file mode 100644
index 0000000..7c57b13
--- /dev/null
+++ b/vrarmik.html
@@ -0,0 +1,1870 @@
+<!doctype html>
+<html>
+  <head>
+    <meta http-equiv="origin-trial" content="AspvaSU7F1Gbpa8q9JRNRNXFF+0+77C1xkxf1hkzJCrBI7Mmt/eG25QXLBn7lfzPsgrN5next8ZtIiCeGs6R4w8AAABleyJvcmlnaW4iOiJodHRwczovL2V4b2tpdC5vcmc6NDQzIiwiZmVhdHVyZSI6IldlYlhSRGV2aWNlTTc2IiwiZXhwaXJ5IjoxNTcxMTEyNjU0LCJpc1N1YmRvbWFpbiI6dHJ1ZX0=">
+    <style>
+* {
+  box-sizing: border-box;
+}
+body {
+  margin: 0;
+  background-color: #000;
+  /* color: #F5F5F5; */
+  font-family: -apple-system,BlinkMacSystemFont,"Segoe UI","Roboto","Oxygen","Ubuntu","Cantarell","Fira Sans","Droid Sans","Helvetica Neue",sans-serif;
+  font-size: 15px;
+}
+.body {
+  display: flex;
+  width: 100vw;
+  height: 100vh;
+  overflow: hidden;
+}
+header {
+  position: absolute;
+  display: flex;
+  top: 0;
+  left: 0;
+  width: 100vw;
+  height: 50px;
+  background-color: #FFF;
+  box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.08);
+  align-items: center;
+  user-select: none;
+  z-index: 1;
+}
+header .icon {
+  width: 50px;
+  height: 50px;
+  margin: 0 20px;
+}
+header nav {
+  display: flex;
+  height: 100%;
+  padding: 0 10px;
+  letter-spacing: 0.9px;
+  align-items: center;
+  text-transform: uppercase;
+}
+header nav span {
+  display: flex;
+  height: 30px;
+  padding: 10px;
+  border-radius: 4px;
+  align-items: center;
+}
+header nav.selected span {
+  background-color: #5c6bc0;
+  color: #FFF;
+  cursor: default;
+}
+header nav:not(.selected):hover {
+  cursor: pointer;
+}
+header nav:not(.selected):hover span {
+  background-color: #EEE;
+}
+.examples {
+  width: 200px;
+  padding-top: 50px;
+  background-color: #FFF;
+  overflow-y: auto;
+}
+h1, h2, h3, h4, h5, h6, p, .examples > .multibutton {
+  margin: 15px 0;
+  padding: 0 20px;
+  font-weight: inherit;
+}
+li {
+  /* padding-left: 20px;
+  padding-right: 20px; */
+}
+.iframe-wrapper {
+  position: relative;
+  display: flex;
+  margin-top: 50px;
+  flex: 1;
+  background-color: #FFF;
+}
+.tabs {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+}
+.tabs .tab {
+  display: inline-flex;
+  margin: 5px 5px;
+  padding: 5px 10px;
+  background-color: #D8D8D8;
+  border-radius: 4px;
+  color: #000;
+  align-items: center;
+}
+.tabs .tab .text {
+  margin-right: 10px;
+  align-items: center;
+}
+.tabs .tab .close-x {
+  display: flex;
+  width: 20px;
+  height: 20px;
+  background-color: #ef5350;
+  color: #FFF;
+  justify-content: center;
+  align-items: center;
+}
+canvas {
+  width: 100% !important;
+  height: 100vh !important;
+  background-color: #f8f8f8;
+}
+a {
+  color: #AAA;
+  text-decoration: none;
+}
+a:hover {
+  color: #42a5f5;
+}
+a:active {
+  color: #1976d2;
+}
+.body > .multibutton {
+  position: absolute;
+  right: 30px;
+  bottom: 30px;
+}
+.multibutton {
+  display: flex;
+}
+.multibutton .button:not(.first) {
+  border-top-left-radius: 0;
+  border-bottom-left-radius: 0;
+}
+.multibutton .button:not(.last) {
+  border-top-right-radius: 0;
+  border-bottom-right-radius: 0;
+}
+.button {
+  display: inline-flex;
+  margin-right: 5px;
+  padding: 7px 14px;
+  border: 2px solid;
+  border-radius: 100px;
+  color: #5c6bc0;
+  font-size: 13px;
+  cursor: pointer;
+  outline: none
+}
+/* .button:not(:last-child) {
+  margin-right: 20px;
+} */
+.button:not([disabled]):hover {
+  background-color: #5c6bc0;
+  border-color: #5c6bc0;
+  color: #FFF;
+}
+.button[disabled] {
+  color: #b71c1c;
+  cursor: auto;
+}
+#code-header:not(.open),
+#code-button:not(.open) .opened-text,
+#code-button.open .closed-text
+{
+  display: none;
+}
+.coming-soon {
+  color: #ccc;
+}
+.coming-soon-sub {
+  font-size: 10px;
+  display: block;
+}
+.header-link {
+  color: #666;
+}
+.code-header {
+  position: absolute;
+  top: 50px;
+  right: 0;
+  display: flex;
+  align-items: center;
+  width: 600px;
+  height: 32px;
+  padding: 5px;
+  font-size: 13px;
+  color: #4caf50;
+  background-color: #f2f3f5;
+}
+.code {
+  position: absolute;
+  top: 82px;
+  bottom: 0;
+  right: 0;
+  width: 600px;
+  border: 0;
+  border-left: 5px solid #f2f3f5;
+  outline: none;
+}
+.code:not(.open) {
+  display: none;
+}
+input[type=text] {
+  width: 160px;
+  margin: 0 20px;
+  padding: 7px 14px;
+  background-color: #f2f3f5;
+  border: 0;
+  border-radius: 8px;
+  font-family: inherit;
+  font-size: inherit;
+  outline: none;
+}
+
+/* account.css */
+
+input[type=email],
+input[type=text]
+{
+  margin-right: 10px;
+  padding: 7px 14px;
+  background-color: #f2f3f5;
+  border: 0;
+  border-radius: 8px;
+  font-family: inherit;
+  font-size: inherit;
+  outline: none;
+}
+
+header > .login-form {
+  display: flex;
+  margin-left: auto;
+}
+
+body.logging-in .login-form,
+header > .login-form:not(.phase-1) > .phase-1-content,
+header > .login-form:not(.phase-2) > .phase-2-content,
+header > .login-form:not(.phase-3) > .phase-3-content,
+header > .login-form.phase-1 > .phaseless-content,
+header > .login-form.phase-2 > .phaseless-content,
+header > .login-form.phase-3 > .phaseless-content
+{
+  display: none;
+}
+
+.login-form .phase-content {
+  display: flex;
+  align-items: center;
+}
+.login-form .phase-content .login-error
+{
+  margin-right: 15px;
+  font-weight: 600;
+}
+.login-form .phase-content .user-button {
+  display: flex;
+  height: 30px;
+  margin-right: 10px;
+  padding: 3px 10px;
+  background-color: #f2f3f5;
+  border: 0;
+  border-radius: 8px;
+  align-items: center;
+  cursor: pointer;
+}
+.login-form .phase-content .user-button:hover,
+.login-form .phase-content .user-button.open {
+  background-color: #CCC;
+}
+.login-form .phase-content .user-button > img {
+  width: 20px;
+  height: 20px;
+  margin-right: 5px;
+}
+.login-form .phase-content .user-button > .name {
+  display: flex;
+  height: 100%;
+  font-weight: 600;
+  align-items: center;
+}
+.login-form .phase-content .login-notice {
+  color: #4caf50;
+}
+.login-form .phase-content .login-error {
+  color: #e53935;
+}
+.login-form .phaseless-content {
+  padding: 0 30px;
+}
+    </style>
+    <script src="three.js"></script>
+    <script src="OrbitControls.js"></script>
+    <script src="Reflector.js"></script>
+    <script src="bmfont.js"></script>
+  </head>
+  <body>
+    <div class=body>
+      <header>
+        <img src="logo.svg" class="icon">
+        <nav class=selected><span>Avatars</span></nav>
+        <!-- <a href="https://docs.exokit.org/"><nav><span class="header-link">Documentation</span></nav></a>
+        <a href="https://browser.exokit.org"><nav><span class="header-link">Browser
+        </span></nav></a>
+        <a href="https://discord.gg/UgZDFZW"><nav><span class="coming-soon">Exoland
+          <p class="coming-soon-sub">Coming soon!</p>
+        </span></nav></a> -->
+
+        <form class="login-form phase-1" id=login-form>
+          <div class=phase-content>
+            <div class=login-notice id=login-notice></div>
+            <div class=login-error id=login-error></div>
+          </div>
+          <div class="phase-content phase-1-content">
+            <input type=email placeholder="your@email.com" id=login-email>
+            <input type=submit value="Log in" class="button highlight">
+          </div>
+          <div class="phase-content phase-2-content">
+            <input type=text placeholder="Verification code" id=login-verification-code>
+            <input type=submit value="Verify" class="button highlight">
+          </div>
+          <div class="phase-content phase-3-content">
+            <button class=user-button id=user-button>
+              <img src="exobot.png">
+              <span class=name id=login-email-static>a@modules.io</span>
+            </button>
+            <input type=button value="Load avatar" class="button highlight" id=load-avater>
+            <input type=button value="Save avatar" class="button highlight" id=save-avater>
+            <input type=submit value="Log out" class="button highlight">
+          </div>
+          <div class="phase-content phaseless-content">
+            <div>Working...</div>
+          </div>
+        </form>
+      </header>
+
+      <div class=examples>
+        <h3>Examples</h3>
+        <p>
+          <a href="https://exokitxr.github.io/avatar-models/model.glb" class="a-avatar">model.glb</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model2.vrm" class="a-avatar">model2.vrm</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model3.unitypackage" class="a-avatar">model3.unitypackage</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model4.zip" class="a-avatar">model4.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model5.fbx" class="a-avatar">model5.fbx</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model6.zip" class="a-avatar">model6.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model7.vrm" class="a-avatar">model7.vrm</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model8.vrm" class="a-avatar">model8.vrm</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model9.vrm" class="a-avatar">model9.vrm</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model10.vrm" class="a-avatar">model10.vrm</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model11.vrm" class="a-avatar">model11.vrm</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model12.fbx" class="a-avatar">model12.fbx</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model13.zip" class="a-avatar">model13.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model14.zip" class="a-avatar">model14.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model15.zip" class="a-avatar">model15.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model16.zip" class="a-avatar">model16.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model17.zip" class="a-avatar">model17.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model18.zip" class="a-avatar">model18.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model19.zip" class="a-avatar">model19.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model20.zip" class="a-avatar">model20.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model21.zip" class="a-avatar">model21.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model22.zip" class="a-avatar">model22.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model23.zip" class="a-avatar">model23.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model24.zip" class="a-avatar">model24.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model25.zip" class="a-avatar">model25.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model26.zip" class="a-avatar">model26.zip</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model27.png" class="a-avatar">model27.png</a><br>
+          <a href="https://exokitxr.github.io/avatar-models/model28.png" class="a-avatar">model28.png</a><br>
+        </p>
+        <div class=multibutton>
+          <label for="upload-file-button">
+            <a class="button first last">Upload file...</a>
+            <input type="file" id="upload-file-button" style="display: none">
+          </label>
+        </div>
+        <div class=multibutton>
+          <nav class="button first last" id=export-model-button>Export model</nav>
+        </div>
+        <div class=multibutton>
+          <nav class="button first" id=scale-down-button>Scale -</nav>
+          <nav class="button last" id=scale-up-button>Scale +</nav>
+        </div>
+        <h3>Multiplayer</h3>
+        <input type=text value="avaer/yatis" placeholder="user/channel" id=channel-input>
+        <div class=multibutton>
+          <nav class="button first last" id=connect-button>Connect</nav>
+        </div>
+      </div>
+
+      <div class=iframe-wrapper id=iframe-wrapper></div>
+
+      <div class=multibutton>
+        <a class="button first" id="enable-mic-button" style="display: none;">Enable Mic</a>
+        <a class="button first" id="disable-mic-button" disabled style="display: none;">Disable Mic</a>
+        <a class="button" id="firstperson-button">Firstperson</a>
+        <a class="button" id="thirdperson-button">Thirdperson</a>
+        <a class="button last" id="enter-xr-button" style="display: none;">Enter XR</a>
+        <a class="button last" id="no-xr-button" disabled style="display: none;">No XR</a>
+      </div>
+    </div>
+    <script type=module>
+import './webxr-polyfill.module.js';
+import './HelioWebXRPolyfill.js';
+import ModelLoader from 'https://model-loader.exokit.org/model-loader.js';
+import Avatar from './vrarmik/avatars.js';
+import {XRChannelConnection} from 'https://multiplayer.exokit.org/multiplayer.js';
+
+const peerPoseUpdateRate = 50;
+const walkSpeed = 0.025;
+const floorPlane = new THREE.Plane().setFromNormalAndCoplanarPoint(new THREE.Vector3(0, 1, 0), new THREE.Vector3(0, 0, 0));
+
+const localVector = new THREE.Vector3();
+const localVector2 = new THREE.Vector3();
+const localVector3 = new THREE.Vector3();
+const localVector4 = new THREE.Vector3();
+const localVector5 = new THREE.Vector3();
+const localQuaternion = new THREE.Quaternion();
+const localQuaternion2 = new THREE.Quaternion();
+const localMatrix = new THREE.Matrix4();
+const localEuler = new THREE.Euler();
+const localRay = new THREE.Ray();
+
+const z180Quaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
+
+const scene = new THREE.Scene();
+
+const camera = new THREE.PerspectiveCamera(90, window.innerWidth / window.innerHeight, 0.1, 1000);
+camera.position.y = 1.5;
+camera.position.z = 2;
+// camera.rotation.y = Math.PI;
+
+const ambientLight = new THREE.AmbientLight(0x808080);
+scene.add(ambientLight);
+
+const directionalLight = new THREE.DirectionalLight(0xFFFFFF, 1);
+directionalLight.position.set(0.5, 1, 0.5);
+scene.add(directionalLight);
+
+/* const directionalLight2 = new THREE.DirectionalLight(0xFFFFFF, 1);
+directionalLight2.position.set(0, -0.25, -0.25);
+scene.add(directionalLight2); */
+
+const gridHelper = new THREE.GridHelper(10, 10);
+scene.add(gridHelper);
+
+const cubeGeometry = new THREE.ConeBufferGeometry(0.05, 0.2, 3)
+  .applyMatrix(new THREE.Matrix4().makeRotationFromQuaternion(
+    new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), new THREE.Vector3(0, 0, 1)))
+  );
+const materials ={};
+const _getCubeMaterial = color => {
+  let material = materials[color];
+  if (!material) {
+    material = new THREE.MeshPhongMaterial({
+      color,
+      flatShading: true,
+    });
+    materials[color] = material;
+  }
+  return material;
+}
+const _makeCubeMesh = (color = 0x0000FF) => {
+  const mesh = new THREE.Mesh(cubeGeometry, _getCubeMaterial(color));
+  mesh.frustumCulled = false;
+  if (color === 0x008000 || color === 0x808000) {
+    // mesh.add(new THREE.AxesHelper());
+  }
+  return mesh;
+};
+const _makeTextMesh = (s = '', color = 0x000000, size = 1) => {
+  // create a geometry of packed bitmap glyphs,
+  // word wrapped to 300px and right-aligned
+  var geometry = createTextGeometry({
+    width: Infinity,
+    font: fontJson,
+  });
+
+  // change text and other options as desired
+  // the options sepcified in constructor will
+  // be used as defaults
+  geometry.update(s);
+
+  // the resulting layout has metrics and bounds
+  // console.log(geometry.layout.height)
+  // console.log(geometry.layout.descender)
+
+  var material = new THREE.RawShaderMaterial(createSDFShader({
+    map: fontTexture,
+    transparent: true,
+    color,
+    // color: palette[Math.floor(Math.random() * palette.length)]
+    // negate: false,
+    side: THREE.DoubleSide,
+  }));
+
+  const scaleFactor = 0.002 * size;
+
+  const mesh = new THREE.Mesh(geometry, material)
+  mesh.position.set(0, -geometry.layout.lineHeight * 0.001, 0);
+  mesh.scale.set(scaleFactor, -scaleFactor, -scaleFactor);
+  mesh.getText = () => s;
+  mesh.setText = newS => {
+    if (newS !== s) {
+      s = newS;
+      geometry.update(s);
+    }
+  };
+  return mesh;
+};
+const meshes = {
+  eyes: _makeCubeMesh(0xFF0000),
+  head: _makeCubeMesh(0xFF8080),
+
+  chest: _makeCubeMesh(0xFFFF00),
+  leftShoulder: _makeCubeMesh(0x00FF00),
+  rightShoulder: _makeCubeMesh(0x008000),
+  leftUpperArm: _makeCubeMesh(0x00FFFF),
+  rightUpperArm: _makeCubeMesh(0x008080),
+  leftLowerArm: _makeCubeMesh(0x0000FF),
+  rightLowerArm: _makeCubeMesh(0x000080),
+  leftHand: _makeCubeMesh(0xFFFFFF),
+  rightHand: _makeCubeMesh(0x808080),
+
+  hips: _makeCubeMesh(0xFF0000),
+  leftUpperLeg: _makeCubeMesh(0xFFFF00),
+  rightUpperLeg: _makeCubeMesh(0x808000),
+  leftLowerLeg: _makeCubeMesh(0x00FF00),
+  rightLowerLeg: _makeCubeMesh(0x008000),
+  leftFoot: _makeCubeMesh(0xFFFFFF),
+  rightFoot: _makeCubeMesh(0x808080),
+};
+const meshDolly = new THREE.Object3D();
+for (const k in meshes) {
+  // meshDolly.add(meshes[k]);
+}
+scene.add(meshDolly);
+/* scene.remove(meshes.shoulderLeft);
+scene.remove(meshes.upperArmLeft);
+scene.remove(meshes.lowerArmLeft);
+scene.remove(meshes.handLeft);
+scene.remove(meshes.shoulderRight);
+scene.remove(meshes.upperArmRight);
+scene.remove(meshes.lowerArmRight);
+scene.remove(meshes.handRight);
+scene.remove(meshes.shoulderRight);
+scene.remove(meshes.upperLegRight);
+scene.remove(meshes.lowerLegRight);
+scene.remove(meshes.footRight); */
+
+const teleportGeometry = new THREE.TorusBufferGeometry(0.5, 0.15, 3, 5)
+  .applyMatrix(new THREE.Matrix4().makeRotationX(-(Math.PI / 2)))
+  .applyMatrix(new THREE.Matrix4().makeRotationY((1 / 20) * (Math.PI * 2)));
+const teleportMaterial = new THREE.MeshBasicMaterial({
+  color: 0x44c2ff,
+});
+const _makeTeleportMesh = () => {
+  const geometry = teleportGeometry;
+  const material = teleportMaterial;
+
+  const mesh = new THREE.Mesh(geometry, material);
+  mesh.visible = false;
+  mesh.frustumCulled = false;
+  return mesh;
+};
+const teleportMeshes = [
+  _makeTeleportMesh(),
+  _makeTeleportMesh(),
+];
+scene.add(teleportMeshes[0]);
+scene.add(teleportMeshes[1]);
+
+const _patchModel = object => {
+  object.scene.traverse(o => {
+    if (o.isMesh) {
+      o.frustumCulled = false;
+
+      if (o.material.opacity === 0) {
+        o.material.opacity = 1;
+      }
+    }
+  });
+};
+const _loadModelUrl = async (url, filename) => {
+  const model = await ModelLoader.loadModelUrl(url, filename);
+  _patchModel(model);
+  return model;
+};
+
+const _bindUploadFileButton = inputFileEl => {
+  inputFileEl.addEventListener('change', async e => {
+    const {files} = e.target;
+    if (files.length === 1) {
+      const [file] = files;
+      const dataUrl = URL.createObjectURL(file);
+      const model = await _loadModelUrl(dataUrl, file.name);
+      _setLocalModel(model);
+      // modelUrl = dataUrl;
+    }
+
+    const {parentNode} = inputFileEl;
+    parentNode.removeChild(inputFileEl);
+    const newInputFileEl = document.createElement('input');
+    newInputFileEl.type = 'file';
+    newInputFileEl.id = 'upload-file-button';
+    newInputFileEl.style.display = 'none';
+    parentNode.appendChild(newInputFileEl);
+    _bindUploadFileButton(newInputFileEl);
+  });
+};
+_bindUploadFileButton(document.getElementById('upload-file-button'));
+window.document.addEventListener('dragover', e => {
+  e.preventDefault();
+});
+window.document.addEventListener('drop', async e => {
+  e.preventDefault();
+
+  if (e.dataTransfer.items.length !== 1) {
+    return;
+  }
+
+  for (var i = 0; i < e.dataTransfer.items.length; i++) {
+    if (e.dataTransfer.items[i].kind === 'file') {
+      const file = e.dataTransfer.items[i].getAsFile();
+      // console.log('got file', e.dataTransfer.items[i], file);
+      const dataUrl = URL.createObjectURL(file);
+      const model = await _loadModelUrl(dataUrl, file.name);
+      _setLocalModel(model);
+      // modelUrl = dataUrl;
+    }
+  }
+});
+
+const renderer = new THREE.WebGLRenderer({
+  // canvas: document.getElementById('canvas'),
+  // alpha: true,
+  antialias: true,
+});
+// console.log('set size', window.innerWidth, window.innerHeight);
+renderer.setSize(window.innerWidth, window.innerHeight);
+renderer.setPixelRatio(window.devicePixelRatio);
+renderer.sortObjects = false;
+document.getElementById('iframe-wrapper').appendChild(renderer.domElement);
+
+const orbitControls = new THREE.OrbitControls(camera, renderer.domElement);
+orbitControls.screenSpacePanning = true;
+orbitControls.enableMiddleZoom = false;
+orbitControls.update();
+
+const aAvatars = Array.from(document.querySelectorAll('.a-avatar'));
+for (let i = 0; i < aAvatars.length; i++) {
+  const aAvatar = aAvatars[i];
+  aAvatar.addEventListener('click', async e => {
+    e.preventDefault();
+
+    const {href} = aAvatar;
+    const model = await _loadModelUrl(href);
+    _setLocalModel(model);
+    modelUrl = href;
+    _sendAllPeerConnections(JSON.stringify({
+      method: 'model',
+      url: modelUrl,
+    }));
+  });
+}
+
+let fontJson, fontTexture;
+const fontPromise = Promise.all([
+  fetch('DejaVu-sdf.json').then(res => res.json()),
+  new Promise((accept, reject) => {
+    new THREE.TextureLoader().load('DejaVu-sdf.png', accept);
+  }),
+]).then(results => {
+  fontJson = results[0];
+  fontTexture = results[1];
+});
+const buttonSize = new THREE.Vector3(1, 0.1*0.9, 0.1);
+const buttonGeometry = new THREE.BoxBufferGeometry(buttonSize.x, buttonSize.y, buttonSize.z);
+const colors = {
+  normal: 0x5c6bc0,
+  highlight: 0x303f9f,
+};
+const mirrorMesh = (() => {
+  const mirrorWidth = 3;
+  const mirrorHeight = 2;
+  const geometry = new THREE.PlaneBufferGeometry(mirrorWidth, mirrorHeight)
+    .applyMatrix(new THREE.Matrix4().makeTranslation(0, 1, 0));
+  const mesh = new THREE.Reflector(geometry, {
+    clipBias: 0.003,
+    textureWidth: 1024 * window.devicePixelRatio,
+    textureHeight: 2048 * window.devicePixelRatio,
+    color: 0x889999,
+    addColor: 0x300000,
+    recursion: 1,
+    transparent: true,
+  });
+  mesh.position.set(0, 0, -1);
+
+  const borderMesh = new THREE.Mesh(
+    new THREE.BoxBufferGeometry(mirrorWidth + 0.1, mirrorHeight + 0.1, 0.1)
+      .applyMatrix(new THREE.Matrix4().makeTranslation(0, 1, -0.1/2 - 0.01)),
+    new THREE.MeshPhongMaterial({
+      color: 0x5c6bc0,
+    })
+  );
+  mesh.add(borderMesh);
+
+  const buttonMeshes = aAvatars.map((aAvatar, i) => {
+    const geometry = buttonGeometry;
+    const material = new THREE.MeshPhongMaterial({
+      color: colors.normal,
+    });
+    const mesh = new THREE.Mesh(geometry, material);
+    mesh.position.set(-2, 2 - 0.1/2 - i*0.1, 0);
+    mesh.frustumCulled = false;
+
+    fontPromise.then(() => {
+      const textMesh = _makeTextMesh(aAvatar.innerText, 0xFFFFFF);
+      textMesh.position.x = -0.45;
+      textMesh.position.y = -0.02;
+      textMesh.position.z = 0.06;
+      mesh.add(textMesh);
+    });
+
+    mesh.box = new THREE.Box3();
+
+    return mesh;
+  });
+  for (let i = 0; i < buttonMeshes.length; i++) {
+    mesh.add(buttonMeshes[i]);
+  }
+  mesh.buttonMeshes = buttonMeshes;
+  mesh.update = () => {
+    for (let i = 0; i < buttonMeshes.length; i++) {
+      const buttonMesh = buttonMeshes[i];
+      buttonMesh.box.setFromCenterAndSize(buttonMesh.getWorldPosition(new THREE.Vector3()), buttonSize.clone().multiply(buttonMesh.getWorldScale(new THREE.Vector3())));
+    }
+  };
+  mesh.getButtonIntersectionIndex = position => {
+    for (let i = 0; i < buttonMeshes.length; i++) {
+      if (buttonMeshes[i].box.containsPoint(position)) {
+        return i;
+      }
+    }
+    return -1;
+  };
+
+  mesh.onBeforeRender2 = () => {
+    if (rig) {
+      rig.undecapitate();
+      // meshDolly.visible = true;
+    }
+  };
+  mesh.onAfterRender2 = () => {
+    if (rig && session) {
+      rig.decapitate();
+      // meshDolly.visible = false;
+    }
+  };
+
+  return mesh;
+})();
+scene.add(mirrorMesh);
+
+const userHeight = 1.7;
+const _getHeightFactor = rigHeight => rigHeight / userHeight;
+
+let rig = null;
+let model = null;
+let modelUrl = '';
+let heightFactor = 0;
+const _setLocalModel = newModel => {
+  if (rig) {
+    meshDolly.remove(model.scene);
+    rig.destroy();
+    rig = null;
+    model = null;
+  }
+
+  model = newModel;
+  rig = new Avatar(newModel, {
+    fingers: true,
+    hair: true,
+    visemes: true,
+    // decapitate: true,
+    microphoneMediaStream,
+  });
+  meshDolly.add(model.scene);
+  window.model = newModel;
+
+  heightFactor = _getHeightFactor(rig.height);
+
+  scene.scale.set(1, 1, 1);
+  /* mirrorMesh.position.z = -heightFactor;
+  mirrorMesh.scale.set(1, 1, 1).multiplyScalar(heightFactor);
+  for (let i = 0; i < teleportMeshes.length; i++) {
+    teleportMeshes[i].scale.set(1, 1, 1).multiplyScalar(heightFactor);
+  }
+  scene.updateMatrixWorld();
+  mirrorMesh.update(); */
+  scene.scale.divideScalar(heightFactor);
+};
+
+const lastPresseds = [false, false];
+const lastBs = [false, false];
+const lastPads = [false, false];
+const lastPositions = [new THREE.Vector3(), new THREE.Vector3()];
+const startGripPositions = [new THREE.Vector3(), new THREE.Vector3()];
+const startSceneMatrix = new THREE.Matrix4();
+let startModelScale = 1;
+const dateOffset = Math.floor(Math.random() * 60 * 1000);
+const realDateNow = (now => () => dateOffset + now())(Date.now);
+function animate(timestamp, frame, referenceSpace) {
+  if (rig) {
+    if (renderer.vr.enabled) {
+      const vrCameras = renderer.vr.getCamera(camera).cameras;
+      const vrCamera = vrCameras[0];
+      const vrCamera2 = vrCameras[1];
+      vrCamera.matrixWorld.decompose(vrCamera.position, vrCamera.quaternion, vrCamera.scale);
+      vrCamera2.matrixWorld.decompose(vrCamera2.position, vrCamera2.quaternion, vrCamera2.scale);
+      vrCamera.position.add(vrCamera2.position).divideScalar(2);
+      const {inputSources} = session;
+      const gamepads = navigator.getGamepads();
+
+      rig.inputs.hmd.position.copy(vrCamera.position).sub(scene.position).multiplyScalar(heightFactor);
+      rig.inputs.hmd.quaternion.copy(vrCamera.quaternion);
+
+      const _getGamepad = i => {
+        const handedness = i === 0 ? 'left' : 'right';
+        const inputSource = inputSources.find(inputSource => inputSource.handedness === handedness);
+        let pose, gamepad;
+        if (inputSource && (pose = frame.getPose(inputSource.gripSpace, referenceSpace)) && (gamepad = inputSource.gamepad || gamepads[i])) {
+          const {transform} = pose;
+          const {position, orientation, matrix} = transform;
+          if (position) { // new WebXR api
+            const rawP = localVector.copy(position);
+            const p = localVector2.copy(rawP).sub(scene.position).multiplyScalar(heightFactor);
+            const q = localQuaternion.copy(orientation);
+            const pressed = gamepad.buttons[0].pressed;
+            const lastPressed = lastPresseds[i];
+            const pointer = gamepad.buttons[0].value;
+            const grip = gamepad.buttons[1].value;
+            const pad = gamepad.axes[1] <= -0.5 || gamepad.axes[3] <= -0.5;
+            const padX = gamepad.axes[0] !== 0 ? gamepad.axes[0] : gamepad.axes[2];
+            const padY = gamepad.axes[1] !== 0 ? gamepad.axes[1] : gamepad.axes[3];
+            const stick = !!gamepad.buttons[3] && gamepad.buttons[3].pressed;
+            const a = !!gamepad.buttons[4] && gamepad.buttons[4].pressed;
+            const b = !!gamepad.buttons[5] && gamepad.buttons[5].pressed;
+            const lastB = lastBs[i];
+            return {
+              rawPosition: rawP,
+              position: p,
+              quaternion: q,
+              pressed,
+              lastPressed,
+              pointer,
+              grip,
+              pad,
+              padX,
+              padY,
+              stick,
+              a,
+              b,
+              lastB,
+            };
+          } else if (matrix) { // old WebXR api
+            const rawP = localVector;
+            const p = localVector2;
+            const q = localQuaternion;
+            const s = localVector3;
+            localMatrix
+              .fromArray(transform.matrix)
+              .decompose(rawP, q, s);
+            p.copy(rawP).sub(scene.position).multiplyScalar(heightFactor);
+            const pressed = gamepad.buttons[0].pressed;
+            const lastPressed = lastPresseds[i];
+            const pointer = gamepad.buttons[0].value;
+            const grip = gamepad.buttons[1].value;
+            const pad = gamepad.axes[1] <= -0.5 || gamepad.axes[3] <= -0.5;
+            const padX = gamepad.axes[0] !== 0 ? gamepad.axes[0] : gamepad.axes[2];
+            const padY = gamepad.axes[1] !== 0 ? gamepad.axes[1] : gamepad.axes[3];
+            const stick = !!gamepad.buttons[3] && gamepad.buttons[3].pressed;
+            const a = !!gamepad.buttons[4] && gamepad.buttons[4].pressed;
+            const b = !!gamepad.buttons[5] && gamepad.buttons[5].pressed;
+            const lastB = lastBs[i];
+            return {
+              rawPosition: rawP,
+              position: p,
+              quaternion: q,
+              pressed,
+              lastPressed,
+              pointer,
+              grip,
+              pad,
+              padX,
+              padY,
+              stick,
+              a,
+              b,
+              lastB,
+            };
+          } else {
+            return null;
+          }
+        } else {
+          return null;
+        }
+      };
+      const _updateTeleportMesh = (i, pad, lastPad, position, quaternion, padX, padY, stick) => {
+        const teleportMesh = teleportMeshes[i];
+        teleportMesh.visible = false;
+
+        if (pad) {
+          localVector.copy(vrCamera.position).applyMatrix4(localMatrix.getInverse(scene.matrix));
+          localEuler.setFromQuaternion(quaternion, 'YXZ');
+
+          for (let i = 0; i < 20; i++, localVector.add(localVector2), localEuler.x = Math.max(localEuler.x - Math.PI*0.07, -Math.PI/2)) {
+            localRay.set(localVector, localVector2.set(0, 0, -1).applyQuaternion(localQuaternion.setFromEuler(localEuler)));
+            const intersection = localRay.intersectPlane(floorPlane, localVector3);
+            if (intersection && intersection.distanceTo(localRay.origin) <= 1) {
+              teleportMesh.position.copy(intersection);
+              localEuler.setFromQuaternion(localQuaternion, 'YXZ');
+              localEuler.x = 0;
+              localEuler.z = 0;
+              teleportMesh.quaternion.setFromEuler(localEuler);
+              teleportMesh.visible = true;
+              break;
+            }
+          }
+        } else if (lastPad) {
+          localVector.copy(teleportMesh.position).applyMatrix4(scene.matrix).sub(vrCamera.position);
+          localVector.y = 0;
+          scene.position.sub(localVector);
+        }
+
+        if (padX !== 0 || padY !== 0) {
+          localVector.set(padX, 0, padY);
+          const moveLength = localVector.length();
+          if (moveLength > 1) {
+            localVector.divideScalar(moveLength);
+          }
+          const hmdEuler = localEuler.setFromQuaternion(rig.inputs.hmd.quaternion, 'YXZ');
+          localEuler.x = 0;
+          localEuler.z = 0;
+          scene.position.sub(localVector.multiplyScalar(walkSpeed * (stick ? 3 : 1) * rig.height).applyEuler(hmdEuler));
+        }
+      };
+
+      const wasLastBd = lastBs[0] && lastBs[1];
+
+      const lg = _getGamepad(1);
+      let li = -1;
+      if (lg) {
+        const {rawPosition, position, quaternion, pressed, lastPressed, pointer, grip, pad, b} = lg;
+        rig.inputs.leftGamepad.quaternion.copy(quaternion);
+        rig.inputs.leftGamepad.position.copy(position);
+        rig.inputs.leftGamepad.pointer = pointer;
+        rig.inputs.leftGamepad.grip = grip;
+
+        li = mirrorMesh.getButtonIntersectionIndex(position);
+        if (pressed && !lastPressed) {
+          if (li !== -1) {
+            aAvatars[li].click();
+          }
+        }
+
+        _updateTeleportMesh(0, pad, lastPads[0], position, quaternion, 0, 0, false);
+
+        lastPresseds[0] = pressed;
+        lastPads[0] = pad;
+        lastBs[0] = b;
+        lastPositions[0].copy(rawPosition);
+      }
+      const rg = _getGamepad(0);
+      let ri = -1;
+      if (rg) {
+        const {rawPosition, position, quaternion, pressed, lastPressed, pointer, grip, pad, padX, padY, stick, b} = rg;
+        rig.inputs.rightGamepad.quaternion.copy(quaternion);
+        rig.inputs.rightGamepad.position.copy(position);
+        rig.inputs.rightGamepad.pointer = pointer;
+        rig.inputs.rightGamepad.grip = grip;
+
+        ri = mirrorMesh.getButtonIntersectionIndex(position);
+        if (pressed && !lastPressed) {
+          if (ri !== -1) {
+            aAvatars[ri].click();
+          }
+        }
+
+        _updateTeleportMesh(1, false, false, position, quaternion, padX, padY, stick);
+
+        lastPresseds[1] = pressed;
+        lastPads[1] = pad;
+        lastBs[1] = b;
+        lastPositions[1].copy(rawPosition);
+      }
+
+      const _startScale = () => {
+        for (let i = 0; i < startGripPositions.length; i++) {
+          startGripPositions[i].copy(lastPositions[i]);
+        }
+        startSceneMatrix.copy(scene.matrix);
+        startModelScale = rig ? rig.inputs.hmd.scaleFactor : 1;
+      };
+      const _processScale = () => {
+        const startDistance = startGripPositions[0].distanceTo(startGripPositions[1]);
+        const currentDistance = lastPositions[0].distanceTo(lastPositions[1]);
+        const scaleFactor = currentDistance / startDistance;
+
+        let startGripPosition = localVector3.copy(startGripPositions[0]).add(startGripPositions[1]).divideScalar(2)
+          /* .divideScalar(heightFactor)
+          .add(scene.position); */
+        let currentGripPosition = localVector4.copy(lastPositions[0]).add(lastPositions[1]).divideScalar(2)
+          /* .divideScalar(heightFactor)
+          .add(scene.position); */
+        startGripPosition.applyMatrix4(localMatrix.getInverse(startSceneMatrix));
+        currentGripPosition.applyMatrix4(localMatrix/*.getInverse(startSceneMatrix)*/);
+
+        const positionDiff = localVector5.copy(currentGripPosition).sub(startGripPosition);
+
+        scene.matrix.copy(startSceneMatrix)
+          .multiply(localMatrix.makeTranslation(currentGripPosition.x, currentGripPosition.y, currentGripPosition.z))
+          .multiply(localMatrix.makeScale(scaleFactor, scaleFactor, scaleFactor))
+          .multiply(localMatrix.makeTranslation(-currentGripPosition.x, -currentGripPosition.y, -currentGripPosition.z))
+          .multiply(localMatrix.makeTranslation(positionDiff.x, positionDiff.y, positionDiff.z))
+          .decompose(scene.position, scene.quaternion, scene.scale);
+
+        if (rig) {
+          rig.inputs.hmd.scaleFactor = startModelScale / scaleFactor;
+        }
+
+        // _startScale();
+      };
+      const isLastBd = lastBs[0] && lastBs[1];
+      if (!wasLastBd && isLastBd) {
+        _startScale();
+      } else if (isLastBd) {
+        _processScale();
+      }
+
+      for (let i = 0; i < mirrorMesh.buttonMeshes.length; i++) {
+        mirrorMesh.buttonMeshes[i].material.color.setHex((i === li || i === ri) ? colors.highlight : colors.normal);
+      }
+    } else if (controlsBound) {
+      localEuler.setFromQuaternion(rig.inputs.hmd.quaternion, 'YXZ');
+      localEuler.x = Math.min(Math.max(localEuler.x - mouse.movementY * 0.01, -Math.PI/2), Math.PI/2);
+      localEuler.y -= mouse.movementX * 0.01
+      localEuler.z = 0;
+      rig.inputs.hmd.quaternion.setFromEuler(localEuler);
+      mouse.movementX = 0;
+      mouse.movementY = 0;
+
+      localEuler.setFromQuaternion(rig.inputs.hmd.quaternion, 'YXZ');
+      localEuler.x = 0;
+      localEuler.z = 0;
+      const floorRotation = localQuaternion.setFromEuler(localEuler);
+
+      localVector.set(0, 0, 0);
+      if (keys.left) {
+        localVector.x += -1;
+      }
+      if (keys.right) {
+        localVector.x += 1;
+      }
+      if (keys.up) {
+        localVector.z += -1;
+      }
+      if (keys.down) {
+        localVector.z += 1;
+      }
+      rig.inputs.hmd.position.add(localVector.normalize().multiplyScalar(walkSpeed * (keys.shift ? 3 : 1) * rig.height).applyQuaternion(floorRotation));
+      if (keys.space) {
+        const lerpFactor = 0.3;
+        rig.inputs.hmd.position.y = rig.inputs.hmd.position.y * (1-lerpFactor) + rig.height*1.1 * lerpFactor;
+      } else if (keys.z) {
+        const lerpFactor = 0.05;
+        rig.inputs.hmd.position.y = rig.inputs.hmd.position.y * (1-lerpFactor) + rig.height*0.2 * lerpFactor;
+      } else if (keys.c) {
+        const lerpFactor = 0.2;
+        rig.inputs.hmd.position.y = rig.inputs.hmd.position.y * (1-lerpFactor) + rig.height*0.7 * lerpFactor;
+      } else {
+        const lerpFactor = 0.3;
+        rig.inputs.hmd.position.y = rig.inputs.hmd.position.y * (1-lerpFactor) + rig.height*0.9 * lerpFactor;
+      }
+
+      rig.inputs.leftGamepad.position.copy(rig.inputs.hmd.position)
+        .add(localVector.set(0.15, -0.15, -0.2).multiplyScalar(rig.height).applyQuaternion(rig.inputs.hmd.quaternion));
+      rig.inputs.leftGamepad.quaternion.copy(rig.inputs.hmd.quaternion)
+        .multiply(localQuaternion2.setFromAxisAngle(localVector.set(1, 0, 0), Math.PI*0.5));
+      rig.inputs.rightGamepad.position.copy(rig.inputs.hmd.position)
+        .add(localVector.set(-0.15, -0.15, -0.2).multiplyScalar(rig.height).applyQuaternion(rig.inputs.hmd.quaternion));
+      rig.inputs.rightGamepad.quaternion.copy(rig.inputs.hmd.quaternion)
+        .multiply(localQuaternion2.setFromAxisAngle(localVector.set(1, 0, 0), Math.PI*0.5))
+
+      if (controlsBound === 'firstperson') {
+        rig.outputs.eyes.matrixWorld.decompose(camera.position, camera.quaternion, localVector);
+        camera.position.divideScalar(heightFactor).add(scene.position);
+        camera.quaternion.multiply(z180Quaternion);
+        rig.decapitate();
+      } else if (controlsBound === 'thirdperson') {
+        rig.outputs.eyes.matrixWorld.decompose(camera.position, camera.quaternion, localVector);
+        camera.position.divideScalar(heightFactor).add(scene.position);
+        camera.quaternion.multiply(z180Quaternion);
+        camera.position.add(localVector.set(0, 0.5, 2).applyQuaternion(camera.quaternion));
+        rig.undecapitate();
+      } else {
+        rig.undecapitate();
+      }
+    } else {
+      const positionOffset = Math.sin((realDateNow()%10000)/10000*Math.PI*2)*2;
+      const positionOffset2 = -Math.sin((realDateNow()%5000)/5000*Math.PI*2)*1;
+      const standFactor = rig.height - 0.1*rig.height + Math.sin((realDateNow()%2000)/2000*Math.PI*2)*0.2*rig.height;
+      const rotationAngle = (realDateNow()%5000)/5000*Math.PI*2;
+
+      // rig.inputs.hmd.position.set(positionOffset, 0.6 + standFactor, 0);
+      rig.inputs.hmd.position.set(positionOffset, standFactor, positionOffset2);
+      rig.inputs.hmd.quaternion.setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationAngle)
+        .multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.sin((realDateNow()%2000)/2000*Math.PI*2)*Math.PI*0.2))
+        .multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), Math.sin((realDateNow()%2000)/2000*Math.PI*2)*Math.PI*0.25));
+
+      rig.inputs.rightGamepad.quaternion.setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationAngle)
+        // .multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.sin((realDateNow()%5000)/5000*Math.PI*2)*Math.PI*0.6));
+      rig.inputs.rightGamepad.position.set(positionOffset, rig.height*0.7 + Math.sin((realDateNow()%2000)/2000*Math.PI*2)*0.1, positionOffset2).add(
+        new THREE.Vector3(-rig.shoulderWidth/2, 0, -0.2).applyQuaternion(rig.inputs.rightGamepad.quaternion)
+      )/*.add(
+        new THREE.Vector3(-0.1, 0, -1).normalize().multiplyScalar(rig.rightArmLength*0.4).applyQuaternion(rig.inputs.rightGamepad.quaternion)
+      ); */
+      rig.inputs.leftGamepad.quaternion.setFromAxisAngle(new THREE.Vector3(0, 1, 0), rotationAngle);
+      rig.inputs.leftGamepad.position.set(positionOffset, rig.height*0.7, positionOffset2).add(
+        new THREE.Vector3(rig.shoulderWidth/2, 0, -0.2).applyQuaternion(rig.inputs.leftGamepad.quaternion)
+      )/*.add(
+        new THREE.Vector3(0.1, 0, -1).normalize().multiplyScalar(rig.leftArmLength*0.4).applyQuaternion(rig.inputs.leftGamepad.quaternion)
+      );*/
+
+      rig.inputs.leftGamepad.pointer = (Math.sin((Date.now()%10000)/10000*Math.PI*2) + 1) / 2;
+      rig.inputs.leftGamepad.grip = (Math.sin((Date.now()%10000)/10000*Math.PI*2) + 1) / 2;
+
+      rig.inputs.rightGamepad.pointer = (Math.sin((Date.now()%10000)/10000*Math.PI*2) + 1) / 2;
+      rig.inputs.rightGamepad.grip = (Math.sin((Date.now()%10000)/10000*Math.PI*2) + 1) / 2;
+    }
+
+    rig.update();
+
+    for (const k in meshes) {
+      const mesh = meshes[k];
+      const output = rig.outputs[k];
+      /* if (!mesh || !output) {
+        console.warn('bad k', k);
+      } */
+      mesh.matrix.copy(output.matrixWorld).decompose(mesh.position, mesh.quaternion, mesh.scale);
+    }
+  }
+
+  for (let i = 0; i < peerConnections.length; i++) {
+    const peerConnection = peerConnections[i];
+    if (peerConnection.rig) {
+      peerConnection.rig.update();
+    }
+  }
+
+  /* if (rig) {
+    rig.decapitate();
+  } */
+
+  renderer.render(scene, camera);
+
+  /* if (rig) {
+    rig.undecapitate();
+  } */
+}
+renderer.setAnimationLoop(animate);
+
+const mouse = {
+  movementX: 0,
+  movementY: 0,
+};
+const keys = {
+  up: false,
+  down: false,
+  left: false,
+  right: false,
+  z: false,
+  c: false,
+  space: false,
+  shift: false,
+};
+let controlsBound = null;
+let unbindControls = null;
+window.document.addEventListener('pointerlockchange', () => {
+  if (!window.document.pointerLockElement && unbindControls) {
+    unbindControls();
+    unbindControls = null;
+  }
+});
+
+const _bindControls = type => {
+  const _keydown = e => {
+    switch (e.which) {
+      case 65: {
+        keys.left = true;
+        break;
+      }
+      case 68: {
+        keys.right = true;
+        break;
+      }
+      case 87: {
+        keys.up = true;
+        break;
+      }
+      case 83: {
+        keys.down = true;
+        break;
+      }
+      case 90: {
+        keys.z = true;
+        break;
+      }
+      case 67: {
+        keys.c = true;
+        break;
+      }
+      case 32: {
+        keys.space = true;
+        break;
+      }
+      case 16: {
+        keys.shift = true;
+        break;
+      }
+    }
+  };
+  window.addEventListener('keydown', _keydown);
+  const _keyup = e => {
+    switch (e.which) {
+      case 65: {
+        keys.left = false;
+        break;
+      }
+      case 68: {
+        keys.right = false;
+        break;
+      }
+      case 87: {
+        keys.up = false;
+        break;
+      }
+      case 83: {
+        keys.down = false;
+        break;
+      }
+      case 90: {
+        keys.z = false;
+        break;
+      }
+      case 67: {
+        keys.c = false;
+        break;
+      }
+      case 32: {
+        keys.space = false;
+        break;
+      }
+      case 16: {
+        keys.shift = false;
+        break;
+      }
+    }
+  };
+  window.addEventListener('keyup', _keyup);
+  const _mousemove = e => {
+    mouse.movementX += e.movementX;
+    mouse.movementY += e.movementY;
+  };
+  window.addEventListener('mousemove', _mousemove);
+  orbitControls.enabled = false;
+  controlsBound = type;
+
+  unbindControls = () => {
+    window.addEventListener('keydown', _keydown);
+    window.addEventListener('keyup', _keyup);
+    window.removeEventListener('mousemove', _mousemove);
+    orbitControls.target.copy(camera.position).add(new THREE.Vector3(0, 0, -3).applyQuaternion(camera.quaternion));
+    orbitControls.enabled = true;
+    controlsBound = null;
+  };
+};
+const firstpersonButton = document.getElementById('firstperson-button');
+firstpersonButton.addEventListener('click', async () => {
+  if (rig) {
+    await renderer.domElement.requestPointerLock();
+    _bindControls('firstperson');
+  }
+});
+const thirdpersonButton = document.getElementById('thirdperson-button');
+thirdpersonButton.addEventListener('click', async () => {
+  if (rig) {
+    await renderer.domElement.requestPointerLock();
+    _bindControls('thirdperson');
+  }
+});
+
+let session = null;
+const enterXrButton = document.getElementById('enter-xr-button');
+const noXrButton = document.getElementById('no-xr-button');
+enterXrButton.addEventListener('click', async () => {
+  session = await navigator.xr.requestSession('immersive-vr', {
+    requiredFeatures: ['local-floor'],
+  });
+  /* if (model) {
+    meshDolly.visible = false;
+  } */
+  let referenceSpace;
+  let referenceSpaceType = '';
+  const _loadReferenceSpace = async () => {
+    const lastReferenceSpaceType = referenceSpaceType;
+    try {
+      referenceSpace = await session.requestReferenceSpace('local-floor');
+      referenceSpaceType = 'local-floor';
+    } catch (err) {
+      referenceSpace = await session.requestReferenceSpace('local');
+      referenceSpaceType = 'local';
+    }
+
+    if (referenceSpaceType !== lastReferenceSpaceType) {
+      console.log(`referenceSpace changed to ${referenceSpaceType}`);
+    }
+  };
+  await _loadReferenceSpace();
+  const loadReferenceSpaceInterval = setInterval(_loadReferenceSpace, 1000);
+
+  renderer.vr.setSession(session);
+
+  session.requestAnimationFrame((timestamp, frame) => {
+    const pose = frame.getViewerPose(referenceSpace);
+    const viewport = session.renderState.baseLayer.getViewport(pose.views[0]);
+    // const width = viewport.width;
+    const height = viewport.height;
+    const fullWidth = (() => {
+      let result = 0;
+      for (let i = 0; i < pose.views.length; i++) {
+        result += session.renderState.baseLayer.getViewport(pose.views[i]).width;
+      }
+      return result;
+    })();
+    renderer.setSize(fullWidth, height);
+    renderer.setPixelRatio(1);
+
+    renderer.setAnimationLoop(null);
+
+    renderer.vr.enabled = true;
+    renderer.vr.setSession(session);
+    renderer.vr.setAnimationLoop(animate);
+
+    console.log('loaded root in XR');
+  });
+});
+
+let microphoneMediaStream = null;
+const enableMicButton = document.getElementById('enable-mic-button');
+const disableMicButton = document.getElementById('disable-mic-button');
+enableMicButton.addEventListener('click', async () => {
+  try {
+    microphoneMediaStream  = await navigator.mediaDevices.getUserMedia({
+      audio: true,
+    });
+
+    rig.setMicrophoneMediaStream(microphoneMediaStream);
+    if (channelConnection) {
+      channelConnection.setMicrophoneMediaStream(microphoneMediaStream);
+    }
+
+    disableMicButton.style.display = null;
+    enableMicButton.style.display = 'none';
+  } catch (err) {
+    console.warn(err);
+  }
+});
+disableMicButton.addEventListener('click', async () => {
+  rig.setMicrophoneMediaStream(null);
+  if (channelConnection) {
+    channelConnection.setMicrophoneMediaStream(null);
+  }
+  microphoneMediaStream.getAudioTracks().forEach(track => {
+    track.stop();
+  });
+
+  microphoneMediaStream = null;
+  enableMicButton.style.display = null;
+  disableMicButton.style.display = 'none';
+
+  /* try {
+    await navigator.permissions.revoke({
+      name: 'microphone',
+    });
+  } catch(err) {
+    console.warn(err);
+  } */
+});
+
+let channelConnection = null;
+const peerConnections = [];
+const _sendAllPeerConnections = s => {
+  for (let i = 0; i < peerConnections.length; i++) {
+    peerConnections[i].send(s);
+  }
+};
+const channelInput = document.getElementById('channel-input');
+const connectButton = document.getElementById('connect-button');
+connectButton.addEventListener('click', () => {
+  const channelInputValue = channelInput.value;
+  const match = channelInputValue.match(/^(.+?)\/(.+?)$/);
+  if (match) {
+    const userName = match[1];
+    const channelName = match[2];
+
+    console.log(`connecting to ${userName}/${channelName}`);
+
+    channelConnection = new XRChannelConnection(`wss://presence.exokit.org/?u=${encodeURIComponent(userName)}&c=${encodeURIComponent(channelName)}`, {
+      microphoneMediaStream,
+    });
+    channelConnection.addEventListener('open', () => {
+      console.log('xr channel open');
+    });
+    channelConnection.addEventListener('error', err => {
+      console.warn('xr channel error', err);
+    });
+    channelConnection.addEventListener('peerconnection', e => {
+      const peerConnection = e.detail;
+
+      peerConnection.model = null;
+      peerConnection.rig = null;
+      peerConnection.mediaStream = null;
+      let updateInterval = 0;
+      peerConnection.addEventListener('open', () => {
+        console.log('add peer connection', peerConnection);
+
+        peerConnections.push(peerConnection);
+
+        peerConnection.send(JSON.stringify({
+          method: 'model',
+          url: modelUrl,
+        }));
+
+        updateInterval = setInterval(() => {
+          if (rig) {
+            const hmd = {
+              position: localVector.copy(rig.inputs.hmd.position).divideScalar(heightFactor).toArray(),
+              quaternion: rig.inputs.hmd.quaternion.toArray(),
+              scaleFactor: rig.inputs.hmd.scaleFactor,
+            };
+            const gamepads = [
+              {
+                position: localVector.copy(rig.inputs.leftGamepad.position).divideScalar(heightFactor).toArray(),
+                quaternion: rig.inputs.leftGamepad.quaternion.toArray(),
+                pointer: rig.inputs.leftGamepad.pointer,
+                grip: rig.inputs.leftGamepad.grip,
+                visible: true,
+              },
+              {
+                position: localVector.copy(rig.inputs.rightGamepad.position).divideScalar(heightFactor).toArray(),
+                quaternion: rig.inputs.rightGamepad.quaternion.toArray(),
+                pointer: rig.inputs.rightGamepad.pointer,
+                grip: rig.inputs.rightGamepad.grip,
+                visible: true,
+              },
+            ];
+            peerConnection.update(hmd, gamepads);
+          }
+        }, peerPoseUpdateRate);
+      });
+      peerConnection.addEventListener('close', () => {
+        console.log('remove peer connection', peerConnection);
+
+        const index = peerConnections.indexOf(peerConnection);
+        if (index !== -1) {
+          peerConnections.splice(index, 1);
+        }
+
+        clearInterval(updateInterval);
+
+        if (peerConnection.model) {
+          scene.remove(peerConnection.model.scene);
+        }
+      });
+      peerConnection.addEventListener('pose', e => {
+        const {rig} = peerConnection;
+        if (rig) {
+          const {detail: data} = e;
+          const {hmd, gamepads} = data;
+
+          rig.starts.hmd.position.copy(peerConnection.rig.inputs.hmd.position);
+          rig.starts.hmd.rotation.copy(peerConnection.rig.inputs.hmd.quaternion);
+          rig.starts.hmd.scaleFactor = peerConnection.rig.inputs.hmd.scaleFactor;
+          rig.starts.gamepads[0].position.copy(peerConnection.rig.inputs.leftGamepad.position);
+          rig.starts.gamepads[0].rotation.copy(peerConnection.rig.inputs.leftGamepad.quaternion);
+          rig.starts.gamepads[0].pointer = peerConnection.rig.inputs.leftGamepad.pointer;
+          rig.starts.gamepads[0].grip = peerConnection.rig.inputs.leftGamepad.grip;
+          rig.starts.gamepads[1].position.copy(peerConnection.rig.inputs.rightGamepad.position);
+          rig.starts.gamepads[1].rotation.copy(peerConnection.rig.inputs.rightGamepad.quaternion);
+          rig.starts.gamepads[1].pointer = peerConnection.rig.inputs.rightGamepad.pointer;
+          rig.starts.gamepads[1].grip = peerConnection.rig.inputs.rightGamepad.grip;
+
+          rig.targets.hmd.position.fromArray(hmd.position);
+          rig.targets.hmd.rotation.fromArray(hmd.quaternion);
+          rig.targets.hmd.scaleFactor = hmd.scaleFactor;
+          rig.targets.gamepads[0].position.fromArray(gamepads[0].position);
+          rig.targets.gamepads[0].rotation.fromArray(gamepads[0].quaternion);
+          rig.targets.gamepads[0].pointer = gamepads[0].pointer;
+          rig.targets.gamepads[0].grip = gamepads[0].grip;
+          rig.targets.gamepads[1].position.fromArray(gamepads[1].position);
+          rig.targets.gamepads[1].rotation.fromArray(gamepads[1].quaternion);
+          rig.targets.gamepads[1].pointer = gamepads[1].pointer;
+          rig.targets.gamepads[1].grip = gamepads[1].grip;
+          rig.targets.timestamp = Date.now();
+        }
+      });
+      peerConnection.addEventListener('mediastream', e => {
+        console.log('got media stream', e.detail, e.detail.getAudioTracks());
+        peerConnection.mediaStream = e.detail;
+        if (peerConnection.rig) {
+          peerConnection.rig.setMicrophoneMediaStream(peerConnection.mediaStream, {
+            muted: false,
+          });
+        }
+      });
+      peerConnection.addEventListener('message', async e => {
+        console.log('got message', e);
+        const data = JSON.parse(e.data);
+        const {method} = data;
+        if (method === 'model') {
+          const {url} = data;
+          console.log('got peer model', {url});
+
+          if (peerConnection.model) {
+            scene.remove(peerConnection.model.scene);
+            peerConnection.rig.destroy();
+          }
+
+          peerConnection.model = await _loadModelUrl(url);
+          peerConnection.rig = new Avatar(peerConnection.model, {
+            fingers: true,
+            hair: true,
+            visemes: true,
+            microphoneMediaStream: peerConnection.mediaStream,
+            muted: false,
+          });
+          scene.add(peerConnection.model.scene);
+
+          peerConnection.rig.starts = {
+            hmd: {
+              position: peerConnection.rig.inputs.hmd.position.clone(),
+              rotation: peerConnection.rig.inputs.hmd.quaternion.clone(),
+              scaleFactor: peerConnection.rig.inputs.hmd.scaleFactor,
+            },
+            gamepads: [
+              {
+                position: peerConnection.rig.inputs.leftGamepad.position.clone(),
+                rotation:  peerConnection.rig.inputs.leftGamepad.quaternion.clone(),
+                pointer: peerConnection.rig.inputs.leftGamepad.pointer,
+                grip: peerConnection.rig.inputs.leftGamepad.grip,
+              },
+              {
+                position: peerConnection.rig.inputs.rightGamepad.position.clone(),
+                rotation: peerConnection.rig.inputs.rightGamepad.quaternion.clone(),
+                pointer: peerConnection.rig.inputs.rightGamepad.pointer,
+                grip: peerConnection.rig.inputs.rightGamepad.grip,
+              },
+            ],
+          };
+          peerConnection.rig.targets = {
+            hmd: {
+              position: new THREE.Vector3(),
+              rotation: new THREE.Quaternion(),
+              scaleFactor: 1,
+            },
+            gamepads: [
+              {
+                position: new THREE.Vector3(),
+                rotation: new THREE.Quaternion(),
+                pointer: 0,
+                grip: 0,
+              },
+              {
+                position: new THREE.Vector3(),
+                rotation: new THREE.Quaternion(),
+                pointer: 0,
+                grip: 0,
+              },
+            ],
+            timestamp: Date.now(),
+          };
+          const heightFactor = _getHeightFactor(peerConnection.rig.height);
+          peerConnection.rig.update = (_update => function update() {
+            const now = Date.now();
+            const {timestamp} = peerConnection.rig.targets;
+            const lerpFactor = Math.min(Math.max((now - timestamp) / (peerPoseUpdateRate*2), 0), 1);  
+
+            peerConnection.rig.inputs.hmd.quaternion.copy(peerConnection.rig.starts.hmd.rotation).slerp(peerConnection.rig.targets.hmd.rotation, lerpFactor);
+            peerConnection.rig.inputs.hmd.position.copy(peerConnection.rig.starts.hmd.position).lerp(
+              localVector.copy(peerConnection.rig.targets.hmd.position).multiplyScalar(heightFactor),
+              lerpFactor
+            );
+            peerConnection.rig.inputs.hmd.scaleFactor = peerConnection.rig.starts.hmd.scaleFactor * (1-lerpFactor) + peerConnection.rig.targets.hmd.scaleFactor * lerpFactor;
+
+            peerConnection.rig.inputs.leftGamepad.position.copy(peerConnection.rig.starts.gamepads[0].position).lerp(
+              localVector.copy(peerConnection.rig.targets.gamepads[0].position).multiplyScalar(heightFactor),
+              lerpFactor
+            );
+            peerConnection.rig.inputs.leftGamepad.quaternion.copy(peerConnection.rig.starts.gamepads[0].rotation).slerp(peerConnection.rig.targets.gamepads[0].rotation, lerpFactor);
+            peerConnection.rig.inputs.leftGamepad.pointer = peerConnection.rig.starts.gamepads[0].pointer * (1-lerpFactor) + peerConnection.rig.targets.gamepads[0].pointer * lerpFactor;
+            peerConnection.rig.inputs.leftGamepad.grip = peerConnection.rig.starts.gamepads[0].grip * (1-lerpFactor) + peerConnection.rig.targets.gamepads[0].grip * lerpFactor;
+
+            peerConnection.rig.inputs.rightGamepad.position.copy(peerConnection.rig.starts.gamepads[1].position).lerp(
+              localVector.copy(peerConnection.rig.targets.gamepads[1].position).multiplyScalar(heightFactor),
+              lerpFactor
+            );
+            peerConnection.rig.inputs.rightGamepad.quaternion.copy(peerConnection.rig.starts.gamepads[1].rotation).slerp(peerConnection.rig.targets.gamepads[1].rotation, lerpFactor);
+            peerConnection.rig.inputs.rightGamepad.pointer = peerConnection.rig.starts.gamepads[1].pointer * (1-lerpFactor) + peerConnection.rig.targets.gamepads[1].pointer * lerpFactor;
+            peerConnection.rig.inputs.rightGamepad.grip = peerConnection.rig.starts.gamepads[1].grip * (1-lerpFactor) + peerConnection.rig.targets.gamepads[1].grip * lerpFactor;
+
+            _update.apply(this, arguments);
+          })(peerConnection.rig.update);
+        } else {
+          console.warn('invalid method', {method});
+        }
+      });
+    });
+
+    connectButton.style.display = 'none';
+  } else {
+    console.warn(`invalid user/channel: ${channelInputValue}`);
+  }
+});
+
+(async () => {
+  let result;
+  if (navigator.xr) {
+    try {
+      await navigator.xr.supportsSession('immersive-vr');
+      result = true;
+    } catch (err) {
+      console.warn(err);
+      result = false;
+    }
+  } else {
+    result = false;
+  }
+  if (result) {
+    console.log('xr available');
+    enterXrButton.style.display = null;
+  } else {
+    console.log('no xr');
+    noXrButton.style.display = null;
+  }
+
+  /* const microphonePermission = await navigator.permissions.query({
+    name: 'microphone',
+  });
+  if (microphonePermission.state === 'granted') {
+    microphoneMediaStream  = await navigator.mediaDevices.getUserMedia({
+      audio: true,
+    });
+    disableMicButton.style.display = null;
+  } else {
+    enableMicButton.style.display = null;
+  } */
+  enableMicButton.style.display = null;
+
+  const url = aAvatars[0].href;
+  const model = await _loadModelUrl(url);
+  _setLocalModel(model);
+  modelUrl = url;
+  _sendAllPeerConnections(JSON.stringify({
+    method: 'model',
+    url: modelUrl,
+  }));
+})();
+
+let loginToken = null;
+const loginUrl = 'https://login.exokit.org/';
+async function doLogin(email, code) {
+  const res = await fetch(`${loginUrl}?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code)}`, {
+    method: 'POST',
+  });
+  if (res.status >= 200 && res.status < 300) {
+    const newLoginToken = await res.json();
+
+    await storage.set('loginToken', newLoginToken);
+
+    loginToken = newLoginToken;
+
+    // loginNameStatic.innerText = loginToken.name;
+    // loginEmailStatic.innerText = loginToken.email;
+
+    document.body.classList.add('logged-in');
+    loginForm.classList.remove('phase-1');
+    loginForm.classList.remove('phase-2');
+    loginForm.classList.add('phase-3');
+
+    return true;
+  } else {
+    return false;
+  }
+}
+const storage = {
+  async get(k) {
+    const s = localStorage.getItem(k);
+    if (typeof s === 'string') {
+      return JSON.parse(s);
+    } else {
+      return undefined;
+    }
+  },
+  async set(k, v) {
+    localStorage.setItem(k, JSON.stringify(v));
+  },
+  async remove(k) {
+    localStorage.removeItem(k);
+  },
+};
+
+// const loginButton = document.getElementById('login-button');
+// const loginButton2 = document.getElementById('login-button-2');
+// const loginPopdown = document.getElementById('login-popdown');
+const loginForm = document.getElementById('login-form');
+const loginEmail = document.getElementById('login-email');
+const loginNameStatic = document.getElementById('login-name-static');
+const loginEmailStatic = document.getElementById('login-email-static');
+const statusNotConnected = document.getElementById('status-not-connected');
+const statusConnected = document.getElementById('status-connected');
+const loginVerificationCode = document.getElementById('login-verification-code');
+const loginNotice = document.getElementById('login-notice');
+const loginError = document.getElementById('login-error');
+const logoutButton = document.getElementById('logout-button');
+loginForm.onsubmit = async e => {
+  e.preventDefault();
+
+  if (loginForm.classList.contains('phase-1') && loginEmail.value) {
+    loginNotice.innerHTML = '';
+    loginError.innerHTML = '';
+    loginForm.classList.remove('phase-1');
+
+    const res = await fetch(`${loginUrl}?email=${encodeURIComponent(loginEmail.value)}`, {
+      method: 'POST',
+    })
+    if (res.status >= 200 && res.status < 300) {
+      loginNotice.innerText = `Code sent to ${loginEmail.value}!`;
+      loginForm.classList.add('phase-2');
+
+      return res.blob();
+    } else if (res.status === 403) {
+      loginError.innerText = `${loginEmail.value} is not in the beta yet :(`;
+
+      loginForm.classList.add('phase-1');
+    } else {
+      throw new Error(`invalid status code: ${res.status}`);
+    }
+  } else if (loginForm.classList.contains('phase-2') && loginEmail.value && loginVerificationCode.value) {
+    loginNotice.innerHTML = '';
+    loginError.innerHTML = '';
+    loginForm.classList.remove('phase-2');
+
+    await doLogin(loginEmail.value, loginVerificationCode.value);
+  } else if (loginForm.classList.contains('phase-3')) {
+    await storage.remove('loginToken');
+
+    window.location.reload();
+
+    /* loginToken = null;
+    xrEngine.postMessage({
+      method: 'login',
+      loginToken,
+    });
+
+    loginNotice.innerHTML = '';
+    loginError.innerHTML = '';
+    document.body.classList.remove('logged-in');
+    loginForm.classList.remove('phase-3');
+    loginForm.classList.add('phase-1'); */
+  }
+};
+
+const exportModelButton = document.getElementById('export-model-button');
+exportModelButton.addEventListener('click', async () => {
+  const ab = await model.export();
+  const b = new Blob([ab], {type: 'model/gltf-binary'});
+  const u = URL.createObjectURL(b);
+
+  const a = document.createElement('a');
+  a.download = 'model.glb';
+  a.href = u;
+  a.style.display = 'none';
+  document.body.appendChild(a);
+  a.click();
+
+  document.body.removeChild(a);
+  URL.revokeObjectURL(u);
+});
+
+const scaleDownButton = document.getElementById('scale-down-button');
+scaleDownButton.addEventListener('click', () => {
+  const scaleFactor = 1.25;
+
+  const orbitControlsTarget = localVector.copy(orbitControls.target);
+  scene.matrix
+    .multiply(localMatrix.makeTranslation(orbitControlsTarget.x, orbitControlsTarget.y, orbitControlsTarget.z))
+    .multiply(localMatrix.makeScale(scaleFactor, scaleFactor, scaleFactor))
+    .multiply(localMatrix.makeTranslation(-orbitControlsTarget.x, -orbitControlsTarget.y, -orbitControlsTarget.z))
+    .decompose(scene.position, scene.quaternion, scene.scale);
+
+  if (rig) {
+    rig.inputs.hmd.scaleFactor /= scaleFactor;
+  }
+});
+const scaleUpButton = document.getElementById('scale-up-button');
+scaleUpButton.addEventListener('click', () => {
+  const scaleFactor = 1/1.25;
+
+  const orbitControlsTarget = localVector.copy(orbitControls.target);
+  scene.matrix
+    .multiply(localMatrix.makeTranslation(orbitControlsTarget.x, orbitControlsTarget.y, orbitControlsTarget.z))
+    .multiply(localMatrix.makeScale(scaleFactor, scaleFactor, scaleFactor))
+    .multiply(localMatrix.makeTranslation(-orbitControlsTarget.x, -orbitControlsTarget.y, -orbitControlsTarget.z))
+    .decompose(scene.position, scene.quaternion, scene.scale);
+
+  if (rig) {
+    rig.inputs.hmd.scaleFactor /= scaleFactor;
+  }
+});
+
+(async () => {
+  const localLoginToken = await storage.get('loginToken');
+  if (localLoginToken) {
+    const res = await fetch(`${loginUrl}?email=${encodeURIComponent(localLoginToken.email)}&token=${encodeURIComponent(localLoginToken.token)}`, {
+      method: 'POST',
+    })
+    if (res.status >= 200 && res.status < 300) {
+      loginToken = await res.json();
+
+      await storage.set('loginToken', loginToken);
+
+      // loginNameStatic.innerText = loginToken.name;
+      // loginEmailStatic.innerText = loginToken.email;
+
+      document.body.classList.add('logged-in');
+      loginForm.classList.remove('phase-1');
+      loginForm.classList.remove('phase-2');
+      loginForm.classList.add('phase-3');
+    } else {
+      await storage.remove('loginToken');
+
+      console.warn(`invalid status code: ${res.status}`);
+    }
+  }
+})();
+
+window.addEventListener('resize', e => {
+  camera.aspect = window.innerWidth / window.innerHeight;
+  camera.updateProjectionMatrix();
+});
+    </script>
+  </body>
+</html>
diff --git a/vrarmik/ArmTransforms.js b/vrarmik/ArmTransforms.js
new file mode 100644
index 0000000..e0f9b5e
--- /dev/null
+++ b/vrarmik/ArmTransforms.js
@@ -0,0 +1,15 @@
+class ArmTransforms
+	{
+		constructor() {
+      this.transform = new THREE.Object3D();
+			this.upperArm = new THREE.Object3D();
+			this.lowerArm = new THREE.Object3D();
+			this.hand = new THREE.Object3D();
+
+      this.transform.add(this.upperArm);
+			this.upperArm.add(this.lowerArm);
+			this.lowerArm.add(this.hand);
+		}
+	}
+
+export default ArmTransforms;
diff --git a/vrarmik/LegsManager.js b/vrarmik/LegsManager.js
new file mode 100644
index 0000000..ce3ec53
--- /dev/null
+++ b/vrarmik/LegsManager.js
@@ -0,0 +1,458 @@
+import {Helpers} from './Unity.js';
+
+const stepRate = 0.2;
+const stepHeight = 0.2;
+const stepMinDistance = 0;
+const stepMaxDistance = 0.25;
+const stepRestitutionDistance = 0.8;
+// const minStepDistanceTimeFactor = 0.2;
+const minHmdVelocityTimeFactor = 0.015;
+// const velocityLearningFactor = 1;
+const maxVelocity = 0.015;
+const velocityRestitutionFactor = 25;
+const crossStepFactor = 0.9;
+
+const zeroVector = new THREE.Vector3();
+const oneVector = new THREE.Vector3(1, 1, 1);
+const identityRotation = new THREE.Quaternion();
+const downHalfRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), -Math.PI/2);
+const upHalfRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI/2);
+const downJumpRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), -Math.PI/4);
+// const downQuarterRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), -Math.PI/4);
+
+const localVector = new THREE.Vector3();
+const localVector2 = new THREE.Vector3();
+const localVector3 = new THREE.Vector3();
+const localVector4 = new THREE.Vector3();
+const localVector5 = new THREE.Vector3();
+const localVector6 = new THREE.Vector3();
+const localVector7 = new THREE.Vector3();
+const localQuaternion = new THREE.Quaternion();
+const localQuaternion2 = new THREE.Quaternion();
+const localQuaternion3 = new THREE.Quaternion();
+const localEuler = new THREE.Euler();
+const localMatrix = new THREE.Matrix4();
+const localMatrix2 = new THREE.Matrix4();
+const localMatrix3 = new THREE.Matrix4();
+
+const _mod = (a, n) => (a % n + n) % n;
+const _angleDiff = (targetA, sourceA) => {
+  let a = targetA - sourceA;
+  a = _mod((a + Math.PI), Math.PI*2) - Math.PI;
+  return a;
+};
+
+class Leg {
+  constructor(legsManager, left) {
+  	this.transform = new THREE.Object3D();
+    this.upperLeg = new THREE.Object3D();
+    this.lowerLeg = new THREE.Object3D();
+    this.foot = new THREE.Object3D();
+    this.foot.stickTransform = new THREE.Object3D();
+    this.foot.startTransform = new THREE.Object3D();
+    this.foot.endTransform = new THREE.Object3D();
+    this.foot.startHmdFloorTransform = new THREE.Object3D();
+
+    this.transform.add(this.upperLeg);
+    this.upperLeg.add(this.lowerLeg);
+    this.lowerLeg.add(this.foot);
+
+    this.upperLegLength = 0;
+    this.lowerLegLength = 0;
+    this.legLength = 0;
+    this.eyesToUpperLegOffset = new THREE.Vector3();
+
+    this.legsManager = legsManager;
+    this.left = left;
+
+    this.standing = true;
+    this.standFactor = 1;
+    const now = Date.now();
+    this.lastStandTimestamp = now;
+    this.lastJumpTimestamp = now;
+
+    this.stepping = false;
+    this.lastStepTimestamp = now;
+
+    this.balance = 1;
+  }
+
+  Start() {
+    this.upperLegLength = this.lowerLeg.position.length();
+    this.lowerLegLength = this.foot.position.length();
+    this.legLength = this.upperLegLength + this.lowerLegLength;
+
+    Helpers.getWorldPosition(this.upperLeg, this.eyesToUpperLegOffset)
+  	  .sub(Helpers.getWorldPosition(this.legsManager.rig.shoulderTransforms.eyes, localVector));
+  }
+
+  Update() {
+    const footPosition = localVector.copy(this.foot.stickTransform.position);
+    // footPosition.y = 0;
+    const upperLegPosition = Helpers.getWorldPosition(this.upperLeg, localVector2);
+
+    const footRotation = this.foot.stickTransform.quaternion;
+    /* localEuler.setFromQuaternion(footRotation, 'YXZ');
+    localEuler.x = 0;
+    localEuler.z = 0;
+    const flatFootRotation = localQuaternion.setFromEuler(localEuler); */
+
+    const hypotenuseDistance = this.upperLegLength;
+    const verticalDistance = ((this.legsManager.rig.shoulderTransforms.prone || !this.standing) ?
+    	upperLegPosition.distanceTo(this.foot.stickTransform.position)
+    :
+      Math.abs(upperLegPosition.y - this.foot.stickTransform.position.y)
+    ) * this.upperLegLength / this.legLength;
+    const offsetDistance = hypotenuseDistance > verticalDistance ? Math.sqrt(hypotenuseDistance*hypotenuseDistance - verticalDistance*verticalDistance) : 0;
+
+    const lowerLegPosition = localVector4.copy(upperLegPosition).add(footPosition).divideScalar(2)
+      .add(
+      	localVector5.copy(footPosition).sub(upperLegPosition)
+	        .cross(localVector6.set(1, 0, 0).applyQuaternion(footRotation))
+	        .normalize()
+      		.multiplyScalar(offsetDistance)
+      );
+
+    this.upperLeg.quaternion.setFromRotationMatrix(
+      localMatrix.lookAt(
+        zeroVector,
+        localVector5.copy(upperLegPosition).sub(lowerLegPosition),
+        localVector6.set(0, 1, 0).applyQuaternion(footRotation)
+      )
+    )
+      .multiply(downHalfRotation)
+      .premultiply(Helpers.getWorldQuaternion(this.transform, localQuaternion2).inverse());
+    Helpers.updateMatrixMatrixWorld(this.upperLeg);
+
+    this.lowerLeg.quaternion.setFromRotationMatrix(
+      localMatrix.lookAt(
+        zeroVector,
+        localVector5.copy(lowerLegPosition).sub(footPosition),
+        localVector6.set(0, 0, 1).applyQuaternion(footRotation)
+      )
+    )
+      .multiply(downHalfRotation)
+      .premultiply(Helpers.getWorldQuaternion(this.upperLeg, localQuaternion2).inverse());
+    Helpers.updateMatrixMatrixWorld(this.lowerLeg);
+
+    // this.lowerLeg.position = lowerLegPosition;
+
+    // if (this.standing || this.stepping) {
+      // this.foot.position = footPosition;
+      this.foot.quaternion.copy(footRotation)
+        .multiply(downHalfRotation)
+        .premultiply(Helpers.getWorldQuaternion(this.lowerLeg, localQuaternion2).inverse());
+      Helpers.updateMatrixMatrixWorld(this.foot);
+    /* } else {
+      this.foot.quaternion.slerp(downQuarterRotation, 0.1);
+    } */
+	}
+
+	getStandFactor() {
+		return 1 - Math.pow(Math.min(Math.max(
+			(Helpers.getWorldPosition(this.legsManager.rig.shoulderTransforms.eyes, localVector).add(this.eyesToUpperLegOffset).y - this.legLength) / (this.legsManager.rig.height*0.2),
+		0), 1), 0.7);
+	}
+}
+
+class LegsManager {
+	constructor(rig) {
+    this.hips = rig.shoulderTransforms.hips;
+    this.leftLeg = new Leg(this, true);
+    this.hips.add(this.leftLeg.transform);
+    this.rightLeg = new Leg(this, false);
+    this.hips.add(this.rightLeg.transform);
+
+    this.rig = rig;
+    this.poseManager = rig.poseManager;
+
+    this.legSeparation = 0;
+    this.lastHmdPosition = new THREE.Vector3();
+
+    this.hmdVelocity = new THREE.Vector3();
+  }
+
+  Start() {
+  	this.legSeparation = Helpers.getWorldPosition(this.leftLeg.upperLeg, localVector)
+  	  .distanceTo(Helpers.getWorldPosition(this.rightLeg.upperLeg, localVector2));
+  	this.lastHmdPosition.copy(this.poseManager.vrTransforms.head.position);
+  	this.leftLeg.Start();
+  	this.rightLeg.Start();
+  }
+
+	Update() {
+		Helpers.updateMatrixWorld(this.leftLeg.transform);
+		Helpers.updateMatrixWorld(this.leftLeg.upperLeg);
+		Helpers.updateMatrixWorld(this.leftLeg.lowerLeg);
+		Helpers.updateMatrixWorld(this.leftLeg.foot);
+
+    Helpers.updateMatrixWorld(this.rightLeg.transform);
+		Helpers.updateMatrixWorld(this.rightLeg.upperLeg);
+		Helpers.updateMatrixWorld(this.rightLeg.lowerLeg);
+		Helpers.updateMatrixWorld(this.rightLeg.foot);
+
+		const now = Date.now();
+
+		/* this.hmdVelocity.multiplyScalar(1-velocityLearningFactor)
+		  .add(localVector.copy(this.poseManager.vrTransforms.head.position).sub(this.lastHmdPosition).multiplyScalar(velocityLearningFactor)); */
+		this.hmdVelocity.copy(this.poseManager.vrTransforms.head.position).sub(this.lastHmdPosition);
+		this.lastHmdPosition.copy(this.poseManager.vrTransforms.head.position);
+		// console.log('v', this.hmdVelocity.toArray().join(','));
+
+    this.leftLeg.standFactor = this.leftLeg.getStandFactor();
+	  this.leftLeg.standing = this.leftLeg.standFactor >= 1;
+	  if (this.leftLeg.standing) {
+	  	this.leftLeg.lastStandTimestamp = now;
+	  } else {
+	  	this.leftLeg.lastJumpTimestamp = now;
+	  }
+	  if (this.leftLeg.stepping && !this.leftLeg.standing) {
+      this.leftLeg.stepping = false;
+	  }
+	  this.rightLeg.standFactor = this.rightLeg.getStandFactor();
+	  this.rightLeg.standing = this.rightLeg.standFactor >= 1;
+	  if (this.rightLeg.standing) {
+	  	this.rightLeg.lastStandTimestamp = now;
+	  } else {
+	  	this.rightLeg.lastJumpTimestamp = now;
+	  }
+	  if (this.rightLeg.stepping && !this.rightLeg.standing) {
+      this.rightLeg.stepping = false;
+	  }
+
+    const hipsFloorPosition = localVector.copy(this.hips.position);
+    hipsFloorPosition.y = 0;
+    const hipsFloorEuler = localEuler.setFromQuaternion(this.hips.quaternion, 'YXZ');
+    hipsFloorEuler.x = 0;
+    hipsFloorEuler.z = 0;
+    const planeMatrix = localMatrix.compose(hipsFloorPosition, localQuaternion.setFromEuler(hipsFloorEuler), oneVector);
+    const planeMatrixInverse = localMatrix2.getInverse(planeMatrix);
+
+    const fakePosition = localVector2;
+    const fakeScale = localVector3;
+
+    const leftFootPosition = localVector4;
+    const leftFootRotation = localQuaternion;
+    localMatrix3.compose(this.leftLeg.foot.stickTransform.position, this.leftLeg.foot.stickTransform.quaternion, oneVector)
+      .premultiply(planeMatrixInverse)
+      .decompose(leftFootPosition, leftFootRotation, fakeScale);
+
+    const rightFootPosition = localVector5;
+    const rightFootRotation = localQuaternion2;
+    localMatrix3.compose(this.rightLeg.foot.stickTransform.position, this.rightLeg.foot.stickTransform.quaternion, oneVector)
+      .premultiply(planeMatrixInverse)
+      .decompose(rightFootPosition, rightFootRotation, fakeScale);
+
+    // rotation
+
+    const maxTiltAngleFactor = 0.1;
+    if (this.leftLeg.standing && !this.rig.shoulderTransforms.prone) {
+      const leftFootEuler = localEuler.setFromQuaternion(leftFootRotation, 'YXZ');
+      leftFootEuler.x = 0;
+	    leftFootEuler.z = 0;
+    	if (leftFootEuler.y < -Math.PI*maxTiltAngleFactor) {
+    		leftFootEuler.y = -Math.PI*maxTiltAngleFactor;
+    	}
+    	if (leftFootEuler.y > Math.PI*maxTiltAngleFactor) {
+    		leftFootEuler.y = Math.PI*maxTiltAngleFactor;
+    	}
+    	localMatrix3.compose(zeroVector, localQuaternion3.setFromEuler(leftFootEuler), oneVector)
+	      .premultiply(planeMatrix)
+	      .decompose(fakePosition, this.leftLeg.foot.stickTransform.quaternion, fakeScale);
+	  } else if (!this.leftLeg.standing) {
+	  	this.leftLeg.foot.stickTransform.quaternion.copy(this.hips.quaternion)
+	  	  .multiply(downJumpRotation);
+    } else {
+    	Helpers.getWorldQuaternion(this.leftLeg.foot, this.leftLeg.foot.stickTransform.quaternion)
+    	  .multiply(upHalfRotation);
+    }
+    if (this.rightLeg.standing && !this.rig.shoulderTransforms.prone) {
+	    const rightFootEuler = localEuler.setFromQuaternion(rightFootRotation, 'YXZ');
+	    rightFootEuler.x = 0;
+	    rightFootEuler.z = 0;
+    	if (rightFootEuler.y < -Math.PI*maxTiltAngleFactor) {
+    		rightFootEuler.y = -Math.PI*maxTiltAngleFactor;
+    	}
+    	if (rightFootEuler.y > Math.PI*maxTiltAngleFactor) {
+    		rightFootEuler.y = Math.PI*maxTiltAngleFactor;
+    	}
+    	localMatrix3.compose(zeroVector, localQuaternion3.setFromEuler(rightFootEuler), oneVector)
+	      .premultiply(planeMatrix)
+	      .decompose(fakePosition, this.rightLeg.foot.stickTransform.quaternion, fakeScale);
+	  } else if (!this.rightLeg.standing) {
+	  	this.rightLeg.foot.stickTransform.quaternion.copy(this.hips.quaternion)
+	  	  .multiply(downJumpRotation);
+	  } else {
+      Helpers.getWorldQuaternion(this.rightLeg.foot, this.rightLeg.foot.stickTransform.quaternion)
+        .multiply(upHalfRotation);
+	  }
+
+	  // position
+
+    const _getLegStepFactor = leg => {
+    	if (leg.stepping) {
+	      const timeDiff = now - leg.lastStepTimestamp;
+	      leg.lastStepTimestamp = now;
+
+				const scaledStepRate = stepRate
+				  /* / Math.max(
+				  	localVector.set(this.poseManager.vrTransforms.head.position.x, 0, this.poseManager.vrTransforms.head.position.z)
+				  	  .distanceTo(leg.foot.startHmdFloorTransform.position),
+				  	minStepDistanceTimeFactor
+				  ) */
+				  * Math.max(localVector2.set(this.hmdVelocity.x, 0, this.hmdVelocity.z).length() / this.rig.height, minHmdVelocityTimeFactor);
+				return Math.min(Math.max(leg.stepFactor + scaledStepRate * timeDiff, 0), 1);
+	    } else {
+	    	return 0;
+	    }
+    };
+    this.leftLeg.stepFactor = _getLegStepFactor(this.leftLeg);
+    this.rightLeg.stepFactor = _getLegStepFactor(this.rightLeg);
+
+    const leftCanStep = this.leftLeg.standing && !this.leftLeg.stepping && (!this.rightLeg.stepping || this.rightLeg.stepFactor >= crossStepFactor);
+    const rightCanStep = this.rightLeg.standing && !this.rightLeg.stepping && (!this.leftLeg.stepping || this.leftLeg.stepFactor >= crossStepFactor);
+    const maxStepAngleFactor = 0;
+    if (leftCanStep || rightCanStep) {
+    	let leftStepDistance = 0;
+    	let leftStepAngleDiff = 0;
+	    if (leftCanStep) {
+	    	const leftDistance = Math.sqrt(leftFootPosition.x*leftFootPosition.x + leftFootPosition.z*leftFootPosition.z);
+				const leftAngleDiff = Math.atan2(leftFootPosition.x, leftFootPosition.z);
+				if (leftDistance < this.rig.height*stepMinDistance) {
+					leftStepDistance = leftDistance;
+				} else if (leftDistance > this.rig.height*stepMaxDistance) {
+					leftStepDistance = leftDistance;
+				}
+				if (leftAngleDiff > -Math.PI*maxStepAngleFactor) {
+					leftStepAngleDiff = leftAngleDiff;
+				} else if (leftAngleDiff < -Math.PI+Math.PI*maxStepAngleFactor) {
+					leftStepAngleDiff = leftAngleDiff;
+				}
+			}
+			let rightStepDistance = 0;
+    	let rightStepAngleDiff = 0;
+			if (rightCanStep) {
+				const rightDistance = Math.sqrt(rightFootPosition.x*rightFootPosition.x + rightFootPosition.z*rightFootPosition.z);
+				const rightAngleDiff = Math.atan2(rightFootPosition.x, rightFootPosition.z);
+		    if (rightDistance < this.rig.height*stepMinDistance) {
+		    	rightStepDistance = rightDistance;
+		    } else if (rightDistance > this.rig.height*stepMaxDistance) {
+		    	rightStepDistance = rightDistance;
+		    }
+		    if (rightAngleDiff < Math.PI*maxStepAngleFactor) {
+		    	rightStepAngleDiff = rightAngleDiff;
+		    } else if (rightAngleDiff > Math.PI-Math.PI*maxStepAngleFactor) {
+					rightStepAngleDiff = rightAngleDiff;
+				}
+			}
+
+      const _stepLeg = leg => {
+        const footDistance = this.legSeparation*stepRestitutionDistance;//Math.min(Math.max(leftStepDistance, this.legSeparation*0.7), this.legSeparation*1.4);
+
+				leg.foot.startTransform.position.copy(leg.foot.stickTransform.position);
+        // leg.foot.startTransform.quaternion.copy(leg.foot.stickTransform.quaternion);
+
+			  leg.foot.endTransform.position.copy(hipsFloorPosition)
+				  .add(localVector6.set((leg.left ? -1 : 1) * footDistance, 0, 0).applyQuaternion(leg.foot.stickTransform.quaternion));
+				const velocityVector = localVector6.set(this.hmdVelocity.x, 0, this.hmdVelocity.z);
+				const velocityVectorLength = velocityVector.length();
+				if (velocityVectorLength > maxVelocity*this.rig.height) {
+          velocityVector.multiplyScalar(maxVelocity*this.rig.height / velocityVectorLength);
+				}
+				velocityVector.multiplyScalar(velocityRestitutionFactor);
+				leg.foot.endTransform.position.add(velocityVector);
+			  // leg.foot.endTransform.quaternion.copy(this.rightLeg.foot.stickTransform.quaternion);
+
+			  leg.foot.startHmdFloorTransform.position.set(this.poseManager.vrTransforms.head.position.x, 0, this.poseManager.vrTransforms.head.position.z);
+
+        leg.lastStepTimestamp = now;
+        leg.stepping = true;
+			};
+
+			if (
+				(leftStepDistance !== 0 || leftStepAngleDiff !== 0) &&
+				(rightStepDistance === 0 || Math.abs(leftStepDistance*this.leftLeg.balance) >= Math.abs(rightStepDistance*this.rightLeg.balance)) &&
+				(rightStepAngleDiff === 0 || Math.abs(leftStepAngleDiff*this.leftLeg.balance) >= Math.abs(rightStepAngleDiff*this.rightLeg.balance))
+			) {
+				_stepLeg(this.leftLeg);
+        this.leftLeg.balance = 0;
+        this.rightLeg.balance = 1;
+			} else if (rightStepDistance !== 0  || rightStepAngleDiff !== 0) {
+				_stepLeg(this.rightLeg);
+      	this.rightLeg.balance = 0;
+        this.leftLeg.balance = 1;
+			}
+		}
+
+    if (this.rig.shoulderTransforms.prone) {
+    	const targetPosition = Helpers.getWorldPosition(this.leftLeg.upperLeg, localVector6)
+        .add(
+        	localVector7.set(0, -this.leftLeg.legLength*0.95, 0)
+        	  .applyQuaternion(this.hips.quaternion)
+        );
+      targetPosition.y = 0;
+    	this.leftLeg.foot.stickTransform.position.lerp(targetPosition, 0.1);
+
+    	this.leftLeg.stepping = false;
+    } else if (this.leftLeg.stepping) {
+      this.leftLeg.foot.stickTransform.position.copy(this.leftLeg.foot.startTransform.position)
+        .lerp(this.leftLeg.foot.endTransform.position, this.leftLeg.stepFactor)
+        .add(localVector6.set(0, Math.sin(this.leftLeg.stepFactor*Math.PI) * stepHeight * this.rig.height, 0));
+
+      if (this.leftLeg.stepFactor >= 1) {
+      	this.leftLeg.stepping = false;
+      }
+		} else if (!this.leftLeg.standing) {
+      const targetPosition = Helpers.getWorldPosition(this.leftLeg.upperLeg, localVector6)
+        .add(
+        	localVector7.set(0, 0, 1)
+            .normalize()
+        	  .applyQuaternion(this.hips.quaternion)
+        	  .multiplyScalar(this.leftLeg.legLength*0.5)
+        );
+      this.leftLeg.foot.stickTransform.position.lerp(targetPosition, 0.1);
+		} else {
+			const targetPosition = localVector6.copy(this.leftLeg.foot.stickTransform.position);
+			targetPosition.y = 0;
+			this.leftLeg.foot.stickTransform.position.lerp(targetPosition, 0.2);
+		}
+		if (this.rig.shoulderTransforms.prone) {
+    	const targetPosition = Helpers.getWorldPosition(this.rightLeg.upperLeg, localVector6)
+        .add(
+        	localVector7.set(0, -this.rightLeg.legLength*0.95, 0)
+        	  .applyQuaternion(this.hips.quaternion)
+        );
+      targetPosition.y = 0;
+    	this.rightLeg.foot.stickTransform.position.lerp(targetPosition, 0.1);
+
+    	this.rightLeg.stepping = false;
+		} else if (this.rightLeg.stepping) {
+      this.rightLeg.foot.stickTransform.position.copy(this.rightLeg.foot.startTransform.position)
+        .lerp(this.rightLeg.foot.endTransform.position, this.rightLeg.stepFactor)
+        .add(localVector6.set(0, Math.sin(this.rightLeg.stepFactor*Math.PI) * stepHeight * this.rig.height, 0));
+      // this.rightLeg.foot.stickTransform.quaternion.copy(this.rightLeg.foot.startTransform.quaternion).slerp(this.rightLeg.foot.endTransform.quaternion, stepFactor);
+
+      if (this.rightLeg.stepFactor >= 1) {
+      	this.rightLeg.stepping = false;
+      }
+		} else if (!this.rightLeg.standing) {
+      const targetPosition = Helpers.getWorldPosition(this.rightLeg.upperLeg, localVector6)
+        .add(
+        	localVector7.set(0, 0, 1)
+        	  .normalize()
+        	  .applyQuaternion(this.hips.quaternion)
+        	  .multiplyScalar(this.rightLeg.legLength*0.6)
+        );
+      this.rightLeg.foot.stickTransform.position.lerp(targetPosition, 0.1);
+		} else {
+			const targetPosition = localVector6.copy(this.rightLeg.foot.stickTransform.position);
+			targetPosition.y = 0;
+			this.rightLeg.foot.stickTransform.position.lerp(targetPosition, 0.2);
+		}
+
+		this.leftLeg.Update();
+		this.rightLeg.Update();
+  }
+}
+
+export default LegsManager;
diff --git a/vrarmik/PoseManager.js b/vrarmik/PoseManager.js
new file mode 100644
index 0000000..0c43d53
--- /dev/null
+++ b/vrarmik/PoseManager.js
@@ -0,0 +1,84 @@
+import VRTrackingReferences from './VRTrackingReferences.js';
+
+class PoseManager
+	{
+		constructor(rig) {
+			this.vrTransforms = new VRTrackingReferences();
+		  // this.OnCalibrateListener = null;
+
+      // Oculus uses a different reference position -> 0 is the reference head position if the user is standing in the middle of the room. 
+      // In OpenVR, the 0 position is the ground position and the user is then at (0, playerHeightHmd, 0) if he is in the middle of the room, so I need to correct this for shoulder calculation 
+      // this.vrSystemOffsetHeight = 0.0;
+
+			this.referencePlayerHeightHmd = 1.7;
+			this.referencePlayerWidthWrist = 1.39;
+			this.playerHeightHmd = 1.70;
+			this.playerWidthWrist = 1.39;
+			// this.playerWidthShoulders = 0.31;
+      // this.loadPlayerSizeOnAwake = false;
+
+      // PoseManager.Instance = this;
+    }
+
+		/* OnEnable()
+		{
+			if (PoseManager.Instance === null)
+			{
+				PoseManager.Instance = this;
+			}
+			else if (PoseManager.Instance !== null)
+			{
+				Debug.LogError("Multiple Instances of PoseManager in Scene");
+			}
+		} */
+
+		/* Start()
+		{
+      if (this.loadPlayerSizeOnAwake)
+      {
+          this.loadPlayerSize();
+      }
+      // this.vrSystemOffsetHeight = 0;
+
+			onCalibrate += OnCalibrate;
+		}
+
+		OnCalibrate()
+		{
+			this.playerHeightHmd = Camera.main.transform.position.y;
+		}
+
+		loadPlayerWidthShoulders()
+		{
+			this.playerWidthShoulders = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthShoulders", 0.31);
+		}
+
+		savePlayerWidthShoulders(width)
+		{
+			PlayerPrefs.SetFloat("VRArmIK_PlayerWidthShoulders", width);
+		}
+
+		calibrateIK()
+		{
+			this.playerWidthWrist = this.vrTransforms.leftHand.position.clone().sub(this.vrTransforms.rightHand.position).magnitude;
+			this.playerHeightHmd = this.vrTransforms.hmd.position.y;
+			this.savePlayerSize(this.playerHeightHmd, this.playerWidthWrist);
+		}
+
+		savePlayerSize(heightHmd, widthWrist)
+		{
+			PlayerPrefs.SetFloat("VRArmIK_PlayerHeightHmd", this.heightHmd);
+			PlayerPrefs.SetFloat("VRArmIK_PlayerWidthWrist", this.widthWrist);
+			this.loadPlayerSize();
+			this.onCalibrate && this.onCalibrate.Invoke();
+		}
+
+		loadPlayerSize()
+		{
+			this.playerHeightHmd = PlayerPrefs.GetFloat("VRArmIK_PlayerHeightHmd", this.referencePlayerHeightHmd);
+			this.playerWidthWrist = PlayerPrefs.GetFloat("VRArmIK_PlayerWidthWrist", this.referencePlayerWidthWrist);
+		} */
+	}
+	// PoseManager.Instance = null;
+
+export default PoseManager;
diff --git a/vrarmik/ShoulderPoser.js b/vrarmik/ShoulderPoser.js
new file mode 100644
index 0000000..27ef53c
--- /dev/null
+++ b/vrarmik/ShoulderPoser.js
@@ -0,0 +1,438 @@
+import {Helpers} from './Unity.js';
+
+const rightVector = new THREE.Vector3(1, 0, 0);
+const z180Quaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
+
+const localVector = new THREE.Vector3();
+const localVector2 = new THREE.Vector3();
+const localVector3 = new THREE.Vector3();
+const localVector4 = new THREE.Vector3();
+const localQuaternion = new THREE.Quaternion();
+const localQuaternion2 = new THREE.Quaternion();
+const localQuaternion3 = new THREE.Quaternion();
+const localEuler = new THREE.Euler();
+const localEuler2 = new THREE.Euler();
+
+class ShoulderPoser
+	{
+		constructor(rig, shoulder) {
+			this.rig = rig;
+			this.shoulder = shoulder;
+			this.poseManager = rig.poseManager;
+			this.vrTransforms = this.poseManager.vrTransforms;
+
+      // this.headNeckDirectionVector = new Vector3(1.0894440904962721e-10, -0.06860782711996793, -0.0006757629250115499).normalize();
+			// this.headNeckDistance = 0.06861115505261682;
+			// this.neckShoulderDistance = new Vector3(3.122724301363178e-10, -0.1953215129534993, 0.02834002902116923);
+
+			// this.maxDeltaHeadRotation = 80;
+
+			// this.distinctShoulderRotationLimitForward = 33;
+
+			// this.distinctShoulderRotationLimitBackward = 0;
+
+			// this.distinctShoulderRotationLimitUpward = 33;
+			// this.distinctShoulderRotationMultiplier = 30;
+
+	  	// this.rightRotationStartHeight = 0;
+			// this.rightRotationHeightFactor = 142;
+			// this.rightRotationHeadRotationFactor = 0.3;
+			// this.rightRotationHeadRotationOffset = -20;
+
+			// this.startShoulderDislocationBefore = 0.005;
+
+			// this.ignoreYPos = true;
+		  // this.autoDetectHandsBehindHead = true;
+			// this.clampRotationToHead = true;
+		  // this.enableDistinctShoulderRotation = true;
+			// this.enableShoulderDislocation = true;
+
+
+			// this.handsBehindHead = false;
+
+			// this.clampingHeadRotation = false;
+			// this.shoulderDislocated = false;
+			// this.shoulderRightRotation;
+
+			// this.lastAngle = Vector3.zero;
+
+			// this.leftShoulderAnkerStartLocalPosition = new Vector3();
+			// this.rightShoulderAnkerStartLocalPosition = new Vector3();
+		}
+
+		/* Start() {
+			this.leftShoulderAnkerStartLocalPosition = this.shoulder.leftShoulderAnchor.localPosition.clone();
+			this.rightShoulderAnkerStartLocalPosition = this.shoulder.rightShoulderAnchor.position.clone();
+		} */
+
+		/* onCalibrate()
+		{
+			this.shoulder.leftArm.setArmLength((avatarTrackingReferences.leftHand.position - this.shoulder.leftShoulderAnchor.position)
+				.magnitude);
+			this.shoulder.rightArm.setArmLength((avatarTrackingReferences.rightHand.position - this.shoulder.rightShoulderAnchor.position)
+				.magnitude);
+		} */
+
+		Update()
+		{
+      this.shoulder.proneFactor = this.getProneFactor();
+      this.shoulder.prone = this.shoulder.proneFactor > 0;
+      if (this.shoulder.prone) {
+        this.shoulder.lastProneTimestamp = Date.now();
+      } else {
+        this.shoulder.lastStandTimestamp = Date.now();
+      }
+
+      this.updateHips();
+
+			// this.shoulder.transform.rotation = Quaternion.identity;
+			// this.positionShoulder();
+			this.rotateShoulderBase();
+
+			/* if (this.enableDistinctShoulderRotation)
+			{
+				this.rotateLeftShoulder(rotation);
+				this.rotateRightShoulder(rotation);
+			} */
+
+			/* if (this.enableShoulderDislocation)
+			{
+				this.clampShoulderHandDistance();
+			}
+			else
+			{
+				this.shoulder.leftArm.transform.localPosition = Vector3.zero;
+				this.shoulder.rightArm.transform.localPosition = Vector3.zero;
+			} */
+
+			this.updateNeck();
+
+			// Debug.DrawRay(this.shoulder.transform.position, this.shoulder.transform.forward);
+		}
+
+		/* updateHips() {
+		  const hmdRotation = localQuaternion.copy(this.vrTransforms.head.quaternion)
+        .multiply(z180Quaternion);
+      const hmdEuler = localEuler.setFromQuaternion(hmdRotation, 'YXZ');
+      hmdEuler.x = 0;
+      hmdEuler.z = 0;
+      const hmdFlatRotation = localQuaternion2.setFromEuler(hmdEuler);
+
+      const headPosition = localVector.copy(this.vrTransforms.head.position)
+        .add(localVector2.copy(this.shoulder.eyes.position).multiplyScalar(-1).applyQuaternion(hmdRotation));
+		  const neckPosition = headPosition.add(localVector2.copy(this.shoulder.head.position).multiplyScalar(-1).applyQuaternion(hmdRotation));
+		  const chestPosition = neckPosition.add(localVector2.copy(this.shoulder.neck.position).multiplyScalar(-1).applyQuaternion(hmdFlatRotation));
+		  const spinePosition = chestPosition.add(localVector2.copy(this.shoulder.transform.position).multiplyScalar(-1).applyQuaternion(hmdFlatRotation));
+		  const hipsPosition = spinePosition.add(localVector2.copy(this.shoulder.spine.position).multiplyScalar(-1).applyQuaternion(hmdFlatRotation));
+
+      this.shoulder.hips.position.copy(hipsPosition);
+      this.shoulder.hips.quaternion.copy(hmdFlatRotation);
+      Helpers.updateMatrix(this.shoulder.hips);
+      this.shoulder.hips.matrixWorld.copy(this.shoulder.hips.matrix);
+      Helpers.updateMatrixWorld(this.shoulder.spine);
+      Helpers.updateMatrixWorld(this.shoulder.transform);
+		} */
+
+		updateHips() {
+		  const hmdRotation = localQuaternion.copy(this.vrTransforms.head.quaternion)
+        .multiply(z180Quaternion);
+      /* const hmdXYRotation = localQuaternion2.setFromRotationMatrix(localMatrix.lookAt(
+      	new THREE.Vector3(),
+      	new THREE.Vector3(0, 0, -1).applyQuaternion(hmdRotation),
+      	new THREE.Vector3(0, 1, 0).applyQuaternion(hmdRotation)
+      )); */
+      const hmdEuler = localEuler.setFromQuaternion(hmdRotation, 'YXZ');
+      hmdEuler.x = 0;
+      hmdEuler.z = 0;
+      const hmdXYRotation = localQuaternion2.setFromEuler(hmdEuler);
+      hmdXYRotation.multiply(localQuaternion3.setFromAxisAngle(rightVector, this.shoulder.proneFactor * Math.PI/2));
+      if (!this.rig.legsManager.leftLeg.standing && !this.rig.legsManager.rightLeg.standing) {
+        const jumpFactor = 1-Math.min(this.rig.legsManager.leftLeg.standFactor, this.rig.legsManager.rightLeg.standFactor);
+        hmdXYRotation.multiply(localQuaternion3.setFromAxisAngle(rightVector, jumpFactor * Math.PI/4));
+      } else {
+      	const standFactor = Math.min(this.rig.legsManager.leftLeg.standFactor, this.rig.legsManager.rightLeg.standFactor);
+      	hmdXYRotation.multiply(localQuaternion3.setFromAxisAngle(rightVector, (1-standFactor) * Math.PI/4));
+      }
+
+      const headPosition = localVector.copy(this.vrTransforms.head.position)
+        .sub(localVector2.copy(this.shoulder.eyes.position).applyQuaternion(hmdRotation));
+		  const neckPosition = headPosition.sub(localVector2.copy(this.shoulder.head.position).applyQuaternion(hmdRotation));
+		  const chestPosition = neckPosition.sub(localVector2.copy(this.shoulder.neck.position).applyQuaternion(hmdXYRotation));
+		  const spinePosition = chestPosition.sub(localVector2.copy(this.shoulder.transform.position).applyQuaternion(hmdXYRotation));
+		  const hipsPosition = spinePosition.sub(localVector2.copy(this.shoulder.spine.position).applyQuaternion(hmdXYRotation));
+
+      this.shoulder.hips.position.copy(hipsPosition);
+      this.shoulder.hips.quaternion.copy(hmdXYRotation);
+      Helpers.updateMatrix(this.shoulder.hips);
+      this.shoulder.hips.matrixWorld.copy(this.shoulder.hips.matrix);
+      Helpers.updateMatrixWorld(this.shoulder.spine);
+      Helpers.updateMatrixWorld(this.shoulder.transform);
+		}
+
+		/* updateNeck() {
+			const hmdRotation = localQuaternion.copy(this.vrTransforms.head.quaternion)
+		    .multiply(z180Quaternion);
+      const hmdFlatEuler = localEuler.setFromQuaternion(hmdRotation, 'YXZ');
+      hmdFlatEuler.x = 0;
+      hmdFlatEuler.z = 0;
+      const hmdUpEuler = localEuler2.setFromQuaternion(hmdRotation, 'YXZ');
+      hmdUpEuler.y = 0;
+
+      this.shoulder.neck.quaternion.setFromEuler(hmdFlatEuler)
+        .premultiply(Helpers.getWorldQuaternion(this.shoulder.neck.parent, localQuaternion).inverse());
+      Helpers.updateMatrixMatrixWorld(this.shoulder.neck);
+
+      this.shoulder.head.quaternion.setFromEuler(hmdUpEuler);
+      Helpers.updateMatrixMatrixWorld(this.shoulder.head);
+
+      Helpers.updateMatrixWorld(this.shoulder.eyes);
+		} */
+
+		updateNeck() {
+			const hmdRotation = localQuaternion.copy(this.vrTransforms.head.quaternion)
+		    .multiply(z180Quaternion);
+		  /* const hmdXYRotation = localQuaternion2.setFromRotationMatrix(localMatrix.lookAt(
+      	new THREE.Vector3(),
+      	new THREE.Vector3(0, 0, -1).applyQuaternion(hmdRotation),
+      	new THREE.Vector3(0, 1, 0).applyQuaternion(hmdRotation)
+      )); */
+      const hmdEuler = localEuler.setFromQuaternion(hmdRotation, 'YXZ');
+      hmdEuler.x = 0;
+      hmdEuler.z = 0;
+      const hmdXYRotation = localQuaternion2.setFromEuler(hmdEuler);
+
+      this.shoulder.neck.quaternion.copy(hmdXYRotation)
+        .premultiply(Helpers.getWorldQuaternion(this.shoulder.neck.parent, localQuaternion3).inverse());
+      Helpers.updateMatrixMatrixWorld(this.shoulder.neck);
+
+      this.shoulder.head.quaternion.copy(hmdRotation)
+        .premultiply(Helpers.getWorldQuaternion(this.shoulder.head.parent, localQuaternion3).inverse());
+      Helpers.updateMatrixMatrixWorld(this.shoulder.head);
+
+      Helpers.updateMatrixWorld(this.shoulder.eyes);
+		}
+
+		/* rotateLeftShoulder(shoulderRotation)
+		{
+			this.rotateShoulderUp(this.shoulder.leftShoulder, this.shoulder.leftArm, this.avatarTrackingReferences.leftHand, this.leftShoulderAnkerStartLocalPosition, 1, shoulderRotation);
+		}
+
+		rotateRightShoulder(shoulderRotation)
+		{
+			this.rotateShoulderUp(this.shoulder.rightShoulder, this.shoulder.rightArm, this.avatarTrackingReferences.rightHand, this.rightShoulderAnkerStartLocalPosition, -1, shoulderRotation);
+		}
+
+		rotateShoulderUp(shoulderSide, arm, targetHand, initialShoulderLocalPos, angleSign, shoulderRotation)
+		{
+			const initialShoulderPos = initialShoulderLocalPos.clone().applyMatrix4(this.shoulder.transform.matrixWorld);
+			const handShoulderOffset = new Vector3().subVectors(targetHand.position, initialShoulderPos);
+			const armLength = arm.armLength;
+
+			const targetAngle = Vector3.zero;
+
+		  const forwardDistanceRatio = Vector3.Dot(handShoulderOffset, Vector3.forward.applyQuaternion(shoulderRotation)) / armLength;
+			const upwardDistanceRatio = Vector3.Dot(handShoulderOffset, Vector3.up.applyQuaternion(shoulderRotation)) / armLength;
+			if (forwardDistanceRatio > 0)
+			{
+				targetAngle.y = Mathf.Clamp((forwardDistanceRatio - 0.5) * this.distinctShoulderRotationMultiplier, 0, this.distinctShoulderRotationLimitForward);
+			}
+			else
+			{
+				targetAngle.y = Mathf.Clamp(-(forwardDistanceRatio + 0.08) * this.distinctShoulderRotationMultiplier * 10, -this.distinctShoulderRotationLimitBackward, 0);
+			}
+
+			targetAngle.z = Mathf.Clamp(-(upwardDistanceRatio - 0.5) * this.distinctShoulderRotationMultiplier, -this.distinctShoulderRotationLimitUpward, 0);
+
+      targetAngle.multiplyScalar(angleSign);
+
+      shoulderSide.localRotation = new THREE.Quaternion().setFromEuler(new THREE.Euler(targetAngle.x * Mathf.Deg2Rad, targetAngle.y * Mathf.Deg2Rad, targetAngle.z * Mathf.Deg2Rad, Mathf.Order));
+		}
+
+		positionShoulder()
+		{
+			const headNeckOffset = this.headNeckDirectionVector.clone().applyQuaternion(this.avatarTrackingReferences.head.rotation);
+			const targetPosition = new Vector3().addVectors(this.avatarTrackingReferences.head.position, headNeckOffset.clone().multiplyScalar(this.headNeckDistance));
+			this.shoulder.transform.localPosition =
+				new Vector3().addVectors(targetPosition, this.neckShoulderDistance);
+		} */
+
+		rotateShoulderBase()
+		{
+			const angleY = this.getCombinedDirectionAngleUp();
+
+			// const targetRotation = new Vector3(0, angle, 0);
+
+			/* if (this.autoDetectHandsBehindHead)
+			{
+				this.detectHandsBehindHead(targetRotation);
+			} */
+
+			/* if (this.clampRotationToHead)
+			{ */
+				// angleY = this.clampHeadRotationDeltaUp(angleY);
+			// }
+
+			this.shoulder.transform.quaternion.setFromEuler(localEuler.set(0, angleY, 0, 'YXZ'))
+			  .premultiply(
+			  	localQuaternion.copy(this.shoulder.hips.quaternion)
+			      .multiply(z180Quaternion)
+			  );
+			/* this.shoulder.transform.quaternion.multiply(localQuaternion3.setFromAxisAngle(rightVector, this.shoulder.proneFactor * Math.PI/2));
+			if (!this.rig.legsManager.leftLeg.standing && !this.rig.legsManager.rightLeg.standing) {
+        const jumpFactor = 1-Math.min(this.rig.legsManager.leftLeg.standFactor, this.rig.legsManager.rightLeg.standFactor);
+        this.shoulder.transform.quaternion.multiply(localQuaternion3.setFromAxisAngle(rightVector, jumpFactor * Math.PI/4));
+      } else {
+      	const standFactor = Math.min(this.rig.legsManager.leftLeg.standFactor, this.rig.legsManager.rightLeg.standFactor);
+      	this.shoulder.transform.quaternion.multiply(localQuaternion3.setFromAxisAngle(rightVector, (1-standFactor) * Math.PI/4));
+      } */
+      this.shoulder.transform.quaternion
+			  .premultiply(Helpers.getWorldQuaternion(this.shoulder.transform.parent, localQuaternion).inverse());
+			Helpers.updateMatrixMatrixWorld(this.shoulder.transform);
+      Helpers.updateMatrixWorld(this.shoulder.leftShoulderAnchor);
+      Helpers.updateMatrixWorld(this.shoulder.rightShoulderAnchor);
+		}
+
+		/* rotateShoulderRightBase(rotation)
+		{
+
+			const heightDiff = this.vrTransforms.head.position.y - this.poseManager.vrSystemOffsetHeight;
+			const relativeHeightDiff = -heightDiff / this.poseManager.playerHeightHmd;
+
+      const hmdRotation = this.vrTransforms.head.rotation;
+      hmdRotation.multiply(z180Quaternion);
+			const headRightRotation = VectorHelpers.getAngleBetween(this.shoulder.transform.forward,
+										  new Vector3(0, 0, 1).applyQuaternion(hmdRotation),
+										  Vector3.up, this.shoulder.transform.right) + this.rightRotationHeadRotationOffset;
+			const heightFactor = Mathf.Clamp(relativeHeightDiff - this.rightRotationStartHeight, 0, 1);
+			this.shoulderRightRotation = heightFactor * this.rightRotationHeightFactor;
+			this.shoulderRightRotation += Mathf.Clamp(headRightRotation * this.rightRotationHeadRotationFactor * heightFactor, 0, 50);
+
+            this.shoulderRightRotation = Mathf.Clamp(this.shoulderRightRotation, 0, 50);
+
+			const deltaRot = Quaternion.AngleAxis(this.shoulderRightRotation, this.shoulder.transform.right);
+
+
+			// this.shoulder.transform.rotation = new Quaternion().multiplyQuaternions(deltaRot,  this.shoulder.transform.rotation);
+			return new Quaternion().multiplyQuaternions(deltaRot, rotation);
+			// this.positionShoulderRelative();
+		}
+
+		positionShoulderRelative()
+		{
+			const deltaRot = Quaternion.AngleAxis(this.shoulderRightRotation, this.shoulder.transform.right);
+			const shoulderHeadDiff = new Vector3().subVectors(this.shoulder.transform.position, this.avatarTrackingReferences.head.position);
+		  // this.shoulder.transform.position = new Vector3().addVectors(shoulderHeadDiff.clone().applyQuaternion(deltaRot), this.avatarTrackingReferences.head.position);
+		} */
+
+		getCombinedDirectionAngleUp()
+		{
+			const hipsRotation = localQuaternion.copy(this.shoulder.hips.quaternion)
+        .multiply(z180Quaternion);
+			const hipsRotationInverse = localQuaternion2.copy(hipsRotation)
+			  .inverse();
+
+			const distanceLeftHand = localVector.copy(this.vrTransforms.leftHand.position)
+			  .sub(this.vrTransforms.head.position)
+			  .applyQuaternion(hipsRotationInverse);
+			const distanceRightHand = localVector2.copy(this.vrTransforms.rightHand.position)
+			  .sub(this.vrTransforms.head.position)
+			  .applyQuaternion(hipsRotationInverse);
+
+			distanceLeftHand.y = 0;
+			distanceRightHand.y = 0;
+
+			const leftBehind = distanceLeftHand.z > 0;
+			const rightBehind = distanceRightHand.z > 0;
+			if (leftBehind) {
+				distanceLeftHand.z *= rightBehind ? -2 : -1;
+			}
+			if (rightBehind) {
+				distanceRightHand.z *= leftBehind ? -2 : -1;
+			}
+
+			const combinedDirection = localVector.addVectors(distanceLeftHand.normalize(), distanceRightHand.normalize());
+			return Math.atan2(combinedDirection.x, combinedDirection.z);
+		}
+
+		getProneFactor() {
+      return 1 - Math.min(Math.max((this.vrTransforms.head.position.y - this.rig.height*0.3)/(this.rig.height*0.3), 0), 1);
+		}
+
+		/* detectHandsBehindHead(targetRotation)
+		{
+			const delta = Mathf.Abs(targetRotation.y - this.lastAngle.y + 360) % 360;
+			if (delta > 150 && delta < 210 && this.lastAngle.magnitude > 0.000001 && !this.clampingHeadRotation)
+			{
+				this.handsBehindHead = !this.handsBehindHead;
+			}
+
+			this.lastAngle = targetRotation;
+
+			if (this.handsBehindHead)
+			{
+				targetRotation.y += 180;
+			}
+		}
+
+		clampHeadRotationDeltaUp(angleY)
+		{
+			const hmdRotation = localQuaternion.copy(this.vrTransforms.head.quaternion)
+			  .multiply(z180Quaternion);
+
+			const headUpRotation = (localEuler.setFromQuaternion(hmdRotation, 'YXZ').y + Math.PI*2) % (Math.PI*2);
+			const targetUpRotation = (angleY + Math.PI*2) % (Math.PI*2);
+
+			const delta = headUpRotation - targetUpRotation;
+
+			if (delta > this.maxDeltaHeadRotation && delta < Math.PI || delta < -Math.PI && delta >= -Math.PI*2 + this.maxDeltaHeadRotation)
+			{
+				angleY = headUpRotation - this.maxDeltaHeadRotation;
+				// this.clampingHeadRotation = true;
+			}
+			else if (delta < -this.maxDeltaHeadRotation && delta > -Math.PI || delta > Math.PI && delta < Math.PI*2 - this.maxDeltaHeadRotation)
+			{
+				angleY = headUpRotation + this.maxDeltaHeadRotation;
+				// this.clampingHeadRotation = true;
+			}
+			// else
+			// {
+				// this.clampingHeadRotation = false;
+			// }
+			return angleY;
+		}
+
+		clampShoulderHandDistance()
+		{
+			const leftHandVector = new Vector3().subVectors(this.avatarTrackingReferences.leftHand.position, this.shoulder.leftShoulderAnchor.position);
+			const rightHandVector = new Vector3().subVectors(this.avatarTrackingReferences.rightHand.position, this.shoulder.rightShoulderAnchor.position);
+			const leftShoulderHandDistance = leftHandVector.magnitude;
+      const rightShoulderHandDistance = rightHandVector.magnitude;
+			this.shoulderDislocated = false;
+
+		  const startBeforeFactor = (1 - this.startShoulderDislocationBefore);
+
+			if (leftShoulderHandDistance > this.shoulder.leftArm.armLength * startBeforeFactor)
+			{
+				this.shoulderDislocated = true;
+				this.shoulder.leftArm.transform.position = new Vector3().addVectors(this.shoulder.leftShoulderAnchor.position,
+													  leftHandVector.normalized.multiplyScalar(leftShoulderHandDistance - this.shoulder.leftArm.armLength * startBeforeFactor));
+			}
+			else
+			{
+				this.shoulder.leftArm.transform.localPosition = Vector3.zero;
+			}
+
+			if (rightShoulderHandDistance > this.shoulder.rightArm.armLength * startBeforeFactor)
+			{
+				this.shoulderDislocated = true;
+				this.shoulder.rightArm.transform.position = new Vector3().addVectors(this.shoulder.rightShoulderAnchor.position,
+													   rightHandVector.normalized.multiplyScalar(rightShoulderHandDistance - this.shoulder.rightArm.armLength * startBeforeFactor));
+			}
+			else
+			{
+				this.shoulder.rightArm.transform.localPosition = Vector3.zero;
+			}
+		} */
+	}
+
+export default ShoulderPoser;
diff --git a/vrarmik/ShoulderTransforms.js b/vrarmik/ShoulderTransforms.js
new file mode 100644
index 0000000..30dcfe4
--- /dev/null
+++ b/vrarmik/ShoulderTransforms.js
@@ -0,0 +1,63 @@
+import ArmTransforms from './ArmTransforms.js';
+import ShoulderPoser from './ShoulderPoser.js';
+import VRArmIK from './VRArmIK.js';
+
+
+class ShoulderTransforms
+	{
+		constructor(rig) {
+      this.transform = new THREE.Object3D();
+      this.hips = new THREE.Object3D();
+      this.spine = new THREE.Object3D();
+      this.neck = new THREE.Object3D();
+      this.head = new THREE.Object3D();
+      this.eyes = new THREE.Object3D();
+
+      this.hips.add(this.spine);
+      this.spine.add(this.transform);
+      this.transform.add(this.neck);
+      this.neck.add(this.head);
+      this.head.add(this.eyes);
+
+			// this.leftShoulder = new THREE.Object3D();
+			// this.transform.add(this.leftShoulder);
+			// this.rightShoulder = new THREE.Object3D();
+			// this.transform.add(this.rightShoulder);
+
+			this.leftShoulderAnchor = new THREE.Object3D();
+			this.transform.add(this.leftShoulderAnchor);
+			this.rightShoulderAnchor = new THREE.Object3D();
+			this.transform.add(this.rightShoulderAnchor);
+
+			this.leftArm = new ArmTransforms();
+			this.rightArm = new ArmTransforms();
+
+			this.leftShoulderAnchor.add(this.leftArm.transform);
+			this.rightShoulderAnchor.add(this.rightArm.transform);
+
+      this.prone = false;
+      this.proneFactor = 0;
+      const now = Date.now();
+      this.lastStandTimestamp = now;
+      this.lastProneTimestamp = now;
+
+			this.shoulderPoser = new ShoulderPoser(rig, this);
+
+			this.leftArmIk = new VRArmIK(this.leftArm, this, this.shoulderPoser, this.shoulderPoser.vrTransforms.leftHand, true);
+			this.rightArmIk = new VRArmIK(this.rightArm, this, this.shoulderPoser, this.shoulderPoser.vrTransforms.rightHand, false);
+		}
+
+		Start()
+		{
+			this.leftArmIk.Start();
+			this.rightArmIk.Start();
+		}
+
+		Update() {
+			this.shoulderPoser.Update();
+			this.leftArmIk.Update();
+			this.rightArmIk.Update();
+		}
+	}
+
+export default ShoulderTransforms;
diff --git a/vrarmik/SkeletonUtils.js b/vrarmik/SkeletonUtils.js
new file mode 100644
index 0000000..fd82960
--- /dev/null
+++ b/vrarmik/SkeletonUtils.js
@@ -0,0 +1,169 @@
+/**
+* Takes in a rootBone and recursively traverses the bone heirarchy,
+* setting each bone's +Z axis to face it's child bones. The IK system follows this
+* convention, so this step is necessary to update the bindings of a skinned mesh.
+*
+* Must rebind the model to it's skeleton after this function.
+*
+* @param {THREE.Bone} rootBone
+* @param {Object} context - options and buffer for stateful bone calculations
+*                 context.exclude: [ boneNames to exclude ]
+*                 context.preRotations: { boneName: THREE.Quaternion, ... }
+*/
+
+function fixSkeletonZForward(rootBone, context) {
+  context = context || {};
+  precalculateZForwards(rootBone, context);
+  if (context.exclude) {
+    var bones = [rootBone];
+    rootBone.traverse((b) => bones.push(b));
+    bones.forEach((b) => {
+      if (~context.exclude.indexOf(b.id) || ~context.exclude.indexOf(b.name)) {
+        delete context.averagedDirs[b.id];
+      }
+    });
+  }
+  return setZForward(rootBone, context);
+}
+
+const RESETQUAT = new THREE.Quaternion();
+const Y_AXIS = new THREE.Vector3(0,1,0);
+
+/**
+* Takes in a rootBone and recursively traverses the bone heirarchy,
+* setting each bone's +Z axis to face it's child bones. The IK system follows this
+* convention, so this step is necessary to update the bindings of a skinned mesh.
+*
+* Must rebind the model to it's skeleton after this function.
+*
+* @param {THREE.BONE} rootBone
+*/
+
+function precalculateZForwards(rootBone, context) {
+  context = context || rootBone;
+  context.worldPos = context.worldPos || {};
+  context.averagedDirs = context.averagedDirs || {};
+  context.preRotations = context.preRotations || {};
+  getOriginalWorldPositions(rootBone, context.worldPos)
+  calculateAverages(rootBone, context.worldPos, context.averagedDirs);
+  return context;
+}
+
+function setZForward(rootBone, context) {
+  if (!context || !context.worldPos) {
+    context = context || {};
+    precalculateZForwards(rootBone, context);
+  }
+  updateTransformations(rootBone, context.worldPos, context.averagedDirs, context.preRotations);
+  return context;
+}
+
+function calculateAverages(parentBone, worldPos, averagedDirs) {
+  var averagedDir = new THREE.Vector3();
+  parentBone.children.forEach((childBone) => {
+    //average the child bone world pos
+    var childBonePosWorld = worldPos[childBone.id][0];
+    averagedDir.add(childBonePosWorld);
+  });
+
+  averagedDir.multiplyScalar(1/(parentBone.children.length));
+  averagedDirs[parentBone.id] = averagedDir;
+
+  parentBone.children.forEach((childBone) => {
+    calculateAverages(childBone, worldPos, averagedDirs);
+  });
+}
+
+function updateTransformations(parentBone, worldPos, averagedDirs, preRotations) {
+
+      var averagedDir = averagedDirs[parentBone.id];
+      if (averagedDir) {
+
+        //set quaternion
+        parentBone.quaternion.copy(RESETQUAT);
+        // parentBone.quaternion.premultiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI*2));
+        parentBone.updateMatrixWorld();
+
+        //get the child bone position in local coordinates
+        // var childBoneDir = parentBone.worldToLocal(averagedDir.clone()).normalize();
+
+        //set direction to face child
+        // setQuaternionFromDirection(childBoneDir, Y_AXIS, parentBone.quaternion)
+        // console.log('new quaternion', parentBone.quaternion.toArray().join(','));
+    }
+    var preRot = preRotations[parentBone.id] || preRotations[parentBone.name];
+    if (preRot) parentBone.quaternion.multiply(preRot);
+    // parentBone.quaternion.multiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI));
+    parentBone.updateMatrixWorld();
+
+    //set child bone position relative to the new parent matrix.
+    parentBone.children.forEach((childBone) => {
+      var childBonePosWorld = worldPos[childBone.id][0].clone();
+      parentBone.worldToLocal(childBonePosWorld);
+      childBone.position.copy(childBonePosWorld);
+    });
+
+    parentBone.children.forEach((childBone) => {
+      updateTransformations(childBone, worldPos, averagedDirs, preRotations);
+    });
+}
+
+//borrowing this from utils.js , not sure how to import it
+const t1 = new THREE.Vector3();
+const t2 = new THREE.Vector3();
+const t3 = new THREE.Vector3();
+const m1 = new THREE.Matrix4();
+function setQuaternionFromDirection(direction, up, target) {
+  const x = t1;
+  const y = t2;
+  const z = t3;
+  const m = m1;
+  const el = m1.elements;
+
+  z.copy(direction);
+  x.crossVectors(up, z);
+
+  if (x.lengthSq() === 0) {
+    // parallel
+    if (Math.abs(up.z) === 1) {
+      z.x += 0.0001;
+    } else {
+      z.z += 0.0001;
+    }
+    z.normalize();
+    x.crossVectors(up, z);
+  }
+
+  x.normalize();
+  y.crossVectors(z, x);
+
+  el[ 0 ] = x.x; el[ 4 ] = y.x; el[ 8 ] = z.x;
+  el[ 1 ] = x.y; el[ 5 ] = y.y; el[ 9 ] = z.y;
+  el[ 2 ] = x.z; el[ 6 ] = y.z; el[ 10 ] = z.z;
+
+  return target.setFromRotationMatrix(m);
+}
+
+function getOriginalWorldPositions(rootBone, worldPos) {
+  var rootBoneWorldPos = rootBone.getWorldPosition(new THREE.Vector3())
+  worldPos[rootBone.id] = [rootBoneWorldPos];
+  rootBone.children.forEach((child) => {
+    getOriginalWorldPositions(child, worldPos)
+  })
+}
+
+function _worldToLocalDirection(direction, parent) {
+    const inverseParent = new THREE.Matrix4().getInverse(parent.matrixWorld);
+    direction.transformDirection(inverseParent);
+  return direction;
+}
+
+function _localToWorldDirection(direction, parent) {
+  const parentMat = parent.matrixWorld;
+  direction.transformDirection(parentMat);
+  return direction;
+}
+
+export {
+  fixSkeletonZForward, setQuaternionFromDirection
+};
\ No newline at end of file
diff --git a/vrarmik/Unity.js b/vrarmik/Unity.js
new file mode 100644
index 0000000..9039b53
--- /dev/null
+++ b/vrarmik/Unity.js
@@ -0,0 +1,28 @@
+const localVector = new THREE.Vector3();
+const localVector2 = new THREE.Vector3();
+const Helpers = {
+  getWorldPosition(o, v) {
+    return v.setFromMatrixPosition(o.matrixWorld);
+  },
+  getWorldQuaternion(o, q) {
+    o.matrixWorld.decompose(localVector, q, localVector2);
+    return q;
+  },
+  getWorldScale(o, v) {
+    return v.setFromMatrixScale(o.matrixWorld);
+  },
+  updateMatrix(o) {
+    o.matrix.compose(o.position, o.quaternion, o.scale);
+  },
+  updateMatrixWorld(o) {
+    o.matrixWorld.multiplyMatrices(o.parent.matrixWorld, o.matrix);
+  },
+  updateMatrixMatrixWorld(o) {
+    o.matrix.compose(o.position, o.quaternion, o.scale);
+    o.matrixWorld.multiplyMatrices(o.parent.matrixWorld, o.matrix);
+  },
+};
+
+export {
+  Helpers,
+};
diff --git a/vrarmik/VRArmIK.js b/vrarmik/VRArmIK.js
new file mode 100644
index 0000000..452fe53
--- /dev/null
+++ b/vrarmik/VRArmIK.js
@@ -0,0 +1,130 @@
+import {Helpers} from './Unity.js';
+
+const zeroVector = new THREE.Vector3();
+const forwardVector = new THREE.Vector3(0, 0, 1);
+const leftRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI/2);
+const rightRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), -Math.PI/2);
+const bankLeftRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), Math.PI/2);
+const bankRightRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 0, 1), -Math.PI/2);
+const z180Quaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
+
+const localVector = new THREE.Vector3();
+const localVector2 = new THREE.Vector3();
+const localVector3 = new THREE.Vector3();
+const localVector4 = new THREE.Vector3();
+const localVector5 = new THREE.Vector3();
+const localVector6 = new THREE.Vector3();
+const localQuaternion = new THREE.Quaternion();
+const localQuaternion2 = new THREE.Quaternion();
+const localQuaternion3 = new THREE.Quaternion();
+const localEuler = new THREE.Euler();
+const localMatrix = new THREE.Matrix4();
+
+	class VRArmIK
+	{
+		constructor(arm, shoulder, shoulderPoser, target, left) {
+			this.arm = arm;
+			this.shoulder = shoulder;
+			this.shoulderPoser = shoulderPoser;
+			this.target = target;
+			this.left = left;
+
+			this.upperArmLength = 0;
+			this.lowerArmLength = 0;
+			this.armLength = 0;
+    }
+
+		Start()
+		{
+			this.upperArmLength = Helpers.getWorldPosition(this.arm.lowerArm, localVector).distanceTo(Helpers.getWorldPosition(this.arm.upperArm, localVector2));
+			this.lowerArmLength = Helpers.getWorldPosition(this.arm.hand, localVector).distanceTo(Helpers.getWorldPosition(this.arm.lowerArm, localVector2));
+			this.armLength = this.upperArmLength + this.lowerArmLength;
+		}
+
+		Update()
+		{
+			Helpers.updateMatrixWorld(this.arm.transform);
+			Helpers.updateMatrixWorld(this.arm.upperArm);
+
+			const upperArmPosition = Helpers.getWorldPosition(this.arm.upperArm, localVector);
+      const handRotation = this.target.quaternion;
+      const handPosition = localVector2.copy(this.target.position);
+
+      const shoulderRotation = Helpers.getWorldQuaternion(this.shoulder.transform, localQuaternion);
+      const shoulderRotationInverse = localQuaternion2.copy(shoulderRotation).inverse();
+
+      const hypotenuseDistance = this.upperArmLength;
+	    const directDistance = upperArmPosition.distanceTo(handPosition) / 2;
+      const offsetDistance = hypotenuseDistance > directDistance ? Math.sqrt(hypotenuseDistance*hypotenuseDistance - directDistance*directDistance) : 0;
+      const offsetDirection = localVector3.copy(handPosition).sub(upperArmPosition)
+        .normalize()
+        .cross(localVector4.set(-1, 0, 0).applyQuaternion(shoulderRotation));
+
+      const targetEuler = localEuler.setFromQuaternion(
+      	localQuaternion3
+      	  .multiplyQuaternions(handRotation, shoulderRotationInverse)
+      	  .premultiply(z180Quaternion),
+      	'XYZ'
+      );
+      // const targetDirection = new Vector3(0, 0, 1).applyQuaternion(targetLocalRotation);
+      if (this.left) {
+    		const yFactor = Math.min(Math.max((targetEuler.y+Math.PI*0.1)/(Math.PI/2), 0), 1);
+    		// const zFactor = Math.min(Math.max((-targetDirection.x + 0.5)/0.25, 0), 1)
+    		// const xFactor = Math.min(Math.max((targetDirection.y-0.8)/0.2, 0), 1);
+    		// yFactor *= 1-xFactor;
+    		// const factor = Math.min(yFactor, 1-xFactor);//Math.min(yFactor, 1-xFactor);
+    		targetEuler.z = Math.min(Math.max(targetEuler.z, -Math.PI/2), 0);
+    		targetEuler.z = (targetEuler.z * (1 - yFactor)) + (-Math.PI/2 * yFactor);
+    		// targetEuler.z *= 1 - xFactor;
+    		// targetEuler.z *= 1 - zFactor;
+      } else {
+      	const yFactor = Math.min(Math.max((-targetEuler.y-Math.PI*0.1)/(Math.PI/2), 0), 1);
+    		// const zFactor = Math.min(Math.max((-targetDirection.x + 0.5)/0.25, 0), 1)
+    		// const xFactor = Math.min(Math.max((targetDirection.y-0.8)/0.2, 0), 1);
+    		// yFactor *= 1-xFactor;
+    		// const factor = Math.min(yFactor, 1-xFactor);//Math.min(yFactor, 1-xFactor);
+    		targetEuler.z = Math.min(Math.max(targetEuler.z, 0), Math.PI/2);
+    		targetEuler.z = (targetEuler.z * (1 - yFactor)) + (Math.PI/2 * yFactor);
+    		// targetEuler.z *= 1 - xFactor;
+    		// targetEuler.z *= 1 - zFactor;
+      }
+      offsetDirection
+        .applyQuaternion(shoulderRotationInverse)
+        .applyAxisAngle(forwardVector, targetEuler.z)
+        .applyQuaternion(shoulderRotation);
+
+      const elbowPosition = localVector4.copy(upperArmPosition).add(handPosition).divideScalar(2)
+        .add(localVector5.copy(offsetDirection).multiplyScalar(offsetDistance));
+      const upVector = localVector5.set(this.left ? -1 : 1, 0, 0).applyQuaternion(shoulderRotation);
+      this.arm.upperArm.quaternion.setFromRotationMatrix(
+      	localMatrix.lookAt(
+	      	zeroVector,
+	      	localVector6.copy(elbowPosition).sub(upperArmPosition),
+	      	upVector
+	      )
+      )
+        .multiply(this.left ? rightRotation : leftRotation)
+        .premultiply(Helpers.getWorldQuaternion(this.arm.upperArm.parent, localQuaternion3).inverse());
+      Helpers.updateMatrixMatrixWorld(this.arm.upperArm);
+
+      // this.arm.lowerArm.position = elbowPosition;
+      this.arm.lowerArm.quaternion.setFromRotationMatrix(
+        localMatrix.lookAt(
+	      	zeroVector,
+	      	localVector6.copy(handPosition).sub(elbowPosition),
+	      	upVector
+	      )
+      )
+        .multiply(this.left ? rightRotation : leftRotation)
+        .premultiply(Helpers.getWorldQuaternion(this.arm.lowerArm.parent, localQuaternion3).inverse());
+      Helpers.updateMatrixMatrixWorld(this.arm.lowerArm);
+
+      // this.arm.hand.position = handPosition;
+      this.arm.hand.quaternion.copy(this.target.quaternion)
+        .multiply(this.left ? bankRightRotation : bankLeftRotation)
+        .premultiply(Helpers.getWorldQuaternion(this.arm.hand.parent, localQuaternion3).inverse());
+      Helpers.updateMatrixMatrixWorld(this.arm.hand);
+		}
+	}
+
+export default VRArmIK;
diff --git a/vrarmik/VRTrackingReferences.js b/vrarmik/VRTrackingReferences.js
new file mode 100644
index 0000000..c58358e
--- /dev/null
+++ b/vrarmik/VRTrackingReferences.js
@@ -0,0 +1,22 @@
+class VRTrackingReferences {
+  constructor() {
+    /* this.leftController = new Transform();
+    this.rightController = new Transform();
+    this.hmd = new Transform(); */
+    /* this.hmd.onchange = () => {
+      console.log('change 1', new Error().stack);
+    }; */
+    this.head = new THREE.Object3D();
+    this.leftHand = new THREE.Object3D();
+    this.leftHand.pointer = 0;
+    this.leftHand.grip = 0;
+    this.rightHand = new THREE.Object3D();
+    this.rightHand.pointer = 0;
+    this.rightHand.grip = 0;
+    /* this.head.onchange = () => {
+      console.log('change 2', new Error().stack);
+    }; */
+  }
+}
+
+export default VRTrackingReferences;
diff --git a/vrarmik/audio-volume-worklet.js b/vrarmik/audio-volume-worklet.js
new file mode 100644
index 0000000..3e1f4ca
--- /dev/null
+++ b/vrarmik/audio-volume-worklet.js
@@ -0,0 +1,56 @@
+const numTicks = 1;
+
+let tick = 0;
+let sampleSum = 0;
+let numSamples = 0;
+let muted = true;
+
+class VolumeProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+
+    this.port.addEventListener('message', e => {
+      const data = JSON.parse(e.data);
+      const {method} = data;
+      if (method === 'muted') {
+        muted = data.muted;
+      }
+    });
+    this.port.start();
+  }
+  process(inputs, outputs) {
+    const channels = inputs[0];
+    // const output = outputs[0];
+
+    // for (let i = 0; i < channels.length; i++) {
+      const i = 0;
+      const samples = channels[i];
+      for (let j = 0; j < samples.length; j++) {
+        sampleSum += Math.abs(samples[j]);
+      }
+      numSamples += samples.length;
+    // }
+
+    if (++tick >= numTicks) {
+      this.port.postMessage(sampleSum / numSamples);
+
+      tick = 0;
+      sampleSum = 0;
+      numSamples = 0;
+    }
+
+    if (!muted) {
+      for (let i = 0; i < outputs.length; i++) {
+        const input = inputs[i];
+        const output = outputs[i];
+
+        for (let channel = 0; channel < output.length; channel++) {
+          output[channel].set(input[channel]);
+        }
+      }
+    }
+
+    return true;
+  }
+}
+registerProcessor('volume-processor', VolumeProcessor);
\ No newline at end of file
diff --git a/vrarmik/avatars.js b/vrarmik/avatars.js
new file mode 100644
index 0000000..b727b3c
--- /dev/null
+++ b/vrarmik/avatars.js
@@ -0,0 +1,967 @@
+import './three-vrm.js';
+import {fixSkeletonZForward} from './SkeletonUtils.js';
+import PoseManager from './PoseManager.js';
+import ShoulderTransforms from './ShoulderTransforms.js';
+import LegsManager from './LegsManager.js';
+import MicrophoneWorker from './microphone-worker.js';
+
+const zeroVector = new THREE.Vector3();
+const upRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI/2);
+const leftRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI*0.8);
+const rightRotation = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), -Math.PI*0.8);
+const z180Quaternion = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI);
+
+const localVector = new THREE.Vector3();
+const localVector2 = new THREE.Vector3();
+const localVector3 = new THREE.Vector3();
+const localVector4 = new THREE.Vector3();
+const localVector5 = new THREE.Vector3();
+const localVector6 = new THREE.Vector3();
+const localQuaternion = new THREE.Quaternion();
+const localQuaternion2 = new THREE.Quaternion();
+const localMatrix = new THREE.Matrix4();
+
+const _localizeMatrixWorld = bone => {
+  bone.matrix.copy(bone.matrixWorld);
+  if (bone.parent) {
+    bone.matrix.premultiply(new THREE.Matrix4().getInverse(bone.parent.matrixWorld));
+  }
+  bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
+
+  for (let i = 0; i < bone.children.length; i++) {
+    _localizeMatrixWorld(bone.children[i]);
+  }
+};
+const _findBoneDeep = (bones, boneName) => {
+  for (let i = 0; i < bones.length; i++) {
+    const bone = bones[i];
+    if (bone.name === boneName) {
+      return bone;
+    } else {
+      const deepBone = _findBoneDeep(bone.children, boneName);
+      if (deepBone) {
+        return deepBone;
+      }
+    }
+  }
+  return null;
+};
+const _copySkeleton = (src, dst) => {
+  for (let i = 0; i < src.bones.length; i++) {
+    const srcBone = src.bones[i];
+    const dstBone = _findBoneDeep(dst.bones, srcBone.name);
+    dstBone.matrixWorld.copy(srcBone.matrixWorld);
+  }
+
+  const armature = dst.bones[0].parent;
+  _localizeMatrixWorld(armature);
+
+  dst.calculateInverses();
+};
+
+class Avatar {
+	constructor(object, options = {}) {
+    const model = object.isMesh ? object : object.scene;
+    this.model = model;
+    this.options = options;
+
+    model.updateMatrixWorld(true);
+    const skinnedMeshes = [];
+	  model.traverse(o => {
+	    if (o.isSkinnedMesh) {
+        skinnedMeshes.push(o);
+	    }
+	  });
+    skinnedMeshes.sort((a, b) => b.skeleton.bones.length - a.skeleton.bones.length);
+    this.skinnedMeshes = skinnedMeshes;
+
+    const skeletonSkinnedMesh = skinnedMeshes.find(o => o.skeleton.bones[0].parent) || null;
+    const skeleton = skeletonSkinnedMesh && skeletonSkinnedMesh.skeleton;
+    /* if (skeleton) {
+      skeletonSkinnedMesh.bind(skeleton);
+    } */
+    const poseSkeletonSkinnedMesh = skeleton ? skinnedMeshes.find(o => o.skeleton !== skeleton && o.skeleton.bones.length >= skeleton.bones.length) : null;
+    const poseSkeleton = poseSkeletonSkinnedMesh && poseSkeletonSkinnedMesh.skeleton;
+    if (poseSkeleton) {
+      _copySkeleton(poseSkeleton, skeleton);
+      poseSkeletonSkinnedMesh.bind(skeleton);
+    }
+
+    const _getTailBones = skeleton => {
+      const result = [];
+      const _recurse = bones => {
+        for (let i = 0; i < bones.length; i++) {
+          const bone = bones[i];
+          if (bone.children.length === 0) {
+            if (!result.includes(bone)) {
+              result.push(bone);
+            }
+          } else {
+            _recurse(bone.children);
+          }
+        }
+      };
+      _recurse(skeleton.bones);
+      return result;
+    };
+	  const tailBones = _getTailBones(skeleton);
+    // const tailBones = skeleton.bones.filter(bone => bone.children.length === 0);
+	  const _findClosestParentBone = (bone, pred) => {
+      for (; bone; bone = bone.parent) {
+      	if (pred(bone)) {
+          return bone;
+      	}
+      }
+      return null;
+	  };
+	  const _findFurthestParentBone = (bone, pred) => {
+	  	let result = null;
+      for (; bone; bone = bone.parent) {
+      	if (pred(bone)) {
+          result = bone;
+      	}
+      }
+      return result;
+	  };
+	  const _distanceToParentBone = (bone, parentBone) => {
+      for (let i = 0; bone; bone = bone.parent, i++) {
+      	if (bone === parentBone) {
+          return i;
+      	}
+      }
+      return Infinity;
+	  };
+    const _findClosestChildBone = (bone, pred) => {
+      const _recurse = bone => {
+        if (pred(bone)) {
+          return bone;
+        } else {
+          for (let i = 0; i < bone.children.length; i++) {
+            const result = _recurse(bone.children[i]);
+            if (result) {
+              return result;
+            }
+          }
+          return null;
+        }
+      }
+      return _recurse(bone);
+    };
+	  const _traverseChild = (bone, distance) => {
+	  	if (distance <= 0) {
+	  		return bone;
+	  	} else {
+	      for (let i = 0; i < bone.children.length; i++) {
+	        const child = bone.children[i];
+	        const subchild = _traverseChild(child, distance - 1);
+	        if (subchild !== null) {
+	        	return subchild;
+	        }
+	      }
+	      return null;
+	    }
+	  };
+	  const _countCharacters = (name, regex) => {
+	  	let result = 0;
+      for (let i = 0; i < name.length; i++) {
+      	if (regex.test(name[i])) {
+      		result++;
+      	}
+      }
+      return result;
+	  };
+    const _findHead = () => {
+      const headBones = tailBones.map(tailBone => {
+        const headBone = _findFurthestParentBone(tailBone, bone => /head/i.test(bone.name));
+        if (headBone) {
+          return headBone;
+        } else {
+          return null;
+        }
+      }).filter(bone => bone);
+      const headBone = headBones.length > 0 ? headBones[0] : null;
+      if (headBone) {
+        return headBone;
+      } else {
+        return null;
+      }
+    };
+	  const _findEye = left => {
+	  	const regexp = left ? /l/i : /r/i;
+	    const eyeBones = tailBones.map(tailBone => {
+        const eyeBone = _findFurthestParentBone(tailBone, bone => /eye/i.test(bone.name) && regexp.test(bone.name.replace(/eye/gi, '')));
+        if (eyeBone) {
+        	return eyeBone;
+        } else {
+        	return null;
+        }
+	    }).filter(spec => spec).sort((a, b) => {
+      	const aName = a.name.replace(/shoulder/gi, '');
+      	const aLeftBalance = _countCharacters(aName, /l/i) - _countCharacters(aName, /r/i);
+      	const bName = b.name.replace(/shoulder/gi, '');
+      	const bLeftBalance = _countCharacters(bName, /l/i) - _countCharacters(bName, /r/i);
+      	if (!left) {
+      	  return aLeftBalance - bLeftBalance;
+      	} else {
+          return bLeftBalance - aLeftBalance;
+      	}
+	    });
+	    const eyeBone = eyeBones.length > 0 ? eyeBones[0] : null;
+	    if (eyeBone) {
+	    	return eyeBone;
+	    } else {
+	    	return null;
+	    }
+	  };
+	  const _findHips = () => {
+      return skeleton.bones.find(bone => /hip/i.test(bone.name));
+	  };
+	  const _findSpine = (chest, hips) => {
+      for (let bone = chest; bone; bone = bone.parent) {
+        if (bone.parent === hips) {
+          return bone;
+        }
+      }
+      return null;
+	  };
+	  const _findShoulder = left => {
+	  	const regexp = left ? /l/i : /r/i;
+	    const shoulderBones = tailBones.map(tailBone => {
+        const shoulderBone = _findClosestParentBone(tailBone, bone => /shoulder/i.test(bone.name) && regexp.test(bone.name.replace(/shoulder/gi, '')));
+        if (shoulderBone) {
+          const distance = _distanceToParentBone(tailBone, shoulderBone);
+          if (distance >= 3) {
+            return {
+              bone: shoulderBone,
+              distance,
+            };
+          } else {
+          	return null;
+          }
+        } else {
+        	return null;
+        }
+	    }).filter(spec => spec).sort((a, b) => {
+        const diff = b.distance - a.distance;
+        if (diff !== 0) {
+          return diff;
+        } else {
+        	const aName = a.bone.name.replace(/shoulder/gi, '');
+        	const aLeftBalance = _countCharacters(aName, /l/i) - _countCharacters(aName, /r/i);
+        	const bName = b.bone.name.replace(/shoulder/gi, '');
+        	const bLeftBalance = _countCharacters(bName, /l/i) - _countCharacters(bName, /r/i);
+        	if (!left) {
+        	  return aLeftBalance - bLeftBalance;
+        	} else {
+            return bLeftBalance - aLeftBalance;
+        	}
+        }
+	    });
+	    const shoulderBone = shoulderBones.length > 0 ? shoulderBones[0].bone : null;
+	    if (shoulderBone) {
+	    	return shoulderBone;
+	    } else {
+	    	return null;
+	    }
+	  };
+	  const _findHand = shoulderBone => _findClosestChildBone(shoulderBone, bone => /hand|wrist/i.test(bone.name));
+	  const _findFoot = left => {
+	  	const regexp = left ? /l/i : /r/i;
+	    const legBones = tailBones.map(tailBone => {
+        const footBone = _findFurthestParentBone(tailBone, bone => /foot|ankle/i.test(bone.name) && regexp.test(bone.name.replace(/foot|ankle/gi, '')));
+        if (footBone) {
+          const legBone = _findFurthestParentBone(footBone, bone => /leg|thigh/i.test(bone.name) && regexp.test(bone.name.replace(/leg|thigh/gi, '')));
+          if (legBone) {
+            const distance = _distanceToParentBone(footBone, legBone);
+            if (distance >= 2) {
+              return {
+                footBone,
+                distance,
+              };
+            } else {
+            	return null;
+            }
+          } else {
+            return null;
+          }
+        } else {
+          return null;
+        }
+	    }).filter(spec => spec).sort((a, b) => {
+        const diff = b.distance - a.distance;
+        if (diff !== 0) {
+          return diff;
+        } else {
+        	const aName = a.footBone.name.replace(/foot|ankle/gi, '');
+        	const aLeftBalance = _countCharacters(aName, /l/i) - _countCharacters(aName, /r/i);
+        	const bName = b.footBone.name.replace(/foot|ankle/gi, '');
+        	const bLeftBalance = _countCharacters(bName, /l/i) - _countCharacters(bName, /r/i);
+        	if (!left) {
+        	  return aLeftBalance - bLeftBalance;
+        	} else {
+            return bLeftBalance - aLeftBalance;
+        	}
+        }
+	    });
+	    const footBone = legBones.length > 0 ? legBones[0].footBone : null;
+	    if (footBone) {
+        return footBone;
+	    } else {
+	    	return null;
+	    }
+	  };
+	  const Eye_L = _findEye(true);
+	  const Eye_R = _findEye(false);
+	  const Head = _findHead();
+	  const Neck = Head.parent;
+	  const Chest = Neck.parent;
+	  const Hips = _findHips();
+	  const Spine = _findSpine(Chest, Hips);
+	  const Left_shoulder = _findShoulder(true);
+	  const Left_wrist = _findHand(Left_shoulder);
+	  const Left_elbow = Left_wrist.parent;
+	  const Left_arm = Left_elbow.parent;
+	  const Right_shoulder = _findShoulder(false);
+	  const Right_wrist = _findHand(Right_shoulder);
+	  const Right_elbow = Right_wrist.parent;
+	  const Right_arm = Right_elbow.parent;
+	  const Left_ankle = _findFoot(true);
+	  const Left_knee = Left_ankle.parent;
+	  const Left_leg = Left_knee.parent;
+	  const Right_ankle = _findFoot(false);
+	  const Right_knee = Right_ankle.parent;
+	  const Right_leg = Right_knee.parent;
+    const modelBones = {
+	    Hips,
+	    Spine,
+	    Chest,
+	    Neck,
+	    Head,
+	    /* Eye_L,
+	    Eye_R, */
+
+	    Left_shoulder,
+	    Left_arm,
+	    Left_elbow,
+	    Left_wrist,
+	    Left_leg,
+	    Left_knee,
+	    Left_ankle,
+
+	    Right_shoulder,
+	    Right_arm,
+	    Right_elbow,
+	    Right_wrist,
+	    Right_leg,
+	    Right_knee,
+	    Right_ankle,
+	  };
+	  this.modelBones = modelBones;
+    /* for (const k in modelBones) {
+      if (!modelBones[k]) {
+        console.warn('missing bone', k);
+      }
+    } */
+
+    const _findArmature = bone => {
+      for (; bone; bone = bone.parent) {
+        if (!bone.isBone) {
+        	return bone;
+        }
+      }
+      return null;
+    };
+	  const armature = _findArmature(Hips);
+
+    const _getEyePosition = () => {
+      if (Eye_L && Eye_R) {
+        return Eye_L.getWorldPosition(new THREE.Vector3())
+          .add(Eye_R.getWorldPosition(new THREE.Vector3()))
+          .divideScalar(2);
+      } else {
+        const neckToHeadDiff = Head.getWorldPosition(new THREE.Vector3()).sub(Neck.getWorldPosition(new THREE.Vector3()));
+        if (neckToHeadDiff.z < 0) {
+          neckToHeadDiff.z *= -1;
+        }
+        return Head.getWorldPosition(new THREE.Vector3()).add(neckToHeadDiff);
+      }
+    };
+    // const eyeDirection = _getEyePosition().sub(Head.getWorldPosition(new Vector3()));
+    const leftArmDirection = Left_wrist.getWorldPosition(new THREE.Vector3()).sub(Head.getWorldPosition(new THREE.Vector3()));
+	  const flipZ = leftArmDirection.x < 0;//eyeDirection.z < 0;
+    const armatureDirection = new THREE.Vector3(0, 1, 0).applyQuaternion(armature.quaternion);
+    const flipY = armatureDirection.z < -0.5;
+    const legDirection = new THREE.Vector3(0, 0, -1).applyQuaternion(Left_leg.getWorldQuaternion(new THREE.Quaternion()).premultiply(armature.quaternion.clone().inverse()));
+    const flipLeg = legDirection.y < 0.5;
+	  console.log('flip', flipZ, flipY, flipLeg);
+	  this.flipZ = flipZ;
+	  this.flipY = flipY;
+    this.flipLeg = flipLeg;
+
+    const armatureQuaternion = armature.quaternion.clone();
+    const armatureMatrixInverse = new THREE.Matrix4().getInverse(armature.matrixWorld);
+    armature.position.set(0, 0, 0);
+    armature.quaternion.set(0, 0, 0, 1);
+    armature.scale.set(1, 1, 1);
+    armature.updateMatrix();
+
+    Head.traverse(o => {
+      o.savedPosition = o.position.clone();
+      o.savedMatrixWorld = o.matrixWorld.clone();
+    });
+
+    const allHairBones = [];
+    const _recurseAllHairBones = bones => {
+      for (let i = 0; i < bones.length; i++) {
+        const bone = bones[i];
+        if (/hair/i.test(bone.name)) {
+          allHairBones.push(bone);
+        }
+        _recurseAllHairBones(bone.children);
+      }
+    };
+    _recurseAllHairBones(skeleton.bones);
+    const hairBones = tailBones.filter(bone => /hair/i.test(bone.name)).map(bone => {
+      for (; bone; bone = bone.parent) {
+        if (bone.parent === Head) {
+          return bone;
+        }
+      }
+      return null;
+    }).filter(bone => bone);
+    this.allHairBones = allHairBones;
+    this.hairBones = hairBones;
+
+    this.springBoneManager = null;
+    if (options.hair) {
+      new Promise((accept, reject) => {
+        if (!object.parser) {
+          object.parser = {
+            json: {
+              extensions: {},
+            },
+          };
+        }
+        if (!object.parser.json.extensions) {
+          object.parser.json.extensions = {};
+        }
+        if (!object.parser.json.extensions.VRM) {
+          object.parser.json.extensions.VRM = {
+            secondaryAnimation: {
+              boneGroups: this.hairBones.map(hairBone => {
+                const boneIndices = [];
+                const _recurse = bone => {
+                  boneIndices.push(this.allHairBones.indexOf(bone));
+                  if (bone.children.length > 0) {
+                    _recurse(bone.children[0]);
+                  }
+                };
+                _recurse(hairBone);
+                return {
+                  comment: hairBone.name,
+                  stiffiness: 0.5,
+                  gravityPower: 0.2,
+                  gravityDir: {
+                    x: 0,
+                    y: -1,
+                    z: 0
+                  },
+                  dragForce: 0.3,
+                  center: -1,
+                  hitRadius: 0.02,
+                  bones: boneIndices,
+                  colliderGroups: [],
+                };
+              }),
+            },
+          };
+          object.parser.getDependency = async (type, nodeIndex) => {
+            if (type === 'node') {
+              return this.allHairBones[nodeIndex];
+            } else {
+              throw new Error('unsupported type');
+            }
+          };
+        }
+
+        new THREE.VRMSpringBoneImporter().import(object)
+          .then(springBoneManager => {
+            this.springBoneManager = springBoneManager;
+          });
+      });
+    }
+
+    const _findFinger = (r, left) => {
+      const fingerTipBone = tailBones
+        .filter(bone => r.test(bone.name) && _findClosestParentBone(bone, bone => bone === modelBones.Left_wrist || bone === modelBones.Right_wrist))
+        .sort((a, b) => {
+          const aName = a.name.replace(r, '');
+          const aLeftBalance = _countCharacters(aName, /l/i) - _countCharacters(aName, /r/i);
+          const bName = b.name.replace(r, '');
+          const bLeftBalance = _countCharacters(bName, /l/i) - _countCharacters(bName, /r/i);
+          if (!left) {
+            return aLeftBalance - bLeftBalance;
+          } else {
+            return bLeftBalance - aLeftBalance;
+          }
+        });
+      const fingerRootBone = fingerTipBone.length > 0 ? _findFurthestParentBone(fingerTipBone[0], bone => r.test(bone.name)) : null;
+      return fingerRootBone;
+    };
+    const fingerBones = {
+      left: {
+        thumb: _findFinger(/thumb/gi, true),
+        index: _findFinger(/index/gi, true),
+        middle: _findFinger(/middle/gi, true),
+        ring: _findFinger(/ring/gi, true),
+        little: _findFinger(/little/gi, true) || _findFinger(/pinky/gi, true),
+      },
+      right: {
+        thumb: _findFinger(/thumb/gi, false),
+        index: _findFinger(/index/gi, false),
+        middle: _findFinger(/middle/gi, false),
+        ring: _findFinger(/ring/gi, false),
+        little: _findFinger(/little/gi, false) || _findFinger(/pinky/gi, false),
+      },
+    };
+    this.fingerBones = fingerBones;
+
+    const preRotations = {};
+    const _ensurePrerotation = k => {
+      const boneName = modelBones[k].name;
+      if (!preRotations[boneName]) {
+        preRotations[boneName] = new THREE.Quaternion();
+      }
+      return preRotations[boneName];
+    };
+    if (flipY) {
+      ['Hips'].forEach(k => {
+        _ensurePrerotation(k).premultiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), -Math.PI/2));
+      });
+    }
+    if (flipZ) {
+      ['Hips'].forEach(k => {
+        _ensurePrerotation(k).premultiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI));
+      });
+    }
+    if (flipLeg) {
+      ['Left_leg', 'Right_leg'].forEach(k => {
+        _ensurePrerotation(k).premultiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), Math.PI/2));
+      });
+    }
+
+    const qrArm = flipZ ? Left_arm : Right_arm;
+    const qrElbow = flipZ ? Left_elbow : Right_elbow;
+    const qrWrist = flipZ ? Left_wrist : Right_wrist;
+    const qr = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), -Math.PI/2)
+      .premultiply(
+        new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt(
+          new THREE.Vector3(0, 0, 0),
+          qrElbow.getWorldPosition(new THREE.Vector3()).applyMatrix4(armatureMatrixInverse)
+            .sub(qrArm.getWorldPosition(new THREE.Vector3()).applyMatrix4(armatureMatrixInverse))
+            .applyQuaternion(armatureQuaternion),
+          new THREE.Vector3(0, 1, 0),
+        ))
+      );
+    const qr2 = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), -Math.PI/2)
+      .premultiply(
+        new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt(
+          new THREE.Vector3(0, 0, 0),
+          qrWrist.getWorldPosition(new THREE.Vector3()).applyMatrix4(armatureMatrixInverse)
+            .sub(qrElbow.getWorldPosition(new THREE.Vector3()).applyMatrix4(armatureMatrixInverse))
+            .applyQuaternion(armatureQuaternion),
+          new THREE.Vector3(0, 1, 0),
+        ))
+      );
+    const qlArm = flipZ ? Right_arm : Left_arm;
+    const qlElbow = flipZ ? Right_elbow : Left_elbow;
+    const qlWrist = flipZ ? Right_wrist : Left_wrist;
+    const ql = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI/2)
+      .premultiply(
+        new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt(
+          new THREE.Vector3(0, 0, 0),
+          qlElbow.getWorldPosition(new THREE.Vector3()).applyMatrix4(armatureMatrixInverse)
+            .sub(qlArm.getWorldPosition(new THREE.Vector3()).applyMatrix4(armatureMatrixInverse))
+            .applyQuaternion(armatureQuaternion),
+          new THREE.Vector3(0, 1, 0),
+        ))
+      );
+    const ql2 = new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI/2)
+      .premultiply(
+        new THREE.Quaternion().setFromRotationMatrix(new THREE.Matrix4().lookAt(
+          new THREE.Vector3(0, 0, 0),
+          qlWrist.getWorldPosition(new THREE.Vector3()).applyMatrix4(armatureMatrixInverse)
+            .sub(qlElbow.getWorldPosition(new THREE.Vector3()).applyMatrix4(armatureMatrixInverse))
+            .applyQuaternion(armatureQuaternion),
+          new THREE.Vector3(0, 1, 0),
+        ))
+      );
+
+    _ensurePrerotation('Right_arm')
+      .multiply(qr.clone().inverse());
+    _ensurePrerotation('Right_elbow')
+      .multiply(qr.clone())
+      .premultiply(qr2.clone().inverse());
+    _ensurePrerotation('Left_arm')
+      .multiply(ql.clone().inverse());
+    _ensurePrerotation('Left_elbow')
+      .multiply(ql.clone())
+      .premultiply(ql2.clone().inverse());
+
+    _ensurePrerotation('Left_leg').premultiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0),  -Math.PI/2));
+    _ensurePrerotation('Right_leg').premultiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0),  -Math.PI/2));
+
+    for (const k in preRotations) {
+      preRotations[k].inverse();
+    }
+	  fixSkeletonZForward(armature.children[0], {
+	    preRotations,
+	  });
+	  model.traverse(o => {
+	    if (o.isSkinnedMesh) {
+	      o.bind((o.skeleton.bones.length === skeleton.bones.length && o.skeleton.bones.every((bone, i) => bone === skeleton.bones[i])) ? skeleton : o.skeleton);
+	    }
+	  });
+    if (flipY) {
+      ['Hips'].forEach(name => {
+        modelBones[name].quaternion.premultiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(1, 0, 0), -Math.PI/2));
+      });
+    }
+	  if (!flipZ) {
+	    /* ['Left_arm', 'Right_arm'].forEach((name, i) => {
+		    const bone = modelBones[name];
+		    if (bone) {
+		      bone.quaternion.premultiply(new Quaternion().setFromAxisAngle(new Vector3(0, 0, 1), (i === 0 ? 1 : -1) * Math.PI*0.25));
+		    }
+		  }); */
+		} else {
+		  ['Hips'].forEach(name => {
+		    modelBones[name].quaternion.premultiply(new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), Math.PI));
+		  });
+		}
+    modelBones.Right_arm.quaternion.premultiply(qr.clone().inverse());
+    modelBones.Right_elbow.quaternion
+      .premultiply(qr)
+      .premultiply(qr2.clone().inverse());
+    modelBones.Left_arm.quaternion.premultiply(ql.clone().inverse());
+    modelBones.Left_elbow.quaternion
+      .premultiply(ql)
+      .premultiply(ql2.clone().inverse());
+	  model.updateMatrixWorld(true);
+
+    for (let i = 0; i < skeleton.bones.length; i++) {
+      const bone = skeleton.bones[i];
+      if (!bone.initialQuaternion) {
+        bone.initialQuaternion = bone.quaternion.clone();
+      }
+    }
+
+	  const _averagePoint = points => {
+      const result = new THREE.Vector3();
+      for (let i = 0; i < points.length; i++) {
+        result.add(points[i]);
+      }
+      result.divideScalar(points.length);
+      return result;
+	  };
+    const eyePosition = _getEyePosition();
+
+		this.poseManager = new PoseManager(this);
+		this.shoulderTransforms = new ShoulderTransforms(this);
+		this.legsManager = new LegsManager(this);
+
+    const _getOffset = (bone, parent = bone.parent) => bone.getWorldPosition(new THREE.Vector3()).sub(parent.getWorldPosition(new THREE.Vector3()));
+    this.initializeBonePositions({
+      spine: _getOffset(modelBones.Spine),
+      chest: _getOffset(modelBones.Chest, modelBones.Spine),
+      neck: _getOffset(modelBones.Neck),
+      head: _getOffset(modelBones.Head),
+      eyes: eyePosition.clone().sub(Head.getWorldPosition(new THREE.Vector3())),
+
+      leftShoulder: _getOffset(modelBones.Right_shoulder),
+      leftUpperArm: _getOffset(modelBones.Right_arm),
+      leftLowerArm: _getOffset(modelBones.Right_elbow),
+      leftHand: _getOffset(modelBones.Right_wrist),
+
+      rightShoulder: _getOffset(modelBones.Left_shoulder),
+      rightUpperArm: _getOffset(modelBones.Left_arm),
+      rightLowerArm: _getOffset(modelBones.Left_elbow),
+      rightHand: _getOffset(modelBones.Left_wrist),
+
+      leftUpperLeg: _getOffset(modelBones.Right_leg),
+      leftLowerLeg: _getOffset(modelBones.Right_knee),
+      leftFoot: _getOffset(modelBones.Right_ankle),
+
+      rightUpperLeg: _getOffset(modelBones.Left_leg),
+      rightLowerLeg: _getOffset(modelBones.Left_knee),
+      rightFoot: _getOffset(modelBones.Left_ankle),
+    });
+
+    this.height = eyePosition.sub(_averagePoint([modelBones.Left_ankle.getWorldPosition(new THREE.Vector3()), modelBones.Right_ankle.getWorldPosition(new THREE.Vector3())])).y;
+    this.shoulderWidth = modelBones.Left_arm.getWorldPosition(new THREE.Vector3()).distanceTo(modelBones.Right_arm.getWorldPosition(new THREE.Vector3()));
+    this.leftArmLength = this.shoulderTransforms.leftArm.armLength;
+    this.rightArmLength = this.shoulderTransforms.rightArm.armLength;
+
+		this.inputs = {
+      hmd: this.poseManager.vrTransforms.head,
+			leftGamepad: this.poseManager.vrTransforms.leftHand,
+			rightGamepad: this.poseManager.vrTransforms.rightHand,
+		};
+    this.inputs.hmd.scaleFactor = 1;
+    this.lastModelScaleFactor = 1;
+		this.outputs = {
+			eyes: this.shoulderTransforms.eyes,
+      head: this.shoulderTransforms.head,
+      hips: this.legsManager.hips,
+      spine: this.shoulderTransforms.spine,
+      chest: this.shoulderTransforms.transform,
+      neck: this.shoulderTransforms.neck,
+      leftShoulder: this.shoulderTransforms.leftShoulderAnchor,
+      leftUpperArm: this.shoulderTransforms.leftArm.upperArm,
+      leftLowerArm: this.shoulderTransforms.leftArm.lowerArm,
+      leftHand: this.shoulderTransforms.leftArm.hand,
+      rightShoulder: this.shoulderTransforms.rightShoulderAnchor,
+      rightUpperArm: this.shoulderTransforms.rightArm.upperArm,
+      rightLowerArm: this.shoulderTransforms.rightArm.lowerArm,
+      rightHand: this.shoulderTransforms.rightArm.hand,
+      leftUpperLeg: this.legsManager.leftLeg.upperLeg,
+      leftLowerLeg: this.legsManager.leftLeg.lowerLeg,
+      leftFoot: this.legsManager.leftLeg.foot,
+      rightUpperLeg: this.legsManager.rightLeg.upperLeg,
+      rightLowerLeg: this.legsManager.rightLeg.lowerLeg,
+      rightFoot: this.legsManager.rightLeg.foot,
+		};
+		this.modelBoneOutputs = {
+	    Hips: this.outputs.hips,
+	    Spine: this.outputs.spine,
+	    Chest: this.outputs.chest,
+	    Neck: this.outputs.neck,
+	    Head: this.outputs.head,
+
+	    Left_shoulder: this.outputs.rightShoulder,
+	    Left_arm: this.outputs.rightUpperArm,
+	    Left_elbow: this.outputs.rightLowerArm,
+	    Left_wrist: this.outputs.rightHand,
+	    Left_leg: this.outputs.rightUpperLeg,
+	    Left_knee: this.outputs.rightLowerLeg,
+	    Left_ankle: this.outputs.rightFoot,
+
+	    Right_shoulder: this.outputs.leftShoulder,
+	    Right_arm: this.outputs.leftUpperArm,
+	    Right_elbow: this.outputs.leftLowerArm,
+	    Right_wrist: this.outputs.leftHand,
+	    Right_leg: this.outputs.leftUpperLeg,
+	    Right_knee: this.outputs.leftLowerLeg,
+	    Right_ankle: this.outputs.leftFoot,
+	  };
+
+    this.microphoneWorker = null;
+    this.volume = 0;
+    this.setMicrophoneMediaStream(options.microphoneMediaStream, {
+      muted: options.muted,
+    });
+
+    this.lastTimestamp = Date.now();
+
+    this.shoulderTransforms.Start();
+    this.legsManager.Start();
+
+    this.decapitated = false;
+    if (options.decapitate) {
+      this.decapitate();
+    }
+	}
+  initializeBonePositions(setups) {
+    this.shoulderTransforms.spine.position.copy(setups.spine);
+    this.shoulderTransforms.transform.position.copy(setups.chest);
+    this.shoulderTransforms.neck.position.copy(setups.neck);
+    this.shoulderTransforms.head.position.copy(setups.head);
+    this.shoulderTransforms.eyes.position.copy(setups.eyes);
+
+    this.shoulderTransforms.leftShoulderAnchor.position.copy(setups.leftShoulder);
+    this.shoulderTransforms.leftArm.upperArm.position.copy(setups.leftUpperArm);
+    this.shoulderTransforms.leftArm.lowerArm.position.copy(setups.leftLowerArm);
+    this.shoulderTransforms.leftArm.hand.position.copy(setups.leftHand);
+
+    this.shoulderTransforms.rightShoulderAnchor.position.copy(setups.rightShoulder);
+    this.shoulderTransforms.rightArm.upperArm.position.copy(setups.rightUpperArm);
+    this.shoulderTransforms.rightArm.lowerArm.position.copy(setups.rightLowerArm);
+    this.shoulderTransforms.rightArm.hand.position.copy(setups.rightHand);
+
+    this.legsManager.leftLeg.upperLeg.position.copy(setups.leftUpperLeg);
+    this.legsManager.leftLeg.lowerLeg.position.copy(setups.leftLowerLeg);
+    this.legsManager.leftLeg.foot.position.copy(setups.leftFoot);
+
+    this.legsManager.rightLeg.upperLeg.position.copy(setups.rightUpperLeg);
+    this.legsManager.rightLeg.lowerLeg.position.copy(setups.rightLowerLeg);
+    this.legsManager.rightLeg.foot.position.copy(setups.rightFoot);
+
+    this.shoulderTransforms.hips.updateMatrixWorld();
+  }
+	update() {
+// return;
+
+   const wasDecapitated = this.decapitated;
+   if (this.springBoneManager && wasDecapitated) {
+    this.undecapitate();
+   }
+
+    const modelScaleFactor = this.inputs.hmd.scaleFactor;
+    if (modelScaleFactor !== this.lastModelScaleFactor) {
+      this.model.scale.set(modelScaleFactor, modelScaleFactor, modelScaleFactor);
+      this.lastModelScaleFactor = modelScaleFactor;
+
+      this.springBoneManager && this.springBoneManager.springBoneGroupList.forEach(springBoneGroup => {
+        springBoneGroup.forEach(springBone => {
+          springBone._worldBoneLength = springBone.bone
+            .localToWorld(localVector.copy(springBone._initialLocalChildPosition))
+            .sub(springBone._worldPosition)
+            .length();
+        });
+      });
+    }
+
+    this.shoulderTransforms.Update();
+    this.legsManager.Update();
+
+	  for (const k in this.modelBones) {
+      const modelBone = this.modelBones[k];
+      const modelBoneOutput = this.modelBoneOutputs[k];
+
+      if (k === 'Hips') {
+        modelBone.position.copy(modelBoneOutput.position);
+      }
+      modelBone.quaternion.multiplyQuaternions(modelBoneOutput.quaternion, modelBone.initialQuaternion)
+
+      if (k === 'Left_ankle' || k === 'Right_ankle') {
+        modelBone.quaternion.multiply(upRotation);
+      } else if (k === 'Left_wrist') {
+        modelBone.quaternion.multiply(leftRotation); // center
+      } else if (k === 'Right_wrist') {
+        modelBone.quaternion.multiply(rightRotation); // center
+      }
+      modelBone.updateMatrixWorld();
+    }
+
+    const now = Date.now();
+    const timeDiff = Math.min(now - this.lastTimestamp, 1000);
+    this.lastTimestamp = now;
+
+    if (this.options.fingers) {
+      const _processFingerBones = left => {
+        const fingerBones = left ? this.fingerBones.left : this.fingerBones.right;
+        const gamepadInput = left ? this.inputs.rightGamepad : this.inputs.leftGamepad;
+        for (const k in fingerBones) {
+          const fingerBone = fingerBones[k];
+          if (fingerBone) {
+            let setter;
+            if (k === 'thumb') {
+              setter = (q, i) => q.setFromAxisAngle(localVector.set(0, left ? 1 : -1, 0), gamepadInput.grip * Math.PI*(i === 0 ? 0.125 : 0.25));
+            } else if (k === 'index') {
+              setter = (q, i) => q.setFromAxisAngle(localVector.set(0, 0, left ? -1 : 1), gamepadInput.pointer * Math.PI*0.5);
+            } else {
+              setter = (q, i) => q.setFromAxisAngle(localVector.set(0, 0, left ? -1 : 1), gamepadInput.grip * Math.PI*0.5);
+            }
+            let index = 0;
+            fingerBone.traverse(subFingerBone => {
+              setter(subFingerBone.quaternion, index++);
+            });
+          }
+        }
+      };
+      _processFingerBones(true);
+      _processFingerBones(false);
+    }
+
+    if (this.springBoneManager) {
+      this.springBoneManager.lateUpdate(timeDiff / 1000);
+    }
+    if (this.springBoneManager && wasDecapitated) {
+      this.decapitate();
+    }
+
+    if (this.options.visemes) {
+      const aaValue = Math.min(this.volume * 10, 1);
+      const blinkValue = (() => {
+        const nowWindow = now % 2000;
+        if (nowWindow >= 0 && nowWindow < 100) {
+          return nowWindow/100;
+        } else if (nowWindow >= 100 && nowWindow < 200) {
+          return 1 - (nowWindow-100)/100;
+        } else {
+          return 0;
+        }
+      })();
+      this.skinnedMeshes.forEach(o => {
+        const {morphTargetDictionary, morphTargetInfluences} = o;
+        if (morphTargetDictionary && morphTargetInfluences) {
+          let aaMorphTargetIndex = morphTargetDictionary['vrc.v_aa'];
+          if (aaMorphTargetIndex === undefined) {
+            aaMorphTargetIndex = morphTargetDictionary['morphTarget26'];
+          }
+          if (aaMorphTargetIndex !== undefined) {
+            morphTargetInfluences[aaMorphTargetIndex] = aaValue;
+          }
+
+          let blinkLeftMorphTargetIndex = morphTargetDictionary['vrc.blink_left'];
+          if (blinkLeftMorphTargetIndex === undefined) {
+            blinkLeftMorphTargetIndex = morphTargetDictionary['morphTarget16'];
+          }
+          if (blinkLeftMorphTargetIndex !== undefined) {
+            morphTargetInfluences[blinkLeftMorphTargetIndex] = blinkValue;
+          }
+
+          let blinkRightMorphTargetIndex = morphTargetDictionary['vrc.blink_right'];
+          if (blinkRightMorphTargetIndex === undefined) {
+            blinkRightMorphTargetIndex = morphTargetDictionary['morphTarget17'];
+          }
+          if (blinkRightMorphTargetIndex !== undefined) {
+            morphTargetInfluences[blinkRightMorphTargetIndex] = blinkValue;
+          }
+        }
+      });
+    }
+	}
+
+  async setMicrophoneMediaStream(microphoneMediaStream, options = {}) {
+    if (this.microphoneWorker) {
+      this.microphoneWorker.close();
+      this.microphoneWorker = null;
+      setTimeout(() => {
+        this.volume = 0;
+      });
+    }
+    if (microphoneMediaStream) {
+      this.microphoneWorker = new MicrophoneWorker(microphoneMediaStream, options);
+      this.microphoneWorker.addEventListener('volume', e => {
+        this.volume = this.volume*0.8 + e.data*0.2;
+      });
+    }
+  }
+
+  decapitate() {
+    if (!this.decapitated) {
+      this.modelBones.Head.traverse(o => {
+        o.savedPosition.copy(o.position);
+        o.savedMatrixWorld.copy(o.matrixWorld);
+        o.position.set(NaN, NaN, NaN);
+        o.matrixWorld.set(NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN);
+      });
+      this.decapitated = true;
+    }
+  }
+  undecapitate() {
+    if (this.decapitated) {
+      this.modelBones.Head.traverse(o => {
+        o.position.copy(o.savedPosition);
+        o.matrixWorld.copy(o.savedMatrixWorld);
+      });
+      this.decapitated = false;
+    }
+  }
+
+  destroy() {
+    this.setMicrophoneMediaStream(null);
+  }
+}
+export default Avatar;
\ No newline at end of file
diff --git a/vrarmik/microphone-worker.js b/vrarmik/microphone-worker.js
new file mode 100644
index 0000000..6d9aaca
--- /dev/null
+++ b/vrarmik/microphone-worker.js
@@ -0,0 +1,32 @@
+ class MicrophoneWorker extends EventTarget {
+  constructor(mediaStream, options = {}) {
+    super();
+
+    const audio = document.createElement('audio');
+    audio.srcObject = mediaStream;
+    audio.muted = true;
+    this.audioContext = new AudioContext();
+    const mediaStreamSource = this.audioContext.createMediaStreamSource(mediaStream);
+
+    this.audioContext.audioWorklet.addModule('vrarmik/audio-volume-worklet.js')
+      .then(() => {
+        const audioWorkletNode = new AudioWorkletNode(this.audioContext, 'volume-processor');
+        if (options.muted === false) {
+          audioWorkletNode.port.postMessage(JSON.stringify({
+            method: 'muted',
+            muted: false,
+          }));
+        }
+        audioWorkletNode.port.onmessage = e => {
+          this.dispatchEvent(new MessageEvent('volume', {
+            data: e.data,
+          }));
+        };
+        mediaStreamSource.connect(audioWorkletNode).connect(this.audioContext.destination);
+      });
+  }
+  close() {
+    this.audioContext.close();
+  }
+}
+export default MicrophoneWorker;
\ No newline at end of file
diff --git a/vrarmik/three-vrm.js b/vrarmik/three-vrm.js
new file mode 100644
index 0000000..65e3338
--- /dev/null
+++ b/vrarmik/three-vrm.js
@@ -0,0 +1,4219 @@
+var __three_vrm__ =
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = "./src/assign.ts");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "./src/assign.ts":
+/*!***********************!*\
+  !*** ./src/assign.ts ***!
+  \***********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var __three_vrm__ = __webpack_require__(/*! . */ "./src/index.ts");
+Object.assign(THREE, __three_vrm__);
+
+
+/***/ }),
+
+/***/ "./src/index.ts":
+/*!**********************!*\
+  !*** ./src/index.ts ***!
+  \**********************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./vrm/ */ "./src/vrm/index.ts"));
+
+
+/***/ }),
+
+/***/ "./src/vrm/VRM.ts":
+/*!************************!*\
+  !*** ./src/vrm/VRM.ts ***!
+  \************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var disposer_1 = __webpack_require__(/*! ./utils/disposer */ "./src/vrm/utils/disposer.ts");
+var VRMImporter_1 = __webpack_require__(/*! ./VRMImporter */ "./src/vrm/VRMImporter.ts");
+var VRM = (function () {
+    function VRM(params) {
+        this.scene = params.scene;
+        this.humanoid = params.humanoid;
+        this.blendShapeProxy = params.blendShapeProxy;
+        this.firstPerson = params.firstPerson;
+        this.lookAt = params.lookAt;
+        this.materials = params.materials;
+        this.springBoneManager = params.springBoneManager;
+        this.meta = params.meta;
+    }
+    VRM.from = function (gltf, options) {
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, Promise, function () {
+            var importer;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        importer = new VRMImporter_1.VRMImporter(options);
+                        return [4, importer.import(gltf)];
+                    case 1: return [2, _a.sent()];
+                }
+            });
+        });
+    };
+    VRM.prototype.update = function (delta) {
+        if (this.lookAt) {
+            this.lookAt.update(delta);
+        }
+        if (this.blendShapeProxy) {
+            this.blendShapeProxy.update();
+        }
+        if (this.springBoneManager) {
+            this.springBoneManager.lateUpdate(delta);
+        }
+        if (this.materials) {
+            this.materials.forEach(function (material) {
+                if (material.updateVRMMaterials) {
+                    material.updateVRMMaterials(delta);
+                }
+            });
+        }
+    };
+    VRM.prototype.dispose = function () {
+        var scene = this.scene;
+        if (scene) {
+            while (scene.children.length > 0) {
+                var object = scene.children[scene.children.length - 1];
+                disposer_1.deepDispose(object);
+                scene.remove(object);
+            }
+        }
+    };
+    return VRM;
+}());
+exports.VRM = VRM;
+
+
+/***/ }),
+
+/***/ "./src/vrm/VRMImporter.ts":
+/*!********************************!*\
+  !*** ./src/vrm/VRMImporter.ts ***!
+  \********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var blendshape_1 = __webpack_require__(/*! ./blendshape */ "./src/vrm/blendshape/index.ts");
+var firstperson_1 = __webpack_require__(/*! ./firstperson */ "./src/vrm/firstperson/index.ts");
+var VRMHumanoidImporter_1 = __webpack_require__(/*! ./humanoid/VRMHumanoidImporter */ "./src/vrm/humanoid/VRMHumanoidImporter.ts");
+var VRMLookAtImporter_1 = __webpack_require__(/*! ./lookat/VRMLookAtImporter */ "./src/vrm/lookat/VRMLookAtImporter.ts");
+var material_1 = __webpack_require__(/*! ./material */ "./src/vrm/material/index.ts");
+var reduceBones_1 = __webpack_require__(/*! ./reduceBones */ "./src/vrm/reduceBones.ts");
+var VRMSpringBoneImporter_1 = __webpack_require__(/*! ./springbone/VRMSpringBoneImporter */ "./src/vrm/springbone/VRMSpringBoneImporter.ts");
+var VRM_1 = __webpack_require__(/*! ./VRM */ "./src/vrm/VRM.ts");
+var VRMImporter = (function () {
+    function VRMImporter(options) {
+        if (options === void 0) { options = {}; }
+        this._blendShapeImporter = options.blendShapeImporter || new blendshape_1.VRMBlendShapeImporter();
+        this._lookAtImporter = options.lookAtImporter || new VRMLookAtImporter_1.VRMLookAtImporter();
+        this._humanoidImporter = options.humanoidImporter || new VRMHumanoidImporter_1.VRMHumanoidImporter();
+        this._firstPersonImporter = options.firstPersonImporter || new firstperson_1.VRMFirstPersonImporter();
+        this._materialImporter = options.materialImporter || new material_1.VRMMaterialImporter();
+        this._springBoneImporter = options.springBoneImporter || new VRMSpringBoneImporter_1.VRMSpringBoneImporter();
+    }
+    VRMImporter.prototype.import = function (gltf) {
+        return __awaiter(this, void 0, Promise, function () {
+            var vrmExt, scene, materials, humanoid, firstPerson, _a, blendShapeProxy, lookAt, _b, springBoneManager;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (gltf.parser.json.extensions === undefined || gltf.parser.json.extensions.VRM === undefined) {
+                            throw new Error('Could not find VRM extension on the GLTF');
+                        }
+                        vrmExt = gltf.parser.json.extensions.VRM;
+                        scene = gltf.scene;
+                        scene.updateMatrixWorld(false);
+                        scene.traverse(function (object3d) {
+                            if (object3d.isMesh) {
+                                object3d.frustumCulled = false;
+                            }
+                        });
+                        reduceBones_1.reduceBones(scene);
+                        return [4, this._materialImporter.convertGLTFMaterials(gltf)];
+                    case 1:
+                        materials = (_c.sent()) || undefined;
+                        return [4, this._humanoidImporter.import(gltf)];
+                    case 2:
+                        humanoid = (_c.sent()) || undefined;
+                        if (!humanoid) return [3, 4];
+                        return [4, this._firstPersonImporter.import(gltf, humanoid)];
+                    case 3:
+                        _a = (_c.sent()) || undefined;
+                        return [3, 5];
+                    case 4:
+                        _a = undefined;
+                        _c.label = 5;
+                    case 5:
+                        firstPerson = _a;
+                        return [4, this._blendShapeImporter.import(gltf)];
+                    case 6:
+                        blendShapeProxy = (_c.sent()) || undefined;
+                        if (!(firstPerson && blendShapeProxy && humanoid)) return [3, 8];
+                        return [4, this._lookAtImporter.import(gltf, firstPerson, blendShapeProxy, humanoid)];
+                    case 7:
+                        _b = (_c.sent()) || undefined;
+                        return [3, 9];
+                    case 8:
+                        _b = undefined;
+                        _c.label = 9;
+                    case 9:
+                        lookAt = _b;
+                        return [4, this._springBoneImporter.import(gltf)];
+                    case 10:
+                        springBoneManager = (_c.sent()) || undefined;
+                        return [2, new VRM_1.VRM({
+                                scene: gltf.scene,
+                                meta: vrmExt.meta,
+                                materials: materials,
+                                humanoid: humanoid,
+                                firstPerson: firstPerson,
+                                blendShapeProxy: blendShapeProxy,
+                                lookAt: lookAt,
+                                springBoneManager: springBoneManager,
+                            })];
+                }
+            });
+        });
+    };
+    return VRMImporter;
+}());
+exports.VRMImporter = VRMImporter;
+
+
+/***/ }),
+
+/***/ "./src/vrm/blendshape/VRMBlendShapeGroup.ts":
+/*!**************************************************!*\
+  !*** ./src/vrm/blendshape/VRMBlendShapeGroup.ts ***!
+  \**************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var VRMBlendShapeMaterialValueType;
+(function (VRMBlendShapeMaterialValueType) {
+    VRMBlendShapeMaterialValueType[VRMBlendShapeMaterialValueType["NUMBER"] = 0] = "NUMBER";
+    VRMBlendShapeMaterialValueType[VRMBlendShapeMaterialValueType["VECTOR2"] = 1] = "VECTOR2";
+    VRMBlendShapeMaterialValueType[VRMBlendShapeMaterialValueType["VECTOR3"] = 2] = "VECTOR3";
+    VRMBlendShapeMaterialValueType[VRMBlendShapeMaterialValueType["VECTOR4"] = 3] = "VECTOR4";
+    VRMBlendShapeMaterialValueType[VRMBlendShapeMaterialValueType["COLOR"] = 4] = "COLOR";
+})(VRMBlendShapeMaterialValueType || (VRMBlendShapeMaterialValueType = {}));
+var _v2 = new THREE.Vector2();
+var _v3 = new THREE.Vector3();
+var _v4 = new THREE.Vector4();
+var _color = new THREE.Color();
+var VRMBlendShapeGroup = (function (_super) {
+    __extends(VRMBlendShapeGroup, _super);
+    function VRMBlendShapeGroup(expressionName) {
+        var _this = _super.call(this) || this;
+        _this.weight = 0.0;
+        _this.isBinary = false;
+        _this._binds = [];
+        _this._materialValues = [];
+        _this.name = "BlendShapeController_" + expressionName;
+        _this.type = 'BlendShapeController';
+        _this.visible = false;
+        return _this;
+    }
+    VRMBlendShapeGroup.prototype.addBind = function (args) {
+        var weight = args.weight / 100;
+        this._binds.push({
+            meshes: args.meshes,
+            morphTargetIndex: args.morphTargetIndex,
+            weight: weight,
+        });
+    };
+    VRMBlendShapeGroup.prototype.addMaterialValue = function (args) {
+        var material = args.material;
+        var propertyName = args.propertyName;
+        var value = material[propertyName];
+        if (!value) {
+            return;
+        }
+        value = args.defaultValue || value;
+        var type;
+        var defaultValue;
+        var targetValue;
+        var deltaValue;
+        if (value.isVector2) {
+            type = VRMBlendShapeMaterialValueType.VECTOR2;
+            defaultValue = value.clone();
+            targetValue = new THREE.Vector2().fromArray(args.targetValue);
+            deltaValue = targetValue.clone().sub(defaultValue);
+        }
+        else if (value.isVector3) {
+            type = VRMBlendShapeMaterialValueType.VECTOR3;
+            defaultValue = value.clone();
+            targetValue = new THREE.Vector3().fromArray(args.targetValue);
+            deltaValue = targetValue.clone().sub(defaultValue);
+        }
+        else if (value.isVector4) {
+            type = VRMBlendShapeMaterialValueType.VECTOR4;
+            defaultValue = value.clone();
+            targetValue = new THREE.Vector4().fromArray([
+                args.targetValue[2],
+                args.targetValue[3],
+                args.targetValue[0],
+                args.targetValue[1],
+            ]);
+            deltaValue = targetValue.clone().sub(defaultValue);
+        }
+        else if (value.isColor) {
+            type = VRMBlendShapeMaterialValueType.COLOR;
+            defaultValue = value.clone();
+            targetValue = new THREE.Color().fromArray(args.targetValue);
+            deltaValue = targetValue.clone().sub(defaultValue);
+        }
+        else {
+            type = VRMBlendShapeMaterialValueType.NUMBER;
+            defaultValue = value;
+            targetValue = args.targetValue[0];
+            deltaValue = targetValue - defaultValue;
+        }
+        this._materialValues.push({
+            material: material,
+            propertyName: propertyName,
+            defaultValue: defaultValue,
+            targetValue: targetValue,
+            deltaValue: deltaValue,
+            type: type,
+        });
+    };
+    VRMBlendShapeGroup.prototype.applyWeight = function () {
+        var w = this.isBinary ? (this.weight < 0.5 ? 0.0 : 1.0) : this.weight;
+        this._binds.forEach(function (bind) {
+            bind.meshes.forEach(function (mesh) {
+                if (!mesh.morphTargetInfluences) {
+                    return;
+                }
+                mesh.morphTargetInfluences[bind.morphTargetIndex] += w * bind.weight;
+            });
+        });
+        this._materialValues.forEach(function (materialValue) {
+            var prop = materialValue.material[materialValue.propertyName];
+            if (prop === undefined) {
+                return;
+            }
+            if (materialValue.type === VRMBlendShapeMaterialValueType.NUMBER) {
+                var deltaValue = materialValue.deltaValue;
+                materialValue.material[materialValue.propertyName] += deltaValue * w;
+            }
+            else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR2) {
+                var deltaValue = materialValue.deltaValue;
+                materialValue.material[materialValue.propertyName].add(_v2.copy(deltaValue).multiplyScalar(w));
+            }
+            else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR3) {
+                var deltaValue = materialValue.deltaValue;
+                materialValue.material[materialValue.propertyName].add(_v3.copy(deltaValue).multiplyScalar(w));
+            }
+            else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR4) {
+                var deltaValue = materialValue.deltaValue;
+                materialValue.material[materialValue.propertyName].add(_v4.copy(deltaValue).multiplyScalar(w));
+            }
+            else if (materialValue.type === VRMBlendShapeMaterialValueType.COLOR) {
+                var deltaValue = materialValue.deltaValue;
+                materialValue.material[materialValue.propertyName].add(_color.copy(deltaValue).multiplyScalar(w));
+            }
+            if (typeof materialValue.material.shouldApplyUniforms === 'boolean') {
+                materialValue.material.shouldApplyUniforms = true;
+            }
+        });
+    };
+    VRMBlendShapeGroup.prototype.clearAppliedWeight = function () {
+        this._binds.forEach(function (bind) {
+            bind.meshes.forEach(function (mesh) {
+                if (!mesh.morphTargetInfluences) {
+                    return;
+                }
+                mesh.morphTargetInfluences[bind.morphTargetIndex] = 0.0;
+            });
+        });
+        this._materialValues.forEach(function (materialValue) {
+            var prop = materialValue.material[materialValue.propertyName];
+            if (prop === undefined) {
+                return;
+            }
+            if (materialValue.type === VRMBlendShapeMaterialValueType.NUMBER) {
+                var defaultValue = materialValue.defaultValue;
+                materialValue.material[materialValue.propertyName] = defaultValue;
+            }
+            else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR2) {
+                var defaultValue = materialValue.defaultValue;
+                materialValue.material[materialValue.propertyName].copy(defaultValue);
+            }
+            else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR3) {
+                var defaultValue = materialValue.defaultValue;
+                materialValue.material[materialValue.propertyName].copy(defaultValue);
+            }
+            else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR4) {
+                var defaultValue = materialValue.defaultValue;
+                materialValue.material[materialValue.propertyName].copy(defaultValue);
+            }
+            else if (materialValue.type === VRMBlendShapeMaterialValueType.COLOR) {
+                var defaultValue = materialValue.defaultValue;
+                materialValue.material[materialValue.propertyName].copy(defaultValue);
+            }
+            if (typeof materialValue.material.shouldApplyUniforms === 'boolean') {
+                materialValue.material.shouldApplyUniforms = true;
+            }
+        });
+    };
+    return VRMBlendShapeGroup;
+}(THREE.Object3D));
+exports.VRMBlendShapeGroup = VRMBlendShapeGroup;
+
+
+/***/ }),
+
+/***/ "./src/vrm/blendshape/VRMBlendShapeImporter.ts":
+/*!*****************************************************!*\
+  !*** ./src/vrm/blendshape/VRMBlendShapeImporter.ts ***!
+  \*****************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var types_1 = __webpack_require__(/*! ../types */ "./src/vrm/types/index.ts");
+var renameMaterialProperty_1 = __webpack_require__(/*! ../utils/renameMaterialProperty */ "./src/vrm/utils/renameMaterialProperty.ts");
+var VRMBlendShapeGroup_1 = __webpack_require__(/*! ./VRMBlendShapeGroup */ "./src/vrm/blendshape/VRMBlendShapeGroup.ts");
+var VRMBlendShapeProxy_1 = __webpack_require__(/*! ./VRMBlendShapeProxy */ "./src/vrm/blendshape/VRMBlendShapeProxy.ts");
+var VRMBlendShapeImporter = (function () {
+    function VRMBlendShapeImporter() {
+    }
+    VRMBlendShapeImporter.prototype.import = function (gltf) {
+        return __awaiter(this, void 0, Promise, function () {
+            var vrmExt, schemaBlendShape, blendShape, blendShapeGroups, blendShapePresetMap;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        vrmExt = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;
+                        if (!vrmExt) {
+                            return [2, null];
+                        }
+                        schemaBlendShape = vrmExt.blendShapeMaster;
+                        if (!schemaBlendShape) {
+                            return [2, null];
+                        }
+                        blendShape = new VRMBlendShapeProxy_1.VRMBlendShapeProxy();
+                        blendShapeGroups = schemaBlendShape.blendShapeGroups;
+                        if (!blendShapeGroups) {
+                            return [2, blendShape];
+                        }
+                        blendShapePresetMap = {};
+                        return [4, Promise.all(blendShapeGroups.map(function (schemaGroup) { return __awaiter(_this, void 0, void 0, function () {
+                                var name, presetName, group, materialValues;
+                                var _this = this;
+                                return __generator(this, function (_a) {
+                                    name = schemaGroup.name;
+                                    if (name === undefined) {
+                                        console.warn('VRMBlendShapeImporter: One of blendShapeGroups has no name');
+                                        return [2];
+                                    }
+                                    if (schemaGroup.presetName &&
+                                        schemaGroup.presetName !== types_1.VRMSchema.BlendShapePresetName.Unknown &&
+                                        !blendShapePresetMap[schemaGroup.presetName]) {
+                                        presetName = schemaGroup.presetName;
+                                        blendShapePresetMap[schemaGroup.presetName] = name;
+                                    }
+                                    group = new VRMBlendShapeGroup_1.VRMBlendShapeGroup(name);
+                                    gltf.scene.add(group);
+                                    group.isBinary = schemaGroup.isBinary || false;
+                                    if (schemaGroup.binds) {
+                                        schemaGroup.binds.forEach(function (bind) { return __awaiter(_this, void 0, void 0, function () {
+                                            var morphMeshes, primitives, morphTargetIndex;
+                                            return __generator(this, function (_a) {
+                                                switch (_a.label) {
+                                                    case 0:
+                                                        if (bind.mesh === undefined || bind.index === undefined) {
+                                                            return [2];
+                                                        }
+                                                        return [4, gltf.parser.getDependency('mesh', bind.mesh)];
+                                                    case 1:
+                                                        morphMeshes = _a.sent();
+                                                        primitives = morphMeshes.type === 'Group'
+                                                            ? morphMeshes.children
+                                                            : [morphMeshes];
+                                                        morphTargetIndex = bind.index;
+                                                        if (!primitives.every(function (primitive) {
+                                                            return Array.isArray(primitive.morphTargetInfluences) &&
+                                                                morphTargetIndex < primitive.morphTargetInfluences.length;
+                                                        })) {
+                                                            console.warn("VRMBlendShapeImporter: " + schemaGroup.name + " attempts to index " + morphTargetIndex + "th morph but not found.");
+                                                            return [2];
+                                                        }
+                                                        group.addBind({
+                                                            meshes: primitives,
+                                                            morphTargetIndex: morphTargetIndex,
+                                                            weight: bind.weight || 100,
+                                                        });
+                                                        return [2];
+                                                }
+                                            });
+                                        }); });
+                                    }
+                                    materialValues = schemaGroup.materialValues;
+                                    if (materialValues) {
+                                        materialValues.forEach(function (materialValue) {
+                                            if (materialValue.materialName === undefined ||
+                                                materialValue.propertyName === undefined ||
+                                                materialValue.targetValue === undefined) {
+                                                return;
+                                            }
+                                            var materials = [];
+                                            gltf.scene.traverse(function (object) {
+                                                if (object.material) {
+                                                    var material = object.material;
+                                                    if (Array.isArray(material)) {
+                                                        materials.push.apply(materials, material.filter(function (mtl) { return mtl.name === materialValue.materialName && materials.indexOf(mtl) === -1; }));
+                                                    }
+                                                    else if (material.name === materialValue.materialName && materials.indexOf(material) === -1) {
+                                                        materials.push(material);
+                                                    }
+                                                }
+                                            });
+                                            materials.forEach(function (material) {
+                                                group.addMaterialValue({
+                                                    material: material,
+                                                    propertyName: renameMaterialProperty_1.renameMaterialProperty(materialValue.propertyName),
+                                                    targetValue: materialValue.targetValue,
+                                                });
+                                            });
+                                        });
+                                    }
+                                    blendShape.registerBlendShapeGroup(name, presetName, group);
+                                    return [2];
+                                });
+                            }); }))];
+                    case 1:
+                        _a.sent();
+                        return [2, blendShape];
+                }
+            });
+        });
+    };
+    return VRMBlendShapeImporter;
+}());
+exports.VRMBlendShapeImporter = VRMBlendShapeImporter;
+
+
+/***/ }),
+
+/***/ "./src/vrm/blendshape/VRMBlendShapeProxy.ts":
+/*!**************************************************!*\
+  !*** ./src/vrm/blendshape/VRMBlendShapeProxy.ts ***!
+  \**************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var math_1 = __webpack_require__(/*! ../utils/math */ "./src/vrm/utils/math.ts");
+var VRMBlendShapeProxy = (function () {
+    function VRMBlendShapeProxy() {
+        this._blendShapeGroups = {};
+        this._blendShapePresetMap = {};
+    }
+    Object.defineProperty(VRMBlendShapeProxy.prototype, "expressions", {
+        get: function () {
+            return Object.keys(this._blendShapeGroups);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    VRMBlendShapeProxy.prototype.getBlendShapeGroup = function (name) {
+        var presetName = this._blendShapePresetMap[name];
+        var controller = presetName ? this._blendShapeGroups[presetName] : this._blendShapeGroups[name];
+        if (!controller) {
+            console.warn("no blend shape found by " + name);
+            return undefined;
+        }
+        return controller;
+    };
+    VRMBlendShapeProxy.prototype.registerBlendShapeGroup = function (name, presetName, controller) {
+        this._blendShapeGroups[name] = controller;
+        if (presetName) {
+            this._blendShapePresetMap[presetName] = name;
+        }
+    };
+    VRMBlendShapeProxy.prototype.getValue = function (name) {
+        var controller = this.getBlendShapeGroup(name);
+        return (controller && controller.weight) || null;
+    };
+    VRMBlendShapeProxy.prototype.setValue = function (name, weight) {
+        var controller = this.getBlendShapeGroup(name);
+        if (controller) {
+            controller.weight = math_1.saturate(weight);
+        }
+    };
+    VRMBlendShapeProxy.prototype.getBlendShapeTrackName = function (name) {
+        var controller = this.getBlendShapeGroup(name);
+        return controller ? controller.name + ".weight" : null;
+    };
+    VRMBlendShapeProxy.prototype.update = function () {
+        var _this = this;
+        Object.keys(this._blendShapeGroups).forEach(function (name) {
+            var controller = _this._blendShapeGroups[name];
+            controller.clearAppliedWeight();
+        });
+        Object.keys(this._blendShapeGroups).forEach(function (name) {
+            var controller = _this._blendShapeGroups[name];
+            controller.applyWeight();
+        });
+    };
+    return VRMBlendShapeProxy;
+}());
+exports.VRMBlendShapeProxy = VRMBlendShapeProxy;
+
+
+/***/ }),
+
+/***/ "./src/vrm/blendshape/index.ts":
+/*!*************************************!*\
+  !*** ./src/vrm/blendshape/index.ts ***!
+  \*************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./VRMBlendShapeGroup */ "./src/vrm/blendshape/VRMBlendShapeGroup.ts"));
+__export(__webpack_require__(/*! ./VRMBlendShapeImporter */ "./src/vrm/blendshape/VRMBlendShapeImporter.ts"));
+__export(__webpack_require__(/*! ./VRMBlendShapeProxy */ "./src/vrm/blendshape/VRMBlendShapeProxy.ts"));
+
+
+/***/ }),
+
+/***/ "./src/vrm/debug/VRMDebug.ts":
+/*!***********************************!*\
+  !*** ./src/vrm/debug/VRMDebug.ts ***!
+  \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var VRM_1 = __webpack_require__(/*! ../VRM */ "./src/vrm/VRM.ts");
+var VRMImporterDebug_1 = __webpack_require__(/*! ./VRMImporterDebug */ "./src/vrm/debug/VRMImporterDebug.ts");
+var VRMDebug = (function (_super) {
+    __extends(VRMDebug, _super);
+    function VRMDebug(params, debugOption) {
+        if (debugOption === void 0) { debugOption = {}; }
+        var _this = _super.call(this, params) || this;
+        if (!debugOption.disableBoxHelper) {
+            _this.scene.add(new THREE.BoxHelper(_this.scene));
+        }
+        if (!debugOption.disableSkeletonHelper) {
+            _this.scene.add(new THREE.SkeletonHelper(_this.scene));
+        }
+        return _this;
+    }
+    VRMDebug.from = function (gltf, options, debugOption) {
+        if (options === void 0) { options = {}; }
+        if (debugOption === void 0) { debugOption = {}; }
+        return __awaiter(this, void 0, Promise, function () {
+            var importer;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        importer = new VRMImporterDebug_1.VRMImporterDebug(options);
+                        return [4, importer.import(gltf, debugOption)];
+                    case 1: return [2, _a.sent()];
+                }
+            });
+        });
+    };
+    VRMDebug.prototype.update = function (delta) {
+        _super.prototype.update.call(this, delta);
+    };
+    return VRMDebug;
+}(VRM_1.VRM));
+exports.VRMDebug = VRMDebug;
+
+
+/***/ }),
+
+/***/ "./src/vrm/debug/VRMDebugOptions.ts":
+/*!******************************************!*\
+  !*** ./src/vrm/debug/VRMDebugOptions.ts ***!
+  \******************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+/***/ }),
+
+/***/ "./src/vrm/debug/VRMImporterDebug.ts":
+/*!*******************************************!*\
+  !*** ./src/vrm/debug/VRMImporterDebug.ts ***!
+  \*******************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var reduceBones_1 = __webpack_require__(/*! ../reduceBones */ "./src/vrm/reduceBones.ts");
+var VRMImporter_1 = __webpack_require__(/*! ../VRMImporter */ "./src/vrm/VRMImporter.ts");
+var VRMDebug_1 = __webpack_require__(/*! ./VRMDebug */ "./src/vrm/debug/VRMDebug.ts");
+var VRMLookAtImporterDebug_1 = __webpack_require__(/*! ./VRMLookAtImporterDebug */ "./src/vrm/debug/VRMLookAtImporterDebug.ts");
+var VRMSpringBoneImporterDebug_1 = __webpack_require__(/*! ./VRMSpringBoneImporterDebug */ "./src/vrm/debug/VRMSpringBoneImporterDebug.ts");
+var VRMImporterDebug = (function (_super) {
+    __extends(VRMImporterDebug, _super);
+    function VRMImporterDebug(options) {
+        if (options === void 0) { options = {}; }
+        var _this = this;
+        options.lookAtImporter = options.lookAtImporter || new VRMLookAtImporterDebug_1.VRMLookAtImporterDebug();
+        options.springBoneImporter = options.springBoneImporter || new VRMSpringBoneImporterDebug_1.VRMSpringBoneImporterDebug();
+        _this = _super.call(this, options) || this;
+        return _this;
+    }
+    VRMImporterDebug.prototype.import = function (gltf, debugOptions) {
+        if (debugOptions === void 0) { debugOptions = {}; }
+        return __awaiter(this, void 0, Promise, function () {
+            var vrmExt, scene, materials, humanoid, firstPerson, _a, blendShapeProxy, lookAt, _b, springBoneManager;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (gltf.parser.json.extensions === undefined || gltf.parser.json.extensions.VRM === undefined) {
+                            throw new Error('Could not find VRM extension on the GLTF');
+                        }
+                        vrmExt = gltf.parser.json.extensions.VRM;
+                        scene = gltf.scene;
+                        scene.updateMatrixWorld(false);
+                        scene.traverse(function (object3d) {
+                            if (object3d.isMesh) {
+                                object3d.frustumCulled = false;
+                            }
+                        });
+                        reduceBones_1.reduceBones(scene);
+                        return [4, this._materialImporter.convertGLTFMaterials(gltf)];
+                    case 1:
+                        materials = (_c.sent()) || undefined;
+                        return [4, this._humanoidImporter.import(gltf)];
+                    case 2:
+                        humanoid = (_c.sent()) || undefined;
+                        if (!humanoid) return [3, 4];
+                        return [4, this._firstPersonImporter.import(gltf, humanoid)];
+                    case 3:
+                        _a = (_c.sent()) || undefined;
+                        return [3, 5];
+                    case 4:
+                        _a = undefined;
+                        _c.label = 5;
+                    case 5:
+                        firstPerson = _a;
+                        return [4, this._blendShapeImporter.import(gltf)];
+                    case 6:
+                        blendShapeProxy = (_c.sent()) || undefined;
+                        if (!(firstPerson && blendShapeProxy && humanoid)) return [3, 8];
+                        return [4, this._lookAtImporter.import(gltf, firstPerson, blendShapeProxy, humanoid)];
+                    case 7:
+                        _b = (_c.sent()) || undefined;
+                        return [3, 9];
+                    case 8:
+                        _b = undefined;
+                        _c.label = 9;
+                    case 9:
+                        lookAt = _b;
+                        if (lookAt.setupHelper) {
+                            lookAt.setupHelper(scene, debugOptions);
+                        }
+                        return [4, this._springBoneImporter.import(gltf)];
+                    case 10:
+                        springBoneManager = (_c.sent()) || undefined;
+                        return [2, new VRMDebug_1.VRMDebug({
+                                scene: gltf.scene,
+                                meta: vrmExt.meta,
+                                materials: materials,
+                                humanoid: humanoid,
+                                firstPerson: firstPerson,
+                                blendShapeProxy: blendShapeProxy,
+                                lookAt: lookAt,
+                                springBoneManager: springBoneManager,
+                            }, debugOptions)];
+                }
+            });
+        });
+    };
+    return VRMImporterDebug;
+}(VRMImporter_1.VRMImporter));
+exports.VRMImporterDebug = VRMImporterDebug;
+
+
+/***/ }),
+
+/***/ "./src/vrm/debug/VRMLookAtHeadDebug.ts":
+/*!*********************************************!*\
+  !*** ./src/vrm/debug/VRMLookAtHeadDebug.ts ***!
+  \*********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var VRMLookAtHead_1 = __webpack_require__(/*! ../lookat/VRMLookAtHead */ "./src/vrm/lookat/VRMLookAtHead.ts");
+var _v3 = new THREE.Vector3();
+var VRMLookAtHeadDebug = (function (_super) {
+    __extends(VRMLookAtHeadDebug, _super);
+    function VRMLookAtHeadDebug() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    VRMLookAtHeadDebug.prototype.setupHelper = function (scene, debugOption) {
+        if (!debugOption.disableFaceDirectionHelper) {
+            this._faceDirectionHelper = new THREE.ArrowHelper(new THREE.Vector3(0, 0, -1), new THREE.Vector3(0, 0, 0), 0.5, 0xff00ff);
+            scene.add(this._faceDirectionHelper);
+        }
+    };
+    VRMLookAtHeadDebug.prototype.update = function (delta) {
+        _super.prototype.update.call(this, delta);
+        if (this._faceDirectionHelper) {
+            this.firstPerson.getFirstPersonWorldPosition(this._faceDirectionHelper.position);
+            this._faceDirectionHelper.setDirection(this.getLookAtWorldDirection(_v3));
+        }
+    };
+    return VRMLookAtHeadDebug;
+}(VRMLookAtHead_1.VRMLookAtHead));
+exports.VRMLookAtHeadDebug = VRMLookAtHeadDebug;
+
+
+/***/ }),
+
+/***/ "./src/vrm/debug/VRMLookAtImporterDebug.ts":
+/*!*************************************************!*\
+  !*** ./src/vrm/debug/VRMLookAtImporterDebug.ts ***!
+  \*************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var VRMLookAtImporter_1 = __webpack_require__(/*! ../lookat/VRMLookAtImporter */ "./src/vrm/lookat/VRMLookAtImporter.ts");
+var VRMLookAtHeadDebug_1 = __webpack_require__(/*! ./VRMLookAtHeadDebug */ "./src/vrm/debug/VRMLookAtHeadDebug.ts");
+var VRMLookAtImporterDebug = (function (_super) {
+    __extends(VRMLookAtImporterDebug, _super);
+    function VRMLookAtImporterDebug() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    VRMLookAtImporterDebug.prototype.import = function (gltf, firstPerson, blendShapeProxy, humanoid) {
+        var vrmExt = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;
+        if (!vrmExt) {
+            return null;
+        }
+        var schemaFirstPerson = vrmExt.firstPerson;
+        if (!schemaFirstPerson) {
+            return null;
+        }
+        var applyer = this._importApplyer(schemaFirstPerson, blendShapeProxy, humanoid);
+        return new VRMLookAtHeadDebug_1.VRMLookAtHeadDebug(firstPerson, applyer || undefined);
+    };
+    return VRMLookAtImporterDebug;
+}(VRMLookAtImporter_1.VRMLookAtImporter));
+exports.VRMLookAtImporterDebug = VRMLookAtImporterDebug;
+
+
+/***/ }),
+
+/***/ "./src/vrm/debug/VRMSpringBoneDebug.ts":
+/*!*********************************************!*\
+  !*** ./src/vrm/debug/VRMSpringBoneDebug.ts ***!
+  \*********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var springbone_1 = __webpack_require__(/*! ../springbone */ "./src/vrm/springbone/index.ts");
+var _v3A = new THREE.Vector3();
+var VRMSpringBoneDebug = (function (_super) {
+    __extends(VRMSpringBoneDebug, _super);
+    function VRMSpringBoneDebug(bone, radius, stiffiness, gravityDir, gravityPower, dragForce, colliders) {
+        if (colliders === void 0) { colliders = []; }
+        return _super.call(this, bone, radius, stiffiness, gravityDir, gravityPower, dragForce, colliders) || this;
+    }
+    VRMSpringBoneDebug.prototype.getGizmo = function () {
+        if (this._gizmo) {
+            return this._gizmo;
+        }
+        var nextTailRelative = _v3A.copy(this._nextTail).sub(this._worldPosition);
+        var nextTailRelativeLength = nextTailRelative.length();
+        this._gizmo = new THREE.ArrowHelper(nextTailRelative.normalize(), this._worldPosition, nextTailRelativeLength, 0xffff00, this.radius, this.radius);
+        this._gizmo.line.renderOrder = springbone_1.GIZMO_RENDER_ORDER;
+        this._gizmo.cone.renderOrder = springbone_1.GIZMO_RENDER_ORDER;
+        this._gizmo.line.material.depthTest = false;
+        this._gizmo.line.material.transparent = true;
+        this._gizmo.cone.material.depthTest = false;
+        this._gizmo.cone.material.transparent = true;
+        return this._gizmo;
+    };
+    VRMSpringBoneDebug.prototype.update = function (delta) {
+        _super.prototype.update.call(this, delta);
+        this._updateGizmo();
+    };
+    VRMSpringBoneDebug.prototype._updateGizmo = function () {
+        if (!this._gizmo) {
+            return;
+        }
+        var nextTailRelative = _v3A.copy(this._currentTail).sub(this._worldPosition);
+        var nextTailRelativeLength = nextTailRelative.length();
+        this._gizmo.setDirection(nextTailRelative.normalize());
+        this._gizmo.setLength(nextTailRelativeLength, this.radius, this.radius);
+        this._gizmo.position.copy(this._worldPosition);
+    };
+    return VRMSpringBoneDebug;
+}(springbone_1.VRMSpringBone));
+exports.VRMSpringBoneDebug = VRMSpringBoneDebug;
+
+
+/***/ }),
+
+/***/ "./src/vrm/debug/VRMSpringBoneImporterDebug.ts":
+/*!*****************************************************!*\
+  !*** ./src/vrm/debug/VRMSpringBoneImporterDebug.ts ***!
+  \*****************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var VRMSpringBoneImporter_1 = __webpack_require__(/*! ../springbone/VRMSpringBoneImporter */ "./src/vrm/springbone/VRMSpringBoneImporter.ts");
+var VRMSpringBoneDebug_1 = __webpack_require__(/*! ./VRMSpringBoneDebug */ "./src/vrm/debug/VRMSpringBoneDebug.ts");
+var VRMSpringBoneImporterDebug = (function (_super) {
+    __extends(VRMSpringBoneImporterDebug, _super);
+    function VRMSpringBoneImporterDebug() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(VRMSpringBoneImporterDebug.prototype, "_isColiderMeshVisible", {
+        get: function () {
+            return true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    VRMSpringBoneImporterDebug.prototype._createSpringBone = function (gltf, bone, hitRadius, stiffiness, gravityDir, gravityPower, dragForce, colliders) {
+        if (colliders === void 0) { colliders = []; }
+        var springBone = new VRMSpringBoneDebug_1.VRMSpringBoneDebug(bone, hitRadius, stiffiness, gravityDir, gravityPower, dragForce, colliders);
+        gltf.scene.add(springBone.getGizmo());
+        return springBone;
+    };
+    return VRMSpringBoneImporterDebug;
+}(VRMSpringBoneImporter_1.VRMSpringBoneImporter));
+exports.VRMSpringBoneImporterDebug = VRMSpringBoneImporterDebug;
+
+
+/***/ }),
+
+/***/ "./src/vrm/debug/index.ts":
+/*!********************************!*\
+  !*** ./src/vrm/debug/index.ts ***!
+  \********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./VRMDebugOptions */ "./src/vrm/debug/VRMDebugOptions.ts"));
+__export(__webpack_require__(/*! ./VRMDebug */ "./src/vrm/debug/VRMDebug.ts"));
+__export(__webpack_require__(/*! ./VRMSpringBoneDebug */ "./src/vrm/debug/VRMSpringBoneDebug.ts"));
+__export(__webpack_require__(/*! ./VRMSpringBoneImporterDebug */ "./src/vrm/debug/VRMSpringBoneImporterDebug.ts"));
+
+
+/***/ }),
+
+/***/ "./src/vrm/firstperson/VRMFirstPerson.ts":
+/*!***********************************************!*\
+  !*** ./src/vrm/firstperson/VRMFirstPerson.ts ***!
+  \***********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var math_1 = __webpack_require__(/*! ../utils/math */ "./src/vrm/utils/math.ts");
+var VECTOR3_FRONT = Object.freeze(new THREE.Vector3(0.0, 0.0, -1.0));
+var _quat = new THREE.Quaternion();
+var FirstPersonFlag;
+(function (FirstPersonFlag) {
+    FirstPersonFlag[FirstPersonFlag["Auto"] = 0] = "Auto";
+    FirstPersonFlag[FirstPersonFlag["Both"] = 1] = "Both";
+    FirstPersonFlag[FirstPersonFlag["ThirdPersonOnly"] = 2] = "ThirdPersonOnly";
+    FirstPersonFlag[FirstPersonFlag["FirstPersonOnly"] = 3] = "FirstPersonOnly";
+})(FirstPersonFlag || (FirstPersonFlag = {}));
+var VRMRendererFirstPersonFlags = (function () {
+    function VRMRendererFirstPersonFlags(firstPersonFlag, mesh) {
+        this.firstPersonFlag = VRMRendererFirstPersonFlags._parseFirstPersonFlag(firstPersonFlag);
+        this.mesh = mesh;
+    }
+    VRMRendererFirstPersonFlags._parseFirstPersonFlag = function (firstPersonFlag) {
+        switch (firstPersonFlag) {
+            case 'Both':
+                return FirstPersonFlag.Both;
+            case 'ThirdPersonOnly':
+                return FirstPersonFlag.ThirdPersonOnly;
+            case 'FirstPersonOnly':
+                return FirstPersonFlag.FirstPersonOnly;
+            default:
+                return FirstPersonFlag.Auto;
+        }
+    };
+    return VRMRendererFirstPersonFlags;
+}());
+exports.VRMRendererFirstPersonFlags = VRMRendererFirstPersonFlags;
+var VRMFirstPerson = (function () {
+    function VRMFirstPerson(firstPersonBone, firstPersonBoneOffset, meshAnnotations) {
+        this._meshAnnotations = [];
+        this._firstPersonOnlyLayer = VRMFirstPerson._DEFAULT_FIRSTPERSON_ONLY_LAYER;
+        this._thirdPersonOnlyLayer = VRMFirstPerson._DEFAULT_THIRDPERSON_ONLY_LAYER;
+        this._initialized = false;
+        this._firstPersonBone = firstPersonBone;
+        this._firstPersonBoneOffset = firstPersonBoneOffset;
+        this._meshAnnotations = meshAnnotations;
+    }
+    Object.defineProperty(VRMFirstPerson.prototype, "firstPersonBone", {
+        get: function () {
+            return this._firstPersonBone;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(VRMFirstPerson.prototype, "meshAnnotations", {
+        get: function () {
+            return this._meshAnnotations;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    VRMFirstPerson.prototype.getFirstPersonWorldDirection = function (target) {
+        return target.copy(VECTOR3_FRONT).applyQuaternion(math_1.getWorldQuaternionLite(this._firstPersonBone, _quat));
+    };
+    Object.defineProperty(VRMFirstPerson.prototype, "firstPersonOnlyLayer", {
+        get: function () {
+            return this._firstPersonOnlyLayer;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(VRMFirstPerson.prototype, "thirdPersonOnlyLayer", {
+        get: function () {
+            return this._thirdPersonOnlyLayer;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    VRMFirstPerson.prototype.getFirstPersonBoneOffset = function (target) {
+        return target.copy(this._firstPersonBoneOffset);
+    };
+    VRMFirstPerson.prototype.getFirstPersonWorldPosition = function (v3) {
+        var offset = this._firstPersonBoneOffset;
+        var v4 = new THREE.Vector4(offset.x, offset.y, offset.z, 1.0);
+        v4.applyMatrix4(this._firstPersonBone.matrixWorld);
+        return v3.set(v4.x, v4.y, v4.z);
+    };
+    VRMFirstPerson.prototype.setup = function (_a) {
+        var _this = this;
+        var _b = _a === void 0 ? {} : _a, _c = _b.firstPersonOnlyLayer, firstPersonOnlyLayer = _c === void 0 ? VRMFirstPerson._DEFAULT_FIRSTPERSON_ONLY_LAYER : _c, _d = _b.thirdPersonOnlyLayer, thirdPersonOnlyLayer = _d === void 0 ? VRMFirstPerson._DEFAULT_THIRDPERSON_ONLY_LAYER : _d;
+        if (this._initialized) {
+            return;
+        }
+        this._initialized = true;
+        this._firstPersonOnlyLayer = firstPersonOnlyLayer;
+        this._thirdPersonOnlyLayer = thirdPersonOnlyLayer;
+        this._meshAnnotations.forEach(function (item) {
+            if (item.firstPersonFlag === FirstPersonFlag.FirstPersonOnly) {
+                item.mesh.layers.set(_this._firstPersonOnlyLayer);
+                item.mesh.traverse(function (child) { return child.layers.set(_this._firstPersonOnlyLayer); });
+            }
+            else if (item.firstPersonFlag === FirstPersonFlag.ThirdPersonOnly) {
+                item.mesh.layers.set(_this._thirdPersonOnlyLayer);
+                item.mesh.traverse(function (child) { return child.layers.set(_this._thirdPersonOnlyLayer); });
+            }
+            else if (item.firstPersonFlag === FirstPersonFlag.Auto) {
+                _this._createHeadlessModel(item.mesh);
+            }
+        });
+    };
+    VRMFirstPerson.prototype._excludeTriangles = function (triangles, bws, skinIndex, exclude) {
+        var count = 0;
+        if (bws != null && bws.length > 0) {
+            for (var i = 0; i < triangles.length; i += 3) {
+                var a = triangles[i];
+                var b = triangles[i + 1];
+                var c = triangles[i + 2];
+                var bw0 = bws[a];
+                var skin0 = skinIndex[a];
+                if (bw0[0] > 0 && exclude.includes(skin0[0]))
+                    continue;
+                if (bw0[1] > 0 && exclude.includes(skin0[1]))
+                    continue;
+                if (bw0[2] > 0 && exclude.includes(skin0[2]))
+                    continue;
+                if (bw0[3] > 0 && exclude.includes(skin0[3]))
+                    continue;
+                var bw1 = bws[b];
+                var skin1 = skinIndex[b];
+                if (bw1[0] > 0 && exclude.includes(skin1[0]))
+                    continue;
+                if (bw1[1] > 0 && exclude.includes(skin1[1]))
+                    continue;
+                if (bw1[2] > 0 && exclude.includes(skin1[2]))
+                    continue;
+                if (bw1[3] > 0 && exclude.includes(skin1[3]))
+                    continue;
+                var bw2 = bws[c];
+                var skin2 = skinIndex[c];
+                if (bw2[0] > 0 && exclude.includes(skin2[0]))
+                    continue;
+                if (bw2[1] > 0 && exclude.includes(skin2[1]))
+                    continue;
+                if (bw2[2] > 0 && exclude.includes(skin2[2]))
+                    continue;
+                if (bw2[3] > 0 && exclude.includes(skin2[3]))
+                    continue;
+                triangles[count++] = a;
+                triangles[count++] = b;
+                triangles[count++] = c;
+            }
+        }
+        return count;
+    };
+    VRMFirstPerson.prototype._createErasedMesh = function (src, erasingBonesIndex) {
+        var dst = new THREE.SkinnedMesh(src.geometry.clone(), src.material);
+        dst.name = src.name + "(erase)";
+        dst.frustumCulled = src.frustumCulled;
+        dst.layers.set(this._firstPersonOnlyLayer);
+        var geometry = dst.geometry;
+        var skinIndexAttr = geometry.getAttribute('skinIndex').array;
+        var skinIndex = [];
+        for (var i = 0; i < skinIndexAttr.length; i += 4) {
+            skinIndex.push([skinIndexAttr[i], skinIndexAttr[i + 1], skinIndexAttr[i + 2], skinIndexAttr[i + 3]]);
+        }
+        var skinWeightAttr = geometry.getAttribute('skinWeight').array;
+        var skinWeight = [];
+        for (var i = 0; i < skinWeightAttr.length; i += 4) {
+            skinWeight.push([skinWeightAttr[i], skinWeightAttr[i + 1], skinWeightAttr[i + 2], skinWeightAttr[i + 3]]);
+        }
+        var oldTriangles = Array.from(geometry.getIndex().array);
+        var count = this._excludeTriangles(oldTriangles, skinWeight, skinIndex, erasingBonesIndex);
+        var newTriangle = [];
+        for (var i = 0; i < count; i++) {
+            newTriangle[i] = oldTriangles[i];
+        }
+        geometry.setIndex(newTriangle);
+        if (src.onBeforeRender) {
+            dst.onBeforeRender = src.onBeforeRender;
+        }
+        dst.bind(new THREE.Skeleton(src.skeleton.bones, src.skeleton.boneInverses), new THREE.Matrix4());
+        return dst;
+    };
+    VRMFirstPerson.prototype._createHeadlessModelForSkinnedMesh = function (parent, mesh) {
+        var _this = this;
+        var eraseBoneIndexes = [];
+        mesh.skeleton.bones.forEach(function (bone, index) {
+            if (_this._isEraseTarget(bone))
+                eraseBoneIndexes.push(index);
+        });
+        if (!eraseBoneIndexes.length) {
+            mesh.layers.enable(this._thirdPersonOnlyLayer);
+            mesh.layers.enable(this._firstPersonOnlyLayer);
+            return;
+        }
+        mesh.layers.set(this._thirdPersonOnlyLayer);
+        var newMesh = this._createErasedMesh(mesh, eraseBoneIndexes);
+        parent.add(newMesh);
+    };
+    VRMFirstPerson.prototype._createHeadlessModel = function (node) {
+        var _this = this;
+        if (node.type === 'Group') {
+            node.layers.set(this._thirdPersonOnlyLayer);
+            if (this._isEraseTarget(node)) {
+                node.traverse(function (child) { return child.layers.set(_this._thirdPersonOnlyLayer); });
+            }
+            else {
+                var parent_1 = new THREE.Group();
+                parent_1.name = "_headless_" + node.name;
+                parent_1.layers.set(this._firstPersonOnlyLayer);
+                node.parent.add(parent_1);
+                node.children
+                    .filter(function (child) { return child.type === 'SkinnedMesh'; })
+                    .forEach(function (child) {
+                    _this._createHeadlessModelForSkinnedMesh(parent_1, child);
+                });
+            }
+        }
+        else if (node.type === 'SkinnedMesh') {
+            this._createHeadlessModelForSkinnedMesh(node.parent, node);
+        }
+        else {
+            if (this._isEraseTarget(node)) {
+                node.layers.set(this._thirdPersonOnlyLayer);
+                node.traverse(function (child) { return child.layers.set(_this._thirdPersonOnlyLayer); });
+            }
+        }
+    };
+    VRMFirstPerson.prototype._isEraseTarget = function (bone) {
+        if (bone.name === this._firstPersonBone.name) {
+            return true;
+        }
+        else if (!bone.parent) {
+            return false;
+        }
+        else {
+            return this._isEraseTarget(bone.parent);
+        }
+    };
+    VRMFirstPerson._DEFAULT_FIRSTPERSON_ONLY_LAYER = 9;
+    VRMFirstPerson._DEFAULT_THIRDPERSON_ONLY_LAYER = 10;
+    return VRMFirstPerson;
+}());
+exports.VRMFirstPerson = VRMFirstPerson;
+
+
+/***/ }),
+
+/***/ "./src/vrm/firstperson/VRMFirstPersonImporter.ts":
+/*!*******************************************************!*\
+  !*** ./src/vrm/firstperson/VRMFirstPersonImporter.ts ***!
+  \*******************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var types_1 = __webpack_require__(/*! ../types */ "./src/vrm/types/index.ts");
+var VRMFirstPerson_1 = __webpack_require__(/*! ./VRMFirstPerson */ "./src/vrm/firstperson/VRMFirstPerson.ts");
+var VRMFirstPersonImporter = (function () {
+    function VRMFirstPersonImporter() {
+    }
+    VRMFirstPersonImporter.prototype.import = function (gltf, humanoid) {
+        return __awaiter(this, void 0, Promise, function () {
+            var vrmExt, schemaFirstPerson, firstPersonBoneIndex, firstPersonBone, firstPersonBoneOffset, meshAnnotations, meshes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        vrmExt = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;
+                        if (!vrmExt) {
+                            return [2, null];
+                        }
+                        schemaFirstPerson = vrmExt.firstPerson;
+                        if (!schemaFirstPerson) {
+                            return [2, null];
+                        }
+                        firstPersonBoneIndex = schemaFirstPerson.firstPersonBone;
+                        if (!(firstPersonBoneIndex === undefined || firstPersonBoneIndex === -1)) return [3, 1];
+                        firstPersonBone = humanoid.getBoneNode(types_1.VRMSchema.HumanoidBoneName.Head);
+                        return [3, 3];
+                    case 1: return [4, gltf.parser.getDependency('node', firstPersonBoneIndex)];
+                    case 2:
+                        firstPersonBone = _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        if (!firstPersonBone) {
+                            console.warn('VRMFirstPersonImporter: Could not find firstPersonBone of the VRM');
+                            return [2, null];
+                        }
+                        firstPersonBoneOffset = schemaFirstPerson.firstPersonBoneOffset
+                            ? new THREE.Vector3(schemaFirstPerson.firstPersonBoneOffset.x, schemaFirstPerson.firstPersonBoneOffset.y, schemaFirstPerson.firstPersonBoneOffset.z)
+                            : new THREE.Vector3(0.0, 0.06, 0.0);
+                        meshAnnotations = [];
+                        return [4, gltf.parser.getDependencies('mesh')];
+                    case 4:
+                        meshes = _a.sent();
+                        meshes.forEach(function (mesh, meshIndex) {
+                            var flag = schemaFirstPerson.meshAnnotations
+                                ? schemaFirstPerson.meshAnnotations.find(function (a) { return a.mesh === meshIndex; })
+                                : undefined;
+                            meshAnnotations.push(new VRMFirstPerson_1.VRMRendererFirstPersonFlags(flag && flag.firstPersonFlag, mesh));
+                        });
+                        return [2, new VRMFirstPerson_1.VRMFirstPerson(firstPersonBone, firstPersonBoneOffset, meshAnnotations)];
+                }
+            });
+        });
+    };
+    return VRMFirstPersonImporter;
+}());
+exports.VRMFirstPersonImporter = VRMFirstPersonImporter;
+
+
+/***/ }),
+
+/***/ "./src/vrm/firstperson/index.ts":
+/*!**************************************!*\
+  !*** ./src/vrm/firstperson/index.ts ***!
+  \**************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./VRMFirstPerson */ "./src/vrm/firstperson/VRMFirstPerson.ts"));
+__export(__webpack_require__(/*! ./VRMFirstPersonImporter */ "./src/vrm/firstperson/VRMFirstPersonImporter.ts"));
+
+
+/***/ }),
+
+/***/ "./src/vrm/humanoid/VRMHumanBone.ts":
+/*!******************************************!*\
+  !*** ./src/vrm/humanoid/VRMHumanBone.ts ***!
+  \******************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var VRMHumanBone = (function () {
+    function VRMHumanBone(node, humanLimit) {
+        this.node = node;
+        this.humanLimit = humanLimit;
+    }
+    return VRMHumanBone;
+}());
+exports.VRMHumanBone = VRMHumanBone;
+
+
+/***/ }),
+
+/***/ "./src/vrm/humanoid/VRMHumanBones.ts":
+/*!*******************************************!*\
+  !*** ./src/vrm/humanoid/VRMHumanBones.ts ***!
+  \*******************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+/***/ }),
+
+/***/ "./src/vrm/humanoid/VRMHumanDescription.ts":
+/*!*************************************************!*\
+  !*** ./src/vrm/humanoid/VRMHumanDescription.ts ***!
+  \*************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+/***/ }),
+
+/***/ "./src/vrm/humanoid/VRMHumanLimit.ts":
+/*!*******************************************!*\
+  !*** ./src/vrm/humanoid/VRMHumanLimit.ts ***!
+  \*******************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+/***/ }),
+
+/***/ "./src/vrm/humanoid/VRMHumanoid.ts":
+/*!*****************************************!*\
+  !*** ./src/vrm/humanoid/VRMHumanoid.ts ***!
+  \*****************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var types_1 = __webpack_require__(/*! ../types */ "./src/vrm/types/index.ts");
+var VRMHumanoid = (function () {
+    function VRMHumanoid(boneArray, humanDescription) {
+        this.humanBones = this._createHumanBones(boneArray);
+        this.humanDescription = humanDescription;
+        this.restPose = this.getPose();
+    }
+    VRMHumanoid.prototype.getPose = function () {
+        var _this = this;
+        var pose = {};
+        Object.keys(this.humanBones).forEach(function (vrmBoneName) {
+            var node = _this.getBoneNode(vrmBoneName);
+            if (!node) {
+                return;
+            }
+            if (pose[vrmBoneName]) {
+                return;
+            }
+            pose[vrmBoneName] = {
+                position: node.position.toArray(),
+                rotation: node.quaternion.toArray(),
+            };
+        }, {});
+        return pose;
+    };
+    VRMHumanoid.prototype.setPose = function (poseObject) {
+        var _this = this;
+        Object.keys(poseObject).forEach(function (boneName) {
+            var state = poseObject[boneName];
+            var node = _this.getBoneNode(boneName);
+            if (!node) {
+                return;
+            }
+            var restState = _this.restPose[boneName];
+            if (!restState) {
+                return;
+            }
+            if (state.position) {
+                node.position.set(restState.position[0] + state.position[0], restState.position[1] + state.position[1], restState.position[2] + state.position[2]);
+            }
+            if (state.rotation) {
+                node.quaternion.fromArray(state.rotation);
+            }
+        });
+    };
+    VRMHumanoid.prototype.getBone = function (name) {
+        return this.humanBones[name][0] || undefined;
+    };
+    VRMHumanoid.prototype.getBones = function (name) {
+        return this.humanBones[name];
+    };
+    VRMHumanoid.prototype.getBoneNode = function (name) {
+        return (this.humanBones[name][0] && this.humanBones[name][0].node) || null;
+    };
+    VRMHumanoid.prototype.getBoneNodes = function (name) {
+        return this.humanBones[name].map(function (bone) { return bone.node; });
+    };
+    VRMHumanoid.prototype._createHumanBones = function (boneArray) {
+        var bones = Object.values(types_1.VRMSchema.HumanoidBoneName).reduce(function (accum, name) {
+            accum[name] = [];
+            return accum;
+        }, {});
+        boneArray.forEach(function (bone) {
+            bones[bone.name].push(bone.bone);
+        });
+        return bones;
+    };
+    return VRMHumanoid;
+}());
+exports.VRMHumanoid = VRMHumanoid;
+
+
+/***/ }),
+
+/***/ "./src/vrm/humanoid/VRMHumanoidImporter.ts":
+/*!*************************************************!*\
+  !*** ./src/vrm/humanoid/VRMHumanoidImporter.ts ***!
+  \*************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var VRMHumanBone_1 = __webpack_require__(/*! ./VRMHumanBone */ "./src/vrm/humanoid/VRMHumanBone.ts");
+var VRMHumanoid_1 = __webpack_require__(/*! ./VRMHumanoid */ "./src/vrm/humanoid/VRMHumanoid.ts");
+var VRMHumanoidImporter = (function () {
+    function VRMHumanoidImporter() {
+    }
+    VRMHumanoidImporter.prototype.import = function (gltf) {
+        return __awaiter(this, void 0, Promise, function () {
+            var vrmExt, schemaHumanoid, humanBoneArray, humanDescription;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        vrmExt = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;
+                        if (!vrmExt) {
+                            return [2, null];
+                        }
+                        schemaHumanoid = vrmExt.humanoid;
+                        if (!schemaHumanoid) {
+                            return [2, null];
+                        }
+                        humanBoneArray = [];
+                        if (!schemaHumanoid.humanBones) return [3, 2];
+                        return [4, Promise.all(schemaHumanoid.humanBones.map(function (bone) { return __awaiter(_this, void 0, void 0, function () {
+                                var node;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            if (!bone.bone || !bone.node) {
+                                                return [2];
+                                            }
+                                            return [4, gltf.parser.getDependency('node', bone.node)];
+                                        case 1:
+                                            node = _a.sent();
+                                            humanBoneArray.push({
+                                                name: bone.bone,
+                                                bone: new VRMHumanBone_1.VRMHumanBone(node, {
+                                                    axisLength: bone.axisLength,
+                                                    center: bone.center && new THREE.Vector3(bone.center.x, bone.center.y, bone.center.z),
+                                                    max: bone.max && new THREE.Vector3(bone.max.x, bone.max.y, bone.max.z),
+                                                    min: bone.min && new THREE.Vector3(bone.min.x, bone.min.y, bone.min.z),
+                                                    useDefaultValues: bone.useDefaultValues,
+                                                }),
+                                            });
+                                            return [2];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        humanDescription = {
+                            armStretch: schemaHumanoid.armStretch,
+                            legStretch: schemaHumanoid.legStretch,
+                            upperArmTwist: schemaHumanoid.upperArmTwist,
+                            lowerArmTwist: schemaHumanoid.lowerArmTwist,
+                            upperLegTwist: schemaHumanoid.upperLegTwist,
+                            lowerLegTwist: schemaHumanoid.lowerLegTwist,
+                            feetSpacing: schemaHumanoid.feetSpacing,
+                            hasTranslationDoF: schemaHumanoid.hasTranslationDoF,
+                        };
+                        return [2, new VRMHumanoid_1.VRMHumanoid(humanBoneArray, humanDescription)];
+                }
+            });
+        });
+    };
+    return VRMHumanoidImporter;
+}());
+exports.VRMHumanoidImporter = VRMHumanoidImporter;
+
+
+/***/ }),
+
+/***/ "./src/vrm/humanoid/index.ts":
+/*!***********************************!*\
+  !*** ./src/vrm/humanoid/index.ts ***!
+  \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./VRMHumanBone */ "./src/vrm/humanoid/VRMHumanBone.ts"));
+__export(__webpack_require__(/*! ./VRMHumanBones */ "./src/vrm/humanoid/VRMHumanBones.ts"));
+__export(__webpack_require__(/*! ./VRMHumanDescription */ "./src/vrm/humanoid/VRMHumanDescription.ts"));
+__export(__webpack_require__(/*! ./VRMHumanLimit */ "./src/vrm/humanoid/VRMHumanLimit.ts"));
+__export(__webpack_require__(/*! ./VRMHumanoid */ "./src/vrm/humanoid/VRMHumanoid.ts"));
+__export(__webpack_require__(/*! ./VRMHumanoidImporter */ "./src/vrm/humanoid/VRMHumanoidImporter.ts"));
+
+
+/***/ }),
+
+/***/ "./src/vrm/index.ts":
+/*!**************************!*\
+  !*** ./src/vrm/index.ts ***!
+  \**************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./VRM */ "./src/vrm/VRM.ts"));
+__export(__webpack_require__(/*! ./VRMImporter */ "./src/vrm/VRMImporter.ts"));
+__export(__webpack_require__(/*! ./reduceBones */ "./src/vrm/reduceBones.ts"));
+__export(__webpack_require__(/*! ./blendshape */ "./src/vrm/blendshape/index.ts"));
+__export(__webpack_require__(/*! ./debug */ "./src/vrm/debug/index.ts"));
+__export(__webpack_require__(/*! ./firstperson */ "./src/vrm/firstperson/index.ts"));
+__export(__webpack_require__(/*! ./humanoid */ "./src/vrm/humanoid/index.ts"));
+__export(__webpack_require__(/*! ./lookat */ "./src/vrm/lookat/index.ts"));
+__export(__webpack_require__(/*! ./springbone */ "./src/vrm/springbone/index.ts"));
+__export(__webpack_require__(/*! ./types */ "./src/vrm/types/index.ts"));
+__export(__webpack_require__(/*! ./material */ "./src/vrm/material/index.ts"));
+
+
+/***/ }),
+
+/***/ "./src/vrm/lookat/CurveMapper.ts":
+/*!***************************************!*\
+  !*** ./src/vrm/lookat/CurveMapper.ts ***!
+  \***************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var hermiteSpline = function (y0, y1, t0, t1, x) {
+    var xc = x * x * x;
+    var xs = x * x;
+    var dy = y1 - y0;
+    var h01 = -2.0 * xc + 3.0 * xs;
+    var h10 = xc - 2.0 * xs + x;
+    var h11 = xc - xs;
+    return y0 + dy * h01 + t0 * h10 + t1 * h11;
+};
+var evaluateCurve = function (arr, x) {
+    if (arr.length < 8) {
+        throw new Error('evaluateCurve: Invalid curve detected! (Array length must be 8 at least)');
+    }
+    if (arr.length % 4 !== 0) {
+        throw new Error('evaluateCurve: Invalid curve detected! (Array length must be multiples of 4');
+    }
+    var outNode;
+    for (outNode = 0;; outNode++) {
+        if (arr.length <= 4 * outNode) {
+            return arr[4 * outNode - 3];
+        }
+        else if (x <= arr[4 * outNode]) {
+            break;
+        }
+    }
+    var inNode = outNode - 1;
+    if (inNode < 0) {
+        return arr[4 * inNode + 5];
+    }
+    var x0 = arr[4 * inNode];
+    var x1 = arr[4 * outNode];
+    var xHermite = (x - x0) / (x1 - x0);
+    var y0 = arr[4 * inNode + 1];
+    var y1 = arr[4 * outNode + 1];
+    var t0 = arr[4 * inNode + 3];
+    var t1 = arr[4 * outNode + 2];
+    return hermiteSpline(y0, y1, t0, t1, xHermite);
+};
+var CurveMapper = (function () {
+    function CurveMapper(xRange, yRange, curve) {
+        this.curve = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0];
+        this.curveXRangeDegree = 90.0;
+        this.curveYRangeDegree = 10.0;
+        if (xRange !== undefined) {
+            this.curveXRangeDegree = xRange;
+        }
+        if (yRange !== undefined) {
+            this.curveYRangeDegree = yRange;
+        }
+        if (curve !== undefined) {
+            this.curve = curve;
+        }
+    }
+    CurveMapper.prototype.map = function (src) {
+        var clampedSrc = Math.min(Math.max(src, 0.0), this.curveXRangeDegree);
+        var x = clampedSrc / this.curveXRangeDegree;
+        return this.curveYRangeDegree * evaluateCurve(this.curve, x);
+    };
+    return CurveMapper;
+}());
+exports.CurveMapper = CurveMapper;
+
+
+/***/ }),
+
+/***/ "./src/vrm/lookat/VRMLookAtApplyer.ts":
+/*!********************************************!*\
+  !*** ./src/vrm/lookat/VRMLookAtApplyer.ts ***!
+  \********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var VRMLookAtApplyer = (function () {
+    function VRMLookAtApplyer() {
+    }
+    return VRMLookAtApplyer;
+}());
+exports.VRMLookAtApplyer = VRMLookAtApplyer;
+
+
+/***/ }),
+
+/***/ "./src/vrm/lookat/VRMLookAtBlendShapeApplyer.ts":
+/*!******************************************************!*\
+  !*** ./src/vrm/lookat/VRMLookAtBlendShapeApplyer.ts ***!
+  \******************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var types_1 = __webpack_require__(/*! ../types */ "./src/vrm/types/index.ts");
+var VRMLookAtApplyer_1 = __webpack_require__(/*! ./VRMLookAtApplyer */ "./src/vrm/lookat/VRMLookAtApplyer.ts");
+var VRMLookAtBlendShapeApplyer = (function (_super) {
+    __extends(VRMLookAtBlendShapeApplyer, _super);
+    function VRMLookAtBlendShapeApplyer(blendShapeProxy, curveHorizontal, curveVerticalDown, curveVerticalUp) {
+        var _this = _super.call(this) || this;
+        _this.type = types_1.VRMSchema.FirstPersonLookAtTypeName.BlendShape;
+        _this._curveHorizontal = curveHorizontal;
+        _this._curveVerticalDown = curveVerticalDown;
+        _this._curveVerticalUp = curveVerticalUp;
+        _this._blendShapeProxy = blendShapeProxy;
+        return _this;
+    }
+    VRMLookAtBlendShapeApplyer.prototype.name = function () {
+        return types_1.VRMSchema.FirstPersonLookAtTypeName.BlendShape;
+    };
+    VRMLookAtBlendShapeApplyer.prototype.lookAt = function (euler) {
+        var srcX = euler.x;
+        var srcY = euler.y;
+        if (srcX < 0.0) {
+            this._blendShapeProxy.setValue(types_1.VRMSchema.BlendShapePresetName.Lookup, 0.0);
+            this._blendShapeProxy.setValue(types_1.VRMSchema.BlendShapePresetName.Lookdown, this._curveVerticalDown.map(-srcX));
+        }
+        else {
+            this._blendShapeProxy.setValue(types_1.VRMSchema.BlendShapePresetName.Lookdown, 0.0);
+            this._blendShapeProxy.setValue(types_1.VRMSchema.BlendShapePresetName.Lookup, this._curveVerticalUp.map(srcX));
+        }
+        if (srcY < 0.0) {
+            this._blendShapeProxy.setValue(types_1.VRMSchema.BlendShapePresetName.Lookleft, 0.0);
+            this._blendShapeProxy.setValue(types_1.VRMSchema.BlendShapePresetName.Lookright, this._curveHorizontal.map(-srcY));
+        }
+        else {
+            this._blendShapeProxy.setValue(types_1.VRMSchema.BlendShapePresetName.Lookright, 0.0);
+            this._blendShapeProxy.setValue(types_1.VRMSchema.BlendShapePresetName.Lookleft, this._curveHorizontal.map(srcY));
+        }
+    };
+    return VRMLookAtBlendShapeApplyer;
+}(VRMLookAtApplyer_1.VRMLookAtApplyer));
+exports.VRMLookAtBlendShapeApplyer = VRMLookAtBlendShapeApplyer;
+
+
+/***/ }),
+
+/***/ "./src/vrm/lookat/VRMLookAtBoneApplyer.ts":
+/*!************************************************!*\
+  !*** ./src/vrm/lookat/VRMLookAtBoneApplyer.ts ***!
+  \************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var types_1 = __webpack_require__(/*! ../types */ "./src/vrm/types/index.ts");
+var VRMLookAtApplyer_1 = __webpack_require__(/*! ./VRMLookAtApplyer */ "./src/vrm/lookat/VRMLookAtApplyer.ts");
+var VRMLookAtHead_1 = __webpack_require__(/*! ./VRMLookAtHead */ "./src/vrm/lookat/VRMLookAtHead.ts");
+var _euler = new THREE.Euler(0.0, 0.0, 0.0, VRMLookAtHead_1.VRMLookAtHead.EULER_ORDER);
+var VRMLookAtBoneApplyer = (function (_super) {
+    __extends(VRMLookAtBoneApplyer, _super);
+    function VRMLookAtBoneApplyer(humanoid, curveHorizontalInner, curveHorizontalOuter, curveVerticalDown, curveVerticalUp) {
+        var _this = _super.call(this) || this;
+        _this.type = types_1.VRMSchema.FirstPersonLookAtTypeName.Bone;
+        _this._curveHorizontalInner = curveHorizontalInner;
+        _this._curveHorizontalOuter = curveHorizontalOuter;
+        _this._curveVerticalDown = curveVerticalDown;
+        _this._curveVerticalUp = curveVerticalUp;
+        _this._leftEye = humanoid.getBoneNode(types_1.VRMSchema.HumanoidBoneName.LeftEye);
+        _this._rightEye = humanoid.getBoneNode(types_1.VRMSchema.HumanoidBoneName.RightEye);
+        return _this;
+    }
+    VRMLookAtBoneApplyer.prototype.lookAt = function (euler) {
+        var srcX = euler.x;
+        var srcY = euler.y;
+        if (this._leftEye) {
+            if (srcX < 0.0) {
+                _euler.x = -this._curveVerticalDown.map(-srcX);
+            }
+            else {
+                _euler.x = this._curveVerticalUp.map(srcX);
+            }
+            if (srcY < 0.0) {
+                _euler.y = -this._curveHorizontalInner.map(-srcY);
+            }
+            else {
+                _euler.y = this._curveHorizontalOuter.map(srcY);
+            }
+            this._leftEye.quaternion.setFromEuler(_euler);
+        }
+        if (this._rightEye) {
+            if (srcX < 0.0) {
+                _euler.x = -this._curveVerticalDown.map(-srcX);
+            }
+            else {
+                _euler.x = this._curveVerticalUp.map(srcX);
+            }
+            if (srcY < 0.0) {
+                _euler.y = -this._curveHorizontalOuter.map(-srcY);
+            }
+            else {
+                _euler.y = this._curveHorizontalInner.map(srcY);
+            }
+            this._rightEye.quaternion.setFromEuler(_euler);
+        }
+    };
+    return VRMLookAtBoneApplyer;
+}(VRMLookAtApplyer_1.VRMLookAtApplyer));
+exports.VRMLookAtBoneApplyer = VRMLookAtBoneApplyer;
+
+
+/***/ }),
+
+/***/ "./src/vrm/lookat/VRMLookAtHead.ts":
+/*!*****************************************!*\
+  !*** ./src/vrm/lookat/VRMLookAtHead.ts ***!
+  \*****************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var math_1 = __webpack_require__(/*! ../utils/math */ "./src/vrm/utils/math.ts");
+var VECTOR3_FRONT = Object.freeze(new THREE.Vector3(0.0, 0.0, -1.0));
+var _v3A = new THREE.Vector3();
+var _v3B = new THREE.Vector3();
+var _v3C = new THREE.Vector3();
+var _quat = new THREE.Quaternion();
+var VRMLookAtHead = (function () {
+    function VRMLookAtHead(firstPerson, applyer) {
+        this.autoUpdate = true;
+        this._euler = new THREE.Euler(0.0, 0.0, 0.0, VRMLookAtHead.EULER_ORDER);
+        this.firstPerson = firstPerson;
+        this.applyer = applyer;
+    }
+    VRMLookAtHead.prototype.getLookAtWorldDirection = function (target) {
+        var rot = math_1.getWorldQuaternionLite(this.firstPerson.firstPersonBone, _quat);
+        return target
+            .copy(VECTOR3_FRONT)
+            .applyEuler(this._euler)
+            .applyQuaternion(rot);
+    };
+    VRMLookAtHead.prototype.lookAt = function (position) {
+        this._calcEuler(this._euler, position);
+        if (this.applyer) {
+            this.applyer.lookAt(this._euler);
+        }
+    };
+    VRMLookAtHead.prototype.update = function (delta) {
+        if (this.target && this.autoUpdate) {
+            this.lookAt(this.target.getWorldPosition(_v3A));
+            if (this.applyer) {
+                this.applyer.lookAt(this._euler);
+            }
+        }
+    };
+    VRMLookAtHead.prototype._calcEuler = function (target, position) {
+        var headPosition = this.firstPerson.getFirstPersonWorldPosition(_v3B);
+        var lookAtDir = _v3C
+            .copy(position)
+            .sub(headPosition)
+            .normalize();
+        lookAtDir.applyQuaternion(math_1.getWorldQuaternionLite(this.firstPerson.firstPersonBone, _quat).inverse());
+        target.x = Math.atan2(lookAtDir.y, Math.sqrt(lookAtDir.x * lookAtDir.x + lookAtDir.z * lookAtDir.z));
+        target.y = Math.atan2(-lookAtDir.x, -lookAtDir.z);
+        return target;
+    };
+    VRMLookAtHead.EULER_ORDER = 'YXZ';
+    return VRMLookAtHead;
+}());
+exports.VRMLookAtHead = VRMLookAtHead;
+
+
+/***/ }),
+
+/***/ "./src/vrm/lookat/VRMLookAtImporter.ts":
+/*!*********************************************!*\
+  !*** ./src/vrm/lookat/VRMLookAtImporter.ts ***!
+  \*********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var types_1 = __webpack_require__(/*! ../types */ "./src/vrm/types/index.ts");
+var CurveMapper_1 = __webpack_require__(/*! ./CurveMapper */ "./src/vrm/lookat/CurveMapper.ts");
+var VRMLookAtBlendShapeApplyer_1 = __webpack_require__(/*! ./VRMLookAtBlendShapeApplyer */ "./src/vrm/lookat/VRMLookAtBlendShapeApplyer.ts");
+var VRMLookAtBoneApplyer_1 = __webpack_require__(/*! ./VRMLookAtBoneApplyer */ "./src/vrm/lookat/VRMLookAtBoneApplyer.ts");
+var VRMLookAtHead_1 = __webpack_require__(/*! ./VRMLookAtHead */ "./src/vrm/lookat/VRMLookAtHead.ts");
+var VRMLookAtImporter = (function () {
+    function VRMLookAtImporter() {
+    }
+    VRMLookAtImporter.prototype.import = function (gltf, firstPerson, blendShapeProxy, humanoid) {
+        var vrmExt = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;
+        if (!vrmExt) {
+            return null;
+        }
+        var schemaFirstPerson = vrmExt.firstPerson;
+        if (!schemaFirstPerson) {
+            return null;
+        }
+        var applyer = this._importApplyer(schemaFirstPerson, blendShapeProxy, humanoid);
+        return new VRMLookAtHead_1.VRMLookAtHead(firstPerson, applyer || undefined);
+    };
+    VRMLookAtImporter.prototype._importApplyer = function (schemaFirstPerson, blendShapeProxy, humanoid) {
+        var lookAtHorizontalInner = schemaFirstPerson.lookAtHorizontalInner;
+        var lookAtHorizontalOuter = schemaFirstPerson.lookAtHorizontalOuter;
+        var lookAtVerticalDown = schemaFirstPerson.lookAtVerticalDown;
+        var lookAtVerticalUp = schemaFirstPerson.lookAtVerticalUp;
+        switch (schemaFirstPerson.lookAtTypeName) {
+            case types_1.VRMSchema.FirstPersonLookAtTypeName.Bone: {
+                if (lookAtHorizontalInner === undefined ||
+                    lookAtHorizontalOuter === undefined ||
+                    lookAtVerticalDown === undefined ||
+                    lookAtVerticalUp === undefined) {
+                    return null;
+                }
+                else {
+                    return new VRMLookAtBoneApplyer_1.VRMLookAtBoneApplyer(humanoid, this._importCurveMapperBone(lookAtHorizontalInner), this._importCurveMapperBone(lookAtHorizontalOuter), this._importCurveMapperBone(lookAtVerticalDown), this._importCurveMapperBone(lookAtVerticalUp));
+                }
+            }
+            case types_1.VRMSchema.FirstPersonLookAtTypeName.BlendShape: {
+                if (lookAtHorizontalOuter === undefined || lookAtVerticalDown === undefined || lookAtVerticalUp === undefined) {
+                    return null;
+                }
+                else {
+                    return new VRMLookAtBlendShapeApplyer_1.VRMLookAtBlendShapeApplyer(blendShapeProxy, this._importCurveMapperBlendShape(lookAtHorizontalOuter), this._importCurveMapperBlendShape(lookAtVerticalDown), this._importCurveMapperBlendShape(lookAtVerticalUp));
+                }
+            }
+            default: {
+                return null;
+            }
+        }
+    };
+    VRMLookAtImporter.prototype._importCurveMapperBone = function (map) {
+        return new CurveMapper_1.CurveMapper(typeof map.xRange === 'number' ? THREE.Math.DEG2RAD * map.xRange : undefined, typeof map.yRange === 'number' ? THREE.Math.DEG2RAD * map.yRange : undefined, map.curve);
+    };
+    VRMLookAtImporter.prototype._importCurveMapperBlendShape = function (map) {
+        return new CurveMapper_1.CurveMapper(typeof map.xRange === 'number' ? THREE.Math.DEG2RAD * map.xRange : undefined, map.yRange, map.curve);
+    };
+    return VRMLookAtImporter;
+}());
+exports.VRMLookAtImporter = VRMLookAtImporter;
+
+
+/***/ }),
+
+/***/ "./src/vrm/lookat/index.ts":
+/*!*********************************!*\
+  !*** ./src/vrm/lookat/index.ts ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./CurveMapper */ "./src/vrm/lookat/CurveMapper.ts"));
+__export(__webpack_require__(/*! ./VRMLookAtApplyer */ "./src/vrm/lookat/VRMLookAtApplyer.ts"));
+__export(__webpack_require__(/*! ./VRMLookAtBlendShapeApplyer */ "./src/vrm/lookat/VRMLookAtBlendShapeApplyer.ts"));
+__export(__webpack_require__(/*! ./VRMLookAtBoneApplyer */ "./src/vrm/lookat/VRMLookAtBoneApplyer.ts"));
+__export(__webpack_require__(/*! ./VRMLookAtHead */ "./src/vrm/lookat/VRMLookAtHead.ts"));
+__export(__webpack_require__(/*! ./VRMLookAtImporter */ "./src/vrm/lookat/VRMLookAtImporter.ts"));
+
+
+/***/ }),
+
+/***/ "./src/vrm/material/MToonMaterial.ts":
+/*!*******************************************!*\
+  !*** ./src/vrm/material/MToonMaterial.ts ***!
+  \*******************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var getTexelDecodingFunction_1 = __webpack_require__(/*! ./getTexelDecodingFunction */ "./src/vrm/material/getTexelDecodingFunction.ts");
+var mtoon_vert_1 = __webpack_require__(/*! ./shaders/mtoon.vert */ "./src/vrm/material/shaders/mtoon.vert");
+var mtoon_frag_1 = __webpack_require__(/*! ./shaders/mtoon.frag */ "./src/vrm/material/shaders/mtoon.frag");
+var TAU = 2.0 * Math.PI;
+var MToonMaterialCullMode;
+(function (MToonMaterialCullMode) {
+    MToonMaterialCullMode[MToonMaterialCullMode["Off"] = 0] = "Off";
+    MToonMaterialCullMode[MToonMaterialCullMode["Front"] = 1] = "Front";
+    MToonMaterialCullMode[MToonMaterialCullMode["Back"] = 2] = "Back";
+})(MToonMaterialCullMode = exports.MToonMaterialCullMode || (exports.MToonMaterialCullMode = {}));
+var MToonMaterialDebugMode;
+(function (MToonMaterialDebugMode) {
+    MToonMaterialDebugMode[MToonMaterialDebugMode["None"] = 0] = "None";
+    MToonMaterialDebugMode[MToonMaterialDebugMode["Normal"] = 1] = "Normal";
+    MToonMaterialDebugMode[MToonMaterialDebugMode["LitShadeRate"] = 2] = "LitShadeRate";
+    MToonMaterialDebugMode[MToonMaterialDebugMode["UV"] = 3] = "UV";
+})(MToonMaterialDebugMode = exports.MToonMaterialDebugMode || (exports.MToonMaterialDebugMode = {}));
+var MToonMaterialOutlineColorMode;
+(function (MToonMaterialOutlineColorMode) {
+    MToonMaterialOutlineColorMode[MToonMaterialOutlineColorMode["FixedColor"] = 0] = "FixedColor";
+    MToonMaterialOutlineColorMode[MToonMaterialOutlineColorMode["MixedLighting"] = 1] = "MixedLighting";
+})(MToonMaterialOutlineColorMode = exports.MToonMaterialOutlineColorMode || (exports.MToonMaterialOutlineColorMode = {}));
+var MToonMaterialOutlineWidthMode;
+(function (MToonMaterialOutlineWidthMode) {
+    MToonMaterialOutlineWidthMode[MToonMaterialOutlineWidthMode["None"] = 0] = "None";
+    MToonMaterialOutlineWidthMode[MToonMaterialOutlineWidthMode["WorldCoordinates"] = 1] = "WorldCoordinates";
+    MToonMaterialOutlineWidthMode[MToonMaterialOutlineWidthMode["ScreenCoordinates"] = 2] = "ScreenCoordinates";
+})(MToonMaterialOutlineWidthMode = exports.MToonMaterialOutlineWidthMode || (exports.MToonMaterialOutlineWidthMode = {}));
+var MToonMaterialRenderMode;
+(function (MToonMaterialRenderMode) {
+    MToonMaterialRenderMode[MToonMaterialRenderMode["Opaque"] = 0] = "Opaque";
+    MToonMaterialRenderMode[MToonMaterialRenderMode["Cutout"] = 1] = "Cutout";
+    MToonMaterialRenderMode[MToonMaterialRenderMode["Transparent"] = 2] = "Transparent";
+    MToonMaterialRenderMode[MToonMaterialRenderMode["TransparentWithZWrite"] = 3] = "TransparentWithZWrite";
+})(MToonMaterialRenderMode = exports.MToonMaterialRenderMode || (exports.MToonMaterialRenderMode = {}));
+var MToonMaterial = (function (_super) {
+    __extends(MToonMaterial, _super);
+    function MToonMaterial(colorSpaceGamma, parameters) {
+        var _this = _super.call(this) || this;
+        _this.isMToonMaterial = true;
+        _this.cutoff = 0.5;
+        _this.color = new THREE.Vector4(1.0, 1.0, 1.0, 1.0);
+        _this.shadeColor = new THREE.Vector4(0.97, 0.81, 0.86, 1.0);
+        _this.map = null;
+        _this.mainTex_ST = new THREE.Vector4(0.0, 0.0, 1.0, 1.0);
+        _this.shadeTexture = null;
+        _this.bumpScale = 1.0;
+        _this.normalMap = null;
+        _this.receiveShadowRate = 1.0;
+        _this.receiveShadowTexture = null;
+        _this.shadingGradeRate = 1.0;
+        _this.shadingGradeTexture = null;
+        _this.shadeShift = 0.0;
+        _this.shadeToony = 0.9;
+        _this.lightColorAttenuation = 0.0;
+        _this.indirectLightIntensity = 0.1;
+        _this.rimTexture = null;
+        _this.rimColor = new THREE.Vector4(0.0, 0.0, 0.0, 1.0);
+        _this.rimLightingMix = 0.0;
+        _this.rimFresnelPower = 1.0;
+        _this.rimLift = 0.0;
+        _this.sphereAdd = null;
+        _this.emissionColor = new THREE.Vector4(0.0, 0.0, 0.0, 1.0);
+        _this.emissiveMap = null;
+        _this.outlineWidthTexture = null;
+        _this.outlineWidth = 0.5;
+        _this.outlineScaledMaxDistance = 1.0;
+        _this.outlineColor = new THREE.Vector4(0.0, 0.0, 0.0, 1.0);
+        _this.outlineLightingMix = 1.0;
+        _this.uvAnimMaskTexture = null;
+        _this.uvAnimScrollX = 0.0;
+        _this.uvAnimScrollY = 0.0;
+        _this.uvAnimRotation = 0.0;
+        _this.shouldApplyUniforms = true;
+        _this._debugMode = MToonMaterialDebugMode.None;
+        _this._blendMode = MToonMaterialRenderMode.Opaque;
+        _this._outlineWidthMode = MToonMaterialOutlineWidthMode.None;
+        _this._outlineColorMode = MToonMaterialOutlineColorMode.FixedColor;
+        _this._cullMode = MToonMaterialCullMode.Back;
+        _this._outlineCullMode = MToonMaterialCullMode.Front;
+        _this._isOutline = false;
+        _this._uvAnimOffsetX = 0.0;
+        _this._uvAnimOffsetY = 0.0;
+        _this._uvAnimPhase = 0.0;
+        _this._colorSpaceGamma = colorSpaceGamma;
+        if (parameters === undefined) {
+            parameters = {};
+        }
+        [
+            'mToonVersion',
+            'shadeTexture_ST',
+            'bumpMap_ST',
+            'receiveShadowTexture_ST',
+            'shadingGradeTexture_ST',
+            'sphereAdd_ST',
+            'emissionMap_ST',
+            'outlineWidthTexture_ST',
+            'srcBlend',
+            'dstBlend',
+        ].forEach(function (key) {
+            if (parameters[key] !== undefined) {
+                delete parameters[key];
+            }
+        });
+        parameters.fog = true;
+        parameters.lights = true;
+        parameters.clipping = true;
+        parameters.skinning = parameters.skinning || false;
+        parameters.morphTargets = parameters.morphTargets || false;
+        parameters.morphNormals = parameters.morphNormals || false;
+        parameters.uniforms = THREE.UniformsUtils.merge([
+            THREE.UniformsLib.common,
+            THREE.UniformsLib.normalmap,
+            THREE.UniformsLib.emissivemap,
+            THREE.UniformsLib.fog,
+            THREE.UniformsLib.lights,
+            {
+                cutoff: { value: 0.5 },
+                color: { value: new THREE.Color(1.0, 1.0, 1.0) },
+                colorAlpha: { value: 1.0 },
+                shadeColor: { value: new THREE.Color(0.97, 0.81, 0.86) },
+                mainTex_ST: { value: new THREE.Vector4(0.0, 0.0, 1.0, 1.0) },
+                shadeTexture: { value: null },
+                bumpScale: { value: 1.0 },
+                receiveShadowRate: { value: 1.0 },
+                receiveShadowTexture: { value: null },
+                shadingGradeRate: { value: 1.0 },
+                shadingGradeTexture: { value: null },
+                shadeShift: { value: 0.0 },
+                shadeToony: { value: 0.9 },
+                lightColorAttenuation: { value: 0.0 },
+                indirectLightIntensity: { value: 0.1 },
+                rimTexture: { value: null },
+                rimColor: { value: new THREE.Color(0.0, 0.0, 0.0) },
+                rimLightingMix: { value: 0.0 },
+                rimFresnelPower: { value: 1.0 },
+                rimLift: { value: 0.0 },
+                sphereAdd: { value: null },
+                emissionColor: { value: new THREE.Color(0.0, 0.0, 0.0) },
+                outlineWidthTexture: { value: null },
+                outlineWidth: { value: 0.5 },
+                outlineScaledMaxDistance: { value: 1.0 },
+                outlineColor: { value: new THREE.Color(0.0, 0.0, 0.0) },
+                outlineLightingMix: { value: 1.0 },
+                uvAnimMaskTexture: { value: null },
+                uvAnimOffsetX: { value: 0.0 },
+                uvAnimOffsetY: { value: 0.0 },
+                uvAnimTheta: { value: 0.0 },
+            },
+        ]);
+        _this.setValues(parameters);
+        _this._updateShaderCode();
+        _this._applyUniforms();
+        return _this;
+    }
+    Object.defineProperty(MToonMaterial.prototype, "mainTex", {
+        get: function () {
+            return this.map;
+        },
+        set: function (t) {
+            this.map = t;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MToonMaterial.prototype, "bumpMap", {
+        get: function () {
+            return this.normalMap;
+        },
+        set: function (t) {
+            this.normalMap = t;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MToonMaterial.prototype, "emissionMap", {
+        get: function () {
+            return this.emissiveMap;
+        },
+        set: function (t) {
+            this.emissiveMap = t;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MToonMaterial.prototype, "blendMode", {
+        get: function () {
+            return this._blendMode;
+        },
+        set: function (m) {
+            this._blendMode = m;
+            this.depthWrite = this._blendMode !== MToonMaterialRenderMode.Transparent;
+            this.transparent =
+                this._blendMode === MToonMaterialRenderMode.Transparent ||
+                    this._blendMode === MToonMaterialRenderMode.TransparentWithZWrite;
+            this._updateShaderCode();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MToonMaterial.prototype, "debugMode", {
+        get: function () {
+            return this._debugMode;
+        },
+        set: function (m) {
+            this._debugMode = m;
+            this._updateShaderCode();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MToonMaterial.prototype, "outlineWidthMode", {
+        get: function () {
+            return this._outlineWidthMode;
+        },
+        set: function (m) {
+            this._outlineWidthMode = m;
+            this._updateShaderCode();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MToonMaterial.prototype, "outlineColorMode", {
+        get: function () {
+            return this._outlineColorMode;
+        },
+        set: function (m) {
+            this._outlineColorMode = m;
+            this._updateShaderCode();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MToonMaterial.prototype, "cullMode", {
+        get: function () {
+            return this._cullMode;
+        },
+        set: function (m) {
+            this._cullMode = m;
+            this._updateCullFace();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MToonMaterial.prototype, "outlineCullMode", {
+        get: function () {
+            return this._outlineCullMode;
+        },
+        set: function (m) {
+            this._outlineCullMode = m;
+            this._updateCullFace();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MToonMaterial.prototype, "zWrite", {
+        get: function () {
+            return this.depthWrite ? 1 : 0;
+        },
+        set: function (i) {
+            this.depthWrite = 0.5 <= i;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MToonMaterial.prototype, "isOutline", {
+        get: function () {
+            return this._isOutline;
+        },
+        set: function (b) {
+            this._isOutline = b;
+            this._updateShaderCode();
+            this._updateCullFace();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    MToonMaterial.prototype.updateVRMMaterials = function (delta) {
+        this._uvAnimOffsetX = this._uvAnimOffsetX + delta * this.uvAnimScrollX;
+        this._uvAnimOffsetY = this._uvAnimOffsetY + delta * this.uvAnimScrollY;
+        this._uvAnimPhase = this._uvAnimPhase + delta * this.uvAnimRotation;
+        this._applyUniforms();
+    };
+    MToonMaterial.prototype.copy = function (source) {
+        _super.prototype.copy.call(this, source);
+        this.cutoff = source.cutoff;
+        this.color.copy(source.color);
+        this.shadeColor.copy(source.shadeColor);
+        this.map = source.map;
+        this.mainTex_ST.copy(source.mainTex_ST);
+        this.shadeTexture = source.shadeTexture;
+        this.bumpScale = source.bumpScale;
+        this.normalMap = source.normalMap;
+        this.receiveShadowRate = source.receiveShadowRate;
+        this.receiveShadowTexture = source.receiveShadowTexture;
+        this.shadingGradeRate = source.shadingGradeRate;
+        this.shadingGradeTexture = source.shadingGradeTexture;
+        this.shadeShift = source.shadeShift;
+        this.shadeToony = source.shadeToony;
+        this.lightColorAttenuation = source.lightColorAttenuation;
+        this.indirectLightIntensity = source.indirectLightIntensity;
+        this.rimTexture = source.rimTexture;
+        this.rimColor.copy(source.rimColor);
+        this.rimLightingMix = source.rimLightingMix;
+        this.rimFresnelPower = source.rimFresnelPower;
+        this.rimLift = source.rimLift;
+        this.sphereAdd = source.sphereAdd;
+        this.emissionColor.copy(source.emissionColor);
+        this.emissiveMap = source.emissiveMap;
+        this.outlineWidthTexture = source.outlineWidthTexture;
+        this.outlineWidth = source.outlineWidth;
+        this.outlineScaledMaxDistance = source.outlineScaledMaxDistance;
+        this.outlineColor.copy(source.outlineColor);
+        this.outlineLightingMix = source.outlineLightingMix;
+        this.uvAnimMaskTexture = source.uvAnimMaskTexture;
+        this.uvAnimScrollX = source.uvAnimScrollX;
+        this.uvAnimScrollY = source.uvAnimScrollY;
+        this.uvAnimRotation = source.uvAnimRotation;
+        this.debugMode = source.debugMode;
+        this.blendMode = source.blendMode;
+        this.outlineWidthMode = source.outlineWidthMode;
+        this.outlineColorMode = source.outlineColorMode;
+        this.cullMode = source.cullMode;
+        this.outlineCullMode = source.outlineCullMode;
+        this.isOutline = source.isOutline;
+        return this;
+    };
+    MToonMaterial.prototype._applyUniforms = function () {
+        this.uniforms.uvAnimOffsetX.value = this._uvAnimOffsetX;
+        this.uniforms.uvAnimOffsetY.value = this._uvAnimOffsetY;
+        this.uniforms.uvAnimTheta.value = TAU * this._uvAnimPhase;
+        if (!this.shouldApplyUniforms) {
+            return;
+        }
+        this.shouldApplyUniforms = false;
+        this.uniforms.cutoff.value = this.cutoff;
+        this.uniforms.color.value.setRGB(this.color.x, this.color.y, this.color.z);
+        if (!this._colorSpaceGamma) {
+            this.uniforms.color.value.convertSRGBToLinear();
+        }
+        this.uniforms.colorAlpha.value = this.color.w;
+        this.uniforms.shadeColor.value.setRGB(this.shadeColor.x, this.shadeColor.y, this.shadeColor.z);
+        if (!this._colorSpaceGamma) {
+            this.uniforms.shadeColor.value.convertSRGBToLinear();
+        }
+        this.uniforms.map.value = this.map;
+        this.uniforms.mainTex_ST.value.copy(this.mainTex_ST);
+        this.uniforms.shadeTexture.value = this.shadeTexture;
+        this.uniforms.bumpScale.value = this.bumpScale;
+        this.uniforms.normalMap.value = this.normalMap;
+        this.uniforms.receiveShadowRate.value = this.receiveShadowRate;
+        this.uniforms.receiveShadowTexture.value = this.receiveShadowTexture;
+        this.uniforms.shadingGradeRate.value = this.shadingGradeRate;
+        this.uniforms.shadingGradeTexture.value = this.shadingGradeTexture;
+        this.uniforms.shadeShift.value = this.shadeShift;
+        this.uniforms.shadeToony.value = this.shadeToony;
+        this.uniforms.lightColorAttenuation.value = this.lightColorAttenuation;
+        this.uniforms.indirectLightIntensity.value = this.indirectLightIntensity;
+        this.uniforms.rimTexture.value = this.rimTexture;
+        this.uniforms.rimColor.value.setRGB(this.rimColor.x, this.rimColor.y, this.rimColor.z);
+        if (!this._colorSpaceGamma) {
+            this.uniforms.rimColor.value.convertSRGBToLinear();
+        }
+        this.uniforms.rimLightingMix.value = this.rimLightingMix;
+        this.uniforms.rimFresnelPower.value = this.rimFresnelPower;
+        this.uniforms.rimLift.value = this.rimLift;
+        this.uniforms.sphereAdd.value = this.sphereAdd;
+        this.uniforms.emissionColor.value.setRGB(this.emissionColor.x, this.emissionColor.y, this.emissionColor.z);
+        if (!this._colorSpaceGamma) {
+            this.uniforms.emissionColor.value.convertSRGBToLinear();
+        }
+        this.uniforms.emissiveMap.value = this.emissiveMap;
+        this.uniforms.outlineWidthTexture.value = this.outlineWidthTexture;
+        this.uniforms.outlineWidth.value = this.outlineWidth;
+        this.uniforms.outlineScaledMaxDistance.value = this.outlineScaledMaxDistance;
+        this.uniforms.outlineColor.value.setRGB(this.outlineColor.x, this.outlineColor.y, this.outlineColor.z);
+        if (!this._colorSpaceGamma) {
+            this.uniforms.outlineColor.value.convertSRGBToLinear();
+        }
+        this.uniforms.outlineLightingMix.value = this.outlineLightingMix;
+        this.uniforms.uvAnimMaskTexture.value = this.uvAnimMaskTexture;
+        this._updateCullFace();
+    };
+    MToonMaterial.prototype._updateShaderCode = function () {
+        this.defines = {
+            OUTLINE: this._isOutline,
+            BLENDMODE_OPAQUE: this._blendMode === MToonMaterialRenderMode.Opaque,
+            BLENDMODE_CUTOUT: this._blendMode === MToonMaterialRenderMode.Cutout,
+            BLENDMODE_TRANSPARENT: this._blendMode === MToonMaterialRenderMode.Transparent ||
+                this._blendMode === MToonMaterialRenderMode.TransparentWithZWrite,
+            USE_SHADETEXTURE: this.shadeTexture !== null,
+            USE_RECEIVESHADOWTEXTURE: this.receiveShadowTexture !== null,
+            USE_SHADINGGRADETEXTURE: this.shadingGradeTexture !== null,
+            USE_RIMTEXTURE: this.rimTexture !== null,
+            USE_SPHEREADD: this.sphereAdd !== null,
+            USE_OUTLINEWIDTHTEXTURE: this.outlineWidthTexture !== null,
+            USE_UVANIMMASKTEXTURE: this.uvAnimMaskTexture !== null,
+            DEBUG_NORMAL: this._debugMode === MToonMaterialDebugMode.Normal,
+            DEBUG_LITSHADERATE: this._debugMode === MToonMaterialDebugMode.LitShadeRate,
+            DEBUG_UV: this._debugMode === MToonMaterialDebugMode.UV,
+            OUTLINE_WIDTH_WORLD: this._outlineWidthMode === MToonMaterialOutlineWidthMode.WorldCoordinates,
+            OUTLINE_WIDTH_SCREEN: this._outlineWidthMode === MToonMaterialOutlineWidthMode.ScreenCoordinates,
+            OUTLINE_COLOR_FIXED: this._outlineColorMode === MToonMaterialOutlineColorMode.FixedColor,
+            OUTLINE_COLOR_MIXED: this._outlineColorMode === MToonMaterialOutlineColorMode.MixedLighting,
+        };
+        var encodings = (this.shadeTexture !== null
+            ? getTexelDecodingFunction_1.getTexelDecodingFunction('shadeTextureTexelToLinear', this.shadeTexture.encoding) + '\n'
+            : '') +
+            (this.sphereAdd !== null
+                ? getTexelDecodingFunction_1.getTexelDecodingFunction('sphereAddTexelToLinear', this.sphereAdd.encoding) + '\n'
+                : '');
+        this.vertexShader = mtoon_vert_1.default;
+        this.fragmentShader = encodings + mtoon_frag_1.default;
+        this.needsUpdate = true;
+    };
+    MToonMaterial.prototype._updateCullFace = function () {
+        if (!this.isOutline) {
+            if (this.cullMode === MToonMaterialCullMode.Off) {
+                this.side = THREE.DoubleSide;
+            }
+            else if (this.cullMode === MToonMaterialCullMode.Front) {
+                this.side = THREE.BackSide;
+            }
+            else if (this.cullMode === MToonMaterialCullMode.Back) {
+                this.side = THREE.FrontSide;
+            }
+        }
+        else {
+            if (this.outlineCullMode === MToonMaterialCullMode.Off) {
+                this.side = THREE.DoubleSide;
+            }
+            else if (this.outlineCullMode === MToonMaterialCullMode.Front) {
+                this.side = THREE.BackSide;
+            }
+            else if (this.outlineCullMode === MToonMaterialCullMode.Back) {
+                this.side = THREE.FrontSide;
+            }
+        }
+    };
+    return MToonMaterial;
+}(THREE.ShaderMaterial));
+exports.MToonMaterial = MToonMaterial;
+
+
+/***/ }),
+
+/***/ "./src/vrm/material/VRMMaterialImporter.ts":
+/*!*************************************************!*\
+  !*** ./src/vrm/material/VRMMaterialImporter.ts ***!
+  \*************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var MToonMaterial_1 = __webpack_require__(/*! ./MToonMaterial */ "./src/vrm/material/MToonMaterial.ts");
+var VRMUnlitMaterial_1 = __webpack_require__(/*! ./VRMUnlitMaterial */ "./src/vrm/material/VRMUnlitMaterial.ts");
+var VRMMaterialImporter = (function () {
+    function VRMMaterialImporter(options) {
+        if (options === void 0) { options = {}; }
+        this._colorSpaceGamma = options.colorSpaceGamma || true;
+        this._requestEnvMap = options.requestEnvMap;
+    }
+    VRMMaterialImporter.prototype.convertGLTFMaterials = function (gltf) {
+        return __awaiter(this, void 0, Promise, function () {
+            var vrmExt, materialProperties, meshesMap, materialList, materials;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        vrmExt = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;
+                        if (!vrmExt) {
+                            return [2, null];
+                        }
+                        materialProperties = vrmExt.materialProperties;
+                        if (!materialProperties) {
+                            return [2, null];
+                        }
+                        return [4, gltf.parser.getDependencies('mesh')];
+                    case 1:
+                        meshesMap = _a.sent();
+                        materialList = {};
+                        materials = [];
+                        return [4, Promise.all(meshesMap.map(function (mesh, meshIndex) { return __awaiter(_this, void 0, void 0, function () {
+                                var primitives;
+                                var _this = this;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            primitives = mesh.type === 'Group' ? mesh.children : [mesh];
+                                            return [4, Promise.all(primitives.map(function (primitive, primitiveIndex) { return __awaiter(_this, void 0, void 0, function () {
+                                                    var vrmMaterialIndex, props, vrmMaterials;
+                                                    return __generator(this, function (_a) {
+                                                        switch (_a.label) {
+                                                            case 0:
+                                                                if (!Array.isArray(primitive.material)) {
+                                                                    primitive.material = [primitive.material];
+                                                                    primitive.geometry.addGroup(0, primitive.geometry.index.count, 0);
+                                                                }
+                                                                vrmMaterialIndex = gltf.parser.json.meshes[meshIndex].primitives[primitiveIndex].material;
+                                                                props = materialProperties[vrmMaterialIndex];
+                                                                if (!props) {
+                                                                    console.warn("VRMMaterialImporter: There are no material definition for material #" + vrmMaterialIndex + " on VRM extension.");
+                                                                    props = { shader: 'VRM_USE_GLTFSHADER' };
+                                                                }
+                                                                if (!materialList[vrmMaterialIndex]) return [3, 1];
+                                                                vrmMaterials = materialList[vrmMaterialIndex];
+                                                                return [3, 3];
+                                                            case 1: return [4, this.createVRMMaterials(primitive.material[0], props, gltf)];
+                                                            case 2:
+                                                                vrmMaterials = _a.sent();
+                                                                materialList[vrmMaterialIndex] = vrmMaterials;
+                                                                materials.push(vrmMaterials.surface);
+                                                                if (vrmMaterials.outline) {
+                                                                    materials.push(vrmMaterials.outline);
+                                                                }
+                                                                _a.label = 3;
+                                                            case 3:
+                                                                primitive.material[0] = vrmMaterials.surface;
+                                                                if (this._requestEnvMap) {
+                                                                    this._requestEnvMap().then(function (envMap) {
+                                                                        vrmMaterials.surface.envMap = envMap;
+                                                                        vrmMaterials.surface.needsUpdate = true;
+                                                                    });
+                                                                }
+                                                                primitive.renderOrder = props.renderQueue || 2000;
+                                                                if (vrmMaterials.outline) {
+                                                                    primitive.material[1] = vrmMaterials.outline;
+                                                                    primitive.geometry.addGroup(0, primitive.geometry.index.count, 1);
+                                                                }
+                                                                return [2];
+                                                        }
+                                                    });
+                                                }); }))];
+                                        case 1:
+                                            _a.sent();
+                                            return [2];
+                                    }
+                                });
+                            }); }))];
+                    case 2:
+                        _a.sent();
+                        return [2, materials];
+                }
+            });
+        });
+    };
+    VRMMaterialImporter.prototype.createVRMMaterials = function (originalMaterial, vrmProps, gltf) {
+        return __awaiter(this, void 0, Promise, function () {
+            var newSurface, newOutline, params_1, params, params, params, params;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(vrmProps.shader === 'VRM/MToon')) return [3, 2];
+                        return [4, this._extractMaterialProperties(originalMaterial, vrmProps, gltf)];
+                    case 1:
+                        params_1 = _a.sent();
+                        ['srcBlend', 'dstBlend', 'isFirstSetup'].forEach(function (name) {
+                            if (params_1[name] !== undefined) {
+                                delete params_1[name];
+                            }
+                        });
+                        ['mainTex', 'shadeTexture', 'emission', 'sphereAdd'].forEach(function (name) {
+                            if (params_1[name] !== undefined) {
+                                params_1[name].encoding = _this._colorSpaceGamma ? THREE.LinearEncoding : THREE.sRGBEncoding;
+                            }
+                        });
+                        newSurface = new MToonMaterial_1.MToonMaterial(this._colorSpaceGamma, params_1);
+                        if (params_1.outlineWidthMode !== MToonMaterial_1.MToonMaterialOutlineWidthMode.None) {
+                            params_1.isOutline = true;
+                            newOutline = new MToonMaterial_1.MToonMaterial(this._colorSpaceGamma, params_1);
+                        }
+                        return [3, 11];
+                    case 2:
+                        if (!(vrmProps.shader === 'VRM/UnlitTexture')) return [3, 4];
+                        return [4, this._extractMaterialProperties(originalMaterial, vrmProps, gltf)];
+                    case 3:
+                        params = _a.sent();
+                        params.renderType = VRMUnlitMaterial_1.VRMUnlitMaterialRenderType.Opaque;
+                        newSurface = new VRMUnlitMaterial_1.VRMUnlitMaterial(params);
+                        return [3, 11];
+                    case 4:
+                        if (!(vrmProps.shader === 'VRM/UnlitCutout')) return [3, 6];
+                        return [4, this._extractMaterialProperties(originalMaterial, vrmProps, gltf)];
+                    case 5:
+                        params = _a.sent();
+                        params.renderType = VRMUnlitMaterial_1.VRMUnlitMaterialRenderType.Cutout;
+                        newSurface = new VRMUnlitMaterial_1.VRMUnlitMaterial(params);
+                        return [3, 11];
+                    case 6:
+                        if (!(vrmProps.shader === 'VRM/UnlitTransparent')) return [3, 8];
+                        return [4, this._extractMaterialProperties(originalMaterial, vrmProps, gltf)];
+                    case 7:
+                        params = _a.sent();
+                        params.renderType = VRMUnlitMaterial_1.VRMUnlitMaterialRenderType.Transparent;
+                        newSurface = new VRMUnlitMaterial_1.VRMUnlitMaterial(params);
+                        return [3, 11];
+                    case 8:
+                        if (!(vrmProps.shader === 'VRM/UnlitTransparentZWrite')) return [3, 10];
+                        return [4, this._extractMaterialProperties(originalMaterial, vrmProps, gltf)];
+                    case 9:
+                        params = _a.sent();
+                        params.renderType = VRMUnlitMaterial_1.VRMUnlitMaterialRenderType.TransparentWithZWrite;
+                        newSurface = new VRMUnlitMaterial_1.VRMUnlitMaterial(params);
+                        return [3, 11];
+                    case 10:
+                        if (vrmProps.shader !== 'VRM_USE_GLTFSHADER') {
+                            console.warn("Unknown shader detected: \"" + vrmProps.shader + "\"");
+                        }
+                        newSurface = this._convertGLTFMaterial(originalMaterial.clone());
+                        _a.label = 11;
+                    case 11:
+                        newSurface.name = originalMaterial.name;
+                        newSurface.userData = JSON.parse(JSON.stringify(originalMaterial.userData));
+                        newSurface.userData.vrmMaterialProperties = vrmProps;
+                        if (newOutline) {
+                            newOutline.name = originalMaterial.name + ' (Outline)';
+                            newOutline.userData = JSON.parse(JSON.stringify(originalMaterial.userData));
+                            newOutline.userData.vrmMaterialProperties = vrmProps;
+                        }
+                        return [2, {
+                                surface: newSurface,
+                                outline: newOutline,
+                            }];
+                }
+            });
+        });
+    };
+    VRMMaterialImporter.prototype._renameMaterialProperty = function (name) {
+        if (name[0] !== '_') {
+            console.warn("VRMMaterials: Given property name \"" + name + "\" might be invalid");
+            return name;
+        }
+        name = name.substring(1);
+        if (!/[A-Z]/.test(name[0])) {
+            console.warn("VRMMaterials: Given property name \"" + name + "\" might be invalid");
+            return name;
+        }
+        return name[0].toLowerCase() + name.substring(1);
+    };
+    VRMMaterialImporter.prototype._convertGLTFMaterial = function (material) {
+        if (material.isMeshStandardMaterial) {
+            var mtl = material;
+            if (this._colorSpaceGamma) {
+                if (mtl.map) {
+                    mtl.map.encoding = THREE.LinearEncoding;
+                }
+                if (mtl.emissiveMap) {
+                    mtl.emissiveMap.encoding = THREE.LinearEncoding;
+                }
+            }
+            else {
+                mtl.color.convertSRGBToLinear();
+                mtl.emissive.convertSRGBToLinear();
+            }
+        }
+        if (material.isMeshBasicMaterial) {
+            var mtl = material;
+            if (this._colorSpaceGamma) {
+                if (mtl.map) {
+                    mtl.map.encoding = THREE.LinearEncoding;
+                }
+            }
+            else {
+                mtl.color.convertSRGBToLinear();
+            }
+        }
+        return material;
+    };
+    VRMMaterialImporter.prototype._extractMaterialProperties = function (originalMaterial, vrmProps, gltf) {
+        var taskList = [];
+        var params = {};
+        if (vrmProps.textureProperties) {
+            var _loop_1 = function (name) {
+                var newName = this_1._renameMaterialProperty(name);
+                var textureIndex = vrmProps.textureProperties[name];
+                taskList.push(gltf.parser.getDependency('texture', textureIndex).then(function (texture) {
+                    params[newName] = texture;
+                }));
+            };
+            var this_1 = this;
+            for (var _i = 0, _a = Object.keys(vrmProps.textureProperties); _i < _a.length; _i++) {
+                var name = _a[_i];
+                _loop_1(name);
+            }
+        }
+        if (vrmProps.floatProperties) {
+            for (var _b = 0, _c = Object.keys(vrmProps.floatProperties); _b < _c.length; _b++) {
+                var name = _c[_b];
+                var newName = this._renameMaterialProperty(name);
+                params[newName] = vrmProps.floatProperties[name];
+            }
+        }
+        if (vrmProps.vectorProperties) {
+            var _loop_2 = function (name) {
+                var _a;
+                var newName = this_2._renameMaterialProperty(name);
+                var isTextureST = [
+                    '_MainTex',
+                    '_ShadeTexture',
+                    '_BumpMap',
+                    '_ReceiveShadowTexture',
+                    '_ShadingGradeTexture',
+                    '_SphereAdd',
+                    '_EmissionMap',
+                    '_OutlineWidthTexture',
+                ].some(function (textureName) { return name === textureName; });
+                if (isTextureST) {
+                    newName += '_ST';
+                }
+                params[newName] = new ((_a = THREE.Vector4).bind.apply(_a, [void 0].concat(vrmProps.vectorProperties[name])))();
+            };
+            var this_2 = this;
+            for (var _d = 0, _e = Object.keys(vrmProps.vectorProperties); _d < _e.length; _d++) {
+                var name = _e[_d];
+                _loop_2(name);
+            }
+        }
+        if (vrmProps.keywordMap._ALPHATEST_ON && params.blendMode === MToonMaterial_1.MToonMaterialRenderMode.Opaque) {
+            params.blendMode = MToonMaterial_1.MToonMaterialRenderMode.Cutout;
+        }
+        params.skinning = originalMaterial.skinning || false;
+        params.morphTargets = originalMaterial.morphTargets || false;
+        params.morphNormals = originalMaterial.morphNormals || false;
+        return Promise.all(taskList).then(function () { return params; });
+    };
+    return VRMMaterialImporter;
+}());
+exports.VRMMaterialImporter = VRMMaterialImporter;
+
+
+/***/ }),
+
+/***/ "./src/vrm/material/VRMUnlitMaterial.ts":
+/*!**********************************************!*\
+  !*** ./src/vrm/material/VRMUnlitMaterial.ts ***!
+  \**********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var unlit_vert_1 = __webpack_require__(/*! ./shaders/unlit.vert */ "./src/vrm/material/shaders/unlit.vert");
+var unlit_frag_1 = __webpack_require__(/*! ./shaders/unlit.frag */ "./src/vrm/material/shaders/unlit.frag");
+var VRMUnlitMaterialRenderType;
+(function (VRMUnlitMaterialRenderType) {
+    VRMUnlitMaterialRenderType[VRMUnlitMaterialRenderType["Opaque"] = 0] = "Opaque";
+    VRMUnlitMaterialRenderType[VRMUnlitMaterialRenderType["Cutout"] = 1] = "Cutout";
+    VRMUnlitMaterialRenderType[VRMUnlitMaterialRenderType["Transparent"] = 2] = "Transparent";
+    VRMUnlitMaterialRenderType[VRMUnlitMaterialRenderType["TransparentWithZWrite"] = 3] = "TransparentWithZWrite";
+})(VRMUnlitMaterialRenderType = exports.VRMUnlitMaterialRenderType || (exports.VRMUnlitMaterialRenderType = {}));
+var VRMUnlitMaterial = (function (_super) {
+    __extends(VRMUnlitMaterial, _super);
+    function VRMUnlitMaterial(parameters) {
+        var _this = _super.call(this) || this;
+        _this.isVRMUnlitMaterial = true;
+        _this.cutoff = 0.5;
+        _this.map = null;
+        _this.mainTex_ST = new THREE.Vector4(0.0, 0.0, 1.0, 1.0);
+        _this._renderType = VRMUnlitMaterialRenderType.Opaque;
+        _this.shouldApplyUniforms = true;
+        if (parameters === undefined) {
+            parameters = {};
+        }
+        parameters.fog = true;
+        parameters.clipping = true;
+        parameters.skinning = parameters.skinning || false;
+        parameters.morphTargets = parameters.morphTargets || false;
+        parameters.morphNormals = parameters.morphNormals || false;
+        parameters.uniforms = THREE.UniformsUtils.merge([
+            THREE.UniformsLib.common,
+            THREE.UniformsLib.fog,
+            {
+                cutoff: { value: 0.5 },
+                mainTex_ST: { value: new THREE.Vector4(0.0, 0.0, 1.0, 1.0) },
+            },
+        ]);
+        _this.setValues(parameters);
+        _this._updateShaderCode();
+        _this._applyUniforms();
+        return _this;
+    }
+    Object.defineProperty(VRMUnlitMaterial.prototype, "mainTex", {
+        get: function () {
+            return this.map;
+        },
+        set: function (t) {
+            this.map = t;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(VRMUnlitMaterial.prototype, "renderType", {
+        get: function () {
+            return this._renderType;
+        },
+        set: function (t) {
+            this._renderType = t;
+            this.depthWrite = this._renderType !== VRMUnlitMaterialRenderType.Transparent;
+            this.transparent =
+                this._renderType === VRMUnlitMaterialRenderType.Transparent ||
+                    this._renderType === VRMUnlitMaterialRenderType.TransparentWithZWrite;
+            this._updateShaderCode();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    VRMUnlitMaterial.prototype.updateVRMMaterials = function (delta) {
+        this._applyUniforms();
+    };
+    VRMUnlitMaterial.prototype.copy = function (source) {
+        _super.prototype.copy.call(this, source);
+        this.cutoff = source.cutoff;
+        this.map = source.map;
+        this.mainTex_ST.copy(source.mainTex_ST);
+        this.renderType = source.renderType;
+        return this;
+    };
+    VRMUnlitMaterial.prototype._applyUniforms = function () {
+        if (!this.shouldApplyUniforms) {
+            return;
+        }
+        this.shouldApplyUniforms = false;
+        this.uniforms.cutoff.value = this.cutoff;
+        this.uniforms.map.value = this.map;
+        this.uniforms.mainTex_ST.value.copy(this.mainTex_ST);
+    };
+    VRMUnlitMaterial.prototype._updateShaderCode = function () {
+        this.defines = {
+            RENDERTYPE_OPAQUE: this._renderType === VRMUnlitMaterialRenderType.Opaque,
+            RENDERTYPE_CUTOUT: this._renderType === VRMUnlitMaterialRenderType.Cutout,
+            RENDERTYPE_TRANSPARENT: this._renderType === VRMUnlitMaterialRenderType.Transparent ||
+                this._renderType === VRMUnlitMaterialRenderType.TransparentWithZWrite,
+        };
+        this.vertexShader = unlit_vert_1.default;
+        this.fragmentShader = unlit_frag_1.default;
+        this.needsUpdate = true;
+    };
+    return VRMUnlitMaterial;
+}(THREE.ShaderMaterial));
+exports.VRMUnlitMaterial = VRMUnlitMaterial;
+
+
+/***/ }),
+
+/***/ "./src/vrm/material/getTexelDecodingFunction.ts":
+/*!******************************************************!*\
+  !*** ./src/vrm/material/getTexelDecodingFunction.ts ***!
+  \******************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+exports.getEncodingComponents = function (encoding) {
+    switch (encoding) {
+        case THREE.LinearEncoding:
+            return ['Linear', '( value )'];
+        case THREE.sRGBEncoding:
+            return ['sRGB', '( value )'];
+        case THREE.RGBEEncoding:
+            return ['RGBE', '( value )'];
+        case THREE.RGBM7Encoding:
+            return ['RGBM', '( value, 7.0 )'];
+        case THREE.RGBM16Encoding:
+            return ['RGBM', '( value, 16.0 )'];
+        case THREE.RGBDEncoding:
+            return ['RGBD', '( value, 256.0 )'];
+        case THREE.GammaEncoding:
+            return ['Gamma', '( value, float( GAMMA_FACTOR ) )'];
+        default:
+            throw new Error('unsupported encoding: ' + encoding);
+    }
+};
+exports.getTexelDecodingFunction = function (functionName, encoding) {
+    var components = exports.getEncodingComponents(encoding);
+    return 'vec4 ' + functionName + '( vec4 value ) { return ' + components[0] + 'ToLinear' + components[1] + '; }';
+};
+
+
+/***/ }),
+
+/***/ "./src/vrm/material/index.ts":
+/*!***********************************!*\
+  !*** ./src/vrm/material/index.ts ***!
+  \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./MToonMaterial */ "./src/vrm/material/MToonMaterial.ts"));
+__export(__webpack_require__(/*! ./VRMMaterialImporter */ "./src/vrm/material/VRMMaterialImporter.ts"));
+__export(__webpack_require__(/*! ./VRMUnlitMaterial */ "./src/vrm/material/VRMUnlitMaterial.ts"));
+
+
+/***/ }),
+
+/***/ "./src/vrm/material/shaders/mtoon.frag":
+/*!*********************************************!*\
+  !*** ./src/vrm/material/shaders/mtoon.frag ***!
+  \*********************************************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = ("// #define PHONG\n\n#ifdef BLENDMODE_CUTOUT\n  uniform float cutoff;\n#endif\n\nuniform vec3 color;\nuniform float colorAlpha;\nuniform vec3 shadeColor;\n#ifdef USE_SHADETEXTURE\n  uniform sampler2D shadeTexture;\n#endif\n\nuniform float receiveShadowRate;\n#ifdef USE_RECEIVESHADOWTEXTURE\n  uniform sampler2D receiveShadowTexture;\n#endif\n\nuniform float shadingGradeRate;\n#ifdef USE_SHADINGGRADETEXTURE\n  uniform sampler2D shadingGradeTexture;\n#endif\n\nuniform float shadeShift;\nuniform float shadeToony;\nuniform float lightColorAttenuation;\nuniform float indirectLightIntensity;\n\n#ifdef USE_RIMTEXTURE\n  uniform sampler2D rimTexture;\n#endif\nuniform vec3 rimColor;\nuniform float rimLightingMix;\nuniform float rimFresnelPower;\nuniform float rimLift;\n\n#ifdef USE_SPHEREADD\n  uniform sampler2D sphereAdd;\n#endif\n\nuniform vec3 emissionColor;\n\nuniform vec3 outlineColor;\nuniform float outlineLightingMix;\n\n#ifdef USE_UVANIMMASKTEXTURE\n  uniform sampler2D uvAnimMaskTexture;\n#endif\n\nuniform float uvAnimOffsetX;\nuniform float uvAnimOffsetY;\nuniform float uvAnimTheta;\n\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n\n// #include <uv_pars_fragment>\n#if defined( USE_MAP ) || defined( USE_SHADETEXTURE ) || defined( USE_NORMALMAP ) || defined( USE_RECEIVESHADOWTEXTURE ) || defined( USE_SHADINGGRADETEXTURE ) || defined( USE_RIMTEXTURE ) || defined( USE_EMISSIVEMAP ) || defined( USE_OUTLINEWIDTHTEXTURE ) || defined( USE_UVANIMMASKTEXTURE )\n  varying vec2 vUv;\n#endif\n\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n// #include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n// #include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n// #include <envmap_pars_fragment>\n// #include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n\n// #include <lights_phong_pars_fragment>\nvarying vec3 vViewPosition;\n\n#ifndef FLAT_SHADED\n  varying vec3 vNormal;\n#endif\n\n#define Material_LightProbeLOD( material ) (0)\n\n#include <shadowmap_pars_fragment>\n// #include <bumpmap_pars_fragment>\n\n// #include <normalmap_pars_fragment>\n#ifdef USE_NORMALMAP\n  uniform sampler2D normalMap;\n  uniform float bumpScale;\n\n  // this number is very random, this is still a 対処療法\n  #define UV_DERIVATIVE_EPSILON 1E-6\n\n  // Per-Pixel Tangent Space Normal Mapping\n  // http://hacksoflife.blogspot.ch/2009/11/per-pixel-tangent-space-normal-mapping.html\n  vec3 perturbNormal2Arb( vec2 uv, vec3 eye_pos, vec3 surf_norm ) {\n    // Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988\n    vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n    vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n    vec2 st0 = dFdx( uv.st );\n    vec2 st1 = dFdy( uv.st );\n\n    float scale = sign( st1.t * st0.s - st0.t * st1.s ); // we do not care about the magnitude\n    vec3 S = ( q0 * st1.t - q1 * st0.t ) * scale;\n    vec3 T = ( - q0 * st1.s + q1 * st0.s ) * scale;\n\n    // Workaround for the issue that happens when delta of uv = 0.0\n    if ( length( S ) == 0.0 || length( T ) == 0.0 ) {\n      return surf_norm;\n    }\n\n    S = normalize( S );\n    T = normalize( T );\n    vec3 N = normalize( surf_norm );\n\n    vec3 mapN = texture2D( normalMap, uv ).xyz * 2.0 - 1.0;\n\n    mapN.xy *= bumpScale;\n\n    #ifdef DOUBLE_SIDED\n      // Workaround for Adreno GPUs gl_FrontFacing bug. See #15850 and #10331\n      // http://hacksoflife.blogspot.com/2009/11/per-pixel-tangent-space-normal-mapping.html?showComment=1522254677437#c5087545147696715943\n      vec3 NfromST = cross( S, T );\n      if( dot( NfromST, N ) > 0.0 ) {\n        S *= -1.0;\n        T *= -1.0;\n      }\n    #else\n      mapN.xy *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n    #endif\n\n    mat3 tsn = mat3( S, T, N );\n\n    return normalize( tsn * mapN );\n  }\n#endif\n\n// #include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\n\n// == lighting stuff ===========================================================\nfloat getLightIntensity(\n  const in IncidentLight directLight,\n  const in GeometricContext geometry,\n  const in float shadow,\n  const in float shadingGrade\n) {\n  float lightIntensity = dot( geometry.normal, directLight.direction );\n  lightIntensity = 0.5 + 0.5 * lightIntensity;\n  lightIntensity = lightIntensity * shadow;\n  lightIntensity = lightIntensity * shadingGrade;\n  lightIntensity = lightIntensity * 2.0 - 1.0;\n  return smoothstep( shadeShift, shadeShift + ( 1.0 - shadeToony ), lightIntensity );\n}\n\nvec3 getLighting( const in vec3 lightColor ) {\n  vec3 lighting = lightColor;\n  lighting = mix(\n    lighting,\n    vec3( max( 0.001, max( lighting.x, max( lighting.y, lighting.z ) ) ) ),\n    lightColorAttenuation\n  );\n\n  #ifndef PHYSICALLY_CORRECT_LIGHTS\n    lighting *= PI;\n  #endif\n\n  return lighting;\n}\n\nvec3 getDiffuse(\n  const in vec3 lit,\n  const in vec3 shade,\n  const in float lightIntensity,\n  const in vec3 lighting\n) {\n  #ifdef DEBUG_LITSHADERATE\n    return vec3( BRDF_Diffuse_Lambert( lightIntensity * lighting ) );\n  #endif\n\n  return lighting * BRDF_Diffuse_Lambert( mix( shade, lit, lightIntensity ) );\n}\n\nvec3 calcDirectDiffuse(\n  const in vec2 uv,\n  const in vec3 lit,\n  const in vec3 shade,\n  in GeometricContext geometry,\n  inout ReflectedLight reflectedLight\n) {\n  IncidentLight directLight;\n  vec3 lightingSum = vec3( 0.0 );\n\n  float shadingGrade = 1.0;\n  #ifdef USE_SHADINGGRADETEXTURE\n    shadingGrade = 1.0 - shadingGradeRate * ( 1.0 - texture2D( shadingGradeTexture, uv ).r );\n  #endif\n\n  float receiveShadow = receiveShadowRate;\n  #ifdef USE_RECEIVESHADOWTEXTURE\n    receiveShadow *= texture2D( receiveShadowTexture, uv ).a;\n  #endif\n\n  #if ( NUM_POINT_LIGHTS > 0 )\n    PointLight pointLight;\n\n    #pragma unroll_loop\n    for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n      pointLight = pointLights[ i ];\n      getPointDirectLightIrradiance( pointLight, geometry, directLight );\n\n      float atten = 1.0;\n      #ifdef USE_SHADOWMAP\n        atten = all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n      #endif\n\n      float shadow = 1.0 - receiveShadow * ( 1.0 - ( 0.5 + 0.5 * atten ) );\n      float lightIntensity = getLightIntensity( directLight, geometry, shadow, shadingGrade );\n      vec3 lighting = getLighting( directLight.color );\n      reflectedLight.directDiffuse += getDiffuse( lit, shade, lightIntensity, lighting );\n      lightingSum += lighting;\n    }\n  #endif\n\n  #if ( NUM_SPOT_LIGHTS > 0 )\n    SpotLight spotLight;\n\n    #pragma unroll_loop\n    for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n      spotLight = spotLights[ i ];\n      getSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\n      float atten = 1.0;\n      #ifdef USE_SHADOWMAP\n        atten = all( bvec2( spotLight.shadow, directLight.visible ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n      #endif\n\n      float shadow = 1.0 - receiveShadow * ( 1.0 - ( 0.5 + 0.5 * atten ) );\n      float lightIntensity = getLightIntensity( directLight, geometry, shadow, shadingGrade );\n      vec3 lighting = getLighting( directLight.color );\n      reflectedLight.directDiffuse += getDiffuse( lit, shade, lightIntensity, lighting );\n      lightingSum += lighting;\n    }\n  #endif\n\n  #if ( NUM_DIR_LIGHTS > 0 )\n    DirectionalLight directionalLight;\n\n    #pragma unroll_loop\n    for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n      directionalLight = directionalLights[ i ];\n      getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\n      float atten = 1.0;\n      #ifdef USE_SHADOWMAP\n        atten = all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n      #endif\n\n      float shadow = 1.0 - receiveShadow * ( 1.0 - ( 0.5 + 0.5 * atten ) );\n      float lightIntensity = getLightIntensity( directLight, geometry, shadow, shadingGrade );\n      vec3 lighting = getLighting( directLight.color );\n      reflectedLight.directDiffuse += getDiffuse( lit, shade, lightIntensity, lighting );\n      lightingSum += lighting;\n    }\n  #endif\n\n  return lightingSum;\n}\n\n// == post correction ==========================================================\nvoid postCorrection() {\n  #include <tonemapping_fragment>\n  #include <encodings_fragment>\n  #include <fog_fragment>\n  #include <premultiplied_alpha_fragment>\n  #include <dithering_fragment>\n}\n\n// == main procedure ===========================================================\nvoid main() {\n  #include <clipping_planes_fragment>\n\n  vec2 uv = vec2(0.5, 0.5);\n\n  #if defined( USE_MAP ) || defined( USE_SHADETEXTURE ) || defined( USE_NORMALMAP ) || defined( USE_RECEIVESHADOWTEXTURE ) || defined( USE_SHADINGGRADETEXTURE ) || defined( USE_RIMTEXTURE ) || defined( USE_EMISSIVEMAP ) || defined( USE_OUTLINEWIDTHTEXTURE ) || defined( USE_UVANIMMASKTEXTURE )\n    uv = vUv;\n\n    float uvAnimMask = 1.0;\n    #ifdef USE_UVANIMMASKTEXTURE\n      uvAnimMask = texture2D( uvAnimMaskTexture, uv ).x;\n    #endif\n\n    uv = uv + vec2( uvAnimOffsetX, uvAnimOffsetY ) * uvAnimMask;\n    float uvRotCos = cos( uvAnimTheta * uvAnimMask );\n    float uvRotSin = sin( uvAnimTheta * uvAnimMask );\n    uv = mat2( uvRotCos, uvRotSin, -uvRotSin, uvRotCos ) * ( uv - 0.5 ) + 0.5;\n  #endif\n\n  #ifdef DEBUG_UV\n    gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n    #if defined( USE_MAP ) || defined( USE_SHADETEXTURE ) || defined( USE_NORMALMAP ) || defined( USE_RECEIVESHADOWTEXTURE ) || defined( USE_SHADINGGRADETEXTURE ) || defined( USE_RIMTEXTURE ) || defined( USE_EMISSIVEMAP ) || defined( USE_OUTLINEWIDTHTEXTURE ) || defined( USE_UVANIMMASKTEXTURE )\n      gl_FragColor = vec4( uv, 0.0, 1.0 );\n    #endif\n    return;\n  #endif\n\n  vec4 diffuseColor = vec4( color, colorAlpha );\n  ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n  vec3 totalEmissiveRadiance = emissionColor;\n\n  #include <logdepthbuf_fragment>\n\n  // #include <map_fragment>\n  #ifdef USE_MAP\n    diffuseColor *= mapTexelToLinear( texture2D( map, uv ) );\n  #endif\n\n  #include <color_fragment>\n  // #include <alphamap_fragment>\n\n  // -- MToon: alpha -----------------------------------------------------------\n  // #include <alphatest_fragment>\n  #ifdef BLENDMODE_CUTOUT\n    if ( diffuseColor.a <= cutoff ) { discard; }\n    diffuseColor.a = 1.0;\n  #endif\n\n  #ifdef BLENDMODE_OPAQUE\n    diffuseColor.a = 1.0;\n  #endif\n\n  #if defined( OUTLINE ) && defined( OUTLINE_COLOR_FIXED ) // omitting DebugMode\n    gl_FragColor = vec4( outlineColor, diffuseColor.a );\n    postCorrection();\n    return;\n  #endif\n\n  // #include <specularmap_fragment>\n  #include <normal_fragment_begin>\n\n  #ifdef OUTLINE\n    normal *= -1.0;\n  #endif\n\n  // #include <normal_fragment_maps>\n  #ifdef USE_NORMALMAP\n    normal = perturbNormal2Arb( uv, -vViewPosition, normal );\n  #endif\n\n  // #include <emissivemap_fragment>\n  #ifdef USE_EMISSIVEMAP\n    totalEmissiveRadiance *= emissiveMapTexelToLinear( texture2D( emissiveMap, uv ) ).rgb;\n  #endif\n\n  #ifdef DEBUG_NORMAL\n    gl_FragColor = vec4( 0.5 + 0.5 * normal, 1.0 );\n    return;\n  #endif\n\n  // -- MToon: lighting --------------------------------------------------------\n  // accumulation\n  // #include <lights_phong_fragment>\n  // #include <lights_fragment_begin>\n  vec3 lit = diffuseColor.rgb;\n  vec3 shade = shadeColor;\n  #ifdef USE_SHADETEXTURE\n    shade *= shadeTextureTexelToLinear( texture2D( shadeTexture, uv ) ).rgb;\n  #endif\n\n  GeometricContext geometry;\n\n  geometry.position = - vViewPosition;\n  geometry.normal = normal;\n  geometry.viewDir = normalize( vViewPosition );\n\n  vec3 lighting = calcDirectDiffuse( uv, diffuseColor.rgb, shade, geometry, reflectedLight );\n\n  vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n  #if ( NUM_HEMI_LIGHTS > 0 )\n    #pragma unroll_loop\n    for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n      irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n    }\n  #endif\n\n  // #include <lights_fragment_maps>\n  #ifdef USE_LIGHTMAP\n    vec3 lightMapIrradiance = texture2D( lightMap, vUv2 ).rgb * lightMapIntensity;\n    #ifndef PHYSICALLY_CORRECT_LIGHTS\n      lightMapIrradiance *= PI; // factor of PI should not be present; included here to prevent breakage\n    #endif\n    irradiance += lightMapIrradiance;\n  #endif\n\n  // #include <lights_fragment_end>\n  reflectedLight.indirectDiffuse += indirectLightIntensity * irradiance * BRDF_Diffuse_Lambert( lit );\n\n  // modulation\n  #include <aomap_fragment>\n\n  vec3 col = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\n  #if defined( OUTLINE ) && defined( OUTLINE_COLOR_MIXED ) // omitting DebugMode\n    gl_FragColor = vec4(\n      outlineColor.rgb * mix( vec3( 1.0 ), col, outlineLightingMix ),\n      diffuseColor.a\n    );\n    postCorrection();\n    return;\n  #endif\n\n  // -- MToon: parametric rim lighting -----------------------------------------\n  vec3 viewDir = normalize( vViewPosition );\n  vec3 rimMix = mix(vec3(1.0), lighting + indirectLightIntensity * irradiance, rimLightingMix);\n  vec3 rim = rimColor * pow( saturate( 1.0 - dot( viewDir, normal ) + rimLift ), rimFresnelPower );\n  #ifdef USE_RIMTEXTURE\n    rim *= texture2D( rimTexture, uv ).rgb;\n  #endif\n  col += rim;\n\n  // -- MToon: additive matcap -------------------------------------------------\n  #ifdef USE_SPHEREADD\n    {\n      vec3 x = normalize( vec3( viewDir.z, 0.0, -viewDir.x ) );\n      vec3 y = cross( viewDir, x ); // guaranteed to be normalized\n      vec2 sphereUv = 0.5 + 0.5 * vec2( dot( x, normal ), -dot( y, normal ) );\n      vec3 matcap = sphereAddTexelToLinear( texture2D( sphereAdd, sphereUv ) ).xyz;\n      col += matcap;\n    }\n  #endif\n\n  // -- MToon: Emission --------------------------------------------------------\n  col += totalEmissiveRadiance;\n\n  // #include <envmap_fragment>\n\n  // -- Almost done! -----------------------------------------------------------\n  gl_FragColor = vec4( col, diffuseColor.a );\n  postCorrection();\n}");
+
+/***/ }),
+
+/***/ "./src/vrm/material/shaders/mtoon.vert":
+/*!*********************************************!*\
+  !*** ./src/vrm/material/shaders/mtoon.vert ***!
+  \*********************************************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = ("// #define PHONG\n\nvarying vec3 vViewPosition;\n\n#ifndef FLAT_SHADED\n  varying vec3 vNormal;\n#endif\n\n#include <common>\n\n// #include <uv_pars_vertex>\n#if defined( USE_MAP ) || defined( USE_SHADETEXTURE ) || defined( USE_NORMALMAP ) || defined( USE_RECEIVESHADOWTEXTURE ) || defined( USE_SHADINGGRADETEXTURE ) || defined( USE_RIMTEXTURE ) || defined( USE_EMISSIVEMAP ) || defined( USE_OUTLINEWIDTHTEXTURE ) || defined( USE_UVANIMMASKTEXTURE )\n  varying vec2 vUv;\n  uniform vec4 mainTex_ST;\n#endif\n\n#include <uv2_pars_vertex>\n// #include <displacementmap_pars_vertex>\n// #include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\n#ifdef USE_OUTLINEWIDTHTEXTURE\n  uniform sampler2D outlineWidthTexture;\n#endif\n\nuniform float outlineWidth;\nuniform float outlineScaledMaxDistance;\n\nvoid main() {\n\n  // #include <uv_vertex>\n  #if defined( USE_MAP ) || defined( USE_SHADETEXTURE ) || defined( USE_NORMALMAP ) || defined( USE_RECEIVESHADOWTEXTURE ) || defined( USE_SHADINGGRADETEXTURE ) || defined( USE_RIMTEXTURE ) || defined( USE_EMISSIVEMAP ) || defined( USE_OUTLINEWIDTHTEXTURE ) || defined( USE_UVANIMMASKTEXTURE )\n    vUv = vec2( mainTex_ST.p * uv.x + mainTex_ST.s, mainTex_ST.q * uv.y + mainTex_ST.t );\n  #endif\n\n  #include <uv2_vertex>\n  #include <color_vertex>\n\n  #include <beginnormal_vertex>\n  #include <morphnormal_vertex>\n  #include <skinbase_vertex>\n  #include <skinnormal_vertex>\n  #include <defaultnormal_vertex>\n\n  #ifndef FLAT_SHADED // Normal computed with derivatives when FLAT_SHADED\n    vNormal = normalize( transformedNormal );\n  #endif\n\n  #include <begin_vertex>\n\n  #include <morphtarget_vertex>\n  #include <skinning_vertex>\n  // #include <displacementmap_vertex>\n  #include <project_vertex>\n  #include <logdepthbuf_vertex>\n  #include <clipping_planes_vertex>\n\n  vViewPosition = - mvPosition.xyz;\n\n  float outlineTex = 1.0;\n\n  #ifdef OUTLINE\n    #ifdef USE_OUTLINEWIDTHTEXTURE\n      outlineTex = texture2D( outlineWidthTexture, vUv ).r;\n    #endif\n\n    #ifdef OUTLINE_WIDTH_WORLD\n      vec3 outlineOffset = 0.01 * outlineWidth * outlineTex * normalize( objectNormal );\n      gl_Position += projectionMatrix * modelViewMatrix * vec4( outlineOffset, 0.0 );\n    #endif\n\n    #ifdef OUTLINE_WIDTH_SCREEN\n      vec3 clipNormal = ( projectionMatrix * modelViewMatrix * vec4( normalize( objectNormal ), 0.0 ) ).xyz;\n      vec2 projectedNormal = normalize( clipNormal.xy );\n      projectedNormal *= min( gl_Position.w, outlineScaledMaxDistance );\n      projectedNormal.x *= projectionMatrix[ 0 ].x / projectionMatrix[ 1 ].y;\n      gl_Position.xy += 0.01 * outlineWidth * outlineTex * projectedNormal.xy;\n    #endif\n\n    gl_Position.z += 1E-6 * gl_Position.w; // anti-artifact magic\n  #endif\n\n  #include <worldpos_vertex>\n  // #include <envmap_vertex>\n  #include <shadowmap_vertex>\n  #include <fog_vertex>\n\n}");
+
+/***/ }),
+
+/***/ "./src/vrm/material/shaders/unlit.frag":
+/*!*********************************************!*\
+  !*** ./src/vrm/material/shaders/unlit.frag ***!
+  \*********************************************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = ("#ifdef RENDERTYPE_CUTOUT\n  uniform float cutoff;\n#endif\n\n#include <common>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n// #include <alphamap_pars_fragment>\n// #include <aomap_pars_fragment>\n// #include <lightmap_pars_fragment>\n// #include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n// #include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\n\n// == main procedure ===========================================================\nvoid main() {\n  #include <clipping_planes_fragment>\n\n  vec4 diffuseColor = vec4( 1.0 );\n\n  #include <logdepthbuf_fragment>\n\n  // #include <map_fragment>\n  #ifdef USE_MAP\n    diffuseColor *= mapTexelToLinear( texture2D( map, vUv ) );\n  #endif\n\n  #include <color_fragment>\n  // #include <alphamap_fragment>\n\n  // MToon: alpha\n  // #include <alphatest_fragment>\n  #ifdef RENDERTYPE_CUTOUT\n    if ( diffuseColor.a <= cutoff ) { discard; }\n    diffuseColor.a = 1.0;\n  #endif\n\n  #ifdef RENDERTYPE_OPAQUE\n    diffuseColor.a = 1.0;\n  #endif\n\n  // #include <specularmap_fragment>\n\n  ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\n  // accumulation (baked indirect lighting only)\n  #ifdef USE_LIGHTMAP\n    reflectedLight.indirectDiffuse += texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n  #else\n    reflectedLight.indirectDiffuse += vec3( 1.0 );\n  #endif\n\n  // modulation\n  // #include <aomap_fragment>\n\n  reflectedLight.indirectDiffuse *= diffuseColor.rgb;\n  vec3 outgoingLight = reflectedLight.indirectDiffuse;\n\n  // #include <envmap_fragment>\n\n  gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\n  #include <premultiplied_alpha_fragment>\n  #include <tonemapping_fragment>\n  #include <encodings_fragment>\n  #include <fog_fragment>\n}");
+
+/***/ }),
+
+/***/ "./src/vrm/material/shaders/unlit.vert":
+/*!*********************************************!*\
+  !*** ./src/vrm/material/shaders/unlit.vert ***!
+  \*********************************************/
+/*! exports provided: default */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony default export */ __webpack_exports__["default"] = ("#include <common>\n\n// #include <uv_pars_vertex>\n#ifdef USE_MAP\n  varying vec2 vUv;\n  uniform vec4 mainTex_ST;\n#endif\n\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\nvoid main() {\n\n  // #include <uv_vertex>\n  #ifdef USE_MAP\n    vUv = vec2( mainTex_ST.p * uv.x + mainTex_ST.s, mainTex_ST.q * uv.y + mainTex_ST.t );\n  #endif\n\n  #include <uv2_vertex>\n  #include <color_vertex>\n  #include <skinbase_vertex>\n\n  #ifdef USE_ENVMAP\n\n  #include <beginnormal_vertex>\n  #include <morphnormal_vertex>\n  #include <skinnormal_vertex>\n  #include <defaultnormal_vertex>\n\n  #endif\n\n  #include <begin_vertex>\n  #include <morphtarget_vertex>\n  #include <skinning_vertex>\n  #include <project_vertex>\n  #include <logdepthbuf_vertex>\n\n  #include <worldpos_vertex>\n  #include <clipping_planes_vertex>\n  #include <envmap_vertex>\n  #include <fog_vertex>\n\n}");
+
+/***/ }),
+
+/***/ "./src/vrm/reduceBones.ts":
+/*!********************************!*\
+  !*** ./src/vrm/reduceBones.ts ***!
+  \********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+function reduceBones(root) {
+    root.traverse(function (obj) {
+        if (obj.type !== 'SkinnedMesh') {
+            return;
+        }
+        var mesh = obj;
+        var geometry = mesh.geometry.clone();
+        mesh.geometry = geometry;
+        var attribute = geometry.getAttribute('skinIndex');
+        var bones = [];
+        var boneInverses = [];
+        var boneIndexMap = {};
+        var array = attribute.array.map(function (index) {
+            if (boneIndexMap[index] === undefined) {
+                boneIndexMap[index] = bones.length;
+                bones.push(mesh.skeleton.bones[index]);
+                boneInverses.push(mesh.skeleton.boneInverses[index]);
+            }
+            return boneIndexMap[index];
+        });
+        geometry.removeAttribute('skinIndex');
+        geometry.addAttribute('skinIndex', new THREE.BufferAttribute(array, 4, false));
+        mesh.bind(new THREE.Skeleton(bones, boneInverses), new THREE.Matrix4());
+    });
+}
+exports.reduceBones = reduceBones;
+
+
+/***/ }),
+
+/***/ "./src/vrm/springbone/VRMSpringBone.ts":
+/*!*********************************************!*\
+  !*** ./src/vrm/springbone/VRMSpringBone.ts ***!
+  \*********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var math_1 = __webpack_require__(/*! ../utils/math */ "./src/vrm/utils/math.ts");
+exports.GIZMO_RENDER_ORDER = 10000;
+var IDENTITY_MATRIX4 = Object.freeze(new THREE.Matrix4());
+var IDENTITY_QUATERNION = Object.freeze(new THREE.Quaternion());
+var _v3A = new THREE.Vector3();
+var _v3B = new THREE.Vector3();
+var _v3C = new THREE.Vector3();
+var _quatA = new THREE.Quaternion();
+var _matA = new THREE.Matrix4();
+var _matB = new THREE.Matrix4();
+var VRMSpringBone = (function () {
+    function VRMSpringBone(bone, radius, stiffiness, gravityDir, gravityPower, dragForce, colliders) {
+        var _this = this;
+        if (colliders === void 0) { colliders = []; }
+        this.bone = bone;
+        this.bone.matrixAutoUpdate = false;
+        this.radius = radius;
+        this.stiffnessForce = stiffiness;
+        this.gravityDir = gravityDir;
+        this.gravityPower = gravityPower;
+        this.dragForce = dragForce;
+        this.colliders = colliders;
+        this._worldPosition = new THREE.Vector3().setFromMatrixPosition(this.bone.matrixWorld);
+        this._parentWorldRotation = new THREE.Quaternion();
+        this._initialLocalMatrix = this.bone.matrix.clone();
+        this._initialLocalRotation = this.bone.quaternion.clone();
+        this._initialLocalChildPosition = (function () {
+            if (_this.bone.children.length === 0) {
+                return _this.bone.position
+                    .clone()
+                    .normalize()
+                    .multiplyScalar(0.07);
+            }
+            else {
+                var firstChild = _this.bone.children[0];
+                return firstChild.position.clone();
+            }
+        })();
+        this._currentTail = this.bone.localToWorld(this._initialLocalChildPosition.clone());
+        this._prevTail = this._currentTail.clone();
+        this._nextTail = this._currentTail.clone();
+        this._boneAxis = this._initialLocalChildPosition.clone().normalize();
+        this._worldBoneLength = this.bone
+            .localToWorld(_v3A.copy(this._initialLocalChildPosition))
+            .sub(this._worldPosition)
+            .length();
+    }
+    VRMSpringBone.prototype.reset = function () {
+        this.bone.matrix.copy(this._initialLocalMatrix);
+        this.bone.localToWorld(this._currentTail.copy(this._initialLocalChildPosition));
+        this._prevTail.copy(this._currentTail);
+        this._nextTail.copy(this._currentTail);
+        this.bone.updateMatrix();
+        this.bone.matrixWorld.multiplyMatrices(this._getParentMatrixWorld(), this.bone.matrix);
+        this._worldPosition.setFromMatrixPosition(this.bone.matrixWorld);
+    };
+    VRMSpringBone.prototype.update = function (delta) {
+        if (delta <= 0)
+            return;
+        this.bone.matrixWorld.multiplyMatrices(this._getParentMatrixWorld(), this.bone.matrix);
+        if (this.bone.parent) {
+            math_1.getWorldQuaternionLite(this.bone.parent, this._parentWorldRotation);
+        }
+        else {
+            this._parentWorldRotation.copy(IDENTITY_QUATERNION);
+        }
+        this._worldPosition.setFromMatrixPosition(this.bone.matrixWorld);
+        var stiffness = this.stiffnessForce * delta;
+        var external = _v3B.copy(this.gravityDir).multiplyScalar(this.gravityPower * delta);
+        this._nextTail
+            .copy(this._currentTail)
+            .add(_v3A
+            .copy(this._currentTail)
+            .sub(this._prevTail)
+            .multiplyScalar(1 - this.dragForce))
+            .add(_v3A
+            .copy(this._boneAxis)
+            .applyMatrix4(this._initialLocalMatrix)
+            .applyMatrix4(this._getParentMatrixWorld())
+            .sub(this._worldPosition)
+            .normalize()
+            .multiplyScalar(stiffness))
+            .add(external);
+        this._nextTail
+            .sub(this._worldPosition)
+            .normalize()
+            .multiplyScalar(this._worldBoneLength)
+            .add(this._worldPosition);
+        this._collision(this._nextTail);
+        this._prevTail.copy(this._currentTail);
+        this._currentTail.copy(this._nextTail);
+        var initialWorldMatrixInv = _matA.getInverse(_matB.copy(this._getParentMatrixWorld()).multiply(this._initialLocalMatrix));
+        var applyRotation = _quatA.setFromUnitVectors(this._boneAxis, _v3A
+            .copy(this._nextTail)
+            .applyMatrix4(initialWorldMatrixInv)
+            .normalize());
+        this.bone.quaternion.copy(this._initialLocalRotation).multiply(applyRotation);
+        this.bone.updateMatrix();
+        this.bone.matrixWorld.multiplyMatrices(this._getParentMatrixWorld(), this.bone.matrix);
+    };
+    VRMSpringBone.prototype._collision = function (tail) {
+        var _this = this;
+        this.colliders.forEach(function (collider) {
+            var colliderWorldPosition = _v3A.setFromMatrixPosition(collider.matrixWorld);
+            var colliderRadius = collider.geometry.boundingSphere.radius;
+            var r = _this.radius + colliderRadius;
+            if (tail.distanceToSquared(colliderWorldPosition) <= r * r) {
+                var normal = _v3B.subVectors(tail, colliderWorldPosition).normalize();
+                var posFromCollider = _v3C.addVectors(colliderWorldPosition, normal.multiplyScalar(r));
+                tail.copy(posFromCollider
+                    .sub(_this._worldPosition)
+                    .normalize()
+                    .multiplyScalar(_this._worldBoneLength)
+                    .add(_this._worldPosition));
+            }
+        });
+    };
+    VRMSpringBone.prototype._getParentMatrixWorld = function () {
+        return this.bone.parent ? this.bone.parent.matrixWorld : IDENTITY_MATRIX4;
+    };
+    return VRMSpringBone;
+}());
+exports.VRMSpringBone = VRMSpringBone;
+
+
+/***/ }),
+
+/***/ "./src/vrm/springbone/VRMSpringBoneColliderGroup.ts":
+/*!**********************************************************!*\
+  !*** ./src/vrm/springbone/VRMSpringBoneColliderGroup.ts ***!
+  \**********************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+/***/ }),
+
+/***/ "./src/vrm/springbone/VRMSpringBoneImporter.ts":
+/*!*****************************************************!*\
+  !*** ./src/vrm/springbone/VRMSpringBoneImporter.ts ***!
+  \*****************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+var VRMSpringBone_1 = __webpack_require__(/*! ./VRMSpringBone */ "./src/vrm/springbone/VRMSpringBone.ts");
+var VRMSpringBoneManager_1 = __webpack_require__(/*! ./VRMSpringBoneManager */ "./src/vrm/springbone/VRMSpringBoneManager.ts");
+var VRMSpringBoneImporter = (function () {
+    function VRMSpringBoneImporter() {
+    }
+    VRMSpringBoneImporter.prototype.import = function (gltf) {
+        return __awaiter(this, void 0, Promise, function () {
+            var colliderGroups, springBoneGroupList;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!gltf.parser.json.extensions ||
+                            !gltf.parser.json.extensions.VRM ||
+                            !gltf.parser.json.extensions.VRM.secondaryAnimation) {
+                            return [2, null];
+                        }
+                        return [4, this._getColliderMeshGroups(gltf)];
+                    case 1:
+                        colliderGroups = _a.sent();
+                        colliderGroups.forEach(function (group) {
+                            var _a;
+                            return (_a = gltf.scene).add.apply(_a, group.colliders);
+                        });
+                        return [4, this._getSpringBoneGroupList(gltf, colliderGroups)];
+                    case 2:
+                        springBoneGroupList = _a.sent();
+                        return [2, new VRMSpringBoneManager_1.VRMSpringBoneManager(springBoneGroupList)];
+                }
+            });
+        });
+    };
+    Object.defineProperty(VRMSpringBoneImporter.prototype, "_isColiderMeshVisible", {
+        get: function () {
+            return false;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    VRMSpringBoneImporter.prototype._createSpringBone = function (gltf, bone, hitRadius, stiffiness, gravityDir, gravityPower, dragForce, colliders) {
+        if (colliders === void 0) { colliders = []; }
+        return new VRMSpringBone_1.VRMSpringBone(bone, hitRadius, stiffiness, gravityDir, gravityPower, dragForce, colliders);
+    };
+    VRMSpringBoneImporter.prototype._getSpringBoneGroupList = function (gltf, colliderGroups) {
+        return __awaiter(this, void 0, Promise, function () {
+            var springBoneGroups, springBoneGroupList;
+            var _this = this;
+            return __generator(this, function (_a) {
+                springBoneGroups = gltf.parser.json.extensions.VRM.secondaryAnimation
+                    .boneGroups;
+                springBoneGroupList = [];
+                springBoneGroups.forEach(function (vrmBoneGroup) {
+                    if (vrmBoneGroup.stiffiness === undefined ||
+                        vrmBoneGroup.gravityDir === undefined ||
+                        vrmBoneGroup.gravityDir.x === undefined ||
+                        vrmBoneGroup.gravityDir.y === undefined ||
+                        vrmBoneGroup.gravityDir.z === undefined ||
+                        vrmBoneGroup.gravityPower === undefined ||
+                        vrmBoneGroup.dragForce === undefined ||
+                        vrmBoneGroup.hitRadius === undefined ||
+                        vrmBoneGroup.colliderGroups === undefined ||
+                        vrmBoneGroup.bones === undefined) {
+                        return;
+                    }
+                    var stiffiness = vrmBoneGroup.stiffiness;
+                    var gravityDir = new THREE.Vector3(vrmBoneGroup.gravityDir.x, vrmBoneGroup.gravityDir.y, vrmBoneGroup.gravityDir.z);
+                    var gravityPower = vrmBoneGroup.gravityPower;
+                    var dragForce = vrmBoneGroup.dragForce;
+                    var hitRadius = vrmBoneGroup.hitRadius;
+                    var colliders = [];
+                    vrmBoneGroup.colliderGroups.forEach(function (colliderIndex) {
+                        colliders.push.apply(colliders, colliderGroups[colliderIndex].colliders);
+                    });
+                    var springBoneGroup = [];
+                    vrmBoneGroup.bones.forEach(function (nodeIndex) { return __awaiter(_this, void 0, void 0, function () {
+                        var springRootBone;
+                        var _this = this;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4, gltf.parser.getDependency('node', nodeIndex)];
+                                case 1:
+                                    springRootBone = _a.sent();
+                                    if (!springRootBone) {
+                                        return [2];
+                                    }
+                                    springRootBone.traverse(function (bone) {
+                                        var springBone = _this._createSpringBone(gltf, bone, hitRadius, stiffiness, gravityDir, gravityPower, dragForce, colliders);
+                                        springBoneGroup.push(springBone);
+                                    });
+                                    return [2];
+                            }
+                        });
+                    }); });
+                    springBoneGroupList.push(springBoneGroup);
+                });
+                return [2, springBoneGroupList];
+            });
+        });
+    };
+    VRMSpringBoneImporter.prototype._getColliderMeshGroups = function (gltf) {
+        return __awaiter(this, void 0, Promise, function () {
+            var vrmExt, secondaryAnimation, vrmColliderGroups, colliderGroups;
+            var _this = this;
+            return __generator(this, function (_a) {
+                vrmExt = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;
+                if (vrmExt === undefined) {
+                    return [2, []];
+                }
+                secondaryAnimation = vrmExt.secondaryAnimation;
+                if (secondaryAnimation === undefined) {
+                    return [2, []];
+                }
+                vrmColliderGroups = secondaryAnimation.colliderGroups;
+                if (vrmColliderGroups === undefined) {
+                    return [2, []];
+                }
+                colliderGroups = [];
+                vrmColliderGroups.forEach(function (colliderGroup) { return __awaiter(_this, void 0, void 0, function () {
+                    var bone, colliders, colliderMeshGroup;
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (colliderGroup.node === undefined || colliderGroup.colliders === undefined) {
+                                    return [2];
+                                }
+                                return [4, gltf.parser.getDependency('node', colliderGroup.node)];
+                            case 1:
+                                bone = _a.sent();
+                                colliders = [];
+                                colliderGroup.colliders.forEach(function (collider) {
+                                    if (collider.offset === undefined ||
+                                        collider.offset.x === undefined ||
+                                        collider.offset.y === undefined ||
+                                        collider.offset.z === undefined ||
+                                        collider.radius === undefined) {
+                                        return;
+                                    }
+                                    var offsetMatrix = new THREE.Matrix4().makeTranslation(collider.offset.x, collider.offset.y, -collider.offset.z);
+                                    var visible = _this._isColiderMeshVisible;
+                                    var colliderMesh = new THREE.Mesh(new THREE.SphereBufferGeometry(collider.radius, 8, 4), new THREE.MeshBasicMaterial({
+                                        color: 0xff00ff,
+                                        visible: visible,
+                                        wireframe: true,
+                                        transparent: true,
+                                        depthTest: false,
+                                    }));
+                                    colliderMesh.material.renderOrder = VRMSpringBone_1.GIZMO_RENDER_ORDER;
+                                    colliderMesh.name = 'vrmColliderSphere';
+                                    colliderMesh.geometry.computeBoundingSphere();
+                                    colliderMesh.updateMatrixWorld = function () {
+                                        colliderMesh.matrixWorld.copy(bone.matrixWorld).multiply(offsetMatrix);
+                                    };
+                                    colliders.push(colliderMesh);
+                                });
+                                colliderMeshGroup = {
+                                    node: colliderGroup.node,
+                                    colliders: colliders,
+                                };
+                                colliderGroups.push(colliderMeshGroup);
+                                return [2];
+                        }
+                    });
+                }); });
+                return [2, colliderGroups];
+            });
+        });
+    };
+    return VRMSpringBoneImporter;
+}());
+exports.VRMSpringBoneImporter = VRMSpringBoneImporter;
+
+
+/***/ }),
+
+/***/ "./src/vrm/springbone/VRMSpringBoneManager.ts":
+/*!****************************************************!*\
+  !*** ./src/vrm/springbone/VRMSpringBoneManager.ts ***!
+  \****************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var VRMSpringBoneManager = (function () {
+    function VRMSpringBoneManager(springBoneGroupList) {
+        this.springBoneGroupList = [];
+        this.springBoneGroupList = springBoneGroupList;
+    }
+    VRMSpringBoneManager.prototype.lateUpdate = function (delta) {
+        this.springBoneGroupList.forEach(function (springBoneGroup) {
+            springBoneGroup.forEach(function (springBone) {
+                springBone.update(delta);
+            });
+        });
+    };
+    VRMSpringBoneManager.prototype.reset = function () {
+        this.springBoneGroupList.forEach(function (springBoneGroup) {
+            springBoneGroup.forEach(function (springBone) {
+                springBone.reset();
+            });
+        });
+    };
+    return VRMSpringBoneManager;
+}());
+exports.VRMSpringBoneManager = VRMSpringBoneManager;
+
+
+/***/ }),
+
+/***/ "./src/vrm/springbone/index.ts":
+/*!*************************************!*\
+  !*** ./src/vrm/springbone/index.ts ***!
+  \*************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./VRMSpringBone */ "./src/vrm/springbone/VRMSpringBone.ts"));
+__export(__webpack_require__(/*! ./VRMSpringBoneColliderGroup */ "./src/vrm/springbone/VRMSpringBoneColliderGroup.ts"));
+__export(__webpack_require__(/*! ./VRMSpringBoneImporter */ "./src/vrm/springbone/VRMSpringBoneImporter.ts"));
+__export(__webpack_require__(/*! ./VRMSpringBoneManager */ "./src/vrm/springbone/VRMSpringBoneManager.ts"));
+
+
+/***/ }),
+
+/***/ "./src/vrm/types/GLTFSchema.ts":
+/*!*************************************!*\
+  !*** ./src/vrm/types/GLTFSchema.ts ***!
+  \*************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+/***/ }),
+
+/***/ "./src/vrm/types/VRMSchema.ts":
+/*!************************************!*\
+  !*** ./src/vrm/types/VRMSchema.ts ***!
+  \************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var VRMSchema;
+(function (VRMSchema) {
+    var BlendShapePresetName;
+    (function (BlendShapePresetName) {
+        BlendShapePresetName["A"] = "a";
+        BlendShapePresetName["Angry"] = "angry";
+        BlendShapePresetName["Blink"] = "blink";
+        BlendShapePresetName["BlinkL"] = "blink_l";
+        BlendShapePresetName["BlinkR"] = "blink_r";
+        BlendShapePresetName["E"] = "e";
+        BlendShapePresetName["Fun"] = "fun";
+        BlendShapePresetName["I"] = "i";
+        BlendShapePresetName["Joy"] = "joy";
+        BlendShapePresetName["Lookdown"] = "lookdown";
+        BlendShapePresetName["Lookleft"] = "lookleft";
+        BlendShapePresetName["Lookright"] = "lookright";
+        BlendShapePresetName["Lookup"] = "lookup";
+        BlendShapePresetName["Neutral"] = "neutral";
+        BlendShapePresetName["O"] = "o";
+        BlendShapePresetName["Sorrow"] = "sorrow";
+        BlendShapePresetName["U"] = "u";
+        BlendShapePresetName["Unknown"] = "unknown";
+    })(BlendShapePresetName = VRMSchema.BlendShapePresetName || (VRMSchema.BlendShapePresetName = {}));
+    var FirstPersonLookAtTypeName;
+    (function (FirstPersonLookAtTypeName) {
+        FirstPersonLookAtTypeName["BlendShape"] = "BlendShape";
+        FirstPersonLookAtTypeName["Bone"] = "Bone";
+    })(FirstPersonLookAtTypeName = VRMSchema.FirstPersonLookAtTypeName || (VRMSchema.FirstPersonLookAtTypeName = {}));
+    var HumanoidBoneName;
+    (function (HumanoidBoneName) {
+        HumanoidBoneName["Chest"] = "chest";
+        HumanoidBoneName["Head"] = "head";
+        HumanoidBoneName["Hips"] = "hips";
+        HumanoidBoneName["Jaw"] = "jaw";
+        HumanoidBoneName["LeftEye"] = "leftEye";
+        HumanoidBoneName["LeftFoot"] = "leftFoot";
+        HumanoidBoneName["LeftHand"] = "leftHand";
+        HumanoidBoneName["LeftIndexDistal"] = "leftIndexDistal";
+        HumanoidBoneName["LeftIndexIntermediate"] = "leftIndexIntermediate";
+        HumanoidBoneName["LeftIndexProximal"] = "leftIndexProximal";
+        HumanoidBoneName["LeftLittleDistal"] = "leftLittleDistal";
+        HumanoidBoneName["LeftLittleIntermediate"] = "leftLittleIntermediate";
+        HumanoidBoneName["LeftLittleProximal"] = "leftLittleProximal";
+        HumanoidBoneName["LeftLowerArm"] = "leftLowerArm";
+        HumanoidBoneName["LeftLowerLeg"] = "leftLowerLeg";
+        HumanoidBoneName["LeftMiddleDistal"] = "leftMiddleDistal";
+        HumanoidBoneName["LeftMiddleIntermediate"] = "leftMiddleIntermediate";
+        HumanoidBoneName["LeftMiddleProximal"] = "leftMiddleProximal";
+        HumanoidBoneName["LeftRingDistal"] = "leftRingDistal";
+        HumanoidBoneName["LeftRingIntermediate"] = "leftRingIntermediate";
+        HumanoidBoneName["LeftRingProximal"] = "leftRingProximal";
+        HumanoidBoneName["LeftShoulder"] = "leftShoulder";
+        HumanoidBoneName["LeftThumbDistal"] = "leftThumbDistal";
+        HumanoidBoneName["LeftThumbIntermediate"] = "leftThumbIntermediate";
+        HumanoidBoneName["LeftThumbProximal"] = "leftThumbProximal";
+        HumanoidBoneName["LeftToes"] = "leftToes";
+        HumanoidBoneName["LeftUpperArm"] = "leftUpperArm";
+        HumanoidBoneName["LeftUpperLeg"] = "leftUpperLeg";
+        HumanoidBoneName["Neck"] = "neck";
+        HumanoidBoneName["RightEye"] = "rightEye";
+        HumanoidBoneName["RightFoot"] = "rightFoot";
+        HumanoidBoneName["RightHand"] = "rightHand";
+        HumanoidBoneName["RightIndexDistal"] = "rightIndexDistal";
+        HumanoidBoneName["RightIndexIntermediate"] = "rightIndexIntermediate";
+        HumanoidBoneName["RightIndexProximal"] = "rightIndexProximal";
+        HumanoidBoneName["RightLittleDistal"] = "rightLittleDistal";
+        HumanoidBoneName["RightLittleIntermediate"] = "rightLittleIntermediate";
+        HumanoidBoneName["RightLittleProximal"] = "rightLittleProximal";
+        HumanoidBoneName["RightLowerArm"] = "rightLowerArm";
+        HumanoidBoneName["RightLowerLeg"] = "rightLowerLeg";
+        HumanoidBoneName["RightMiddleDistal"] = "rightMiddleDistal";
+        HumanoidBoneName["RightMiddleIntermediate"] = "rightMiddleIntermediate";
+        HumanoidBoneName["RightMiddleProximal"] = "rightMiddleProximal";
+        HumanoidBoneName["RightRingDistal"] = "rightRingDistal";
+        HumanoidBoneName["RightRingIntermediate"] = "rightRingIntermediate";
+        HumanoidBoneName["RightRingProximal"] = "rightRingProximal";
+        HumanoidBoneName["RightShoulder"] = "rightShoulder";
+        HumanoidBoneName["RightThumbDistal"] = "rightThumbDistal";
+        HumanoidBoneName["RightThumbIntermediate"] = "rightThumbIntermediate";
+        HumanoidBoneName["RightThumbProximal"] = "rightThumbProximal";
+        HumanoidBoneName["RightToes"] = "rightToes";
+        HumanoidBoneName["RightUpperArm"] = "rightUpperArm";
+        HumanoidBoneName["RightUpperLeg"] = "rightUpperLeg";
+        HumanoidBoneName["Spine"] = "spine";
+        HumanoidBoneName["UpperChest"] = "upperChest";
+    })(HumanoidBoneName = VRMSchema.HumanoidBoneName || (VRMSchema.HumanoidBoneName = {}));
+    var MetaAllowedUserName;
+    (function (MetaAllowedUserName) {
+        MetaAllowedUserName["Everyone"] = "Everyone";
+        MetaAllowedUserName["ExplicitlyLicensedPerson"] = "ExplicitlyLicensedPerson";
+        MetaAllowedUserName["OnlyAuthor"] = "OnlyAuthor";
+    })(MetaAllowedUserName = VRMSchema.MetaAllowedUserName || (VRMSchema.MetaAllowedUserName = {}));
+    var MetaUssageName;
+    (function (MetaUssageName) {
+        MetaUssageName["Allow"] = "Allow";
+        MetaUssageName["Disallow"] = "Disallow";
+    })(MetaUssageName = VRMSchema.MetaUssageName || (VRMSchema.MetaUssageName = {}));
+    var MetaLicenseName;
+    (function (MetaLicenseName) {
+        MetaLicenseName["Cc0"] = "CC0";
+        MetaLicenseName["CcBy"] = "CC_BY";
+        MetaLicenseName["CcByNc"] = "CC_BY_NC";
+        MetaLicenseName["CcByNcNd"] = "CC_BY_NC_ND";
+        MetaLicenseName["CcByNcSa"] = "CC_BY_NC_SA";
+        MetaLicenseName["CcByNd"] = "CC_BY_ND";
+        MetaLicenseName["CcBySa"] = "CC_BY_SA";
+        MetaLicenseName["Other"] = "Other";
+        MetaLicenseName["RedistributionProhibited"] = "Redistribution_Prohibited";
+    })(MetaLicenseName = VRMSchema.MetaLicenseName || (VRMSchema.MetaLicenseName = {}));
+})(VRMSchema = exports.VRMSchema || (exports.VRMSchema = {}));
+
+
+/***/ }),
+
+/***/ "./src/vrm/types/index.ts":
+/*!********************************!*\
+  !*** ./src/vrm/types/index.ts ***!
+  \********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./GLTFSchema */ "./src/vrm/types/GLTFSchema.ts"));
+__export(__webpack_require__(/*! ./VRMSchema */ "./src/vrm/types/VRMSchema.ts"));
+__export(__webpack_require__(/*! ./types */ "./src/vrm/types/types.ts"));
+
+
+/***/ }),
+
+/***/ "./src/vrm/types/types.ts":
+/*!********************************!*\
+  !*** ./src/vrm/types/types.ts ***!
+  \********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+
+
+/***/ }),
+
+/***/ "./src/vrm/utils/disposer.ts":
+/*!***********************************!*\
+  !*** ./src/vrm/utils/disposer.ts ***!
+  \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+function disposeMaterial(material) {
+    Object.keys(material).forEach(function (propertyName) {
+        if (!!material[propertyName] && typeof material[propertyName].dispose === 'function') {
+            material[propertyName].dispose();
+        }
+    });
+    material.dispose();
+    material = undefined;
+}
+function dispose(object3D) {
+    if (object3D.geometry) {
+        object3D.geometry.dispose();
+        object3D.geometry = undefined;
+    }
+    if (!!object3D.material && Array.isArray(object3D.material)) {
+        object3D.material.forEach(function (material) { return disposeMaterial(material); });
+    }
+    else if (object3D.material) {
+        disposeMaterial(object3D.material);
+    }
+}
+function deepDispose(object3D) {
+    object3D.traverse(dispose);
+}
+exports.deepDispose = deepDispose;
+
+
+/***/ }),
+
+/***/ "./src/vrm/utils/math.ts":
+/*!*******************************!*\
+  !*** ./src/vrm/utils/math.ts ***!
+  \*******************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var THREE = __webpack_require__(/*! three */ "three");
+function saturate(value) {
+    return Math.max(Math.min(value, 1.0), 0.0);
+}
+exports.saturate = saturate;
+function linstep(x, min, max) {
+    if (x <= min)
+        return 0;
+    if (x >= max)
+        return 1;
+    return (x - min) / (max - min);
+}
+exports.linstep = linstep;
+var _position = new THREE.Vector3();
+var _scale = new THREE.Vector3();
+var _rotation = new THREE.Quaternion();
+function getWorldPositionLite(object, out) {
+    object.matrixWorld.decompose(out, _rotation, _scale);
+    return out;
+}
+exports.getWorldPositionLite = getWorldPositionLite;
+function getWorldScaleLite(object, out) {
+    object.matrixWorld.decompose(_position, _rotation, out);
+    return out;
+}
+exports.getWorldScaleLite = getWorldScaleLite;
+function getWorldQuaternionLite(object, out) {
+    object.matrixWorld.decompose(_position, out, _scale);
+    return out;
+}
+exports.getWorldQuaternionLite = getWorldQuaternionLite;
+
+
+/***/ }),
+
+/***/ "./src/vrm/utils/renameMaterialProperty.ts":
+/*!*************************************************!*\
+  !*** ./src/vrm/utils/renameMaterialProperty.ts ***!
+  \*************************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+function renameMaterialProperty(name) {
+    if (name[0] !== '_') {
+        console.warn("renameMaterialProperty: Given property name \"" + name + "\" might be invalid");
+        return name;
+    }
+    name = name.substring(1);
+    if (!/[A-Z]/.test(name[0])) {
+        console.warn("renameMaterialProperty: Given property name \"" + name + "\" might be invalid");
+        return name;
+    }
+    return name[0].toLowerCase() + name.substring(1);
+}
+exports.renameMaterialProperty = renameMaterialProperty;
+
+
+/***/ }),
+
+/***/ "three":
+/*!************************!*\
+  !*** external "THREE" ***!
+  \************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = THREE;
+
+/***/ })
+
+/******/ });
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://__three_vrm__/webpack/bootstrap","webpack://__three_vrm__/./src/assign.ts","webpack://__three_vrm__/./src/index.ts","webpack://__three_vrm__/./src/vrm/VRM.ts","webpack://__three_vrm__/./src/vrm/VRMImporter.ts","webpack://__three_vrm__/./src/vrm/blendshape/VRMBlendShapeGroup.ts","webpack://__three_vrm__/./src/vrm/blendshape/VRMBlendShapeImporter.ts","webpack://__three_vrm__/./src/vrm/blendshape/VRMBlendShapeProxy.ts","webpack://__three_vrm__/./src/vrm/blendshape/index.ts","webpack://__three_vrm__/./src/vrm/debug/VRMDebug.ts","webpack://__three_vrm__/./src/vrm/debug/VRMImporterDebug.ts","webpack://__three_vrm__/./src/vrm/debug/VRMLookAtHeadDebug.ts","webpack://__three_vrm__/./src/vrm/debug/VRMLookAtImporterDebug.ts","webpack://__three_vrm__/./src/vrm/debug/VRMSpringBoneDebug.ts","webpack://__three_vrm__/./src/vrm/debug/VRMSpringBoneImporterDebug.ts","webpack://__three_vrm__/./src/vrm/debug/index.ts","webpack://__three_vrm__/./src/vrm/firstperson/VRMFirstPerson.ts","webpack://__three_vrm__/./src/vrm/firstperson/VRMFirstPersonImporter.ts","webpack://__three_vrm__/./src/vrm/firstperson/index.ts","webpack://__three_vrm__/./src/vrm/humanoid/VRMHumanBone.ts","webpack://__three_vrm__/./src/vrm/humanoid/VRMHumanoid.ts","webpack://__three_vrm__/./src/vrm/humanoid/VRMHumanoidImporter.ts","webpack://__three_vrm__/./src/vrm/humanoid/index.ts","webpack://__three_vrm__/./src/vrm/index.ts","webpack://__three_vrm__/./src/vrm/lookat/CurveMapper.ts","webpack://__three_vrm__/./src/vrm/lookat/VRMLookAtApplyer.ts","webpack://__three_vrm__/./src/vrm/lookat/VRMLookAtBlendShapeApplyer.ts","webpack://__three_vrm__/./src/vrm/lookat/VRMLookAtBoneApplyer.ts","webpack://__three_vrm__/./src/vrm/lookat/VRMLookAtHead.ts","webpack://__three_vrm__/./src/vrm/lookat/VRMLookAtImporter.ts","webpack://__three_vrm__/./src/vrm/lookat/index.ts","webpack://__three_vrm__/./src/vrm/material/MToonMaterial.ts","webpack://__three_vrm__/./src/vrm/material/VRMMaterialImporter.ts","webpack://__three_vrm__/./src/vrm/material/VRMUnlitMaterial.ts","webpack://__three_vrm__/./src/vrm/material/getTexelDecodingFunction.ts","webpack://__three_vrm__/./src/vrm/material/index.ts","webpack://__three_vrm__/./src/vrm/material/shaders/mtoon.frag","webpack://__three_vrm__/./src/vrm/material/shaders/mtoon.vert","webpack://__three_vrm__/./src/vrm/material/shaders/unlit.frag","webpack://__three_vrm__/./src/vrm/material/shaders/unlit.vert","webpack://__three_vrm__/./src/vrm/reduceBones.ts","webpack://__three_vrm__/./src/vrm/springbone/VRMSpringBone.ts","webpack://__three_vrm__/./src/vrm/springbone/VRMSpringBoneImporter.ts","webpack://__three_vrm__/./src/vrm/springbone/VRMSpringBoneManager.ts","webpack://__three_vrm__/./src/vrm/springbone/index.ts","webpack://__three_vrm__/./src/vrm/types/VRMSchema.ts","webpack://__three_vrm__/./src/vrm/types/index.ts","webpack://__three_vrm__/./src/vrm/utils/disposer.ts","webpack://__three_vrm__/./src/vrm/utils/math.ts","webpack://__three_vrm__/./src/vrm/utils/renameMaterialProperty.ts","webpack://__three_vrm__/external \"THREE\""],"names":[],"mappings":"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","file":"three-vrm.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./src/assign.ts\");\n","/* eslint-disable */\nimport * as __three_vrm__ from '.';\n// @ts-ignore\nObject.assign(THREE, __three_vrm__);\n","export * from './vrm/';\n","import * as THREE from 'three';\nimport { VRMBlendShapeProxy } from './blendshape';\nimport { VRMFirstPerson } from './firstperson';\nimport { VRMHumanoid } from './humanoid';\nimport { VRMLookAtHead } from './lookat';\nimport { VRMSpringBoneManager } from './springbone';\nimport { VRMSchema } from './types';\nimport { deepDispose } from './utils/disposer';\nimport { VRMImporter, VRMImporterOptions } from './VRMImporter';\n\n/**\n * Parameters for a [[VRM]] class.\n */\nexport interface VRMParameters {\n  scene: THREE.Scene;\n  humanoid?: VRMHumanoid;\n  blendShapeProxy?: VRMBlendShapeProxy;\n  firstPerson?: VRMFirstPerson;\n  lookAt?: VRMLookAtHead;\n  materials?: THREE.Material[];\n  springBoneManager?: VRMSpringBoneManager;\n  meta?: VRMSchema.Meta;\n}\n\n/**\n * A class that represents a single VRM model.\n * See the documentation of [[VRM.from]] for the most basic use of VRM.\n */\nexport class VRM {\n  /**\n   * Create a new VRM from a parsed result of GLTF taken from GLTFLoader.\n   * It's probably a thing what you want to get started with VRMs.\n   *\n   * @example Most basic use of VRM\n   * ```\n   * const scene = new THREE.Scene();\n   *\n   * new THREE.GLTFLoader().load( 'models/three-vrm-girl.vrm', ( gltf ) => {\n   *\n   *   THREE.VRM.from( gltf ).then( ( vrm ) => {\n   *\n   *     scene.add( vrm.scene );\n   *\n   *   } );\n   *\n   * } );\n   * ```\n   *\n   * @param gltf A parsed GLTF object taken from GLTFLoader\n   * @param options Options that will be used in importer\n   */\n  public static async from(gltf: THREE.GLTF, options: VRMImporterOptions = {}): Promise<VRM> {\n    const importer = new VRMImporter(options);\n    return await importer.import(gltf);\n  }\n  /**\n   * `THREE.Scene` that contains the entire VRM.\n   */\n  public readonly scene: THREE.Scene;\n\n  /**\n   * Contains [[VRMHumanoid]] of the VRM.\n   * You can control each bones using [[VRMHumanoid.getBoneNode]].\n   *\n   * @TODO Add a link to VRM spec\n   */\n  public readonly humanoid?: VRMHumanoid;\n\n  /**\n   * Contains [[VRMBlendShapeProxy]] of the VRM.\n   * You might want to control these facial expressions via [[VRMBlendShapeProxy.setValue]].\n   */\n  public readonly blendShapeProxy?: VRMBlendShapeProxy;\n\n  /**\n   * Contains [[VRMFirstPerson]] of the VRM.\n   * You can use various feature of the firstPerson field.\n   */\n  public readonly firstPerson?: VRMFirstPerson;\n\n  /**\n   * Contains [[VRMLookAtHead]] of the VRM.\n   * You might want to use [[VRMLookAtHead.target]] to control the eye direction of your VRMs.\n   */\n  public readonly lookAt?: VRMLookAtHead;\n\n  /**\n   * Contains materials of the VRM.\n   * `updateVRMMaterials` method of these materials will be called via its [[VRM.update]] method.\n   */\n  public readonly materials?: THREE.Material[];\n\n  /**\n   * Contains meta fields of the VRM.\n   * You might want to refer these license fields before use your VRMs.\n   */\n  public readonly meta?: VRMSchema.Meta;\n\n  /**\n   * A [[VRMSpringBoneManager]] manipulates all spring bones attached on the VRM.\n   * Usually you don't have to care about this property.\n   */\n  public readonly springBoneManager?: VRMSpringBoneManager;\n\n  /**\n   * Create a new VRM instance.\n   *\n   * @param params [[VRMParameters]] that represents components of the VRM\n   */\n  public constructor(params: VRMParameters) {\n    this.scene = params.scene;\n    this.humanoid = params.humanoid;\n    this.blendShapeProxy = params.blendShapeProxy;\n    this.firstPerson = params.firstPerson;\n    this.lookAt = params.lookAt;\n    this.materials = params.materials;\n    this.springBoneManager = params.springBoneManager;\n    this.meta = params.meta;\n  }\n\n  /**\n   * **You need to call this on your update loop.**\n   *\n   * This function updates every VRM components.\n   *\n   * @param delta deltaTime\n   */\n  public update(delta: number): void {\n    if (this.lookAt) {\n      this.lookAt.update(delta);\n    }\n\n    if (this.blendShapeProxy) {\n      this.blendShapeProxy.update();\n    }\n\n    if (this.springBoneManager) {\n      this.springBoneManager.lateUpdate(delta);\n    }\n\n    if (this.materials) {\n      this.materials.forEach((material: any) => {\n        if (material.updateVRMMaterials) {\n          material.updateVRMMaterials(delta);\n        }\n      });\n    }\n  }\n\n  /**\n   * Dispose everything about the VRM instance.\n   */\n  public dispose(): void {\n    const scene = this.scene;\n    if (scene) {\n      while (scene.children.length > 0) {\n        const object = scene.children[scene.children.length - 1];\n        deepDispose(object);\n        scene.remove(object);\n      }\n    }\n  }\n}\n","import * as THREE from 'three';\nimport { VRMBlendShapeImporter } from './blendshape';\nimport { VRMFirstPersonImporter } from './firstperson';\nimport { VRMHumanoidImporter } from './humanoid/VRMHumanoidImporter';\nimport { VRMLookAtImporter } from './lookat/VRMLookAtImporter';\nimport { VRMMaterialImporter } from './material';\nimport { reduceBones } from './reduceBones';\nimport { VRMSpringBoneImporter } from './springbone/VRMSpringBoneImporter';\nimport { VRMSchema } from './types';\nimport { VRM } from './VRM';\n\nexport interface VRMImporterOptions {\n  lookAtImporter?: VRMLookAtImporter;\n  humanoidImporter?: VRMHumanoidImporter;\n  blendShapeImporter?: VRMBlendShapeImporter;\n  firstPersonImporter?: VRMFirstPersonImporter;\n  materialImporter?: VRMMaterialImporter;\n  springBoneImporter?: VRMSpringBoneImporter;\n}\n\n/**\n * An importer that imports a [[VRM]] from a VRM extension of a GLTF.\n */\nexport class VRMImporter {\n  protected readonly _blendShapeImporter: VRMBlendShapeImporter;\n  protected readonly _lookAtImporter: VRMLookAtImporter;\n  protected readonly _humanoidImporter: VRMHumanoidImporter;\n  protected readonly _firstPersonImporter: VRMFirstPersonImporter;\n  protected readonly _materialImporter: VRMMaterialImporter;\n  protected readonly _springBoneImporter: VRMSpringBoneImporter;\n\n  /**\n   * Create a new VRMImporter.\n   *\n   * @param options [[VRMImporterOptions]], optionally contains importers for each component\n   */\n  public constructor(options: VRMImporterOptions = {}) {\n    this._blendShapeImporter = options.blendShapeImporter || new VRMBlendShapeImporter();\n    this._lookAtImporter = options.lookAtImporter || new VRMLookAtImporter();\n    this._humanoidImporter = options.humanoidImporter || new VRMHumanoidImporter();\n    this._firstPersonImporter = options.firstPersonImporter || new VRMFirstPersonImporter();\n    this._materialImporter = options.materialImporter || new VRMMaterialImporter();\n    this._springBoneImporter = options.springBoneImporter || new VRMSpringBoneImporter();\n  }\n\n  /**\n   * Receive a GLTF object retrieved from `THREE.GLTFLoader` and create a new [[VRM]] instance.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  public async import(gltf: THREE.GLTF): Promise<VRM> {\n    if (gltf.parser.json.extensions === undefined || gltf.parser.json.extensions.VRM === undefined) {\n      throw new Error('Could not find VRM extension on the GLTF');\n    }\n    const vrmExt: VRMSchema.VRM = gltf.parser.json.extensions.VRM;\n\n    const scene = gltf.scene;\n\n    scene.updateMatrixWorld(false);\n\n    // Skinned object should not be frustumCulled\n    // Since pre-skinned position might be outside of view\n    scene.traverse((object3d) => {\n      if ((object3d as any).isMesh) {\n        object3d.frustumCulled = false;\n      }\n    });\n\n    reduceBones(scene);\n\n    const materials = (await this._materialImporter.convertGLTFMaterials(gltf)) || undefined;\n\n    const humanoid = (await this._humanoidImporter.import(gltf)) || undefined;\n\n    const firstPerson = humanoid ? (await this._firstPersonImporter.import(gltf, humanoid)) || undefined : undefined;\n\n    const blendShapeProxy = (await this._blendShapeImporter.import(gltf)) || undefined;\n\n    const lookAt =\n      firstPerson && blendShapeProxy && humanoid\n        ? (await this._lookAtImporter.import(gltf, firstPerson, blendShapeProxy, humanoid)) || undefined\n        : undefined;\n\n    const springBoneManager = (await this._springBoneImporter.import(gltf)) || undefined;\n\n    return new VRM({\n      scene: gltf.scene,\n      meta: vrmExt.meta,\n      materials,\n      humanoid,\n      firstPerson,\n      blendShapeProxy,\n      lookAt,\n      springBoneManager,\n    });\n  }\n}\n","import * as THREE from 'three';\nimport { GLTFPrimitive } from '../types';\n\nexport interface VRMBlendShapeBind {\n  meshes: GLTFPrimitive[];\n  morphTargetIndex: number;\n  weight: number;\n}\n\nenum VRMBlendShapeMaterialValueType {\n  NUMBER,\n  VECTOR2,\n  VECTOR3,\n  VECTOR4,\n  COLOR,\n}\n\nexport interface VRMBlendShapeMaterialValue {\n  material: THREE.Material;\n  propertyName: string;\n  defaultValue: number | THREE.Vector2 | THREE.Vector3 | THREE.Vector4 | THREE.Color;\n  targetValue: number | THREE.Vector2 | THREE.Vector3 | THREE.Vector4 | THREE.Color;\n  deltaValue: number | THREE.Vector2 | THREE.Vector3 | THREE.Vector4 | THREE.Color; // targetValue - defaultValue\n  type: VRMBlendShapeMaterialValueType;\n}\n\nconst _v2 = new THREE.Vector2();\nconst _v3 = new THREE.Vector3();\nconst _v4 = new THREE.Vector4();\nconst _color = new THREE.Color();\n\n// animationMixer の監視対象は、Scene の中に入っている必要がある。\n// そのため、表示オブジェクトではないけれど、Object3D を継承して Scene に投入できるようにする。\nexport class VRMBlendShapeGroup extends THREE.Object3D {\n  public weight = 0.0;\n  public isBinary = false;\n\n  private _binds: VRMBlendShapeBind[] = [];\n  private _materialValues: VRMBlendShapeMaterialValue[] = [];\n\n  constructor(expressionName: string) {\n    super();\n    this.name = `BlendShapeController_${expressionName}`;\n\n    // traverse 時の救済手段として Object3D ではないことを明示しておく\n    this.type = 'BlendShapeController';\n    // 表示目的のオブジェクトではないので、負荷軽減のために visible を false にしておく。\n    // これにより、このインスタンスに対する毎フレームの matrix 自動計算を省略できる。\n    this.visible = false;\n  }\n\n  public addBind(args: { meshes: GLTFPrimitive[]; morphTargetIndex: number; weight: number }): void {\n    // original weight is 0-100 but we want to deal with this value within 0-1\n    const weight = args.weight / 100;\n\n    this._binds.push({\n      meshes: args.meshes,\n      morphTargetIndex: args.morphTargetIndex,\n      weight,\n    });\n  }\n\n  public addMaterialValue(args: {\n    material: THREE.Material;\n    propertyName: string;\n    targetValue: number[];\n    defaultValue?: number | THREE.Vector2 | THREE.Vector3 | THREE.Vector4 | THREE.Color;\n  }): void {\n    const material = args.material;\n    const propertyName = args.propertyName;\n\n    let value = (material as any)[propertyName];\n    if (!value) {\n      // property has not been found\n      return;\n    }\n    value = args.defaultValue || value;\n\n    let type: VRMBlendShapeMaterialValueType;\n    let defaultValue: number | THREE.Vector2 | THREE.Vector3 | THREE.Vector4 | THREE.Color;\n    let targetValue: number | THREE.Vector2 | THREE.Vector3 | THREE.Vector4 | THREE.Color;\n    let deltaValue: number | THREE.Vector2 | THREE.Vector3 | THREE.Vector4 | THREE.Color;\n\n    if ((value as any).isVector2) {\n      type = VRMBlendShapeMaterialValueType.VECTOR2;\n      defaultValue = (value as THREE.Vector2).clone();\n      targetValue = new THREE.Vector2().fromArray(args.targetValue);\n      deltaValue = targetValue.clone().sub(defaultValue);\n    } else if ((value as any).isVector3) {\n      type = VRMBlendShapeMaterialValueType.VECTOR3;\n      defaultValue = (value as THREE.Vector3).clone();\n      targetValue = new THREE.Vector3().fromArray(args.targetValue);\n      deltaValue = targetValue.clone().sub(defaultValue);\n    } else if ((value as any).isVector4) {\n      type = VRMBlendShapeMaterialValueType.VECTOR4;\n      defaultValue = (value as THREE.Vector4).clone();\n\n      // vectorProperty and targetValue index is different from each other\n      // exported vrm by UniVRM file is\n      //\n      // vectorProperty\n      // offset = targetValue[0], targetValue[1]\n      // tiling = targetValue[2], targetValue[3]\n      //\n      // targetValue\n      // offset = targetValue[2], targetValue[3]\n      // tiling = targetValue[0], targetValue[1]\n      targetValue = new THREE.Vector4().fromArray([\n        args.targetValue[2],\n        args.targetValue[3],\n        args.targetValue[0],\n        args.targetValue[1],\n      ]);\n      deltaValue = targetValue.clone().sub(defaultValue);\n    } else if ((value as any).isColor) {\n      type = VRMBlendShapeMaterialValueType.COLOR;\n      defaultValue = (value as THREE.Color).clone();\n      targetValue = new THREE.Color().fromArray(args.targetValue);\n      deltaValue = targetValue.clone().sub(defaultValue);\n    } else {\n      type = VRMBlendShapeMaterialValueType.NUMBER;\n      defaultValue = value as number;\n      targetValue = args.targetValue[0];\n      deltaValue = targetValue - defaultValue;\n    }\n\n    this._materialValues.push({\n      material,\n      propertyName,\n      defaultValue,\n      targetValue,\n      deltaValue,\n      type,\n    });\n  }\n\n  /**\n   * Apply weight to every assigned blend shapes.\n   * Should be called via {@link BlendShapeMaster#update}.\n   */\n  public applyWeight(): void {\n    const w = this.isBinary ? (this.weight < 0.5 ? 0.0 : 1.0) : this.weight;\n\n    this._binds.forEach((bind) => {\n      bind.meshes.forEach((mesh) => {\n        if (!mesh.morphTargetInfluences) {\n          return;\n        } // TODO: we should kick this at `addBind`\n        mesh.morphTargetInfluences[bind.morphTargetIndex] += w * bind.weight;\n      });\n    });\n\n    this._materialValues.forEach((materialValue) => {\n      const prop = (materialValue.material as any)[materialValue.propertyName];\n      if (prop === undefined) {\n        return;\n      } // TODO: we should kick this at `addMaterialValue`\n\n      if (materialValue.type === VRMBlendShapeMaterialValueType.NUMBER) {\n        const deltaValue = materialValue.deltaValue as number;\n        (materialValue.material as any)[materialValue.propertyName] += deltaValue * w;\n      } else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR2) {\n        const deltaValue = materialValue.deltaValue as THREE.Vector2;\n        (materialValue.material as any)[materialValue.propertyName].add(_v2.copy(deltaValue).multiplyScalar(w));\n      } else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR3) {\n        const deltaValue = materialValue.deltaValue as THREE.Vector3;\n        (materialValue.material as any)[materialValue.propertyName].add(_v3.copy(deltaValue).multiplyScalar(w));\n      } else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR4) {\n        const deltaValue = materialValue.deltaValue as THREE.Vector4;\n        (materialValue.material as any)[materialValue.propertyName].add(_v4.copy(deltaValue).multiplyScalar(w));\n      } else if (materialValue.type === VRMBlendShapeMaterialValueType.COLOR) {\n        const deltaValue = materialValue.deltaValue as THREE.Color;\n        (materialValue.material as any)[materialValue.propertyName].add(_color.copy(deltaValue).multiplyScalar(w));\n      }\n\n      if (typeof (materialValue.material as any).shouldApplyUniforms === 'boolean') {\n        (materialValue.material as any).shouldApplyUniforms = true;\n      }\n    });\n  }\n\n  /**\n   * Clear previously assigned blend shapes.\n   */\n  public clearAppliedWeight(): void {\n    this._binds.forEach((bind) => {\n      bind.meshes.forEach((mesh) => {\n        if (!mesh.morphTargetInfluences) {\n          return;\n        } // TODO: we should kick this at `addBind`\n        mesh.morphTargetInfluences[bind.morphTargetIndex] = 0.0;\n      });\n    });\n\n    this._materialValues.forEach((materialValue) => {\n      const prop = (materialValue.material as any)[materialValue.propertyName];\n      if (prop === undefined) {\n        return;\n      } // TODO: we should kick this at `addMaterialValue`\n\n      if (materialValue.type === VRMBlendShapeMaterialValueType.NUMBER) {\n        const defaultValue = materialValue.defaultValue as number;\n        (materialValue.material as any)[materialValue.propertyName] = defaultValue;\n      } else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR2) {\n        const defaultValue = materialValue.defaultValue as THREE.Vector2;\n        (materialValue.material as any)[materialValue.propertyName].copy(defaultValue);\n      } else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR3) {\n        const defaultValue = materialValue.defaultValue as THREE.Vector3;\n        (materialValue.material as any)[materialValue.propertyName].copy(defaultValue);\n      } else if (materialValue.type === VRMBlendShapeMaterialValueType.VECTOR4) {\n        const defaultValue = materialValue.defaultValue as THREE.Vector4;\n        (materialValue.material as any)[materialValue.propertyName].copy(defaultValue);\n      } else if (materialValue.type === VRMBlendShapeMaterialValueType.COLOR) {\n        const defaultValue = materialValue.defaultValue as THREE.Color;\n        (materialValue.material as any)[materialValue.propertyName].copy(defaultValue);\n      }\n\n      if (typeof (materialValue.material as any).shouldApplyUniforms === 'boolean') {\n        (materialValue.material as any).shouldApplyUniforms = true;\n      }\n    });\n  }\n}\n","import * as THREE from 'three';\nimport { GLTFMesh, GLTFPrimitive, VRMSchema } from '../types';\nimport { renameMaterialProperty } from '../utils/renameMaterialProperty';\nimport { VRMBlendShapeGroup } from './VRMBlendShapeGroup';\nimport { VRMBlendShapeProxy } from './VRMBlendShapeProxy';\n\n/**\n * An importer that imports a [[VRMBlendShape]] from a VRM extension of a GLTF.\n */\nexport class VRMBlendShapeImporter {\n  /**\n   * Import a [[VRMBlendShape]] from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  public async import(gltf: THREE.GLTF): Promise<VRMBlendShapeProxy | null> {\n    const vrmExt: VRMSchema.VRM | undefined = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaBlendShape: VRMSchema.BlendShape | undefined = vrmExt.blendShapeMaster;\n    if (!schemaBlendShape) {\n      return null;\n    }\n\n    const blendShape = new VRMBlendShapeProxy();\n\n    const blendShapeGroups: VRMSchema.BlendShapeGroup[] | undefined = schemaBlendShape.blendShapeGroups;\n    if (!blendShapeGroups) {\n      return blendShape;\n    }\n\n    const blendShapePresetMap: { [presetName in VRMSchema.BlendShapePresetName]?: string } = {};\n\n    await Promise.all(\n      blendShapeGroups.map(async (schemaGroup) => {\n        const name = schemaGroup.name;\n        if (name === undefined) {\n          console.warn('VRMBlendShapeImporter: One of blendShapeGroups has no name');\n          return;\n        }\n\n        let presetName: VRMSchema.BlendShapePresetName | undefined;\n        if (\n          schemaGroup.presetName &&\n          schemaGroup.presetName !== VRMSchema.BlendShapePresetName.Unknown &&\n          !blendShapePresetMap[schemaGroup.presetName]\n        ) {\n          presetName = schemaGroup.presetName;\n          blendShapePresetMap[schemaGroup.presetName] = name;\n        }\n\n        const group = new VRMBlendShapeGroup(name);\n        gltf.scene.add(group);\n\n        group.isBinary = schemaGroup.isBinary || false;\n\n        if (schemaGroup.binds) {\n          schemaGroup.binds.forEach(async (bind) => {\n            if (bind.mesh === undefined || bind.index === undefined) {\n              return;\n            }\n\n            const morphMeshes: GLTFMesh = await gltf.parser.getDependency('mesh', bind.mesh);\n            const primitives: GLTFPrimitive[] =\n              morphMeshes.type === 'Group'\n                ? (morphMeshes.children as Array<GLTFPrimitive>)\n                : [morphMeshes as GLTFPrimitive];\n            const morphTargetIndex = bind.index;\n            if (\n              !primitives.every(\n                (primitive) =>\n                  Array.isArray(primitive.morphTargetInfluences) &&\n                  morphTargetIndex < primitive.morphTargetInfluences.length,\n              )\n            ) {\n              console.warn(\n                `VRMBlendShapeImporter: ${schemaGroup.name} attempts to index ${morphTargetIndex}th morph but not found.`,\n              );\n              return;\n            }\n\n            group.addBind({\n              meshes: primitives,\n              morphTargetIndex,\n              weight: bind.weight || 100,\n            });\n          });\n        }\n\n        const materialValues = schemaGroup.materialValues;\n        if (materialValues) {\n          materialValues.forEach((materialValue) => {\n            if (\n              materialValue.materialName === undefined ||\n              materialValue.propertyName === undefined ||\n              materialValue.targetValue === undefined\n            ) {\n              return;\n            }\n\n            const materials: THREE.Material[] = [];\n            gltf.scene.traverse((object) => {\n              if ((object as any).material) {\n                const material: THREE.Material[] | THREE.Material = (object as any).material;\n                if (Array.isArray(material)) {\n                  materials.push(\n                    ...material.filter(\n                      (mtl) => mtl.name === materialValue.materialName! && materials.indexOf(mtl) === -1,\n                    ),\n                  );\n                } else if (material.name === materialValue.materialName && materials.indexOf(material) === -1) {\n                  materials.push(material);\n                }\n              }\n            });\n\n            materials.forEach((material) => {\n              group.addMaterialValue({\n                material,\n                propertyName: renameMaterialProperty(materialValue.propertyName!),\n                targetValue: materialValue.targetValue!,\n              });\n            });\n          });\n        }\n\n        blendShape.registerBlendShapeGroup(name, presetName, group);\n      }),\n    );\n\n    return blendShape;\n  }\n}\n","import { VRMSchema } from '../types';\nimport { saturate } from '../utils/math';\nimport { VRMBlendShapeGroup } from './VRMBlendShapeGroup';\n\nexport class VRMBlendShapeProxy {\n  /**\n   * List of registered blend shape.\n   */\n  public readonly _blendShapeGroups: { [name: string]: VRMBlendShapeGroup } = {};\n\n  /**\n   * A map from [[VRMSchema.BlendShapePresetName]] to its actual blend shape name.\n   */\n  private readonly _blendShapePresetMap: { [presetName in VRMSchema.BlendShapePresetName]?: string } = {};\n\n  /**\n   * Create a new VRMBlendShape.\n   */\n  public constructor() {\n    // do nothing\n  }\n\n  /**\n   * List of name of registered blend shape group.\n   */\n  public get expressions(): string[] {\n    return Object.keys(this._blendShapeGroups);\n  }\n\n  /**\n   * Return registered blend shape group.\n   *\n   * @param name Name of the blend shape group\n   */\n  public getBlendShapeGroup(name: string | VRMSchema.BlendShapePresetName): VRMBlendShapeGroup | undefined {\n    const presetName = this._blendShapePresetMap[name as VRMSchema.BlendShapePresetName];\n    const controller = presetName ? this._blendShapeGroups[presetName] : this._blendShapeGroups[name];\n    if (!controller) {\n      console.warn(`no blend shape found by ${name}`);\n      return undefined;\n    }\n    return controller;\n  }\n\n  /**\n   * Register a blend shape group.\n   *\n   * @param name Name of the blend shape gorup\n   * @param controller VRMBlendShapeController that describes the blend shape group\n   */\n  public registerBlendShapeGroup(\n    name: string,\n    presetName: VRMSchema.BlendShapePresetName | undefined,\n    controller: VRMBlendShapeGroup,\n  ): void {\n    this._blendShapeGroups[name] = controller;\n    if (presetName) {\n      this._blendShapePresetMap[presetName] = name;\n    }\n  }\n\n  /**\n   * Get current weight of specified blend shape group.\n   *\n   * @param name Name of the blend shape group\n   */\n  public getValue(name: VRMSchema.BlendShapePresetName | string): number | null {\n    const controller = this.getBlendShapeGroup(name);\n    return (controller && controller.weight) || null;\n  }\n\n  /**\n   * Set a weight to specified blend shape group.\n   *\n   * @param name Name of the blend shape group\n   * @param weight Weight\n   */\n  public setValue(name: VRMSchema.BlendShapePresetName | string, weight: number): void {\n    const controller = this.getBlendShapeGroup(name);\n    if (controller) {\n      controller.weight = saturate(weight);\n    }\n  }\n\n  /**\n   * Get a track name of specified blend shape group.\n   * This track name is needed to manipulate its blend shape group via keyframe animations.\n   *\n   * @example Manipulate a blend shape group using keyframe animation\n   * ```js\n   * const trackName = vrm.blendShapeProxy.getBlendShapeTrackName( THREE.VRMSchema.BlendShapePresetName.Blink );\n   * const track = new THREE.NumberKeyframeTrack(\n   *   name,\n   *   [ 0.0, 0.5, 1.0 ], // times\n   *   [ 0.0, 1.0, 0.0 ] // values\n   * );\n   *\n   * const clip = new THREE.AnimationClip(\n   *   'blink', // name\n   *   1.0, // duration\n   *   [ track ] // tracks\n   * );\n   *\n   * const mixer = new THREE.AnimationMixer( vrm.scene );\n   * const action = mixer.clipAction( clip );\n   * action.play();\n   * ```\n   *\n   * @param name Name of the blend shape group\n   */\n  public getBlendShapeTrackName(name: VRMSchema.BlendShapePresetName | string): string | null {\n    const controller = this.getBlendShapeGroup(name);\n    return controller ? `${controller.name}.weight` : null;\n  }\n\n  /**\n   * Update every blend shape groups.\n   */\n  public update(): void {\n    Object.keys(this._blendShapeGroups).forEach((name) => {\n      const controller = this._blendShapeGroups[name];\n      controller.clearAppliedWeight();\n    });\n\n    Object.keys(this._blendShapeGroups).forEach((name) => {\n      const controller = this._blendShapeGroups[name];\n      controller.applyWeight();\n    });\n  }\n}\n","export * from './VRMBlendShapeGroup';\nexport * from './VRMBlendShapeImporter';\nexport * from './VRMBlendShapeProxy';\n","import * as THREE from 'three';\nimport { VRM, VRMParameters } from '../VRM';\nimport { VRMImporterOptions } from '../VRMImporter';\nimport { VRMDebugOptions } from './VRMDebugOptions';\nimport { VRMImporterDebug } from './VRMImporterDebug';\n\n/**\n * [[VRM]] but it has some useful gizmos.\n */\nexport class VRMDebug extends VRM {\n  /**\n   * Create a new VRMDebug from a parsed result of GLTF taken from GLTFLoader.\n   *\n   * See [[VRM.from]] for a detailed example.\n   *\n   * @param gltf A parsed GLTF object taken from GLTFLoader\n   * @param options Options that will be used in importer\n   * @param debugOption Options for VRMDebug features\n   */\n  public static async from(\n    gltf: THREE.GLTF,\n    options: VRMImporterOptions = {},\n    debugOption: VRMDebugOptions = {},\n  ): Promise<VRM> {\n    const importer = new VRMImporterDebug(options);\n    return await importer.import(gltf, debugOption);\n  }\n\n  /**\n   * Create a new VRMDebug instance.\n   *\n   * @param params [[VRMParameters]] that represents components of the VRM\n   * @param debugOption Options for VRMDebug features\n   */\n  constructor(params: VRMParameters, debugOption: VRMDebugOptions = {}) {\n    super(params);\n\n    // Gizmoを展開\n    if (!debugOption.disableBoxHelper) {\n      this.scene.add(new THREE.BoxHelper(this.scene));\n    }\n\n    if (!debugOption.disableSkeletonHelper) {\n      this.scene.add(new THREE.SkeletonHelper(this.scene));\n    }\n  }\n\n  public update(delta: number): void {\n    super.update(delta);\n  }\n}\n","import * as THREE from 'three';\nimport { reduceBones } from '../reduceBones';\nimport { VRMImporter, VRMImporterOptions } from '../VRMImporter';\nimport { VRMDebug } from './VRMDebug';\nimport { VRMDebugOptions } from './VRMDebugOptions';\nimport { VRMLookAtHeadDebug } from './VRMLookAtHeadDebug';\nimport { VRMLookAtImporterDebug } from './VRMLookAtImporterDebug';\nimport { VRMSpringBoneImporterDebug } from './VRMSpringBoneImporterDebug';\n\n/**\n * An importer that imports a [[VRMDebug]] from a VRM extension of a GLTF.\n */\nexport class VRMImporterDebug extends VRMImporter {\n  public constructor(options: VRMImporterOptions = {}) {\n    options.lookAtImporter = options.lookAtImporter || new VRMLookAtImporterDebug();\n    options.springBoneImporter = options.springBoneImporter || new VRMSpringBoneImporterDebug();\n    super(options);\n  }\n\n  public async import(gltf: THREE.GLTF, debugOptions: VRMDebugOptions = {}): Promise<VRMDebug> {\n    if (gltf.parser.json.extensions === undefined || gltf.parser.json.extensions.VRM === undefined) {\n      throw new Error('Could not find VRM extension on the GLTF');\n    }\n    const vrmExt = gltf.parser.json.extensions.VRM;\n\n    const scene = gltf.scene;\n\n    scene.updateMatrixWorld(false);\n\n    // Skinned object should not be frustumCulled\n    // Since pre-skinned position might be outside of view\n    scene.traverse((object3d) => {\n      if ((object3d as any).isMesh) {\n        object3d.frustumCulled = false;\n      }\n    });\n\n    reduceBones(scene);\n\n    const materials = (await this._materialImporter.convertGLTFMaterials(gltf)) || undefined;\n\n    const humanoid = (await this._humanoidImporter.import(gltf)) || undefined;\n\n    const firstPerson = humanoid ? (await this._firstPersonImporter.import(gltf, humanoid)) || undefined : undefined;\n\n    const blendShapeProxy = (await this._blendShapeImporter.import(gltf)) || undefined;\n\n    const lookAt =\n      firstPerson && blendShapeProxy && humanoid\n        ? (await this._lookAtImporter.import(gltf, firstPerson, blendShapeProxy, humanoid)) || undefined\n        : undefined;\n    if ((lookAt as any).setupHelper) {\n      (lookAt as VRMLookAtHeadDebug).setupHelper(scene, debugOptions);\n    }\n\n    const springBoneManager = (await this._springBoneImporter.import(gltf)) || undefined;\n\n    return new VRMDebug(\n      {\n        scene: gltf.scene,\n        meta: vrmExt.meta,\n        materials,\n        humanoid,\n        firstPerson,\n        blendShapeProxy,\n        lookAt,\n        springBoneManager,\n      },\n      debugOptions,\n    );\n  }\n}\n","import * as THREE from 'three';\nimport { VRMLookAtHead } from '../lookat/VRMLookAtHead';\nimport { VRMDebugOptions } from './VRMDebugOptions';\n\nconst _v3 = new THREE.Vector3();\n\nexport class VRMLookAtHeadDebug extends VRMLookAtHead {\n  private _faceDirectionHelper?: THREE.ArrowHelper;\n\n  public setupHelper(scene: THREE.Scene, debugOption: VRMDebugOptions): void {\n    if (!debugOption.disableFaceDirectionHelper) {\n      this._faceDirectionHelper = new THREE.ArrowHelper(\n        new THREE.Vector3(0, 0, -1),\n        new THREE.Vector3(0, 0, 0),\n        0.5,\n        0xff00ff,\n      );\n      scene.add(this._faceDirectionHelper);\n    }\n  }\n\n  public update(delta: number): void {\n    super.update(delta);\n\n    if (this._faceDirectionHelper) {\n      this.firstPerson.getFirstPersonWorldPosition(this._faceDirectionHelper.position);\n      this._faceDirectionHelper.setDirection(this.getLookAtWorldDirection(_v3));\n    }\n  }\n}\n","import * as THREE from 'three';\nimport { VRMBlendShapeProxy } from '../blendshape';\nimport { VRMFirstPerson } from '../firstperson';\nimport { VRMHumanoid } from '../humanoid';\nimport { VRMLookAtHead } from '../lookat/VRMLookAtHead';\nimport { VRMLookAtImporter } from '../lookat/VRMLookAtImporter';\nimport { VRMSchema } from '../types';\nimport { VRMLookAtHeadDebug } from './VRMLookAtHeadDebug';\n\nexport class VRMLookAtImporterDebug extends VRMLookAtImporter {\n  public import(\n    gltf: THREE.GLTF,\n    firstPerson: VRMFirstPerson,\n    blendShapeProxy: VRMBlendShapeProxy,\n    humanoid: VRMHumanoid,\n  ): VRMLookAtHead | null {\n    const vrmExt: VRMSchema.VRM | undefined = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaFirstPerson: VRMSchema.FirstPerson | undefined = vrmExt.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const applyer = this._importApplyer(schemaFirstPerson, blendShapeProxy, humanoid);\n    return new VRMLookAtHeadDebug(firstPerson, applyer || undefined);\n  }\n}\n","import * as THREE from 'three';\nimport { GIZMO_RENDER_ORDER, VRMSpringBone } from '../springbone';\n\nconst _v3A = new THREE.Vector3();\n\nexport class VRMSpringBoneDebug extends VRMSpringBone {\n  private _gizmo?: THREE.ArrowHelper;\n\n  constructor(\n    bone: THREE.Object3D,\n    radius: number,\n    stiffiness: number,\n    gravityDir: THREE.Vector3,\n    gravityPower: number,\n    dragForce: number,\n    colliders: THREE.Mesh[] = [],\n  ) {\n    super(bone, radius, stiffiness, gravityDir, gravityPower, dragForce, colliders);\n  }\n\n  /**\n   * Return spring bone gizmo, as `THREE.ArrowHelper`.\n   * Useful in debugging spring bones.\n   */\n  public getGizmo(): THREE.ArrowHelper {\n    // return if gizmo is already existed\n    if (this._gizmo) {\n      return this._gizmo;\n    }\n\n    const nextTailRelative = _v3A.copy(this._nextTail).sub(this._worldPosition);\n    const nextTailRelativeLength = nextTailRelative.length();\n\n    this._gizmo = new THREE.ArrowHelper(\n      nextTailRelative.normalize(),\n      this._worldPosition,\n      nextTailRelativeLength,\n      0xffff00,\n      this.radius,\n      this.radius,\n    );\n\n    // it should be always visible\n    this._gizmo.line.renderOrder = GIZMO_RENDER_ORDER;\n    this._gizmo.cone.renderOrder = GIZMO_RENDER_ORDER;\n    (this._gizmo.line.material as THREE.Material).depthTest = false;\n    (this._gizmo.line.material as THREE.Material).transparent = true;\n    (this._gizmo.cone.material as THREE.Material).depthTest = false;\n    (this._gizmo.cone.material as THREE.Material).transparent = true;\n\n    return this._gizmo;\n  }\n\n  public update(delta: number): void {\n    super.update(delta);\n    // lastly we're gonna update gizmo\n    this._updateGizmo();\n  }\n\n  private _updateGizmo(): void {\n    if (!this._gizmo) {\n      return;\n    }\n\n    const nextTailRelative = _v3A.copy(this._currentTail).sub(this._worldPosition);\n    const nextTailRelativeLength = nextTailRelative.length();\n\n    this._gizmo.setDirection(nextTailRelative.normalize());\n    this._gizmo.setLength(nextTailRelativeLength, this.radius, this.radius);\n    this._gizmo.position.copy(this._worldPosition);\n  }\n}\n","import * as THREE from 'three';\nimport { VRMSpringBone } from '../springbone/VRMSpringBone';\nimport { VRMSpringBoneImporter } from '../springbone/VRMSpringBoneImporter';\nimport { VRMSpringBoneDebug } from './VRMSpringBoneDebug';\n\nexport class VRMSpringBoneImporterDebug extends VRMSpringBoneImporter {\n  protected get _isColiderMeshVisible(): boolean {\n    return true;\n  }\n\n  protected _createSpringBone(\n    gltf: THREE.GLTF,\n    bone: THREE.Object3D,\n    hitRadius: number,\n    stiffiness: number,\n    gravityDir: THREE.Vector3,\n    gravityPower: number,\n    dragForce: number,\n    colliders: THREE.Mesh[] = [],\n  ): VRMSpringBone {\n    const springBone = new VRMSpringBoneDebug(\n      bone,\n      hitRadius,\n      stiffiness,\n      gravityDir,\n      gravityPower,\n      dragForce,\n      colliders,\n    );\n    gltf.scene.add(springBone.getGizmo());\n    return springBone;\n  }\n}\n","export * from './VRMDebugOptions';\nexport * from './VRMDebug';\nexport * from './VRMSpringBoneDebug';\nexport * from './VRMSpringBoneImporterDebug';\n","import * as THREE from 'three';\nimport { GLTFMesh, GLTFNode } from '../types';\nimport { getWorldQuaternionLite } from '../utils/math';\n\nconst VECTOR3_FRONT = Object.freeze(new THREE.Vector3(0.0, 0.0, -1.0));\n\nconst _quat = new THREE.Quaternion();\n\nenum FirstPersonFlag {\n  Auto,\n  Both,\n  ThirdPersonOnly,\n  FirstPersonOnly,\n}\n\n/**\n * This class represents a single [`meshAnnotation`](https://github.com/vrm-c/UniVRM/blob/master/specification/0.0/schema/vrm.firstperson.meshannotation.schema.json) entry.\n * Each mesh will be assigned to specified layer when you call [[VRMFirstPerson.setup]].\n */\nexport class VRMRendererFirstPersonFlags {\n  private static _parseFirstPersonFlag(firstPersonFlag: string | undefined): FirstPersonFlag {\n    switch (firstPersonFlag) {\n      case 'Both':\n        return FirstPersonFlag.Both;\n      case 'ThirdPersonOnly':\n        return FirstPersonFlag.ThirdPersonOnly;\n      case 'FirstPersonOnly':\n        return FirstPersonFlag.FirstPersonOnly;\n      default:\n        return FirstPersonFlag.Auto;\n    }\n  }\n\n  /**\n   * A [[FirstPersonFlag]] of the annotation entry.\n   */\n  public firstPersonFlag: FirstPersonFlag;\n\n  /**\n   * A mesh of the annotation entry.\n   */\n  public mesh: GLTFMesh;\n\n  /**\n   * Create a new mesh annotation.\n   *\n   * @param firstPersonFlag A [[FirstPersonFlag]] of the annotation entry\n   * @param node A node of the annotation entry.\n   */\n  constructor(firstPersonFlag: string | undefined, mesh: GLTFMesh) {\n    this.firstPersonFlag = VRMRendererFirstPersonFlags._parseFirstPersonFlag(firstPersonFlag);\n    this.mesh = mesh;\n  }\n}\n\nexport class VRMFirstPerson {\n  /**\n   * A default camera layer for `FirstPersonOnly` layer.\n   *\n   * @see [[getFirstPersonOnlyLayer]]\n   */\n  private static readonly _DEFAULT_FIRSTPERSON_ONLY_LAYER = 9;\n\n  /**\n   * A default camera layer for `ThirdPersonOnly` layer.\n   *\n   * @see [[getThirdPersonOnlyLayer]]\n   */\n  private static readonly _DEFAULT_THIRDPERSON_ONLY_LAYER = 10;\n\n  private readonly _firstPersonBone: GLTFNode;\n  private readonly _meshAnnotations: VRMRendererFirstPersonFlags[] = [];\n  private readonly _firstPersonBoneOffset: THREE.Vector3;\n\n  private _firstPersonOnlyLayer = VRMFirstPerson._DEFAULT_FIRSTPERSON_ONLY_LAYER;\n  private _thirdPersonOnlyLayer = VRMFirstPerson._DEFAULT_THIRDPERSON_ONLY_LAYER;\n\n  private _initialized = false;\n\n  /**\n   * Create a new VRMFirstPerson object.\n   *\n   * @param firstPersonBone A first person bone\n   * @param firstPersonBoneOffset An offset from the specified first person bone\n   * @param meshAnnotations A renderer settings. See the description of [[RendererFirstPersonFlags]] for more info\n   */\n  constructor(\n    firstPersonBone: GLTFNode,\n    firstPersonBoneOffset: THREE.Vector3,\n    meshAnnotations: VRMRendererFirstPersonFlags[],\n  ) {\n    this._firstPersonBone = firstPersonBone;\n    this._firstPersonBoneOffset = firstPersonBoneOffset;\n    this._meshAnnotations = meshAnnotations;\n  }\n\n  public get firstPersonBone(): GLTFNode {\n    return this._firstPersonBone;\n  }\n\n  public get meshAnnotations(): VRMRendererFirstPersonFlags[] {\n    return this._meshAnnotations;\n  }\n\n  public getFirstPersonWorldDirection(target: THREE.Vector3): THREE.Vector3 {\n    return target.copy(VECTOR3_FRONT).applyQuaternion(getWorldQuaternionLite(this._firstPersonBone, _quat));\n  }\n\n  /**\n   * A camera layer represents `FirstPersonOnly` layer.\n   * Note that **you must call [[setup]] first before you use the layer feature** or it does not work properly.\n   *\n   * The value is [[DEFAULT_FIRSTPERSON_ONLY_LAYER]] by default but you can change the layer by specifying via [[setup]] if you prefer.\n   *\n   * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/\n   * @see https://threejs.org/docs/#api/en/core/Layers\n   */\n  public get firstPersonOnlyLayer(): number {\n    return this._firstPersonOnlyLayer;\n  }\n\n  /**\n   * A camera layer represents `ThirdPersonOnly` layer.\n   * Note that **you must call [[setup]] first before you use the layer feature** or it does not work properly.\n   *\n   * The value is [[DEFAULT_THIRDPERSON_ONLY_LAYER]] by default but you can change the layer by specifying via [[setup]] if you prefer.\n   *\n   * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/\n   * @see https://threejs.org/docs/#api/en/core/Layers\n   */\n  public get thirdPersonOnlyLayer(): number {\n    return this._thirdPersonOnlyLayer;\n  }\n\n  public getFirstPersonBoneOffset(target: THREE.Vector3): THREE.Vector3 {\n    return target.copy(this._firstPersonBoneOffset);\n  }\n\n  /**\n   * Get current world position of the first person.\n   * The position takes [[FirstPersonBone]] and [[FirstPersonOffset]] into account.\n   *\n   * @param v3 target\n   * @returns Current world position of the first person\n   */\n  public getFirstPersonWorldPosition(v3: THREE.Vector3): THREE.Vector3 {\n    // UniVRM#VRMFirstPersonEditor\n    // var worldOffset = head.localToWorldMatrix.MultiplyPoint(component.FirstPersonOffset);\n    const offset = this._firstPersonBoneOffset;\n    const v4 = new THREE.Vector4(offset.x, offset.y, offset.z, 1.0);\n    v4.applyMatrix4(this._firstPersonBone.matrixWorld);\n    return v3.set(v4.x, v4.y, v4.z);\n  }\n\n  /**\n   * In this method, it assigns layers for every meshes based on mesh annotations.\n   * You must call this method first before you use the layer feature.\n   *\n   * This is an equivalent of [VRMFirstPerson.Setup](https://github.com/vrm-c/UniVRM/blob/master/Assets/VRM/UniVRM/Scripts/FirstPerson/VRMFirstPerson.cs) of the UniVRM.\n   *\n   * The `cameraLayer` parameter specifies which layer will be assigned for `FirstPersonOnly` / `ThirdPersonOnly`.\n   * In UniVRM, we specified those by naming each desired layer as `FIRSTPERSON_ONLY_LAYER` / `THIRDPERSON_ONLY_LAYER`\n   * but we are going to specify these layers at here since we are unable to name layers in Three.js.\n   *\n   * @param cameraLayer Specify which layer will be for `FirstPersonOnly` / `ThirdPersonOnly`.\n   */\n  public setup({\n    firstPersonOnlyLayer = VRMFirstPerson._DEFAULT_FIRSTPERSON_ONLY_LAYER,\n    thirdPersonOnlyLayer = VRMFirstPerson._DEFAULT_THIRDPERSON_ONLY_LAYER,\n  } = {}): void {\n    if (this._initialized) {\n      return;\n    }\n    this._initialized = true;\n    this._firstPersonOnlyLayer = firstPersonOnlyLayer;\n    this._thirdPersonOnlyLayer = thirdPersonOnlyLayer;\n\n    this._meshAnnotations.forEach((item) => {\n      if (item.firstPersonFlag === FirstPersonFlag.FirstPersonOnly) {\n        item.mesh.layers.set(this._firstPersonOnlyLayer);\n        item.mesh.traverse((child) => child.layers.set(this._firstPersonOnlyLayer));\n      } else if (item.firstPersonFlag === FirstPersonFlag.ThirdPersonOnly) {\n        item.mesh.layers.set(this._thirdPersonOnlyLayer);\n        item.mesh.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n      } else if (item.firstPersonFlag === FirstPersonFlag.Auto) {\n        this._createHeadlessModel(item.mesh);\n      }\n    });\n  }\n\n  private _excludeTriangles(triangles: number[], bws: number[][], skinIndex: number[][], exclude: number[]): number {\n    let count = 0;\n    if (bws != null && bws.length > 0) {\n      for (let i = 0; i < triangles.length; i += 3) {\n        const a = triangles[i];\n        const b = triangles[i + 1];\n        const c = triangles[i + 2];\n        const bw0 = bws[a];\n        const skin0 = skinIndex[a];\n\n        if (bw0[0] > 0 && exclude.includes(skin0[0])) continue;\n        if (bw0[1] > 0 && exclude.includes(skin0[1])) continue;\n        if (bw0[2] > 0 && exclude.includes(skin0[2])) continue;\n        if (bw0[3] > 0 && exclude.includes(skin0[3])) continue;\n\n        const bw1 = bws[b];\n        const skin1 = skinIndex[b];\n        if (bw1[0] > 0 && exclude.includes(skin1[0])) continue;\n        if (bw1[1] > 0 && exclude.includes(skin1[1])) continue;\n        if (bw1[2] > 0 && exclude.includes(skin1[2])) continue;\n        if (bw1[3] > 0 && exclude.includes(skin1[3])) continue;\n\n        const bw2 = bws[c];\n        const skin2 = skinIndex[c];\n        if (bw2[0] > 0 && exclude.includes(skin2[0])) continue;\n        if (bw2[1] > 0 && exclude.includes(skin2[1])) continue;\n        if (bw2[2] > 0 && exclude.includes(skin2[2])) continue;\n        if (bw2[3] > 0 && exclude.includes(skin2[3])) continue;\n\n        triangles[count++] = a;\n        triangles[count++] = b;\n        triangles[count++] = c;\n      }\n    }\n    return count;\n  }\n\n  private _createErasedMesh(src: THREE.SkinnedMesh, erasingBonesIndex: number[]): THREE.SkinnedMesh {\n    const dst = new THREE.SkinnedMesh(src.geometry.clone(), src.material);\n    dst.name = `${src.name}(erase)`;\n    dst.frustumCulled = src.frustumCulled;\n    dst.layers.set(this._firstPersonOnlyLayer);\n\n    const geometry = dst.geometry as THREE.BufferGeometry;\n    const skinIndexAttr = geometry.getAttribute('skinIndex').array;\n    const skinIndex = [];\n    for (let i = 0; i < skinIndexAttr.length; i += 4) {\n      skinIndex.push([skinIndexAttr[i], skinIndexAttr[i + 1], skinIndexAttr[i + 2], skinIndexAttr[i + 3]]);\n    }\n    const skinWeightAttr = geometry.getAttribute('skinWeight').array;\n    const skinWeight = [];\n    for (let i = 0; i < skinWeightAttr.length; i += 4) {\n      skinWeight.push([skinWeightAttr[i], skinWeightAttr[i + 1], skinWeightAttr[i + 2], skinWeightAttr[i + 3]]);\n    }\n    const oldTriangles = Array.from(geometry.getIndex().array);\n    const count = this._excludeTriangles(oldTriangles, skinWeight, skinIndex, erasingBonesIndex);\n    const newTriangle: number[] = [];\n    for (let i = 0; i < count; i++) {\n      newTriangle[i] = oldTriangles[i];\n    }\n    geometry.setIndex(newTriangle);\n\n    // mtoon material includes onBeforeRender. this is unsupported at SkinnedMesh#clone\n    if (src.onBeforeRender) {\n      dst.onBeforeRender = src.onBeforeRender;\n    }\n    dst.bind(new THREE.Skeleton(src.skeleton.bones, src.skeleton.boneInverses), new THREE.Matrix4());\n    return dst;\n  }\n\n  private _createHeadlessModelForSkinnedMesh(parent: THREE.Object3D, mesh: THREE.SkinnedMesh): void {\n    const eraseBoneIndexes: number[] = [];\n    mesh.skeleton.bones.forEach((bone, index) => {\n      if (this._isEraseTarget(bone)) eraseBoneIndexes.push(index);\n    });\n\n    // Unlike UniVRM we don't copy mesh if no invisible bone was found\n    if (!eraseBoneIndexes.length) {\n      mesh.layers.enable(this._thirdPersonOnlyLayer);\n      mesh.layers.enable(this._firstPersonOnlyLayer);\n      return;\n    }\n    mesh.layers.set(this._thirdPersonOnlyLayer);\n    const newMesh = this._createErasedMesh(mesh, eraseBoneIndexes);\n    parent.add(newMesh);\n  }\n\n  private _createHeadlessModel(node: GLTFNode): void {\n    if (node.type === 'Group') {\n      node.layers.set(this._thirdPersonOnlyLayer);\n      if (this._isEraseTarget(node)) {\n        node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n      } else {\n        const parent = new THREE.Group();\n        parent.name = `_headless_${node.name}`;\n        parent.layers.set(this._firstPersonOnlyLayer);\n        node.parent!.add(parent);\n        node.children\n          .filter((child) => child.type === 'SkinnedMesh')\n          .forEach((child) => {\n            this._createHeadlessModelForSkinnedMesh(parent, child as THREE.SkinnedMesh);\n          });\n      }\n    } else if (node.type === 'SkinnedMesh') {\n      this._createHeadlessModelForSkinnedMesh(node.parent!, node as THREE.SkinnedMesh);\n    } else {\n      if (this._isEraseTarget(node)) {\n        node.layers.set(this._thirdPersonOnlyLayer);\n        node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n      }\n    }\n  }\n\n  private _isEraseTarget(bone: GLTFNode): boolean {\n    if (bone.name === this._firstPersonBone.name) {\n      return true;\n    } else if (!bone.parent) {\n      return false;\n    } else {\n      return this._isEraseTarget(bone.parent!);\n    }\n  }\n}\n","import * as THREE from 'three';\nimport { VRMHumanoid } from '../humanoid';\nimport { GLTFMesh, GLTFNode, VRMSchema } from '../types';\nimport { VRMFirstPerson, VRMRendererFirstPersonFlags } from './VRMFirstPerson';\n\n/**\n * An importer that imports a [[VRMFirstPerson]] from a VRM extension of a GLTF.\n */\nexport class VRMFirstPersonImporter {\n  /**\n   * Import a [[VRMFirstPerson]] from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   * @param humanoid A [[VRMHumanoid]] instance that represents the VRM\n   */\n  public async import(gltf: THREE.GLTF, humanoid: VRMHumanoid): Promise<VRMFirstPerson | null> {\n    const vrmExt: VRMSchema.VRM | undefined = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaFirstPerson: VRMSchema.FirstPerson | undefined = vrmExt.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const firstPersonBoneIndex = schemaFirstPerson.firstPersonBone;\n\n    let firstPersonBone: GLTFNode | null;\n    if (firstPersonBoneIndex === undefined || firstPersonBoneIndex === -1) {\n      firstPersonBone = humanoid.getBoneNode(VRMSchema.HumanoidBoneName.Head);\n    } else {\n      firstPersonBone = await gltf.parser.getDependency('node', firstPersonBoneIndex);\n    }\n\n    if (!firstPersonBone) {\n      console.warn('VRMFirstPersonImporter: Could not find firstPersonBone of the VRM');\n      return null;\n    }\n\n    const firstPersonBoneOffset = schemaFirstPerson.firstPersonBoneOffset\n      ? new THREE.Vector3(\n          schemaFirstPerson.firstPersonBoneOffset.x,\n          schemaFirstPerson.firstPersonBoneOffset.y,\n          schemaFirstPerson.firstPersonBoneOffset.z,\n        )\n      : new THREE.Vector3(0.0, 0.06, 0.0); // fallback, taken from UniVRM implementation\n\n    const meshAnnotations: VRMRendererFirstPersonFlags[] = [];\n    const meshes: GLTFMesh[] = await gltf.parser.getDependencies('mesh');\n    meshes.forEach((mesh, meshIndex) => {\n      const flag = schemaFirstPerson.meshAnnotations\n        ? schemaFirstPerson.meshAnnotations.find((a) => a.mesh === meshIndex)\n        : undefined;\n      meshAnnotations.push(new VRMRendererFirstPersonFlags(flag && flag.firstPersonFlag, mesh));\n    });\n\n    return new VRMFirstPerson(firstPersonBone, firstPersonBoneOffset, meshAnnotations);\n  }\n}\n","export * from './VRMFirstPerson';\nexport * from './VRMFirstPersonImporter';\n","import { GLTFNode } from '../types';\nimport { VRMHumanLimit } from './VRMHumanLimit';\n\n/**\n * A class represents a single `humanBone` of a VRM.\n */\nexport class VRMHumanBone {\n  /**\n   * A [[GLTFNode]] (that actually is a `THREE.Object3D`) that represents the bone.\n   */\n  public readonly node: GLTFNode;\n\n  /**\n   * A [[VRMHumanLimit]] object that represents properties of the bone.\n   */\n  public readonly humanLimit: VRMHumanLimit;\n\n  /**\n   * Create a new VRMHumanBone.\n   *\n   * @param node A [[GLTFNode]] that represents the new bone\n   * @param humanLimit A [[VRMHumanLimit]] object that represents properties of the new bone\n   */\n  public constructor(node: GLTFNode, humanLimit: VRMHumanLimit) {\n    this.node = node;\n    this.humanLimit = humanLimit;\n  }\n}\n","import { GLTFNode, RawVector3, RawVector4, VRMPose, VRMSchema } from '../types';\nimport { VRMHumanBone } from './VRMHumanBone';\nimport { VRMHumanBoneArray } from './VRMHumanBoneArray';\nimport { VRMHumanBones } from './VRMHumanBones';\nimport { VRMHumanDescription } from './VRMHumanDescription';\n\n/**\n * A class represents humanoid of a VRM.\n */\nexport class VRMHumanoid {\n  /**\n   * A [[VRMHumanBones]] that contains all the human bones of the VRM.\n   * You might want to get these bones using [[VRMHumanoid.getBone]].\n   */\n  public readonly humanBones: VRMHumanBones;\n\n  /**\n   * A [[VRMHumanDescription]] that represents properties of the humanoid.\n   */\n  public readonly humanDescription: VRMHumanDescription;\n\n  /**\n   * A [[VRMPose]] that is its default state.\n   * You might use [[VRMHumanoid.setPose]] with this pose to reset its state.\n   */\n  public readonly restPose: VRMPose;\n\n  /**\n   * Create a new [[VRMHumanoid]].\n   * @param boneArray A [[VRMHumanBoneArray]] contains all the bones of the new humanoid\n   * @param humanDescription A [[VRMHumanDescription]] that represents properties of the new humanoid\n   */\n  public constructor(boneArray: VRMHumanBoneArray, humanDescription: VRMHumanDescription) {\n    this.humanBones = this._createHumanBones(boneArray);\n    this.humanDescription = humanDescription;\n\n    this.restPose = this.getPose();\n  }\n\n  /**\n   * Return the current pose of this humanoid as a [[VRMPose]].\n   */\n  public getPose(): VRMPose {\n    const pose: VRMPose = {};\n    Object.keys(this.humanBones).forEach(\n      (vrmBoneName) => {\n        const node = this.getBoneNode(vrmBoneName as VRMSchema.HumanoidBoneName)!;\n\n        // Ignore when there are no bone on the VRMHumanoid\n        if (!node) {\n          return;\n        }\n\n        // When there are two or more bones in a same name, we are not going to overwrite existing one\n        if (pose[vrmBoneName]) {\n          return;\n        }\n\n        pose[vrmBoneName] = {\n          position: node.position.toArray() as RawVector3,\n          rotation: node.quaternion.toArray() as RawVector4,\n        };\n      },\n      {} as VRMPose,\n    );\n    return pose;\n  }\n\n  /**\n   * Let the humanoid do a specified pose.\n   *\n   * @param poseObject A [[VRMPose]] that represents a single pose\n   */\n  public setPose(poseObject: VRMPose): void {\n    Object.keys(poseObject).forEach((boneName) => {\n      const state = poseObject[boneName]!;\n      const node = this.getBoneNode(boneName as VRMSchema.HumanoidBoneName);\n\n      // Ignore when there are no bone that is defined in the pose on the VRMHumanoid\n      if (!node) {\n        return;\n      }\n\n      const restState = this.restPose[boneName];\n      if (!restState) {\n        return;\n      }\n\n      if (state.position) {\n        // 元の状態に戻してから、移動分を追加\n        node.position.set(\n          restState.position![0] + state.position[0],\n          restState.position![1] + state.position[1],\n          restState.position![2] + state.position[2],\n        );\n      }\n      if (state.rotation) {\n        node.quaternion.fromArray(state.rotation);\n      }\n    });\n  }\n\n  /**\n   * Return a bone bound to a specified [[HumanBone]], as a [[VRMHumanBone]].\n   *\n   * See also: [[VRMHumanoid.getBones]]\n   *\n   * @param name Name of the bone you want\n   */\n  public getBone(name: VRMSchema.HumanoidBoneName): VRMHumanBone | undefined {\n    return this.humanBones[name][0] || undefined;\n  }\n\n  /**\n   * Return bones bound to a specified [[HumanBone]], as an array of [[VRMHumanBone]].\n   *\n   * See also: [[VRMHumanoid.getBone]]\n   *\n   * @param name Name of the bone you want\n   */\n  public getBones(name: VRMSchema.HumanoidBoneName): VRMHumanBone[] {\n    return this.humanBones[name];\n  }\n\n  /**\n   * Return a bone bound to a specified [[HumanBone]], as a THREE.Object3D.\n   *\n   * See also: [[VRMHumanoid.getBoneNodes]]\n   *\n   * @param name Name of the bone you want\n   */\n  public getBoneNode(name: VRMSchema.HumanoidBoneName): GLTFNode | null {\n    return (this.humanBones[name][0] && this.humanBones[name][0].node) || null;\n  }\n\n  /**\n   * Return bones bound to a specified [[HumanBone]], as an array of THREE.Object3D.\n   *\n   * See also: [[VRMHumanoid.getBoneNode]]\n   *\n   * @param name Name of the bone you want\n   */\n  public getBoneNodes(name: VRMSchema.HumanoidBoneName): GLTFNode[] {\n    return this.humanBones[name].map((bone) => bone.node);\n  }\n\n  /**\n   * Prepare a [[VRMHumanBones]] from a [[VRMHumanBoneArray]].\n   */\n  private _createHumanBones(boneArray: VRMHumanBoneArray): VRMHumanBones {\n    const bones: VRMHumanBones = Object.values(VRMSchema.HumanoidBoneName).reduce((accum, name) => {\n      accum[name] = [];\n      return accum;\n    }, {});\n\n    boneArray.forEach((bone) => {\n      bones[bone.name].push(bone.bone);\n    });\n\n    return bones;\n  }\n}\n","import * as THREE from 'three';\nimport { VRMSchema } from '../types';\nimport { VRMHumanBone } from './VRMHumanBone';\nimport { VRMHumanBoneArray } from './VRMHumanBoneArray';\nimport { VRMHumanDescription } from './VRMHumanDescription';\nimport { VRMHumanoid } from './VRMHumanoid';\n\n/**\n * An importer that imports a [[VRMHumanoid]] from a VRM extension of a GLTF.\n */\nexport class VRMHumanoidImporter {\n  /**\n   * Import a [[VRMHumanoid]] from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  public async import(gltf: THREE.GLTF): Promise<VRMHumanoid | null> {\n    const vrmExt: VRMSchema.VRM | undefined = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaHumanoid: VRMSchema.Humanoid | undefined = vrmExt.humanoid;\n    if (!schemaHumanoid) {\n      return null;\n    }\n\n    const humanBoneArray: VRMHumanBoneArray = [];\n    if (schemaHumanoid.humanBones) {\n      await Promise.all(\n        schemaHumanoid.humanBones.map(async (bone) => {\n          if (!bone.bone || !bone.node) {\n            return;\n          }\n\n          const node = await gltf.parser.getDependency('node', bone.node);\n          humanBoneArray.push({\n            name: bone.bone,\n            bone: new VRMHumanBone(node, {\n              axisLength: bone.axisLength,\n              center: bone.center && new THREE.Vector3(bone.center.x, bone.center.y, bone.center.z),\n              max: bone.max && new THREE.Vector3(bone.max.x, bone.max.y, bone.max.z),\n              min: bone.min && new THREE.Vector3(bone.min.x, bone.min.y, bone.min.z),\n              useDefaultValues: bone.useDefaultValues,\n            }),\n          });\n        }),\n      );\n    }\n\n    const humanDescription: VRMHumanDescription = {\n      armStretch: schemaHumanoid.armStretch,\n      legStretch: schemaHumanoid.legStretch,\n      upperArmTwist: schemaHumanoid.upperArmTwist,\n      lowerArmTwist: schemaHumanoid.lowerArmTwist,\n      upperLegTwist: schemaHumanoid.upperLegTwist,\n      lowerLegTwist: schemaHumanoid.lowerLegTwist,\n      feetSpacing: schemaHumanoid.feetSpacing,\n      hasTranslationDoF: schemaHumanoid.hasTranslationDoF,\n    };\n\n    return new VRMHumanoid(humanBoneArray, humanDescription);\n  }\n}\n","export * from './VRMHumanBone';\nexport * from './VRMHumanBones';\nexport * from './VRMHumanDescription';\nexport * from './VRMHumanLimit';\nexport * from './VRMHumanoid';\nexport * from './VRMHumanoidImporter';\n","export * from './VRM';\nexport * from './VRMImporter';\nexport * from './reduceBones';\nexport * from './blendshape';\nexport * from './debug';\nexport * from './firstperson';\nexport * from './humanoid';\nexport * from './lookat';\nexport * from './springbone';\nexport * from './types';\nexport * from './material';\n","/**\n * Evaluate a hermite spline.\n *\n * @param y0 y on start\n * @param y1 y on end\n * @param t0 delta y on start\n * @param t1 delta y on end\n * @param x input value\n */\nconst hermiteSpline = (y0: number, y1: number, t0: number, t1: number, x: number): number => {\n  const xc = x * x * x;\n  const xs = x * x;\n  const dy = y1 - y0;\n  const h01 = -2.0 * xc + 3.0 * xs;\n  const h10 = xc - 2.0 * xs + x;\n  const h11 = xc - xs;\n  return y0 + dy * h01 + t0 * h10 + t1 * h11;\n};\n\n/**\n * Evaluate an AnimationCurve array. See AnimationCurve class of Unity for its details.\n *\n * See: https://docs.unity3d.com/ja/current/ScriptReference/AnimationCurve.html\n *\n * @param arr An array represents a curve\n * @param x An input value\n */\nconst evaluateCurve = (arr: number[], x: number): number => {\n  // -- sanity check -----------------------------------------------------------\n  if (arr.length < 8) {\n    throw new Error('evaluateCurve: Invalid curve detected! (Array length must be 8 at least)');\n  }\n  if (arr.length % 4 !== 0) {\n    throw new Error('evaluateCurve: Invalid curve detected! (Array length must be multiples of 4');\n  }\n\n  // -- check range ------------------------------------------------------------\n  let outNode;\n  for (outNode = 0; ; outNode++) {\n    if (arr.length <= 4 * outNode) {\n      return arr[4 * outNode - 3]; // too further!! assume as \"Clamp\"\n    } else if (x <= arr[4 * outNode]) {\n      break;\n    }\n  }\n\n  const inNode = outNode - 1;\n  if (inNode < 0) {\n    return arr[4 * inNode + 5]; // too behind!! assume as \"Clamp\"\n  }\n\n  // -- calculate local x ------------------------------------------------------\n  const x0 = arr[4 * inNode];\n  const x1 = arr[4 * outNode];\n  const xHermite = (x - x0) / (x1 - x0);\n\n  // -- finally do the hermite spline ------------------------------------------\n  const y0 = arr[4 * inNode + 1];\n  const y1 = arr[4 * outNode + 1];\n  const t0 = arr[4 * inNode + 3];\n  const t1 = arr[4 * outNode + 2];\n  return hermiteSpline(y0, y1, t0, t1, xHermite);\n};\n\n/**\n * This is an equivalent of CurveMapper class defined in UniVRM.\n * Will be used for [[VRMLookAtApplyer]]s, to define behavior of LookAt.\n *\n * See: https://github.com/vrm-c/UniVRM/blob/master/Assets/VRM/UniVRM/Scripts/LookAt/CurveMapper.cs\n */\nexport class CurveMapper {\n  /**\n   * An array represents the curve. See AnimationCurve class of Unity for its details.\n   *\n   * See: https://docs.unity3d.com/ja/current/ScriptReference/AnimationCurve.html\n   */\n  public curve: number[] = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0];\n\n  /**\n   * The maximum input range of the [[CurveMapper]].\n   */\n  public curveXRangeDegree = 90.0;\n\n  /**\n   * The maximum output value of the [[CurveMapper]].\n   */\n  public curveYRangeDegree = 10.0;\n\n  /**\n   * Create a new [[CurveMapper]].\n   *\n   * @param xRange The maximum input range\n   * @param yRange The maximum output value\n   * @param curve An array represents the curve\n   */\n  constructor(xRange?: number, yRange?: number, curve?: number[]) {\n    if (xRange !== undefined) {\n      this.curveXRangeDegree = xRange;\n    }\n\n    if (yRange !== undefined) {\n      this.curveYRangeDegree = yRange;\n    }\n\n    if (curve !== undefined) {\n      this.curve = curve;\n    }\n  }\n\n  /**\n   * Evaluate an input value and output a mapped value.\n   *\n   * @param src The input value\n   */\n  public map(src: number): number {\n    const clampedSrc = Math.min(Math.max(src, 0.0), this.curveXRangeDegree);\n    const x = clampedSrc / this.curveXRangeDegree;\n    return this.curveYRangeDegree * evaluateCurve(this.curve, x);\n  }\n}\n","import * as THREE from 'three';\nimport { VRMSchema } from '../types';\n\n/**\n * This class is used by [[VRMLookAtHead]], applies look at direction.\n * There are currently two variant of applier: [[VRMLookAtBoneApplyer]] and [[VRMLookAtBlendShapeApplyer]].\n */\nexport abstract class VRMLookAtApplyer {\n  /**\n   * It represents its type of applier.\n   */\n  public abstract readonly type: VRMSchema.FirstPersonLookAtTypeName;\n\n  /**\n   * Apply look at direction to its associated VRM model.\n   *\n   * @param euler `THREE.Euler` object that represents the look at direction\n   */\n  public abstract lookAt(euler: THREE.Euler): void;\n}\n","import * as THREE from 'three';\nimport { VRMBlendShapeProxy } from '../blendshape';\nimport { VRMSchema } from '../types';\nimport { CurveMapper } from './CurveMapper';\nimport { VRMLookAtApplyer } from './VRMLookAtApplyer';\n\n/**\n * This class is used by [[VRMLookAtHead]], applies look at direction to eye blend shapes of a VRM.\n */\nexport class VRMLookAtBlendShapeApplyer extends VRMLookAtApplyer {\n  public readonly type = VRMSchema.FirstPersonLookAtTypeName.BlendShape;\n\n  private readonly _curveHorizontal: CurveMapper;\n  private readonly _curveVerticalDown: CurveMapper;\n  private readonly _curveVerticalUp: CurveMapper;\n\n  private readonly _blendShapeProxy: VRMBlendShapeProxy;\n\n  /**\n   * Create a new VRMLookAtBlendShapeApplyer.\n   *\n   * @param blendShapeProxy A [[VRMBlendShapeProxy]] used by this applier\n   * @param curveHorizontal A [[CurveMapper]] used for transverse direction\n   * @param curveVerticalDown A [[CurveMapper]] used for down direction\n   * @param curveVerticalUp A [[CurveMapper]] used for up direction\n   */\n  constructor(\n    blendShapeProxy: VRMBlendShapeProxy,\n    curveHorizontal: CurveMapper,\n    curveVerticalDown: CurveMapper,\n    curveVerticalUp: CurveMapper,\n  ) {\n    super();\n\n    this._curveHorizontal = curveHorizontal;\n    this._curveVerticalDown = curveVerticalDown;\n    this._curveVerticalUp = curveVerticalUp;\n\n    this._blendShapeProxy = blendShapeProxy;\n  }\n\n  public name(): VRMSchema.FirstPersonLookAtTypeName {\n    return VRMSchema.FirstPersonLookAtTypeName.BlendShape;\n  }\n\n  public lookAt(euler: THREE.Euler): void {\n    const srcX = euler.x;\n    const srcY = euler.y;\n\n    if (srcX < 0.0) {\n      this._blendShapeProxy.setValue(VRMSchema.BlendShapePresetName.Lookup, 0.0);\n      this._blendShapeProxy.setValue(VRMSchema.BlendShapePresetName.Lookdown, this._curveVerticalDown.map(-srcX));\n    } else {\n      this._blendShapeProxy.setValue(VRMSchema.BlendShapePresetName.Lookdown, 0.0);\n      this._blendShapeProxy.setValue(VRMSchema.BlendShapePresetName.Lookup, this._curveVerticalUp.map(srcX));\n    }\n\n    if (srcY < 0.0) {\n      this._blendShapeProxy.setValue(VRMSchema.BlendShapePresetName.Lookleft, 0.0);\n      this._blendShapeProxy.setValue(VRMSchema.BlendShapePresetName.Lookright, this._curveHorizontal.map(-srcY));\n    } else {\n      this._blendShapeProxy.setValue(VRMSchema.BlendShapePresetName.Lookright, 0.0);\n      this._blendShapeProxy.setValue(VRMSchema.BlendShapePresetName.Lookleft, this._curveHorizontal.map(srcY));\n    }\n  }\n}\n","import * as THREE from 'three';\nimport { VRMHumanoid } from '../humanoid';\nimport { GLTFNode, VRMSchema } from '../types';\nimport { CurveMapper } from './CurveMapper';\nimport { VRMLookAtApplyer } from './VRMLookAtApplyer';\nimport { VRMLookAtHead } from './VRMLookAtHead';\n\nconst _euler = new THREE.Euler(0.0, 0.0, 0.0, VRMLookAtHead.EULER_ORDER);\n\n/**\n * This class is used by [[VRMLookAtHead]], applies look at direction to eye bones of a VRM.\n */\nexport class VRMLookAtBoneApplyer extends VRMLookAtApplyer {\n  public readonly type = VRMSchema.FirstPersonLookAtTypeName.Bone;\n\n  private readonly _curveHorizontalInner: CurveMapper;\n  private readonly _curveHorizontalOuter: CurveMapper;\n  private readonly _curveVerticalDown: CurveMapper;\n  private readonly _curveVerticalUp: CurveMapper;\n\n  private readonly _leftEye: GLTFNode | null;\n  private readonly _rightEye: GLTFNode | null;\n\n  /**\n   * Create a new VRMLookAtBoneApplyer.\n   *\n   * @param humanoid A [[VRMHumanoid]] used by this applier\n   * @param curveHorizontalInner A [[CurveMapper]] used for inner transverse direction\n   * @param curveHorizontalOuter A [[CurveMapper]] used for outer transverse direction\n   * @param curveVerticalDown A [[CurveMapper]] used for down direction\n   * @param curveVerticalUp A [[CurveMapper]] used for up direction\n   */\n  constructor(\n    humanoid: VRMHumanoid,\n    curveHorizontalInner: CurveMapper,\n    curveHorizontalOuter: CurveMapper,\n    curveVerticalDown: CurveMapper,\n    curveVerticalUp: CurveMapper,\n  ) {\n    super();\n\n    this._curveHorizontalInner = curveHorizontalInner;\n    this._curveHorizontalOuter = curveHorizontalOuter;\n    this._curveVerticalDown = curveVerticalDown;\n    this._curveVerticalUp = curveVerticalUp;\n\n    this._leftEye = humanoid.getBoneNode(VRMSchema.HumanoidBoneName.LeftEye);\n    this._rightEye = humanoid.getBoneNode(VRMSchema.HumanoidBoneName.RightEye);\n  }\n\n  public lookAt(euler: THREE.Euler): void {\n    const srcX = euler.x;\n    const srcY = euler.y;\n\n    // left\n    if (this._leftEye) {\n      if (srcX < 0.0) {\n        _euler.x = -this._curveVerticalDown.map(-srcX);\n      } else {\n        _euler.x = this._curveVerticalUp.map(srcX);\n      }\n\n      if (srcY < 0.0) {\n        _euler.y = -this._curveHorizontalInner.map(-srcY);\n      } else {\n        _euler.y = this._curveHorizontalOuter.map(srcY);\n      }\n\n      this._leftEye.quaternion.setFromEuler(_euler);\n    }\n\n    // right\n    if (this._rightEye) {\n      if (srcX < 0.0) {\n        _euler.x = -this._curveVerticalDown.map(-srcX);\n      } else {\n        _euler.x = this._curveVerticalUp.map(srcX);\n      }\n\n      if (srcY < 0.0) {\n        _euler.y = -this._curveHorizontalOuter.map(-srcY);\n      } else {\n        _euler.y = this._curveHorizontalInner.map(srcY);\n      }\n\n      this._rightEye.quaternion.setFromEuler(_euler);\n    }\n  }\n}\n","import * as THREE from 'three';\nimport { VRMFirstPerson } from '../firstperson/VRMFirstPerson';\nimport { getWorldQuaternionLite } from '../utils/math';\nimport { VRMLookAtApplyer } from './VRMLookAtApplyer';\n\nconst VECTOR3_FRONT = Object.freeze(new THREE.Vector3(0.0, 0.0, -1.0));\n\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\nconst _v3C = new THREE.Vector3();\nconst _quat = new THREE.Quaternion();\n\n/**\n * A class represents look at of a VRM.\n */\nexport class VRMLookAtHead {\n  public static readonly EULER_ORDER = 'YXZ'; // yaw-pitch-roll\n\n  /**\n   * Associated [[VRMFirstPerson]], will be used for direction calculation.\n   */\n  public readonly firstPerson: VRMFirstPerson;\n\n  /**\n   * Associated [[VRMLookAtApplyer]], its look at direction will be applied to the model using this applier.\n   */\n  public readonly applyer?: VRMLookAtApplyer;\n\n  /**\n   * If this is true, its look at direction will be updated automatically by calling [[VRMLookAtHead.update]] (which is called from [[VRM.update]]).\n   *\n   * See also: [[VRMLookAtHead.target]]\n   */\n  public autoUpdate = true;\n\n  /**\n   * The target object of the look at.\n   * Note that it does not make any sense if [[VRMLookAtHead.autoUpdate]] is disabled.\n   */\n  public target?: THREE.Object3D;\n\n  protected _euler: THREE.Euler = new THREE.Euler(0.0, 0.0, 0.0, VRMLookAtHead.EULER_ORDER);\n\n  /**\n   * Create a new VRMLookAtHead.\n   *\n   * @param firstPerson A [[VRMFirstPerson]] that will be associated with this new VRMLookAtHead\n   * @param applyer A [[VRMLookAtApplyer]] that will be associated with this new VRMLookAtHead\n   */\n  constructor(firstPerson: VRMFirstPerson, applyer?: VRMLookAtApplyer) {\n    this.firstPerson = firstPerson;\n    this.applyer = applyer;\n  }\n\n  /**\n   * Get its look at direction in world coordinate.\n   *\n   * @param target A target `THREE.Vector3`\n   */\n  public getLookAtWorldDirection(target: THREE.Vector3): THREE.Vector3 {\n    const rot = getWorldQuaternionLite(this.firstPerson.firstPersonBone, _quat);\n    return target\n      .copy(VECTOR3_FRONT)\n      .applyEuler(this._euler)\n      .applyQuaternion(rot);\n  }\n\n  /**\n   * Set its look at position.\n   * Note that its result will be instantly overwritten if [[VRMLookAtHead.autoUpdate]] is enabled.\n   *\n   * @param position A target position\n   */\n  public lookAt(position: THREE.Vector3): void {\n    this._calcEuler(this._euler, position);\n\n    if (this.applyer) {\n      this.applyer.lookAt(this._euler);\n    }\n  }\n\n  /**\n   * Update the VRMLookAtHead.\n   * If [[VRMLookAtHead.autoUpdate]] is disabled, it will do nothing.\n   *\n   * @param delta deltaTime\n   */\n  public update(delta: number): void {\n    if (this.target && this.autoUpdate) {\n      this.lookAt(this.target.getWorldPosition(_v3A));\n\n      if (this.applyer) {\n        this.applyer.lookAt(this._euler);\n      }\n    }\n  }\n\n  protected _calcEuler(target: THREE.Euler, position: THREE.Vector3): THREE.Euler {\n    const headPosition = this.firstPerson.getFirstPersonWorldPosition(_v3B);\n\n    // Look at direction in world coordinate\n    const lookAtDir = _v3C\n      .copy(position)\n      .sub(headPosition)\n      .normalize();\n\n    // Transform the direction into local coordinate from the first person bone\n    lookAtDir.applyQuaternion(getWorldQuaternionLite(this.firstPerson.firstPersonBone, _quat).inverse());\n\n    // convert the direction into euler\n    target.x = Math.atan2(lookAtDir.y, Math.sqrt(lookAtDir.x * lookAtDir.x + lookAtDir.z * lookAtDir.z));\n    target.y = Math.atan2(-lookAtDir.x, -lookAtDir.z);\n\n    return target;\n  }\n}\n","import * as THREE from 'three';\nimport { VRMBlendShapeProxy } from '../blendshape';\nimport { VRMFirstPerson } from '../firstperson';\nimport { VRMHumanoid } from '../humanoid';\nimport { VRMSchema } from '../types';\nimport { CurveMapper } from './CurveMapper';\nimport { VRMLookAtApplyer } from './VRMLookAtApplyer';\nimport { VRMLookAtBlendShapeApplyer } from './VRMLookAtBlendShapeApplyer';\nimport { VRMLookAtBoneApplyer } from './VRMLookAtBoneApplyer';\nimport { VRMLookAtHead } from './VRMLookAtHead';\n\n/**\n * An importer that imports a [[VRMLookAtHead]] from a VRM extension of a GLTF.\n */\nexport class VRMLookAtImporter {\n  /**\n   * Import a [[VRMLookAtHead]] from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   * @param blendShapeProxy A [[VRMBlendShapeProxy]] instance that represents the VRM\n   * @param humanoid A [[VRMHumanoid]] instance that represents the VRM\n   */\n  public import(\n    gltf: THREE.GLTF,\n    firstPerson: VRMFirstPerson,\n    blendShapeProxy: VRMBlendShapeProxy,\n    humanoid: VRMHumanoid,\n  ): VRMLookAtHead | null {\n    const vrmExt: VRMSchema.VRM | undefined = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaFirstPerson: VRMSchema.FirstPerson | undefined = vrmExt.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const applyer = this._importApplyer(schemaFirstPerson, blendShapeProxy, humanoid);\n    return new VRMLookAtHead(firstPerson, applyer || undefined);\n  }\n\n  protected _importApplyer(\n    schemaFirstPerson: VRMSchema.FirstPerson,\n    blendShapeProxy: VRMBlendShapeProxy,\n    humanoid: VRMHumanoid,\n  ): VRMLookAtApplyer | null {\n    const lookAtHorizontalInner = schemaFirstPerson.lookAtHorizontalInner;\n    const lookAtHorizontalOuter = schemaFirstPerson.lookAtHorizontalOuter;\n    const lookAtVerticalDown = schemaFirstPerson.lookAtVerticalDown;\n    const lookAtVerticalUp = schemaFirstPerson.lookAtVerticalUp;\n\n    switch (schemaFirstPerson.lookAtTypeName) {\n      case VRMSchema.FirstPersonLookAtTypeName.Bone: {\n        if (\n          lookAtHorizontalInner === undefined ||\n          lookAtHorizontalOuter === undefined ||\n          lookAtVerticalDown === undefined ||\n          lookAtVerticalUp === undefined\n        ) {\n          return null;\n        } else {\n          return new VRMLookAtBoneApplyer(\n            humanoid,\n            this._importCurveMapperBone(lookAtHorizontalInner),\n            this._importCurveMapperBone(lookAtHorizontalOuter),\n            this._importCurveMapperBone(lookAtVerticalDown),\n            this._importCurveMapperBone(lookAtVerticalUp),\n          );\n        }\n      }\n      case VRMSchema.FirstPersonLookAtTypeName.BlendShape: {\n        if (lookAtHorizontalOuter === undefined || lookAtVerticalDown === undefined || lookAtVerticalUp === undefined) {\n          return null;\n        } else {\n          return new VRMLookAtBlendShapeApplyer(\n            blendShapeProxy,\n            this._importCurveMapperBlendShape(lookAtHorizontalOuter),\n            this._importCurveMapperBlendShape(lookAtVerticalDown),\n            this._importCurveMapperBlendShape(lookAtVerticalUp),\n          );\n        }\n      }\n      default: {\n        return null;\n      }\n    }\n  }\n\n  private _importCurveMapperBone(map: VRMSchema.FirstPersonDegreeMap): CurveMapper {\n    return new CurveMapper(\n      typeof map.xRange === 'number' ? THREE.Math.DEG2RAD * map.xRange : undefined,\n      typeof map.yRange === 'number' ? THREE.Math.DEG2RAD * map.yRange : undefined,\n      map.curve,\n    );\n  }\n\n  private _importCurveMapperBlendShape(map: VRMSchema.FirstPersonDegreeMap): CurveMapper {\n    return new CurveMapper(\n      typeof map.xRange === 'number' ? THREE.Math.DEG2RAD * map.xRange : undefined,\n      map.yRange,\n      map.curve,\n    );\n  }\n}\n","export * from './CurveMapper';\nexport * from './VRMLookAtApplyer';\nexport * from './VRMLookAtBlendShapeApplyer';\nexport * from './VRMLookAtBoneApplyer';\nexport * from './VRMLookAtHead';\nexport * from './VRMLookAtImporter';\n","/* tslint:disable:member-ordering */\n\nimport * as THREE from 'three';\nimport { getTexelDecodingFunction } from './getTexelDecodingFunction';\nimport vertexShader from './shaders/mtoon.vert';\nimport fragmentShader from './shaders/mtoon.frag';\n\nconst TAU = 2.0 * Math.PI;\n\nexport interface MToonParameters extends THREE.ShaderMaterialParameters {\n  mToonVersion?: number; // _MToonVersion\n\n  cutoff?: number; // _Cutoff\n  color?: THREE.Vector4; // rgb of _Color\n  shadeColor?: THREE.Vector4; // _ShadeColor\n  map?: THREE.Texture; // _MainTex\n  mainTex?: THREE.Texture; // _MainTex (will be renamed to map)\n  mainTex_ST?: THREE.Vector4; // _MainTex_ST\n  shadeTexture?: THREE.Texture; // _ShadeTexture\n  bumpScale?: number; // _BumpScale\n  normalMap?: THREE.Texture; // _BumpMap\n  bumpMap?: THREE.Texture; // _BumpMap (will be renamed to normalMap)\n  receiveShadowRate?: number; // _ReceiveShadowRate\n  receiveShadowTexture?: THREE.Texture; // _ReceiveShadowTexture\n  shadingGradeRate?: number; // _ShadingGradeRate\n  shadingGradeTexture?: THREE.Texture; // _ShadingGradeTexture\n  shadeShift?: number; // _ShadeShift\n  shadeToony?: number; // _ShadeToony\n  lightColorAttenuation?: number; // _LightColorAttenuation\n  indirectLightIntensity?: number; // _IndirectLightIntensity\n  rimTexture?: THREE.Texture; // _RimTexture\n  rimColor?: THREE.Vector4; // _RimColor\n  rimLightingMix?: number; // _RimLightingMix\n  rimFresnelPower?: number; // _RimFresnelPower\n  rimLift?: number; // _RimLift\n  sphereAdd?: THREE.Texture; // _SphereAdd\n  emissionColor?: THREE.Vector4; // _EmissionColor\n  emissiveMap?: THREE.Texture; // _EmissionMap\n  emissionMap?: THREE.Texture; // _EmissionMap (will be renamed to emissiveMap)\n  outlineWidthTexture?: THREE.Texture; // _OutlineWidthTexture\n  outlineWidth?: number; // _OutlineWidth\n  outlineScaledMaxDistance?: number; // _OutlineScaledMaxDistance\n  outlineColor?: THREE.Vector4; // _OutlineColor\n  outlineLightingMix?: number; // _OutlineLightingMix\n  uvAnimMaskTexture?: THREE.Texture; // _UvAnimMaskTexture\n  uvAnimScrollX?: number; // _UvAnimScrollX\n  uvAnimScrollY?: number; // _UvAnimScrollY\n  uvAnimRotation?: number; // _uvAnimRotation\n\n  debugMode?: MToonMaterialDebugMode | number; // _DebugMode\n  blendMode?: MToonMaterialRenderMode | number; // _BlendMode\n  outlineWidthMode?: MToonMaterialOutlineWidthMode | number; // OutlineWidthMode\n  outlineColorMode?: MToonMaterialOutlineColorMode | number; // OutlineColorMode\n  cullMode?: MToonMaterialCullMode | number; // _CullMode\n  outlineCullMode?: MToonMaterialCullMode | number; // _OutlineCullMode\n  srcBlend?: number; // _SrcBlend\n  dstBlend?: number; // _DstBlend\n  zWrite?: number; // _ZWrite (will be renamed to depthWrite)\n\n  isOutline?: boolean;\n}\n\nexport enum MToonMaterialCullMode {\n  Off,\n  Front,\n  Back,\n}\n\nexport enum MToonMaterialDebugMode {\n  None,\n  Normal,\n  LitShadeRate,\n  UV,\n}\n\nexport enum MToonMaterialOutlineColorMode {\n  FixedColor,\n  MixedLighting,\n}\n\nexport enum MToonMaterialOutlineWidthMode {\n  None,\n  WorldCoordinates,\n  ScreenCoordinates,\n}\n\nexport enum MToonMaterialRenderMode {\n  Opaque,\n  Cutout,\n  Transparent,\n  TransparentWithZWrite,\n}\n\n/**\n * MToon is a material specification that has various features.\n * The spec and implementation are originally founded for Unity engine and this is a port of the material.\n *\n * See: https://github.com/Santarh/MToon\n */\nexport class MToonMaterial extends THREE.ShaderMaterial {\n  /**\n   * Readonly boolean that indicates this is a [[MToonMaterial]].\n   */\n  public readonly isMToonMaterial: boolean = true;\n\n  public cutoff = 0.5; // _Cutoff\n  public color: THREE.Vector4 = new THREE.Vector4(1.0, 1.0, 1.0, 1.0); // _Color\n  public shadeColor: THREE.Vector4 = new THREE.Vector4(0.97, 0.81, 0.86, 1.0); // _ShadeColor\n  public map: THREE.Texture | null = null; // _MainTex\n  public mainTex_ST: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 1.0, 1.0); // _MainTex_ST\n  public shadeTexture: THREE.Texture | null = null; // _ShadeTexture\n  // public shadeTexture_ST: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 1.0, 1.0); // _ShadeTexture_ST (unused)\n  public bumpScale = 1.0; // _BumpScale\n  public normalMap: THREE.Texture | null = null; // _BumpMap. again, THIS IS _BumpMap\n  // public bumpMap_ST: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 1.0, 1.0); // _BumpMap_ST (unused)\n  public receiveShadowRate = 1.0; // _ReceiveShadowRate\n  public receiveShadowTexture: THREE.Texture | null = null; // _ReceiveShadowTexture\n  // public receiveShadowTexture_ST: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 1.0, 1.0); // _ReceiveShadowTexture_ST (unused)\n  public shadingGradeRate = 1.0; // _ShadingGradeRate\n  public shadingGradeTexture: THREE.Texture | null = null; // _ShadingGradeTexture\n  // public shadingGradeTexture_ST: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 1.0, 1.0); // _ShadingGradeTexture_ST (unused)\n  public shadeShift = 0.0; // _ShadeShift\n  public shadeToony = 0.9; // _ShadeToony\n  public lightColorAttenuation = 0.0; // _LightColorAttenuation\n  public indirectLightIntensity = 0.1; // _IndirectLightIntensity\n  public rimTexture: THREE.Texture | null = null; // _RimTexture\n  public rimColor: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 0.0, 1.0); // _RimColor\n  public rimLightingMix = 0.0; // _RimLightingMix\n  public rimFresnelPower = 1.0; // _RimFresnelPower\n  public rimLift = 0.0; // _RimLift\n  public sphereAdd: THREE.Texture | null = null; // _SphereAdd\n  // public sphereAdd_ST: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 1.0, 1.0); // _SphereAdd_ST (unused)\n  public emissionColor: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 0.0, 1.0); // _EmissionColor\n  public emissiveMap: THREE.Texture | null = null; // _EmissionMap\n  // public emissionMap_ST: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 1.0, 1.0); // _EmissionMap_ST (unused)\n  public outlineWidthTexture: THREE.Texture | null = null; // _OutlineWidthTexture\n  // public outlineWidthTexture_ST: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 1.0, 1.0); // _OutlineWidthTexture_ST (unused)\n  public outlineWidth = 0.5; // _OutlineWidth\n  public outlineScaledMaxDistance = 1.0; // _OutlineScaledMaxDistance\n  public outlineColor: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 0.0, 1.0); // _OutlineColor\n  public outlineLightingMix = 1.0; // _OutlineLightingMix\n  public uvAnimMaskTexture: THREE.Texture | null = null; // _UvAnimMaskTexture\n  public uvAnimScrollX = 0.0; // _UvAnimScrollX\n  public uvAnimScrollY = 0.0; // _UvAnimScrollY\n  public uvAnimRotation = 0.0; // _uvAnimRotation\n\n  public shouldApplyUniforms = true; // when this is true, applyUniforms effects\n\n  private _debugMode: MToonMaterialDebugMode = MToonMaterialDebugMode.None; // _DebugMode\n  private _blendMode: MToonMaterialRenderMode = MToonMaterialRenderMode.Opaque; // _BlendMode\n  private _outlineWidthMode: MToonMaterialOutlineWidthMode = MToonMaterialOutlineWidthMode.None; // _OutlineWidthMode\n  private _outlineColorMode: MToonMaterialOutlineColorMode = MToonMaterialOutlineColorMode.FixedColor; // _OutlineColorMode\n  private _cullMode: MToonMaterialCullMode = MToonMaterialCullMode.Back; // _CullMode\n  private _outlineCullMode: MToonMaterialCullMode = MToonMaterialCullMode.Front; // _OutlineCullMode\n  // public srcBlend: number = 1.0; // _SrcBlend (is not supported)\n  // public dstBlend: number = 0.0; // _DstBlend (is not supported)\n  // public zWrite: number = 1.0; // _ZWrite (will be converted to depthWrite)\n\n  private _isOutline = false;\n\n  private readonly _colorSpaceGamma: boolean;\n\n  private _uvAnimOffsetX = 0.0;\n  private _uvAnimOffsetY = 0.0;\n  private _uvAnimPhase = 0.0;\n\n  // TODO: ここにcolorSpaceGammaあるのダサい\n  constructor(colorSpaceGamma: boolean, parameters?: MToonParameters) {\n    super();\n\n    this._colorSpaceGamma = colorSpaceGamma;\n\n    if (parameters === undefined) {\n      parameters = {};\n    }\n\n    // == these parameter has no compatibility with this implementation ========\n    [\n      'mToonVersion',\n      'shadeTexture_ST',\n      'bumpMap_ST',\n      'receiveShadowTexture_ST',\n      'shadingGradeTexture_ST',\n      'sphereAdd_ST',\n      'emissionMap_ST',\n      'outlineWidthTexture_ST',\n      'srcBlend',\n      'dstBlend',\n    ].forEach((key) => {\n      if ((parameters as any)[key] !== undefined) {\n        // console.warn(`THREE.${this.type}: The parameter \"${key}\" is not supported.`);\n        delete (parameters as any)[key];\n      }\n    });\n\n    // == enabling bunch of stuff ==============================================\n    parameters.fog = true;\n    parameters.lights = true;\n    parameters.clipping = true;\n\n    parameters.skinning = parameters.skinning || false;\n    parameters.morphTargets = parameters.morphTargets || false;\n    parameters.morphNormals = parameters.morphNormals || false;\n\n    // == uniforms =============================================================\n    parameters.uniforms = THREE.UniformsUtils.merge([\n      THREE.UniformsLib.common, // map\n      THREE.UniformsLib.normalmap, // normalMap\n      THREE.UniformsLib.emissivemap, // emissiveMap\n      THREE.UniformsLib.fog,\n      THREE.UniformsLib.lights,\n      {\n        cutoff: { value: 0.5 },\n        color: { value: new THREE.Color(1.0, 1.0, 1.0) },\n        colorAlpha: { value: 1.0 },\n        shadeColor: { value: new THREE.Color(0.97, 0.81, 0.86) },\n        mainTex_ST: { value: new THREE.Vector4(0.0, 0.0, 1.0, 1.0) },\n        shadeTexture: { value: null },\n        bumpScale: { value: 1.0 },\n        receiveShadowRate: { value: 1.0 },\n        receiveShadowTexture: { value: null },\n        shadingGradeRate: { value: 1.0 },\n        shadingGradeTexture: { value: null },\n        shadeShift: { value: 0.0 },\n        shadeToony: { value: 0.9 },\n        lightColorAttenuation: { value: 0.0 },\n        indirectLightIntensity: { value: 0.1 },\n        rimTexture: { value: null },\n        rimColor: { value: new THREE.Color(0.0, 0.0, 0.0) },\n        rimLightingMix: { value: 0.0 },\n        rimFresnelPower: { value: 1.0 },\n        rimLift: { value: 0.0 },\n        sphereAdd: { value: null },\n        emissionColor: { value: new THREE.Color(0.0, 0.0, 0.0) },\n        outlineWidthTexture: { value: null },\n        outlineWidth: { value: 0.5 },\n        outlineScaledMaxDistance: { value: 1.0 },\n        outlineColor: { value: new THREE.Color(0.0, 0.0, 0.0) },\n        outlineLightingMix: { value: 1.0 },\n        uvAnimMaskTexture: { value: null },\n        uvAnimOffsetX: { value: 0.0 },\n        uvAnimOffsetY: { value: 0.0 },\n        uvAnimTheta: { value: 0.0 },\n      },\n    ]);\n\n    // == finally compile the shader program ===================================\n    this.setValues(parameters);\n\n    // == update shader stuff ==================================================\n    this._updateShaderCode();\n    this._applyUniforms();\n  }\n\n  get mainTex(): THREE.Texture | null {\n    return this.map;\n  }\n\n  set mainTex(t: THREE.Texture | null) {\n    this.map = t;\n  }\n\n  get bumpMap(): THREE.Texture | null {\n    return this.normalMap;\n  }\n\n  set bumpMap(t: THREE.Texture | null) {\n    this.normalMap = t;\n  }\n\n  get emissionMap(): THREE.Texture | null {\n    return this.emissiveMap;\n  }\n\n  set emissionMap(t: THREE.Texture | null) {\n    this.emissiveMap = t;\n  }\n\n  get blendMode(): MToonMaterialRenderMode {\n    return this._blendMode;\n  }\n\n  set blendMode(m: MToonMaterialRenderMode) {\n    this._blendMode = m;\n\n    this.depthWrite = this._blendMode !== MToonMaterialRenderMode.Transparent;\n    this.transparent =\n      this._blendMode === MToonMaterialRenderMode.Transparent ||\n      this._blendMode === MToonMaterialRenderMode.TransparentWithZWrite;\n    this._updateShaderCode();\n  }\n\n  get debugMode(): MToonMaterialDebugMode {\n    return this._debugMode;\n  }\n\n  set debugMode(m: MToonMaterialDebugMode) {\n    this._debugMode = m;\n\n    this._updateShaderCode();\n  }\n\n  get outlineWidthMode(): MToonMaterialOutlineWidthMode {\n    return this._outlineWidthMode;\n  }\n\n  set outlineWidthMode(m: MToonMaterialOutlineWidthMode) {\n    this._outlineWidthMode = m;\n\n    this._updateShaderCode();\n  }\n\n  get outlineColorMode(): MToonMaterialOutlineColorMode {\n    return this._outlineColorMode;\n  }\n\n  set outlineColorMode(m: MToonMaterialOutlineColorMode) {\n    this._outlineColorMode = m;\n\n    this._updateShaderCode();\n  }\n\n  get cullMode(): MToonMaterialCullMode {\n    return this._cullMode;\n  }\n\n  set cullMode(m: MToonMaterialCullMode) {\n    this._cullMode = m;\n\n    this._updateCullFace();\n  }\n\n  get outlineCullMode(): MToonMaterialCullMode {\n    return this._outlineCullMode;\n  }\n\n  set outlineCullMode(m: MToonMaterialCullMode) {\n    this._outlineCullMode = m;\n\n    this._updateCullFace();\n  }\n\n  get zWrite(): number {\n    return this.depthWrite ? 1 : 0;\n  }\n\n  set zWrite(i: number) {\n    this.depthWrite = 0.5 <= i;\n  }\n\n  get isOutline(): boolean {\n    return this._isOutline;\n  }\n\n  set isOutline(b: boolean) {\n    this._isOutline = b;\n\n    this._updateShaderCode();\n    this._updateCullFace();\n  }\n\n  /**\n   * Update this material.\n   * Usually this will be called via [[VRM.update]] so you don't have to call this manually.\n   *\n   * @param delta deltaTime since last update\n   */\n  public updateVRMMaterials(delta: number): void {\n    this._uvAnimOffsetX = this._uvAnimOffsetX + delta * this.uvAnimScrollX;\n    this._uvAnimOffsetY = this._uvAnimOffsetY + delta * this.uvAnimScrollY;\n    this._uvAnimPhase = this._uvAnimPhase + delta * this.uvAnimRotation;\n\n    this._applyUniforms();\n  }\n\n  public copy(source: this): this {\n    super.copy(source);\n\n    // == copy members =========================================================\n    this.cutoff = source.cutoff;\n    this.color.copy(source.color);\n    this.shadeColor.copy(source.shadeColor);\n    this.map = source.map;\n    this.mainTex_ST.copy(source.mainTex_ST);\n    this.shadeTexture = source.shadeTexture;\n    this.bumpScale = source.bumpScale;\n    this.normalMap = source.normalMap;\n    this.receiveShadowRate = source.receiveShadowRate;\n    this.receiveShadowTexture = source.receiveShadowTexture;\n    this.shadingGradeRate = source.shadingGradeRate;\n    this.shadingGradeTexture = source.shadingGradeTexture;\n    this.shadeShift = source.shadeShift;\n    this.shadeToony = source.shadeToony;\n    this.lightColorAttenuation = source.lightColorAttenuation;\n    this.indirectLightIntensity = source.indirectLightIntensity;\n    this.rimTexture = source.rimTexture;\n    this.rimColor.copy(source.rimColor);\n    this.rimLightingMix = source.rimLightingMix;\n    this.rimFresnelPower = source.rimFresnelPower;\n    this.rimLift = source.rimLift;\n    this.sphereAdd = source.sphereAdd;\n    this.emissionColor.copy(source.emissionColor);\n    this.emissiveMap = source.emissiveMap;\n    this.outlineWidthTexture = source.outlineWidthTexture;\n    this.outlineWidth = source.outlineWidth;\n    this.outlineScaledMaxDistance = source.outlineScaledMaxDistance;\n    this.outlineColor.copy(source.outlineColor);\n    this.outlineLightingMix = source.outlineLightingMix;\n    this.uvAnimMaskTexture = source.uvAnimMaskTexture;\n    this.uvAnimScrollX = source.uvAnimScrollX;\n    this.uvAnimScrollY = source.uvAnimScrollY;\n    this.uvAnimRotation = source.uvAnimRotation;\n\n    this.debugMode = source.debugMode;\n    this.blendMode = source.blendMode;\n    this.outlineWidthMode = source.outlineWidthMode;\n    this.outlineColorMode = source.outlineColorMode;\n    this.cullMode = source.cullMode;\n    this.outlineCullMode = source.outlineCullMode;\n\n    this.isOutline = source.isOutline;\n\n    return this;\n  }\n\n  /**\n   * Apply updated uniform variables.\n   */\n  private _applyUniforms(): void {\n    this.uniforms.uvAnimOffsetX.value = this._uvAnimOffsetX;\n    this.uniforms.uvAnimOffsetY.value = this._uvAnimOffsetY;\n    this.uniforms.uvAnimTheta.value = TAU * this._uvAnimPhase;\n\n    if (!this.shouldApplyUniforms) {\n      return;\n    }\n    this.shouldApplyUniforms = false;\n\n    this.uniforms.cutoff.value = this.cutoff;\n    this.uniforms.color.value.setRGB(this.color.x, this.color.y, this.color.z);\n    if (!this._colorSpaceGamma) {\n      this.uniforms.color.value.convertSRGBToLinear();\n    }\n    this.uniforms.colorAlpha.value = this.color.w;\n    this.uniforms.shadeColor.value.setRGB(this.shadeColor.x, this.shadeColor.y, this.shadeColor.z);\n    if (!this._colorSpaceGamma) {\n      this.uniforms.shadeColor.value.convertSRGBToLinear();\n    }\n    this.uniforms.map.value = this.map;\n    this.uniforms.mainTex_ST.value.copy(this.mainTex_ST);\n    this.uniforms.shadeTexture.value = this.shadeTexture;\n    this.uniforms.bumpScale.value = this.bumpScale;\n    this.uniforms.normalMap.value = this.normalMap;\n    this.uniforms.receiveShadowRate.value = this.receiveShadowRate;\n    this.uniforms.receiveShadowTexture.value = this.receiveShadowTexture;\n    this.uniforms.shadingGradeRate.value = this.shadingGradeRate;\n    this.uniforms.shadingGradeTexture.value = this.shadingGradeTexture;\n    this.uniforms.shadeShift.value = this.shadeShift;\n    this.uniforms.shadeToony.value = this.shadeToony;\n    this.uniforms.lightColorAttenuation.value = this.lightColorAttenuation;\n    this.uniforms.indirectLightIntensity.value = this.indirectLightIntensity;\n    this.uniforms.rimTexture.value = this.rimTexture;\n    this.uniforms.rimColor.value.setRGB(this.rimColor.x, this.rimColor.y, this.rimColor.z);\n    if (!this._colorSpaceGamma) {\n      this.uniforms.rimColor.value.convertSRGBToLinear();\n    }\n    this.uniforms.rimLightingMix.value = this.rimLightingMix;\n    this.uniforms.rimFresnelPower.value = this.rimFresnelPower;\n    this.uniforms.rimLift.value = this.rimLift;\n    this.uniforms.sphereAdd.value = this.sphereAdd;\n    this.uniforms.emissionColor.value.setRGB(this.emissionColor.x, this.emissionColor.y, this.emissionColor.z);\n    if (!this._colorSpaceGamma) {\n      this.uniforms.emissionColor.value.convertSRGBToLinear();\n    }\n    this.uniforms.emissiveMap.value = this.emissiveMap;\n    this.uniforms.outlineWidthTexture.value = this.outlineWidthTexture;\n    this.uniforms.outlineWidth.value = this.outlineWidth;\n    this.uniforms.outlineScaledMaxDistance.value = this.outlineScaledMaxDistance;\n    this.uniforms.outlineColor.value.setRGB(this.outlineColor.x, this.outlineColor.y, this.outlineColor.z);\n    if (!this._colorSpaceGamma) {\n      this.uniforms.outlineColor.value.convertSRGBToLinear();\n    }\n    this.uniforms.outlineLightingMix.value = this.outlineLightingMix;\n    this.uniforms.uvAnimMaskTexture.value = this.uvAnimMaskTexture;\n\n    this._updateCullFace();\n  }\n\n  private _updateShaderCode(): void {\n    this.defines = {\n      OUTLINE: this._isOutline,\n      BLENDMODE_OPAQUE: this._blendMode === MToonMaterialRenderMode.Opaque,\n      BLENDMODE_CUTOUT: this._blendMode === MToonMaterialRenderMode.Cutout,\n      BLENDMODE_TRANSPARENT:\n        this._blendMode === MToonMaterialRenderMode.Transparent ||\n        this._blendMode === MToonMaterialRenderMode.TransparentWithZWrite,\n      USE_SHADETEXTURE: this.shadeTexture !== null,\n      USE_RECEIVESHADOWTEXTURE: this.receiveShadowTexture !== null,\n      USE_SHADINGGRADETEXTURE: this.shadingGradeTexture !== null,\n      USE_RIMTEXTURE: this.rimTexture !== null,\n      USE_SPHEREADD: this.sphereAdd !== null,\n      USE_OUTLINEWIDTHTEXTURE: this.outlineWidthTexture !== null,\n      USE_UVANIMMASKTEXTURE: this.uvAnimMaskTexture !== null,\n      DEBUG_NORMAL: this._debugMode === MToonMaterialDebugMode.Normal,\n      DEBUG_LITSHADERATE: this._debugMode === MToonMaterialDebugMode.LitShadeRate,\n      DEBUG_UV: this._debugMode === MToonMaterialDebugMode.UV,\n      OUTLINE_WIDTH_WORLD: this._outlineWidthMode === MToonMaterialOutlineWidthMode.WorldCoordinates,\n      OUTLINE_WIDTH_SCREEN: this._outlineWidthMode === MToonMaterialOutlineWidthMode.ScreenCoordinates,\n      OUTLINE_COLOR_FIXED: this._outlineColorMode === MToonMaterialOutlineColorMode.FixedColor,\n      OUTLINE_COLOR_MIXED: this._outlineColorMode === MToonMaterialOutlineColorMode.MixedLighting,\n    };\n\n    // == texture encodings ====================================================\n    const encodings =\n      (this.shadeTexture !== null\n        ? getTexelDecodingFunction('shadeTextureTexelToLinear', this.shadeTexture.encoding) + '\\n'\n        : '') +\n      (this.sphereAdd !== null\n        ? getTexelDecodingFunction('sphereAddTexelToLinear', this.sphereAdd.encoding) + '\\n'\n        : '');\n\n    // == generate shader code =================================================\n    this.vertexShader = vertexShader;\n    this.fragmentShader = encodings + fragmentShader;\n\n    // == set needsUpdate flag =================================================\n    this.needsUpdate = true;\n  }\n\n  private _updateCullFace(): void {\n    if (!this.isOutline) {\n      if (this.cullMode === MToonMaterialCullMode.Off) {\n        this.side = THREE.DoubleSide;\n      } else if (this.cullMode === MToonMaterialCullMode.Front) {\n        this.side = THREE.BackSide;\n      } else if (this.cullMode === MToonMaterialCullMode.Back) {\n        this.side = THREE.FrontSide;\n      }\n    } else {\n      if (this.outlineCullMode === MToonMaterialCullMode.Off) {\n        this.side = THREE.DoubleSide;\n      } else if (this.outlineCullMode === MToonMaterialCullMode.Front) {\n        this.side = THREE.BackSide;\n      } else if (this.outlineCullMode === MToonMaterialCullMode.Back) {\n        this.side = THREE.FrontSide;\n      }\n    }\n  }\n}\n","import * as THREE from 'three';\nimport { GLTFMesh, GLTFPrimitive, VRMSchema } from '../types';\nimport { MToonMaterial, MToonMaterialOutlineWidthMode, MToonMaterialRenderMode } from './MToonMaterial';\nimport { VRMUnlitMaterial, VRMUnlitMaterialRenderType } from './VRMUnlitMaterial';\n\n/**\n * Options for a [[VRMMaterialImporter]] instance.\n */\nexport interface VRMMaterialImporterOptions {\n  /**\n   * Whether the workflow should be linear or gamma.\n   *\n   * See also: https://threejs.org/docs/#api/en/renderers/WebGLRenderer.gammaOutput\n   */\n  colorSpaceGamma?: boolean;\n\n  /**\n   * A function that returns a `Promise` of environment map texture.\n   * The importer will attempt to call this function when it have to use an envmap.\n   */\n  requestEnvMap?: () => Promise<THREE.Texture | null>;\n}\n\n/**\n * An importer that imports VRM materials from a VRM extension of a GLTF.\n */\nexport class VRMMaterialImporter {\n  private readonly _colorSpaceGamma: boolean;\n  private readonly _requestEnvMap?: () => Promise<THREE.Texture | null>;\n\n  /**\n   * Create a new VRMMaterialImporter.\n   *\n   * @param options Options of the VRMMaterialImporter\n   */\n  constructor(options: VRMMaterialImporterOptions = {}) {\n    this._colorSpaceGamma = options.colorSpaceGamma || true;\n    this._requestEnvMap = options.requestEnvMap;\n  }\n\n  /**\n   * Convert all the materials of given GLTF based on VRM extension field `materialProperties`.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  public async convertGLTFMaterials(gltf: THREE.GLTF): Promise<THREE.Material[] | null> {\n    const vrmExt: VRMSchema.VRM | undefined = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const materialProperties: VRMSchema.Material[] | undefined = vrmExt.materialProperties;\n    if (!materialProperties) {\n      return null;\n    }\n\n    const meshesMap: GLTFMesh[] = await gltf.parser.getDependencies('mesh');\n    const materialList: { [vrmMaterialIndex: number]: { surface: THREE.Material; outline?: THREE.Material } } = {};\n    const materials: THREE.Material[] = []; // result\n\n    await Promise.all(\n      meshesMap.map(async (mesh, meshIndex) => {\n        const primitives: GLTFPrimitive[] =\n          mesh.type === 'Group' ? (mesh.children as GLTFPrimitive[]) : [mesh as GLTFPrimitive];\n        await Promise.all(\n          primitives.map(async (primitive, primitiveIndex) => {\n            // if primitives material is not an array, make it an array\n            if (!Array.isArray(primitive.material)) {\n              primitive.material = [primitive.material];\n              (primitive.geometry as THREE.BufferGeometry).addGroup(\n                0,\n                (primitive.geometry as THREE.BufferGeometry).index.count,\n                0,\n              );\n            }\n\n            // create / push to cache (or pop from cache) vrm materials\n            const vrmMaterialIndex = gltf.parser.json.meshes![meshIndex].primitives[primitiveIndex].material!;\n\n            let props = materialProperties[vrmMaterialIndex];\n            if (!props) {\n              console.warn(\n                `VRMMaterialImporter: There are no material definition for material #${vrmMaterialIndex} on VRM extension.`,\n              );\n              props = { shader: 'VRM_USE_GLTFSHADER' }; // fallback\n            }\n\n            let vrmMaterials: { surface: THREE.Material; outline?: THREE.Material };\n            if (materialList[vrmMaterialIndex]) {\n              vrmMaterials = materialList[vrmMaterialIndex];\n            } else {\n              vrmMaterials = await this.createVRMMaterials(primitive.material[0], props, gltf);\n              materialList[vrmMaterialIndex] = vrmMaterials;\n\n              materials.push(vrmMaterials.surface);\n              if (vrmMaterials.outline) {\n                materials.push(vrmMaterials.outline);\n              }\n            }\n\n            // surface\n            primitive.material[0] = vrmMaterials.surface;\n\n            // envmap\n            if (this._requestEnvMap) {\n              this._requestEnvMap().then((envMap) => {\n                (vrmMaterials.surface as any).envMap = envMap;\n                vrmMaterials.surface.needsUpdate = true;\n              });\n            }\n\n            // render order\n            primitive.renderOrder = props.renderQueue || 2000;\n\n            // outline (\"2 pass shading using groups\" trick here)\n            if (vrmMaterials.outline) {\n              primitive.material[1] = vrmMaterials.outline;\n              (primitive.geometry as THREE.BufferGeometry).addGroup(\n                0,\n                (primitive.geometry as THREE.BufferGeometry).index.count,\n                1,\n              );\n            }\n          }),\n        );\n      }),\n    );\n\n    return materials;\n  }\n\n  public async createVRMMaterials(\n    originalMaterial: THREE.Material,\n    vrmProps: VRMSchema.Material,\n    gltf: THREE.GLTF,\n  ): Promise<{\n    surface: THREE.Material;\n    outline?: THREE.Material;\n  }> {\n    let newSurface: THREE.Material | undefined;\n    let newOutline: THREE.Material | undefined;\n\n    if (vrmProps.shader === 'VRM/MToon') {\n      const params = await this._extractMaterialProperties(originalMaterial, vrmProps, gltf);\n\n      // we need to get rid of these properties\n      ['srcBlend', 'dstBlend', 'isFirstSetup'].forEach((name) => {\n        if (params[name] !== undefined) {\n          delete params[name];\n        }\n      });\n\n      // these textures must be sRGB Encoding, depends on current colorspace\n      ['mainTex', 'shadeTexture', 'emission', 'sphereAdd'].forEach((name) => {\n        if (params[name] !== undefined) {\n          params[name].encoding = this._colorSpaceGamma ? THREE.LinearEncoding : THREE.sRGBEncoding;\n        }\n      });\n\n      // done\n      newSurface = new MToonMaterial(this._colorSpaceGamma, params);\n\n      // outline\n      if (params.outlineWidthMode !== MToonMaterialOutlineWidthMode.None) {\n        params.isOutline = true;\n        newOutline = new MToonMaterial(this._colorSpaceGamma, params);\n      }\n    } else if (vrmProps.shader === 'VRM/UnlitTexture') {\n      // this is very legacy\n      const params = await this._extractMaterialProperties(originalMaterial, vrmProps, gltf);\n      params.renderType = VRMUnlitMaterialRenderType.Opaque;\n      newSurface = new VRMUnlitMaterial(params);\n    } else if (vrmProps.shader === 'VRM/UnlitCutout') {\n      // this is very legacy\n      const params = await this._extractMaterialProperties(originalMaterial, vrmProps, gltf);\n      params.renderType = VRMUnlitMaterialRenderType.Cutout;\n      newSurface = new VRMUnlitMaterial(params);\n    } else if (vrmProps.shader === 'VRM/UnlitTransparent') {\n      // this is very legacy\n      const params = await this._extractMaterialProperties(originalMaterial, vrmProps, gltf);\n      params.renderType = VRMUnlitMaterialRenderType.Transparent;\n      newSurface = new VRMUnlitMaterial(params);\n    } else if (vrmProps.shader === 'VRM/UnlitTransparentZWrite') {\n      // this is very legacy\n      const params = await this._extractMaterialProperties(originalMaterial, vrmProps, gltf);\n      params.renderType = VRMUnlitMaterialRenderType.TransparentWithZWrite;\n      newSurface = new VRMUnlitMaterial(params);\n    } else {\n      if (vrmProps.shader !== 'VRM_USE_GLTFSHADER') {\n        console.warn(`Unknown shader detected: \"${vrmProps.shader}\"`);\n        // then presume as VRM_USE_GLTFSHADER\n      }\n\n      newSurface = this._convertGLTFMaterial(originalMaterial.clone());\n    }\n\n    newSurface.name = originalMaterial.name;\n    newSurface.userData = JSON.parse(JSON.stringify(originalMaterial.userData));\n    newSurface.userData.vrmMaterialProperties = vrmProps;\n\n    if (newOutline) {\n      newOutline.name = originalMaterial.name + ' (Outline)';\n      newOutline.userData = JSON.parse(JSON.stringify(originalMaterial.userData));\n      newOutline.userData.vrmMaterialProperties = vrmProps;\n    }\n\n    return {\n      surface: newSurface,\n      outline: newOutline,\n    };\n  }\n\n  private _renameMaterialProperty(name: string): string {\n    if (name[0] !== '_') {\n      console.warn(`VRMMaterials: Given property name \"${name}\" might be invalid`);\n      return name;\n    }\n    name = name.substring(1);\n\n    if (!/[A-Z]/.test(name[0])) {\n      console.warn(`VRMMaterials: Given property name \"${name}\" might be invalid`);\n      return name;\n    }\n    return name[0].toLowerCase() + name.substring(1);\n  }\n\n  private _convertGLTFMaterial(material: THREE.Material): THREE.Material {\n    if ((material as any).isMeshStandardMaterial) {\n      const mtl = material as THREE.MeshStandardMaterial;\n\n      if (this._colorSpaceGamma) {\n        if (mtl.map) {\n          mtl.map.encoding = THREE.LinearEncoding;\n        }\n        if (mtl.emissiveMap) {\n          mtl.emissiveMap.encoding = THREE.LinearEncoding;\n        }\n      } else {\n        (mtl as any).color.convertSRGBToLinear(); // TODO: `as any` is temporal, since there are no declaration in @types/three\n        (mtl as any).emissive.convertSRGBToLinear(); // TODO: `as any` is temporal, since there are no declaration in @types/three\n      }\n    }\n\n    if ((material as any).isMeshBasicMaterial) {\n      const mtl = material as THREE.MeshBasicMaterial;\n\n      if (this._colorSpaceGamma) {\n        if (mtl.map) {\n          mtl.map.encoding = THREE.LinearEncoding;\n        }\n      } else {\n        (mtl as any).color.convertSRGBToLinear(); // TODO: `as any` is temporal, since there are no declaration in @types/three\n      }\n    }\n\n    return material;\n  }\n\n  private _extractMaterialProperties(\n    originalMaterial: THREE.Material,\n    vrmProps: VRMSchema.Material,\n    gltf: THREE.GLTF,\n  ): Promise<any> {\n    const taskList: Array<Promise<any>> = [];\n    const params: any = {};\n\n    // extract texture properties\n    if (vrmProps.textureProperties) {\n      for (const name of Object.keys(vrmProps.textureProperties)) {\n        const newName = this._renameMaterialProperty(name);\n        const textureIndex = vrmProps.textureProperties[name];\n\n        taskList.push(\n          gltf.parser.getDependency('texture', textureIndex).then((texture: THREE.Texture) => {\n            params[newName] = texture;\n          }),\n        );\n      }\n    }\n\n    // extract float properties\n    if (vrmProps.floatProperties) {\n      for (const name of Object.keys(vrmProps.floatProperties)) {\n        const newName = this._renameMaterialProperty(name);\n        params[newName] = vrmProps.floatProperties[name];\n      }\n    }\n\n    // extract vector (color tbh) properties\n    if (vrmProps.vectorProperties) {\n      for (const name of Object.keys(vrmProps.vectorProperties)) {\n        let newName = this._renameMaterialProperty(name);\n\n        // if this is textureST (same name as texture name itself), add '_ST'\n        // this is my most favorite MToon feature tbh\n        const isTextureST = [\n          '_MainTex',\n          '_ShadeTexture',\n          '_BumpMap',\n          '_ReceiveShadowTexture',\n          '_ShadingGradeTexture',\n          '_SphereAdd',\n          '_EmissionMap',\n          '_OutlineWidthTexture',\n        ].some((textureName) => name === textureName);\n        if (isTextureST) {\n          newName += '_ST';\n        }\n\n        params[newName] = new THREE.Vector4(...vrmProps.vectorProperties[name]);\n      }\n    }\n\n    // TODO: f (https://github.com/dwango/UniVRM/issues/172)\n    if (vrmProps.keywordMap!._ALPHATEST_ON && params.blendMode === MToonMaterialRenderMode.Opaque) {\n      params.blendMode = MToonMaterialRenderMode.Cutout;\n    }\n\n    // set whether it needs skinning and morphing or not\n    params.skinning = (originalMaterial as any).skinning || false;\n    params.morphTargets = (originalMaterial as any).morphTargets || false;\n    params.morphNormals = (originalMaterial as any).morphNormals || false;\n\n    return Promise.all(taskList).then(() => params);\n  }\n}\n","/* tslint:disable:member-ordering */\n\nimport * as THREE from 'three';\nimport vertexShader from './shaders/unlit.vert';\nimport fragmentShader from './shaders/unlit.frag';\n\nexport interface VRMUnlitMaterialParameters extends THREE.ShaderMaterialParameters {\n  cutoff?: number; // _Cutoff\n  map?: THREE.Texture; // _MainTex\n  mainTex?: THREE.Texture; // _MainTex (will be renamed to map)\n  mainTex_ST?: THREE.Vector4; // _MainTex_ST\n\n  renderType?: VRMUnlitMaterialRenderType | number;\n}\n\nexport enum VRMUnlitMaterialRenderType {\n  Opaque,\n  Cutout,\n  Transparent,\n  TransparentWithZWrite,\n}\n\n/**\n * This is a material that is an equivalent of \"VRM/Unlit***\" on VRM spec, those materials are already kinda deprecated though...\n */\nexport class VRMUnlitMaterial extends THREE.ShaderMaterial {\n  /**\n   * Readonly boolean that indicates this is a [[VRMUnlitMaterial]].\n   */\n  public readonly isVRMUnlitMaterial: boolean = true;\n\n  public cutoff = 0.5;\n  public map: THREE.Texture | null = null; // _MainTex\n  public mainTex_ST: THREE.Vector4 = new THREE.Vector4(0.0, 0.0, 1.0, 1.0); // _MainTex_ST\n  private _renderType: VRMUnlitMaterialRenderType = VRMUnlitMaterialRenderType.Opaque;\n\n  public shouldApplyUniforms = true; // when this is true, applyUniforms effects\n\n  constructor(parameters?: VRMUnlitMaterialParameters) {\n    super();\n\n    if (parameters === undefined) {\n      parameters = {};\n    }\n\n    // == enabling bunch of stuff ==============================================\n    parameters.fog = true;\n    parameters.clipping = true;\n\n    parameters.skinning = parameters.skinning || false;\n    parameters.morphTargets = parameters.morphTargets || false;\n    parameters.morphNormals = parameters.morphNormals || false;\n\n    // == uniforms =============================================================\n    parameters.uniforms = THREE.UniformsUtils.merge([\n      THREE.UniformsLib.common, // map\n      THREE.UniformsLib.fog,\n      {\n        cutoff: { value: 0.5 },\n        mainTex_ST: { value: new THREE.Vector4(0.0, 0.0, 1.0, 1.0) },\n      },\n    ]);\n\n    // == finally compile the shader program ===================================\n    this.setValues(parameters);\n\n    // == update shader stuff ==================================================\n    this._updateShaderCode();\n    this._applyUniforms();\n  }\n\n  get mainTex(): THREE.Texture | null {\n    return this.map;\n  }\n\n  set mainTex(t: THREE.Texture | null) {\n    this.map = t;\n  }\n\n  get renderType(): VRMUnlitMaterialRenderType {\n    return this._renderType;\n  }\n\n  set renderType(t: VRMUnlitMaterialRenderType) {\n    this._renderType = t;\n\n    this.depthWrite = this._renderType !== VRMUnlitMaterialRenderType.Transparent;\n    this.transparent =\n      this._renderType === VRMUnlitMaterialRenderType.Transparent ||\n      this._renderType === VRMUnlitMaterialRenderType.TransparentWithZWrite;\n    this._updateShaderCode();\n  }\n\n  /**\n   * Update this material.\n   * Usually this will be called via [[VRM.update]] so you don't have to call this manually.\n   *\n   * @param delta deltaTime since last update\n   */\n  public updateVRMMaterials(delta: number): void {\n    this._applyUniforms();\n  }\n\n  public copy(source: this): this {\n    super.copy(source);\n\n    // == copy members =========================================================\n    this.cutoff = source.cutoff;\n    this.map = source.map;\n    this.mainTex_ST.copy(source.mainTex_ST);\n    this.renderType = source.renderType;\n\n    return this;\n  }\n\n  /**\n   * Apply updated uniform variables.\n   */\n  private _applyUniforms(): void {\n    if (!this.shouldApplyUniforms) {\n      return;\n    }\n    this.shouldApplyUniforms = false;\n\n    this.uniforms.cutoff.value = this.cutoff;\n    this.uniforms.map.value = this.map;\n    this.uniforms.mainTex_ST.value.copy(this.mainTex_ST);\n  }\n\n  private _updateShaderCode(): void {\n    this.defines = {\n      RENDERTYPE_OPAQUE: this._renderType === VRMUnlitMaterialRenderType.Opaque,\n      RENDERTYPE_CUTOUT: this._renderType === VRMUnlitMaterialRenderType.Cutout,\n      RENDERTYPE_TRANSPARENT:\n        this._renderType === VRMUnlitMaterialRenderType.Transparent ||\n        this._renderType === VRMUnlitMaterialRenderType.TransparentWithZWrite,\n    };\n\n    this.vertexShader = vertexShader;\n    this.fragmentShader = fragmentShader;\n\n    // == set needsUpdate flag =================================================\n    this.needsUpdate = true;\n  }\n}\n","import * as THREE from 'three';\n\nexport const getEncodingComponents = (encoding: THREE.TextureEncoding): [string, string] => {\n  switch (encoding) {\n    case THREE.LinearEncoding:\n      return ['Linear', '( value )'];\n    case THREE.sRGBEncoding:\n      return ['sRGB', '( value )'];\n    case THREE.RGBEEncoding:\n      return ['RGBE', '( value )'];\n    case THREE.RGBM7Encoding:\n      return ['RGBM', '( value, 7.0 )'];\n    case THREE.RGBM16Encoding:\n      return ['RGBM', '( value, 16.0 )'];\n    case THREE.RGBDEncoding:\n      return ['RGBD', '( value, 256.0 )'];\n    case THREE.GammaEncoding:\n      return ['Gamma', '( value, float( GAMMA_FACTOR ) )'];\n    default:\n      throw new Error('unsupported encoding: ' + encoding);\n  }\n};\n\nexport const getTexelDecodingFunction = (functionName: string, encoding: THREE.TextureEncoding): string => {\n  const components = getEncodingComponents(encoding);\n  return 'vec4 ' + functionName + '( vec4 value ) { return ' + components[0] + 'ToLinear' + components[1] + '; }';\n};\n","export * from './MToonMaterial';\nexport * from './VRMMaterialImporter';\nexport * from './VRMUnlitMaterial';\n","export default \"// #define PHONG\\n\\n#ifdef BLENDMODE_CUTOUT\\n  uniform float cutoff;\\n#endif\\n\\nuniform vec3 color;\\nuniform float colorAlpha;\\nuniform vec3 shadeColor;\\n#ifdef USE_SHADETEXTURE\\n  uniform sampler2D shadeTexture;\\n#endif\\n\\nuniform float receiveShadowRate;\\n#ifdef USE_RECEIVESHADOWTEXTURE\\n  uniform sampler2D receiveShadowTexture;\\n#endif\\n\\nuniform float shadingGradeRate;\\n#ifdef USE_SHADINGGRADETEXTURE\\n  uniform sampler2D shadingGradeTexture;\\n#endif\\n\\nuniform float shadeShift;\\nuniform float shadeToony;\\nuniform float lightColorAttenuation;\\nuniform float indirectLightIntensity;\\n\\n#ifdef USE_RIMTEXTURE\\n  uniform sampler2D rimTexture;\\n#endif\\nuniform vec3 rimColor;\\nuniform float rimLightingMix;\\nuniform float rimFresnelPower;\\nuniform float rimLift;\\n\\n#ifdef USE_SPHEREADD\\n  uniform sampler2D sphereAdd;\\n#endif\\n\\nuniform vec3 emissionColor;\\n\\nuniform vec3 outlineColor;\\nuniform float outlineLightingMix;\\n\\n#ifdef USE_UVANIMMASKTEXTURE\\n  uniform sampler2D uvAnimMaskTexture;\\n#endif\\n\\nuniform float uvAnimOffsetX;\\nuniform float uvAnimOffsetY;\\nuniform float uvAnimTheta;\\n\\n#include <common>\\n#include <packing>\\n#include <dithering_pars_fragment>\\n#include <color_pars_fragment>\\n\\n// #include <uv_pars_fragment>\\n#if defined( USE_MAP ) || defined( USE_SHADETEXTURE ) || defined( USE_NORMALMAP ) || defined( USE_RECEIVESHADOWTEXTURE ) || defined( USE_SHADINGGRADETEXTURE ) || defined( USE_RIMTEXTURE ) || defined( USE_EMISSIVEMAP ) || defined( USE_OUTLINEWIDTHTEXTURE ) || defined( USE_UVANIMMASKTEXTURE )\\n  varying vec2 vUv;\\n#endif\\n\\n#include <uv2_pars_fragment>\\n#include <map_pars_fragment>\\n// #include <alphamap_pars_fragment>\\n#include <aomap_pars_fragment>\\n// #include <lightmap_pars_fragment>\\n#include <emissivemap_pars_fragment>\\n// #include <envmap_pars_fragment>\\n// #include <gradientmap_pars_fragment>\\n#include <fog_pars_fragment>\\n#include <bsdfs>\\n#include <lights_pars_begin>\\n\\n// #include <lights_phong_pars_fragment>\\nvarying vec3 vViewPosition;\\n\\n#ifndef FLAT_SHADED\\n  varying vec3 vNormal;\\n#endif\\n\\n#define Material_LightProbeLOD( material ) (0)\\n\\n#include <shadowmap_pars_fragment>\\n// #include <bumpmap_pars_fragment>\\n\\n// #include <normalmap_pars_fragment>\\n#ifdef USE_NORMALMAP\\n  uniform sampler2D normalMap;\\n  uniform float bumpScale;\\n\\n  // this number is very random, this is still a 対処療法\\n  #define UV_DERIVATIVE_EPSILON 1E-6\\n\\n  // Per-Pixel Tangent Space Normal Mapping\\n  // http://hacksoflife.blogspot.ch/2009/11/per-pixel-tangent-space-normal-mapping.html\\n  vec3 perturbNormal2Arb( vec2 uv, vec3 eye_pos, vec3 surf_norm ) {\\n    // Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988\\n    vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\\n    vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\\n    vec2 st0 = dFdx( uv.st );\\n    vec2 st1 = dFdy( uv.st );\\n\\n    float scale = sign( st1.t * st0.s - st0.t * st1.s ); // we do not care about the magnitude\\n    vec3 S = ( q0 * st1.t - q1 * st0.t ) * scale;\\n    vec3 T = ( - q0 * st1.s + q1 * st0.s ) * scale;\\n\\n    // Workaround for the issue that happens when delta of uv = 0.0\\n    if ( length( S ) == 0.0 || length( T ) == 0.0 ) {\\n      return surf_norm;\\n    }\\n\\n    S = normalize( S );\\n    T = normalize( T );\\n    vec3 N = normalize( surf_norm );\\n\\n    vec3 mapN = texture2D( normalMap, uv ).xyz * 2.0 - 1.0;\\n\\n    mapN.xy *= bumpScale;\\n\\n    #ifdef DOUBLE_SIDED\\n      // Workaround for Adreno GPUs gl_FrontFacing bug. See #15850 and #10331\\n      // http://hacksoflife.blogspot.com/2009/11/per-pixel-tangent-space-normal-mapping.html?showComment=1522254677437#c5087545147696715943\\n      vec3 NfromST = cross( S, T );\\n      if( dot( NfromST, N ) > 0.0 ) {\\n        S *= -1.0;\\n        T *= -1.0;\\n      }\\n    #else\\n      mapN.xy *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\\n    #endif\\n\\n    mat3 tsn = mat3( S, T, N );\\n\\n    return normalize( tsn * mapN );\\n  }\\n#endif\\n\\n// #include <specularmap_pars_fragment>\\n#include <logdepthbuf_pars_fragment>\\n#include <clipping_planes_pars_fragment>\\n\\n// == lighting stuff ===========================================================\\nfloat getLightIntensity(\\n  const in IncidentLight directLight,\\n  const in GeometricContext geometry,\\n  const in float shadow,\\n  const in float shadingGrade\\n) {\\n  float lightIntensity = dot( geometry.normal, directLight.direction );\\n  lightIntensity = 0.5 + 0.5 * lightIntensity;\\n  lightIntensity = lightIntensity * shadow;\\n  lightIntensity = lightIntensity * shadingGrade;\\n  lightIntensity = lightIntensity * 2.0 - 1.0;\\n  return smoothstep( shadeShift, shadeShift + ( 1.0 - shadeToony ), lightIntensity );\\n}\\n\\nvec3 getLighting( const in vec3 lightColor ) {\\n  vec3 lighting = lightColor;\\n  lighting = mix(\\n    lighting,\\n    vec3( max( 0.001, max( lighting.x, max( lighting.y, lighting.z ) ) ) ),\\n    lightColorAttenuation\\n  );\\n\\n  #ifndef PHYSICALLY_CORRECT_LIGHTS\\n    lighting *= PI;\\n  #endif\\n\\n  return lighting;\\n}\\n\\nvec3 getDiffuse(\\n  const in vec3 lit,\\n  const in vec3 shade,\\n  const in float lightIntensity,\\n  const in vec3 lighting\\n) {\\n  #ifdef DEBUG_LITSHADERATE\\n    return vec3( BRDF_Diffuse_Lambert( lightIntensity * lighting ) );\\n  #endif\\n\\n  return lighting * BRDF_Diffuse_Lambert( mix( shade, lit, lightIntensity ) );\\n}\\n\\nvec3 calcDirectDiffuse(\\n  const in vec2 uv,\\n  const in vec3 lit,\\n  const in vec3 shade,\\n  in GeometricContext geometry,\\n  inout ReflectedLight reflectedLight\\n) {\\n  IncidentLight directLight;\\n  vec3 lightingSum = vec3( 0.0 );\\n\\n  float shadingGrade = 1.0;\\n  #ifdef USE_SHADINGGRADETEXTURE\\n    shadingGrade = 1.0 - shadingGradeRate * ( 1.0 - texture2D( shadingGradeTexture, uv ).r );\\n  #endif\\n\\n  float receiveShadow = receiveShadowRate;\\n  #ifdef USE_RECEIVESHADOWTEXTURE\\n    receiveShadow *= texture2D( receiveShadowTexture, uv ).a;\\n  #endif\\n\\n  #if ( NUM_POINT_LIGHTS > 0 )\\n    PointLight pointLight;\\n\\n    #pragma unroll_loop\\n    for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\\n      pointLight = pointLights[ i ];\\n      getPointDirectLightIrradiance( pointLight, geometry, directLight );\\n\\n      float atten = 1.0;\\n      #ifdef USE_SHADOWMAP\\n        atten = all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\\n      #endif\\n\\n      float shadow = 1.0 - receiveShadow * ( 1.0 - ( 0.5 + 0.5 * atten ) );\\n      float lightIntensity = getLightIntensity( directLight, geometry, shadow, shadingGrade );\\n      vec3 lighting = getLighting( directLight.color );\\n      reflectedLight.directDiffuse += getDiffuse( lit, shade, lightIntensity, lighting );\\n      lightingSum += lighting;\\n    }\\n  #endif\\n\\n  #if ( NUM_SPOT_LIGHTS > 0 )\\n    SpotLight spotLight;\\n\\n    #pragma unroll_loop\\n    for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\\n      spotLight = spotLights[ i ];\\n      getSpotDirectLightIrradiance( spotLight, geometry, directLight );\\n\\n      float atten = 1.0;\\n      #ifdef USE_SHADOWMAP\\n        atten = all( bvec2( spotLight.shadow, directLight.visible ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\\n      #endif\\n\\n      float shadow = 1.0 - receiveShadow * ( 1.0 - ( 0.5 + 0.5 * atten ) );\\n      float lightIntensity = getLightIntensity( directLight, geometry, shadow, shadingGrade );\\n      vec3 lighting = getLighting( directLight.color );\\n      reflectedLight.directDiffuse += getDiffuse( lit, shade, lightIntensity, lighting );\\n      lightingSum += lighting;\\n    }\\n  #endif\\n\\n  #if ( NUM_DIR_LIGHTS > 0 )\\n    DirectionalLight directionalLight;\\n\\n    #pragma unroll_loop\\n    for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\\n      directionalLight = directionalLights[ i ];\\n      getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\\n\\n      float atten = 1.0;\\n      #ifdef USE_SHADOWMAP\\n        atten = all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\\n      #endif\\n\\n      float shadow = 1.0 - receiveShadow * ( 1.0 - ( 0.5 + 0.5 * atten ) );\\n      float lightIntensity = getLightIntensity( directLight, geometry, shadow, shadingGrade );\\n      vec3 lighting = getLighting( directLight.color );\\n      reflectedLight.directDiffuse += getDiffuse( lit, shade, lightIntensity, lighting );\\n      lightingSum += lighting;\\n    }\\n  #endif\\n\\n  return lightingSum;\\n}\\n\\n// == post correction ==========================================================\\nvoid postCorrection() {\\n  #include <tonemapping_fragment>\\n  #include <encodings_fragment>\\n  #include <fog_fragment>\\n  #include <premultiplied_alpha_fragment>\\n  #include <dithering_fragment>\\n}\\n\\n// == main procedure ===========================================================\\nvoid main() {\\n  #include <clipping_planes_fragment>\\n\\n  vec2 uv = vec2(0.5, 0.5);\\n\\n  #if defined( USE_MAP ) || defined( USE_SHADETEXTURE ) || defined( USE_NORMALMAP ) || defined( USE_RECEIVESHADOWTEXTURE ) || defined( USE_SHADINGGRADETEXTURE ) || defined( USE_RIMTEXTURE ) || defined( USE_EMISSIVEMAP ) || defined( USE_OUTLINEWIDTHTEXTURE ) || defined( USE_UVANIMMASKTEXTURE )\\n    uv = vUv;\\n\\n    float uvAnimMask = 1.0;\\n    #ifdef USE_UVANIMMASKTEXTURE\\n      uvAnimMask = texture2D( uvAnimMaskTexture, uv ).x;\\n    #endif\\n\\n    uv = uv + vec2( uvAnimOffsetX, uvAnimOffsetY ) * uvAnimMask;\\n    float uvRotCos = cos( uvAnimTheta * uvAnimMask );\\n    float uvRotSin = sin( uvAnimTheta * uvAnimMask );\\n    uv = mat2( uvRotCos, uvRotSin, -uvRotSin, uvRotCos ) * ( uv - 0.5 ) + 0.5;\\n  #endif\\n\\n  #ifdef DEBUG_UV\\n    gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\\n    #if defined( USE_MAP ) || defined( USE_SHADETEXTURE ) || defined( USE_NORMALMAP ) || defined( USE_RECEIVESHADOWTEXTURE ) || defined( USE_SHADINGGRADETEXTURE ) || defined( USE_RIMTEXTURE ) || defined( USE_EMISSIVEMAP ) || defined( USE_OUTLINEWIDTHTEXTURE ) || defined( USE_UVANIMMASKTEXTURE )\\n      gl_FragColor = vec4( uv, 0.0, 1.0 );\\n    #endif\\n    return;\\n  #endif\\n\\n  vec4 diffuseColor = vec4( color, colorAlpha );\\n  ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\n  vec3 totalEmissiveRadiance = emissionColor;\\n\\n  #include <logdepthbuf_fragment>\\n\\n  // #include <map_fragment>\\n  #ifdef USE_MAP\\n    diffuseColor *= mapTexelToLinear( texture2D( map, uv ) );\\n  #endif\\n\\n  #include <color_fragment>\\n  // #include <alphamap_fragment>\\n\\n  // -- MToon: alpha -----------------------------------------------------------\\n  // #include <alphatest_fragment>\\n  #ifdef BLENDMODE_CUTOUT\\n    if ( diffuseColor.a <= cutoff ) { discard; }\\n    diffuseColor.a = 1.0;\\n  #endif\\n\\n  #ifdef BLENDMODE_OPAQUE\\n    diffuseColor.a = 1.0;\\n  #endif\\n\\n  #if defined( OUTLINE ) && defined( OUTLINE_COLOR_FIXED ) // omitting DebugMode\\n    gl_FragColor = vec4( outlineColor, diffuseColor.a );\\n    postCorrection();\\n    return;\\n  #endif\\n\\n  // #include <specularmap_fragment>\\n  #include <normal_fragment_begin>\\n\\n  #ifdef OUTLINE\\n    normal *= -1.0;\\n  #endif\\n\\n  // #include <normal_fragment_maps>\\n  #ifdef USE_NORMALMAP\\n    normal = perturbNormal2Arb( uv, -vViewPosition, normal );\\n  #endif\\n\\n  // #include <emissivemap_fragment>\\n  #ifdef USE_EMISSIVEMAP\\n    totalEmissiveRadiance *= emissiveMapTexelToLinear( texture2D( emissiveMap, uv ) ).rgb;\\n  #endif\\n\\n  #ifdef DEBUG_NORMAL\\n    gl_FragColor = vec4( 0.5 + 0.5 * normal, 1.0 );\\n    return;\\n  #endif\\n\\n  // -- MToon: lighting --------------------------------------------------------\\n  // accumulation\\n  // #include <lights_phong_fragment>\\n  // #include <lights_fragment_begin>\\n  vec3 lit = diffuseColor.rgb;\\n  vec3 shade = shadeColor;\\n  #ifdef USE_SHADETEXTURE\\n    shade *= shadeTextureTexelToLinear( texture2D( shadeTexture, uv ) ).rgb;\\n  #endif\\n\\n  GeometricContext geometry;\\n\\n  geometry.position = - vViewPosition;\\n  geometry.normal = normal;\\n  geometry.viewDir = normalize( vViewPosition );\\n\\n  vec3 lighting = calcDirectDiffuse( uv, diffuseColor.rgb, shade, geometry, reflectedLight );\\n\\n  vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\\n  #if ( NUM_HEMI_LIGHTS > 0 )\\n    #pragma unroll_loop\\n    for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\\n      irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\\n    }\\n  #endif\\n\\n  // #include <lights_fragment_maps>\\n  #ifdef USE_LIGHTMAP\\n    vec3 lightMapIrradiance = texture2D( lightMap, vUv2 ).rgb * lightMapIntensity;\\n    #ifndef PHYSICALLY_CORRECT_LIGHTS\\n      lightMapIrradiance *= PI; // factor of PI should not be present; included here to prevent breakage\\n    #endif\\n    irradiance += lightMapIrradiance;\\n  #endif\\n\\n  // #include <lights_fragment_end>\\n  reflectedLight.indirectDiffuse += indirectLightIntensity * irradiance * BRDF_Diffuse_Lambert( lit );\\n\\n  // modulation\\n  #include <aomap_fragment>\\n\\n  vec3 col = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\\n\\n  #if defined( OUTLINE ) && defined( OUTLINE_COLOR_MIXED ) // omitting DebugMode\\n    gl_FragColor = vec4(\\n      outlineColor.rgb * mix( vec3( 1.0 ), col, outlineLightingMix ),\\n      diffuseColor.a\\n    );\\n    postCorrection();\\n    return;\\n  #endif\\n\\n  // -- MToon: parametric rim lighting -----------------------------------------\\n  vec3 viewDir = normalize( vViewPosition );\\n  vec3 rimMix = mix(vec3(1.0), lighting + indirectLightIntensity * irradiance, rimLightingMix);\\n  vec3 rim = rimColor * pow( saturate( 1.0 - dot( viewDir, normal ) + rimLift ), rimFresnelPower );\\n  #ifdef USE_RIMTEXTURE\\n    rim *= texture2D( rimTexture, uv ).rgb;\\n  #endif\\n  col += rim;\\n\\n  // -- MToon: additive matcap -------------------------------------------------\\n  #ifdef USE_SPHEREADD\\n    {\\n      vec3 x = normalize( vec3( viewDir.z, 0.0, -viewDir.x ) );\\n      vec3 y = cross( viewDir, x ); // guaranteed to be normalized\\n      vec2 sphereUv = 0.5 + 0.5 * vec2( dot( x, normal ), -dot( y, normal ) );\\n      vec3 matcap = sphereAddTexelToLinear( texture2D( sphereAdd, sphereUv ) ).xyz;\\n      col += matcap;\\n    }\\n  #endif\\n\\n  // -- MToon: Emission --------------------------------------------------------\\n  col += totalEmissiveRadiance;\\n\\n  // #include <envmap_fragment>\\n\\n  // -- Almost done! -----------------------------------------------------------\\n  gl_FragColor = vec4( col, diffuseColor.a );\\n  postCorrection();\\n}\"","export default \"// #define PHONG\\n\\nvarying vec3 vViewPosition;\\n\\n#ifndef FLAT_SHADED\\n  varying vec3 vNormal;\\n#endif\\n\\n#include <common>\\n\\n// #include <uv_pars_vertex>\\n#if defined( USE_MAP ) || defined( USE_SHADETEXTURE ) || defined( USE_NORMALMAP ) || defined( USE_RECEIVESHADOWTEXTURE ) || defined( USE_SHADINGGRADETEXTURE ) || defined( USE_RIMTEXTURE ) || defined( USE_EMISSIVEMAP ) || defined( USE_OUTLINEWIDTHTEXTURE ) || defined( USE_UVANIMMASKTEXTURE )\\n  varying vec2 vUv;\\n  uniform vec4 mainTex_ST;\\n#endif\\n\\n#include <uv2_pars_vertex>\\n// #include <displacementmap_pars_vertex>\\n// #include <envmap_pars_vertex>\\n#include <color_pars_vertex>\\n#include <fog_pars_vertex>\\n#include <morphtarget_pars_vertex>\\n#include <skinning_pars_vertex>\\n#include <shadowmap_pars_vertex>\\n#include <logdepthbuf_pars_vertex>\\n#include <clipping_planes_pars_vertex>\\n\\n#ifdef USE_OUTLINEWIDTHTEXTURE\\n  uniform sampler2D outlineWidthTexture;\\n#endif\\n\\nuniform float outlineWidth;\\nuniform float outlineScaledMaxDistance;\\n\\nvoid main() {\\n\\n  // #include <uv_vertex>\\n  #if defined( USE_MAP ) || defined( USE_SHADETEXTURE ) || defined( USE_NORMALMAP ) || defined( USE_RECEIVESHADOWTEXTURE ) || defined( USE_SHADINGGRADETEXTURE ) || defined( USE_RIMTEXTURE ) || defined( USE_EMISSIVEMAP ) || defined( USE_OUTLINEWIDTHTEXTURE ) || defined( USE_UVANIMMASKTEXTURE )\\n    vUv = vec2( mainTex_ST.p * uv.x + mainTex_ST.s, mainTex_ST.q * uv.y + mainTex_ST.t );\\n  #endif\\n\\n  #include <uv2_vertex>\\n  #include <color_vertex>\\n\\n  #include <beginnormal_vertex>\\n  #include <morphnormal_vertex>\\n  #include <skinbase_vertex>\\n  #include <skinnormal_vertex>\\n  #include <defaultnormal_vertex>\\n\\n  #ifndef FLAT_SHADED // Normal computed with derivatives when FLAT_SHADED\\n    vNormal = normalize( transformedNormal );\\n  #endif\\n\\n  #include <begin_vertex>\\n\\n  #include <morphtarget_vertex>\\n  #include <skinning_vertex>\\n  // #include <displacementmap_vertex>\\n  #include <project_vertex>\\n  #include <logdepthbuf_vertex>\\n  #include <clipping_planes_vertex>\\n\\n  vViewPosition = - mvPosition.xyz;\\n\\n  float outlineTex = 1.0;\\n\\n  #ifdef OUTLINE\\n    #ifdef USE_OUTLINEWIDTHTEXTURE\\n      outlineTex = texture2D( outlineWidthTexture, vUv ).r;\\n    #endif\\n\\n    #ifdef OUTLINE_WIDTH_WORLD\\n      vec3 outlineOffset = 0.01 * outlineWidth * outlineTex * normalize( objectNormal );\\n      gl_Position += projectionMatrix * modelViewMatrix * vec4( outlineOffset, 0.0 );\\n    #endif\\n\\n    #ifdef OUTLINE_WIDTH_SCREEN\\n      vec3 clipNormal = ( projectionMatrix * modelViewMatrix * vec4( normalize( objectNormal ), 0.0 ) ).xyz;\\n      vec2 projectedNormal = normalize( clipNormal.xy );\\n      projectedNormal *= min( gl_Position.w, outlineScaledMaxDistance );\\n      projectedNormal.x *= projectionMatrix[ 0 ].x / projectionMatrix[ 1 ].y;\\n      gl_Position.xy += 0.01 * outlineWidth * outlineTex * projectedNormal.xy;\\n    #endif\\n\\n    gl_Position.z += 1E-6 * gl_Position.w; // anti-artifact magic\\n  #endif\\n\\n  #include <worldpos_vertex>\\n  // #include <envmap_vertex>\\n  #include <shadowmap_vertex>\\n  #include <fog_vertex>\\n\\n}\"","export default \"#ifdef RENDERTYPE_CUTOUT\\n  uniform float cutoff;\\n#endif\\n\\n#include <common>\\n#include <color_pars_fragment>\\n#include <uv_pars_fragment>\\n#include <uv2_pars_fragment>\\n#include <map_pars_fragment>\\n// #include <alphamap_pars_fragment>\\n// #include <aomap_pars_fragment>\\n// #include <lightmap_pars_fragment>\\n// #include <envmap_pars_fragment>\\n#include <fog_pars_fragment>\\n// #include <specularmap_pars_fragment>\\n#include <logdepthbuf_pars_fragment>\\n#include <clipping_planes_pars_fragment>\\n\\n// == main procedure ===========================================================\\nvoid main() {\\n  #include <clipping_planes_fragment>\\n\\n  vec4 diffuseColor = vec4( 1.0 );\\n\\n  #include <logdepthbuf_fragment>\\n\\n  // #include <map_fragment>\\n  #ifdef USE_MAP\\n    diffuseColor *= mapTexelToLinear( texture2D( map, vUv ) );\\n  #endif\\n\\n  #include <color_fragment>\\n  // #include <alphamap_fragment>\\n\\n  // MToon: alpha\\n  // #include <alphatest_fragment>\\n  #ifdef RENDERTYPE_CUTOUT\\n    if ( diffuseColor.a <= cutoff ) { discard; }\\n    diffuseColor.a = 1.0;\\n  #endif\\n\\n  #ifdef RENDERTYPE_OPAQUE\\n    diffuseColor.a = 1.0;\\n  #endif\\n\\n  // #include <specularmap_fragment>\\n\\n  ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\n\\n  // accumulation (baked indirect lighting only)\\n  #ifdef USE_LIGHTMAP\\n    reflectedLight.indirectDiffuse += texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\\n  #else\\n    reflectedLight.indirectDiffuse += vec3( 1.0 );\\n  #endif\\n\\n  // modulation\\n  // #include <aomap_fragment>\\n\\n  reflectedLight.indirectDiffuse *= diffuseColor.rgb;\\n  vec3 outgoingLight = reflectedLight.indirectDiffuse;\\n\\n  // #include <envmap_fragment>\\n\\n  gl_FragColor = vec4( outgoingLight, diffuseColor.a );\\n\\n  #include <premultiplied_alpha_fragment>\\n  #include <tonemapping_fragment>\\n  #include <encodings_fragment>\\n  #include <fog_fragment>\\n}\"","export default \"#include <common>\\n\\n// #include <uv_pars_vertex>\\n#ifdef USE_MAP\\n  varying vec2 vUv;\\n  uniform vec4 mainTex_ST;\\n#endif\\n\\n#include <uv2_pars_vertex>\\n#include <envmap_pars_vertex>\\n#include <color_pars_vertex>\\n#include <fog_pars_vertex>\\n#include <morphtarget_pars_vertex>\\n#include <skinning_pars_vertex>\\n#include <logdepthbuf_pars_vertex>\\n#include <clipping_planes_pars_vertex>\\n\\nvoid main() {\\n\\n  // #include <uv_vertex>\\n  #ifdef USE_MAP\\n    vUv = vec2( mainTex_ST.p * uv.x + mainTex_ST.s, mainTex_ST.q * uv.y + mainTex_ST.t );\\n  #endif\\n\\n  #include <uv2_vertex>\\n  #include <color_vertex>\\n  #include <skinbase_vertex>\\n\\n  #ifdef USE_ENVMAP\\n\\n  #include <beginnormal_vertex>\\n  #include <morphnormal_vertex>\\n  #include <skinnormal_vertex>\\n  #include <defaultnormal_vertex>\\n\\n  #endif\\n\\n  #include <begin_vertex>\\n  #include <morphtarget_vertex>\\n  #include <skinning_vertex>\\n  #include <project_vertex>\\n  #include <logdepthbuf_vertex>\\n\\n  #include <worldpos_vertex>\\n  #include <clipping_planes_vertex>\\n  #include <envmap_vertex>\\n  #include <fog_vertex>\\n\\n}\"","import * as THREE from 'three';\n\nexport function reduceBones(root: THREE.Object3D): void {\n  // Traverse an entire tree\n  root.traverse((obj) => {\n    if (obj.type !== 'SkinnedMesh') {\n      return;\n    }\n\n    const mesh = obj as THREE.SkinnedMesh;\n    const geometry = (mesh.geometry as THREE.BufferGeometry).clone();\n    mesh.geometry = geometry;\n    const attribute = geometry.getAttribute('skinIndex');\n\n    // generate reduced bone list\n    const bones: THREE.Bone[] = []; // new list of bone\n    const boneInverses: THREE.Matrix4[] = []; // new list of boneInverse\n    const boneIndexMap: { [index: number]: number } = {}; // map of old bone index vs. new bone index\n    const array = (attribute.array as any).map((index: number) => {\n      // new skinIndex buffer\n      if (boneIndexMap[index] === undefined) {\n        boneIndexMap[index] = bones.length;\n        bones.push(mesh.skeleton.bones[index]);\n        boneInverses.push(mesh.skeleton.boneInverses[index]);\n      }\n      return boneIndexMap[index];\n    });\n\n    // attach new skinIndex buffer\n    geometry.removeAttribute('skinIndex');\n    geometry.addAttribute('skinIndex', new THREE.BufferAttribute(array, 4, false));\n    mesh.bind(new THREE.Skeleton(bones, boneInverses), new THREE.Matrix4());\n    //                                                 ^^^^^^^^^^^^^^^^^^^ transform of meshes should be ignored\n    // See: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins\n  });\n}\n","import * as THREE from 'three';\nimport { getWorldQuaternionLite } from '../utils/math';\n// based on\n// http://rocketjump.skr.jp/unity3d/109/\n// https://github.com/dwango/UniVRM/blob/master/Scripts/SpringBone/VRMSpringBone.cs\n\nexport const GIZMO_RENDER_ORDER = 10000;\nconst IDENTITY_MATRIX4 = Object.freeze(new THREE.Matrix4());\nconst IDENTITY_QUATERNION = Object.freeze(new THREE.Quaternion());\n\n// 計算中の一時保存用変数（一度インスタンスを作ったらあとは使い回す）\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\nconst _v3C = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\nconst _matA = new THREE.Matrix4();\nconst _matB = new THREE.Matrix4();\n\n/**\n * A class represents a single spring bone of a VRM.\n * It should be managed by a [[VRMSpringBoneManager]].\n */\nexport class VRMSpringBone {\n  /**\n   * Radius of the bone, will be used for collision.\n   */\n  public readonly radius: number;\n\n  /**\n   * Stiffness force of the bone. Increasing the value = faster convergence (feels \"harder\").\n   * On UniVRM, its range on GUI is between `0.0` and `4.0` .\n   */\n  public readonly stiffnessForce: number;\n\n  /**\n   * Power of the gravity against this bone.\n   * The \"power\" used in here is very far from scientific physics term...\n   */\n  public readonly gravityPower: number;\n\n  /**\n   * Direction of the gravity against this bone.\n   * Usually it should be normalized.\n   */\n  public readonly gravityDir: THREE.Vector3;\n\n  /**\n   * Drag force of the bone. Increasing the value = less oscillation (feels \"heavier\").\n   * On UniVRM, its range on GUI is between `0.0` and `1.0` .\n   */\n  public readonly dragForce: number;\n\n  /**\n   * An Object3D attached to this bone.\n   */\n  public readonly bone: THREE.Object3D;\n\n  /**\n   * Colliders (as `THREE.Mesh` ) attached to this bone.\n   */\n  public readonly colliders: THREE.Mesh[];\n\n  /**\n   * Current position of child tail, in world unit. Will be used for verlet integration.\n   */\n  protected _currentTail: THREE.Vector3;\n\n  /**\n   * Previous position of child tail, in world unit. Will be used for verlet integration.\n   */\n  protected _prevTail: THREE.Vector3;\n\n  /**\n   * Next position of child tail, in world unit. Will be used for verlet integration.\n   * Actually used only in [[update]] and it's kind of temporary variable.\n   */\n  protected _nextTail: THREE.Vector3;\n\n  /**\n   * Initial axis of the bone, in local unit.\n   */\n  protected _boneAxis: THREE.Vector3;\n\n  /**\n   * Length of the bone in **world unit**. Will be used for normalization in update loop.\n   * It's same as local unit length unless there are scale transformation in world matrix.\n   */\n  protected _worldBoneLength: number;\n\n  /**\n   * World position of this bone, kind of temporary variable.\n   */\n  protected _worldPosition: THREE.Vector3;\n\n  /**\n   * Rotation of parent bone, in world unit.\n   * We should update this constantly in [[update]].\n   */\n  private _parentWorldRotation: THREE.Quaternion;\n\n  /**\n   * Initial state of the local matrix of the bone.\n   */\n  private _initialLocalMatrix: THREE.Matrix4;\n\n  /**\n   * Initial state of the rotation of the bone.\n   */\n  private _initialLocalRotation: THREE.Quaternion;\n\n  /**\n   * Initial state of the position of its child.\n   */\n  private _initialLocalChildPosition: THREE.Vector3;\n\n  /**\n   * Create a new VRMSpringBone.\n   *\n   * @param bone An Object3D that will be attached to this bone\n   * @param radius Radius of the bone\n   * @param stiffness Stiffness force of the bone\n   * @param gravityDir Direction of the gravity against this bone\n   * @param gravityPower Power of the gravity against this bone\n   * @param dragForce Drag force of the bone\n   * @param colliders Colliders that will be attached to this bone\n   */\n  constructor(\n    bone: THREE.Object3D,\n    radius: number,\n    stiffiness: number,\n    gravityDir: THREE.Vector3,\n    gravityPower: number,\n    dragForce: number,\n    colliders: THREE.Mesh[] = [],\n  ) {\n    this.bone = bone; // uniVRMでの parent\n    this.bone.matrixAutoUpdate = false; // updateにより計算されるのでthree.js内での自動処理は不要\n\n    this.radius = radius;\n    this.stiffnessForce = stiffiness;\n    this.gravityDir = gravityDir;\n    this.gravityPower = gravityPower;\n    this.dragForce = dragForce;\n    this.colliders = colliders;\n\n    this._worldPosition = new THREE.Vector3().setFromMatrixPosition(this.bone.matrixWorld);\n\n    this._parentWorldRotation = new THREE.Quaternion();\n\n    this._initialLocalMatrix = this.bone.matrix.clone();\n    this._initialLocalRotation = this.bone.quaternion.clone();\n    this._initialLocalChildPosition = ((): THREE.Vector3 => {\n      if (this.bone.children.length === 0) {\n        // 末端のボーン。子ボーンがいないため「自分の少し先」が子ボーンということにする\n        // https://github.com/dwango/UniVRM/blob/master/Assets/VRM/UniVRM/Scripts/SpringBone/VRMSpringBone.cs#L246\n        return this.bone.position\n          .clone()\n          .normalize()\n          .multiplyScalar(0.07); // magic number! derives from original source\n      } else {\n        const firstChild = this.bone.children[0];\n        return firstChild.position.clone();\n      }\n    })();\n\n    this._currentTail = this.bone.localToWorld(this._initialLocalChildPosition.clone());\n    this._prevTail = this._currentTail.clone();\n    this._nextTail = this._currentTail.clone();\n\n    this._boneAxis = this._initialLocalChildPosition.clone().normalize();\n    this._worldBoneLength = this.bone\n      .localToWorld(_v3A.copy(this._initialLocalChildPosition))\n      .sub(this._worldPosition)\n      .length();\n  }\n\n  /**\n   * Reset the state of this bone.\n   * You might want to call [[VRMSpringBoneManager.reset]] instead.\n   */\n  public reset(): void {\n    this.bone.matrix.copy(this._initialLocalMatrix);\n\n    this.bone.localToWorld(this._currentTail.copy(this._initialLocalChildPosition));\n    this._prevTail.copy(this._currentTail);\n    this._nextTail.copy(this._currentTail);\n\n    // ボーンの姿勢を手動で操作したので、matrixWorldも更新しておく\n    this.bone.updateMatrix();\n    this.bone.matrixWorld.multiplyMatrices(this._getParentMatrixWorld(), this.bone.matrix);\n    this._worldPosition.setFromMatrixPosition(this.bone.matrixWorld);\n  }\n\n  /**\n   * Update the state of this bone.\n   * You might want to call [[VRMSpringBoneManager.update]] instead.\n   *\n   * @param delta deltaTime\n   */\n  public update(delta: number): void {\n    if (delta <= 0) return;\n\n    // 親スプリングボーンの姿勢は常に変化している。\n    // それに基づいて処理直前に自分のworldMatrixを更新しておく\n    this.bone.matrixWorld.multiplyMatrices(this._getParentMatrixWorld(), this.bone.matrix);\n\n    if (this.bone.parent) {\n      // SpringBoneは親から順に処理されていくため、\n      // 親のmatrixWorldは最新状態の前提でworldMatrixからquaternionを取り出す。\n      // 制限はあるけれど、計算は少ないのでgetWorldQuaternionではなくこの方法を取る。\n      getWorldQuaternionLite(this.bone.parent, this._parentWorldRotation);\n    } else {\n      this._parentWorldRotation.copy(IDENTITY_QUATERNION);\n    }\n\n    // 更新済みのworldMatrixからworldPositionを取り出す。\n    // `getWorldPosition()` は負荷が高いので利用しない。\n    this._worldPosition.setFromMatrixPosition(this.bone.matrixWorld);\n    const stiffness = this.stiffnessForce * delta;\n    const external = _v3B.copy(this.gravityDir).multiplyScalar(this.gravityPower * delta);\n\n    // verlet積分で次の位置を計算\n    this._nextTail\n      .copy(this._currentTail)\n      .add(\n        _v3A\n          .copy(this._currentTail)\n          .sub(this._prevTail)\n          .multiplyScalar(1 - this.dragForce),\n      ) // 前フレームの移動を継続する(減衰もあるよ)\n      .add(\n        _v3A\n          .copy(this._boneAxis)\n          .applyMatrix4(this._initialLocalMatrix)\n          .applyMatrix4(this._getParentMatrixWorld())\n          .sub(this._worldPosition)\n          .normalize()\n          .multiplyScalar(stiffness),\n      ) // 親の回転による子ボーンの移動目標\n      .add(external); // 外力による移動量\n\n    // normalize bone length\n    this._nextTail\n      .sub(this._worldPosition)\n      .normalize()\n      .multiplyScalar(this._worldBoneLength)\n      .add(this._worldPosition);\n\n    // Collisionで移動\n    this._collision(this._nextTail);\n\n    this._prevTail.copy(this._currentTail);\n    this._currentTail.copy(this._nextTail);\n\n    // Apply rotation, convert vector3 thing into actual quaternion\n    // Original UniVRM is doing world unit calculus at here but we're gonna do this on local unit\n    // since Three.js is not good at world coordination stuff\n    const initialWorldMatrixInv = _matA.getInverse(\n      _matB.copy(this._getParentMatrixWorld()).multiply(this._initialLocalMatrix),\n    );\n    const applyRotation = _quatA.setFromUnitVectors(\n      this._boneAxis,\n      _v3A\n        .copy(this._nextTail)\n        .applyMatrix4(initialWorldMatrixInv)\n        .normalize(),\n    );\n\n    this.bone.quaternion.copy(this._initialLocalRotation).multiply(applyRotation);\n\n    // We need to update its matrixWorld manually, since we tweaked the bone by our hand\n    this.bone.updateMatrix();\n    this.bone.matrixWorld.multiplyMatrices(this._getParentMatrixWorld(), this.bone.matrix);\n  }\n\n  /**\n   * Do collision math against every colliders attached to this bone.\n   *\n   * @param tail The tail you want to process\n   */\n  private _collision(tail: THREE.Vector3): void {\n    this.colliders.forEach((collider) => {\n      const colliderWorldPosition = _v3A.setFromMatrixPosition(collider.matrixWorld);\n      const colliderRadius = collider.geometry.boundingSphere.radius;\n      const r = this.radius + colliderRadius;\n\n      if (tail.distanceToSquared(colliderWorldPosition) <= r * r) {\n        // ヒット。Colliderの半径方向に押し出す\n        const normal = _v3B.subVectors(tail, colliderWorldPosition).normalize();\n        const posFromCollider = _v3C.addVectors(colliderWorldPosition, normal.multiplyScalar(r));\n\n        // normalize bone length\n        tail.copy(\n          posFromCollider\n            .sub(this._worldPosition)\n            .normalize()\n            .multiplyScalar(this._worldBoneLength)\n            .add(this._worldPosition),\n        );\n      }\n    });\n  }\n\n  /**\n   * Returns the world matrix of its parent object.\n   */\n  private _getParentMatrixWorld(): THREE.Matrix4 {\n    return this.bone.parent ? this.bone.parent.matrixWorld : IDENTITY_MATRIX4;\n  }\n}\n","import * as THREE from 'three';\nimport { GLTFNode, VRMSchema } from '../types';\nimport { GIZMO_RENDER_ORDER, VRMSpringBone } from './VRMSpringBone';\nimport { VRMSpringBoneColliderGroup, VRMSpringBoneColliderMesh } from './VRMSpringBoneColliderGroup';\nimport { VRMSpringBoneGroup, VRMSpringBoneManager } from './VRMSpringBoneManager';\n\n/**\n * An importer that imports a [[VRMSpringBoneManager]] from a VRM extension of a GLTF.\n */\nexport class VRMSpringBoneImporter {\n  /**\n   * Import a [[VRMLookAtHead]] from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  public async import(gltf: THREE.GLTF): Promise<VRMSpringBoneManager | null> {\n    if (\n      !gltf.parser.json.extensions ||\n      !gltf.parser.json.extensions.VRM ||\n      !gltf.parser.json.extensions.VRM.secondaryAnimation\n    ) {\n      return null;\n    }\n\n    // 衝突判定球体メッシュ。\n    const colliderGroups = await this._getColliderMeshGroups(gltf);\n    colliderGroups.forEach((group) => gltf.scene.add(...group.colliders));\n\n    // 同じ属性（stiffinessやdragForceが同じ）のボーンはboneGroupにまとめられている。\n    // 一列だけではないことに注意。\n    const springBoneGroupList = await this._getSpringBoneGroupList(gltf, colliderGroups);\n\n    return new VRMSpringBoneManager(springBoneGroupList);\n  }\n\n  protected get _isColiderMeshVisible(): boolean {\n    return false;\n  }\n\n  protected _createSpringBone(\n    gltf: THREE.GLTF,\n    bone: THREE.Object3D,\n    hitRadius: number,\n    stiffiness: number,\n    gravityDir: THREE.Vector3,\n    gravityPower: number,\n    dragForce: number,\n    colliders: THREE.Mesh[] = [],\n  ): VRMSpringBone {\n    return new VRMSpringBone(bone, hitRadius, stiffiness, gravityDir, gravityPower, dragForce, colliders);\n  }\n\n  private async _getSpringBoneGroupList(\n    gltf: THREE.GLTF,\n    colliderGroups: VRMSpringBoneColliderGroup[],\n  ): Promise<VRMSpringBoneGroup[]> {\n    const springBoneGroups: VRMSchema.SecondaryAnimationSpring[] = gltf.parser.json.extensions!.VRM!.secondaryAnimation!\n      .boneGroups;\n\n    const springBoneGroupList: VRMSpringBoneGroup[] = [];\n\n    springBoneGroups.forEach((vrmBoneGroup) => {\n      if (\n        vrmBoneGroup.stiffiness === undefined ||\n        vrmBoneGroup.gravityDir === undefined ||\n        vrmBoneGroup.gravityDir.x === undefined ||\n        vrmBoneGroup.gravityDir.y === undefined ||\n        vrmBoneGroup.gravityDir.z === undefined ||\n        vrmBoneGroup.gravityPower === undefined ||\n        vrmBoneGroup.dragForce === undefined ||\n        vrmBoneGroup.hitRadius === undefined ||\n        vrmBoneGroup.colliderGroups === undefined ||\n        vrmBoneGroup.bones === undefined\n      ) {\n        return;\n      }\n\n      const stiffiness = vrmBoneGroup.stiffiness;\n      const gravityDir = new THREE.Vector3(\n        vrmBoneGroup.gravityDir.x,\n        vrmBoneGroup.gravityDir.y,\n        vrmBoneGroup.gravityDir.z,\n      );\n      const gravityPower = vrmBoneGroup.gravityPower;\n      const dragForce = vrmBoneGroup.dragForce;\n      const hitRadius = vrmBoneGroup.hitRadius;\n\n      const colliders: VRMSpringBoneColliderMesh[] = [];\n      vrmBoneGroup.colliderGroups.forEach((colliderIndex) => {\n        colliders.push(...colliderGroups[colliderIndex].colliders);\n      });\n\n      const springBoneGroup: VRMSpringBoneGroup = [];\n      vrmBoneGroup.bones.forEach(async (nodeIndex) => {\n        // VRMの情報から「揺れモノ」ボーンのルートが取れる\n        const springRootBone: GLTFNode = await gltf.parser.getDependency('node', nodeIndex);\n\n        // it's weird but there might be cases we can't find the root bone\n        if (!springRootBone) {\n          return;\n        }\n\n        springRootBone.traverse((bone) => {\n          const springBone = this._createSpringBone(\n            gltf,\n            bone,\n            hitRadius,\n            stiffiness,\n            gravityDir,\n            gravityPower,\n            dragForce,\n            colliders,\n          );\n          springBoneGroup.push(springBone);\n        });\n      });\n\n      springBoneGroupList.push(springBoneGroup);\n    });\n\n    return springBoneGroupList;\n  }\n\n  /**\n   * Create an array of [[VRMSpringBoneColliderGroup]].\n   */\n  private async _getColliderMeshGroups(gltf: THREE.GLTF): Promise<VRMSpringBoneColliderGroup[]> {\n    const vrmExt: VRMSchema.VRM | undefined = gltf.parser.json.extensions && gltf.parser.json.extensions.VRM;\n    if (vrmExt === undefined) {\n      return [];\n    }\n    const secondaryAnimation = vrmExt.secondaryAnimation;\n    if (secondaryAnimation === undefined) {\n      return [];\n    }\n    const vrmColliderGroups = secondaryAnimation.colliderGroups;\n    if (vrmColliderGroups === undefined) {\n      return [];\n    }\n\n    const colliderGroups: VRMSpringBoneColliderGroup[] = [];\n    vrmColliderGroups.forEach(async (colliderGroup) => {\n      if (colliderGroup.node === undefined || colliderGroup.colliders === undefined) {\n        return;\n      }\n\n      const bone = await gltf.parser.getDependency('node', colliderGroup.node);\n      const colliders: VRMSpringBoneColliderMesh[] = [];\n      colliderGroup.colliders.forEach((collider) => {\n        if (\n          collider.offset === undefined ||\n          collider.offset.x === undefined ||\n          collider.offset.y === undefined ||\n          collider.offset.z === undefined ||\n          collider.radius === undefined\n        ) {\n          return;\n        }\n\n        const offsetMatrix = new THREE.Matrix4().makeTranslation(\n          collider.offset.x,\n          collider.offset.y,\n          -collider.offset.z, // this is pretty weird. See: https://github.com/dwango/UniVRM/issues/65\n        );\n        const visible = this._isColiderMeshVisible;\n        const colliderMesh = new THREE.Mesh(\n          new THREE.SphereBufferGeometry(collider.radius, 8, 4),\n          new THREE.MeshBasicMaterial({\n            color: 0xff00ff,\n            visible,\n            wireframe: true,\n            transparent: true,\n            depthTest: false,\n          }),\n        );\n        (colliderMesh.material as any).renderOrder = GIZMO_RENDER_ORDER;\n\n        // the name have to be this in order to exclude colliders from bounding box\n        // (See Viewer.ts, search for child.name === 'vrmColliderSphere')\n        colliderMesh.name = 'vrmColliderSphere';\n\n        // We will use the radius of the sphere for collision vs bones.\n        // `boundingSphere` must be created to compute the radius.\n        colliderMesh.geometry.computeBoundingSphere();\n\n        // The colliderMesh must sync with the bone.\n        // Attaching bone's matrix to the colliderMesh at every update.\n        // (colliderMesh will move automecicallty)\n        colliderMesh.updateMatrixWorld = (): void => {\n          colliderMesh.matrixWorld.copy(bone.matrixWorld).multiply(offsetMatrix);\n        };\n        colliders.push(colliderMesh);\n      });\n\n      const colliderMeshGroup = {\n        node: colliderGroup.node,\n        colliders,\n      };\n      colliderGroups.push(colliderMeshGroup);\n    });\n\n    return colliderGroups;\n  }\n}\n","import { VRMSpringBone } from './VRMSpringBone';\n\n/**\n * Represents a single spring bone group of a VRM.\n */\nexport type VRMSpringBoneGroup = VRMSpringBone[];\n\n/**\n * A class manages every spring bones on a VRM.\n */\nexport class VRMSpringBoneManager {\n  public readonly springBoneGroupList: VRMSpringBoneGroup[] = [];\n\n  /**\n   * Create a new [[VRMSpringBoneManager]]\n   *\n   * @param springBoneGroupList An array of [[VRMSpringBoneGroup]]\n   */\n  public constructor(springBoneGroupList: VRMSpringBoneGroup[]) {\n    this.springBoneGroupList = springBoneGroupList;\n  }\n\n  /**\n   * Update every spring bone attached to this manager.\n   *\n   * @param delta deltaTime\n   */\n  public lateUpdate(delta: number): void {\n    this.springBoneGroupList.forEach((springBoneGroup) => {\n      springBoneGroup.forEach((springBone) => {\n        springBone.update(delta);\n      });\n    });\n  }\n\n  /**\n   * Reset every spring bone attached to this manager.\n   */\n  public reset(): void {\n    this.springBoneGroupList.forEach((springBoneGroup) => {\n      springBoneGroup.forEach((springBone) => {\n        springBone.reset();\n      });\n    });\n  }\n}\n","export * from './VRMSpringBone';\nexport * from './VRMSpringBoneColliderGroup';\nexport * from './VRMSpringBoneImporter';\nexport * from './VRMSpringBoneManager';\n","// Typedoc does not support export declarations yet\n// then we have to use `namespace` instead of export declarations for now.\n// See: https://github.com/TypeStrong/typedoc/pull/801\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport namespace VRMSchema {\n  /**\n   * VRM extension is for 3d humanoid avatars (and models) in VR applications.\n   */\n  export interface VRM {\n    blendShapeMaster?: BlendShape;\n    /**\n     * Version of exporter that vrm created. UniVRM-0.53.0\n     */\n    exporterVersion?: string;\n    firstPerson?: FirstPerson;\n    humanoid?: Humanoid;\n    materialProperties?: Material[];\n    meta?: Meta;\n    secondaryAnimation?: SecondaryAnimation;\n    /**\n     * Version of VRM specification. 0.0\n     */\n    specVersion?: string;\n  }\n\n  /**\n   * BlendShapeAvatar of UniVRM\n   */\n  export interface BlendShape {\n    blendShapeGroups?: BlendShapeGroup[];\n  }\n\n  export interface BlendShapeGroup {\n    /**\n     * Low level blendshape references.\n     */\n    binds?: BlendShapeBind[];\n    /**\n     * 0 or 1. Do not allow an intermediate value. Value should rounded\n     */\n    isBinary?: boolean;\n    /**\n     * Material animation references.\n     */\n    materialValues?: BlendShapeMaterialbind[];\n    /**\n     * Expression name\n     */\n    name?: string;\n    /**\n     * Predefined Expression name\n     */\n    presetName?: BlendShapePresetName;\n  }\n\n  export interface BlendShapeBind {\n    index?: number;\n    mesh?: number;\n    /**\n     * SkinnedMeshRenderer.SetBlendShapeWeight\n     */\n    weight?: number;\n  }\n\n  export interface BlendShapeMaterialbind {\n    materialName?: string;\n    propertyName?: string;\n    targetValue?: number[];\n  }\n\n  /**\n   * Predefined Expression name\n   */\n  export enum BlendShapePresetName {\n    A = 'a',\n    Angry = 'angry',\n    Blink = 'blink',\n    BlinkL = 'blink_l',\n    BlinkR = 'blink_r',\n    E = 'e',\n    Fun = 'fun',\n    I = 'i',\n    Joy = 'joy',\n    Lookdown = 'lookdown',\n    Lookleft = 'lookleft',\n    Lookright = 'lookright',\n    Lookup = 'lookup',\n    Neutral = 'neutral',\n    O = 'o',\n    Sorrow = 'sorrow',\n    U = 'u',\n    Unknown = 'unknown',\n  }\n\n  export interface FirstPerson {\n    /**\n     * The bone whose rendering should be turned off in first-person view. Usually Head is\n     * specified.\n     */\n    firstPersonBone?: number;\n    /**\n     * The target position of the VR headset in first-person view. It is assumed that an offset\n     * from the head bone to the VR headset is added.\n     */\n    firstPersonBoneOffset?: Vector3;\n    lookAtHorizontalInner?: FirstPersonDegreeMap;\n    lookAtHorizontalOuter?: FirstPersonDegreeMap;\n    /**\n     * Eye controller mode.\n     */\n    lookAtTypeName?: FirstPersonLookAtTypeName;\n    lookAtVerticalDown?: FirstPersonDegreeMap;\n    lookAtVerticalUp?: FirstPersonDegreeMap;\n    /**\n     * Switch display / undisplay for each mesh in first-person view or the others.\n     */\n    meshAnnotations?: FirstPersonMeshannotation[];\n  }\n\n  /**\n   * Eye controller setting.\n   */\n  export interface FirstPersonDegreeMap {\n    /**\n     * None linear mapping params. time, value, inTangent, outTangent\n     */\n    curve?: number[];\n    /**\n     * Look at input clamp range degree.\n     */\n    xRange?: number;\n    /**\n     * Look at map range degree from xRange.\n     */\n    yRange?: number;\n  }\n\n  /**\n   * Eye controller mode.\n   */\n  export enum FirstPersonLookAtTypeName {\n    BlendShape = 'BlendShape',\n    Bone = 'Bone',\n  }\n\n  export interface FirstPersonMeshannotation {\n    firstPersonFlag?: string;\n    mesh?: number;\n  }\n\n  export interface Humanoid {\n    /**\n     * Unity's HumanDescription.armStretch\n     */\n    armStretch?: number;\n    /**\n     * Unity's HumanDescription.feetSpacing\n     */\n    feetSpacing?: number;\n    /**\n     * Unity's HumanDescription.hasTranslationDoF\n     */\n    hasTranslationDoF?: boolean;\n    humanBones?: HumanoidBone[];\n    /**\n     * Unity's HumanDescription.legStretch\n     */\n    legStretch?: number;\n    /**\n     * Unity's HumanDescription.lowerArmTwist\n     */\n    lowerArmTwist?: number;\n    /**\n     * Unity's HumanDescription.lowerLegTwist\n     */\n    lowerLegTwist?: number;\n    /**\n     * Unity's HumanDescription.upperArmTwist\n     */\n    upperArmTwist?: number;\n    /**\n     * Unity's HumanDescription.upperLegTwist\n     */\n    upperLegTwist?: number;\n  }\n\n  export interface HumanoidBone {\n    /**\n     * Unity's HumanLimit.axisLength\n     */\n    axisLength?: number;\n    /**\n     * Human bone name.\n     */\n    bone?: HumanoidBoneName;\n    /**\n     * Unity's HumanLimit.center\n     */\n    center?: Vector3;\n    /**\n     * Unity's HumanLimit.max\n     */\n    max?: Vector3;\n    /**\n     * Unity's HumanLimit.min\n     */\n    min?: Vector3;\n    /**\n     * Reference node index\n     */\n    node?: number;\n    /**\n     * Unity's HumanLimit.useDefaultValues\n     */\n    useDefaultValues?: boolean;\n  }\n\n  /**\n   * Human bone name.\n   */\n  export enum HumanoidBoneName {\n    Chest = 'chest',\n    Head = 'head',\n    Hips = 'hips',\n    Jaw = 'jaw',\n    LeftEye = 'leftEye',\n    LeftFoot = 'leftFoot',\n    LeftHand = 'leftHand',\n    LeftIndexDistal = 'leftIndexDistal',\n    LeftIndexIntermediate = 'leftIndexIntermediate',\n    LeftIndexProximal = 'leftIndexProximal',\n    LeftLittleDistal = 'leftLittleDistal',\n    LeftLittleIntermediate = 'leftLittleIntermediate',\n    LeftLittleProximal = 'leftLittleProximal',\n    LeftLowerArm = 'leftLowerArm',\n    LeftLowerLeg = 'leftLowerLeg',\n    LeftMiddleDistal = 'leftMiddleDistal',\n    LeftMiddleIntermediate = 'leftMiddleIntermediate',\n    LeftMiddleProximal = 'leftMiddleProximal',\n    LeftRingDistal = 'leftRingDistal',\n    LeftRingIntermediate = 'leftRingIntermediate',\n    LeftRingProximal = 'leftRingProximal',\n    LeftShoulder = 'leftShoulder',\n    LeftThumbDistal = 'leftThumbDistal',\n    LeftThumbIntermediate = 'leftThumbIntermediate',\n    LeftThumbProximal = 'leftThumbProximal',\n    LeftToes = 'leftToes',\n    LeftUpperArm = 'leftUpperArm',\n    LeftUpperLeg = 'leftUpperLeg',\n    Neck = 'neck',\n    RightEye = 'rightEye',\n    RightFoot = 'rightFoot',\n    RightHand = 'rightHand',\n    RightIndexDistal = 'rightIndexDistal',\n    RightIndexIntermediate = 'rightIndexIntermediate',\n    RightIndexProximal = 'rightIndexProximal',\n    RightLittleDistal = 'rightLittleDistal',\n    RightLittleIntermediate = 'rightLittleIntermediate',\n    RightLittleProximal = 'rightLittleProximal',\n    RightLowerArm = 'rightLowerArm',\n    RightLowerLeg = 'rightLowerLeg',\n    RightMiddleDistal = 'rightMiddleDistal',\n    RightMiddleIntermediate = 'rightMiddleIntermediate',\n    RightMiddleProximal = 'rightMiddleProximal',\n    RightRingDistal = 'rightRingDistal',\n    RightRingIntermediate = 'rightRingIntermediate',\n    RightRingProximal = 'rightRingProximal',\n    RightShoulder = 'rightShoulder',\n    RightThumbDistal = 'rightThumbDistal',\n    RightThumbIntermediate = 'rightThumbIntermediate',\n    RightThumbProximal = 'rightThumbProximal',\n    RightToes = 'rightToes',\n    RightUpperArm = 'rightUpperArm',\n    RightUpperLeg = 'rightUpperLeg',\n    Spine = 'spine',\n    UpperChest = 'upperChest',\n  }\n\n  export interface Material {\n    floatProperties?: { [key: string]: any };\n    keywordMap?: { [key: string]: any };\n    name?: string;\n    renderQueue?: number;\n    shader?: string;\n    tagMap?: { [key: string]: any };\n    textureProperties?: { [key: string]: any };\n    vectorProperties?: { [key: string]: any };\n  }\n\n  export interface Meta {\n    /**\n     * A person who can perform with this avatar\n     */\n    allowedUserName?: MetaAllowedUserName;\n    /**\n     * Author of VRM model\n     */\n    author?: string;\n    /**\n     * For commercial use\n     */\n    commercialUssageName?: MetaUssageName;\n    /**\n     * Contact Information of VRM model author\n     */\n    contactInformation?: string;\n    /**\n     * License type\n     */\n    licenseName?: MetaLicenseName;\n    /**\n     * If “Other” is selected, put the URL link of the license document here.\n     */\n    otherLicenseUrl?: string;\n    /**\n     * If there are any conditions not mentioned above, put the URL link of the license document\n     * here.\n     */\n    otherPermissionUrl?: string;\n    /**\n     * Reference of VRM model\n     */\n    reference?: string;\n    /**\n     * Permission to perform sexual acts with this avatar\n     */\n    sexualUssageName?: MetaUssageName;\n    /**\n     * Thumbnail of VRM model\n     */\n    texture?: number;\n    /**\n     * Title of VRM model\n     */\n    title?: string;\n    /**\n     * Version of VRM model\n     */\n    version?: string;\n    /**\n     * Permission to perform violent acts with this avatar\n     */\n    violentUssageName?: MetaUssageName;\n  }\n\n  /**\n   * A person who can perform with this avatar\n   */\n  export enum MetaAllowedUserName {\n    Everyone = 'Everyone',\n    ExplicitlyLicensedPerson = 'ExplicitlyLicensedPerson',\n    OnlyAuthor = 'OnlyAuthor',\n  }\n\n  /**\n   * For commercial use\n   *\n   * Permission to perform sexual acts with this avatar\n   *\n   * Permission to perform violent acts with this avatar\n   */\n  export enum MetaUssageName {\n    Allow = 'Allow',\n    Disallow = 'Disallow',\n  }\n\n  /**\n   * License type\n   */\n  export enum MetaLicenseName {\n    Cc0 = 'CC0',\n    CcBy = 'CC_BY',\n    CcByNc = 'CC_BY_NC',\n    CcByNcNd = 'CC_BY_NC_ND',\n    CcByNcSa = 'CC_BY_NC_SA',\n    CcByNd = 'CC_BY_ND',\n    CcBySa = 'CC_BY_SA',\n    Other = 'Other',\n    RedistributionProhibited = 'Redistribution_Prohibited',\n  }\n\n  /**\n   * The setting of automatic animation of string-like objects such as tails and hairs.\n   */\n  export interface SecondaryAnimation {\n    boneGroups?: SecondaryAnimationSpring[];\n    colliderGroups?: SecondaryAnimationCollidergroup[];\n  }\n\n  export interface SecondaryAnimationSpring {\n    /**\n     * Specify the node index of the root bone of the swaying object.\n     */\n    bones?: number[];\n    /**\n     * The reference point of a swaying object can be set at any location except the origin.\n     * When implementing UI moving with warp, the parent node to move with warp can be specified\n     * if you don't want to make the object swaying with warp movement.\n     */\n    center?: number;\n    /**\n     * Specify the index of the collider group for collisions with swaying objects.\n     */\n    colliderGroups?: number[];\n    /**\n     * Annotation comment\n     */\n    comment?: string;\n    /**\n     * The resistance (deceleration) of automatic animation.\n     */\n    dragForce?: number;\n    /**\n     * The direction of gravity. Set (0, -1, 0) for simulating the gravity. Set (1, 0, 0) for\n     * simulating the wind.\n     */\n    gravityDir?: Vector3;\n    /**\n     * The strength of gravity.\n     */\n    gravityPower?: number;\n    /**\n     * The radius of the sphere used for the collision detection with colliders.\n     */\n    hitRadius?: number;\n    /**\n     * The resilience of the swaying object (the power of returning to the initial pose).\n     */\n    stiffiness?: number;\n  }\n\n  export interface SecondaryAnimationCollidergroup {\n    colliders?: SecondaryAnimationCollider[];\n    /**\n     * The node of the collider group for setting up collision detections.\n     */\n    node?: number;\n  }\n\n  export interface SecondaryAnimationCollider {\n    /**\n     * The local coordinate from the node of the collider group.\n     */\n    offset?: Vector3;\n    /**\n     * The radius of the collider.\n     */\n    radius?: number;\n  }\n\n  export interface Vector3 {\n    x?: number;\n    y?: number;\n    z?: number;\n  }\n}\n","// Typedoc does not support export declarations yet\n// then we have to use `namespace` instead of export declarations for now.\n// See: https://github.com/TypeStrong/typedoc/pull/801\n\n// import * as GLTFSchema from './GLTFSchema';\n// import * as VRMSchema from './VRMSchema';\n\n// export { GLTFSchema, VRMSchema };\n\nexport * from './GLTFSchema';\nexport * from './VRMSchema';\n\nexport * from './types';\n","import * as THREE from 'three';\n\nfunction disposeMaterial(material: any): void {\n  Object.keys(material).forEach((propertyName) => {\n    if (!!material[propertyName] && typeof material[propertyName].dispose === 'function') {\n      material[propertyName].dispose();\n    }\n  });\n\n  material.dispose();\n  material = undefined;\n}\n\nfunction dispose(object3D: any): void {\n  if (object3D.geometry) {\n    object3D.geometry.dispose();\n    object3D.geometry = undefined;\n  }\n\n  if (!!object3D.material && Array.isArray(object3D.material)) {\n    object3D.material.forEach((material: THREE.Material) => disposeMaterial(material));\n  } else if (object3D.material) {\n    disposeMaterial(object3D.material);\n  }\n}\n\nexport function deepDispose(object3D: THREE.Object3D): void {\n  object3D.traverse(dispose);\n}\n","import * as THREE from 'three';\n\n/**\n * Clamp an input number within [ `0.0` - `1.0` ].\n *\n * @param value The input value\n */\nexport function saturate(value: number): number {\n  return Math.max(Math.min(value, 1.0), 0.0);\n}\n\n/**\n * Map the range of an input value from [ `min` - `max` ] to [ `0.0` - `1.0` ].\n * If input value is less than `min` , it returns `0.0`.\n * If input value is greater than `max` , it returns `1.0`.\n *\n * See also: https://threejs.org/docs/#api/en/math/Math.smoothstep\n *\n * @param x The value that will be mapped into the specified range\n * @param min Minimum value of the range\n * @param max Maximum value of the range\n */\nexport function linstep(x: number, min: number, max: number): number {\n  if (x <= min) return 0;\n  if (x >= max) return 1;\n\n  return (x - min) / (max - min);\n}\n\nconst _position = new THREE.Vector3();\nconst _scale = new THREE.Vector3();\nconst _rotation = new THREE.Quaternion();\n\n/**\n * Extract world position of an object from its world space matrix, in cheaper way.\n *\n * @param object The object\n * @param out Target vector\n */\nexport function getWorldPositionLite(object: THREE.Object3D, out: THREE.Vector3): THREE.Vector3 {\n  object.matrixWorld.decompose(out, _rotation, _scale);\n  return out;\n}\n\n/**\n * Extract world scale of an object from its world space matrix, in cheaper way.\n *\n * @param object The object\n * @param out Target vector\n */\nexport function getWorldScaleLite(object: THREE.Object3D, out: THREE.Vector3): THREE.Vector3 {\n  object.matrixWorld.decompose(_position, _rotation, out);\n  return out;\n}\n\n/**\n * Extract world rotation of an object from its world space matrix, in cheaper way.\n *\n * @param object The object\n * @param out Target vector\n */\nexport function getWorldQuaternionLite(object: THREE.Object3D, out: THREE.Quaternion): THREE.Quaternion {\n  object.matrixWorld.decompose(_position, out, _scale);\n  return out;\n}\n","export function renameMaterialProperty(name: string): string {\n  if (name[0] !== '_') {\n    console.warn(`renameMaterialProperty: Given property name \"${name}\" might be invalid`);\n    return name;\n  }\n  name = name.substring(1);\n\n  if (!/[A-Z]/.test(name[0])) {\n    console.warn(`renameMaterialProperty: Given property name \"${name}\" might be invalid`);\n    return name;\n  }\n  return name[0].toLowerCase() + name.substring(1);\n}\n","module.exports = THREE;"],"sourceRoot":""}
\ No newline at end of file
diff --git a/webxr-polyfill.module.js b/webxr-polyfill.module.js
new file mode 100644
index 0000000..017698d
--- /dev/null
+++ b/webxr-polyfill.module.js
@@ -0,0 +1,6139 @@
+/**
+ * @license
+ * webxr-polyfill
+ * Copyright (c) 2017 Google
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @license
+ * cardboard-vr-display
+ * Copyright (c) 2015-2017 Google
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @license
+ * webvr-polyfill-dpdb 
+ * Copyright (c) 2017 Google
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @license
+ * wglu-preserve-state
+ * Copyright (c) 2016, Brandon Jones.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/**
+ * @license
+ * nosleep.js
+ * Copyright (c) 2017, Rich Tibbett
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+if (!/(Helio)/g.test(navigator.userAgent)) {
+
+const _global = typeof global !== 'undefined' ? global :
+                typeof self !== 'undefined' ? self :
+                typeof window !== 'undefined' ? window : {};
+
+const PRIVATE = Symbol('@@webxr-polyfill/EventTarget');
+class EventTarget {
+  constructor() {
+    this[PRIVATE] = {
+      listeners: new Map(),
+    };
+  }
+  addEventListener(type, listener) {
+    if (typeof type !== 'string') { throw new Error('`type` must be a string'); }
+    if (typeof listener !== 'function') { throw new Error('`listener` must be a function'); }
+    const typedListeners = this[PRIVATE].listeners.get(type) || [];
+    typedListeners.push(listener);
+    this[PRIVATE].listeners.set(type, typedListeners);
+  }
+  removeEventListener(type, listener) {
+    if (typeof type !== 'string') { throw new Error('`type` must be a string'); }
+    if (typeof listener !== 'function') { throw new Error('`listener` must be a function'); }
+    const typedListeners = this[PRIVATE].listeners.get(type) || [];
+    for (let i = typedListeners.length; i >= 0; i--) {
+      if (typedListeners[i] === listener) {
+        typedListeners.pop();
+      }
+    }
+  }
+  dispatchEvent(type, event) {
+    const typedListeners = this[PRIVATE].listeners.get(type) || [];
+    const queue = [];
+    for (let i = 0; i < typedListeners.length; i++) {
+      queue[i] = typedListeners[i];
+    }
+    for (let listener of queue) {
+      listener(event);
+    }
+    if (typeof this[`on${type}`] === 'function') {
+      this[`on${type}`](event);
+    }
+  }
+}
+
+const PRIVATE$1 = Symbol('@@webxr-polyfill/XR');
+const XRSessionModes = ['inline', 'immersive-vr', 'immersive-ar'];
+const POLYFILL_REQUEST_SESSION_ERROR =
+`Polyfill Error: Must call navigator.xr.supportsSession() with any XRSessionMode
+or navigator.xr.requestSession('inline') prior to requesting an immersive
+session. This is a limitation specific to the WebXR Polyfill and does not apply
+to native implementations of the API.`;
+class XR$1 extends EventTarget {
+  constructor(devicePromise) {
+    super();
+    this[PRIVATE$1] = {
+      device: null,
+      devicePromise,
+      immersiveSession: null,
+      inlineSessions: new Set(),
+    };
+    devicePromise.then((device) => { this[PRIVATE$1].device = device; });
+  }
+  async supportsSession(mode) {
+    if (!this[PRIVATE$1].device) {
+      await this[PRIVATE$1].devicePromise;
+    }
+    if (mode != 'inline') {
+      if (!this[PRIVATE$1].device.supportsSession(mode)) {
+        return Promise.reject(null);
+      }
+    }
+    return Promise.resolve(null);
+  }
+  async requestSession(mode) {
+    if (!this[PRIVATE$1].device) {
+      if (mode != 'inline') {
+        throw new Error(POLYFILL_REQUEST_SESSION_ERROR);
+      } else {
+        await this[PRIVATE$1].devicePromise;
+      }
+    }
+    const sessionId = await this[PRIVATE$1].device.requestSession(mode);
+    const session = new XRSession(this[PRIVATE$1].device, mode, sessionId);
+    if (mode == 'inline') {
+      this[PRIVATE$1].inlineSessions.add(session);
+    } else {
+      this[PRIVATE$1].immersiveSession = session;
+    }
+    const onSessionEnd = () => {
+      if (mode == 'inline') {
+        this[PRIVATE$1].inlineSessions.delete(session);
+      } else {
+        this[PRIVATE$1].immersiveSession = null;
+      }
+      session.removeEventListener('end', onSessionEnd);
+    };
+    session.addEventListener('end', onSessionEnd);
+    return session;
+  }
+}
+
+let now;
+if ('performance' in _global === false) {
+  let startTime = Date.now();
+  now = () => Date.now() - startTime;
+} else {
+  now = () => performance.now();
+}
+var now$1 = now;
+
+const PRIVATE$2 = Symbol('@@webxr-polyfill/XRPose');
+class XRPose$1 {
+  constructor(transform, emulatedPosition) {
+    this[PRIVATE$2] = {
+      transform,
+      emulatedPosition,
+    };
+  }
+  get transform() { return this[PRIVATE$2].transform; }
+  get emulatedPosition() { return this[PRIVATE$2].emulatedPosition; }
+  _setTransform(transform) { this[PRIVATE$2].transform = transform; }
+}
+
+const EPSILON = 0.000001;
+let ARRAY_TYPE = (typeof Float32Array !== 'undefined') ? Float32Array : Array;
+
+
+const degree = Math.PI / 180;
+
+function create() {
+  let out = new ARRAY_TYPE(16);
+  if(ARRAY_TYPE != Float32Array) {
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[11] = 0;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+  }
+  out[0] = 1;
+  out[5] = 1;
+  out[10] = 1;
+  out[15] = 1;
+  return out;
+}
+
+function copy(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  out[4] = a[4];
+  out[5] = a[5];
+  out[6] = a[6];
+  out[7] = a[7];
+  out[8] = a[8];
+  out[9] = a[9];
+  out[10] = a[10];
+  out[11] = a[11];
+  out[12] = a[12];
+  out[13] = a[13];
+  out[14] = a[14];
+  out[15] = a[15];
+  return out;
+}
+
+
+function identity(out) {
+  out[0] = 1;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = 1;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = 0;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 1;
+  return out;
+}
+
+function invert(out, a) {
+  let a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  let a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  let a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  let a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  let b00 = a00 * a11 - a01 * a10;
+  let b01 = a00 * a12 - a02 * a10;
+  let b02 = a00 * a13 - a03 * a10;
+  let b03 = a01 * a12 - a02 * a11;
+  let b04 = a01 * a13 - a03 * a11;
+  let b05 = a02 * a13 - a03 * a12;
+  let b06 = a20 * a31 - a21 * a30;
+  let b07 = a20 * a32 - a22 * a30;
+  let b08 = a20 * a33 - a23 * a30;
+  let b09 = a21 * a32 - a22 * a31;
+  let b10 = a21 * a33 - a23 * a31;
+  let b11 = a22 * a33 - a23 * a32;
+  let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  if (!det) {
+    return null;
+  }
+  det = 1.0 / det;
+  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+  return out;
+}
+
+
+function multiply(out, a, b) {
+  let a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
+  let a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+  let a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
+  let a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+  let b0  = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+  out[0] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+  out[1] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+  out[2] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+  out[3] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+  b0 = b[4]; b1 = b[5]; b2 = b[6]; b3 = b[7];
+  out[4] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+  out[5] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+  out[6] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+  out[7] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+  b0 = b[8]; b1 = b[9]; b2 = b[10]; b3 = b[11];
+  out[8] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+  out[9] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+  out[10] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+  out[11] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+  b0 = b[12]; b1 = b[13]; b2 = b[14]; b3 = b[15];
+  out[12] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+  out[13] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+  out[14] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+  out[15] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+function fromRotationTranslation(out, q, v) {
+  let x = q[0], y = q[1], z = q[2], w = q[3];
+  let x2 = x + x;
+  let y2 = y + y;
+  let z2 = z + z;
+  let xx = x * x2;
+  let xy = x * y2;
+  let xz = x * z2;
+  let yy = y * y2;
+  let yz = y * z2;
+  let zz = z * z2;
+  let wx = w * x2;
+  let wy = w * y2;
+  let wz = w * z2;
+  out[0] = 1 - (yy + zz);
+  out[1] = xy + wz;
+  out[2] = xz - wy;
+  out[3] = 0;
+  out[4] = xy - wz;
+  out[5] = 1 - (xx + zz);
+  out[6] = yz + wx;
+  out[7] = 0;
+  out[8] = xz + wy;
+  out[9] = yz - wx;
+  out[10] = 1 - (xx + yy);
+  out[11] = 0;
+  out[12] = v[0];
+  out[13] = v[1];
+  out[14] = v[2];
+  out[15] = 1;
+  return out;
+}
+
+function getTranslation(out, mat) {
+  out[0] = mat[12];
+  out[1] = mat[13];
+  out[2] = mat[14];
+  return out;
+}
+
+function getRotation(out, mat) {
+  let trace = mat[0] + mat[5] + mat[10];
+  let S = 0;
+  if (trace > 0) {
+    S = Math.sqrt(trace + 1.0) * 2;
+    out[3] = 0.25 * S;
+    out[0] = (mat[6] - mat[9]) / S;
+    out[1] = (mat[8] - mat[2]) / S;
+    out[2] = (mat[1] - mat[4]) / S;
+  } else if ((mat[0] > mat[5]) && (mat[0] > mat[10])) {
+    S = Math.sqrt(1.0 + mat[0] - mat[5] - mat[10]) * 2;
+    out[3] = (mat[6] - mat[9]) / S;
+    out[0] = 0.25 * S;
+    out[1] = (mat[1] + mat[4]) / S;
+    out[2] = (mat[8] + mat[2]) / S;
+  } else if (mat[5] > mat[10]) {
+    S = Math.sqrt(1.0 + mat[5] - mat[0] - mat[10]) * 2;
+    out[3] = (mat[8] - mat[2]) / S;
+    out[0] = (mat[1] + mat[4]) / S;
+    out[1] = 0.25 * S;
+    out[2] = (mat[6] + mat[9]) / S;
+  } else {
+    S = Math.sqrt(1.0 + mat[10] - mat[0] - mat[5]) * 2;
+    out[3] = (mat[1] - mat[4]) / S;
+    out[0] = (mat[8] + mat[2]) / S;
+    out[1] = (mat[6] + mat[9]) / S;
+    out[2] = 0.25 * S;
+  }
+  return out;
+}
+
+
+
+
+function perspective(out, fovy, aspect, near, far) {
+  let f = 1.0 / Math.tan(fovy / 2), nf;
+  out[0] = f / aspect;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = f;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[11] = -1;
+  out[12] = 0;
+  out[13] = 0;
+  out[15] = 0;
+  if (far != null && far !== Infinity) {
+    nf = 1 / (near - far);
+    out[10] = (far + near) * nf;
+    out[14] = (2 * far * near) * nf;
+  } else {
+    out[10] = -1;
+    out[14] = -2 * near;
+  }
+  return out;
+}
+
+function create$1() {
+  let out = new ARRAY_TYPE(3);
+  if(ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  return out;
+}
+function clone$1(a) {
+  var out = new ARRAY_TYPE(3);
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  return out;
+}
+function length(a) {
+  let x = a[0];
+  let y = a[1];
+  let z = a[2];
+  return Math.sqrt(x*x + y*y + z*z);
+}
+function fromValues$1(x, y, z) {
+  let out = new ARRAY_TYPE(3);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+function copy$1(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  return out;
+}
+
+function add$1(out, a, b) {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  out[2] = a[2] + b[2];
+  return out;
+}
+
+
+
+
+
+
+
+
+function scale$1(out, a, b) {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  out[2] = a[2] * b;
+  return out;
+}
+
+
+
+
+
+
+function normalize(out, a) {
+  let x = a[0];
+  let y = a[1];
+  let z = a[2];
+  let len = x*x + y*y + z*z;
+  if (len > 0) {
+    len = 1 / Math.sqrt(len);
+    out[0] = a[0] * len;
+    out[1] = a[1] * len;
+    out[2] = a[2] * len;
+  }
+  return out;
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross(out, a, b) {
+  let ax = a[0], ay = a[1], az = a[2];
+  let bx = b[0], by = b[1], bz = b[2];
+  out[0] = ay * bz - az * by;
+  out[1] = az * bx - ax * bz;
+  out[2] = ax * by - ay * bx;
+  return out;
+}
+
+
+
+
+
+
+function transformQuat(out, a, q) {
+    let qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+    let x = a[0], y = a[1], z = a[2];
+    let uvx = qy * z - qz * y,
+        uvy = qz * x - qx * z,
+        uvz = qx * y - qy * x;
+    let uuvx = qy * uvz - qz * uvy,
+        uuvy = qz * uvx - qx * uvz,
+        uuvz = qx * uvy - qy * uvx;
+    let w2 = qw * 2;
+    uvx *= w2;
+    uvy *= w2;
+    uvz *= w2;
+    uuvx *= 2;
+    uuvy *= 2;
+    uuvz *= 2;
+    out[0] = x + uvx + uuvx;
+    out[1] = y + uvy + uuvy;
+    out[2] = z + uvz + uuvz;
+    return out;
+}
+
+
+
+function angle(a, b) {
+  let tempA = fromValues$1(a[0], a[1], a[2]);
+  let tempB = fromValues$1(b[0], b[1], b[2]);
+  normalize(tempA, tempA);
+  normalize(tempB, tempB);
+  let cosine = dot(tempA, tempB);
+  if(cosine > 1.0) {
+    return 0;
+  }
+  else if(cosine < -1.0) {
+    return Math.PI;
+  } else {
+    return Math.acos(cosine);
+  }
+}
+
+
+
+
+
+
+
+
+const len = length;
+
+const forEach = (function() {
+  let vec = create$1();
+  return function(a, stride, offset, count, fn, arg) {
+    let i, l;
+    if(!stride) {
+      stride = 3;
+    }
+    if(!offset) {
+      offset = 0;
+    }
+    if(count) {
+      l = Math.min((count * stride) + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for(i = offset; i < l; i += stride) {
+      vec[0] = a[i]; vec[1] = a[i+1]; vec[2] = a[i+2];
+      fn(vec, vec, arg);
+      a[i] = vec[0]; a[i+1] = vec[1]; a[i+2] = vec[2];
+    }
+    return a;
+  };
+})();
+
+function create$2() {
+  let out = new ARRAY_TYPE(9);
+  if(ARRAY_TYPE != Float32Array) {
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[5] = 0;
+    out[6] = 0;
+    out[7] = 0;
+  }
+  out[0] = 1;
+  out[4] = 1;
+  out[8] = 1;
+  return out;
+}
+
+function create$3() {
+  let out = new ARRAY_TYPE(4);
+  if(ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+  }
+  return out;
+}
+function clone$3(a) {
+  let out = new ARRAY_TYPE(4);
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  return out;
+}
+function fromValues$3(x, y, z, w) {
+  let out = new ARRAY_TYPE(4);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  out[3] = w;
+  return out;
+}
+function copy$3(out, a) {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function normalize$1(out, a) {
+  let x = a[0];
+  let y = a[1];
+  let z = a[2];
+  let w = a[3];
+  let len = x*x + y*y + z*z + w*w;
+  if (len > 0) {
+    len = 1 / Math.sqrt(len);
+    out[0] = x * len;
+    out[1] = y * len;
+    out[2] = z * len;
+    out[3] = w * len;
+  }
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const forEach$1 = (function() {
+  let vec = create$3();
+  return function(a, stride, offset, count, fn, arg) {
+    let i, l;
+    if(!stride) {
+      stride = 4;
+    }
+    if(!offset) {
+      offset = 0;
+    }
+    if(count) {
+      l = Math.min((count * stride) + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for(i = offset; i < l; i += stride) {
+      vec[0] = a[i]; vec[1] = a[i+1]; vec[2] = a[i+2]; vec[3] = a[i+3];
+      fn(vec, vec, arg);
+      a[i] = vec[0]; a[i+1] = vec[1]; a[i+2] = vec[2]; a[i+3] = vec[3];
+    }
+    return a;
+  };
+})();
+
+function create$4() {
+  let out = new ARRAY_TYPE(4);
+  if(ARRAY_TYPE != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  out[3] = 1;
+  return out;
+}
+
+function setAxisAngle(out, axis, rad) {
+  rad = rad * 0.5;
+  let s = Math.sin(rad);
+  out[0] = s * axis[0];
+  out[1] = s * axis[1];
+  out[2] = s * axis[2];
+  out[3] = Math.cos(rad);
+  return out;
+}
+
+function multiply$4(out, a, b) {
+  let ax = a[0], ay = a[1], az = a[2], aw = a[3];
+  let bx = b[0], by = b[1], bz = b[2], bw = b[3];
+  out[0] = ax * bw + aw * bx + ay * bz - az * by;
+  out[1] = ay * bw + aw * by + az * bx - ax * bz;
+  out[2] = az * bw + aw * bz + ax * by - ay * bx;
+  out[3] = aw * bw - ax * bx - ay * by - az * bz;
+  return out;
+}
+
+
+
+
+function slerp(out, a, b, t) {
+  let ax = a[0], ay = a[1], az = a[2], aw = a[3];
+  let bx = b[0], by = b[1], bz = b[2], bw = b[3];
+  let omega, cosom, sinom, scale0, scale1;
+  cosom = ax * bx + ay * by + az * bz + aw * bw;
+  if ( cosom < 0.0 ) {
+    cosom = -cosom;
+    bx = - bx;
+    by = - by;
+    bz = - bz;
+    bw = - bw;
+  }
+  if ( (1.0 - cosom) > EPSILON ) {
+    omega  = Math.acos(cosom);
+    sinom  = Math.sin(omega);
+    scale0 = Math.sin((1.0 - t) * omega) / sinom;
+    scale1 = Math.sin(t * omega) / sinom;
+  } else {
+    scale0 = 1.0 - t;
+    scale1 = t;
+  }
+  out[0] = scale0 * ax + scale1 * bx;
+  out[1] = scale0 * ay + scale1 * by;
+  out[2] = scale0 * az + scale1 * bz;
+  out[3] = scale0 * aw + scale1 * bw;
+  return out;
+}
+
+function invert$2(out, a) {
+  let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
+  let dot$$1 = a0*a0 + a1*a1 + a2*a2 + a3*a3;
+  let invDot = dot$$1 ? 1.0/dot$$1 : 0;
+  out[0] = -a0*invDot;
+  out[1] = -a1*invDot;
+  out[2] = -a2*invDot;
+  out[3] = a3*invDot;
+  return out;
+}
+
+function fromMat3(out, m) {
+  let fTrace = m[0] + m[4] + m[8];
+  let fRoot;
+  if ( fTrace > 0.0 ) {
+    fRoot = Math.sqrt(fTrace + 1.0);
+    out[3] = 0.5 * fRoot;
+    fRoot = 0.5/fRoot;
+    out[0] = (m[5]-m[7])*fRoot;
+    out[1] = (m[6]-m[2])*fRoot;
+    out[2] = (m[1]-m[3])*fRoot;
+  } else {
+    let i = 0;
+    if ( m[4] > m[0] )
+      i = 1;
+    if ( m[8] > m[i*3+i] )
+      i = 2;
+    let j = (i+1)%3;
+    let k = (i+2)%3;
+    fRoot = Math.sqrt(m[i*3+i]-m[j*3+j]-m[k*3+k] + 1.0);
+    out[i] = 0.5 * fRoot;
+    fRoot = 0.5 / fRoot;
+    out[3] = (m[j*3+k] - m[k*3+j]) * fRoot;
+    out[j] = (m[j*3+i] + m[i*3+j]) * fRoot;
+    out[k] = (m[k*3+i] + m[i*3+k]) * fRoot;
+  }
+  return out;
+}
+function fromEuler(out, x, y, z) {
+    let halfToRad = 0.5 * Math.PI / 180.0;
+    x *= halfToRad;
+    y *= halfToRad;
+    z *= halfToRad;
+    let sx = Math.sin(x);
+    let cx = Math.cos(x);
+    let sy = Math.sin(y);
+    let cy = Math.cos(y);
+    let sz = Math.sin(z);
+    let cz = Math.cos(z);
+    out[0] = sx * cy * cz - cx * sy * sz;
+    out[1] = cx * sy * cz + sx * cy * sz;
+    out[2] = cx * cy * sz - sx * sy * cz;
+    out[3] = cx * cy * cz + sx * sy * sz;
+    return out;
+}
+
+const clone$4 = clone$3;
+const fromValues$4 = fromValues$3;
+const copy$4 = copy$3;
+
+
+
+
+
+
+
+
+
+
+const normalize$2 = normalize$1;
+
+
+const rotationTo = (function() {
+  let tmpvec3 = create$1();
+  let xUnitVec3 = fromValues$1(1,0,0);
+  let yUnitVec3 = fromValues$1(0,1,0);
+  return function(out, a, b) {
+    let dot$$1 = dot(a, b);
+    if (dot$$1 < -0.999999) {
+      cross(tmpvec3, xUnitVec3, a);
+      if (len(tmpvec3) < 0.000001)
+        cross(tmpvec3, yUnitVec3, a);
+      normalize(tmpvec3, tmpvec3);
+      setAxisAngle(out, tmpvec3, Math.PI);
+      return out;
+    } else if (dot$$1 > 0.999999) {
+      out[0] = 0;
+      out[1] = 0;
+      out[2] = 0;
+      out[3] = 1;
+      return out;
+    } else {
+      cross(tmpvec3, a, b);
+      out[0] = tmpvec3[0];
+      out[1] = tmpvec3[1];
+      out[2] = tmpvec3[2];
+      out[3] = 1 + dot$$1;
+      return normalize$2(out, out);
+    }
+  };
+})();
+const sqlerp = (function () {
+  let temp1 = create$4();
+  let temp2 = create$4();
+  return function (out, a, b, c, d, t) {
+    slerp(temp1, a, d, t);
+    slerp(temp2, b, c, t);
+    slerp(out, temp1, temp2, 2 * t * (1 - t));
+    return out;
+  };
+}());
+const setAxes = (function() {
+  let matr = create$2();
+  return function(out, view, right, up) {
+    matr[0] = right[0];
+    matr[3] = right[1];
+    matr[6] = right[2];
+    matr[1] = up[0];
+    matr[4] = up[1];
+    matr[7] = up[2];
+    matr[2] = -view[0];
+    matr[5] = -view[1];
+    matr[8] = -view[2];
+    return normalize$2(out, fromMat3(out, matr));
+  };
+})();
+
+const PRIVATE$3 = Symbol('@@webxr-polyfill/XRRigidTransform');
+class XRRigidTransform$1 {
+  constructor() {
+    this[PRIVATE$3] = {
+      matrix: null,
+      position: null,
+      orientation: null,
+      inverse: null,
+    };
+    if (arguments.length === 0) {
+      this[PRIVATE$3].matrix = identity(new Float32Array(16));
+    } else if (arguments.length === 1) {
+      if (arguments[0] instanceof Float32Array) {
+        this[PRIVATE$3].matrix = arguments[0];
+      } else {
+        this[PRIVATE$3].position = this._getPoint(arguments[0]);
+        this[PRIVATE$3].orientation = DOMPointReadOnly.fromPoint({
+            x: 0, y: 0, z: 0, w: 1
+        });
+      }
+    } else if (arguments.length === 2) {
+      this[PRIVATE$3].position = this._getPoint(arguments[0]);
+      this[PRIVATE$3].orientation = this._getPoint(arguments[1]);
+    } else {
+      throw new Error("Too many arguments!");
+    }
+    if (this[PRIVATE$3].matrix) {
+        let position = create$1();
+        getTranslation(position, this[PRIVATE$3].matrix);
+        this[PRIVATE$3].position = DOMPointReadOnly.fromPoint({
+            x: position[0],
+            y: position[1],
+            z: position[2]
+        });
+        let orientation = create$4();
+        getRotation(orientation, this[PRIVATE$3].matrix);
+        this[PRIVATE$3].orientation = DOMPointReadOnly.fromPoint({
+          x: orientation[0],
+          y: orientation[1],
+          z: orientation[2],
+          w: orientation[3]
+        });
+    } else {
+        this[PRIVATE$3].matrix = identity(new Float32Array(16));
+        fromRotationTranslation(
+          this[PRIVATE$3].matrix,
+          fromValues$4(
+            this[PRIVATE$3].orientation.x,
+            this[PRIVATE$3].orientation.y,
+            this[PRIVATE$3].orientation.z,
+            this[PRIVATE$3].orientation.w),
+          fromValues$1(
+            this[PRIVATE$3].position.x,
+            this[PRIVATE$3].position.y,
+            this[PRIVATE$3].position.z)
+        );
+    }
+  }
+  _getPoint(arg) {
+    if (arg instanceof DOMPointReadOnly) {
+      return arg;
+    }
+    return DOMPointReadOnly.fromPoint(arg);
+  }
+  get matrix() { return this[PRIVATE$3].matrix; }
+  get position() { return this[PRIVATE$3].position; }
+  get orientation() { return this[PRIVATE$3].orientation; }
+  get inverse() {
+    if (this[PRIVATE$3].inverse === null) {
+      let invMatrix = identity(new Float32Array(16));
+      invert(invMatrix, this[PRIVATE$3].matrix);
+      this[PRIVATE$3].inverse = new XRRigidTransform$1(invMatrix);
+      this[PRIVATE$3].inverse[PRIVATE$3].inverse = this;
+    }
+    return this[PRIVATE$3].inverse;
+  }
+}
+
+const PRIVATE$4 = Symbol('@@webxr-polyfill/XRViewerPose');
+class XRViewerPose extends XRPose$1 {
+  constructor(device, views) {
+    super(new XRRigidTransform$1(), false);
+    this[PRIVATE$4] = {
+      device,
+      views,
+      leftViewMatrix: identity(new Float32Array(16)),
+      rightViewMatrix: identity(new Float32Array(16)),
+      poseModelMatrix: identity(new Float32Array(16)),
+    };
+  }
+  get poseModelMatrix() { return this[PRIVATE$4].poseModelMatrix; }
+  get views() {
+    return this[PRIVATE$4].views;
+  }
+  _updateFromReferenceSpace(refSpace) {
+    const pose = this[PRIVATE$4].device.getBasePoseMatrix();
+    const leftViewMatrix = this[PRIVATE$4].device.getBaseViewMatrix('left');
+    const rightViewMatrix = this[PRIVATE$4].device.getBaseViewMatrix('right');
+    if (pose) {
+      refSpace._transformBasePoseMatrix(this[PRIVATE$4].poseModelMatrix, pose);
+      refSpace._adjustForOriginOffset(this[PRIVATE$4].poseModelMatrix);
+      super._setTransform(new XRRigidTransform$1(this[PRIVATE$4].poseModelMatrix));
+    }
+    if (leftViewMatrix) {
+      refSpace._transformBaseViewMatrix(
+        this[PRIVATE$4].leftViewMatrix,
+        leftViewMatrix,
+        this[PRIVATE$4].poseModelMatrix);
+      multiply(
+        this[PRIVATE$4].leftViewMatrix,
+        this[PRIVATE$4].leftViewMatrix,
+        refSpace._originOffsetMatrix());
+    }
+    if (rightViewMatrix) {
+      refSpace._transformBaseViewMatrix(
+        this[PRIVATE$4].rightViewMatrix,
+        rightViewMatrix,
+        this[PRIVATE$4].poseModelMatrix);
+      multiply(
+        this[PRIVATE$4].rightViewMatrix,
+        this[PRIVATE$4].rightViewMatrix,
+        refSpace._originOffsetMatrix());
+    }
+    for (let view of this[PRIVATE$4].views) {
+      if (view.eye == "left") {
+        view._updateViewMatrix(this[PRIVATE$4].leftViewMatrix);
+      } else if (view.eye == "right") {
+        view._updateViewMatrix(this[PRIVATE$4].rightViewMatrix);
+      }
+    }
+  }
+}
+
+const PRIVATE$5 = Symbol('@@webxr-polyfill/XRViewport');
+class XRViewport {
+  constructor(target) {
+    this[PRIVATE$5] = { target };
+  }
+  get x() { return this[PRIVATE$5].target.x; }
+  get y() { return this[PRIVATE$5].target.y; }
+  get width() { return this[PRIVATE$5].target.width; }
+  get height() { return this[PRIVATE$5].target.height; }
+}
+
+const XREyes = ['left', 'right'];
+const PRIVATE$6 = Symbol('@@webxr-polyfill/XRView');
+class XRView {
+  constructor(device, eye, sessionId) {
+    if (!XREyes.includes(eye)) {
+      throw new Error(`XREye must be one of: ${XREyes}`);
+    }
+    const temp = Object.create(null);
+    const viewport = new XRViewport(temp);
+    this[PRIVATE$6] = {
+      device,
+      eye,
+      viewport,
+      temp,
+      sessionId,
+      transform: null,
+    };
+  }
+  get eye() { return this[PRIVATE$6].eye; }
+  get projectionMatrix() { return this[PRIVATE$6].device.getProjectionMatrix(this.eye); }
+  get transform() { return this[PRIVATE$6].transform; }
+  _updateViewMatrix(viewMatrix) {
+    let invMatrix = identity(new Float32Array(16));
+    invert(invMatrix, viewMatrix);
+    this[PRIVATE$6].transform = new XRRigidTransform$1(invMatrix);
+  }
+  _getViewport(layer) {
+    if (this[PRIVATE$6].device.getViewport(this[PRIVATE$6].sessionId,
+                                           this.eye,
+                                           layer,
+                                           this[PRIVATE$6].temp)) {
+      return this[PRIVATE$6].viewport;
+    }
+    return undefined;
+  }
+}
+
+var EPSILON$1 = 0.000001;
+var ARRAY_TYPE$1 = typeof Float32Array !== 'undefined' ? Float32Array : Array;
+
+
+var degree$1 = Math.PI / 180;
+
+function create$7() {
+  var out = new ARRAY_TYPE$1(9);
+  if (ARRAY_TYPE$1 != Float32Array) {
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[5] = 0;
+    out[6] = 0;
+    out[7] = 0;
+  }
+  out[0] = 1;
+  out[4] = 1;
+  out[8] = 1;
+  return out;
+}
+
+function create$9() {
+  var out = new ARRAY_TYPE$1(3);
+  if (ARRAY_TYPE$1 != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  return out;
+}
+
+function length$3(a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  return Math.sqrt(x * x + y * y + z * z);
+}
+function fromValues$9(x, y, z) {
+  var out = new ARRAY_TYPE$1(3);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function normalize$3(out, a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  var len = x * x + y * y + z * z;
+  if (len > 0) {
+    len = 1 / Math.sqrt(len);
+    out[0] = a[0] * len;
+    out[1] = a[1] * len;
+    out[2] = a[2] * len;
+  }
+  return out;
+}
+function dot$3(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cross$1(out, a, b) {
+  var ax = a[0],
+      ay = a[1],
+      az = a[2];
+  var bx = b[0],
+      by = b[1],
+      bz = b[2];
+  out[0] = ay * bz - az * by;
+  out[1] = az * bx - ax * bz;
+  out[2] = ax * by - ay * bx;
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var len$3 = length$3;
+
+var forEach$2 = function () {
+  var vec = create$9();
+  return function (a, stride, offset, count, fn, arg) {
+    var i = void 0,
+        l = void 0;
+    if (!stride) {
+      stride = 3;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];vec[1] = a[i + 1];vec[2] = a[i + 2];
+      fn(vec, vec, arg);
+      a[i] = vec[0];a[i + 1] = vec[1];a[i + 2] = vec[2];
+    }
+    return a;
+  };
+}();
+
+function create$10() {
+  var out = new ARRAY_TYPE$1(4);
+  if (ARRAY_TYPE$1 != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+  }
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function normalize$4(out, a) {
+  var x = a[0];
+  var y = a[1];
+  var z = a[2];
+  var w = a[3];
+  var len = x * x + y * y + z * z + w * w;
+  if (len > 0) {
+    len = 1 / Math.sqrt(len);
+    out[0] = x * len;
+    out[1] = y * len;
+    out[2] = z * len;
+    out[3] = w * len;
+  }
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var forEach$3 = function () {
+  var vec = create$10();
+  return function (a, stride, offset, count, fn, arg) {
+    var i = void 0,
+        l = void 0;
+    if (!stride) {
+      stride = 4;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];vec[1] = a[i + 1];vec[2] = a[i + 2];vec[3] = a[i + 3];
+      fn(vec, vec, arg);
+      a[i] = vec[0];a[i + 1] = vec[1];a[i + 2] = vec[2];a[i + 3] = vec[3];
+    }
+    return a;
+  };
+}();
+
+function create$11() {
+  var out = new ARRAY_TYPE$1(4);
+  if (ARRAY_TYPE$1 != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+  }
+  out[3] = 1;
+  return out;
+}
+
+function setAxisAngle$1(out, axis, rad) {
+  rad = rad * 0.5;
+  var s = Math.sin(rad);
+  out[0] = s * axis[0];
+  out[1] = s * axis[1];
+  out[2] = s * axis[2];
+  out[3] = Math.cos(rad);
+  return out;
+}
+
+
+
+
+
+
+function slerp$1(out, a, b, t) {
+  var ax = a[0],
+      ay = a[1],
+      az = a[2],
+      aw = a[3];
+  var bx = b[0],
+      by = b[1],
+      bz = b[2],
+      bw = b[3];
+  var omega = void 0,
+      cosom = void 0,
+      sinom = void 0,
+      scale0 = void 0,
+      scale1 = void 0;
+  cosom = ax * bx + ay * by + az * bz + aw * bw;
+  if (cosom < 0.0) {
+    cosom = -cosom;
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+  }
+  if (1.0 - cosom > EPSILON$1) {
+    omega = Math.acos(cosom);
+    sinom = Math.sin(omega);
+    scale0 = Math.sin((1.0 - t) * omega) / sinom;
+    scale1 = Math.sin(t * omega) / sinom;
+  } else {
+    scale0 = 1.0 - t;
+    scale1 = t;
+  }
+  out[0] = scale0 * ax + scale1 * bx;
+  out[1] = scale0 * ay + scale1 * by;
+  out[2] = scale0 * az + scale1 * bz;
+  out[3] = scale0 * aw + scale1 * bw;
+  return out;
+}
+
+
+
+function fromMat3$1(out, m) {
+  var fTrace = m[0] + m[4] + m[8];
+  var fRoot = void 0;
+  if (fTrace > 0.0) {
+    fRoot = Math.sqrt(fTrace + 1.0);
+    out[3] = 0.5 * fRoot;
+    fRoot = 0.5 / fRoot;
+    out[0] = (m[5] - m[7]) * fRoot;
+    out[1] = (m[6] - m[2]) * fRoot;
+    out[2] = (m[1] - m[3]) * fRoot;
+  } else {
+    var i = 0;
+    if (m[4] > m[0]) i = 1;
+    if (m[8] > m[i * 3 + i]) i = 2;
+    var j = (i + 1) % 3;
+    var k = (i + 2) % 3;
+    fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);
+    out[i] = 0.5 * fRoot;
+    fRoot = 0.5 / fRoot;
+    out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;
+    out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;
+    out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;
+  }
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var normalize$5 = normalize$4;
+
+
+var rotationTo$1 = function () {
+  var tmpvec3 = create$9();
+  var xUnitVec3 = fromValues$9(1, 0, 0);
+  var yUnitVec3 = fromValues$9(0, 1, 0);
+  return function (out, a, b) {
+    var dot = dot$3(a, b);
+    if (dot < -0.999999) {
+      cross$1(tmpvec3, xUnitVec3, a);
+      if (len$3(tmpvec3) < 0.000001) cross$1(tmpvec3, yUnitVec3, a);
+      normalize$3(tmpvec3, tmpvec3);
+      setAxisAngle$1(out, tmpvec3, Math.PI);
+      return out;
+    } else if (dot > 0.999999) {
+      out[0] = 0;
+      out[1] = 0;
+      out[2] = 0;
+      out[3] = 1;
+      return out;
+    } else {
+      cross$1(tmpvec3, a, b);
+      out[0] = tmpvec3[0];
+      out[1] = tmpvec3[1];
+      out[2] = tmpvec3[2];
+      out[3] = 1 + dot;
+      return normalize$5(out, out);
+    }
+  };
+}();
+var sqlerp$1 = function () {
+  var temp1 = create$11();
+  var temp2 = create$11();
+  return function (out, a, b, c, d, t) {
+    slerp$1(temp1, a, d, t);
+    slerp$1(temp2, b, c, t);
+    slerp$1(out, temp1, temp2, 2 * t * (1 - t));
+    return out;
+  };
+}();
+var setAxes$1 = function () {
+  var matr = create$7();
+  return function (out, view, right, up) {
+    matr[0] = right[0];
+    matr[3] = right[1];
+    matr[6] = right[2];
+    matr[1] = up[0];
+    matr[4] = up[1];
+    matr[7] = up[2];
+    matr[2] = -view[0];
+    matr[5] = -view[1];
+    matr[8] = -view[2];
+    return normalize$5(out, fromMat3$1(out, matr));
+  };
+}();
+
+function create$13() {
+  var out = new ARRAY_TYPE$1(2);
+  if (ARRAY_TYPE$1 != Float32Array) {
+    out[0] = 0;
+    out[1] = 0;
+  }
+  return out;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var forEach$4 = function () {
+  var vec = create$13();
+  return function (a, stride, offset, count, fn, arg) {
+    var i = void 0,
+        l = void 0;
+    if (!stride) {
+      stride = 2;
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    if (count) {
+      l = Math.min(count * stride + offset, a.length);
+    } else {
+      l = a.length;
+    }
+    for (i = offset; i < l; i += stride) {
+      vec[0] = a[i];vec[1] = a[i + 1];
+      fn(vec, vec, arg);
+      a[i] = vec[0];a[i + 1] = vec[1];
+    }
+    return a;
+  };
+}();
+
+const PRIVATE$7 = Symbol('@@webxr-polyfill/XRFrame');
+class XRFrame {
+  constructor(device, session, sessionId) {
+    const views = [
+      new XRView(device, 'left', sessionId),
+    ];
+    if (session.immersive) {
+      views.push(new XRView(device, 'right', sessionId));
+    }
+    this[PRIVATE$7] = {
+      device,
+      viewerPose: new XRViewerPose(device, views),
+      views,
+      session,
+    };
+  }
+  get session() { return this[PRIVATE$7].session; }
+  getViewerPose(space) {
+    this[PRIVATE$7].viewerPose._updateFromReferenceSpace(space);
+    return this[PRIVATE$7].viewerPose;
+  }
+  getPose(space, baseSpace) {
+    if (space._specialType === "viewer") {
+      let viewerPose = this.getViewerPose(baseSpace);
+      return new XRPose(
+        new XRRigidTransform(viewerPose.poseModelMatrix),
+        viewerPose.emulatedPosition);
+    }
+    if (space._specialType === "target-ray" || space._specialType === "grip") {
+      return this[PRIVATE$7].device.getInputPose(
+        space._inputSource, baseSpace, space._specialType);
+    }
+    return null;
+  }
+}
+
+const PRIVATE$8 = Symbol('@@webxr-polyfill/XRSpace');
+
+class XRSpace {
+  constructor(specialType = null, inputSource = null) {
+    this[PRIVATE$8] = {
+      specialType,
+      inputSource,
+    };
+  }
+  get _specialType() {
+    return this[PRIVATE$8].specialType;
+  }
+  get _inputSource() {
+    return this[PRIVATE$8].inputSource;
+  }
+}
+
+const DEFAULT_EMULATION_HEIGHT = 1.6;
+const PRIVATE$9 = Symbol('@@webxr-polyfill/XRReferenceSpace');
+const XRReferenceSpaceTypes = [
+  'viewer',
+  'local',
+  'local-floor',
+  'bounded-floor',
+  'unbounded'
+];
+function isFloor(type) {
+  return type === 'bounded-floor' || type === 'local-floor';
+}
+class XRReferenceSpace extends XRSpace {
+  constructor(device, type, transform) {
+    if (!XRReferenceSpaceTypes.includes(type)) {
+      throw new Error(`XRReferenceSpaceType must be one of ${XRReferenceSpaceTypes}`);
+    }
+    super((type === 'viewer') ? 'viewer' : null);
+    if (type === 'bounded-floor' && !transform) {
+      throw new Error(`XRReferenceSpace cannot use 'bounded-floor' type if the platform does not provide the floor level`);
+    }
+    if (isFloor(type) && !transform) {
+      transform = identity(new Float32Array(16));
+      transform[13] = DEFAULT_EMULATION_HEIGHT;
+    }
+    if (!transform) {
+      transform = identity(new Float32Array(16));
+    }
+    this[PRIVATE$9] = {
+      type,
+      transform,
+      device,
+      originOffset : identity(new Float32Array(16)),
+    };
+  }
+  _transformBasePoseMatrix(out, pose) {
+    multiply(out, this[PRIVATE$9].transform, pose);
+  }
+  _transformBaseViewMatrix(out, view) {
+    invert(out, this[PRIVATE$9].transform);
+    multiply(out, view, out);
+  }
+  _originOffsetMatrix() {
+    return this[PRIVATE$9].originOffset;
+  }
+  _adjustForOriginOffset(transformMatrix) {
+    let inverseOriginOffsetMatrix = identity(new Float32Array(16));
+    invert(inverseOriginOffsetMatrix, this[PRIVATE$9].originOffset);
+    multiply(transformMatrix, inverseOriginOffsetMatrix, transformMatrix);
+  }
+  getOffsetReferenceSpace(additionalOffset) {
+    let newSpace = new XRReferenceSpace(
+      this[PRIVATE$9].device,
+      this[PRIVATE$9].type,
+      this[PRIVATE$9].transform,
+      this[PRIVATE$9].bounds);
+    multiply(newSpace[PRIVATE$9].originOffset, this[PRIVATE$9].originOffset, additionalOffset.matrix);
+    return newSpace;
+  }
+}
+
+const POLYFILLED_XR_COMPATIBLE = Symbol('@@webxr-polyfill/polyfilled-xr-compatible');
+const XR_COMPATIBLE = Symbol('@@webxr-polyfill/xr-compatible');
+
+const PRIVATE$10 = Symbol('@@webxr-polyfill/XRWebGLLayer');
+const XRWebGLLayerInit = Object.freeze({
+  antialias: true,
+  depth: false,
+  stencil: false,
+  alpha: true,
+  multiview: false,
+  ignoreDepthValues: false,
+  framebufferScaleFactor: 1.0,
+});
+class XRWebGLLayer {
+  constructor(session, context, layerInit={}) {
+    const config = Object.assign({}, XRWebGLLayerInit, layerInit);
+    if (!(session instanceof XRSession$1)) {
+      throw new Error('session must be a XRSession');
+    }
+    if (session.ended) {
+      throw new Error(`InvalidStateError`);
+    }
+    if (context[POLYFILLED_XR_COMPATIBLE]) {
+      if (context[XR_COMPATIBLE] !== true) {
+        throw new Error(`InvalidStateError`);
+      }
+    }
+    const framebuffer = context.getParameter(context.FRAMEBUFFER_BINDING);
+    this[PRIVATE$10] = {
+      context,
+      config,
+      framebuffer,
+      session,
+    };
+  }
+  get context() { return this[PRIVATE$10].context; }
+  get antialias() { return this[PRIVATE$10].config.antialias; }
+  get ignoreDepthValues() { return true; }
+  get framebuffer() { return this[PRIVATE$10].framebuffer; }
+  get framebufferWidth() { return this[PRIVATE$10].context.drawingBufferWidth; }
+  get framebufferHeight() { return this[PRIVATE$10].context.drawingBufferHeight; }
+  get _session() { return this[PRIVATE$10].session; }
+  getViewport(view) {
+    return view._getViewport(this);
+  }
+}
+
+const PRIVATE$11 = Symbol('@@webxr-polyfill/XRSession');
+class XRSession$1 extends EventTarget {
+  constructor(device, mode, id) {
+    super();
+    let immersive = mode != 'inline';
+    let outputContext = null;
+    this[PRIVATE$11] = {
+      device,
+      mode,
+      immersive,
+      outputContext,
+      ended: false,
+      suspended: false,
+      suspendedCallback: null,
+      id,
+      activeRenderState: null,
+      pendingRenderState: null,
+    };
+    const frame = new XRFrame(device, this, this[PRIVATE$11].id);
+    this[PRIVATE$11].frame = frame;
+    this[PRIVATE$11].onPresentationEnd = sessionId => {
+      if (sessionId !== this[PRIVATE$11].id) {
+        this[PRIVATE$11].suspended = false;
+        this.dispatchEvent('focus', { session: this });
+        const suspendedCallback = this[PRIVATE$11].suspendedCallback;
+        this[PRIVATE$11].suspendedCallback = null;
+        if (suspendedCallback) {
+          this.requestAnimationFrame(suspendedCallback);
+        }
+        return;
+      }
+      this[PRIVATE$11].ended = true;
+      device.removeEventListener('@webvr-polyfill/vr-present-end', this[PRIVATE$11].onPresentationEnd);
+      device.removeEventListener('@webvr-polyfill/vr-present-start', this[PRIVATE$11].onPresentationStart);
+      device.removeEventListener('@@webvr-polyfill/input-select-start', this[PRIVATE$11].onSelectStart);
+      device.removeEventListener('@@webvr-polyfill/input-select-end', this[PRIVATE$11].onSelectEnd);
+      this.dispatchEvent('end', { session: this });
+    };
+    device.addEventListener('@@webxr-polyfill/vr-present-end', this[PRIVATE$11].onPresentationEnd);
+    this[PRIVATE$11].onPresentationStart = sessionId => {
+      if (sessionId === this[PRIVATE$11].id) {
+        return;
+      }
+      this[PRIVATE$11].suspended = true;
+      this.dispatchEvent('blur', { session: this });
+    };
+    device.addEventListener('@@webxr-polyfill/vr-present-start', this[PRIVATE$11].onPresentationStart);
+    this[PRIVATE$11].onSelectStart = evt => {
+      if (evt.sessionId !== this[PRIVATE$11].id) {
+        return;
+      }
+      this.dispatchEvent('selectstart', {
+        frame: this[PRIVATE$11].frame,
+        inputSource: evt.inputSource
+      });
+    };
+    device.addEventListener('@@webxr-polyfill/input-select-start', this[PRIVATE$11].onSelectStart);
+    this[PRIVATE$11].onSelectEnd = evt => {
+      if (evt.sessionId !== this[PRIVATE$11].id) {
+        return;
+      }
+      this.dispatchEvent('selectend', {
+        frame: this[PRIVATE$11].frame,
+        inputSource: evt.inputSource
+      });
+      this.dispatchEvent('select',  {
+        frame: this[PRIVATE$11].frame,
+        inputSource: evt.inputSource
+      });
+    };
+    device.addEventListener('@@webxr-polyfill/input-select-end', this[PRIVATE$11].onSelectEnd);
+    this.onblur = undefined;
+    this.onfocus = undefined;
+    this.onresetpose = undefined;
+    this.onend = undefined;
+    this.onselect = undefined;
+    this.onselectstart = undefined;
+    this.onselectend = undefined;
+  }
+  get renderState() { return this[PRIVATE$11].activeRenderState; }
+  get immersive() { return this[PRIVATE$11].immersive; }
+  get outputContext() { return this[PRIVATE$11].outputContext; }
+  get depthNear() { return this[PRIVATE$11].device.depthNear; }
+  set depthNear(value) { this[PRIVATE$11].device.depthNear = value; }
+  get depthFar() { return this[PRIVATE$11].device.depthFar; }
+  set depthFar(value) { this[PRIVATE$11].device.depthFar = value; }
+  get environmentBlendMode() {
+    return this[PRIVATE$11].device.environmentBlendMode || 'opaque';
+  }
+  get baseLayer() { return this[PRIVATE$11].baseLayer; }
+  set baseLayer(value) {
+    if (this[PRIVATE$11].ended) {
+      return;
+    }
+    this[PRIVATE$11].baseLayer = value;
+    this[PRIVATE$11].device.onBaseLayerSet(this[PRIVATE$11].id, value);
+  }
+  async requestReferenceSpace(type) {
+    if (this[PRIVATE$11].ended) {
+      return;
+    }
+    if (type === 'unbounded') {
+      throw new NotSupportedError(`The WebXR polyfill does not support the ${type} reference space`);
+    }
+    if (!XRReferenceSpaceTypes.includes(type)) {
+      throw new TypeError(`XRReferenceSpaceType must be one of ${XRReferenceSpaceTypes}`);
+    }
+    let transform = await this[PRIVATE$11].device.requestFrameOfReferenceTransform(type);
+    if (type === 'bounded-floor') {
+      if (!transform) {
+        throw new NotSupportedError(`${type} XRReferenceSpace not supported by this device.`);
+      }
+      let bounds = this[PRIVATE$11].device.requestStageBounds();
+      if (!bounds) {
+        throw new NotSupportedError(`${type} XRReferenceSpace not supported by this device.`);
+      }
+      throw new NotSupportedError(`The WebXR polyfill does not support the ${type} reference space yet.`);
+    }
+    return new XRReferenceSpace(this[PRIVATE$11].device, type, transform);
+  }
+  requestAnimationFrame(callback) {
+    if (this[PRIVATE$11].ended) {
+      return;
+    }
+    if (this[PRIVATE$11].suspended && this[PRIVATE$11].suspendedCallback) {
+      return;
+    }
+    if (this[PRIVATE$11].suspended && !this[PRIVATE$11].suspendedCallback) {
+      this[PRIVATE$11].suspendedCallback = callback;
+    }
+    return this[PRIVATE$11].device.requestAnimationFrame(() => {
+      if (this[PRIVATE$11].pendingRenderState !== null) {
+        this[PRIVATE$11].activeRenderState = this[PRIVATE$11].pendingRenderState;
+        this[PRIVATE$11].pendingRenderState = null;
+        if (this[PRIVATE$11].activeRenderState.baseLayer) {
+          this[PRIVATE$11].device.onBaseLayerSet(
+            this[PRIVATE$11].id,
+            this[PRIVATE$11].activeRenderState.baseLayer);
+        }
+        if (this[PRIVATE$11].activeRenderState.inlineVerticalFieldOfView) {
+          this[PRIVATE$11].device.onInlineVerticalFieldOfViewSet(
+            this[PRIVATE$11].id,
+            this[PRIVATE$11].activeRenderState.inlineVerticalFieldOfView);
+        }
+      }
+      this[PRIVATE$11].device.onFrameStart(this[PRIVATE$11].id);
+      callback(now$1(), this[PRIVATE$11].frame);
+      this[PRIVATE$11].device.onFrameEnd(this[PRIVATE$11].id);
+    });
+  }
+  cancelAnimationFrame(handle) {
+    if (this[PRIVATE$11].ended) {
+      return;
+    }
+    this[PRIVATE$11].device.cancelAnimationFrame(handle);
+  }
+  get inputSources() {
+    return this[PRIVATE$11].device.getInputSources();
+  }
+  async end() {
+    if (this[PRIVATE$11].ended) {
+      return;
+    }
+    if (!this.immersive) {
+      this[PRIVATE$11].ended = true;
+      this[PRIVATE$11].device.removeEventListener('@@webvr-polyfill/vr-present-start',
+                                                 this[PRIVATE$11].onPresentationStart);
+      this[PRIVATE$11].device.removeEventListener('@@webvr-polyfill/vr-present-end',
+                                                 this[PRIVATE$11].onPresentationEnd);
+      this[PRIVATE$11].device.removeEventListener('@@webvr-polyfill/input-select-start',
+                                                 this[PRIVATE$11].onSelectStart);
+      this[PRIVATE$11].device.removeEventListener('@@webvr-polyfill/input-select-end',
+                                                 this[PRIVATE$11].onSelectEnd);
+      this.dispatchEvent('end', { session: this });
+    }
+    return this[PRIVATE$11].device.endSession(this[PRIVATE$11].id);
+  }
+  updateRenderState(newState) {
+    if (this[PRIVATE$11].ended) {
+      const message = "Can't call updateRenderState on an XRSession " +
+                      "that has already ended.";
+      throw new Error(message);
+    }
+    if (newState.baseLayer && (newState.baseLayer._session !== this)) {
+      const message = "Called updateRenderState with a base layer that was " +
+                      "created by a different session.";
+      throw new Error(message);
+    }
+    const fovSet = (newState.inlineVerticalFieldOfView !== null) &&
+                   (newState.inlineVerticalFieldOfView !== undefined);
+    if (fovSet) {
+      if (this[PRIVATE$11].immersive) {
+        const message = "inlineVerticalFieldOfView must not be set for an " +
+                        "XRRenderState passed to updateRenderState for an " +
+                        "immersive session.";
+        throw new Error(message);
+      } else {
+        newState.inlineVerticalFieldOfView = Math.min(
+          3.13, Math.max(0.01, newState.inlineVerticalFieldOfView));
+      }
+    }
+    if (this[PRIVATE$11].pendingRenderState === null) {
+      this[PRIVATE$11].pendingRenderState = Object.assign(
+        {}, this[PRIVATE$11].activeRenderState, newState);
+    }
+  }
+}
+
+const PRIVATE$12 = Symbol('@@webxr-polyfill/XRInputSource');
+class XRInputSource {
+  constructor(impl) {
+    this[PRIVATE$12] = {
+      impl,
+      gripSpace: new XRSpace("grip", this),
+      targetRaySpace: new XRSpace("target-ray", this)
+    };
+  }
+  get handedness() { return this[PRIVATE$12].impl.handedness; }
+  get targetRayMode() { return this[PRIVATE$12].impl.targetRayMode; }
+  get gripSpace() {
+    let mode = this[PRIVATE$12].impl.targetRayMode;
+    if (mode === "gaze" || mode === "screen") {
+      return null;
+    }
+    return this[PRIVATE$12].gripSpace;
+  }
+  get targetRaySpace() { return this[PRIVATE$12].targetRaySpace; }
+  get profiles() { return this[PRIVATE$12].impl.profiles; }
+  get gamepad() { return this[PRIVATE$12].impl.gamepad; }
+}
+
+const PRIVATE$13 = Symbol('@@webxr-polyfill/XRRenderState');
+const XRRenderStateInit = Object.freeze({
+  depthNear: 0.1,
+  depthFar: 1000.0,
+  inlineVerticalFieldOfView: null,
+  baseLayer: null
+});
+class XRRenderState {
+  constructor(stateInit = {}) {
+    const config = Object.assign({}, XRRenderStateInit, stateInit);
+    this[PRIVATE$13] = { config };
+  }
+  get depthNear() { return this[PRIVATE$13].depthNear; }
+  get depthFar() { return this[PRIVATE$13].depthFar; }
+  get inlineVerticalFieldOfView() { return this[PRIVATE$13].inlineVerticalFieldOfView; }
+  get baseLayer() { return this[PRIVATE$13].baseLayer; }
+}
+
+var API = {
+  XR: XR$1,
+  XRSession: XRSession$1,
+  XRFrame,
+  XRView,
+  XRViewport,
+  XRViewerPose,
+  XRWebGLLayer,
+  XRSpace,
+  XRReferenceSpace,
+  XRInputSource,
+  XRRenderState,
+  XRRigidTransform: XRRigidTransform$1,
+  XRPose: XRPose$1,
+};
+
+const polyfillMakeXRCompatible = Context => {
+  if (typeof Context.prototype.makeXRCompatible === 'function') {
+    return false;
+  }
+  Context.prototype.makeXRCompatible = function () {
+    this[XR_COMPATIBLE] = true;
+    return Promise.resolve();
+  };
+  return true;
+};
+const polyfillGetContext = (Canvas) => {
+  const getContext = Canvas.prototype.getContext;
+  Canvas.prototype.getContext = function (contextType, glAttribs) {
+    const ctx = getContext.call(this, contextType, glAttribs);
+    if (ctx) {
+      ctx[POLYFILLED_XR_COMPATIBLE] = true;
+      if (glAttribs && ('xrCompatible' in glAttribs)) {
+        ctx[XR_COMPATIBLE] = glAttribs.xrCompatible;
+      }
+    }
+    return ctx;
+  };
+};
+
+const isImageBitmapSupported = global =>
+  !!(global.ImageBitmapRenderingContext &&
+     global.createImageBitmap);
+
+const applyCanvasStylesForMinimalRendering = canvas => {
+  canvas.style.display = 'block';
+  canvas.style.position = 'absolute';
+  canvas.style.width = canvas.style.height = '1px';
+  canvas.style.top = canvas.style.left = '0px';
+};
+
+var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+
+
+function unwrapExports (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var cardboardVrDisplay = createCommonjsModule(function (module, exports) {
+(function (global, factory) {
+	module.exports = factory();
+}(commonjsGlobal, (function () { var classCallCheck = function (instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+};
+var createClass = function () {
+  function defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+  return function (Constructor, protoProps, staticProps) {
+    if (protoProps) defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) defineProperties(Constructor, staticProps);
+    return Constructor;
+  };
+}();
+var slicedToArray = function () {
+  function sliceIterator(arr, i) {
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _e = undefined;
+    try {
+      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"]) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+    return _arr;
+  }
+  return function (arr, i) {
+    if (Array.isArray(arr)) {
+      return arr;
+    } else if (Symbol.iterator in Object(arr)) {
+      return sliceIterator(arr, i);
+    } else {
+      throw new TypeError("Invalid attempt to destructure non-iterable instance");
+    }
+  };
+}();
+var MIN_TIMESTEP = 0.001;
+var MAX_TIMESTEP = 1;
+var dataUri = function dataUri(mimeType, svg) {
+  return 'data:' + mimeType + ',' + encodeURIComponent(svg);
+};
+var lerp = function lerp(a, b, t) {
+  return a + (b - a) * t;
+};
+var isIOS = function () {
+  var isIOS = /iPad|iPhone|iPod/.test(navigator.platform);
+  return function () {
+    return isIOS;
+  };
+}();
+var isWebViewAndroid = function () {
+  var isWebViewAndroid = navigator.userAgent.indexOf('Version') !== -1 && navigator.userAgent.indexOf('Android') !== -1 && navigator.userAgent.indexOf('Chrome') !== -1;
+  return function () {
+    return isWebViewAndroid;
+  };
+}();
+var isSafari = function () {
+  var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+  return function () {
+    return isSafari;
+  };
+}();
+var isFirefoxAndroid = function () {
+  var isFirefoxAndroid = navigator.userAgent.indexOf('Firefox') !== -1 && navigator.userAgent.indexOf('Android') !== -1;
+  return function () {
+    return isFirefoxAndroid;
+  };
+}();
+var getChromeVersion = function () {
+  var match = navigator.userAgent.match(/.*Chrome\/([0-9]+)/);
+  var value = match ? parseInt(match[1], 10) : null;
+  return function () {
+    return value;
+  };
+}();
+var isChromeWithoutDeviceMotion = function () {
+  var value = false;
+  if (getChromeVersion() === 65) {
+    var match = navigator.userAgent.match(/.*Chrome\/([0-9\.]*)/);
+    if (match) {
+      var _match$1$split = match[1].split('.'),
+          _match$1$split2 = slicedToArray(_match$1$split, 4),
+          major = _match$1$split2[0],
+          minor = _match$1$split2[1],
+          branch = _match$1$split2[2],
+          build = _match$1$split2[3];
+      value = parseInt(branch, 10) === 3325 && parseInt(build, 10) < 148;
+    }
+  }
+  return function () {
+    return value;
+  };
+}();
+var isR7 = function () {
+  var isR7 = navigator.userAgent.indexOf('R7 Build') !== -1;
+  return function () {
+    return isR7;
+  };
+}();
+var isLandscapeMode = function isLandscapeMode() {
+  var rtn = window.orientation == 90 || window.orientation == -90;
+  return isR7() ? !rtn : rtn;
+};
+var isTimestampDeltaValid = function isTimestampDeltaValid(timestampDeltaS) {
+  if (isNaN(timestampDeltaS)) {
+    return false;
+  }
+  if (timestampDeltaS <= MIN_TIMESTEP) {
+    return false;
+  }
+  if (timestampDeltaS > MAX_TIMESTEP) {
+    return false;
+  }
+  return true;
+};
+var getScreenWidth = function getScreenWidth() {
+  return Math.max(window.screen.width, window.screen.height) * window.devicePixelRatio;
+};
+var getScreenHeight = function getScreenHeight() {
+  return Math.min(window.screen.width, window.screen.height) * window.devicePixelRatio;
+};
+var requestFullscreen = function requestFullscreen(element) {
+  if (isWebViewAndroid()) {
+    return false;
+  }
+  if (element.requestFullscreen) {
+    element.requestFullscreen();
+  } else if (element.webkitRequestFullscreen) {
+    element.webkitRequestFullscreen();
+  } else if (element.mozRequestFullScreen) {
+    element.mozRequestFullScreen();
+  } else if (element.msRequestFullscreen) {
+    element.msRequestFullscreen();
+  } else {
+    return false;
+  }
+  return true;
+};
+var exitFullscreen = function exitFullscreen() {
+  if (document.exitFullscreen) {
+    document.exitFullscreen();
+  } else if (document.webkitExitFullscreen) {
+    document.webkitExitFullscreen();
+  } else if (document.mozCancelFullScreen) {
+    document.mozCancelFullScreen();
+  } else if (document.msExitFullscreen) {
+    document.msExitFullscreen();
+  } else {
+    return false;
+  }
+  return true;
+};
+var getFullscreenElement = function getFullscreenElement() {
+  return document.fullscreenElement || document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement;
+};
+var linkProgram = function linkProgram(gl, vertexSource, fragmentSource, attribLocationMap) {
+  var vertexShader = gl.createShader(gl.VERTEX_SHADER);
+  gl.shaderSource(vertexShader, vertexSource);
+  gl.compileShader(vertexShader);
+  var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+  gl.shaderSource(fragmentShader, fragmentSource);
+  gl.compileShader(fragmentShader);
+  var program = gl.createProgram();
+  gl.attachShader(program, vertexShader);
+  gl.attachShader(program, fragmentShader);
+  for (var attribName in attribLocationMap) {
+    gl.bindAttribLocation(program, attribLocationMap[attribName], attribName);
+  }gl.linkProgram(program);
+  gl.deleteShader(vertexShader);
+  gl.deleteShader(fragmentShader);
+  return program;
+};
+var getProgramUniforms = function getProgramUniforms(gl, program) {
+  var uniforms = {};
+  var uniformCount = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
+  var uniformName = '';
+  for (var i = 0; i < uniformCount; i++) {
+    var uniformInfo = gl.getActiveUniform(program, i);
+    uniformName = uniformInfo.name.replace('[0]', '');
+    uniforms[uniformName] = gl.getUniformLocation(program, uniformName);
+  }
+  return uniforms;
+};
+var orthoMatrix = function orthoMatrix(out, left, right, bottom, top, near, far) {
+  var lr = 1 / (left - right),
+      bt = 1 / (bottom - top),
+      nf = 1 / (near - far);
+  out[0] = -2 * lr;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = -2 * bt;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 2 * nf;
+  out[11] = 0;
+  out[12] = (left + right) * lr;
+  out[13] = (top + bottom) * bt;
+  out[14] = (far + near) * nf;
+  out[15] = 1;
+  return out;
+};
+var isMobile = function isMobile() {
+  var check = false;
+  (function (a) {
+    if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4))) check = true;
+  })(navigator.userAgent || navigator.vendor || window.opera);
+  return check;
+};
+var extend = function extend(dest, src) {
+  for (var key in src) {
+    if (src.hasOwnProperty(key)) {
+      dest[key] = src[key];
+    }
+  }
+  return dest;
+};
+var safariCssSizeWorkaround = function safariCssSizeWorkaround(canvas) {
+  if (isIOS()) {
+    var width = canvas.style.width;
+    var height = canvas.style.height;
+    canvas.style.width = parseInt(width) + 1 + 'px';
+    canvas.style.height = parseInt(height) + 'px';
+    setTimeout(function () {
+      canvas.style.width = width;
+      canvas.style.height = height;
+    }, 100);
+  }
+  window.canvas = canvas;
+};
+var frameDataFromPose = function () {
+  var piOver180 = Math.PI / 180.0;
+  var rad45 = Math.PI * 0.25;
+  function mat4_perspectiveFromFieldOfView(out, fov, near, far) {
+    var upTan = Math.tan(fov ? fov.upDegrees * piOver180 : rad45),
+        downTan = Math.tan(fov ? fov.downDegrees * piOver180 : rad45),
+        leftTan = Math.tan(fov ? fov.leftDegrees * piOver180 : rad45),
+        rightTan = Math.tan(fov ? fov.rightDegrees * piOver180 : rad45),
+        xScale = 2.0 / (leftTan + rightTan),
+        yScale = 2.0 / (upTan + downTan);
+    out[0] = xScale;
+    out[1] = 0.0;
+    out[2] = 0.0;
+    out[3] = 0.0;
+    out[4] = 0.0;
+    out[5] = yScale;
+    out[6] = 0.0;
+    out[7] = 0.0;
+    out[8] = -((leftTan - rightTan) * xScale * 0.5);
+    out[9] = (upTan - downTan) * yScale * 0.5;
+    out[10] = far / (near - far);
+    out[11] = -1.0;
+    out[12] = 0.0;
+    out[13] = 0.0;
+    out[14] = far * near / (near - far);
+    out[15] = 0.0;
+    return out;
+  }
+  function mat4_fromRotationTranslation(out, q, v) {
+    var x = q[0],
+        y = q[1],
+        z = q[2],
+        w = q[3],
+        x2 = x + x,
+        y2 = y + y,
+        z2 = z + z,
+        xx = x * x2,
+        xy = x * y2,
+        xz = x * z2,
+        yy = y * y2,
+        yz = y * z2,
+        zz = z * z2,
+        wx = w * x2,
+        wy = w * y2,
+        wz = w * z2;
+    out[0] = 1 - (yy + zz);
+    out[1] = xy + wz;
+    out[2] = xz - wy;
+    out[3] = 0;
+    out[4] = xy - wz;
+    out[5] = 1 - (xx + zz);
+    out[6] = yz + wx;
+    out[7] = 0;
+    out[8] = xz + wy;
+    out[9] = yz - wx;
+    out[10] = 1 - (xx + yy);
+    out[11] = 0;
+    out[12] = v[0];
+    out[13] = v[1];
+    out[14] = v[2];
+    out[15] = 1;
+    return out;
+  }
+  function mat4_translate(out, a, v) {
+    var x = v[0],
+        y = v[1],
+        z = v[2],
+        a00,
+        a01,
+        a02,
+        a03,
+        a10,
+        a11,
+        a12,
+        a13,
+        a20,
+        a21,
+        a22,
+        a23;
+    if (a === out) {
+      out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];
+      out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];
+      out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];
+      out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];
+    } else {
+      a00 = a[0];a01 = a[1];a02 = a[2];a03 = a[3];
+      a10 = a[4];a11 = a[5];a12 = a[6];a13 = a[7];
+      a20 = a[8];a21 = a[9];a22 = a[10];a23 = a[11];
+      out[0] = a00;out[1] = a01;out[2] = a02;out[3] = a03;
+      out[4] = a10;out[5] = a11;out[6] = a12;out[7] = a13;
+      out[8] = a20;out[9] = a21;out[10] = a22;out[11] = a23;
+      out[12] = a00 * x + a10 * y + a20 * z + a[12];
+      out[13] = a01 * x + a11 * y + a21 * z + a[13];
+      out[14] = a02 * x + a12 * y + a22 * z + a[14];
+      out[15] = a03 * x + a13 * y + a23 * z + a[15];
+    }
+    return out;
+  }
+  function mat4_invert(out, a) {
+    var a00 = a[0],
+        a01 = a[1],
+        a02 = a[2],
+        a03 = a[3],
+        a10 = a[4],
+        a11 = a[5],
+        a12 = a[6],
+        a13 = a[7],
+        a20 = a[8],
+        a21 = a[9],
+        a22 = a[10],
+        a23 = a[11],
+        a30 = a[12],
+        a31 = a[13],
+        a32 = a[14],
+        a33 = a[15],
+        b00 = a00 * a11 - a01 * a10,
+        b01 = a00 * a12 - a02 * a10,
+        b02 = a00 * a13 - a03 * a10,
+        b03 = a01 * a12 - a02 * a11,
+        b04 = a01 * a13 - a03 * a11,
+        b05 = a02 * a13 - a03 * a12,
+        b06 = a20 * a31 - a21 * a30,
+        b07 = a20 * a32 - a22 * a30,
+        b08 = a20 * a33 - a23 * a30,
+        b09 = a21 * a32 - a22 * a31,
+        b10 = a21 * a33 - a23 * a31,
+        b11 = a22 * a33 - a23 * a32,
+    det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (!det) {
+      return null;
+    }
+    det = 1.0 / det;
+    out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+    out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+    out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+    out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+    out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+    out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+    out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+    return out;
+  }
+  var defaultOrientation = new Float32Array([0, 0, 0, 1]);
+  var defaultPosition = new Float32Array([0, 0, 0]);
+  function updateEyeMatrices(projection, view, pose, fov, offset, vrDisplay) {
+    mat4_perspectiveFromFieldOfView(projection, fov || null, vrDisplay.depthNear, vrDisplay.depthFar);
+    var orientation = pose.orientation || defaultOrientation;
+    var position = pose.position || defaultPosition;
+    mat4_fromRotationTranslation(view, orientation, position);
+    if (offset) mat4_translate(view, view, offset);
+    mat4_invert(view, view);
+  }
+  return function (frameData, pose, vrDisplay) {
+    if (!frameData || !pose) return false;
+    frameData.pose = pose;
+    frameData.timestamp = pose.timestamp;
+    updateEyeMatrices(frameData.leftProjectionMatrix, frameData.leftViewMatrix, pose, vrDisplay._getFieldOfView("left"), vrDisplay._getEyeOffset("left"), vrDisplay);
+    updateEyeMatrices(frameData.rightProjectionMatrix, frameData.rightViewMatrix, pose, vrDisplay._getFieldOfView("right"), vrDisplay._getEyeOffset("right"), vrDisplay);
+    return true;
+  };
+}();
+var isInsideCrossOriginIFrame = function isInsideCrossOriginIFrame() {
+  var isFramed = window.self !== window.top;
+  var refOrigin = getOriginFromUrl(document.referrer);
+  var thisOrigin = getOriginFromUrl(window.location.href);
+  return isFramed && refOrigin !== thisOrigin;
+};
+var getOriginFromUrl = function getOriginFromUrl(url) {
+  var domainIdx;
+  var protoSepIdx = url.indexOf("://");
+  if (protoSepIdx !== -1) {
+    domainIdx = protoSepIdx + 3;
+  } else {
+    domainIdx = 0;
+  }
+  var domainEndIdx = url.indexOf('/', domainIdx);
+  if (domainEndIdx === -1) {
+    domainEndIdx = url.length;
+  }
+  return url.substring(0, domainEndIdx);
+};
+var getQuaternionAngle = function getQuaternionAngle(quat) {
+  if (quat.w > 1) {
+    console.warn('getQuaternionAngle: w > 1');
+    return 0;
+  }
+  var angle = 2 * Math.acos(quat.w);
+  return angle;
+};
+var warnOnce = function () {
+  var observedWarnings = {};
+  return function (key, message) {
+    if (observedWarnings[key] === undefined) {
+      console.warn('webvr-polyfill: ' + message);
+      observedWarnings[key] = true;
+    }
+  };
+}();
+var deprecateWarning = function deprecateWarning(deprecated, suggested) {
+  var alternative = suggested ? 'Please use ' + suggested + ' instead.' : '';
+  warnOnce(deprecated, deprecated + ' has been deprecated. ' + 'This may not work on native WebVR displays. ' + alternative);
+};
+function WGLUPreserveGLState(gl, bindings, callback) {
+  if (!bindings) {
+    callback(gl);
+    return;
+  }
+  var boundValues = [];
+  var activeTexture = null;
+  for (var i = 0; i < bindings.length; ++i) {
+    var binding = bindings[i];
+    switch (binding) {
+      case gl.TEXTURE_BINDING_2D:
+      case gl.TEXTURE_BINDING_CUBE_MAP:
+        var textureUnit = bindings[++i];
+        if (textureUnit < gl.TEXTURE0 || textureUnit > gl.TEXTURE31) {
+          console.error("TEXTURE_BINDING_2D or TEXTURE_BINDING_CUBE_MAP must be followed by a valid texture unit");
+          boundValues.push(null, null);
+          break;
+        }
+        if (!activeTexture) {
+          activeTexture = gl.getParameter(gl.ACTIVE_TEXTURE);
+        }
+        gl.activeTexture(textureUnit);
+        boundValues.push(gl.getParameter(binding), null);
+        break;
+      case gl.ACTIVE_TEXTURE:
+        activeTexture = gl.getParameter(gl.ACTIVE_TEXTURE);
+        boundValues.push(null);
+        break;
+      default:
+        boundValues.push(gl.getParameter(binding));
+        break;
+    }
+  }
+  callback(gl);
+  for (var i = 0; i < bindings.length; ++i) {
+    var binding = bindings[i];
+    var boundValue = boundValues[i];
+    switch (binding) {
+      case gl.ACTIVE_TEXTURE:
+        break;
+      case gl.ARRAY_BUFFER_BINDING:
+        gl.bindBuffer(gl.ARRAY_BUFFER, boundValue);
+        break;
+      case gl.COLOR_CLEAR_VALUE:
+        gl.clearColor(boundValue[0], boundValue[1], boundValue[2], boundValue[3]);
+        break;
+      case gl.COLOR_WRITEMASK:
+        gl.colorMask(boundValue[0], boundValue[1], boundValue[2], boundValue[3]);
+        break;
+      case gl.CURRENT_PROGRAM:
+        gl.useProgram(boundValue);
+        break;
+      case gl.ELEMENT_ARRAY_BUFFER_BINDING:
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, boundValue);
+        break;
+      case gl.FRAMEBUFFER_BINDING:
+        gl.bindFramebuffer(gl.FRAMEBUFFER, boundValue);
+        break;
+      case gl.RENDERBUFFER_BINDING:
+        gl.bindRenderbuffer(gl.RENDERBUFFER, boundValue);
+        break;
+      case gl.TEXTURE_BINDING_2D:
+        var textureUnit = bindings[++i];
+        if (textureUnit < gl.TEXTURE0 || textureUnit > gl.TEXTURE31)
+          break;
+        gl.activeTexture(textureUnit);
+        gl.bindTexture(gl.TEXTURE_2D, boundValue);
+        break;
+      case gl.TEXTURE_BINDING_CUBE_MAP:
+        var textureUnit = bindings[++i];
+        if (textureUnit < gl.TEXTURE0 || textureUnit > gl.TEXTURE31)
+          break;
+        gl.activeTexture(textureUnit);
+        gl.bindTexture(gl.TEXTURE_CUBE_MAP, boundValue);
+        break;
+      case gl.VIEWPORT:
+        gl.viewport(boundValue[0], boundValue[1], boundValue[2], boundValue[3]);
+        break;
+      case gl.BLEND:
+      case gl.CULL_FACE:
+      case gl.DEPTH_TEST:
+      case gl.SCISSOR_TEST:
+      case gl.STENCIL_TEST:
+        if (boundValue) {
+          gl.enable(binding);
+        } else {
+          gl.disable(binding);
+        }
+        break;
+      default:
+        console.log("No GL restore behavior for 0x" + binding.toString(16));
+        break;
+    }
+    if (activeTexture) {
+      gl.activeTexture(activeTexture);
+    }
+  }
+}
+var glPreserveState = WGLUPreserveGLState;
+var distortionVS = ['attribute vec2 position;', 'attribute vec3 texCoord;', 'varying vec2 vTexCoord;', 'uniform vec4 viewportOffsetScale[2];', 'void main() {', '  vec4 viewport = viewportOffsetScale[int(texCoord.z)];', '  vTexCoord = (texCoord.xy * viewport.zw) + viewport.xy;', '  gl_Position = vec4( position, 1.0, 1.0 );', '}'].join('\n');
+var distortionFS = ['precision mediump float;', 'uniform sampler2D diffuse;', 'varying vec2 vTexCoord;', 'void main() {', '  gl_FragColor = texture2D(diffuse, vTexCoord);', '}'].join('\n');
+function CardboardDistorter(gl, cardboardUI, bufferScale, dirtySubmitFrameBindings) {
+  this.gl = gl;
+  this.cardboardUI = cardboardUI;
+  this.bufferScale = bufferScale;
+  this.dirtySubmitFrameBindings = dirtySubmitFrameBindings;
+  this.ctxAttribs = gl.getContextAttributes();
+  this.meshWidth = 20;
+  this.meshHeight = 20;
+  this.bufferWidth = gl.drawingBufferWidth;
+  this.bufferHeight = gl.drawingBufferHeight;
+  this.realBindFramebuffer = gl.bindFramebuffer;
+  this.realEnable = gl.enable;
+  this.realDisable = gl.disable;
+  this.realColorMask = gl.colorMask;
+  this.realClearColor = gl.clearColor;
+  this.realViewport = gl.viewport;
+  if (!isIOS()) {
+    this.realCanvasWidth = Object.getOwnPropertyDescriptor(gl.canvas.__proto__, 'width');
+    this.realCanvasHeight = Object.getOwnPropertyDescriptor(gl.canvas.__proto__, 'height');
+  }
+  this.isPatched = false;
+  this.lastBoundFramebuffer = null;
+  this.cullFace = false;
+  this.depthTest = false;
+  this.blend = false;
+  this.scissorTest = false;
+  this.stencilTest = false;
+  this.viewport = [0, 0, 0, 0];
+  this.colorMask = [true, true, true, true];
+  this.clearColor = [0, 0, 0, 0];
+  this.attribs = {
+    position: 0,
+    texCoord: 1
+  };
+  this.program = linkProgram(gl, distortionVS, distortionFS, this.attribs);
+  this.uniforms = getProgramUniforms(gl, this.program);
+  this.viewportOffsetScale = new Float32Array(8);
+  this.setTextureBounds();
+  this.vertexBuffer = gl.createBuffer();
+  this.indexBuffer = gl.createBuffer();
+  this.indexCount = 0;
+  this.renderTarget = gl.createTexture();
+  this.framebuffer = gl.createFramebuffer();
+  this.depthStencilBuffer = null;
+  this.depthBuffer = null;
+  this.stencilBuffer = null;
+  if (this.ctxAttribs.depth && this.ctxAttribs.stencil) {
+    this.depthStencilBuffer = gl.createRenderbuffer();
+  } else if (this.ctxAttribs.depth) {
+    this.depthBuffer = gl.createRenderbuffer();
+  } else if (this.ctxAttribs.stencil) {
+    this.stencilBuffer = gl.createRenderbuffer();
+  }
+  this.patch();
+  this.onResize();
+}
+CardboardDistorter.prototype.destroy = function () {
+  var gl = this.gl;
+  this.unpatch();
+  gl.deleteProgram(this.program);
+  gl.deleteBuffer(this.vertexBuffer);
+  gl.deleteBuffer(this.indexBuffer);
+  gl.deleteTexture(this.renderTarget);
+  gl.deleteFramebuffer(this.framebuffer);
+  if (this.depthStencilBuffer) {
+    gl.deleteRenderbuffer(this.depthStencilBuffer);
+  }
+  if (this.depthBuffer) {
+    gl.deleteRenderbuffer(this.depthBuffer);
+  }
+  if (this.stencilBuffer) {
+    gl.deleteRenderbuffer(this.stencilBuffer);
+  }
+  if (this.cardboardUI) {
+    this.cardboardUI.destroy();
+  }
+};
+CardboardDistorter.prototype.onResize = function () {
+  var gl = this.gl;
+  var self = this;
+  var glState = [gl.RENDERBUFFER_BINDING, gl.TEXTURE_BINDING_2D, gl.TEXTURE0];
+  glPreserveState(gl, glState, function (gl) {
+    self.realBindFramebuffer.call(gl, gl.FRAMEBUFFER, null);
+    if (self.scissorTest) {
+      self.realDisable.call(gl, gl.SCISSOR_TEST);
+    }
+    self.realColorMask.call(gl, true, true, true, true);
+    self.realViewport.call(gl, 0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
+    self.realClearColor.call(gl, 0, 0, 0, 1);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    self.realBindFramebuffer.call(gl, gl.FRAMEBUFFER, self.framebuffer);
+    gl.bindTexture(gl.TEXTURE_2D, self.renderTarget);
+    gl.texImage2D(gl.TEXTURE_2D, 0, self.ctxAttribs.alpha ? gl.RGBA : gl.RGB, self.bufferWidth, self.bufferHeight, 0, self.ctxAttribs.alpha ? gl.RGBA : gl.RGB, gl.UNSIGNED_BYTE, null);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, self.renderTarget, 0);
+    if (self.ctxAttribs.depth && self.ctxAttribs.stencil) {
+      gl.bindRenderbuffer(gl.RENDERBUFFER, self.depthStencilBuffer);
+      gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_STENCIL, self.bufferWidth, self.bufferHeight);
+      gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, self.depthStencilBuffer);
+    } else if (self.ctxAttribs.depth) {
+      gl.bindRenderbuffer(gl.RENDERBUFFER, self.depthBuffer);
+      gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, self.bufferWidth, self.bufferHeight);
+      gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, self.depthBuffer);
+    } else if (self.ctxAttribs.stencil) {
+      gl.bindRenderbuffer(gl.RENDERBUFFER, self.stencilBuffer);
+      gl.renderbufferStorage(gl.RENDERBUFFER, gl.STENCIL_INDEX8, self.bufferWidth, self.bufferHeight);
+      gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, self.stencilBuffer);
+    }
+    if (!gl.checkFramebufferStatus(gl.FRAMEBUFFER) === gl.FRAMEBUFFER_COMPLETE) {
+      console.error('Framebuffer incomplete!');
+    }
+    self.realBindFramebuffer.call(gl, gl.FRAMEBUFFER, self.lastBoundFramebuffer);
+    if (self.scissorTest) {
+      self.realEnable.call(gl, gl.SCISSOR_TEST);
+    }
+    self.realColorMask.apply(gl, self.colorMask);
+    self.realViewport.apply(gl, self.viewport);
+    self.realClearColor.apply(gl, self.clearColor);
+  });
+  if (this.cardboardUI) {
+    this.cardboardUI.onResize();
+  }
+};
+CardboardDistorter.prototype.patch = function () {
+  if (this.isPatched) {
+    return;
+  }
+  var self = this;
+  var canvas = this.gl.canvas;
+  var gl = this.gl;
+  if (!isIOS()) {
+    canvas.width = getScreenWidth() * this.bufferScale;
+    canvas.height = getScreenHeight() * this.bufferScale;
+    Object.defineProperty(canvas, 'width', {
+      configurable: true,
+      enumerable: true,
+      get: function get() {
+        return self.bufferWidth;
+      },
+      set: function set(value) {
+        self.bufferWidth = value;
+        self.realCanvasWidth.set.call(canvas, value);
+        self.onResize();
+      }
+    });
+    Object.defineProperty(canvas, 'height', {
+      configurable: true,
+      enumerable: true,
+      get: function get() {
+        return self.bufferHeight;
+      },
+      set: function set(value) {
+        self.bufferHeight = value;
+        self.realCanvasHeight.set.call(canvas, value);
+        self.onResize();
+      }
+    });
+  }
+  this.lastBoundFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+  if (this.lastBoundFramebuffer == null) {
+    this.lastBoundFramebuffer = this.framebuffer;
+    this.gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+  }
+  this.gl.bindFramebuffer = function (target, framebuffer) {
+    self.lastBoundFramebuffer = framebuffer ? framebuffer : self.framebuffer;
+    self.realBindFramebuffer.call(gl, target, self.lastBoundFramebuffer);
+  };
+  this.cullFace = gl.getParameter(gl.CULL_FACE);
+  this.depthTest = gl.getParameter(gl.DEPTH_TEST);
+  this.blend = gl.getParameter(gl.BLEND);
+  this.scissorTest = gl.getParameter(gl.SCISSOR_TEST);
+  this.stencilTest = gl.getParameter(gl.STENCIL_TEST);
+  gl.enable = function (pname) {
+    switch (pname) {
+      case gl.CULL_FACE:
+        self.cullFace = true;break;
+      case gl.DEPTH_TEST:
+        self.depthTest = true;break;
+      case gl.BLEND:
+        self.blend = true;break;
+      case gl.SCISSOR_TEST:
+        self.scissorTest = true;break;
+      case gl.STENCIL_TEST:
+        self.stencilTest = true;break;
+    }
+    self.realEnable.call(gl, pname);
+  };
+  gl.disable = function (pname) {
+    switch (pname) {
+      case gl.CULL_FACE:
+        self.cullFace = false;break;
+      case gl.DEPTH_TEST:
+        self.depthTest = false;break;
+      case gl.BLEND:
+        self.blend = false;break;
+      case gl.SCISSOR_TEST:
+        self.scissorTest = false;break;
+      case gl.STENCIL_TEST:
+        self.stencilTest = false;break;
+    }
+    self.realDisable.call(gl, pname);
+  };
+  this.colorMask = gl.getParameter(gl.COLOR_WRITEMASK);
+  gl.colorMask = function (r, g, b, a) {
+    self.colorMask[0] = r;
+    self.colorMask[1] = g;
+    self.colorMask[2] = b;
+    self.colorMask[3] = a;
+    self.realColorMask.call(gl, r, g, b, a);
+  };
+  this.clearColor = gl.getParameter(gl.COLOR_CLEAR_VALUE);
+  gl.clearColor = function (r, g, b, a) {
+    self.clearColor[0] = r;
+    self.clearColor[1] = g;
+    self.clearColor[2] = b;
+    self.clearColor[3] = a;
+    self.realClearColor.call(gl, r, g, b, a);
+  };
+  this.viewport = gl.getParameter(gl.VIEWPORT);
+  gl.viewport = function (x, y, w, h) {
+    self.viewport[0] = x;
+    self.viewport[1] = y;
+    self.viewport[2] = w;
+    self.viewport[3] = h;
+    self.realViewport.call(gl, x, y, w, h);
+  };
+  this.isPatched = true;
+  safariCssSizeWorkaround(canvas);
+};
+CardboardDistorter.prototype.unpatch = function () {
+  if (!this.isPatched) {
+    return;
+  }
+  var gl = this.gl;
+  var canvas = this.gl.canvas;
+  if (!isIOS()) {
+    Object.defineProperty(canvas, 'width', this.realCanvasWidth);
+    Object.defineProperty(canvas, 'height', this.realCanvasHeight);
+  }
+  canvas.width = this.bufferWidth;
+  canvas.height = this.bufferHeight;
+  gl.bindFramebuffer = this.realBindFramebuffer;
+  gl.enable = this.realEnable;
+  gl.disable = this.realDisable;
+  gl.colorMask = this.realColorMask;
+  gl.clearColor = this.realClearColor;
+  gl.viewport = this.realViewport;
+  if (this.lastBoundFramebuffer == this.framebuffer) {
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+  }
+  this.isPatched = false;
+  setTimeout(function () {
+    safariCssSizeWorkaround(canvas);
+  }, 1);
+};
+CardboardDistorter.prototype.setTextureBounds = function (leftBounds, rightBounds) {
+  if (!leftBounds) {
+    leftBounds = [0, 0, 0.5, 1];
+  }
+  if (!rightBounds) {
+    rightBounds = [0.5, 0, 0.5, 1];
+  }
+  this.viewportOffsetScale[0] = leftBounds[0];
+  this.viewportOffsetScale[1] = leftBounds[1];
+  this.viewportOffsetScale[2] = leftBounds[2];
+  this.viewportOffsetScale[3] = leftBounds[3];
+  this.viewportOffsetScale[4] = rightBounds[0];
+  this.viewportOffsetScale[5] = rightBounds[1];
+  this.viewportOffsetScale[6] = rightBounds[2];
+  this.viewportOffsetScale[7] = rightBounds[3];
+};
+CardboardDistorter.prototype.submitFrame = function () {
+  var gl = this.gl;
+  var self = this;
+  var glState = [];
+  if (!this.dirtySubmitFrameBindings) {
+    glState.push(gl.CURRENT_PROGRAM, gl.ARRAY_BUFFER_BINDING, gl.ELEMENT_ARRAY_BUFFER_BINDING, gl.TEXTURE_BINDING_2D, gl.TEXTURE0);
+  }
+  glPreserveState(gl, glState, function (gl) {
+    self.realBindFramebuffer.call(gl, gl.FRAMEBUFFER, null);
+    if (self.cullFace) {
+      self.realDisable.call(gl, gl.CULL_FACE);
+    }
+    if (self.depthTest) {
+      self.realDisable.call(gl, gl.DEPTH_TEST);
+    }
+    if (self.blend) {
+      self.realDisable.call(gl, gl.BLEND);
+    }
+    if (self.scissorTest) {
+      self.realDisable.call(gl, gl.SCISSOR_TEST);
+    }
+    if (self.stencilTest) {
+      self.realDisable.call(gl, gl.STENCIL_TEST);
+    }
+    self.realColorMask.call(gl, true, true, true, true);
+    self.realViewport.call(gl, 0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
+    if (self.ctxAttribs.alpha || isIOS()) {
+      self.realClearColor.call(gl, 0, 0, 0, 1);
+      gl.clear(gl.COLOR_BUFFER_BIT);
+    }
+    gl.useProgram(self.program);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, self.indexBuffer);
+    gl.bindBuffer(gl.ARRAY_BUFFER, self.vertexBuffer);
+    gl.enableVertexAttribArray(self.attribs.position);
+    gl.enableVertexAttribArray(self.attribs.texCoord);
+    gl.vertexAttribPointer(self.attribs.position, 2, gl.FLOAT, false, 20, 0);
+    gl.vertexAttribPointer(self.attribs.texCoord, 3, gl.FLOAT, false, 20, 8);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.uniform1i(self.uniforms.diffuse, 0);
+    gl.bindTexture(gl.TEXTURE_2D, self.renderTarget);
+    gl.uniform4fv(self.uniforms.viewportOffsetScale, self.viewportOffsetScale);
+    gl.drawElements(gl.TRIANGLES, self.indexCount, gl.UNSIGNED_SHORT, 0);
+    if (self.cardboardUI) {
+      self.cardboardUI.renderNoState();
+    }
+    self.realBindFramebuffer.call(self.gl, gl.FRAMEBUFFER, self.framebuffer);
+    if (!self.ctxAttribs.preserveDrawingBuffer) {
+      self.realClearColor.call(gl, 0, 0, 0, 0);
+      gl.clear(gl.COLOR_BUFFER_BIT);
+    }
+    if (!self.dirtySubmitFrameBindings) {
+      self.realBindFramebuffer.call(gl, gl.FRAMEBUFFER, self.lastBoundFramebuffer);
+    }
+    if (self.cullFace) {
+      self.realEnable.call(gl, gl.CULL_FACE);
+    }
+    if (self.depthTest) {
+      self.realEnable.call(gl, gl.DEPTH_TEST);
+    }
+    if (self.blend) {
+      self.realEnable.call(gl, gl.BLEND);
+    }
+    if (self.scissorTest) {
+      self.realEnable.call(gl, gl.SCISSOR_TEST);
+    }
+    if (self.stencilTest) {
+      self.realEnable.call(gl, gl.STENCIL_TEST);
+    }
+    self.realColorMask.apply(gl, self.colorMask);
+    self.realViewport.apply(gl, self.viewport);
+    if (self.ctxAttribs.alpha || !self.ctxAttribs.preserveDrawingBuffer) {
+      self.realClearColor.apply(gl, self.clearColor);
+    }
+  });
+  if (isIOS()) {
+    var canvas = gl.canvas;
+    if (canvas.width != self.bufferWidth || canvas.height != self.bufferHeight) {
+      self.bufferWidth = canvas.width;
+      self.bufferHeight = canvas.height;
+      self.onResize();
+    }
+  }
+};
+CardboardDistorter.prototype.updateDeviceInfo = function (deviceInfo) {
+  var gl = this.gl;
+  var self = this;
+  var glState = [gl.ARRAY_BUFFER_BINDING, gl.ELEMENT_ARRAY_BUFFER_BINDING];
+  glPreserveState(gl, glState, function (gl) {
+    var vertices = self.computeMeshVertices_(self.meshWidth, self.meshHeight, deviceInfo);
+    gl.bindBuffer(gl.ARRAY_BUFFER, self.vertexBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
+    if (!self.indexCount) {
+      var indices = self.computeMeshIndices_(self.meshWidth, self.meshHeight);
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, self.indexBuffer);
+      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices, gl.STATIC_DRAW);
+      self.indexCount = indices.length;
+    }
+  });
+};
+CardboardDistorter.prototype.computeMeshVertices_ = function (width, height, deviceInfo) {
+  var vertices = new Float32Array(2 * width * height * 5);
+  var lensFrustum = deviceInfo.getLeftEyeVisibleTanAngles();
+  var noLensFrustum = deviceInfo.getLeftEyeNoLensTanAngles();
+  var viewport = deviceInfo.getLeftEyeVisibleScreenRect(noLensFrustum);
+  var vidx = 0;
+  for (var e = 0; e < 2; e++) {
+    for (var j = 0; j < height; j++) {
+      for (var i = 0; i < width; i++, vidx++) {
+        var u = i / (width - 1);
+        var v = j / (height - 1);
+        var s = u;
+        var t = v;
+        var x = lerp(lensFrustum[0], lensFrustum[2], u);
+        var y = lerp(lensFrustum[3], lensFrustum[1], v);
+        var d = Math.sqrt(x * x + y * y);
+        var r = deviceInfo.distortion.distortInverse(d);
+        var p = x * r / d;
+        var q = y * r / d;
+        u = (p - noLensFrustum[0]) / (noLensFrustum[2] - noLensFrustum[0]);
+        v = (q - noLensFrustum[3]) / (noLensFrustum[1] - noLensFrustum[3]);
+        u = (viewport.x + u * viewport.width - 0.5) * 2.0;
+        v = (viewport.y + v * viewport.height - 0.5) * 2.0;
+        vertices[vidx * 5 + 0] = u;
+        vertices[vidx * 5 + 1] = v;
+        vertices[vidx * 5 + 2] = s;
+        vertices[vidx * 5 + 3] = t;
+        vertices[vidx * 5 + 4] = e;
+      }
+    }
+    var w = lensFrustum[2] - lensFrustum[0];
+    lensFrustum[0] = -(w + lensFrustum[0]);
+    lensFrustum[2] = w - lensFrustum[2];
+    w = noLensFrustum[2] - noLensFrustum[0];
+    noLensFrustum[0] = -(w + noLensFrustum[0]);
+    noLensFrustum[2] = w - noLensFrustum[2];
+    viewport.x = 1 - (viewport.x + viewport.width);
+  }
+  return vertices;
+};
+CardboardDistorter.prototype.computeMeshIndices_ = function (width, height) {
+  var indices = new Uint16Array(2 * (width - 1) * (height - 1) * 6);
+  var halfwidth = width / 2;
+  var halfheight = height / 2;
+  var vidx = 0;
+  var iidx = 0;
+  for (var e = 0; e < 2; e++) {
+    for (var j = 0; j < height; j++) {
+      for (var i = 0; i < width; i++, vidx++) {
+        if (i == 0 || j == 0) continue;
+        if (i <= halfwidth == j <= halfheight) {
+          indices[iidx++] = vidx;
+          indices[iidx++] = vidx - width - 1;
+          indices[iidx++] = vidx - width;
+          indices[iidx++] = vidx - width - 1;
+          indices[iidx++] = vidx;
+          indices[iidx++] = vidx - 1;
+        } else {
+          indices[iidx++] = vidx - 1;
+          indices[iidx++] = vidx - width;
+          indices[iidx++] = vidx;
+          indices[iidx++] = vidx - width;
+          indices[iidx++] = vidx - 1;
+          indices[iidx++] = vidx - width - 1;
+        }
+      }
+    }
+  }
+  return indices;
+};
+CardboardDistorter.prototype.getOwnPropertyDescriptor_ = function (proto, attrName) {
+  var descriptor = Object.getOwnPropertyDescriptor(proto, attrName);
+  if (descriptor.get === undefined || descriptor.set === undefined) {
+    descriptor.configurable = true;
+    descriptor.enumerable = true;
+    descriptor.get = function () {
+      return this.getAttribute(attrName);
+    };
+    descriptor.set = function (val) {
+      this.setAttribute(attrName, val);
+    };
+  }
+  return descriptor;
+};
+var uiVS = ['attribute vec2 position;', 'uniform mat4 projectionMat;', 'void main() {', '  gl_Position = projectionMat * vec4( position, -1.0, 1.0 );', '}'].join('\n');
+var uiFS = ['precision mediump float;', 'uniform vec4 color;', 'void main() {', '  gl_FragColor = color;', '}'].join('\n');
+var DEG2RAD = Math.PI / 180.0;
+var kAnglePerGearSection = 60;
+var kOuterRimEndAngle = 12;
+var kInnerRimBeginAngle = 20;
+var kOuterRadius = 1;
+var kMiddleRadius = 0.75;
+var kInnerRadius = 0.3125;
+var kCenterLineThicknessDp = 4;
+var kButtonWidthDp = 28;
+var kTouchSlopFactor = 1.5;
+function CardboardUI(gl) {
+  this.gl = gl;
+  this.attribs = {
+    position: 0
+  };
+  this.program = linkProgram(gl, uiVS, uiFS, this.attribs);
+  this.uniforms = getProgramUniforms(gl, this.program);
+  this.vertexBuffer = gl.createBuffer();
+  this.gearOffset = 0;
+  this.gearVertexCount = 0;
+  this.arrowOffset = 0;
+  this.arrowVertexCount = 0;
+  this.projMat = new Float32Array(16);
+  this.listener = null;
+  this.onResize();
+}
+CardboardUI.prototype.destroy = function () {
+  var gl = this.gl;
+  if (this.listener) {
+    gl.canvas.removeEventListener('click', this.listener, false);
+  }
+  gl.deleteProgram(this.program);
+  gl.deleteBuffer(this.vertexBuffer);
+};
+CardboardUI.prototype.listen = function (optionsCallback, backCallback) {
+  var canvas = this.gl.canvas;
+  this.listener = function (event) {
+    var midline = canvas.clientWidth / 2;
+    var buttonSize = kButtonWidthDp * kTouchSlopFactor;
+    if (event.clientX > midline - buttonSize && event.clientX < midline + buttonSize && event.clientY > canvas.clientHeight - buttonSize) {
+      optionsCallback(event);
+    }
+    else if (event.clientX < buttonSize && event.clientY < buttonSize) {
+        backCallback(event);
+      }
+  };
+  canvas.addEventListener('click', this.listener, false);
+};
+CardboardUI.prototype.onResize = function () {
+  var gl = this.gl;
+  var self = this;
+  var glState = [gl.ARRAY_BUFFER_BINDING];
+  glPreserveState(gl, glState, function (gl) {
+    var vertices = [];
+    var midline = gl.drawingBufferWidth / 2;
+    var physicalPixels = Math.max(screen.width, screen.height) * window.devicePixelRatio;
+    var scalingRatio = gl.drawingBufferWidth / physicalPixels;
+    var dps = scalingRatio * window.devicePixelRatio;
+    var lineWidth = kCenterLineThicknessDp * dps / 2;
+    var buttonSize = kButtonWidthDp * kTouchSlopFactor * dps;
+    var buttonScale = kButtonWidthDp * dps / 2;
+    var buttonBorder = (kButtonWidthDp * kTouchSlopFactor - kButtonWidthDp) * dps;
+    vertices.push(midline - lineWidth, buttonSize);
+    vertices.push(midline - lineWidth, gl.drawingBufferHeight);
+    vertices.push(midline + lineWidth, buttonSize);
+    vertices.push(midline + lineWidth, gl.drawingBufferHeight);
+    self.gearOffset = vertices.length / 2;
+    function addGearSegment(theta, r) {
+      var angle = (90 - theta) * DEG2RAD;
+      var x = Math.cos(angle);
+      var y = Math.sin(angle);
+      vertices.push(kInnerRadius * x * buttonScale + midline, kInnerRadius * y * buttonScale + buttonScale);
+      vertices.push(r * x * buttonScale + midline, r * y * buttonScale + buttonScale);
+    }
+    for (var i = 0; i <= 6; i++) {
+      var segmentTheta = i * kAnglePerGearSection;
+      addGearSegment(segmentTheta, kOuterRadius);
+      addGearSegment(segmentTheta + kOuterRimEndAngle, kOuterRadius);
+      addGearSegment(segmentTheta + kInnerRimBeginAngle, kMiddleRadius);
+      addGearSegment(segmentTheta + (kAnglePerGearSection - kInnerRimBeginAngle), kMiddleRadius);
+      addGearSegment(segmentTheta + (kAnglePerGearSection - kOuterRimEndAngle), kOuterRadius);
+    }
+    self.gearVertexCount = vertices.length / 2 - self.gearOffset;
+    self.arrowOffset = vertices.length / 2;
+    function addArrowVertex(x, y) {
+      vertices.push(buttonBorder + x, gl.drawingBufferHeight - buttonBorder - y);
+    }
+    var angledLineWidth = lineWidth / Math.sin(45 * DEG2RAD);
+    addArrowVertex(0, buttonScale);
+    addArrowVertex(buttonScale, 0);
+    addArrowVertex(buttonScale + angledLineWidth, angledLineWidth);
+    addArrowVertex(angledLineWidth, buttonScale + angledLineWidth);
+    addArrowVertex(angledLineWidth, buttonScale - angledLineWidth);
+    addArrowVertex(0, buttonScale);
+    addArrowVertex(buttonScale, buttonScale * 2);
+    addArrowVertex(buttonScale + angledLineWidth, buttonScale * 2 - angledLineWidth);
+    addArrowVertex(angledLineWidth, buttonScale - angledLineWidth);
+    addArrowVertex(0, buttonScale);
+    addArrowVertex(angledLineWidth, buttonScale - lineWidth);
+    addArrowVertex(kButtonWidthDp * dps, buttonScale - lineWidth);
+    addArrowVertex(angledLineWidth, buttonScale + lineWidth);
+    addArrowVertex(kButtonWidthDp * dps, buttonScale + lineWidth);
+    self.arrowVertexCount = vertices.length / 2 - self.arrowOffset;
+    gl.bindBuffer(gl.ARRAY_BUFFER, self.vertexBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);
+  });
+};
+CardboardUI.prototype.render = function () {
+  var gl = this.gl;
+  var self = this;
+  var glState = [gl.CULL_FACE, gl.DEPTH_TEST, gl.BLEND, gl.SCISSOR_TEST, gl.STENCIL_TEST, gl.COLOR_WRITEMASK, gl.VIEWPORT, gl.CURRENT_PROGRAM, gl.ARRAY_BUFFER_BINDING];
+  glPreserveState(gl, glState, function (gl) {
+    gl.disable(gl.CULL_FACE);
+    gl.disable(gl.DEPTH_TEST);
+    gl.disable(gl.BLEND);
+    gl.disable(gl.SCISSOR_TEST);
+    gl.disable(gl.STENCIL_TEST);
+    gl.colorMask(true, true, true, true);
+    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
+    self.renderNoState();
+  });
+};
+CardboardUI.prototype.renderNoState = function () {
+  var gl = this.gl;
+  gl.useProgram(this.program);
+  gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
+  gl.enableVertexAttribArray(this.attribs.position);
+  gl.vertexAttribPointer(this.attribs.position, 2, gl.FLOAT, false, 8, 0);
+  gl.uniform4f(this.uniforms.color, 1.0, 1.0, 1.0, 1.0);
+  orthoMatrix(this.projMat, 0, gl.drawingBufferWidth, 0, gl.drawingBufferHeight, 0.1, 1024.0);
+  gl.uniformMatrix4fv(this.uniforms.projectionMat, false, this.projMat);
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  gl.drawArrays(gl.TRIANGLE_STRIP, this.gearOffset, this.gearVertexCount);
+  gl.drawArrays(gl.TRIANGLE_STRIP, this.arrowOffset, this.arrowVertexCount);
+};
+function Distortion(coefficients) {
+  this.coefficients = coefficients;
+}
+Distortion.prototype.distortInverse = function (radius) {
+  var r0 = 0;
+  var r1 = 1;
+  var dr0 = radius - this.distort(r0);
+  while (Math.abs(r1 - r0) > 0.0001             ) {
+    var dr1 = radius - this.distort(r1);
+    var r2 = r1 - dr1 * ((r1 - r0) / (dr1 - dr0));
+    r0 = r1;
+    r1 = r2;
+    dr0 = dr1;
+  }
+  return r1;
+};
+Distortion.prototype.distort = function (radius) {
+  var r2 = radius * radius;
+  var ret = 0;
+  for (var i = 0; i < this.coefficients.length; i++) {
+    ret = r2 * (ret + this.coefficients[i]);
+  }
+  return (ret + 1) * radius;
+};
+var degToRad = Math.PI / 180;
+var radToDeg = 180 / Math.PI;
+var Vector3 = function Vector3(x, y, z) {
+  this.x = x || 0;
+  this.y = y || 0;
+  this.z = z || 0;
+};
+Vector3.prototype = {
+  constructor: Vector3,
+  set: function set(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    return this;
+  },
+  copy: function copy(v) {
+    this.x = v.x;
+    this.y = v.y;
+    this.z = v.z;
+    return this;
+  },
+  length: function length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  },
+  normalize: function normalize() {
+    var scalar = this.length();
+    if (scalar !== 0) {
+      var invScalar = 1 / scalar;
+      this.multiplyScalar(invScalar);
+    } else {
+      this.x = 0;
+      this.y = 0;
+      this.z = 0;
+    }
+    return this;
+  },
+  multiplyScalar: function multiplyScalar(scalar) {
+    this.x *= scalar;
+    this.y *= scalar;
+    this.z *= scalar;
+  },
+  applyQuaternion: function applyQuaternion(q) {
+    var x = this.x;
+    var y = this.y;
+    var z = this.z;
+    var qx = q.x;
+    var qy = q.y;
+    var qz = q.z;
+    var qw = q.w;
+    var ix = qw * x + qy * z - qz * y;
+    var iy = qw * y + qz * x - qx * z;
+    var iz = qw * z + qx * y - qy * x;
+    var iw = -qx * x - qy * y - qz * z;
+    this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+    this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+    this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+    return this;
+  },
+  dot: function dot(v) {
+    return this.x * v.x + this.y * v.y + this.z * v.z;
+  },
+  crossVectors: function crossVectors(a, b) {
+    var ax = a.x,
+        ay = a.y,
+        az = a.z;
+    var bx = b.x,
+        by = b.y,
+        bz = b.z;
+    this.x = ay * bz - az * by;
+    this.y = az * bx - ax * bz;
+    this.z = ax * by - ay * bx;
+    return this;
+  }
+};
+var Quaternion = function Quaternion(x, y, z, w) {
+  this.x = x || 0;
+  this.y = y || 0;
+  this.z = z || 0;
+  this.w = w !== undefined ? w : 1;
+};
+Quaternion.prototype = {
+  constructor: Quaternion,
+  set: function set(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+    return this;
+  },
+  copy: function copy(quaternion) {
+    this.x = quaternion.x;
+    this.y = quaternion.y;
+    this.z = quaternion.z;
+    this.w = quaternion.w;
+    return this;
+  },
+  setFromEulerXYZ: function setFromEulerXYZ(x, y, z) {
+    var c1 = Math.cos(x / 2);
+    var c2 = Math.cos(y / 2);
+    var c3 = Math.cos(z / 2);
+    var s1 = Math.sin(x / 2);
+    var s2 = Math.sin(y / 2);
+    var s3 = Math.sin(z / 2);
+    this.x = s1 * c2 * c3 + c1 * s2 * s3;
+    this.y = c1 * s2 * c3 - s1 * c2 * s3;
+    this.z = c1 * c2 * s3 + s1 * s2 * c3;
+    this.w = c1 * c2 * c3 - s1 * s2 * s3;
+    return this;
+  },
+  setFromEulerYXZ: function setFromEulerYXZ(x, y, z) {
+    var c1 = Math.cos(x / 2);
+    var c2 = Math.cos(y / 2);
+    var c3 = Math.cos(z / 2);
+    var s1 = Math.sin(x / 2);
+    var s2 = Math.sin(y / 2);
+    var s3 = Math.sin(z / 2);
+    this.x = s1 * c2 * c3 + c1 * s2 * s3;
+    this.y = c1 * s2 * c3 - s1 * c2 * s3;
+    this.z = c1 * c2 * s3 - s1 * s2 * c3;
+    this.w = c1 * c2 * c3 + s1 * s2 * s3;
+    return this;
+  },
+  setFromAxisAngle: function setFromAxisAngle(axis, angle) {
+    var halfAngle = angle / 2,
+        s = Math.sin(halfAngle);
+    this.x = axis.x * s;
+    this.y = axis.y * s;
+    this.z = axis.z * s;
+    this.w = Math.cos(halfAngle);
+    return this;
+  },
+  multiply: function multiply(q) {
+    return this.multiplyQuaternions(this, q);
+  },
+  multiplyQuaternions: function multiplyQuaternions(a, b) {
+    var qax = a.x,
+        qay = a.y,
+        qaz = a.z,
+        qaw = a.w;
+    var qbx = b.x,
+        qby = b.y,
+        qbz = b.z,
+        qbw = b.w;
+    this.x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
+    this.y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
+    this.z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
+    this.w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
+    return this;
+  },
+  inverse: function inverse() {
+    this.x *= -1;
+    this.y *= -1;
+    this.z *= -1;
+    this.normalize();
+    return this;
+  },
+  normalize: function normalize() {
+    var l = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+    if (l === 0) {
+      this.x = 0;
+      this.y = 0;
+      this.z = 0;
+      this.w = 1;
+    } else {
+      l = 1 / l;
+      this.x = this.x * l;
+      this.y = this.y * l;
+      this.z = this.z * l;
+      this.w = this.w * l;
+    }
+    return this;
+  },
+  slerp: function slerp(qb, t) {
+    if (t === 0) return this;
+    if (t === 1) return this.copy(qb);
+    var x = this.x,
+        y = this.y,
+        z = this.z,
+        w = this.w;
+    var cosHalfTheta = w * qb.w + x * qb.x + y * qb.y + z * qb.z;
+    if (cosHalfTheta < 0) {
+      this.w = -qb.w;
+      this.x = -qb.x;
+      this.y = -qb.y;
+      this.z = -qb.z;
+      cosHalfTheta = -cosHalfTheta;
+    } else {
+      this.copy(qb);
+    }
+    if (cosHalfTheta >= 1.0) {
+      this.w = w;
+      this.x = x;
+      this.y = y;
+      this.z = z;
+      return this;
+    }
+    var halfTheta = Math.acos(cosHalfTheta);
+    var sinHalfTheta = Math.sqrt(1.0 - cosHalfTheta * cosHalfTheta);
+    if (Math.abs(sinHalfTheta) < 0.001) {
+      this.w = 0.5 * (w + this.w);
+      this.x = 0.5 * (x + this.x);
+      this.y = 0.5 * (y + this.y);
+      this.z = 0.5 * (z + this.z);
+      return this;
+    }
+    var ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta,
+        ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+    this.w = w * ratioA + this.w * ratioB;
+    this.x = x * ratioA + this.x * ratioB;
+    this.y = y * ratioA + this.y * ratioB;
+    this.z = z * ratioA + this.z * ratioB;
+    return this;
+  },
+  setFromUnitVectors: function () {
+    var v1, r;
+    var EPS = 0.000001;
+    return function (vFrom, vTo) {
+      if (v1 === undefined) v1 = new Vector3();
+      r = vFrom.dot(vTo) + 1;
+      if (r < EPS) {
+        r = 0;
+        if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
+          v1.set(-vFrom.y, vFrom.x, 0);
+        } else {
+          v1.set(0, -vFrom.z, vFrom.y);
+        }
+      } else {
+        v1.crossVectors(vFrom, vTo);
+      }
+      this.x = v1.x;
+      this.y = v1.y;
+      this.z = v1.z;
+      this.w = r;
+      this.normalize();
+      return this;
+    };
+  }()
+};
+function Device(params) {
+  this.width = params.width || getScreenWidth();
+  this.height = params.height || getScreenHeight();
+  this.widthMeters = params.widthMeters;
+  this.heightMeters = params.heightMeters;
+  this.bevelMeters = params.bevelMeters;
+}
+var DEFAULT_ANDROID = new Device({
+  widthMeters: 0.110,
+  heightMeters: 0.062,
+  bevelMeters: 0.004
+});
+var DEFAULT_IOS = new Device({
+  widthMeters: 0.1038,
+  heightMeters: 0.0584,
+  bevelMeters: 0.004
+});
+var Viewers = {
+  CardboardV1: new CardboardViewer({
+    id: 'CardboardV1',
+    label: 'Cardboard I/O 2014',
+    fov: 40,
+    interLensDistance: 0.060,
+    baselineLensDistance: 0.035,
+    screenLensDistance: 0.042,
+    distortionCoefficients: [0.441, 0.156],
+    inverseCoefficients: [-0.4410035, 0.42756155, -0.4804439, 0.5460139, -0.58821183, 0.5733938, -0.48303202, 0.33299083, -0.17573841, 0.0651772, -0.01488963, 0.001559834]
+  }),
+  CardboardV2: new CardboardViewer({
+    id: 'CardboardV2',
+    label: 'Cardboard I/O 2015',
+    fov: 60,
+    interLensDistance: 0.064,
+    baselineLensDistance: 0.035,
+    screenLensDistance: 0.039,
+    distortionCoefficients: [0.34, 0.55],
+    inverseCoefficients: [-0.33836704, -0.18162185, 0.862655, -1.2462051, 1.0560602, -0.58208317, 0.21609078, -0.05444823, 0.009177956, -9.904169E-4, 6.183535E-5, -1.6981803E-6]
+  })
+};
+function DeviceInfo(deviceParams, additionalViewers) {
+  this.viewer = Viewers.CardboardV2;
+  this.updateDeviceParams(deviceParams);
+  this.distortion = new Distortion(this.viewer.distortionCoefficients);
+  for (var i = 0; i < additionalViewers.length; i++) {
+    var viewer = additionalViewers[i];
+    Viewers[viewer.id] = new CardboardViewer(viewer);
+  }
+}
+DeviceInfo.prototype.updateDeviceParams = function (deviceParams) {
+  this.device = this.determineDevice_(deviceParams) || this.device;
+};
+DeviceInfo.prototype.getDevice = function () {
+  return this.device;
+};
+DeviceInfo.prototype.setViewer = function (viewer) {
+  this.viewer = viewer;
+  this.distortion = new Distortion(this.viewer.distortionCoefficients);
+};
+DeviceInfo.prototype.determineDevice_ = function (deviceParams) {
+  if (!deviceParams) {
+    if (isIOS()) {
+      console.warn('Using fallback iOS device measurements.');
+      return DEFAULT_IOS;
+    } else {
+      console.warn('Using fallback Android device measurements.');
+      return DEFAULT_ANDROID;
+    }
+  }
+  var METERS_PER_INCH = 0.0254;
+  var metersPerPixelX = METERS_PER_INCH / deviceParams.xdpi;
+  var metersPerPixelY = METERS_PER_INCH / deviceParams.ydpi;
+  var width = getScreenWidth();
+  var height = getScreenHeight();
+  return new Device({
+    widthMeters: metersPerPixelX * width,
+    heightMeters: metersPerPixelY * height,
+    bevelMeters: deviceParams.bevelMm * 0.001
+  });
+};
+DeviceInfo.prototype.getDistortedFieldOfViewLeftEye = function () {
+  var viewer = this.viewer;
+  var device = this.device;
+  var distortion = this.distortion;
+  var eyeToScreenDistance = viewer.screenLensDistance;
+  var outerDist = (device.widthMeters - viewer.interLensDistance) / 2;
+  var innerDist = viewer.interLensDistance / 2;
+  var bottomDist = viewer.baselineLensDistance - device.bevelMeters;
+  var topDist = device.heightMeters - bottomDist;
+  var outerAngle = radToDeg * Math.atan(distortion.distort(outerDist / eyeToScreenDistance));
+  var innerAngle = radToDeg * Math.atan(distortion.distort(innerDist / eyeToScreenDistance));
+  var bottomAngle = radToDeg * Math.atan(distortion.distort(bottomDist / eyeToScreenDistance));
+  var topAngle = radToDeg * Math.atan(distortion.distort(topDist / eyeToScreenDistance));
+  return {
+    leftDegrees: Math.min(outerAngle, viewer.fov),
+    rightDegrees: Math.min(innerAngle, viewer.fov),
+    downDegrees: Math.min(bottomAngle, viewer.fov),
+    upDegrees: Math.min(topAngle, viewer.fov)
+  };
+};
+DeviceInfo.prototype.getLeftEyeVisibleTanAngles = function () {
+  var viewer = this.viewer;
+  var device = this.device;
+  var distortion = this.distortion;
+  var fovLeft = Math.tan(-degToRad * viewer.fov);
+  var fovTop = Math.tan(degToRad * viewer.fov);
+  var fovRight = Math.tan(degToRad * viewer.fov);
+  var fovBottom = Math.tan(-degToRad * viewer.fov);
+  var halfWidth = device.widthMeters / 4;
+  var halfHeight = device.heightMeters / 2;
+  var verticalLensOffset = viewer.baselineLensDistance - device.bevelMeters - halfHeight;
+  var centerX = viewer.interLensDistance / 2 - halfWidth;
+  var centerY = -verticalLensOffset;
+  var centerZ = viewer.screenLensDistance;
+  var screenLeft = distortion.distort((centerX - halfWidth) / centerZ);
+  var screenTop = distortion.distort((centerY + halfHeight) / centerZ);
+  var screenRight = distortion.distort((centerX + halfWidth) / centerZ);
+  var screenBottom = distortion.distort((centerY - halfHeight) / centerZ);
+  var result = new Float32Array(4);
+  result[0] = Math.max(fovLeft, screenLeft);
+  result[1] = Math.min(fovTop, screenTop);
+  result[2] = Math.min(fovRight, screenRight);
+  result[3] = Math.max(fovBottom, screenBottom);
+  return result;
+};
+DeviceInfo.prototype.getLeftEyeNoLensTanAngles = function () {
+  var viewer = this.viewer;
+  var device = this.device;
+  var distortion = this.distortion;
+  var result = new Float32Array(4);
+  var fovLeft = distortion.distortInverse(Math.tan(-degToRad * viewer.fov));
+  var fovTop = distortion.distortInverse(Math.tan(degToRad * viewer.fov));
+  var fovRight = distortion.distortInverse(Math.tan(degToRad * viewer.fov));
+  var fovBottom = distortion.distortInverse(Math.tan(-degToRad * viewer.fov));
+  var halfWidth = device.widthMeters / 4;
+  var halfHeight = device.heightMeters / 2;
+  var verticalLensOffset = viewer.baselineLensDistance - device.bevelMeters - halfHeight;
+  var centerX = viewer.interLensDistance / 2 - halfWidth;
+  var centerY = -verticalLensOffset;
+  var centerZ = viewer.screenLensDistance;
+  var screenLeft = (centerX - halfWidth) / centerZ;
+  var screenTop = (centerY + halfHeight) / centerZ;
+  var screenRight = (centerX + halfWidth) / centerZ;
+  var screenBottom = (centerY - halfHeight) / centerZ;
+  result[0] = Math.max(fovLeft, screenLeft);
+  result[1] = Math.min(fovTop, screenTop);
+  result[2] = Math.min(fovRight, screenRight);
+  result[3] = Math.max(fovBottom, screenBottom);
+  return result;
+};
+DeviceInfo.prototype.getLeftEyeVisibleScreenRect = function (undistortedFrustum) {
+  var viewer = this.viewer;
+  var device = this.device;
+  var dist = viewer.screenLensDistance;
+  var eyeX = (device.widthMeters - viewer.interLensDistance) / 2;
+  var eyeY = viewer.baselineLensDistance - device.bevelMeters;
+  var left = (undistortedFrustum[0] * dist + eyeX) / device.widthMeters;
+  var top = (undistortedFrustum[1] * dist + eyeY) / device.heightMeters;
+  var right = (undistortedFrustum[2] * dist + eyeX) / device.widthMeters;
+  var bottom = (undistortedFrustum[3] * dist + eyeY) / device.heightMeters;
+  return {
+    x: left,
+    y: bottom,
+    width: right - left,
+    height: top - bottom
+  };
+};
+DeviceInfo.prototype.getFieldOfViewLeftEye = function (opt_isUndistorted) {
+  return opt_isUndistorted ? this.getUndistortedFieldOfViewLeftEye() : this.getDistortedFieldOfViewLeftEye();
+};
+DeviceInfo.prototype.getFieldOfViewRightEye = function (opt_isUndistorted) {
+  var fov = this.getFieldOfViewLeftEye(opt_isUndistorted);
+  return {
+    leftDegrees: fov.rightDegrees,
+    rightDegrees: fov.leftDegrees,
+    upDegrees: fov.upDegrees,
+    downDegrees: fov.downDegrees
+  };
+};
+DeviceInfo.prototype.getUndistortedFieldOfViewLeftEye = function () {
+  var p = this.getUndistortedParams_();
+  return {
+    leftDegrees: radToDeg * Math.atan(p.outerDist),
+    rightDegrees: radToDeg * Math.atan(p.innerDist),
+    downDegrees: radToDeg * Math.atan(p.bottomDist),
+    upDegrees: radToDeg * Math.atan(p.topDist)
+  };
+};
+DeviceInfo.prototype.getUndistortedViewportLeftEye = function () {
+  var p = this.getUndistortedParams_();
+  var viewer = this.viewer;
+  var device = this.device;
+  var eyeToScreenDistance = viewer.screenLensDistance;
+  var screenWidth = device.widthMeters / eyeToScreenDistance;
+  var screenHeight = device.heightMeters / eyeToScreenDistance;
+  var xPxPerTanAngle = device.width / screenWidth;
+  var yPxPerTanAngle = device.height / screenHeight;
+  var x = Math.round((p.eyePosX - p.outerDist) * xPxPerTanAngle);
+  var y = Math.round((p.eyePosY - p.bottomDist) * yPxPerTanAngle);
+  return {
+    x: x,
+    y: y,
+    width: Math.round((p.eyePosX + p.innerDist) * xPxPerTanAngle) - x,
+    height: Math.round((p.eyePosY + p.topDist) * yPxPerTanAngle) - y
+  };
+};
+DeviceInfo.prototype.getUndistortedParams_ = function () {
+  var viewer = this.viewer;
+  var device = this.device;
+  var distortion = this.distortion;
+  var eyeToScreenDistance = viewer.screenLensDistance;
+  var halfLensDistance = viewer.interLensDistance / 2 / eyeToScreenDistance;
+  var screenWidth = device.widthMeters / eyeToScreenDistance;
+  var screenHeight = device.heightMeters / eyeToScreenDistance;
+  var eyePosX = screenWidth / 2 - halfLensDistance;
+  var eyePosY = (viewer.baselineLensDistance - device.bevelMeters) / eyeToScreenDistance;
+  var maxFov = viewer.fov;
+  var viewerMax = distortion.distortInverse(Math.tan(degToRad * maxFov));
+  var outerDist = Math.min(eyePosX, viewerMax);
+  var innerDist = Math.min(halfLensDistance, viewerMax);
+  var bottomDist = Math.min(eyePosY, viewerMax);
+  var topDist = Math.min(screenHeight - eyePosY, viewerMax);
+  return {
+    outerDist: outerDist,
+    innerDist: innerDist,
+    topDist: topDist,
+    bottomDist: bottomDist,
+    eyePosX: eyePosX,
+    eyePosY: eyePosY
+  };
+};
+function CardboardViewer(params) {
+  this.id = params.id;
+  this.label = params.label;
+  this.fov = params.fov;
+  this.interLensDistance = params.interLensDistance;
+  this.baselineLensDistance = params.baselineLensDistance;
+  this.screenLensDistance = params.screenLensDistance;
+  this.distortionCoefficients = params.distortionCoefficients;
+  this.inverseCoefficients = params.inverseCoefficients;
+}
+DeviceInfo.Viewers = Viewers;
+var format = 1;
+var last_updated = "2018-12-10T17:01:42Z";
+var devices = [{"type":"android","rules":[{"mdmh":"asus/*/Nexus 7/*"},{"ua":"Nexus 7"}],"dpi":[320.8,323],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"asus/*/ASUS_Z00AD/*"},{"ua":"ASUS_Z00AD"}],"dpi":[403,404.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Google/*/Pixel 2 XL/*"},{"ua":"Pixel 2 XL"}],"dpi":537.9,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Google/*/Pixel 3 XL/*"},{"ua":"Pixel 3 XL"}],"dpi":[558.5,553.8],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Google/*/Pixel XL/*"},{"ua":"Pixel XL"}],"dpi":[537.9,533],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Google/*/Pixel 3/*"},{"ua":"Pixel 3"}],"dpi":442.4,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Google/*/Pixel 2/*"},{"ua":"Pixel 2"}],"dpi":441,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"Google/*/Pixel/*"},{"ua":"Pixel"}],"dpi":[432.6,436.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"HTC/*/HTC6435LVW/*"},{"ua":"HTC6435LVW"}],"dpi":[449.7,443.3],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"HTC/*/HTC One XL/*"},{"ua":"HTC One XL"}],"dpi":[315.3,314.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"htc/*/Nexus 9/*"},{"ua":"Nexus 9"}],"dpi":289,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"HTC/*/HTC One M9/*"},{"ua":"HTC One M9"}],"dpi":[442.5,443.3],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"HTC/*/HTC One_M8/*"},{"ua":"HTC One_M8"}],"dpi":[449.7,447.4],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"HTC/*/HTC One/*"},{"ua":"HTC One"}],"dpi":472.8,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Huawei/*/Nexus 6P/*"},{"ua":"Nexus 6P"}],"dpi":[515.1,518],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Huawei/*/BLN-L24/*"},{"ua":"HONORBLN-L24"}],"dpi":480,"bw":4,"ac":500},{"type":"android","rules":[{"mdmh":"Huawei/*/BKL-L09/*"},{"ua":"BKL-L09"}],"dpi":403,"bw":3.47,"ac":500},{"type":"android","rules":[{"mdmh":"LENOVO/*/Lenovo PB2-690Y/*"},{"ua":"Lenovo PB2-690Y"}],"dpi":[457.2,454.713],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"LGE/*/Nexus 5X/*"},{"ua":"Nexus 5X"}],"dpi":[422,419.9],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/LGMS345/*"},{"ua":"LGMS345"}],"dpi":[221.7,219.1],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"LGE/*/LG-D800/*"},{"ua":"LG-D800"}],"dpi":[422,424.1],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"LGE/*/LG-D850/*"},{"ua":"LG-D850"}],"dpi":[537.9,541.9],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"LGE/*/VS985 4G/*"},{"ua":"VS985 4G"}],"dpi":[537.9,535.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/Nexus 5/*"},{"ua":"Nexus 5 B"}],"dpi":[442.4,444.8],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/Nexus 4/*"},{"ua":"Nexus 4"}],"dpi":[319.8,318.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/LG-P769/*"},{"ua":"LG-P769"}],"dpi":[240.6,247.5],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/LGMS323/*"},{"ua":"LGMS323"}],"dpi":[206.6,204.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"LGE/*/LGLS996/*"},{"ua":"LGLS996"}],"dpi":[403.4,401.5],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Micromax/*/4560MMX/*"},{"ua":"4560MMX"}],"dpi":[240,219.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Micromax/*/A250/*"},{"ua":"Micromax A250"}],"dpi":[480,446.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Micromax/*/Micromax AQ4501/*"},{"ua":"Micromax AQ4501"}],"dpi":240,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/G5/*"},{"ua":"Moto G (5) Plus"}],"dpi":[403.4,403],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/DROID RAZR/*"},{"ua":"DROID RAZR"}],"dpi":[368.1,256.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT830C/*"},{"ua":"XT830C"}],"dpi":[254,255.9],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT1021/*"},{"ua":"XT1021"}],"dpi":[254,256.7],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/XT1023/*"},{"ua":"XT1023"}],"dpi":[254,256.7],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/XT1028/*"},{"ua":"XT1028"}],"dpi":[326.6,327.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT1034/*"},{"ua":"XT1034"}],"dpi":[326.6,328.4],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/XT1053/*"},{"ua":"XT1053"}],"dpi":[315.3,316.1],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT1562/*"},{"ua":"XT1562"}],"dpi":[403.4,402.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/Nexus 6/*"},{"ua":"Nexus 6 B"}],"dpi":[494.3,489.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT1063/*"},{"ua":"XT1063"}],"dpi":[295,296.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/XT1064/*"},{"ua":"XT1064"}],"dpi":[295,295.6],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/XT1092/*"},{"ua":"XT1092"}],"dpi":[422,424.1],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"motorola/*/XT1095/*"},{"ua":"XT1095"}],"dpi":[422,423.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"motorola/*/G4/*"},{"ua":"Moto G (4)"}],"dpi":401,"bw":4,"ac":1000},{"type":"android","rules":[{"mdmh":"OnePlus/*/A0001/*"},{"ua":"A0001"}],"dpi":[403.4,401],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"OnePlus/*/ONE E1005/*"},{"ua":"ONE E1005"}],"dpi":[442.4,441.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"OnePlus/*/ONE A2005/*"},{"ua":"ONE A2005"}],"dpi":[391.9,405.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"OnePlus/*/ONEPLUS A5000/*"},{"ua":"ONEPLUS A5000 "}],"dpi":[403.411,399.737],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"OnePlus/*/ONE A5010/*"},{"ua":"ONEPLUS A5010"}],"dpi":[403,400],"bw":2,"ac":1000},{"type":"android","rules":[{"mdmh":"OPPO/*/X909/*"},{"ua":"X909"}],"dpi":[442.4,444.1],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9082/*"},{"ua":"GT-I9082"}],"dpi":[184.7,185.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G360P/*"},{"ua":"SM-G360P"}],"dpi":[196.7,205.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/Nexus S/*"},{"ua":"Nexus S"}],"dpi":[234.5,229.8],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9300/*"},{"ua":"GT-I9300"}],"dpi":[304.8,303.9],"bw":5,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-T230NU/*"},{"ua":"SM-T230NU"}],"dpi":216,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SGH-T399/*"},{"ua":"SGH-T399"}],"dpi":[217.7,231.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SGH-M919/*"},{"ua":"SGH-M919"}],"dpi":[440.8,437.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N9005/*"},{"ua":"SM-N9005"}],"dpi":[386.4,387],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SAMSUNG-SM-N900A/*"},{"ua":"SAMSUNG-SM-N900A"}],"dpi":[386.4,387.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9500/*"},{"ua":"GT-I9500"}],"dpi":[442.5,443.3],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9505/*"},{"ua":"GT-I9505"}],"dpi":439.4,"bw":4,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G900F/*"},{"ua":"SM-G900F"}],"dpi":[415.6,431.6],"bw":5,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G900M/*"},{"ua":"SM-G900M"}],"dpi":[415.6,431.6],"bw":5,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G800F/*"},{"ua":"SM-G800F"}],"dpi":326.8,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G906S/*"},{"ua":"SM-G906S"}],"dpi":[562.7,572.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9300/*"},{"ua":"GT-I9300"}],"dpi":[306.7,304.8],"bw":5,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-T535/*"},{"ua":"SM-T535"}],"dpi":[142.6,136.4],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N920C/*"},{"ua":"SM-N920C"}],"dpi":[515.1,518.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N920P/*"},{"ua":"SM-N920P"}],"dpi":[386.3655,390.144],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N920W8/*"},{"ua":"SM-N920W8"}],"dpi":[515.1,518.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9300I/*"},{"ua":"GT-I9300I"}],"dpi":[304.8,305.8],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-I9195/*"},{"ua":"GT-I9195"}],"dpi":[249.4,256.7],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SPH-L520/*"},{"ua":"SPH-L520"}],"dpi":[249.4,255.9],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SAMSUNG-SGH-I717/*"},{"ua":"SAMSUNG-SGH-I717"}],"dpi":285.8,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SPH-D710/*"},{"ua":"SPH-D710"}],"dpi":[217.7,204.2],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/GT-N7100/*"},{"ua":"GT-N7100"}],"dpi":265.1,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SCH-I605/*"},{"ua":"SCH-I605"}],"dpi":265.1,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/Galaxy Nexus/*"},{"ua":"Galaxy Nexus"}],"dpi":[315.3,314.2],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N910H/*"},{"ua":"SM-N910H"}],"dpi":[515.1,518],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-N910C/*"},{"ua":"SM-N910C"}],"dpi":[515.2,520.2],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G130M/*"},{"ua":"SM-G130M"}],"dpi":[165.9,164.8],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G928I/*"},{"ua":"SM-G928I"}],"dpi":[515.1,518.4],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G920F/*"},{"ua":"SM-G920F"}],"dpi":580.6,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G920P/*"},{"ua":"SM-G920P"}],"dpi":[522.5,577],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G925F/*"},{"ua":"SM-G925F"}],"dpi":580.6,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G925V/*"},{"ua":"SM-G925V"}],"dpi":[522.5,576.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G930F/*"},{"ua":"SM-G930F"}],"dpi":576.6,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G935F/*"},{"ua":"SM-G935F"}],"dpi":533,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G950F/*"},{"ua":"SM-G950F"}],"dpi":[562.707,565.293],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G955U/*"},{"ua":"SM-G955U"}],"dpi":[522.514,525.762],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"samsung/*/SM-G955F/*"},{"ua":"SM-G955F"}],"dpi":[522.514,525.762],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"Sony/*/C6903/*"},{"ua":"C6903"}],"dpi":[442.5,443.3],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"Sony/*/D6653/*"},{"ua":"D6653"}],"dpi":[428.6,427.6],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Sony/*/E6653/*"},{"ua":"E6653"}],"dpi":[428.6,425.7],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Sony/*/E6853/*"},{"ua":"E6853"}],"dpi":[403.4,401.9],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Sony/*/SGP321/*"},{"ua":"SGP321"}],"dpi":[224.7,224.1],"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"TCT/*/ALCATEL ONE TOUCH Fierce/*"},{"ua":"ALCATEL ONE TOUCH Fierce"}],"dpi":[240,247.5],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"THL/*/thl 5000/*"},{"ua":"thl 5000"}],"dpi":[480,443.3],"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"Fly/*/IQ4412/*"},{"ua":"IQ4412"}],"dpi":307.9,"bw":3,"ac":1000},{"type":"android","rules":[{"mdmh":"ZTE/*/ZTE Blade L2/*"},{"ua":"ZTE Blade L2"}],"dpi":240,"bw":3,"ac":500},{"type":"android","rules":[{"mdmh":"BENEVE/*/VR518/*"},{"ua":"VR518"}],"dpi":480,"bw":3,"ac":500},{"type":"ios","rules":[{"res":[640,960]}],"dpi":[325.1,328.4],"bw":4,"ac":1000},{"type":"ios","rules":[{"res":[640,1136]}],"dpi":[317.1,320.2],"bw":3,"ac":1000},{"type":"ios","rules":[{"res":[750,1334]}],"dpi":326.4,"bw":4,"ac":1000},{"type":"ios","rules":[{"res":[1242,2208]}],"dpi":[453.6,458.4],"bw":4,"ac":1000},{"type":"ios","rules":[{"res":[1125,2001]}],"dpi":[410.9,415.4],"bw":4,"ac":1000},{"type":"ios","rules":[{"res":[1125,2436]}],"dpi":458,"bw":4,"ac":1000}];
+var DPDB_CACHE = {
+	format: format,
+	last_updated: last_updated,
+	devices: devices
+};
+function Dpdb(url, onDeviceParamsUpdated) {
+  this.dpdb = DPDB_CACHE;
+  this.recalculateDeviceParams_();
+  if (url) {
+    this.onDeviceParamsUpdated = onDeviceParamsUpdated;
+    var xhr = new XMLHttpRequest();
+    var obj = this;
+    xhr.open('GET', url, true);
+    xhr.addEventListener('load', function () {
+      obj.loading = false;
+      if (xhr.status >= 200 && xhr.status <= 299) {
+        obj.dpdb = JSON.parse(xhr.response);
+        obj.recalculateDeviceParams_();
+      } else {
+        console.error('Error loading online DPDB!');
+      }
+    });
+    xhr.send();
+  }
+}
+Dpdb.prototype.getDeviceParams = function () {
+  return this.deviceParams;
+};
+Dpdb.prototype.recalculateDeviceParams_ = function () {
+  var newDeviceParams = this.calcDeviceParams_();
+  if (newDeviceParams) {
+    this.deviceParams = newDeviceParams;
+    if (this.onDeviceParamsUpdated) {
+      this.onDeviceParamsUpdated(this.deviceParams);
+    }
+  } else {
+    console.error('Failed to recalculate device parameters.');
+  }
+};
+Dpdb.prototype.calcDeviceParams_ = function () {
+  var db = this.dpdb;
+  if (!db) {
+    console.error('DPDB not available.');
+    return null;
+  }
+  if (db.format != 1) {
+    console.error('DPDB has unexpected format version.');
+    return null;
+  }
+  if (!db.devices || !db.devices.length) {
+    console.error('DPDB does not have a devices section.');
+    return null;
+  }
+  var userAgent = navigator.userAgent || navigator.vendor || window.opera;
+  var width = getScreenWidth();
+  var height = getScreenHeight();
+  if (!db.devices) {
+    console.error('DPDB has no devices section.');
+    return null;
+  }
+  for (var i = 0; i < db.devices.length; i++) {
+    var device = db.devices[i];
+    if (!device.rules) {
+      console.warn('Device[' + i + '] has no rules section.');
+      continue;
+    }
+    if (device.type != 'ios' && device.type != 'android') {
+      console.warn('Device[' + i + '] has invalid type.');
+      continue;
+    }
+    if (isIOS() != (device.type == 'ios')) continue;
+    var matched = false;
+    for (var j = 0; j < device.rules.length; j++) {
+      var rule = device.rules[j];
+      if (this.ruleMatches_(rule, userAgent, width, height)) {
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) continue;
+    var xdpi = device.dpi[0] || device.dpi;
+    var ydpi = device.dpi[1] || device.dpi;
+    return new DeviceParams({ xdpi: xdpi, ydpi: ydpi, bevelMm: device.bw });
+  }
+  console.warn('No DPDB device match.');
+  return null;
+};
+Dpdb.prototype.ruleMatches_ = function (rule, ua, screenWidth, screenHeight) {
+  if (!rule.ua && !rule.res) return false;
+  if (rule.ua && rule.ua.substring(0, 2) === 'SM') rule.ua = rule.ua.substring(0, 7);
+  if (rule.ua && ua.indexOf(rule.ua) < 0) return false;
+  if (rule.res) {
+    if (!rule.res[0] || !rule.res[1]) return false;
+    var resX = rule.res[0];
+    var resY = rule.res[1];
+    if (Math.min(screenWidth, screenHeight) != Math.min(resX, resY) || Math.max(screenWidth, screenHeight) != Math.max(resX, resY)) {
+      return false;
+    }
+  }
+  return true;
+};
+function DeviceParams(params) {
+  this.xdpi = params.xdpi;
+  this.ydpi = params.ydpi;
+  this.bevelMm = params.bevelMm;
+}
+function SensorSample(sample, timestampS) {
+  this.set(sample, timestampS);
+}
+SensorSample.prototype.set = function (sample, timestampS) {
+  this.sample = sample;
+  this.timestampS = timestampS;
+};
+SensorSample.prototype.copy = function (sensorSample) {
+  this.set(sensorSample.sample, sensorSample.timestampS);
+};
+function ComplementaryFilter(kFilter, isDebug) {
+  this.kFilter = kFilter;
+  this.isDebug = isDebug;
+  this.currentAccelMeasurement = new SensorSample();
+  this.currentGyroMeasurement = new SensorSample();
+  this.previousGyroMeasurement = new SensorSample();
+  if (isIOS()) {
+    this.filterQ = new Quaternion(-1, 0, 0, 1);
+  } else {
+    this.filterQ = new Quaternion(1, 0, 0, 1);
+  }
+  this.previousFilterQ = new Quaternion();
+  this.previousFilterQ.copy(this.filterQ);
+  this.accelQ = new Quaternion();
+  this.isOrientationInitialized = false;
+  this.estimatedGravity = new Vector3();
+  this.measuredGravity = new Vector3();
+  this.gyroIntegralQ = new Quaternion();
+}
+ComplementaryFilter.prototype.addAccelMeasurement = function (vector, timestampS) {
+  this.currentAccelMeasurement.set(vector, timestampS);
+};
+ComplementaryFilter.prototype.addGyroMeasurement = function (vector, timestampS) {
+  this.currentGyroMeasurement.set(vector, timestampS);
+  var deltaT = timestampS - this.previousGyroMeasurement.timestampS;
+  if (isTimestampDeltaValid(deltaT)) {
+    this.run_();
+  }
+  this.previousGyroMeasurement.copy(this.currentGyroMeasurement);
+};
+ComplementaryFilter.prototype.run_ = function () {
+  if (!this.isOrientationInitialized) {
+    this.accelQ = this.accelToQuaternion_(this.currentAccelMeasurement.sample);
+    this.previousFilterQ.copy(this.accelQ);
+    this.isOrientationInitialized = true;
+    return;
+  }
+  var deltaT = this.currentGyroMeasurement.timestampS - this.previousGyroMeasurement.timestampS;
+  var gyroDeltaQ = this.gyroToQuaternionDelta_(this.currentGyroMeasurement.sample, deltaT);
+  this.gyroIntegralQ.multiply(gyroDeltaQ);
+  this.filterQ.copy(this.previousFilterQ);
+  this.filterQ.multiply(gyroDeltaQ);
+  var invFilterQ = new Quaternion();
+  invFilterQ.copy(this.filterQ);
+  invFilterQ.inverse();
+  this.estimatedGravity.set(0, 0, -1);
+  this.estimatedGravity.applyQuaternion(invFilterQ);
+  this.estimatedGravity.normalize();
+  this.measuredGravity.copy(this.currentAccelMeasurement.sample);
+  this.measuredGravity.normalize();
+  var deltaQ = new Quaternion();
+  deltaQ.setFromUnitVectors(this.estimatedGravity, this.measuredGravity);
+  deltaQ.inverse();
+  if (this.isDebug) {
+    console.log('Delta: %d deg, G_est: (%s, %s, %s), G_meas: (%s, %s, %s)', radToDeg * getQuaternionAngle(deltaQ), this.estimatedGravity.x.toFixed(1), this.estimatedGravity.y.toFixed(1), this.estimatedGravity.z.toFixed(1), this.measuredGravity.x.toFixed(1), this.measuredGravity.y.toFixed(1), this.measuredGravity.z.toFixed(1));
+  }
+  var targetQ = new Quaternion();
+  targetQ.copy(this.filterQ);
+  targetQ.multiply(deltaQ);
+  this.filterQ.slerp(targetQ, 1 - this.kFilter);
+  this.previousFilterQ.copy(this.filterQ);
+};
+ComplementaryFilter.prototype.getOrientation = function () {
+  return this.filterQ;
+};
+ComplementaryFilter.prototype.accelToQuaternion_ = function (accel) {
+  var normAccel = new Vector3();
+  normAccel.copy(accel);
+  normAccel.normalize();
+  var quat = new Quaternion();
+  quat.setFromUnitVectors(new Vector3(0, 0, -1), normAccel);
+  quat.inverse();
+  return quat;
+};
+ComplementaryFilter.prototype.gyroToQuaternionDelta_ = function (gyro, dt) {
+  var quat = new Quaternion();
+  var axis = new Vector3();
+  axis.copy(gyro);
+  axis.normalize();
+  quat.setFromAxisAngle(axis, gyro.length() * dt);
+  return quat;
+};
+function PosePredictor(predictionTimeS, isDebug) {
+  this.predictionTimeS = predictionTimeS;
+  this.isDebug = isDebug;
+  this.previousQ = new Quaternion();
+  this.previousTimestampS = null;
+  this.deltaQ = new Quaternion();
+  this.outQ = new Quaternion();
+}
+PosePredictor.prototype.getPrediction = function (currentQ, gyro, timestampS) {
+  if (!this.previousTimestampS) {
+    this.previousQ.copy(currentQ);
+    this.previousTimestampS = timestampS;
+    return currentQ;
+  }
+  var axis = new Vector3();
+  axis.copy(gyro);
+  axis.normalize();
+  var angularSpeed = gyro.length();
+  if (angularSpeed < degToRad * 20) {
+    if (this.isDebug) {
+      console.log('Moving slowly, at %s deg/s: no prediction', (radToDeg * angularSpeed).toFixed(1));
+    }
+    this.outQ.copy(currentQ);
+    this.previousQ.copy(currentQ);
+    return this.outQ;
+  }
+  var predictAngle = angularSpeed * this.predictionTimeS;
+  this.deltaQ.setFromAxisAngle(axis, predictAngle);
+  this.outQ.copy(this.previousQ);
+  this.outQ.multiply(this.deltaQ);
+  this.previousQ.copy(currentQ);
+  this.previousTimestampS = timestampS;
+  return this.outQ;
+};
+function FusionPoseSensor(kFilter, predictionTime, yawOnly, isDebug) {
+  this.yawOnly = yawOnly;
+  this.accelerometer = new Vector3();
+  this.gyroscope = new Vector3();
+  this.filter = new ComplementaryFilter(kFilter, isDebug);
+  this.posePredictor = new PosePredictor(predictionTime, isDebug);
+  this.isFirefoxAndroid = isFirefoxAndroid();
+  this.isIOS = isIOS();
+  var chromeVersion = getChromeVersion();
+  this.isDeviceMotionInRadians = !this.isIOS && chromeVersion && chromeVersion < 66;
+  this.isWithoutDeviceMotion = isChromeWithoutDeviceMotion();
+  this.filterToWorldQ = new Quaternion();
+  if (isIOS()) {
+    this.filterToWorldQ.setFromAxisAngle(new Vector3(1, 0, 0), Math.PI / 2);
+  } else {
+    this.filterToWorldQ.setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI / 2);
+  }
+  this.inverseWorldToScreenQ = new Quaternion();
+  this.worldToScreenQ = new Quaternion();
+  this.originalPoseAdjustQ = new Quaternion();
+  this.originalPoseAdjustQ.setFromAxisAngle(new Vector3(0, 0, 1), -window.orientation * Math.PI / 180);
+  this.setScreenTransform_();
+  if (isLandscapeMode()) {
+    this.filterToWorldQ.multiply(this.inverseWorldToScreenQ);
+  }
+  this.resetQ = new Quaternion();
+  this.orientationOut_ = new Float32Array(4);
+  this.start();
+}
+FusionPoseSensor.prototype.getPosition = function () {
+  return null;
+};
+FusionPoseSensor.prototype.getOrientation = function () {
+  var orientation = void 0;
+  if (this.isWithoutDeviceMotion && this._deviceOrientationQ) {
+    this.deviceOrientationFixQ = this.deviceOrientationFixQ || function () {
+      var z = new Quaternion().setFromAxisAngle(new Vector3(0, 0, -1), 0);
+      var y = new Quaternion();
+      if (window.orientation === -90) {
+        y.setFromAxisAngle(new Vector3(0, 1, 0), Math.PI / -2);
+      } else {
+        y.setFromAxisAngle(new Vector3(0, 1, 0), Math.PI / 2);
+      }
+      return z.multiply(y);
+    }();
+    this.deviceOrientationFilterToWorldQ = this.deviceOrientationFilterToWorldQ || function () {
+      var q = new Quaternion();
+      q.setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI / 2);
+      return q;
+    }();
+    orientation = this._deviceOrientationQ;
+    var out = new Quaternion();
+    out.copy(orientation);
+    out.multiply(this.deviceOrientationFilterToWorldQ);
+    out.multiply(this.resetQ);
+    out.multiply(this.worldToScreenQ);
+    out.multiplyQuaternions(this.deviceOrientationFixQ, out);
+    if (this.yawOnly) {
+      out.x = 0;
+      out.z = 0;
+      out.normalize();
+    }
+    this.orientationOut_[0] = out.x;
+    this.orientationOut_[1] = out.y;
+    this.orientationOut_[2] = out.z;
+    this.orientationOut_[3] = out.w;
+    return this.orientationOut_;
+  } else {
+    var filterOrientation = this.filter.getOrientation();
+    orientation = this.posePredictor.getPrediction(filterOrientation, this.gyroscope, this.previousTimestampS);
+  }
+  var out = new Quaternion();
+  out.copy(this.filterToWorldQ);
+  out.multiply(this.resetQ);
+  out.multiply(orientation);
+  out.multiply(this.worldToScreenQ);
+  if (this.yawOnly) {
+    out.x = 0;
+    out.z = 0;
+    out.normalize();
+  }
+  this.orientationOut_[0] = out.x;
+  this.orientationOut_[1] = out.y;
+  this.orientationOut_[2] = out.z;
+  this.orientationOut_[3] = out.w;
+  return this.orientationOut_;
+};
+FusionPoseSensor.prototype.resetPose = function () {
+  this.resetQ.copy(this.filter.getOrientation());
+  this.resetQ.x = 0;
+  this.resetQ.y = 0;
+  this.resetQ.z *= -1;
+  this.resetQ.normalize();
+  if (isLandscapeMode()) {
+    this.resetQ.multiply(this.inverseWorldToScreenQ);
+  }
+  this.resetQ.multiply(this.originalPoseAdjustQ);
+};
+FusionPoseSensor.prototype.onDeviceOrientation_ = function (e) {
+  this._deviceOrientationQ = this._deviceOrientationQ || new Quaternion();
+  var alpha = e.alpha,
+      beta = e.beta,
+      gamma = e.gamma;
+  alpha = (alpha || 0) * Math.PI / 180;
+  beta = (beta || 0) * Math.PI / 180;
+  gamma = (gamma || 0) * Math.PI / 180;
+  this._deviceOrientationQ.setFromEulerYXZ(beta, alpha, -gamma);
+};
+FusionPoseSensor.prototype.onDeviceMotion_ = function (deviceMotion) {
+  this.updateDeviceMotion_(deviceMotion);
+};
+FusionPoseSensor.prototype.updateDeviceMotion_ = function (deviceMotion) {
+  var accGravity = deviceMotion.accelerationIncludingGravity;
+  var rotRate = deviceMotion.rotationRate;
+  var timestampS = deviceMotion.timeStamp / 1000;
+  var deltaS = timestampS - this.previousTimestampS;
+  if (deltaS < 0) {
+    warnOnce('fusion-pose-sensor:invalid:non-monotonic', 'Invalid timestamps detected: non-monotonic timestamp from devicemotion');
+    this.previousTimestampS = timestampS;
+    return;
+  } else if (deltaS <= MIN_TIMESTEP || deltaS > MAX_TIMESTEP) {
+    warnOnce('fusion-pose-sensor:invalid:outside-threshold', 'Invalid timestamps detected: Timestamp from devicemotion outside expected range.');
+    this.previousTimestampS = timestampS;
+    return;
+  }
+  this.accelerometer.set(-accGravity.x, -accGravity.y, -accGravity.z);
+  if (isR7()) {
+    this.gyroscope.set(-rotRate.beta, rotRate.alpha, rotRate.gamma);
+  } else {
+    this.gyroscope.set(rotRate.alpha, rotRate.beta, rotRate.gamma);
+  }
+  if (!this.isDeviceMotionInRadians) {
+    this.gyroscope.multiplyScalar(Math.PI / 180);
+  }
+  this.filter.addAccelMeasurement(this.accelerometer, timestampS);
+  this.filter.addGyroMeasurement(this.gyroscope, timestampS);
+  this.previousTimestampS = timestampS;
+};
+FusionPoseSensor.prototype.onOrientationChange_ = function (screenOrientation) {
+  this.setScreenTransform_();
+};
+FusionPoseSensor.prototype.onMessage_ = function (event) {
+  var message = event.data;
+  if (!message || !message.type) {
+    return;
+  }
+  var type = message.type.toLowerCase();
+  if (type !== 'devicemotion') {
+    return;
+  }
+  this.updateDeviceMotion_(message.deviceMotionEvent);
+};
+FusionPoseSensor.prototype.setScreenTransform_ = function () {
+  this.worldToScreenQ.set(0, 0, 0, 1);
+  switch (window.orientation) {
+    case 0:
+      break;
+    case 90:
+      this.worldToScreenQ.setFromAxisAngle(new Vector3(0, 0, 1), -Math.PI / 2);
+      break;
+    case -90:
+      this.worldToScreenQ.setFromAxisAngle(new Vector3(0, 0, 1), Math.PI / 2);
+      break;
+    case 180:
+      break;
+  }
+  this.inverseWorldToScreenQ.copy(this.worldToScreenQ);
+  this.inverseWorldToScreenQ.inverse();
+};
+FusionPoseSensor.prototype.start = function () {
+  this.onDeviceMotionCallback_ = this.onDeviceMotion_.bind(this);
+  this.onOrientationChangeCallback_ = this.onOrientationChange_.bind(this);
+  this.onMessageCallback_ = this.onMessage_.bind(this);
+  this.onDeviceOrientationCallback_ = this.onDeviceOrientation_.bind(this);
+  if (isIOS() && isInsideCrossOriginIFrame()) {
+    window.addEventListener('message', this.onMessageCallback_);
+  }
+  window.addEventListener('orientationchange', this.onOrientationChangeCallback_);
+  if (this.isWithoutDeviceMotion) {
+    window.addEventListener('deviceorientation', this.onDeviceOrientationCallback_);
+  } else {
+    window.addEventListener('devicemotion', this.onDeviceMotionCallback_);
+  }
+};
+FusionPoseSensor.prototype.stop = function () {
+  window.removeEventListener('devicemotion', this.onDeviceMotionCallback_);
+  window.removeEventListener('deviceorientation', this.onDeviceOrientationCallback_);
+  window.removeEventListener('orientationchange', this.onOrientationChangeCallback_);
+  window.removeEventListener('message', this.onMessageCallback_);
+};
+var SENSOR_FREQUENCY = 60;
+var X_AXIS = new Vector3(1, 0, 0);
+var Z_AXIS = new Vector3(0, 0, 1);
+var SENSOR_TO_VR = new Quaternion();
+SENSOR_TO_VR.setFromAxisAngle(X_AXIS, -Math.PI / 2);
+SENSOR_TO_VR.multiply(new Quaternion().setFromAxisAngle(Z_AXIS, Math.PI / 2));
+var PoseSensor = function () {
+  function PoseSensor(config) {
+    classCallCheck(this, PoseSensor);
+    this.config = config;
+    this.sensor = null;
+    this.fusionSensor = null;
+    this._out = new Float32Array(4);
+    this.api = null;
+    this.errors = [];
+    this._sensorQ = new Quaternion();
+    this._outQ = new Quaternion();
+    this._onSensorRead = this._onSensorRead.bind(this);
+    this._onSensorError = this._onSensorError.bind(this);
+    this.init();
+  }
+  createClass(PoseSensor, [{
+    key: 'init',
+    value: function init() {
+      var sensor = null;
+      try {
+        sensor = new RelativeOrientationSensor({
+          frequency: SENSOR_FREQUENCY,
+          referenceFrame: 'screen'
+        });
+        sensor.addEventListener('error', this._onSensorError);
+      } catch (error) {
+        this.errors.push(error);
+        if (error.name === 'SecurityError') {
+          console.error('Cannot construct sensors due to the Feature Policy');
+          console.warn('Attempting to fall back using "devicemotion"; however this will ' + 'fail in the future without correct permissions.');
+          this.useDeviceMotion();
+        } else if (error.name === 'ReferenceError') {
+          this.useDeviceMotion();
+        } else {
+          console.error(error);
+        }
+      }
+      if (sensor) {
+        this.api = 'sensor';
+        this.sensor = sensor;
+        this.sensor.addEventListener('reading', this._onSensorRead);
+        this.sensor.start();
+      }
+    }
+  }, {
+    key: 'useDeviceMotion',
+    value: function useDeviceMotion() {
+      this.api = 'devicemotion';
+      this.fusionSensor = new FusionPoseSensor(this.config.K_FILTER, this.config.PREDICTION_TIME_S, this.config.YAW_ONLY, this.config.DEBUG);
+      if (this.sensor) {
+        this.sensor.removeEventListener('reading', this._onSensorRead);
+        this.sensor.removeEventListener('error', this._onSensorError);
+        this.sensor = null;
+      }
+    }
+  }, {
+    key: 'getOrientation',
+    value: function getOrientation() {
+      if (this.fusionSensor) {
+        return this.fusionSensor.getOrientation();
+      }
+      if (!this.sensor || !this.sensor.quaternion) {
+        this._out[0] = this._out[1] = this._out[2] = 0;
+        this._out[3] = 1;
+        return this._out;
+      }
+      var q = this.sensor.quaternion;
+      this._sensorQ.set(q[0], q[1], q[2], q[3]);
+      var out = this._outQ;
+      out.copy(SENSOR_TO_VR);
+      out.multiply(this._sensorQ);
+      if (this.config.YAW_ONLY) {
+        out.x = out.z = 0;
+        out.normalize();
+      }
+      this._out[0] = out.x;
+      this._out[1] = out.y;
+      this._out[2] = out.z;
+      this._out[3] = out.w;
+      return this._out;
+    }
+  }, {
+    key: '_onSensorError',
+    value: function _onSensorError(event) {
+      this.errors.push(event.error);
+      if (event.error.name === 'NotAllowedError') {
+        console.error('Permission to access sensor was denied');
+      } else if (event.error.name === 'NotReadableError') {
+        console.error('Sensor could not be read');
+      } else {
+        console.error(event.error);
+      }
+      this.useDeviceMotion();
+    }
+  }, {
+    key: '_onSensorRead',
+    value: function _onSensorRead() {}
+  }]);
+  return PoseSensor;
+}();
+var rotateInstructionsAsset = "<svg width='198' height='240' viewBox='0 0 198 240' xmlns='http://www.w3.org/2000/svg'><g fill='none' fill-rule='evenodd'><path d='M149.625 109.527l6.737 3.891v.886c0 .177.013.36.038.549.01.081.02.162.027.242.14 1.415.974 2.998 2.105 3.999l5.72 5.062.081-.09s4.382-2.53 5.235-3.024l25.97 14.993v54.001c0 .771-.386 1.217-.948 1.217-.233 0-.495-.076-.772-.236l-23.967-13.838-.014.024-27.322 15.775-.85-1.323c-4.731-1.529-9.748-2.74-14.951-3.61a.27.27 0 0 0-.007.024l-5.067 16.961-7.891 4.556-.037-.063v27.59c0 .772-.386 1.217-.948 1.217-.232 0-.495-.076-.772-.236l-42.473-24.522c-.95-.549-1.72-1.877-1.72-2.967v-1.035l-.021.047a5.111 5.111 0 0 0-1.816-.399 5.682 5.682 0 0 0-.546.001 13.724 13.724 0 0 1-1.918-.041c-1.655-.153-3.2-.6-4.404-1.296l-46.576-26.89.005.012-10.278-18.75c-1.001-1.827-.241-4.216 1.698-5.336l56.011-32.345a4.194 4.194 0 0 1 2.099-.572c1.326 0 2.572.659 3.227 1.853l.005-.003.227.413-.006.004a9.63 9.63 0 0 0 1.477 2.018l.277.27c1.914 1.85 4.468 2.801 7.113 2.801 1.949 0 3.948-.517 5.775-1.572.013 0 7.319-4.219 7.319-4.219a4.194 4.194 0 0 1 2.099-.572c1.326 0 2.572.658 3.226 1.853l3.25 5.928.022-.018 6.785 3.917-.105-.182 46.881-26.965m0-1.635c-.282 0-.563.073-.815.218l-46.169 26.556-5.41-3.124-3.005-5.481c-.913-1.667-2.699-2.702-4.66-2.703-1.011 0-2.02.274-2.917.792a3825 3825 0 0 1-7.275 4.195l-.044.024a9.937 9.937 0 0 1-4.957 1.353c-2.292 0-4.414-.832-5.976-2.342l-.252-.245a7.992 7.992 0 0 1-1.139-1.534 1.379 1.379 0 0 0-.06-.122l-.227-.414a1.718 1.718 0 0 0-.095-.154c-.938-1.574-2.673-2.545-4.571-2.545-1.011 0-2.02.274-2.917.792L3.125 155.502c-2.699 1.559-3.738 4.94-2.314 7.538l10.278 18.75c.177.323.448.563.761.704l46.426 26.804c1.403.81 3.157 1.332 5.072 1.508a15.661 15.661 0 0 0 2.146.046 4.766 4.766 0 0 1 .396 0c.096.004.19.011.283.022.109 1.593 1.159 3.323 2.529 4.114l42.472 24.522c.524.302 1.058.455 1.59.455 1.497 0 2.583-1.2 2.583-2.852v-26.562l7.111-4.105a1.64 1.64 0 0 0 .749-.948l4.658-15.593c4.414.797 8.692 1.848 12.742 3.128l.533.829a1.634 1.634 0 0 0 2.193.531l26.532-15.317L193 192.433c.523.302 1.058.455 1.59.455 1.497 0 2.583-1.199 2.583-2.852v-54.001c0-.584-.312-1.124-.818-1.416l-25.97-14.993a1.633 1.633 0 0 0-1.636.001c-.606.351-2.993 1.73-4.325 2.498l-4.809-4.255c-.819-.725-1.461-1.933-1.561-2.936a7.776 7.776 0 0 0-.033-.294 2.487 2.487 0 0 1-.023-.336v-.886c0-.584-.312-1.123-.817-1.416l-6.739-3.891a1.633 1.633 0 0 0-.817-.219' fill='#455A64'/><path d='M96.027 132.636l46.576 26.891c1.204.695 1.979 1.587 2.242 2.541l-.01.007-81.374 46.982h-.001c-1.654-.152-3.199-.6-4.403-1.295l-46.576-26.891 83.546-48.235' fill='#FAFAFA'/><path d='M63.461 209.174c-.008 0-.015 0-.022-.002-1.693-.156-3.228-.609-4.441-1.309l-46.576-26.89a.118.118 0 0 1 0-.203l83.546-48.235a.117.117 0 0 1 .117 0l46.576 26.891c1.227.708 2.021 1.612 2.296 2.611a.116.116 0 0 1-.042.124l-.021.016-81.375 46.981a.11.11 0 0 1-.058.016zm-50.747-28.303l46.401 26.79c1.178.68 2.671 1.121 4.32 1.276l81.272-46.922c-.279-.907-1.025-1.73-2.163-2.387l-46.517-26.857-83.313 48.1z' fill='#607D8B'/><path d='M148.327 165.471a5.85 5.85 0 0 1-.546.001c-1.894-.083-3.302-1.038-3.145-2.132a2.693 2.693 0 0 0-.072-1.105l-81.103 46.822c.628.058 1.272.073 1.918.042.182-.009.364-.009.546-.001 1.894.083 3.302 1.038 3.145 2.132l79.257-45.759' fill='#FFF'/><path d='M69.07 211.347a.118.118 0 0 1-.115-.134c.045-.317-.057-.637-.297-.925-.505-.61-1.555-1.022-2.738-1.074a5.966 5.966 0 0 0-.535.001 14.03 14.03 0 0 1-1.935-.041.117.117 0 0 1-.103-.092.116.116 0 0 1 .055-.126l81.104-46.822a.117.117 0 0 1 .171.07c.104.381.129.768.074 1.153-.045.316.057.637.296.925.506.61 1.555 1.021 2.739 1.073.178.008.357.008.535-.001a.117.117 0 0 1 .064.218l-79.256 45.759a.114.114 0 0 1-.059.016zm-3.405-2.372c.089 0 .177.002.265.006 1.266.056 2.353.488 2.908 1.158.227.274.35.575.36.882l78.685-45.429c-.036 0-.072-.001-.107-.003-1.267-.056-2.354-.489-2.909-1.158-.282-.34-.402-.724-.347-1.107a2.604 2.604 0 0 0-.032-.91L63.846 208.97a13.91 13.91 0 0 0 1.528.012c.097-.005.194-.007.291-.007z' fill='#607D8B'/><path d='M2.208 162.134c-1.001-1.827-.241-4.217 1.698-5.337l56.011-32.344c1.939-1.12 4.324-.546 5.326 1.281l.232.41a9.344 9.344 0 0 0 1.47 2.021l.278.27c3.325 3.214 8.583 3.716 12.888 1.23l7.319-4.22c1.94-1.119 4.324-.546 5.325 1.282l3.25 5.928-83.519 48.229-10.278-18.75z' fill='#FAFAFA'/><path d='M12.486 181.001a.112.112 0 0 1-.031-.005.114.114 0 0 1-.071-.056L2.106 162.19c-1.031-1.88-.249-4.345 1.742-5.494l56.01-32.344a4.328 4.328 0 0 1 2.158-.588c1.415 0 2.65.702 3.311 1.882.01.008.018.017.024.028l.227.414a.122.122 0 0 1 .013.038 9.508 9.508 0 0 0 1.439 1.959l.275.266c1.846 1.786 4.344 2.769 7.031 2.769 1.977 0 3.954-.538 5.717-1.557a.148.148 0 0 1 .035-.013l7.284-4.206a4.321 4.321 0 0 1 2.157-.588c1.427 0 2.672.716 3.329 1.914l3.249 5.929a.116.116 0 0 1-.044.157l-83.518 48.229a.116.116 0 0 1-.059.016zm49.53-57.004c-.704 0-1.41.193-2.041.557l-56.01 32.345c-1.882 1.086-2.624 3.409-1.655 5.179l10.221 18.645 83.317-48.112-3.195-5.829c-.615-1.122-1.783-1.792-3.124-1.792a4.08 4.08 0 0 0-2.04.557l-7.317 4.225a.148.148 0 0 1-.035.013 11.7 11.7 0 0 1-5.801 1.569c-2.748 0-5.303-1.007-7.194-2.835l-.278-.27a9.716 9.716 0 0 1-1.497-2.046.096.096 0 0 1-.013-.037l-.191-.347a.11.11 0 0 1-.023-.029c-.615-1.123-1.783-1.793-3.124-1.793z' fill='#607D8B'/><path d='M42.434 155.808c-2.51-.001-4.697-1.258-5.852-3.365-1.811-3.304-.438-7.634 3.059-9.654l12.291-7.098a7.599 7.599 0 0 1 3.789-1.033c2.51 0 4.697 1.258 5.852 3.365 1.811 3.304.439 7.634-3.059 9.654l-12.291 7.098a7.606 7.606 0 0 1-3.789 1.033zm13.287-20.683a7.128 7.128 0 0 0-3.555.971l-12.291 7.098c-3.279 1.893-4.573 5.942-2.883 9.024 1.071 1.955 3.106 3.122 5.442 3.122a7.13 7.13 0 0 0 3.556-.97l12.291-7.098c3.279-1.893 4.572-5.942 2.883-9.024-1.072-1.955-3.106-3.123-5.443-3.123z' fill='#607D8B'/><path d='M149.588 109.407l6.737 3.89v.887c0 .176.013.36.037.549.011.081.02.161.028.242.14 1.415.973 2.998 2.105 3.999l7.396 6.545c.177.156.358.295.541.415 1.579 1.04 2.95.466 3.062-1.282.049-.784.057-1.595.023-2.429l-.003-.16v-1.151l25.987 15.003v54c0 1.09-.77 1.53-1.72.982l-42.473-24.523c-.95-.548-1.72-1.877-1.72-2.966v-34.033' fill='#FAFAFA'/><path d='M194.553 191.25c-.257 0-.54-.085-.831-.253l-42.472-24.521c-.981-.567-1.779-1.943-1.779-3.068v-34.033h.234v34.033c0 1.051.745 2.336 1.661 2.866l42.473 24.521c.424.245.816.288 1.103.122.285-.164.442-.52.442-1.002v-53.933l-25.753-14.868.003 1.106c.034.832.026 1.654-.024 2.439-.054.844-.396 1.464-.963 1.746-.619.309-1.45.173-2.28-.373a5.023 5.023 0 0 1-.553-.426l-7.397-6.544c-1.158-1.026-1.999-2.625-2.143-4.076a9.624 9.624 0 0 0-.027-.238 4.241 4.241 0 0 1-.038-.564v-.82l-6.68-3.856.117-.202 6.738 3.89.058.034v.954c0 .171.012.351.036.533.011.083.021.165.029.246.138 1.395.948 2.935 2.065 3.923l7.397 6.545c.173.153.35.289.527.406.758.499 1.504.63 2.047.359.49-.243.786-.795.834-1.551.05-.778.057-1.591.024-2.417l-.004-.163v-1.355l.175.1 25.987 15.004.059.033v54.068c0 .569-.198.996-.559 1.204a1.002 1.002 0 0 1-.506.131' fill='#607D8B'/><path d='M145.685 163.161l24.115 13.922-25.978 14.998-1.462-.307c-6.534-2.17-13.628-3.728-21.019-4.616-4.365-.524-8.663 1.096-9.598 3.62a2.746 2.746 0 0 0-.011 1.928c1.538 4.267 4.236 8.363 7.995 12.135l.532.845-25.977 14.997-24.115-13.922 75.518-43.6' fill='#FFF'/><path d='M94.282 220.818l-.059-.033-24.29-14.024.175-.101 75.577-43.634.058.033 24.29 14.024-26.191 15.122-.045-.01-1.461-.307c-6.549-2.174-13.613-3.725-21.009-4.614a13.744 13.744 0 0 0-1.638-.097c-3.758 0-7.054 1.531-7.837 3.642a2.62 2.62 0 0 0-.01 1.848c1.535 4.258 4.216 8.326 7.968 12.091l.016.021.526.835.006.01.064.102-.105.061-25.977 14.998-.058.033zm-23.881-14.057l23.881 13.788 24.802-14.32c.546-.315.846-.489 1.017-.575l-.466-.74c-3.771-3.787-6.467-7.881-8.013-12.168a2.851 2.851 0 0 1 .011-2.008c.815-2.199 4.203-3.795 8.056-3.795.557 0 1.117.033 1.666.099 7.412.891 14.491 2.445 21.041 4.621.836.175 1.215.254 1.39.304l25.78-14.884-23.881-13.788-75.284 43.466z' fill='#607D8B'/><path d='M167.23 125.979v50.871l-27.321 15.773-6.461-14.167c-.91-1.996-3.428-1.738-5.624.574a10.238 10.238 0 0 0-2.33 4.018l-6.46 21.628-27.322 15.774v-50.871l75.518-43.6' fill='#FFF'/><path d='M91.712 220.567a.127.127 0 0 1-.059-.016.118.118 0 0 1-.058-.101v-50.871c0-.042.023-.08.058-.101l75.519-43.6a.117.117 0 0 1 .175.101v50.871c0 .041-.023.08-.059.1l-27.321 15.775a.118.118 0 0 1-.094.01.12.12 0 0 1-.071-.063l-6.46-14.168c-.375-.822-1.062-1.275-1.934-1.275-1.089 0-2.364.686-3.5 1.881a10.206 10.206 0 0 0-2.302 3.972l-6.46 21.627a.118.118 0 0 1-.054.068L91.77 220.551a.12.12 0 0 1-.058.016zm.117-50.92v50.601l27.106-15.65 6.447-21.583a10.286 10.286 0 0 1 2.357-4.065c1.18-1.242 2.517-1.954 3.669-1.954.969 0 1.731.501 2.146 1.411l6.407 14.051 27.152-15.676v-50.601l-75.284 43.466z' fill='#607D8B'/><path d='M168.543 126.213v50.87l-27.322 15.774-6.46-14.168c-.91-1.995-3.428-1.738-5.624.574a10.248 10.248 0 0 0-2.33 4.019l-6.461 21.627-27.321 15.774v-50.87l75.518-43.6' fill='#FFF'/><path d='M93.025 220.8a.123.123 0 0 1-.059-.015.12.12 0 0 1-.058-.101v-50.871c0-.042.023-.08.058-.101l75.518-43.6a.112.112 0 0 1 .117 0c.036.02.059.059.059.1v50.871a.116.116 0 0 1-.059.101l-27.321 15.774a.111.111 0 0 1-.094.01.115.115 0 0 1-.071-.062l-6.46-14.168c-.375-.823-1.062-1.275-1.935-1.275-1.088 0-2.363.685-3.499 1.881a10.19 10.19 0 0 0-2.302 3.971l-6.461 21.628a.108.108 0 0 1-.053.067l-27.322 15.775a.12.12 0 0 1-.058.015zm.117-50.919v50.6l27.106-15.649 6.447-21.584a10.293 10.293 0 0 1 2.357-4.065c1.179-1.241 2.516-1.954 3.668-1.954.969 0 1.732.502 2.147 1.412l6.407 14.051 27.152-15.676v-50.601l-75.284 43.466z' fill='#607D8B'/><path d='M169.8 177.083l-27.322 15.774-6.46-14.168c-.91-1.995-3.428-1.738-5.625.574a10.246 10.246 0 0 0-2.329 4.019l-6.461 21.627-27.321 15.774v-50.87l75.518-43.6v50.87z' fill='#FAFAFA'/><path d='M94.282 220.917a.234.234 0 0 1-.234-.233v-50.871c0-.083.045-.161.117-.202l75.518-43.601a.234.234 0 1 1 .35.202v50.871a.233.233 0 0 1-.116.202l-27.322 15.775a.232.232 0 0 1-.329-.106l-6.461-14.168c-.36-.789-.992-1.206-1.828-1.206-1.056 0-2.301.672-3.415 1.844a10.099 10.099 0 0 0-2.275 3.924l-6.46 21.628a.235.235 0 0 1-.107.136l-27.322 15.774a.23.23 0 0 1-.116.031zm.233-50.969v50.331l26.891-15.525 6.434-21.539a10.41 10.41 0 0 1 2.384-4.112c1.201-1.265 2.569-1.991 3.753-1.991 1.018 0 1.818.526 2.253 1.48l6.354 13.934 26.982-15.578v-50.331l-75.051 43.331z' fill='#607D8B'/><path d='M109.894 199.943c-1.774 0-3.241-.725-4.244-2.12a.224.224 0 0 1 .023-.294.233.233 0 0 1 .301-.023c.78.547 1.705.827 2.75.827 1.323 0 2.754-.439 4.256-1.306 5.311-3.067 9.631-10.518 9.631-16.611 0-1.927-.442-3.56-1.278-4.724a.232.232 0 0 1 .323-.327c1.671 1.172 2.591 3.381 2.591 6.219 0 6.242-4.426 13.863-9.865 17.003-1.574.908-3.084 1.356-4.488 1.356zm-2.969-1.542c.813.651 1.82.877 2.968.877h.001c1.321 0 2.753-.327 4.254-1.194 5.311-3.067 9.632-10.463 9.632-16.556 0-1.979-.463-3.599-1.326-4.761.411 1.035.625 2.275.625 3.635 0 6.243-4.426 13.883-9.865 17.023-1.574.909-3.084 1.317-4.49 1.317-.641 0-1.243-.149-1.799-.341z' fill='#607D8B'/><path d='M113.097 197.23c5.384-3.108 9.748-10.636 9.748-16.814 0-2.051-.483-3.692-1.323-4.86-1.784-1.252-4.374-1.194-7.257.47-5.384 3.108-9.748 10.636-9.748 16.814 0 2.051.483 3.692 1.323 4.86 1.784 1.252 4.374 1.194 7.257-.47' fill='#FAFAFA'/><path d='M108.724 198.614c-1.142 0-2.158-.213-3.019-.817-.021-.014-.04.014-.055-.007-.894-1.244-1.367-2.948-1.367-4.973 0-6.242 4.426-13.864 9.865-17.005 1.574-.908 3.084-1.363 4.49-1.363 1.142 0 2.158.309 3.018.913a.23.23 0 0 1 .056.056c.894 1.244 1.367 2.972 1.367 4.997 0 6.243-4.426 13.783-9.865 16.923-1.574.909-3.084 1.276-4.49 1.276zm-2.718-1.109c.774.532 1.688.776 2.718.776 1.323 0 2.754-.413 4.256-1.28 5.311-3.066 9.631-10.505 9.631-16.598 0-1.909-.434-3.523-1.255-4.685-.774-.533-1.688-.799-2.718-.799-1.323 0-2.755.441-4.256 1.308-5.311 3.066-9.631 10.506-9.631 16.599 0 1.909.434 3.517 1.255 4.679z' fill='#607D8B'/><path d='M149.318 114.262l-9.984 8.878 15.893 11.031 5.589-6.112-11.498-13.797' fill='#FAFAFA'/><path d='M169.676 120.84l-9.748 5.627c-3.642 2.103-9.528 2.113-13.147.024-3.62-2.089-3.601-5.488.041-7.591l9.495-5.608-6.729-3.885-81.836 47.071 45.923 26.514 3.081-1.779c.631-.365.869-.898.618-1.39-2.357-4.632-2.593-9.546-.683-14.262 5.638-13.92 24.509-24.815 48.618-28.07 8.169-1.103 16.68-.967 24.704.394.852.145 1.776.008 2.407-.357l3.081-1.778-25.825-14.91' fill='#FAFAFA'/><path d='M113.675 183.459a.47.47 0 0 1-.233-.062l-45.924-26.515a.468.468 0 0 1 .001-.809l81.836-47.071a.467.467 0 0 1 .466 0l6.729 3.885a.467.467 0 0 1-.467.809l-6.496-3.75-80.9 46.533 44.988 25.973 2.848-1.644c.192-.111.62-.409.435-.773-2.416-4.748-2.658-9.814-.7-14.65 2.806-6.927 8.885-13.242 17.582-18.263 8.657-4.998 19.518-8.489 31.407-10.094 8.198-1.107 16.79-.97 24.844.397.739.125 1.561.007 2.095-.301l2.381-1.374-25.125-14.506a.467.467 0 0 1 .467-.809l25.825 14.91a.467.467 0 0 1 0 .809l-3.081 1.779c-.721.417-1.763.575-2.718.413-7.963-1.351-16.457-1.486-24.563-.392-11.77 1.589-22.512 5.039-31.065 9.977-8.514 4.916-14.456 11.073-17.183 17.805-1.854 4.578-1.623 9.376.666 13.875.37.725.055 1.513-.8 2.006l-3.081 1.78a.476.476 0 0 1-.234.062' fill='#455A64'/><path d='M153.316 128.279c-2.413 0-4.821-.528-6.652-1.586-1.818-1.049-2.82-2.461-2.82-3.975 0-1.527 1.016-2.955 2.861-4.02l9.493-5.607a.233.233 0 1 1 .238.402l-9.496 5.609c-1.696.979-2.628 2.263-2.628 3.616 0 1.34.918 2.608 2.585 3.571 3.549 2.049 9.343 2.038 12.914-.024l9.748-5.628a.234.234 0 0 1 .234.405l-9.748 5.628c-1.858 1.072-4.296 1.609-6.729 1.609' fill='#607D8B'/><path d='M113.675 182.992l-45.913-26.508M113.675 183.342a.346.346 0 0 1-.175-.047l-45.913-26.508a.35.35 0 1 1 .35-.607l45.913 26.508a.35.35 0 0 1-.175.654' fill='#455A64'/><path d='M67.762 156.484v54.001c0 1.09.77 2.418 1.72 2.967l42.473 24.521c.95.549 1.72.11 1.72-.98v-54.001' fill='#FAFAFA'/><path d='M112.727 238.561c-.297 0-.62-.095-.947-.285l-42.473-24.521c-1.063-.613-1.895-2.05-1.895-3.27v-54.001a.35.35 0 1 1 .701 0v54.001c0 .96.707 2.18 1.544 2.663l42.473 24.522c.344.198.661.243.87.122.206-.119.325-.411.325-.799v-54.001a.35.35 0 1 1 .7 0v54.001c0 .655-.239 1.154-.675 1.406a1.235 1.235 0 0 1-.623.162' fill='#455A64'/><path d='M112.86 147.512h-.001c-2.318 0-4.499-.522-6.142-1.471-1.705-.984-2.643-2.315-2.643-3.749 0-1.445.952-2.791 2.68-3.788l12.041-6.953c1.668-.962 3.874-1.493 6.212-1.493 2.318 0 4.499.523 6.143 1.472 1.704.984 2.643 2.315 2.643 3.748 0 1.446-.952 2.791-2.68 3.789l-12.042 6.952c-1.668.963-3.874 1.493-6.211 1.493zm12.147-16.753c-2.217 0-4.298.497-5.861 1.399l-12.042 6.952c-1.502.868-2.33 1.998-2.33 3.182 0 1.173.815 2.289 2.293 3.142 1.538.889 3.596 1.378 5.792 1.378h.001c2.216 0 4.298-.497 5.861-1.399l12.041-6.953c1.502-.867 2.33-1.997 2.33-3.182 0-1.172-.814-2.288-2.292-3.142-1.539-.888-3.596-1.377-5.793-1.377z' fill='#607D8B'/><path d='M165.63 123.219l-5.734 3.311c-3.167 1.828-8.286 1.837-11.433.02-3.147-1.817-3.131-4.772.036-6.601l5.734-3.31 11.397 6.58' fill='#FAFAFA'/><path d='M154.233 117.448l9.995 5.771-4.682 2.704c-1.434.827-3.352 1.283-5.399 1.283-2.029 0-3.923-.449-5.333-1.263-1.29-.744-2-1.694-2-2.674 0-.991.723-1.955 2.036-2.713l5.383-3.108m0-.809l-5.734 3.31c-3.167 1.829-3.183 4.784-.036 6.601 1.568.905 3.623 1.357 5.684 1.357 2.077 0 4.159-.46 5.749-1.377l5.734-3.311-11.397-6.58M145.445 179.667c-1.773 0-3.241-.85-4.243-2.245-.067-.092-.057-.275.023-.356.08-.081.207-.12.3-.055.781.548 1.706.812 2.751.811 1.322 0 2.754-.446 4.256-1.313 5.31-3.066 9.631-10.522 9.631-16.615 0-1.927-.442-3.562-1.279-4.726a.235.235 0 0 1 .024-.301.232.232 0 0 1 .3-.027c1.67 1.172 2.59 3.38 2.59 6.219 0 6.242-4.425 13.987-9.865 17.127-1.573.908-3.083 1.481-4.488 1.481zM142.476 178c.814.651 1.82 1.002 2.969 1.002 1.322 0 2.753-.452 4.255-1.32 5.31-3.065 9.631-10.523 9.631-16.617 0-1.98-.463-3.63-1.325-4.793.411 1.035.624 2.26.624 3.62 0 6.242-4.425 13.875-9.865 17.015-1.573.909-3.084 1.376-4.489 1.376a5.49 5.49 0 0 1-1.8-.283z' fill='#607D8B'/><path d='M148.648 176.704c5.384-3.108 9.748-10.636 9.748-16.813 0-2.052-.483-3.693-1.322-4.861-1.785-1.252-4.375-1.194-7.258.471-5.383 3.108-9.748 10.636-9.748 16.813 0 2.051.484 3.692 1.323 4.86 1.785 1.253 4.374 1.195 7.257-.47' fill='#FAFAFA'/><path d='M144.276 178.276c-1.143 0-2.158-.307-3.019-.911a.217.217 0 0 1-.055-.054c-.895-1.244-1.367-2.972-1.367-4.997 0-6.241 4.425-13.875 9.865-17.016 1.573-.908 3.084-1.369 4.489-1.369 1.143 0 2.158.307 3.019.91a.24.24 0 0 1 .055.055c.894 1.244 1.367 2.971 1.367 4.997 0 6.241-4.425 13.875-9.865 17.016-1.573.908-3.084 1.369-4.489 1.369zm-2.718-1.172c.773.533 1.687.901 2.718.901 1.322 0 2.754-.538 4.256-1.405 5.31-3.066 9.631-10.567 9.631-16.661 0-1.908-.434-3.554-1.256-4.716-.774-.532-1.688-.814-2.718-.814-1.322 0-2.754.433-4.256 1.3-5.31 3.066-9.631 10.564-9.631 16.657 0 1.91.434 3.576 1.256 4.738z' fill='#607D8B'/><path d='M150.72 172.361l-.363-.295a24.105 24.105 0 0 0 2.148-3.128 24.05 24.05 0 0 0 1.977-4.375l.443.149a24.54 24.54 0 0 1-2.015 4.46 24.61 24.61 0 0 1-2.19 3.189M115.917 191.514l-.363-.294a24.174 24.174 0 0 0 2.148-3.128 24.038 24.038 0 0 0 1.976-4.375l.443.148a24.48 24.48 0 0 1-2.015 4.461 24.662 24.662 0 0 1-2.189 3.188M114 237.476V182.584 237.476' fill='#607D8B'/><g><path d='M81.822 37.474c.017-.135-.075-.28-.267-.392-.327-.188-.826-.21-1.109-.045l-6.012 3.471c-.131.076-.194.178-.191.285.002.132.002.461.002.578v.043l-.007.128-6.591 3.779c-.001 0-2.077 1.046-2.787 5.192 0 0-.912 6.961-.898 19.745.015 12.57.606 17.07 1.167 21.351.22 1.684 3.001 2.125 3.001 2.125.331.04.698-.027 1.08-.248l75.273-43.551c1.808-1.069 2.667-3.719 3.056-6.284 1.213-7.99 1.675-32.978-.275-39.878-.196-.693-.51-1.083-.868-1.282l-2.086-.79c-.727.028-1.416.467-1.534.535L82.032 37.072l-.21.402' fill='#FFF'/><path d='M144.311 1.701l2.085.79c.358.199.672.589.868 1.282 1.949 6.9 1.487 31.887.275 39.878-.39 2.565-1.249 5.215-3.056 6.284L69.21 93.486a1.78 1.78 0 0 1-.896.258l-.183-.011c0 .001-2.782-.44-3.003-2.124-.56-4.282-1.151-8.781-1.165-21.351-.015-12.784.897-19.745.897-19.745.71-4.146 2.787-5.192 2.787-5.192l6.591-3.779.007-.128v-.043c0-.117 0-.446-.002-.578-.003-.107.059-.21.191-.285l6.012-3.472a.98.98 0 0 1 .481-.11c.218 0 .449.053.627.156.193.112.285.258.268.392l.211-.402 60.744-34.836c.117-.068.806-.507 1.534-.535m0-.997l-.039.001c-.618.023-1.283.244-1.974.656l-.021.012-60.519 34.706a2.358 2.358 0 0 0-.831-.15c-.365 0-.704.084-.98.244l-6.012 3.471c-.442.255-.699.69-.689 1.166l.001.15-6.08 3.487c-.373.199-2.542 1.531-3.29 5.898l-.006.039c-.009.07-.92 7.173-.906 19.875.014 12.62.603 17.116 1.172 21.465l.002.015c.308 2.355 3.475 2.923 3.836 2.98l.034.004c.101.013.204.019.305.019a2.77 2.77 0 0 0 1.396-.392l75.273-43.552c1.811-1.071 2.999-3.423 3.542-6.997 1.186-7.814 1.734-33.096-.301-40.299-.253-.893-.704-1.527-1.343-1.882l-.132-.062-2.085-.789a.973.973 0 0 0-.353-.065' fill='#455A64'/><path d='M128.267 11.565l1.495.434-56.339 32.326' fill='#FFF'/><path d='M74.202 90.545a.5.5 0 0 1-.25-.931l18.437-10.645a.499.499 0 1 1 .499.864L74.451 90.478l-.249.067M75.764 42.654l-.108-.062.046-.171 5.135-2.964.17.045-.045.171-5.135 2.964-.063.017M70.52 90.375V46.421l.063-.036L137.84 7.554v43.954l-.062.036L70.52 90.375zm.25-43.811v43.38l66.821-38.579V7.985L70.77 46.564z' fill='#607D8B'/><path d='M86.986 83.182c-.23.149-.612.384-.849.523l-11.505 6.701c-.237.139-.206.252.068.252h.565c.275 0 .693-.113.93-.252L87.7 83.705c.237-.139.428-.253.425-.256a11.29 11.29 0 0 1-.006-.503c0-.274-.188-.377-.418-.227l-.715.463' fill='#607D8B'/><path d='M75.266 90.782H74.7c-.2 0-.316-.056-.346-.166-.03-.11.043-.217.215-.317l11.505-6.702c.236-.138.615-.371.844-.519l.715-.464a.488.488 0 0 1 .266-.089c.172 0 .345.13.345.421 0 .214.001.363.003.437l.006.004-.004.069c-.003.075-.003.075-.486.356l-11.505 6.702a2.282 2.282 0 0 1-.992.268zm-.6-.25l.034.001h.566c.252 0 .649-.108.866-.234l11.505-6.702c.168-.098.294-.173.361-.214-.004-.084-.004-.218-.004-.437l-.095-.171-.131.049-.714.463c-.232.15-.616.386-.854.525l-11.505 6.702-.029.018z' fill='#607D8B'/><path d='M75.266 89.871H74.7c-.2 0-.316-.056-.346-.166-.03-.11.043-.217.215-.317l11.505-6.702c.258-.151.694-.268.993-.268h.565c.2 0 .316.056.346.166.03.11-.043.217-.215.317l-11.505 6.702a2.282 2.282 0 0 1-.992.268zm-.6-.25l.034.001h.566c.252 0 .649-.107.866-.234l11.505-6.702.03-.018-.035-.001h-.565c-.252 0-.649.108-.867.234l-11.505 6.702-.029.018zM74.37 90.801v-1.247 1.247' fill='#607D8B'/><path d='M68.13 93.901c-.751-.093-1.314-.737-1.439-1.376-.831-4.238-1.151-8.782-1.165-21.352-.015-12.784.897-19.745.897-19.745.711-4.146 2.787-5.192 2.787-5.192l74.859-43.219c.223-.129 2.487-1.584 3.195.923 1.95 6.9 1.488 31.887.275 39.878-.389 2.565-1.248 5.215-3.056 6.283L69.21 93.653c-.382.221-.749.288-1.08.248 0 0-2.781-.441-3.001-2.125-.561-4.281-1.152-8.781-1.167-21.351-.014-12.784.898-19.745.898-19.745.71-4.146 2.787-5.191 2.787-5.191l6.598-3.81.871-.119 6.599-3.83.046-.461L68.13 93.901' fill='#FAFAFA'/><path d='M68.317 94.161l-.215-.013h-.001l-.244-.047c-.719-.156-2.772-.736-2.976-2.292-.568-4.34-1.154-8.813-1.168-21.384-.014-12.654.891-19.707.9-19.777.725-4.231 2.832-5.338 2.922-5.382l6.628-3.827.87-.119 6.446-3.742.034-.334a.248.248 0 0 1 .273-.223.248.248 0 0 1 .223.272l-.059.589-6.752 3.919-.87.118-6.556 3.785c-.031.016-1.99 1.068-2.666 5.018-.007.06-.908 7.086-.894 19.702.014 12.539.597 16.996 1.161 21.305.091.691.689 1.154 1.309 1.452a1.95 1.95 0 0 1-.236-.609c-.781-3.984-1.155-8.202-1.17-21.399-.014-12.653.891-19.707.9-19.777.725-4.231 2.832-5.337 2.922-5.382-.004.001 74.444-42.98 74.846-43.212l.028-.017c.904-.538 1.72-.688 2.36-.433.555.221.949.733 1.172 1.52 2.014 7.128 1.46 32.219.281 39.983-.507 3.341-1.575 5.515-3.175 6.462L69.335 93.869a2.023 2.023 0 0 1-1.018.292zm-.147-.507c.293.036.604-.037.915-.217l75.273-43.551c1.823-1.078 2.602-3.915 2.934-6.106 1.174-7.731 1.731-32.695-.268-39.772-.178-.631-.473-1.032-.876-1.192-.484-.193-1.166-.052-1.921.397l-.034.021-74.858 43.218c-.031.017-1.989 1.069-2.666 5.019-.007.059-.908 7.085-.894 19.702.015 13.155.386 17.351 1.161 21.303.09.461.476.983 1.037 1.139.114.025.185.037.196.039h.001z' fill='#455A64'/><path d='M69.317 68.982c.489-.281.885-.056.885.505 0 .56-.396 1.243-.885 1.525-.488.282-.884.057-.884-.504 0-.56.396-1.243.884-1.526' fill='#FFF'/><path d='M68.92 71.133c-.289 0-.487-.228-.487-.625 0-.56.396-1.243.884-1.526a.812.812 0 0 1 .397-.121c.289 0 .488.229.488.626 0 .56-.396 1.243-.885 1.525a.812.812 0 0 1-.397.121m.794-2.459a.976.976 0 0 0-.49.147c-.548.317-.978 1.058-.978 1.687 0 .486.271.812.674.812a.985.985 0 0 0 .491-.146c.548-.317.978-1.057.978-1.687 0-.486-.272-.813-.675-.813' fill='#8097A2'/><path d='M68.92 70.947c-.271 0-.299-.307-.299-.439 0-.491.361-1.116.79-1.363a.632.632 0 0 1 .303-.096c.272 0 .301.306.301.438 0 .491-.363 1.116-.791 1.364a.629.629 0 0 1-.304.096m.794-2.086a.812.812 0 0 0-.397.121c-.488.283-.884.966-.884 1.526 0 .397.198.625.487.625a.812.812 0 0 0 .397-.121c.489-.282.885-.965.885-1.525 0-.397-.199-.626-.488-.626' fill='#8097A2'/><path d='M69.444 85.35c.264-.152.477-.031.477.272 0 .303-.213.67-.477.822-.263.153-.477.031-.477-.271 0-.302.214-.671.477-.823' fill='#FFF'/><path d='M69.23 86.51c-.156 0-.263-.123-.263-.337 0-.302.214-.671.477-.823a.431.431 0 0 1 .214-.066c.156 0 .263.124.263.338 0 .303-.213.67-.477.822a.431.431 0 0 1-.214.066m.428-1.412c-.1 0-.203.029-.307.09-.32.185-.57.618-.57.985 0 .309.185.524.449.524a.63.63 0 0 0 .308-.09c.32-.185.57-.618.57-.985 0-.309-.185-.524-.45-.524' fill='#8097A2'/><path d='M69.23 86.322l-.076-.149c0-.235.179-.544.384-.661l.12-.041.076.151c0 .234-.179.542-.383.66l-.121.04m.428-1.038a.431.431 0 0 0-.214.066c-.263.152-.477.521-.477.823 0 .214.107.337.263.337a.431.431 0 0 0 .214-.066c.264-.152.477-.519.477-.822 0-.214-.107-.338-.263-.338' fill='#8097A2'/><path d='M139.278 7.769v43.667L72.208 90.16V46.493l67.07-38.724' fill='#455A64'/><path d='M72.083 90.375V46.421l.063-.036 67.257-38.831v43.954l-.062.036-67.258 38.831zm.25-43.811v43.38l66.821-38.579V7.985L72.333 46.564z' fill='#607D8B'/></g><path d='M125.737 88.647l-7.639 3.334V84l-11.459 4.713v8.269L99 100.315l13.369 3.646 13.368-15.314' fill='#455A64'/></g></svg>";
+function RotateInstructions() {
+  this.loadIcon_();
+  var overlay = document.createElement('div');
+  var s = overlay.style;
+  s.position = 'fixed';
+  s.top = 0;
+  s.right = 0;
+  s.bottom = 0;
+  s.left = 0;
+  s.backgroundColor = 'gray';
+  s.fontFamily = 'sans-serif';
+  s.zIndex = 1000000;
+  var img = document.createElement('img');
+  img.src = this.icon;
+  var s = img.style;
+  s.marginLeft = '25%';
+  s.marginTop = '25%';
+  s.width = '50%';
+  overlay.appendChild(img);
+  var text = document.createElement('div');
+  var s = text.style;
+  s.textAlign = 'center';
+  s.fontSize = '16px';
+  s.lineHeight = '24px';
+  s.margin = '24px 25%';
+  s.width = '50%';
+  text.innerHTML = 'Place your phone into your Cardboard viewer.';
+  overlay.appendChild(text);
+  var snackbar = document.createElement('div');
+  var s = snackbar.style;
+  s.backgroundColor = '#CFD8DC';
+  s.position = 'fixed';
+  s.bottom = 0;
+  s.width = '100%';
+  s.height = '48px';
+  s.padding = '14px 24px';
+  s.boxSizing = 'border-box';
+  s.color = '#656A6B';
+  overlay.appendChild(snackbar);
+  var snackbarText = document.createElement('div');
+  snackbarText.style.float = 'left';
+  snackbarText.innerHTML = 'No Cardboard viewer?';
+  var snackbarButton = document.createElement('a');
+  snackbarButton.href = 'https://www.google.com/get/cardboard/get-cardboard/';
+  snackbarButton.innerHTML = 'get one';
+  snackbarButton.target = '_blank';
+  var s = snackbarButton.style;
+  s.float = 'right';
+  s.fontWeight = 600;
+  s.textTransform = 'uppercase';
+  s.borderLeft = '1px solid gray';
+  s.paddingLeft = '24px';
+  s.textDecoration = 'none';
+  s.color = '#656A6B';
+  snackbar.appendChild(snackbarText);
+  snackbar.appendChild(snackbarButton);
+  this.overlay = overlay;
+  this.text = text;
+  this.hide();
+}
+RotateInstructions.prototype.show = function (parent) {
+  if (!parent && !this.overlay.parentElement) {
+    document.body.appendChild(this.overlay);
+  } else if (parent) {
+    if (this.overlay.parentElement && this.overlay.parentElement != parent) this.overlay.parentElement.removeChild(this.overlay);
+    parent.appendChild(this.overlay);
+  }
+  this.overlay.style.display = 'block';
+  var img = this.overlay.querySelector('img');
+  var s = img.style;
+  if (isLandscapeMode()) {
+    s.width = '20%';
+    s.marginLeft = '40%';
+    s.marginTop = '3%';
+  } else {
+    s.width = '50%';
+    s.marginLeft = '25%';
+    s.marginTop = '25%';
+  }
+};
+RotateInstructions.prototype.hide = function () {
+  this.overlay.style.display = 'none';
+};
+RotateInstructions.prototype.showTemporarily = function (ms, parent) {
+  this.show(parent);
+  this.timer = setTimeout(this.hide.bind(this), ms);
+};
+RotateInstructions.prototype.disableShowTemporarily = function () {
+  clearTimeout(this.timer);
+};
+RotateInstructions.prototype.update = function () {
+  this.disableShowTemporarily();
+  if (!isLandscapeMode() && isMobile()) {
+    this.show();
+  } else {
+    this.hide();
+  }
+};
+RotateInstructions.prototype.loadIcon_ = function () {
+  this.icon = dataUri('image/svg+xml', rotateInstructionsAsset);
+};
+var DEFAULT_VIEWER = 'CardboardV1';
+var VIEWER_KEY = 'WEBVR_CARDBOARD_VIEWER';
+var CLASS_NAME = 'webvr-polyfill-viewer-selector';
+function ViewerSelector(defaultViewer) {
+  try {
+    this.selectedKey = localStorage.getItem(VIEWER_KEY);
+  } catch (error) {
+    console.error('Failed to load viewer profile: %s', error);
+  }
+  if (!this.selectedKey) {
+    this.selectedKey = defaultViewer || DEFAULT_VIEWER;
+  }
+  this.dialog = this.createDialog_(DeviceInfo.Viewers);
+  this.root = null;
+  this.onChangeCallbacks_ = [];
+}
+ViewerSelector.prototype.show = function (root) {
+  this.root = root;
+  root.appendChild(this.dialog);
+  var selected = this.dialog.querySelector('#' + this.selectedKey);
+  selected.checked = true;
+  this.dialog.style.display = 'block';
+};
+ViewerSelector.prototype.hide = function () {
+  if (this.root && this.root.contains(this.dialog)) {
+    this.root.removeChild(this.dialog);
+  }
+  this.dialog.style.display = 'none';
+};
+ViewerSelector.prototype.getCurrentViewer = function () {
+  return DeviceInfo.Viewers[this.selectedKey];
+};
+ViewerSelector.prototype.getSelectedKey_ = function () {
+  var input = this.dialog.querySelector('input[name=field]:checked');
+  if (input) {
+    return input.id;
+  }
+  return null;
+};
+ViewerSelector.prototype.onChange = function (cb) {
+  this.onChangeCallbacks_.push(cb);
+};
+ViewerSelector.prototype.fireOnChange_ = function (viewer) {
+  for (var i = 0; i < this.onChangeCallbacks_.length; i++) {
+    this.onChangeCallbacks_[i](viewer);
+  }
+};
+ViewerSelector.prototype.onSave_ = function () {
+  this.selectedKey = this.getSelectedKey_();
+  if (!this.selectedKey || !DeviceInfo.Viewers[this.selectedKey]) {
+    console.error('ViewerSelector.onSave_: this should never happen!');
+    return;
+  }
+  this.fireOnChange_(DeviceInfo.Viewers[this.selectedKey]);
+  try {
+    localStorage.setItem(VIEWER_KEY, this.selectedKey);
+  } catch (error) {
+    console.error('Failed to save viewer profile: %s', error);
+  }
+  this.hide();
+};
+ViewerSelector.prototype.createDialog_ = function (options) {
+  var container = document.createElement('div');
+  container.classList.add(CLASS_NAME);
+  container.style.display = 'none';
+  var overlay = document.createElement('div');
+  var s = overlay.style;
+  s.position = 'fixed';
+  s.left = 0;
+  s.top = 0;
+  s.width = '100%';
+  s.height = '100%';
+  s.background = 'rgba(0, 0, 0, 0.3)';
+  overlay.addEventListener('click', this.hide.bind(this));
+  var width = 280;
+  var dialog = document.createElement('div');
+  var s = dialog.style;
+  s.boxSizing = 'border-box';
+  s.position = 'fixed';
+  s.top = '24px';
+  s.left = '50%';
+  s.marginLeft = -width / 2 + 'px';
+  s.width = width + 'px';
+  s.padding = '24px';
+  s.overflow = 'hidden';
+  s.background = '#fafafa';
+  s.fontFamily = "'Roboto', sans-serif";
+  s.boxShadow = '0px 5px 20px #666';
+  dialog.appendChild(this.createH1_('Select your viewer'));
+  for (var id in options) {
+    dialog.appendChild(this.createChoice_(id, options[id].label));
+  }
+  dialog.appendChild(this.createButton_('Save', this.onSave_.bind(this)));
+  container.appendChild(overlay);
+  container.appendChild(dialog);
+  return container;
+};
+ViewerSelector.prototype.createH1_ = function (name) {
+  var h1 = document.createElement('h1');
+  var s = h1.style;
+  s.color = 'black';
+  s.fontSize = '20px';
+  s.fontWeight = 'bold';
+  s.marginTop = 0;
+  s.marginBottom = '24px';
+  h1.innerHTML = name;
+  return h1;
+};
+ViewerSelector.prototype.createChoice_ = function (id, name) {
+  var div = document.createElement('div');
+  div.style.marginTop = '8px';
+  div.style.color = 'black';
+  var input = document.createElement('input');
+  input.style.fontSize = '30px';
+  input.setAttribute('id', id);
+  input.setAttribute('type', 'radio');
+  input.setAttribute('value', id);
+  input.setAttribute('name', 'field');
+  var label = document.createElement('label');
+  label.style.marginLeft = '4px';
+  label.setAttribute('for', id);
+  label.innerHTML = name;
+  div.appendChild(input);
+  div.appendChild(label);
+  return div;
+};
+ViewerSelector.prototype.createButton_ = function (label, onclick) {
+  var button = document.createElement('button');
+  button.innerHTML = label;
+  var s = button.style;
+  s.float = 'right';
+  s.textTransform = 'uppercase';
+  s.color = '#1094f7';
+  s.fontSize = '14px';
+  s.letterSpacing = 0;
+  s.border = 0;
+  s.background = 'none';
+  s.marginTop = '16px';
+  button.addEventListener('click', onclick);
+  return button;
+};
+var commonjsGlobal$$1 = typeof window !== 'undefined' ? window : typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : typeof self !== 'undefined' ? self : {};
+function unwrapExports$$1 (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+function createCommonjsModule$$1(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+var NoSleep = createCommonjsModule$$1(function (module, exports) {
+(function webpackUniversalModuleDefinition(root, factory) {
+	module.exports = factory();
+})(commonjsGlobal$$1, function() {
+return          (function(modules) {
+         	var installedModules = {};
+         	function __webpack_require__(moduleId) {
+         		if(installedModules[moduleId]) {
+         			return installedModules[moduleId].exports;
+         		}
+         		var module = installedModules[moduleId] = {
+         			i: moduleId,
+         			l: false,
+         			exports: {}
+         		};
+         		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+         		module.l = true;
+         		return module.exports;
+         	}
+         	__webpack_require__.m = modules;
+         	__webpack_require__.c = installedModules;
+         	__webpack_require__.d = function(exports, name, getter) {
+         		if(!__webpack_require__.o(exports, name)) {
+         			Object.defineProperty(exports, name, {
+         				configurable: false,
+         				enumerable: true,
+         				get: getter
+         			});
+         		}
+         	};
+         	__webpack_require__.n = function(module) {
+         		var getter = module && module.__esModule ?
+         			function getDefault() { return module['default']; } :
+         			function getModuleExports() { return module; };
+         		__webpack_require__.d(getter, 'a', getter);
+         		return getter;
+         	};
+         	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+         	__webpack_require__.p = "";
+         	return __webpack_require__(__webpack_require__.s = 0);
+         })
+         ([
+      (function(module, exports, __webpack_require__) {
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+var mediaFile = __webpack_require__(1);
+var oldIOS = typeof navigator !== 'undefined' && parseFloat(('' + (/CPU.*OS ([0-9_]{3,4})[0-9_]{0,1}|(CPU like).*AppleWebKit.*Mobile/i.exec(navigator.userAgent) || [0, ''])[1]).replace('undefined', '3_2').replace('_', '.').replace('_', '')) < 10 && !window.MSStream;
+var NoSleep = function () {
+  function NoSleep() {
+    _classCallCheck(this, NoSleep);
+    if (oldIOS) {
+      this.noSleepTimer = null;
+    } else {
+      this.noSleepVideo = document.createElement('video');
+      this.noSleepVideo.setAttribute('playsinline', '');
+      this.noSleepVideo.setAttribute('src', mediaFile);
+      this.noSleepVideo.addEventListener('timeupdate', function (e) {
+        if (this.noSleepVideo.currentTime > 0.5) {
+          this.noSleepVideo.currentTime = Math.random();
+        }
+      }.bind(this));
+    }
+  }
+  _createClass(NoSleep, [{
+    key: 'enable',
+    value: function enable() {
+      if (oldIOS) {
+        this.disable();
+        this.noSleepTimer = window.setInterval(function () {
+          window.location.href = '/';
+          window.setTimeout(window.stop, 0);
+        }, 15000);
+      } else {
+        this.noSleepVideo.play();
+      }
+    }
+  }, {
+    key: 'disable',
+    value: function disable() {
+      if (oldIOS) {
+        if (this.noSleepTimer) {
+          window.clearInterval(this.noSleepTimer);
+          this.noSleepTimer = null;
+        }
+      } else {
+        this.noSleepVideo.pause();
+      }
+    }
+  }]);
+  return NoSleep;
+}();
+module.exports = NoSleep;
+      }),
+      (function(module, exports, __webpack_require__) {
+module.exports = 'data:video/mp4;base64,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';
+      })
+         ]);
+});
+});
+var NoSleep$1 = unwrapExports$$1(NoSleep);
+var nextDisplayId = 1000;
+var defaultLeftBounds = [0, 0, 0.5, 1];
+var defaultRightBounds = [0.5, 0, 0.5, 1];
+var raf = window.requestAnimationFrame;
+var caf = window.cancelAnimationFrame;
+function VRFrameData() {
+  this.leftProjectionMatrix = new Float32Array(16);
+  this.leftViewMatrix = new Float32Array(16);
+  this.rightProjectionMatrix = new Float32Array(16);
+  this.rightViewMatrix = new Float32Array(16);
+  this.pose = null;
+}
+function VRDisplayCapabilities(config) {
+  Object.defineProperties(this, {
+    hasPosition: {
+      writable: false, enumerable: true, value: config.hasPosition
+    },
+    hasExternalDisplay: {
+      writable: false, enumerable: true, value: config.hasExternalDisplay
+    },
+    canPresent: {
+      writable: false, enumerable: true, value: config.canPresent
+    },
+    maxLayers: {
+      writable: false, enumerable: true, value: config.maxLayers
+    },
+    hasOrientation: {
+      enumerable: true, get: function get() {
+        deprecateWarning('VRDisplayCapabilities.prototype.hasOrientation', 'VRDisplay.prototype.getFrameData');
+        return config.hasOrientation;
+      }
+    }
+  });
+}
+function VRDisplay(config) {
+  config = config || {};
+  var USE_WAKELOCK = 'wakelock' in config ? config.wakelock : true;
+  this.isPolyfilled = true;
+  this.displayId = nextDisplayId++;
+  this.displayName = '';
+  this.depthNear = 0.01;
+  this.depthFar = 10000.0;
+  this.isPresenting = false;
+  Object.defineProperty(this, 'isConnected', {
+    get: function get() {
+      deprecateWarning('VRDisplay.prototype.isConnected', 'VRDisplayCapabilities.prototype.hasExternalDisplay');
+      return false;
+    }
+  });
+  this.capabilities = new VRDisplayCapabilities({
+    hasPosition: false,
+    hasOrientation: false,
+    hasExternalDisplay: false,
+    canPresent: false,
+    maxLayers: 1
+  });
+  this.stageParameters = null;
+  this.waitingForPresent_ = false;
+  this.layer_ = null;
+  this.originalParent_ = null;
+  this.fullscreenElement_ = null;
+  this.fullscreenWrapper_ = null;
+  this.fullscreenElementCachedStyle_ = null;
+  this.fullscreenEventTarget_ = null;
+  this.fullscreenChangeHandler_ = null;
+  this.fullscreenErrorHandler_ = null;
+  if (USE_WAKELOCK && isMobile()) {
+    this.wakelock_ = new NoSleep$1();
+  }
+}
+VRDisplay.prototype.getFrameData = function (frameData) {
+  return frameDataFromPose(frameData, this._getPose(), this);
+};
+VRDisplay.prototype.getPose = function () {
+  deprecateWarning('VRDisplay.prototype.getPose', 'VRDisplay.prototype.getFrameData');
+  return this._getPose();
+};
+VRDisplay.prototype.resetPose = function () {
+  deprecateWarning('VRDisplay.prototype.resetPose');
+  return this._resetPose();
+};
+VRDisplay.prototype.getImmediatePose = function () {
+  deprecateWarning('VRDisplay.prototype.getImmediatePose', 'VRDisplay.prototype.getFrameData');
+  return this._getPose();
+};
+VRDisplay.prototype.requestAnimationFrame = function (callback) {
+  return raf(callback);
+};
+VRDisplay.prototype.cancelAnimationFrame = function (id) {
+  return caf(id);
+};
+VRDisplay.prototype.wrapForFullscreen = function (element) {
+  if (isIOS()) {
+    return element;
+  }
+  if (!this.fullscreenWrapper_) {
+    this.fullscreenWrapper_ = document.createElement('div');
+    var cssProperties = ['height: ' + Math.min(screen.height, screen.width) + 'px !important', 'top: 0 !important', 'left: 0 !important', 'right: 0 !important', 'border: 0', 'margin: 0', 'padding: 0', 'z-index: 999999 !important', 'position: fixed'];
+    this.fullscreenWrapper_.setAttribute('style', cssProperties.join('; ') + ';');
+    this.fullscreenWrapper_.classList.add('webvr-polyfill-fullscreen-wrapper');
+  }
+  if (this.fullscreenElement_ == element) {
+    return this.fullscreenWrapper_;
+  }
+  if (this.fullscreenElement_) {
+    if (this.originalParent_) {
+      this.originalParent_.appendChild(this.fullscreenElement_);
+    } else {
+      this.fullscreenElement_.parentElement.removeChild(this.fullscreenElement_);
+    }
+  }
+  this.fullscreenElement_ = element;
+  this.originalParent_ = element.parentElement;
+  if (!this.originalParent_) {
+    document.body.appendChild(element);
+  }
+  if (!this.fullscreenWrapper_.parentElement) {
+    var parent = this.fullscreenElement_.parentElement;
+    parent.insertBefore(this.fullscreenWrapper_, this.fullscreenElement_);
+    parent.removeChild(this.fullscreenElement_);
+  }
+  this.fullscreenWrapper_.insertBefore(this.fullscreenElement_, this.fullscreenWrapper_.firstChild);
+  this.fullscreenElementCachedStyle_ = this.fullscreenElement_.getAttribute('style');
+  var self = this;
+  function applyFullscreenElementStyle() {
+    if (!self.fullscreenElement_) {
+      return;
+    }
+    var cssProperties = ['position: absolute', 'top: 0', 'left: 0', 'width: ' + Math.max(screen.width, screen.height) + 'px', 'height: ' + Math.min(screen.height, screen.width) + 'px', 'border: 0', 'margin: 0', 'padding: 0'];
+    self.fullscreenElement_.setAttribute('style', cssProperties.join('; ') + ';');
+  }
+  applyFullscreenElementStyle();
+  return this.fullscreenWrapper_;
+};
+VRDisplay.prototype.removeFullscreenWrapper = function () {
+  if (!this.fullscreenElement_) {
+    return;
+  }
+  var element = this.fullscreenElement_;
+  if (this.fullscreenElementCachedStyle_) {
+    element.setAttribute('style', this.fullscreenElementCachedStyle_);
+  } else {
+    element.removeAttribute('style');
+  }
+  this.fullscreenElement_ = null;
+  this.fullscreenElementCachedStyle_ = null;
+  var parent = this.fullscreenWrapper_.parentElement;
+  this.fullscreenWrapper_.removeChild(element);
+  if (this.originalParent_ === parent) {
+    parent.insertBefore(element, this.fullscreenWrapper_);
+  }
+  else if (this.originalParent_) {
+      this.originalParent_.appendChild(element);
+    }
+  parent.removeChild(this.fullscreenWrapper_);
+  return element;
+};
+VRDisplay.prototype.requestPresent = function (layers) {
+  var wasPresenting = this.isPresenting;
+  var self = this;
+  if (!(layers instanceof Array)) {
+    deprecateWarning('VRDisplay.prototype.requestPresent with non-array argument', 'an array of VRLayers as the first argument');
+    layers = [layers];
+  }
+  return new Promise(function (resolve, reject) {
+    if (!self.capabilities.canPresent) {
+      reject(new Error('VRDisplay is not capable of presenting.'));
+      return;
+    }
+    if (layers.length == 0 || layers.length > self.capabilities.maxLayers) {
+      reject(new Error('Invalid number of layers.'));
+      return;
+    }
+    var incomingLayer = layers[0];
+    if (!incomingLayer.source) {
+      resolve();
+      return;
+    }
+    var leftBounds = incomingLayer.leftBounds || defaultLeftBounds;
+    var rightBounds = incomingLayer.rightBounds || defaultRightBounds;
+    if (wasPresenting) {
+      var layer = self.layer_;
+      if (layer.source !== incomingLayer.source) {
+        layer.source = incomingLayer.source;
+      }
+      for (var i = 0; i < 4; i++) {
+        layer.leftBounds[i] = leftBounds[i];
+        layer.rightBounds[i] = rightBounds[i];
+      }
+      self.wrapForFullscreen(self.layer_.source);
+      self.updatePresent_();
+      resolve();
+      return;
+    }
+    self.layer_ = {
+      predistorted: incomingLayer.predistorted,
+      source: incomingLayer.source,
+      leftBounds: leftBounds.slice(0),
+      rightBounds: rightBounds.slice(0)
+    };
+    self.waitingForPresent_ = false;
+    if (self.layer_ && self.layer_.source) {
+      var fullscreenElement = self.wrapForFullscreen(self.layer_.source);
+      var onFullscreenChange = function onFullscreenChange() {
+        var actualFullscreenElement = getFullscreenElement();
+        self.isPresenting = fullscreenElement === actualFullscreenElement;
+        if (self.isPresenting) {
+          if (screen.orientation && screen.orientation.lock) {
+            screen.orientation.lock('landscape-primary').catch(function (error) {
+              console.error('screen.orientation.lock() failed due to', error.message);
+            });
+          }
+          self.waitingForPresent_ = false;
+          self.beginPresent_();
+          resolve();
+        } else {
+          if (screen.orientation && screen.orientation.unlock) {
+            screen.orientation.unlock();
+          }
+          self.removeFullscreenWrapper();
+          self.disableWakeLock();
+          self.endPresent_();
+          self.removeFullscreenListeners_();
+        }
+        self.fireVRDisplayPresentChange_();
+      };
+      var onFullscreenError = function onFullscreenError() {
+        if (!self.waitingForPresent_) {
+          return;
+        }
+        self.removeFullscreenWrapper();
+        self.removeFullscreenListeners_();
+        self.disableWakeLock();
+        self.waitingForPresent_ = false;
+        self.isPresenting = false;
+        reject(new Error('Unable to present.'));
+      };
+      self.addFullscreenListeners_(fullscreenElement, onFullscreenChange, onFullscreenError);
+      if (requestFullscreen(fullscreenElement)) {
+        self.enableWakeLock();
+        self.waitingForPresent_ = true;
+      } else if (isIOS() || isWebViewAndroid()) {
+        self.enableWakeLock();
+        self.isPresenting = true;
+        self.beginPresent_();
+        self.fireVRDisplayPresentChange_();
+        resolve();
+      }
+    }
+    if (!self.waitingForPresent_ && !isIOS()) {
+      exitFullscreen();
+      reject(new Error('Unable to present.'));
+    }
+  });
+};
+VRDisplay.prototype.exitPresent = function () {
+  var wasPresenting = this.isPresenting;
+  var self = this;
+  this.isPresenting = false;
+  this.layer_ = null;
+  this.disableWakeLock();
+  return new Promise(function (resolve, reject) {
+    if (wasPresenting) {
+      if (!exitFullscreen() && isIOS()) {
+        self.endPresent_();
+        self.fireVRDisplayPresentChange_();
+      }
+      if (isWebViewAndroid()) {
+        self.removeFullscreenWrapper();
+        self.removeFullscreenListeners_();
+        self.endPresent_();
+        self.fireVRDisplayPresentChange_();
+      }
+      resolve();
+    } else {
+      reject(new Error('Was not presenting to VRDisplay.'));
+    }
+  });
+};
+VRDisplay.prototype.getLayers = function () {
+  if (this.layer_) {
+    return [this.layer_];
+  }
+  return [];
+};
+VRDisplay.prototype.fireVRDisplayPresentChange_ = function () {
+  var event = new CustomEvent('vrdisplaypresentchange', { detail: { display: this } });
+  window.dispatchEvent(event);
+};
+VRDisplay.prototype.fireVRDisplayConnect_ = function () {
+  var event = new CustomEvent('vrdisplayconnect', { detail: { display: this } });
+  window.dispatchEvent(event);
+};
+VRDisplay.prototype.addFullscreenListeners_ = function (element, changeHandler, errorHandler) {
+  this.removeFullscreenListeners_();
+  this.fullscreenEventTarget_ = element;
+  this.fullscreenChangeHandler_ = changeHandler;
+  this.fullscreenErrorHandler_ = errorHandler;
+  if (changeHandler) {
+    if (document.fullscreenEnabled) {
+      element.addEventListener('fullscreenchange', changeHandler, false);
+    } else if (document.webkitFullscreenEnabled) {
+      element.addEventListener('webkitfullscreenchange', changeHandler, false);
+    } else if (document.mozFullScreenEnabled) {
+      document.addEventListener('mozfullscreenchange', changeHandler, false);
+    } else if (document.msFullscreenEnabled) {
+      element.addEventListener('msfullscreenchange', changeHandler, false);
+    }
+  }
+  if (errorHandler) {
+    if (document.fullscreenEnabled) {
+      element.addEventListener('fullscreenerror', errorHandler, false);
+    } else if (document.webkitFullscreenEnabled) {
+      element.addEventListener('webkitfullscreenerror', errorHandler, false);
+    } else if (document.mozFullScreenEnabled) {
+      document.addEventListener('mozfullscreenerror', errorHandler, false);
+    } else if (document.msFullscreenEnabled) {
+      element.addEventListener('msfullscreenerror', errorHandler, false);
+    }
+  }
+};
+VRDisplay.prototype.removeFullscreenListeners_ = function () {
+  if (!this.fullscreenEventTarget_) return;
+  var element = this.fullscreenEventTarget_;
+  if (this.fullscreenChangeHandler_) {
+    var changeHandler = this.fullscreenChangeHandler_;
+    element.removeEventListener('fullscreenchange', changeHandler, false);
+    element.removeEventListener('webkitfullscreenchange', changeHandler, false);
+    document.removeEventListener('mozfullscreenchange', changeHandler, false);
+    element.removeEventListener('msfullscreenchange', changeHandler, false);
+  }
+  if (this.fullscreenErrorHandler_) {
+    var errorHandler = this.fullscreenErrorHandler_;
+    element.removeEventListener('fullscreenerror', errorHandler, false);
+    element.removeEventListener('webkitfullscreenerror', errorHandler, false);
+    document.removeEventListener('mozfullscreenerror', errorHandler, false);
+    element.removeEventListener('msfullscreenerror', errorHandler, false);
+  }
+  this.fullscreenEventTarget_ = null;
+  this.fullscreenChangeHandler_ = null;
+  this.fullscreenErrorHandler_ = null;
+};
+VRDisplay.prototype.enableWakeLock = function () {
+  if (this.wakelock_) {
+    this.wakelock_.enable();
+  }
+};
+VRDisplay.prototype.disableWakeLock = function () {
+  if (this.wakelock_) {
+    this.wakelock_.disable();
+  }
+};
+VRDisplay.prototype.beginPresent_ = function () {
+};
+VRDisplay.prototype.endPresent_ = function () {
+};
+VRDisplay.prototype.submitFrame = function (pose) {
+};
+VRDisplay.prototype.getEyeParameters = function (whichEye) {
+  return null;
+};
+var config = {
+  ADDITIONAL_VIEWERS: [],
+  DEFAULT_VIEWER: '',
+  MOBILE_WAKE_LOCK: true,
+  DEBUG: false,
+  DPDB_URL: 'https://dpdb.webvr.rocks/dpdb.json',
+  K_FILTER: 0.98,
+  PREDICTION_TIME_S: 0.040,
+  CARDBOARD_UI_DISABLED: false,
+  ROTATE_INSTRUCTIONS_DISABLED: false,
+  YAW_ONLY: false,
+  BUFFER_SCALE: 0.5,
+  DIRTY_SUBMIT_FRAME_BINDINGS: false
+};
+var Eye = {
+  LEFT: 'left',
+  RIGHT: 'right'
+};
+function CardboardVRDisplay(config$$1) {
+  var defaults = extend({}, config);
+  config$$1 = extend(defaults, config$$1 || {});
+  VRDisplay.call(this, {
+    wakelock: config$$1.MOBILE_WAKE_LOCK
+  });
+  this.config = config$$1;
+  this.displayName = 'Cardboard VRDisplay';
+  this.capabilities = new VRDisplayCapabilities({
+    hasPosition: false,
+    hasOrientation: true,
+    hasExternalDisplay: false,
+    canPresent: true,
+    maxLayers: 1
+  });
+  this.stageParameters = null;
+  this.bufferScale_ = this.config.BUFFER_SCALE;
+  this.poseSensor_ = new PoseSensor(this.config);
+  this.distorter_ = null;
+  this.cardboardUI_ = null;
+  this.dpdb_ = new Dpdb(this.config.DPDB_URL, this.onDeviceParamsUpdated_.bind(this));
+  this.deviceInfo_ = new DeviceInfo(this.dpdb_.getDeviceParams(), config$$1.ADDITIONAL_VIEWERS);
+  this.viewerSelector_ = new ViewerSelector(config$$1.DEFAULT_VIEWER);
+  this.viewerSelector_.onChange(this.onViewerChanged_.bind(this));
+  this.deviceInfo_.setViewer(this.viewerSelector_.getCurrentViewer());
+  if (!this.config.ROTATE_INSTRUCTIONS_DISABLED) {
+    this.rotateInstructions_ = new RotateInstructions();
+  }
+  if (isIOS()) {
+    window.addEventListener('resize', this.onResize_.bind(this));
+  }
+}
+CardboardVRDisplay.prototype = Object.create(VRDisplay.prototype);
+CardboardVRDisplay.prototype._getPose = function () {
+  return {
+    position: null,
+    orientation: this.poseSensor_.getOrientation(),
+    linearVelocity: null,
+    linearAcceleration: null,
+    angularVelocity: null,
+    angularAcceleration: null
+  };
+};
+CardboardVRDisplay.prototype._resetPose = function () {
+  if (this.poseSensor_.resetPose) {
+    this.poseSensor_.resetPose();
+  }
+};
+CardboardVRDisplay.prototype._getFieldOfView = function (whichEye) {
+  var fieldOfView;
+  if (whichEye == Eye.LEFT) {
+    fieldOfView = this.deviceInfo_.getFieldOfViewLeftEye();
+  } else if (whichEye == Eye.RIGHT) {
+    fieldOfView = this.deviceInfo_.getFieldOfViewRightEye();
+  } else {
+    console.error('Invalid eye provided: %s', whichEye);
+    return null;
+  }
+  return fieldOfView;
+};
+CardboardVRDisplay.prototype._getEyeOffset = function (whichEye) {
+  var offset;
+  if (whichEye == Eye.LEFT) {
+    offset = [-this.deviceInfo_.viewer.interLensDistance * 0.5, 0.0, 0.0];
+  } else if (whichEye == Eye.RIGHT) {
+    offset = [this.deviceInfo_.viewer.interLensDistance * 0.5, 0.0, 0.0];
+  } else {
+    console.error('Invalid eye provided: %s', whichEye);
+    return null;
+  }
+  return offset;
+};
+CardboardVRDisplay.prototype.getEyeParameters = function (whichEye) {
+  var offset = this._getEyeOffset(whichEye);
+  var fieldOfView = this._getFieldOfView(whichEye);
+  var eyeParams = {
+    offset: offset,
+    renderWidth: this.deviceInfo_.device.width * 0.5 * this.bufferScale_,
+    renderHeight: this.deviceInfo_.device.height * this.bufferScale_
+  };
+  Object.defineProperty(eyeParams, 'fieldOfView', {
+    enumerable: true,
+    get: function get() {
+      deprecateWarning('VRFieldOfView', 'VRFrameData\'s projection matrices');
+      return fieldOfView;
+    }
+  });
+  return eyeParams;
+};
+CardboardVRDisplay.prototype.onDeviceParamsUpdated_ = function (newParams) {
+  if (this.config.DEBUG) {
+    console.log('DPDB reported that device params were updated.');
+  }
+  this.deviceInfo_.updateDeviceParams(newParams);
+  if (this.distorter_) {
+    this.distorter_.updateDeviceInfo(this.deviceInfo_);
+  }
+};
+CardboardVRDisplay.prototype.updateBounds_ = function () {
+  if (this.layer_ && this.distorter_ && (this.layer_.leftBounds || this.layer_.rightBounds)) {
+    this.distorter_.setTextureBounds(this.layer_.leftBounds, this.layer_.rightBounds);
+  }
+};
+CardboardVRDisplay.prototype.beginPresent_ = function () {
+  var gl = this.layer_.source.getContext('webgl');
+  if (!gl) gl = this.layer_.source.getContext('experimental-webgl');
+  if (!gl) gl = this.layer_.source.getContext('webgl2');
+  if (!gl) return;
+  if (this.layer_.predistorted) {
+    if (!this.config.CARDBOARD_UI_DISABLED) {
+      gl.canvas.width = getScreenWidth() * this.bufferScale_;
+      gl.canvas.height = getScreenHeight() * this.bufferScale_;
+      this.cardboardUI_ = new CardboardUI(gl);
+    }
+  } else {
+    if (!this.config.CARDBOARD_UI_DISABLED) {
+      this.cardboardUI_ = new CardboardUI(gl);
+    }
+    this.distorter_ = new CardboardDistorter(gl, this.cardboardUI_, this.config.BUFFER_SCALE, this.config.DIRTY_SUBMIT_FRAME_BINDINGS);
+    this.distorter_.updateDeviceInfo(this.deviceInfo_);
+  }
+  if (this.cardboardUI_) {
+    this.cardboardUI_.listen(function (e) {
+      this.viewerSelector_.show(this.layer_.source.parentElement);
+      e.stopPropagation();
+      e.preventDefault();
+    }.bind(this), function (e) {
+      this.exitPresent();
+      e.stopPropagation();
+      e.preventDefault();
+    }.bind(this));
+  }
+  if (this.rotateInstructions_) {
+    if (isLandscapeMode() && isMobile()) {
+      this.rotateInstructions_.showTemporarily(3000, this.layer_.source.parentElement);
+    } else {
+      this.rotateInstructions_.update();
+    }
+  }
+  this.orientationHandler = this.onOrientationChange_.bind(this);
+  window.addEventListener('orientationchange', this.orientationHandler);
+  this.vrdisplaypresentchangeHandler = this.updateBounds_.bind(this);
+  window.addEventListener('vrdisplaypresentchange', this.vrdisplaypresentchangeHandler);
+  this.fireVRDisplayDeviceParamsChange_();
+};
+CardboardVRDisplay.prototype.endPresent_ = function () {
+  if (this.distorter_) {
+    this.distorter_.destroy();
+    this.distorter_ = null;
+  }
+  if (this.cardboardUI_) {
+    this.cardboardUI_.destroy();
+    this.cardboardUI_ = null;
+  }
+  if (this.rotateInstructions_) {
+    this.rotateInstructions_.hide();
+  }
+  this.viewerSelector_.hide();
+  window.removeEventListener('orientationchange', this.orientationHandler);
+  window.removeEventListener('vrdisplaypresentchange', this.vrdisplaypresentchangeHandler);
+};
+CardboardVRDisplay.prototype.updatePresent_ = function () {
+  this.endPresent_();
+  this.beginPresent_();
+};
+CardboardVRDisplay.prototype.submitFrame = function (pose) {
+  if (this.distorter_) {
+    this.updateBounds_();
+    this.distorter_.submitFrame();
+  } else if (this.cardboardUI_ && this.layer_) {
+    var canvas = this.layer_.source.getContext('webgl').canvas;
+    if (canvas.width != this.lastWidth || canvas.height != this.lastHeight) {
+      this.cardboardUI_.onResize();
+    }
+    this.lastWidth = canvas.width;
+    this.lastHeight = canvas.height;
+    this.cardboardUI_.render();
+  }
+};
+CardboardVRDisplay.prototype.onOrientationChange_ = function (e) {
+  this.viewerSelector_.hide();
+  if (this.rotateInstructions_) {
+    this.rotateInstructions_.update();
+  }
+  this.onResize_();
+};
+CardboardVRDisplay.prototype.onResize_ = function (e) {
+  if (this.layer_) {
+    var gl = this.layer_.source.getContext('webgl');
+    var cssProperties = ['position: absolute', 'top: 0', 'left: 0',
+    'width: 100vw', 'height: 100vh', 'border: 0', 'margin: 0',
+    'padding: 0px', 'box-sizing: content-box'];
+    gl.canvas.setAttribute('style', cssProperties.join('; ') + ';');
+    safariCssSizeWorkaround(gl.canvas);
+  }
+};
+CardboardVRDisplay.prototype.onViewerChanged_ = function (viewer) {
+  this.deviceInfo_.setViewer(viewer);
+  if (this.distorter_) {
+    this.distorter_.updateDeviceInfo(this.deviceInfo_);
+  }
+  this.fireVRDisplayDeviceParamsChange_();
+};
+CardboardVRDisplay.prototype.fireVRDisplayDeviceParamsChange_ = function () {
+  var event = new CustomEvent('vrdisplaydeviceparamschange', {
+    detail: {
+      vrdisplay: this,
+      deviceInfo: this.deviceInfo_
+    }
+  });
+  window.dispatchEvent(event);
+};
+CardboardVRDisplay.VRFrameData = VRFrameData;
+CardboardVRDisplay.VRDisplay = VRDisplay;
+return CardboardVRDisplay;
+})));
+});
+var CardboardVRDisplay = unwrapExports(cardboardVrDisplay);
+
+class XRDevice extends EventTarget {
+  constructor(global) {
+    super();
+    this.global = global;
+    this.onWindowResize = this.onWindowResize.bind(this);
+    this.global.window.addEventListener('resize', this.onWindowResize);
+    this.environmentBlendMode = 'opaque';
+  }
+  get depthNear() { throw new Error('Not implemented'); }
+  set depthNear(val) { throw new Error('Not implemented'); }
+  get depthFar() { throw new Error('Not implemented'); }
+  set depthFar(val) { throw new Error('Not implemented'); }
+  onBaseLayerSet(sessionId, layer) { throw new Error('Not implemented'); }
+  onInlineVerticalFieldOfViewSet(sessionId, value) { throw new Error('Not implemented'); }
+  supportsSession(mode) { throw new Error('Not implemented'); }
+  async requestSession(mode) { throw new Error('Not implemented'); }
+  requestAnimationFrame(callback) { throw new Error('Not implemented'); }
+  onFrameStart(sessionId) { throw new Error('Not implemented'); }
+  onFrameEnd(sessionId) { throw new Error('Not implemented'); }
+  requestStageBounds() { throw new Error('Not implemented'); }
+  async requestFrameOfReferenceTransform(type, options) {
+    return undefined;
+  }
+  cancelAnimationFrame(handle) { throw new Error('Not implemented'); }
+  endSession(sessionId) { throw new Error('Not implemented'); }
+  getViewport(sessionId, eye, layer, target) { throw new Error('Not implemented'); }
+  getProjectionMatrix(eye) { throw new Error('Not implemented'); }
+  getBasePoseMatrix() { throw new Error('Not implemented'); }
+  getBaseViewMatrix(eye) { throw new Error('Not implemented'); }
+  getInputSources() { throw new Error('Not implemented'); }
+  getInputPose(inputSource, coordinateSystem, poseType) { throw new Error('Not implemented'); }
+  onWindowResize() {
+    this.onWindowResize();
+  }
+}
+
+let oculusGo = {
+  mapping: 'xr-standard',
+  profiles: ['oculus-go', 'touchpad-controller'],
+  buttons: {
+    length: 3,
+    0: 1,
+    1: null,
+    2: 0
+  },
+  gripTransform: {
+    orientation: [Math.PI * 0.11, 0, 0, 1]
+  }
+};
+let oculusTouch = {
+  mapping: 'xr-standard',
+  displayProfiles: {
+    'Oculus Quest': ['oculus-quest', 'oculus-touch', 'thumbstick-controller']
+  },
+  profiles: ['oculus-touch', 'thumbstick-controller'],
+  axes: {
+    length: 4,
+    0: null,
+    1: null,
+    2: 0,
+    3: 1
+  },
+  buttons: {
+    length: 6,
+    0: 1,
+    1: 2,
+    2: null,
+    3: 0,
+    4: 3,
+    5: 4
+  },
+  gripTransform: {
+    position: [0, -0.02, 0.04, 1],
+    orientation: [Math.PI * 0.11, 0, 0, 1]
+  }
+};
+let openVr = {
+  mapping: 'xr-standard',
+  profiles: ['openvr-controller', 'touchpad-controller'],
+  displayProfiles: {
+    'HTC Vive': ['htc-vive', 'touchpad-controller'],
+    'HTC Vive DVT': ['htc-vive', 'touchpad-controller']
+  },
+  buttons: {
+    length: 3,
+    0: 1,
+    1: 2,
+    2: 0
+  },
+  gripTransform: {
+    position: [0, 0, 0.05, 1],
+  },
+  targetRayTransform: {
+    orientation: [Math.PI * -0.08, 0, 0, 1]
+  }
+};
+let windowsMixedReality = {
+  mapping: 'xr-standard',
+  profiles: ['windows-mixed-reality', 'touchpad-thumbstick-controller'],
+  buttons: {
+    length: 4,
+    0: 1,
+    1: 0,
+    2: 2,
+    3: 4,
+  },
+  gripTransform: {
+    position: [0, -0.02, 0.04, 1],
+    orientation: [Math.PI * 0.11, 0, 0, 1]
+  }
+};
+let GamepadMappings = {
+  'Oculus Go Controller': oculusGo,
+  'Oculus Touch (Right)': oculusTouch,
+  'Oculus Touch (Left)': oculusTouch,
+  'OpenVR Gamepad': openVr,
+  'Windows Mixed Reality (Right)': windowsMixedReality,
+  'Windows Mixed Reality (Left)': windowsMixedReality,
+};
+
+const HEAD_ELBOW_OFFSET_RIGHTHANDED = fromValues$1(0.155, -0.465, -0.15);
+const HEAD_ELBOW_OFFSET_LEFTHANDED = fromValues$1(-0.155, -0.465, -0.15);
+const ELBOW_WRIST_OFFSET = fromValues$1(0, 0, -0.25);
+const WRIST_CONTROLLER_OFFSET = fromValues$1(0, 0, 0.05);
+const ARM_EXTENSION_OFFSET = fromValues$1(-0.08, 0.14, 0.08);
+const ELBOW_BEND_RATIO = 0.4;
+const EXTENSION_RATIO_WEIGHT = 0.4;
+const MIN_ANGULAR_SPEED = 0.61;
+const MIN_ANGLE_DELTA = 0.175;
+const MIN_EXTENSION_COS = 0.12;
+const MAX_EXTENSION_COS = 0.87;
+const RAD_TO_DEG = 180 / Math.PI;
+function eulerFromQuaternion(out, q, order) {
+  function clamp(value, min$$1, max$$1) {
+    return (value < min$$1 ? min$$1 : (value > max$$1 ? max$$1 : value));
+  }
+  var sqx = q[0] * q[0];
+  var sqy = q[1] * q[1];
+  var sqz = q[2] * q[2];
+  var sqw = q[3] * q[3];
+  if ( order === 'XYZ' ) {
+    out[0] = Math.atan2( 2 * ( q[0] * q[3] - q[1] * q[2] ), ( sqw - sqx - sqy + sqz ) );
+    out[1] = Math.asin(  clamp( 2 * ( q[0] * q[2] + q[1] * q[3] ), -1, 1 ) );
+    out[2] = Math.atan2( 2 * ( q[2] * q[3] - q[0] * q[1] ), ( sqw + sqx - sqy - sqz ) );
+  } else if ( order ===  'YXZ' ) {
+    out[0] = Math.asin(  clamp( 2 * ( q[0] * q[3] - q[1] * q[2] ), -1, 1 ) );
+    out[1] = Math.atan2( 2 * ( q[0] * q[2] + q[1] * q[3] ), ( sqw - sqx - sqy + sqz ) );
+    out[2] = Math.atan2( 2 * ( q[0] * q[1] + q[2] * q[3] ), ( sqw - sqx + sqy - sqz ) );
+  } else if ( order === 'ZXY' ) {
+    out[0] = Math.asin(  clamp( 2 * ( q[0] * q[3] + q[1] * q[2] ), -1, 1 ) );
+    out[1] = Math.atan2( 2 * ( q[1] * q[3] - q[2] * q[0] ), ( sqw - sqx - sqy + sqz ) );
+    out[2] = Math.atan2( 2 * ( q[2] * q[3] - q[0] * q[1] ), ( sqw - sqx + sqy - sqz ) );
+  } else if ( order === 'ZYX' ) {
+    out[0] = Math.atan2( 2 * ( q[0] * q[3] + q[2] * q[1] ), ( sqw - sqx - sqy + sqz ) );
+    out[1] = Math.asin(  clamp( 2 * ( q[1] * q[3] - q[0] * q[2] ), -1, 1 ) );
+    out[2] = Math.atan2( 2 * ( q[0] * q[1] + q[2] * q[3] ), ( sqw + sqx - sqy - sqz ) );
+  } else if ( order === 'YZX' ) {
+    out[0] = Math.atan2( 2 * ( q[0] * q[3] - q[2] * q[1] ), ( sqw - sqx + sqy - sqz ) );
+    out[1] = Math.atan2( 2 * ( q[1] * q[3] - q[0] * q[2] ), ( sqw + sqx - sqy - sqz ) );
+    out[2] = Math.asin(  clamp( 2 * ( q[0] * q[1] + q[2] * q[3] ), -1, 1 ) );
+  } else if ( order === 'XZY' ) {
+    out[0] = Math.atan2( 2 * ( q[0] * q[3] + q[1] * q[2] ), ( sqw - sqx + sqy - sqz ) );
+    out[1] = Math.atan2( 2 * ( q[0] * q[2] + q[1] * q[3] ), ( sqw + sqx - sqy - sqz ) );
+    out[2] = Math.asin(  clamp( 2 * ( q[2] * q[3] - q[0] * q[1] ), -1, 1 ) );
+  } else {
+    console.log('No order given for quaternion to euler conversion.');
+    return;
+  }
+}
+class OrientationArmModel {
+  constructor() {
+    this.hand = 'right';
+    this.headElbowOffset = HEAD_ELBOW_OFFSET_RIGHTHANDED;
+    this.controllerQ = create$4();
+    this.lastControllerQ = create$4();
+    this.headQ = create$4();
+    this.headPos = create$1();
+    this.elbowPos = create$1();
+    this.wristPos = create$1();
+    this.time = null;
+    this.lastTime = null;
+    this.rootQ = create$4();
+    this.position = create$1();
+  }
+  setHandedness(hand) {
+    if (this.hand != hand) {
+      this.hand = hand;
+      if (this.hand == 'left') {
+        this.headElbowOffset = HEAD_ELBOW_OFFSET_LEFTHANDED;
+      } else {
+        this.headElbowOffset = HEAD_ELBOW_OFFSET_RIGHTHANDED;
+      }
+    }
+  }
+  update(controllerOrientation, headPoseMatrix) {
+    this.time = now$1();
+    if (controllerOrientation) {
+      copy$4(this.lastControllerQ, this.controllerQ);
+      copy$4(this.controllerQ, controllerOrientation);
+    }
+    if (headPoseMatrix) {
+      getTranslation(this.headPos, headPoseMatrix);
+      getRotation(this.headQ, headPoseMatrix);
+    }
+    let headYawQ = this.getHeadYawOrientation_();
+    let angleDelta = this.quatAngle_(this.lastControllerQ, this.controllerQ);
+    let timeDelta = (this.time - this.lastTime) / 1000;
+    let controllerAngularSpeed = angleDelta / timeDelta;
+    if (controllerAngularSpeed > MIN_ANGULAR_SPEED) {
+      slerp(this.rootQ, this.rootQ, headYawQ,
+                 Math.min(angleDelta / MIN_ANGLE_DELTA, 1.0));
+    } else {
+      copy$4(this.rootQ, headYawQ);
+    }
+    let controllerForward = fromValues$1(0, 0, -1.0);
+    transformQuat(controllerForward, controllerForward, this.controllerQ);
+    let controllerDotY = dot(controllerForward, [0, 1, 0]);
+    let extensionRatio = this.clamp_(
+        (controllerDotY - MIN_EXTENSION_COS) / MAX_EXTENSION_COS, 0.0, 1.0);
+    let controllerCameraQ = clone$4(this.rootQ);
+    invert$2(controllerCameraQ, controllerCameraQ);
+    multiply$4(controllerCameraQ, controllerCameraQ, this.controllerQ);
+    let elbowPos = this.elbowPos;
+    copy$1(elbowPos, this.headPos);
+    add$1(elbowPos, elbowPos, this.headElbowOffset);
+    let elbowOffset = clone$1(ARM_EXTENSION_OFFSET);
+    scale$1(elbowOffset, elbowOffset, extensionRatio);
+    add$1(elbowPos, elbowPos, elbowOffset);
+    let totalAngle = this.quatAngle_(controllerCameraQ, create$4());
+    let totalAngleDeg = totalAngle * RAD_TO_DEG;
+    let lerpSuppression = 1 - Math.pow(totalAngleDeg / 180, 4);let elbowRatio = ELBOW_BEND_RATIO;
+    let wristRatio = 1 - ELBOW_BEND_RATIO;
+    let lerpValue = lerpSuppression *
+        (elbowRatio + wristRatio * extensionRatio * EXTENSION_RATIO_WEIGHT);
+    let wristQ = create$4();
+    slerp(wristQ, wristQ, controllerCameraQ, lerpValue);
+    let invWristQ = invert$2(create$4(), wristQ);
+    let elbowQ = clone$4(controllerCameraQ);
+    multiply$4(elbowQ, elbowQ, invWristQ);
+    let wristPos = this.wristPos;
+    copy$1(wristPos, WRIST_CONTROLLER_OFFSET);
+    transformQuat(wristPos, wristPos, wristQ);
+    add$1(wristPos, wristPos, ELBOW_WRIST_OFFSET);
+    transformQuat(wristPos, wristPos, elbowQ);
+    add$1(wristPos, wristPos, elbowPos);
+    let offset = clone$1(ARM_EXTENSION_OFFSET);
+    scale$1(offset, offset, extensionRatio);
+    add$1(this.position, this.wristPos, offset);
+    transformQuat(this.position, this.position, this.rootQ);
+    this.lastTime = this.time;
+  }
+  getPosition() {
+    return this.position;
+  }
+  getHeadYawOrientation_() {
+    let headEuler = create$1();
+    eulerFromQuaternion(headEuler, this.headQ, 'YXZ');
+    let destinationQ = fromEuler(create$4(), 0, headEuler[1] * RAD_TO_DEG, 0);
+    return destinationQ;
+  }
+  clamp_(value, min$$1, max$$1) {
+    return Math.min(Math.max(value, min$$1), max$$1);
+  }
+  quatAngle_(q1, q2) {
+    let vec1 = [0, 0, -1];
+    let vec2 = [0, 0, -1];
+    transformQuat(vec1, vec1, q1);
+    transformQuat(vec2, vec2, q2);
+    return angle(vec1, vec2);
+  }
+}
+
+const PRIVATE$14 = Symbol('@@webxr-polyfill/XRRemappedGamepad');
+const PLACEHOLDER_BUTTON = { pressed: false, touched: false, value: 0.0 };
+Object.freeze(PLACEHOLDER_BUTTON);
+class XRRemappedGamepad {
+  constructor(gamepad, display, map) {
+    if (!map) {
+      map = {};
+    }
+    let axes = new Array(map.axes && map.axes.length ? map.axes.length : gamepad.axes.length);
+    let buttons = new Array(map.buttons && map.buttons.length ? map.buttons.length : gamepad.buttons.length);
+    let gripTransform = null;
+    if (map.gripTransform) {
+      let orientation = map.gripTransform.orientation || [0, 0, 0, 1];
+      gripTransform = create();
+      fromRotationTranslation(
+        gripTransform,
+        normalize$2(orientation, orientation),
+        map.gripTransform.position || [0, 0, 0]
+      );
+    }
+    let targetRayTransform = null;
+    if (map.targetRayTransform) {
+      let orientation =  map.targetRayTransform.orientation || [0, 0, 0, 1];
+      targetRayTransform = create();
+      fromRotationTranslation(
+        targetRayTransform,
+        normalize$2(orientation, orientation),
+        map.targetRayTransform.position || [0, 0, 0]
+      );
+    }
+    let profiles = map.profiles;
+    if (map.displayProfiles) {
+      if (display.displayName in map.displayProfiles) {
+        profiles = map.displayProfiles[display.displayName];
+      }
+    }
+    this[PRIVATE$14] = {
+      gamepad,
+      map,
+      profiles: profiles || [gamepad.id],
+      mapping: map.mapping || gamepad.mapping,
+      axes,
+      buttons,
+      gripTransform,
+      targetRayTransform,
+    };
+    this._update();
+  }
+  _update() {
+    let gamepad = this[PRIVATE$14].gamepad;
+    let map = this[PRIVATE$14].map;
+    let axes = this[PRIVATE$14].axes;
+    for (let i = 0; i < axes.length; ++i) {
+      if (map.axes && i in map.axes) {
+        if (map.axes[i] === null) {
+          axes[i] = 0;
+        } else {
+          axes[i] = gamepad.axes[map.axes[i]];
+        }
+      } else {
+        axes[i] = gamepad.axes[i];
+      }
+    }
+    if (map.axes && map.axes.invert) {
+      for (let axis of map.axes.invert) {
+        axes[axis] *= -1;
+      }
+    }
+    let buttons = this[PRIVATE$14].buttons;
+    for (let i = 0; i < buttons.length; ++i) {
+      if (map.buttons && i in map.buttons) {
+        if (map.buttons[i] === null) {
+          buttons[i] = PLACEHOLDER_BUTTON;
+        } else {
+          buttons[i] = gamepad.buttons[map.buttons[i]];
+        }
+      } else {
+        buttons[i] = gamepad.buttons[i];
+      }
+    }
+  }
+  get id() {
+    return '';
+  }
+  get _profiles() {
+    return this[PRIVATE$14].profiles;
+  }
+  get index() {
+    return -1;
+  }
+  get connected() {
+    return this[PRIVATE$14].gamepad.connected;
+  }
+  get timestamp() {
+    return this[PRIVATE$14].gamepad.timestamp;
+  }
+  get mapping() {
+    return this[PRIVATE$14].mapping;
+  }
+  get axes() {
+    return this[PRIVATE$14].axes;
+  }
+  get buttons() {
+    return this[PRIVATE$14].buttons;
+  }
+}
+class GamepadXRInputSource {
+  constructor(polyfill, display, primaryButtonIndex = 0) {
+    this.polyfill = polyfill;
+    this.display = display;
+    this.nativeGamepad = null;
+    this.gamepad = null;
+    this.inputSource = new XRInputSource(this);
+    this.lastPosition = create$1();
+    this.emulatedPosition = false;
+    this.basePoseMatrix = create();
+    this.outputMatrix = create();
+    this.primaryButtonIndex = primaryButtonIndex;
+    this.primaryActionPressed = false;
+    this.handedness = '';
+    this.targetRayMode = 'gaze';
+    this.armModel = null;
+  }
+  get profiles() {
+    return this.gamepad ? this.gamepad._profiles : [];
+  }
+  updateFromGamepad(gamepad) {
+    if (this.nativeGamepad !== gamepad) {
+      this.nativeGamepad = gamepad;
+      if (gamepad) {
+        this.gamepad = new XRRemappedGamepad(gamepad, this.display, GamepadMappings[gamepad.id]);
+      } else {
+        this.gamepad = null;
+      }
+    }
+    this.handedness = gamepad.hand;
+    if (this.gamepad) {
+      this.gamepad._update();
+    }
+    if (gamepad.pose) {
+      this.targetRayMode = 'tracked-pointer';
+      this.emulatedPosition = !gamepad.pose.hasPosition;
+    } else if (gamepad.hand === '') {
+      this.targetRayMode = 'gaze';
+      this.emulatedPosition = false;
+    }
+  }
+  updateBasePoseMatrix() {
+    if (this.nativeGamepad && this.nativeGamepad.pose) {
+      let pose = this.nativeGamepad.pose;
+      let position = pose.position;
+      let orientation = pose.orientation;
+      if (!position && !orientation) {
+        return;
+      }
+      if (!position) {
+        if (!pose.hasPosition) {
+          if (!this.armModel) {
+            this.armModel = new OrientationArmModel();
+          }
+          this.armModel.setHandedness(this.nativeGamepad.hand);
+          this.armModel.update(orientation, this.polyfill.getBasePoseMatrix());
+          position = this.armModel.getPosition();
+        } else {
+          position = this.lastPosition;
+        }
+      } else {
+        this.lastPosition[0] = position[0];
+        this.lastPosition[1] = position[1];
+        this.lastPosition[2] = position[2];
+      }
+      fromRotationTranslation(this.basePoseMatrix, orientation, position);
+    } else {
+      copy(this.basePoseMatrix, this.polyfill.getBasePoseMatrix());
+    }
+    return this.basePoseMatrix;
+  }
+  getXRPose(coordinateSystem, poseType) {
+    this.updateBasePoseMatrix();
+    switch(poseType) {
+      case "target-ray":
+        coordinateSystem._transformBasePoseMatrix(this.outputMatrix, this.basePoseMatrix);
+        if (this.gamepad && this.gamepad[PRIVATE$14].targetRayTransform) {
+          multiply(this.outputMatrix, this.outputMatrix, this.gamepad[PRIVATE$14].targetRayTransform);
+        }
+        break;
+      case "grip":
+        if (!this.nativeGamepad || !this.nativeGamepad.pose) {
+          return null;
+        }
+        coordinateSystem._transformBasePoseMatrix(this.outputMatrix, this.basePoseMatrix);
+        if (this.gamepad && this.gamepad[PRIVATE$14].gripTransform) {
+          multiply(this.outputMatrix, this.outputMatrix, this.gamepad[PRIVATE$14].gripTransform);
+        }
+        break;
+      default:
+        return null;
+    }
+    coordinateSystem._adjustForOriginOffset(this.outputMatrix);
+    return new XRPose(new XRRigidTransform(this.outputMatrix), this.emulatedPosition);
+  }
+}
+
+const TEST_ENV = "production" === 'test';
+const EXTRA_PRESENTATION_ATTRIBUTES = {
+  highRefreshRate: true,
+};
+const PRIMARY_BUTTON_MAP = {
+  oculus: 1,
+  openvr: 1,
+  'spatial controller (spatial interaction source)': 1
+};
+let SESSION_ID = 0;
+class Session {
+  constructor(mode, polyfillOptions={}) {
+    this.mode = mode;
+    this.outputContext = null;
+    this.immersive = mode == 'immersive-vr' || mode == 'immersive-ar';
+    this.ended = null;
+    this.baseLayer = null;
+    this.inlineVerticalFieldOfView = Math.PI * 0.5;
+    this.id = ++SESSION_ID;
+    this.modifiedCanvasLayer = false;
+    if (this.outputContext && !TEST_ENV) {
+      const renderContextType = polyfillOptions.renderContextType || '2d';
+      this.renderContext = this.outputContext.canvas.getContext(renderContextType);
+    }
+  }
+}
+class WebVRDevice extends XRDevice {
+  constructor(global, display) {
+    const { canPresent } = display.capabilities;
+    super(global);
+    this.display = display;
+    this.frame = new global.VRFrameData();
+    this.sessions = new Map();
+    this.immersiveSession = null;
+    this.canPresent = canPresent;
+    this.baseModelMatrix = create();
+    this.gamepadInputSources = {};
+    this.tempVec3 = new Float32Array(3);
+    this.onVRDisplayPresentChange = this.onVRDisplayPresentChange.bind(this);
+    global.window.addEventListener('vrdisplaypresentchange', this.onVRDisplayPresentChange);
+    this.CAN_USE_GAMEPAD = global.navigator && ('getGamepads' in global.navigator);
+    this.HAS_BITMAP_SUPPORT = isImageBitmapSupported(global);
+  }
+  get depthNear() { return this.display.depthNear; }
+  set depthNear(val) { this.display.depthNear = val; }
+  get depthFar() { return this.display.depthFar; }
+  set depthFar(val) { this.display.depthFar = val; }
+  onBaseLayerSet(sessionId, layer) {
+    const session = this.sessions.get(sessionId);
+    const canvas = layer.context.canvas;
+    if (session.immersive) {
+      const left = this.display.getEyeParameters('left');
+      const right = this.display.getEyeParameters('right');
+      canvas.width = Math.max(left.renderWidth, right.renderWidth) * 2;
+      canvas.height = Math.max(left.renderHeight, right.renderHeight);
+      this.display.requestPresent([{
+          source: canvas, attributes: EXTRA_PRESENTATION_ATTRIBUTES
+        }]).then(() => {
+        if (!TEST_ENV && !this.global.document.body.contains(canvas)) {
+          session.modifiedCanvasLayer = true;
+          this.global.document.body.appendChild(canvas);
+          applyCanvasStylesForMinimalRendering(canvas);
+        }
+        session.baseLayer = layer;
+      });
+    }
+    else {
+      session.baseLayer = layer;
+    }
+  }
+  onInlineVerticalFieldOfViewSet(sessionId, value) {
+    const session = this.sessions.get(sessionId);
+    session.inlineVerticalFieldOfView = value;
+  }
+  supportsSession(mode) {
+    if (XRSessionModes.indexOf(mode) == -1) {
+      throw new TypeError(
+          `The provided value '${mode}' is not a valid enum value of type XRSessionMode`);
+    }
+    if (mode == 'immersive-ar') {
+      return false;
+    }
+    if (mode == 'immersive-vr' && this.canPresent === false) {
+      return false;
+    }
+    return true;
+  }
+  async requestSession(mode) {
+    if (!this.supportsSession(mode)) {
+      return Promise.reject();
+    }
+    let immersive = mode == 'immersive-vr';
+    if (immersive) {
+      const canvas = this.global.document.createElement('canvas');
+      if (!TEST_ENV) {
+        const ctx = canvas.getContext('webgl');
+      }
+      await this.display.requestPresent([{
+          source: canvas, attributes: EXTRA_PRESENTATION_ATTRIBUTES }]);
+    }
+    const session = new Session(mode, {
+      renderContextType: this.HAS_BITMAP_SUPPORT ? 'bitmaprenderer' : '2d'
+    });
+    this.sessions.set(session.id, session);
+    if (immersive) {
+      this.immersiveSession = session;
+      this.dispatchEvent('@@webxr-polyfill/vr-present-start', session.id);
+    }
+    return Promise.resolve(session.id);
+  }
+  requestAnimationFrame(callback) {
+    return this.display.requestAnimationFrame(callback);
+  }
+  getPrimaryButtonIndex(gamepad) {
+    let primaryButton = 0;
+    let name = gamepad.id.toLowerCase();
+    for (let key in PRIMARY_BUTTON_MAP) {
+      if (name.includes(key)) {
+        primaryButton = PRIMARY_BUTTON_MAP[key];
+        break;
+      }
+    }
+    return Math.min(primaryButton, gamepad.buttons.length - 1);
+  }
+  onFrameStart(sessionId) {
+    this.display.getFrameData(this.frame);
+    const session = this.sessions.get(sessionId);
+    if (session.immersive && this.CAN_USE_GAMEPAD) {
+      let prevInputSources = this.gamepadInputSources;
+      this.gamepadInputSources = {};
+      let gamepads = this.global.navigator.getGamepads();
+      for (let i = 0; i < gamepads.length; ++i) {
+        let gamepad = gamepads[i];
+        if (gamepad && gamepad.displayId > 0) {
+          let inputSourceImpl = prevInputSources[i];
+          if (!inputSourceImpl) {
+            inputSourceImpl = new GamepadXRInputSource(this, this.display, this.getPrimaryButtonIndex(gamepad));
+          }
+          inputSourceImpl.updateFromGamepad(gamepad);
+          this.gamepadInputSources[i] = inputSourceImpl;
+          if (inputSourceImpl.primaryButtonIndex != -1) {
+            let primaryActionPressed = gamepad.buttons[inputSourceImpl.primaryButtonIndex].pressed;
+            if (primaryActionPressed && !inputSourceImpl.primaryActionPressed) {
+              this.dispatchEvent('@@webxr-polyfill/input-select-start', { sessionId: session.id, inputSource: inputSourceImpl.inputSource });
+            } else if (!primaryActionPressed && inputSourceImpl.primaryActionPressed) {
+              this.dispatchEvent('@@webxr-polyfill/input-select-end', { sessionId: session.id, inputSource: inputSourceImpl.inputSource });
+            }
+            inputSourceImpl.primaryActionPressed = primaryActionPressed;
+          }
+        }
+      }
+    }
+    if (TEST_ENV) {
+      return;
+    }
+    if (!session.immersive && session.baseLayer) {
+      const canvas = session.baseLayer.context.canvas;
+      perspective(this.frame.leftProjectionMatrix, session.inlineVerticalFieldOfView,
+          canvas.width/canvas.height, this.depthNear, this.depthFar);
+    }
+  }
+  onFrameEnd(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session.ended || !session.baseLayer) {
+      return;
+    }
+    if (session.outputContext &&
+        !(session.immersive && !this.display.capabilities.hasExternalDisplay)) {
+      const mirroring =
+        session.immersive && this.display.capabilities.hasExternalDisplay;
+      const iCanvas = session.baseLayer.context.canvas;
+      const iWidth = mirroring ? iCanvas.width / 2 : iCanvas.width;
+      const iHeight = iCanvas.height;
+      if (!TEST_ENV) {
+        const oCanvas = session.outputContext.canvas;
+        const oWidth = oCanvas.width;
+        const oHeight = oCanvas.height;
+        const renderContext = session.renderContext;
+        if (this.HAS_BITMAP_SUPPORT) {
+          if (iCanvas.transferToImageBitmap) {
+            renderContext.transferFromImageBitmap(iCanvas.transferToImageBitmap());
+          }
+          else {
+            this.global.createImageBitmap(iCanvas, 0, 0, iWidth, iHeight, {
+              resizeWidth: oWidth,
+              resizeHeight: oHeight,
+            }).then(bitmap => renderContext.transferFromImageBitmap(bitmap));
+          }
+        } else {
+          renderContext.drawImage(iCanvas, 0, 0, iWidth, iHeight,
+                                           0, 0, oWidth, oHeight);
+        }
+      }
+    }
+    if (session.immersive && session.baseLayer) {
+      this.display.submitFrame();
+    }
+  }
+  cancelAnimationFrame(handle) {
+    this.display.cancelAnimationFrame(handle);
+  }
+  async endSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session.ended) {
+      return;
+    }
+    if (session.immersive) {
+      return this.display.exitPresent();
+    } else {
+      session.ended = true;
+    }
+  }
+  requestStageBounds() {
+    if (this.display.stageParameters) {
+      const width = this.display.stageParameters.sizeX;
+      const depth = this.display.stageParameters.sizeZ;
+      const data = [];
+      data.push(-width / 2);
+      data.push(-depth / 2);
+      data.push(width / 2);
+      data.push(-depth / 2);
+      data.push(width / 2);
+      data.push(depth / 2);
+      data.push(-width / 2);
+      data.push(depth / 2);
+      return data;
+    }
+    return null;
+  }
+  async requestFrameOfReferenceTransform(type, options) {
+    if ((type === 'local-floor' || type === 'bounded-floor') &&
+        this.display.stageParameters &&
+        this.display.stageParameters.sittingToStandingTransform) {
+      return this.display.stageParameters.sittingToStandingTransform;
+    }
+    return null;
+  }
+  getProjectionMatrix(eye) {
+    if (eye === 'left') {
+      return this.frame.leftProjectionMatrix;
+    } else if (eye === 'right') {
+      return this.frame.rightProjectionMatrix;
+    } else if (eye === 'none') {
+      return this.frame.leftProjectionMatrix;
+    } else {
+      throw new Error(`eye must be of type 'left' or 'right'`);
+    }
+  }
+  getViewport(sessionId, eye, layer, target) {
+    const session = this.sessions.get(sessionId);
+    const { width, height } = layer.context.canvas;
+    if (!session.immersive) {
+      target.x = target.y = 0;
+      target.width = width;
+      target.height = height;
+      return true;
+    }
+    if (eye === 'left') {
+      target.x = 0;
+    } else if (eye === 'right') {
+      target.x = width / 2;
+    } else {
+      return false;
+    }
+    target.y = 0;
+    target.width = width / 2;
+    target.height = height;
+    return true;
+  }
+  getBasePoseMatrix() {
+    let { position, orientation } = this.frame.pose;
+    if (!position && !orientation) {
+      return this.baseModelMatrix;
+    }
+    if (!position) {
+      position = this.tempVec3;
+      position[0] = position[1] = position[2] = 0;
+    }
+    fromRotationTranslation(this.baseModelMatrix, orientation, position);
+    return this.baseModelMatrix;
+  }
+  getBaseViewMatrix(eye) {
+    if (eye === 'left') {
+      return this.frame.leftViewMatrix;
+    } else if (eye === 'right') {
+      return this.frame.rightViewMatrix;
+    } else {
+      throw new Error(`eye must be of type 'left' or 'right'`);
+    }
+  }
+  getInputSources() {
+    let inputSources = [];
+    for (let i in this.gamepadInputSources) {
+      inputSources.push(this.gamepadInputSources[i].inputSource);
+    }
+    return inputSources;
+  }
+  getInputPose(inputSource, coordinateSystem, poseType) {
+    if (!coordinateSystem) {
+      return null;
+    }
+    for (let i in this.gamepadInputSources) {
+      let inputSourceImpl = this.gamepadInputSources[i];
+      if (inputSourceImpl.inputSource === inputSource) {
+        return inputSourceImpl.getXRPose(coordinateSystem, poseType);
+      }
+    }
+    return null;
+  }
+  onWindowResize() {
+  }
+  onVRDisplayPresentChange(e) {
+    if (!this.display.isPresenting) {
+      this.sessions.forEach(session => {
+        if (session.immersive && !session.ended) {
+          if (session.modifiedCanvasLayer) {
+            const canvas = session.baseLayer.context.canvas;
+            document.body.removeChild(canvas);
+            canvas.setAttribute('style', '');
+          }
+          if (this.immersiveSession === session) {
+            this.immersiveSession = null;
+          }
+          this.dispatchEvent('@@webxr-polyfill/vr-present-end', session.id);
+        }
+      });
+    }
+  }
+}
+
+class CardboardXRDevice extends WebVRDevice {
+  constructor(global, cardboardConfig) {
+    const display = new CardboardVRDisplay(cardboardConfig || {});
+    super(global, display);
+    this.display = display;
+    this.frame = {
+      rightViewMatrix: new Float32Array(16),
+      leftViewMatrix: new Float32Array(16),
+      rightProjectionMatrix: new Float32Array(16),
+      leftProjectionMatrix: new Float32Array(16),
+      pose: null,
+      timestamp: null,
+    };
+  }
+}
+
+const getWebVRDevice = async function (global) {
+  let device = null;
+  if ('getVRDisplays' in global.navigator) {
+    try {
+      const displays = await global.navigator.getVRDisplays();
+      if (displays && displays.length) {
+        device = new WebVRDevice(global, displays[0]);
+      }
+    } catch (e) {}
+  }
+  return device;
+};
+const requestXRDevice = async function (global, config) {
+  if (config.webvr) {
+    let xr = await getWebVRDevice(global);
+    if (xr) {
+      return xr;
+    }
+  }
+  if (!global.VRFrameData) {
+    global.VRFrameData = function () {
+      this.rightViewMatrix = new Float32Array(16);
+      this.leftViewMatrix = new Float32Array(16);
+      this.rightProjectionMatrix = new Float32Array(16);
+      this.leftProjectionMatrix = new Float32Array(16);
+      this.pose = null;
+    };
+  }
+  return new CardboardXRDevice(global, config.cardboardConfig);
+};
+
+const CONFIG_DEFAULTS = {
+  global: _global,
+  webvr: true,
+  cardboard: true,
+  cardboardConfig: null,
+  allowCardboardOnDesktop: false,
+};
+const partials = ['navigator', 'HTMLCanvasElement', 'WebGLRenderingContext'];
+class WebXRPolyfill {
+  constructor(config={}) {
+    this.config = Object.freeze(Object.assign({}, CONFIG_DEFAULTS, config));
+    this.global = this.config.global;
+    this.nativeWebXR = 'xr' in this.global.navigator;
+    this.injected = false;
+    if (!this.nativeWebXR) {
+      this._injectPolyfill(this.global);
+    } else {
+      this._injectCompatibilityShims(this.global);
+    }
+  }
+  _injectPolyfill(global) {
+    if (!partials.every(iface => !!global[iface])) {
+      throw new Error(`Global must have the following attributes : ${partials}`);
+    }
+    for (const className of Object.keys(API)) {
+      if (global[className] !== undefined) {
+        console.warn(`${className} already defined on global.`);
+      } else {
+        global[className] = API[className];
+      }
+    }
+    {
+      const polyfilledCtx = polyfillMakeXRCompatible(global.WebGLRenderingContext);
+      if (polyfilledCtx) {
+        polyfillGetContext(global.HTMLCanvasElement);
+        if (global.OffscreenCanvas) {
+          polyfillGetContext(global.OffscreenCanvas);
+        }
+        if (global.WebGL2RenderingContext){
+          polyfillMakeXRCompatible(global.WebGL2RenderingContext);
+        }
+      }
+    }
+    this.injected = true;
+    this._patchNavigatorXR();
+  }
+  _patchNavigatorXR() {
+    let devicePromise = requestXRDevice(this.global, this.config);
+    this.xr = new XR(devicePromise);
+    Object.defineProperty(this.global.navigator, 'xr', {
+      value: this.xr,
+      configurable: true,
+    });
+  }
+  _injectCompatibilityShims(global) {
+    if (!partials.every(iface => !!global[iface])) {
+      throw new Error(`Global must have the following attributes : ${partials}`);
+    }
+    if (global.XRWebGLLayer) {
+      let originalRequestSession = global.navigator.xr.requestSession;
+      global.navigator.xr.requestSession = function(mode, options) {
+        return originalRequestSession.call(this, mode, options).then((session) => {
+          session._session_mode = mode;
+          return session;
+        });
+      };
+      var originalXRLayer = global.XRWebGLLayer;
+      global.XRWebGLLayer = function(session, gl, options) {
+        if (!options) {
+          options = {};
+        }
+        options.compositionDisabled = (session._session_mode === "inline");
+        return new originalXRLayer(session, gl, options);
+      };
+    }
+  }
+}
+
+new WebXRPolyfill();
+
+}