Hugging Face's logo

Buckets:
ktongue
/
docker_container

Files
xet
ktongue/docker_container / simsite /frontend /node_modules /three /examples /jsm /loaders /VRMLLoader.js
download
raw
73.2 kB
import {
 BackSide,
 BoxGeometry,
 BufferAttribute,
 BufferGeometry,
 ClampToEdgeWrapping,
 Color,
 ConeGeometry,
 CylinderGeometry,
 DataTexture,
 DoubleSide,
 FileLoader,
 Float32BufferAttribute,
 FrontSide,
 Group,
 LineBasicMaterial,
 LineSegments,
 Loader,
 LoaderUtils,
 Mesh,
 MeshBasicMaterial,
 MeshPhongMaterial,
 Object3D,
 Points,
 PointsMaterial,
 Quaternion,
 RepeatWrapping,
 Scene,
 ShapeUtils,
 SphereGeometry,
 SRGBColorSpace,
 TextureLoader,
 Vector2,
 Vector3
} from 'three';
import chevrotain from '../libs/chevrotain.module.min.js';
class VRMLLoader extends Loader {
constructor( manager ) {
super( manager );
}
load( url, onLoad, onProgress, onError ) {
const scope = this;
const path = ( scope.path === '' ) ? LoaderUtils.extractUrlBase( url ) : scope.path;
const loader = new FileLoader( scope.manager );
 loader.setPath( scope.path );
 loader.setRequestHeader( scope.requestHeader );
 loader.setWithCredentials( scope.withCredentials );
 loader.load( url, function ( text ) {
try {
onLoad( scope.parse( text, path ) );
} catch ( e ) {
if ( onError ) {
onError( e );
} else {
console.error( e );
}
scope.manager.itemError( url );
}
}, onProgress, onError );
}
parse( data, path ) {
const nodeMap = {};
function generateVRMLTree( data ) {
// create lexer, parser and visitor
const tokenData = createTokens();
const lexer = new VRMLLexer( tokenData.tokens );
 const parser = new VRMLParser( tokenData.tokenVocabulary );
 const visitor = createVisitor( parser.getBaseCstVisitorConstructor() );
// lexing
const lexingResult = lexer.lex( data );
 parser.input = lexingResult.tokens;
// parsing
const cstOutput = parser.vrml();
if ( parser.errors.length > 0 ) {
console.error( parser.errors );
throw Error( 'THREE.VRMLLoader: Parsing errors detected.' );
}
// actions
const ast = visitor.visit( cstOutput );
return ast;
}
function createTokens() {
const createToken = chevrotain.createToken;
// from http://gun.teipir.gr/VRML-amgem/spec/part1/concepts.html#SyntaxBasics
const RouteIdentifier = createToken( { name: 'RouteIdentifier', pattern: /[^\x30-\x39\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d][^\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d]*[\.][^\x30-\x39\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d][^\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d]*/ } );
 const Identifier = createToken( { name: 'Identifier', pattern: /[^\x30-\x39\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d][^\0-\x20\x22\x27\x23\x2b\x2c\x2d\x2e\x5b\x5d\x5c\x7b\x7d]*/, longer_alt: RouteIdentifier } );
// from http://gun.teipir.gr/VRML-amgem/spec/part1/nodesRef.html
const nodeTypes = [
 'Anchor', 'Billboard', 'Collision', 'Group', 'Transform', // grouping nodes
 'Inline', 'LOD', 'Switch', // special groups
 'AudioClip', 'DirectionalLight', 'PointLight', 'Script', 'Shape', 'Sound', 'SpotLight', 'WorldInfo', // common nodes
 'CylinderSensor', 'PlaneSensor', 'ProximitySensor', 'SphereSensor', 'TimeSensor', 'TouchSensor', 'VisibilitySensor', // sensors
 'Box', 'Cone', 'Cylinder', 'ElevationGrid', 'Extrusion', 'IndexedFaceSet', 'IndexedLineSet', 'PointSet', 'Sphere', // geometries
 'Color', 'Coordinate', 'Normal', 'TextureCoordinate', // geometric properties
 'Appearance', 'FontStyle', 'ImageTexture', 'Material', 'MovieTexture', 'PixelTexture', 'TextureTransform', // appearance
 'ColorInterpolator', 'CoordinateInterpolator', 'NormalInterpolator', 'OrientationInterpolator', 'PositionInterpolator', 'ScalarInterpolator', // interpolators
 'Background', 'Fog', 'NavigationInfo', 'Viewpoint', // bindable nodes
 'Text' // Text must be placed at the end of the regex so there are no matches for TextureTransform and TextureCoordinate
 ];
//
const Version = createToken( {
 name: 'Version',
 pattern: /#VRML.*/,
 longer_alt: Identifier
 } );
const NodeName = createToken( {
 name: 'NodeName',
 pattern: new RegExp( nodeTypes.join( '|' ) ),
 longer_alt: Identifier
 } );
const DEF = createToken( {
 name: 'DEF',
 pattern: /DEF/,
 longer_alt: Identifier
 } );
const USE = createToken( {
 name: 'USE',
 pattern: /USE/,
 longer_alt: Identifier
 } );
const ROUTE = createToken( {
 name: 'ROUTE',
 pattern: /ROUTE/,
 longer_alt: Identifier
 } );
const TO = createToken( {
 name: 'TO',
 pattern: /TO/,
 longer_alt: Identifier
 } );
//
const StringLiteral = createToken( { name: 'StringLiteral', pattern: /"(?:[^\\"\n\r]|\\[bfnrtv"\\/]|\\u[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])*"/ } );
 const HexLiteral = createToken( { name: 'HexLiteral', pattern: /0[xX][0-9a-fA-F]+/ } );
 const NumberLiteral = createToken( { name: 'NumberLiteral', pattern: /[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?/ } );
 const TrueLiteral = createToken( { name: 'TrueLiteral', pattern: /TRUE/ } );
 const FalseLiteral = createToken( { name: 'FalseLiteral', pattern: /FALSE/ } );
 const NullLiteral = createToken( { name: 'NullLiteral', pattern: /NULL/ } );
 const LSquare = createToken( { name: 'LSquare', pattern: /\[/ } );
 const RSquare = createToken( { name: 'RSquare', pattern: /]/ } );
 const LCurly = createToken( { name: 'LCurly', pattern: /{/ } );
 const RCurly = createToken( { name: 'RCurly', pattern: /}/ } );
 const Comment = createToken( {
 name: 'Comment',
 pattern: /#.*/,
 group: chevrotain.Lexer.SKIPPED
 } );
// commas, blanks, tabs, newlines and carriage returns are whitespace characters wherever they appear outside of string fields
const WhiteSpace = createToken( {
 name: 'WhiteSpace',
 pattern: /[ ,\s]/,
 group: chevrotain.Lexer.SKIPPED
 } );
const tokens = [
 WhiteSpace,
 // keywords appear before the Identifier
 NodeName,
 DEF,
 USE,
 ROUTE,
 TO,
 TrueLiteral,
 FalseLiteral,
 NullLiteral,
 // the Identifier must appear after the keywords because all keywords are valid identifiers
 Version,
 Identifier,
 RouteIdentifier,
 StringLiteral,
 HexLiteral,
 NumberLiteral,
 LSquare,
 RSquare,
 LCurly,
 RCurly,
 Comment
 ];
const tokenVocabulary = {};
for ( let i = 0, l = tokens.length; i < l; i ++ ) {
const token = tokens[ i ];
tokenVocabulary[ token.name ] = token;
}
return { tokens: tokens, tokenVocabulary: tokenVocabulary };
}
function createVisitor( BaseVRMLVisitor ) {
// the visitor is created dynmaically based on the given base class
class VRMLToASTVisitor extends BaseVRMLVisitor {
constructor() {
super();
this.validateVisitor();
}
vrml( ctx ) {
const data = {
 version: this.visit( ctx.version ),
 nodes: [],
 routes: []
 };
for ( let i = 0, l = ctx.node.length; i < l; i ++ ) {
const node = ctx.node[ i ];
data.nodes.push( this.visit( node ) );
}
if ( ctx.route ) {
for ( let i = 0, l = ctx.route.length; i < l; i ++ ) {
const route = ctx.route[ i ];
data.routes.push( this.visit( route ) );
}
}
return data;
}
version( ctx ) {
return ctx.Version[ 0 ].image;
}
node( ctx ) {
const data = {
 name: ctx.NodeName[ 0 ].image,
 fields: []
 };
if ( ctx.field ) {
for ( let i = 0, l = ctx.field.length; i < l; i ++ ) {
const field = ctx.field[ i ];
data.fields.push( this.visit( field ) );
}
}
// DEF
if ( ctx.def ) {
data.DEF = this.visit( ctx.def[ 0 ] );
}
return data;
}
field( ctx ) {
const data = {
 name: ctx.Identifier[ 0 ].image,
 type: null,
 values: null
 };
let result;
// SFValue
if ( ctx.singleFieldValue ) {
result = this.visit( ctx.singleFieldValue[ 0 ] );
}
// MFValue
if ( ctx.multiFieldValue ) {
result = this.visit( ctx.multiFieldValue[ 0 ] );
}
data.type = result.type;
 data.values = result.values;
return data;
}
def( ctx ) {
return ( ctx.Identifier || ctx.NodeName )[ 0 ].image;
}
use( ctx ) {
return { USE: ( ctx.Identifier || ctx.NodeName )[ 0 ].image };
}
singleFieldValue( ctx ) {
return processField( this, ctx );
}
multiFieldValue( ctx ) {
return processField( this, ctx );
}
route( ctx ) {
const data = {
 FROM: ctx.RouteIdentifier[ 0 ].image,
 TO: ctx.RouteIdentifier[ 1 ].image
 };
return data;
}
}
function processField( scope, ctx ) {
const field = {
 type: null,
 values: []
 };
if ( ctx.node ) {
field.type = 'node';
for ( let i = 0, l = ctx.node.length; i < l; i ++ ) {
const node = ctx.node[ i ];
field.values.push( scope.visit( node ) );
}
}
if ( ctx.use ) {
field.type = 'use';
for ( let i = 0, l = ctx.use.length; i < l; i ++ ) {
const use = ctx.use[ i ];
field.values.push( scope.visit( use ) );
}
}
if ( ctx.StringLiteral ) {
field.type = 'string';
for ( let i = 0, l = ctx.StringLiteral.length; i < l; i ++ ) {
const stringLiteral = ctx.StringLiteral[ i ];
field.values.push( stringLiteral.image.replace( /'|"/g, '' ) );
}
}
if ( ctx.NumberLiteral ) {
field.type = 'number';
for ( let i = 0, l = ctx.NumberLiteral.length; i < l; i ++ ) {
const numberLiteral = ctx.NumberLiteral[ i ];
field.values.push( parseFloat( numberLiteral.image ) );
}
}
if ( ctx.HexLiteral ) {
field.type = 'hex';
for ( let i = 0, l = ctx.HexLiteral.length; i < l; i ++ ) {
const hexLiteral = ctx.HexLiteral[ i ];
field.values.push( hexLiteral.image );
}
}
if ( ctx.TrueLiteral ) {
field.type = 'boolean';
for ( let i = 0, l = ctx.TrueLiteral.length; i < l; i ++ ) {
const trueLiteral = ctx.TrueLiteral[ i ];
if ( trueLiteral.image === 'TRUE' ) field.values.push( true );
}
}
if ( ctx.FalseLiteral ) {
field.type = 'boolean';
for ( let i = 0, l = ctx.FalseLiteral.length; i < l; i ++ ) {
const falseLiteral = ctx.FalseLiteral[ i ];
if ( falseLiteral.image === 'FALSE' ) field.values.push( false );
}
}
if ( ctx.NullLiteral ) {
field.type = 'null';
ctx.NullLiteral.forEach( function () {
field.values.push( null );
} );
}
return field;
}
return new VRMLToASTVisitor();
}
function parseTree( tree ) {
// console.log( JSON.stringify( tree, null, 2 ) );
const nodes = tree.nodes;
 const scene = new Scene();
// first iteration: build nodemap based on DEF statements
for ( let i = 0, l = nodes.length; i < l; i ++ ) {
const node = nodes[ i ];
buildNodeMap( node );
}
// second iteration: build nodes
for ( let i = 0, l = nodes.length; i < l; i ++ ) {
const node = nodes[ i ];
 const object = getNode( node );
if ( object instanceof Object3D ) scene.add( object );
if ( node.name === 'WorldInfo' ) scene.userData.worldInfo = object;
}
return scene;
}
function buildNodeMap( node ) {
if ( node.DEF ) {
nodeMap[ node.DEF ] = node;
}
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
if ( field.type === 'node' ) {
const fieldValues = field.values;
for ( let j = 0, jl = fieldValues.length; j < jl; j ++ ) {
buildNodeMap( fieldValues[ j ] );
}
}
}
}
function getNode( node ) {
// handle case where a node refers to a different one
if ( node.USE ) {
return resolveUSE( node.USE );
}
if ( node.build !== undefined ) return node.build;
node.build = buildNode( node );
return node.build;
}
// node builder
function buildNode( node ) {
const nodeName = node.name;
 let build;
switch ( nodeName ) {
case 'Anchor':
 case 'Group':
 case 'Transform':
 case 'Collision':
 build = buildGroupingNode( node );
 break;
case 'Background':
 build = buildBackgroundNode( node );
 break;
case 'Shape':
 build = buildShapeNode( node );
 break;
case 'Appearance':
 build = buildAppearanceNode( node );
 break;
case 'Material':
 build = buildMaterialNode( node );
 break;
case 'ImageTexture':
 build = buildImageTextureNode( node );
 break;
case 'PixelTexture':
 build = buildPixelTextureNode( node );
 break;
case 'TextureTransform':
 build = buildTextureTransformNode( node );
 break;
case 'IndexedFaceSet':
 build = buildIndexedFaceSetNode( node );
 break;
case 'IndexedLineSet':
 build = buildIndexedLineSetNode( node );
 break;
case 'PointSet':
 build = buildPointSetNode( node );
 break;
case 'Box':
 build = buildBoxNode( node );
 break;
case 'Cone':
 build = buildConeNode( node );
 break;
case 'Cylinder':
 build = buildCylinderNode( node );
 break;
case 'Sphere':
 build = buildSphereNode( node );
 break;
case 'ElevationGrid':
 build = buildElevationGridNode( node );
 break;
case 'Extrusion':
 build = buildExtrusionNode( node );
 break;
case 'Color':
 case 'Coordinate':
 case 'Normal':
 case 'TextureCoordinate':
 build = buildGeometricNode( node );
 break;
case 'WorldInfo':
 build = buildWorldInfoNode( node );
 break;
case 'Billboard':
case 'Inline':
 case 'LOD':
 case 'Switch':
case 'AudioClip':
 case 'DirectionalLight':
 case 'PointLight':
 case 'Script':
 case 'Sound':
 case 'SpotLight':
case 'CylinderSensor':
 case 'PlaneSensor':
 case 'ProximitySensor':
 case 'SphereSensor':
 case 'TimeSensor':
 case 'TouchSensor':
 case 'VisibilitySensor':
case 'Text':
case 'FontStyle':
 case 'MovieTexture':
case 'ColorInterpolator':
 case 'CoordinateInterpolator':
 case 'NormalInterpolator':
 case 'OrientationInterpolator':
 case 'PositionInterpolator':
 case 'ScalarInterpolator':
case 'Fog':
 case 'NavigationInfo':
 case 'Viewpoint':
 // node not supported yet
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown node:', nodeName );
 break;
}
if ( build !== undefined && node.DEF !== undefined && build.hasOwnProperty( 'name' ) === true ) {
build.name = node.DEF;
}
return build;
}
function buildGroupingNode( node ) {
const object = new Group();
//
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'bboxCenter':
 // field not supported
 break;
case 'bboxSize':
 // field not supported
 break;
case 'center':
 // field not supported
 break;
case 'children':
 parseFieldChildren( fieldValues, object );
 break;
case 'description':
 // field not supported
 break;
case 'collide':
 // field not supported
 break;
case 'parameter':
 // field not supported
 break;
case 'rotation':
 const axis = new Vector3( fieldValues[ 0 ], fieldValues[ 1 ], fieldValues[ 2 ] );
 const angle = fieldValues[ 3 ];
 object.quaternion.setFromAxisAngle( axis, angle );
 break;
case 'scale':
 object.scale.set( fieldValues[ 0 ], fieldValues[ 1 ], fieldValues[ 2 ] );
 break;
case 'scaleOrientation':
 // field not supported
 break;
case 'translation':
 object.position.set( fieldValues[ 0 ], fieldValues[ 1 ], fieldValues[ 2 ] );
 break;
case 'proxy':
 // field not supported
 break;
case 'url':
 // field not supported
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
return object;
}
function buildBackgroundNode( node ) {
const group = new Group();
let groundAngle, groundColor;
 let skyAngle, skyColor;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'groundAngle':
 groundAngle = fieldValues;
 break;
case 'groundColor':
 groundColor = fieldValues;
 break;
case 'backUrl':
 // field not supported
 break;
case 'bottomUrl':
 // field not supported
 break;
case 'frontUrl':
 // field not supported
 break;
case 'leftUrl':
 // field not supported
 break;
case 'rightUrl':
 // field not supported
 break;
case 'topUrl':
 // field not supported
 break;
case 'skyAngle':
 skyAngle = fieldValues;
 break;
case 'skyColor':
 skyColor = fieldValues;
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
const radius = 10000;
// sky
if ( skyColor ) {
const skyGeometry = new SphereGeometry( radius, 32, 16 );
 const skyMaterial = new MeshBasicMaterial( { fog: false, side: BackSide, depthWrite: false, depthTest: false } );
if ( skyColor.length > 3 ) {
paintFaces( skyGeometry, radius, skyAngle, toColorArray( skyColor ), true );
 skyMaterial.vertexColors = true;
} else {
skyMaterial.color.setRGB( skyColor[ 0 ], skyColor[ 1 ], skyColor[ 2 ] );
 skyMaterial.color.convertSRGBToLinear();
}
const sky = new Mesh( skyGeometry, skyMaterial );
 group.add( sky );
}
// ground
if ( groundColor ) {
if ( groundColor.length > 0 ) {
const groundGeometry = new SphereGeometry( radius, 32, 16, 0, 2 * Math.PI, 0.5 * Math.PI, 1.5 * Math.PI );
 const groundMaterial = new MeshBasicMaterial( { fog: false, side: BackSide, vertexColors: true, depthWrite: false, depthTest: false } );
paintFaces( groundGeometry, radius, groundAngle, toColorArray( groundColor ), false );
const ground = new Mesh( groundGeometry, groundMaterial );
 group.add( ground );
}
}
// render background group first
group.renderOrder = - Infinity;
return group;
}
function buildShapeNode( node ) {
const fields = node.fields;
// if the appearance field is NULL or unspecified, lighting is off and the unlit object color is (0, 0, 0)
let material = new MeshBasicMaterial( {
 name: Loader.DEFAULT_MATERIAL_NAME,
 color: 0x000000
 } );
 let geometry;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'appearance':
 if ( fieldValues[ 0 ] !== null ) {
material = getNode( fieldValues[ 0 ] );
}
break;
case 'geometry':
 if ( fieldValues[ 0 ] !== null ) {
geometry = getNode( fieldValues[ 0 ] );
}
break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
// build 3D object
let object;
if ( geometry && geometry.attributes.position ) {
const type = geometry._type;
if ( type === 'points' ) { // points
const pointsMaterial = new PointsMaterial( {
 name: Loader.DEFAULT_MATERIAL_NAME,
 color: 0xffffff
 } );
if ( geometry.attributes.color !== undefined ) {
pointsMaterial.vertexColors = true;
} else {
// if the color field is NULL and there is a material defined for the appearance affecting this PointSet, then use the emissiveColor of the material to draw the points
if ( material.isMeshPhongMaterial ) {
pointsMaterial.color.copy( material.emissive );
}
}
object = new Points( geometry, pointsMaterial );
} else if ( type === 'line' ) { // lines
const lineMaterial = new LineBasicMaterial( {
 name: Loader.DEFAULT_MATERIAL_NAME,
 color: 0xffffff
 } );
if ( geometry.attributes.color !== undefined ) {
lineMaterial.vertexColors = true;
} else {
// if the color field is NULL and there is a material defined for the appearance affecting this IndexedLineSet, then use the emissiveColor of the material to draw the lines
if ( material.isMeshPhongMaterial ) {
lineMaterial.color.copy( material.emissive );
}
}
object = new LineSegments( geometry, lineMaterial );
} else { // consider meshes
// check "solid" hint (it's placed in the geometry but affects the material)
if ( geometry._solid !== undefined ) {
material.side = ( geometry._solid ) ? FrontSide : DoubleSide;
}
// check for vertex colors
if ( geometry.attributes.color !== undefined ) {
material.vertexColors = true;
}
object = new Mesh( geometry, material );
}
} else {
object = new Object3D();
// if the geometry field is NULL or no vertices are defined the object is not drawn
object.visible = false;
}
return object;
}
function buildAppearanceNode( node ) {
let material = new MeshPhongMaterial();
 let transformData;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'material':
 if ( fieldValues[ 0 ] !== null ) {
const materialData = getNode( fieldValues[ 0 ] );
if ( materialData.diffuseColor ) material.color.copy( materialData.diffuseColor );
 if ( materialData.emissiveColor ) material.emissive.copy( materialData.emissiveColor );
 if ( materialData.shininess ) material.shininess = materialData.shininess;
 if ( materialData.specularColor ) material.specular.copy( materialData.specularColor );
 if ( materialData.transparency ) material.opacity = 1 - materialData.transparency;
 if ( materialData.transparency > 0 ) material.transparent = true;
} else {
// if the material field is NULL or unspecified, lighting is off and the unlit object color is (0, 0, 0)
material = new MeshBasicMaterial( {
 name: Loader.DEFAULT_MATERIAL_NAME,
 color: 0x000000
 } );
}
break;
case 'texture':
 const textureNode = fieldValues[ 0 ];
 if ( textureNode !== null ) {
if ( textureNode.name === 'ImageTexture' || textureNode.name === 'PixelTexture' ) {
material.map = getNode( textureNode );
} else {
// MovieTexture not supported yet
}
}
break;
case 'textureTransform':
 if ( fieldValues[ 0 ] !== null ) {
transformData = getNode( fieldValues[ 0 ] );
}
break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
// only apply texture transform data if a texture was defined
if ( material.map ) {
// respect VRML lighting model
if ( material.map.__type ) {
switch ( material.map.__type ) {
case TEXTURE_TYPE.INTENSITY_ALPHA:
 material.opacity = 1; // ignore transparency
 break;
case TEXTURE_TYPE.RGB:
 material.color.set( 0xffffff ); // ignore material color
 break;
case TEXTURE_TYPE.RGBA:
 material.color.set( 0xffffff ); // ignore material color
 material.opacity = 1; // ignore transparency
 break;
default:
}
delete material.map.__type;
}
// apply texture transform
if ( transformData ) {
material.map.center.copy( transformData.center );
 material.map.rotation = transformData.rotation;
 material.map.repeat.copy( transformData.scale );
 material.map.offset.copy( transformData.translation );
}
}
return material;
}
function buildMaterialNode( node ) {
const materialData = {};
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'ambientIntensity':
 // field not supported
 break;
case 'diffuseColor':
 materialData.diffuseColor = new Color( fieldValues[ 0 ], fieldValues[ 1 ], fieldValues[ 2 ] );
 materialData.diffuseColor.convertSRGBToLinear();
 break;
case 'emissiveColor':
 materialData.emissiveColor = new Color( fieldValues[ 0 ], fieldValues[ 1 ], fieldValues[ 2 ] );
 materialData.emissiveColor.convertSRGBToLinear();
 break;
case 'shininess':
 materialData.shininess = fieldValues[ 0 ];
 break;
case 'specularColor':
 materialData.specularColor = new Color( fieldValues[ 0 ], fieldValues[ 1 ], fieldValues[ 2 ] );
 materialData.specularColor.convertSRGBToLinear();
 break;
case 'transparency':
 materialData.transparency = fieldValues[ 0 ];
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
return materialData;
}
function parseHexColor( hex, textureType, color ) {
let value;
switch ( textureType ) {
case TEXTURE_TYPE.INTENSITY:
 // Intensity texture: A one-component image specifies one-byte hexadecimal or integer values representing the intensity of the image
 value = parseInt( hex );
 color.r = value;
 color.g = value;
 color.b = value;
 color.a = 1;
 break;
case TEXTURE_TYPE.INTENSITY_ALPHA:
 // Intensity+Alpha texture: A two-component image specifies the intensity in the first (high) byte and the alpha opacity in the second (low) byte.
 value = parseInt( '0x' + hex.substring( 2, 4 ) );
 color.r = value;
 color.g = value;
 color.b = value;
 color.a = parseInt( '0x' + hex.substring( 4, 6 ) );
 break;
case TEXTURE_TYPE.RGB:
 // RGB texture: Pixels in a three-component image specify the red component in the first (high) byte, followed by the green and blue components
 color.r = parseInt( '0x' + hex.substring( 2, 4 ) );
 color.g = parseInt( '0x' + hex.substring( 4, 6 ) );
 color.b = parseInt( '0x' + hex.substring( 6, 8 ) );
 color.a = 1;
 break;
case TEXTURE_TYPE.RGBA:
 // RGBA texture: Four-component images specify the alpha opacity byte after red/green/blue
 color.r = parseInt( '0x' + hex.substring( 2, 4 ) );
 color.g = parseInt( '0x' + hex.substring( 4, 6 ) );
 color.b = parseInt( '0x' + hex.substring( 6, 8 ) );
 color.a = parseInt( '0x' + hex.substring( 8, 10 ) );
 break;
default:
}
}
function getTextureType( num_components ) {
let type;
switch ( num_components ) {
case 1:
 type = TEXTURE_TYPE.INTENSITY;
 break;
case 2:
 type = TEXTURE_TYPE.INTENSITY_ALPHA;
 break;
case 3:
 type = TEXTURE_TYPE.RGB;
 break;
case 4:
 type = TEXTURE_TYPE.RGBA;
 break;
default:
}
return type;
}
function buildPixelTextureNode( node ) {
let texture;
 let wrapS = RepeatWrapping;
 let wrapT = RepeatWrapping;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'image':
 const width = fieldValues[ 0 ];
 const height = fieldValues[ 1 ];
 const num_components = fieldValues[ 2 ];
const textureType = getTextureType( num_components );
const data = new Uint8Array( 4 * width * height );
const color = { r: 0, g: 0, b: 0, a: 0 };
for ( let j = 3, k = 0, jl = fieldValues.length; j < jl; j ++, k ++ ) {
parseHexColor( fieldValues[ j ], textureType, color );
const stride = k * 4;
data[ stride + 0 ] = color.r;
 data[ stride + 1 ] = color.g;
 data[ stride + 2 ] = color.b;
 data[ stride + 3 ] = color.a;
}
texture = new DataTexture( data, width, height );
 texture.colorSpace = SRGBColorSpace;
 texture.needsUpdate = true;
 texture.__type = textureType; // needed for material modifications
 break;
case 'repeatS':
 if ( fieldValues[ 0 ] === false ) wrapS = ClampToEdgeWrapping;
 break;
case 'repeatT':
 if ( fieldValues[ 0 ] === false ) wrapT = ClampToEdgeWrapping;
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
if ( texture ) {
texture.wrapS = wrapS;
 texture.wrapT = wrapT;
}
return texture;
}
function buildImageTextureNode( node ) {
let texture;
 let wrapS = RepeatWrapping;
 let wrapT = RepeatWrapping;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'url':
 const url = fieldValues[ 0 ];
 if ( url ) texture = textureLoader.load( url );
 break;
case 'repeatS':
 if ( fieldValues[ 0 ] === false ) wrapS = ClampToEdgeWrapping;
 break;
case 'repeatT':
 if ( fieldValues[ 0 ] === false ) wrapT = ClampToEdgeWrapping;
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
if ( texture ) {
texture.wrapS = wrapS;
 texture.wrapT = wrapT;
 texture.colorSpace = SRGBColorSpace;
}
return texture;
}
function buildTextureTransformNode( node ) {
const transformData = {
 center: new Vector2(),
 rotation: new Vector2(),
 scale: new Vector2(),
 translation: new Vector2()
 };
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'center':
 transformData.center.set( fieldValues[ 0 ], fieldValues[ 1 ] );
 break;
case 'rotation':
 transformData.rotation = fieldValues[ 0 ];
 break;
case 'scale':
 transformData.scale.set( fieldValues[ 0 ], fieldValues[ 1 ] );
 break;
case 'translation':
 transformData.translation.set( fieldValues[ 0 ], fieldValues[ 1 ] );
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
return transformData;
}
function buildGeometricNode( node ) {
return node.fields[ 0 ].values;
}
function buildWorldInfoNode( node ) {
const worldInfo = {};
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'title':
 worldInfo.title = fieldValues[ 0 ];
 break;
case 'info':
 worldInfo.info = fieldValues;
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
return worldInfo;
}
function buildIndexedFaceSetNode( node ) {
let color, coord, normal, texCoord;
 let ccw = true, solid = true, creaseAngle = 0;
 let colorIndex, coordIndex, normalIndex, texCoordIndex;
 let colorPerVertex = true, normalPerVertex = true;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'color':
 const colorNode = fieldValues[ 0 ];
if ( colorNode !== null ) {
color = getNode( colorNode );
}
break;
case 'coord':
 const coordNode = fieldValues[ 0 ];
if ( coordNode !== null ) {
coord = getNode( coordNode );
}
break;
case 'normal':
 const normalNode = fieldValues[ 0 ];
if ( normalNode !== null ) {
normal = getNode( normalNode );
}
break;
case 'texCoord':
 const texCoordNode = fieldValues[ 0 ];
if ( texCoordNode !== null ) {
texCoord = getNode( texCoordNode );
}
break;
case 'ccw':
 ccw = fieldValues[ 0 ];
 break;
case 'colorIndex':
 colorIndex = fieldValues;
 break;
case 'colorPerVertex':
 colorPerVertex = fieldValues[ 0 ];
 break;
case 'convex':
 // field not supported
 break;
case 'coordIndex':
 coordIndex = fieldValues;
 break;
case 'creaseAngle':
 creaseAngle = fieldValues[ 0 ];
 break;
case 'normalIndex':
 normalIndex = fieldValues;
 break;
case 'normalPerVertex':
 normalPerVertex = fieldValues[ 0 ];
 break;
case 'solid':
 solid = fieldValues[ 0 ];
 break;
case 'texCoordIndex':
 texCoordIndex = fieldValues;
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
if ( coordIndex === undefined ) {
console.warn( 'THREE.VRMLLoader: Missing coordIndex.' );
return new BufferGeometry(); // handle VRML files with incomplete geometry definition
}
const triangulatedCoordIndex = triangulateFaceIndex( coordIndex, ccw );
let colorAttribute;
 let normalAttribute;
 let uvAttribute;
if ( color ) {
if ( colorPerVertex === true ) {
if ( colorIndex && colorIndex.length > 0 ) {
// if the colorIndex field is not empty, then it is used to choose colors for each vertex of the IndexedFaceSet.
const triangulatedColorIndex = triangulateFaceIndex( colorIndex, ccw );
 colorAttribute = computeAttributeFromIndexedData( triangulatedCoordIndex, triangulatedColorIndex, color, 3 );
} else {
// if the colorIndex field is empty, then the coordIndex field is used to choose colors from the Color node
colorAttribute = toNonIndexedAttribute( triangulatedCoordIndex, new Float32BufferAttribute( color, 3 ) );
}
} else {
if ( colorIndex && colorIndex.length > 0 ) {
// if the colorIndex field is not empty, then they are used to choose one color for each face of the IndexedFaceSet
const flattenFaceColors = flattenData( color, colorIndex );
 const triangulatedFaceColors = triangulateFaceData( flattenFaceColors, coordIndex );
 colorAttribute = computeAttributeFromFaceData( triangulatedCoordIndex, triangulatedFaceColors );
} else {
// if the colorIndex field is empty, then the color are applied to each face of the IndexedFaceSet in order
const triangulatedFaceColors = triangulateFaceData( color, coordIndex );
 colorAttribute = computeAttributeFromFaceData( triangulatedCoordIndex, triangulatedFaceColors );
}
}
convertColorsToLinearSRGB( colorAttribute );
}
if ( normal ) {
if ( normalPerVertex === true ) {
// consider vertex normals
if ( normalIndex && normalIndex.length > 0 ) {
// if the normalIndex field is not empty, then it is used to choose normals for each vertex of the IndexedFaceSet.
const triangulatedNormalIndex = triangulateFaceIndex( normalIndex, ccw );
 normalAttribute = computeAttributeFromIndexedData( triangulatedCoordIndex, triangulatedNormalIndex, normal, 3 );
} else {
// if the normalIndex field is empty, then the coordIndex field is used to choose normals from the Normal node
normalAttribute = toNonIndexedAttribute( triangulatedCoordIndex, new Float32BufferAttribute( normal, 3 ) );
}
} else {
// consider face normals
if ( normalIndex && normalIndex.length > 0 ) {
// if the normalIndex field is not empty, then they are used to choose one normal for each face of the IndexedFaceSet
const flattenFaceNormals = flattenData( normal, normalIndex );
 const triangulatedFaceNormals = triangulateFaceData( flattenFaceNormals, coordIndex );
 normalAttribute = computeAttributeFromFaceData( triangulatedCoordIndex, triangulatedFaceNormals );
} else {
// if the normalIndex field is empty, then the normals are applied to each face of the IndexedFaceSet in order
const triangulatedFaceNormals = triangulateFaceData( normal, coordIndex );
 normalAttribute = computeAttributeFromFaceData( triangulatedCoordIndex, triangulatedFaceNormals );
}
}
} else {
// if the normal field is NULL, then the loader should automatically generate normals, using creaseAngle to determine if and how normals are smoothed across shared vertices
normalAttribute = computeNormalAttribute( triangulatedCoordIndex, coord, creaseAngle );
}
if ( texCoord ) {
// texture coordinates are always defined on vertex level
if ( texCoordIndex && texCoordIndex.length > 0 ) {
// if the texCoordIndex field is not empty, then it is used to choose texture coordinates for each vertex of the IndexedFaceSet.
const triangulatedTexCoordIndex = triangulateFaceIndex( texCoordIndex, ccw );
 uvAttribute = computeAttributeFromIndexedData( triangulatedCoordIndex, triangulatedTexCoordIndex, texCoord, 2 );
} else {
// if the texCoordIndex field is empty, then the coordIndex array is used to choose texture coordinates from the TextureCoordinate node
uvAttribute = toNonIndexedAttribute( triangulatedCoordIndex, new Float32BufferAttribute( texCoord, 2 ) );
}
}
const geometry = new BufferGeometry();
 const positionAttribute = toNonIndexedAttribute( triangulatedCoordIndex, new Float32BufferAttribute( coord, 3 ) );
geometry.setAttribute( 'position', positionAttribute );
 geometry.setAttribute( 'normal', normalAttribute );
// optional attributes
if ( colorAttribute ) geometry.setAttribute( 'color', colorAttribute );
 if ( uvAttribute ) geometry.setAttribute( 'uv', uvAttribute );
// "solid" influences the material so let's store it for later use
geometry._solid = solid;
 geometry._type = 'mesh';
return geometry;
}
function buildIndexedLineSetNode( node ) {
let color, coord;
 let colorIndex, coordIndex;
 let colorPerVertex = true;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'color':
 const colorNode = fieldValues[ 0 ];
if ( colorNode !== null ) {
color = getNode( colorNode );
}
break;
case 'coord':
 const coordNode = fieldValues[ 0 ];
if ( coordNode !== null ) {
coord = getNode( coordNode );
}
break;
case 'colorIndex':
 colorIndex = fieldValues;
 break;
case 'colorPerVertex':
 colorPerVertex = fieldValues[ 0 ];
 break;
case 'coordIndex':
 coordIndex = fieldValues;
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
// build lines
let colorAttribute;
const expandedLineIndex = expandLineIndex( coordIndex ); // create an index for three.js's linesegment primitive
if ( color ) {
if ( colorPerVertex === true ) {
if ( colorIndex.length > 0 ) {
// if the colorIndex field is not empty, then one color is used for each polyline of the IndexedLineSet.
const expandedColorIndex = expandLineIndex( colorIndex ); // compute colors for each line segment (rendering primitve)
 colorAttribute = computeAttributeFromIndexedData( expandedLineIndex, expandedColorIndex, color, 3 ); // compute data on vertex level
} else {
// if the colorIndex field is empty, then the colors are applied to each polyline of the IndexedLineSet in order.
colorAttribute = toNonIndexedAttribute( expandedLineIndex, new Float32BufferAttribute( color, 3 ) );
}
} else {
if ( colorIndex.length > 0 ) {
// if the colorIndex field is not empty, then colors are applied to each vertex of the IndexedLineSet
const flattenLineColors = flattenData( color, colorIndex ); // compute colors for each VRML primitve
 const expandedLineColors = expandLineData( flattenLineColors, coordIndex ); // compute colors for each line segment (rendering primitve)
 colorAttribute = computeAttributeFromLineData( expandedLineIndex, expandedLineColors ); // compute data on vertex level
} else {
// if the colorIndex field is empty, then the coordIndex field is used to choose colors from the Color node
const expandedLineColors = expandLineData( color, coordIndex ); // compute colors for each line segment (rendering primitve)
 colorAttribute = computeAttributeFromLineData( expandedLineIndex, expandedLineColors ); // compute data on vertex level
}
}
convertColorsToLinearSRGB( colorAttribute );
}
//
const geometry = new BufferGeometry();
const positionAttribute = toNonIndexedAttribute( expandedLineIndex, new Float32BufferAttribute( coord, 3 ) );
 geometry.setAttribute( 'position', positionAttribute );
if ( colorAttribute ) geometry.setAttribute( 'color', colorAttribute );
geometry._type = 'line';
return geometry;
}
function buildPointSetNode( node ) {
let color, coord;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'color':
 const colorNode = fieldValues[ 0 ];
if ( colorNode !== null ) {
color = getNode( colorNode );
}
break;
case 'coord':
 const coordNode = fieldValues[ 0 ];
if ( coordNode !== null ) {
coord = getNode( coordNode );
}
break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
const geometry = new BufferGeometry();
geometry.setAttribute( 'position', new Float32BufferAttribute( coord, 3 ) );
if ( color ) {
const colorAttribute = new Float32BufferAttribute( color, 3 );
 convertColorsToLinearSRGB( colorAttribute );
geometry.setAttribute( 'color', colorAttribute );
}
geometry._type = 'points';
return geometry;
}
function buildBoxNode( node ) {
const size = new Vector3( 2, 2, 2 );
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'size':
 size.x = fieldValues[ 0 ];
 size.y = fieldValues[ 1 ];
 size.z = fieldValues[ 2 ];
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
const geometry = new BoxGeometry( size.x, size.y, size.z );
return geometry;
}
function buildConeNode( node ) {
let radius = 1, height = 2, openEnded = false;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'bottom':
 openEnded = ! fieldValues[ 0 ];
 break;
case 'bottomRadius':
 radius = fieldValues[ 0 ];
 break;
case 'height':
 height = fieldValues[ 0 ];
 break;
case 'side':
 // field not supported
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
const geometry = new ConeGeometry( radius, height, 16, 1, openEnded );
return geometry;
}
function buildCylinderNode( node ) {
let radius = 1, height = 2;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'bottom':
 // field not supported
 break;
case 'radius':
 radius = fieldValues[ 0 ];
 break;
case 'height':
 height = fieldValues[ 0 ];
 break;
case 'side':
 // field not supported
 break;
case 'top':
 // field not supported
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
const geometry = new CylinderGeometry( radius, radius, height, 16, 1 );
return geometry;
}
function buildSphereNode( node ) {
let radius = 1;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'radius':
 radius = fieldValues[ 0 ];
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
const geometry = new SphereGeometry( radius, 16, 16 );
return geometry;
}
function buildElevationGridNode( node ) {
let color;
 let normal;
 let texCoord;
 let height;
let colorPerVertex = true;
 let normalPerVertex = true;
 let solid = true;
 let ccw = true;
 let creaseAngle = 0;
 let xDimension = 2;
 let zDimension = 2;
 let xSpacing = 1;
 let zSpacing = 1;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'color':
 const colorNode = fieldValues[ 0 ];
if ( colorNode !== null ) {
color = getNode( colorNode );
}
break;
case 'normal':
 const normalNode = fieldValues[ 0 ];
if ( normalNode !== null ) {
normal = getNode( normalNode );
}
break;
case 'texCoord':
 const texCoordNode = fieldValues[ 0 ];
if ( texCoordNode !== null ) {
texCoord = getNode( texCoordNode );
}
break;
case 'height':
 height = fieldValues;
 break;
case 'ccw':
 ccw = fieldValues[ 0 ];
 break;
case 'colorPerVertex':
 colorPerVertex = fieldValues[ 0 ];
 break;
case 'creaseAngle':
 creaseAngle = fieldValues[ 0 ];
 break;
case 'normalPerVertex':
 normalPerVertex = fieldValues[ 0 ];
 break;
case 'solid':
 solid = fieldValues[ 0 ];
 break;
case 'xDimension':
 xDimension = fieldValues[ 0 ];
 break;
case 'xSpacing':
 xSpacing = fieldValues[ 0 ];
 break;
case 'zDimension':
 zDimension = fieldValues[ 0 ];
 break;
case 'zSpacing':
 zSpacing = fieldValues[ 0 ];
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
// vertex data
const vertices = [];
 const normals = [];
 const colors = [];
 const uvs = [];
for ( let i = 0; i < zDimension; i ++ ) {
for ( let j = 0; j < xDimension; j ++ ) {
// compute a row major index
const index = ( i * xDimension ) + j;
// vertices
const x = xSpacing * i;
 const y = height[ index ];
 const z = zSpacing * j;
vertices.push( x, y, z );
// colors
if ( color && colorPerVertex === true ) {
const r = color[ index * 3 + 0 ];
 const g = color[ index * 3 + 1 ];
 const b = color[ index * 3 + 2 ];
colors.push( r, g, b );
}
// normals
if ( normal && normalPerVertex === true ) {
const xn = normal[ index * 3 + 0 ];
 const yn = normal[ index * 3 + 1 ];
 const zn = normal[ index * 3 + 2 ];
normals.push( xn, yn, zn );
}
// uvs
if ( texCoord ) {
const s = texCoord[ index * 2 + 0 ];
 const t = texCoord[ index * 2 + 1 ];
uvs.push( s, t );
} else {
uvs.push( i / ( xDimension - 1 ), j / ( zDimension - 1 ) );
}
}
}
// indices
const indices = [];
for ( let i = 0; i < xDimension - 1; i ++ ) {
for ( let j = 0; j < zDimension - 1; j ++ ) {
// from https://tecfa.unige.ch/guides/vrml/vrml97/spec/part1/nodesRef.html#ElevationGrid
const a = i + j * xDimension;
 const b = i + ( j + 1 ) * xDimension;
 const c = ( i + 1 ) + ( j + 1 ) * xDimension;
 const d = ( i + 1 ) + j * xDimension;
// faces
if ( ccw === true ) {
indices.push( a, c, b );
 indices.push( c, a, d );
} else {
indices.push( a, b, c );
 indices.push( c, d, a );
}
}
}
//
const positionAttribute = toNonIndexedAttribute( indices, new Float32BufferAttribute( vertices, 3 ) );
 const uvAttribute = toNonIndexedAttribute( indices, new Float32BufferAttribute( uvs, 2 ) );
 let colorAttribute;
 let normalAttribute;
// color attribute
if ( color ) {
if ( colorPerVertex === false ) {
for ( let i = 0; i < xDimension - 1; i ++ ) {
for ( let j = 0; j < zDimension - 1; j ++ ) {
const index = i + j * ( xDimension - 1 );
const r = color[ index * 3 + 0 ];
 const g = color[ index * 3 + 1 ];
 const b = color[ index * 3 + 2 ];
// one color per quad
colors.push( r, g, b ); colors.push( r, g, b ); colors.push( r, g, b );
 colors.push( r, g, b ); colors.push( r, g, b ); colors.push( r, g, b );
}
}
colorAttribute = new Float32BufferAttribute( colors, 3 );
} else {
colorAttribute = toNonIndexedAttribute( indices, new Float32BufferAttribute( colors, 3 ) );
}
convertColorsToLinearSRGB( colorAttribute );
}
// normal attribute
if ( normal ) {
if ( normalPerVertex === false ) {
for ( let i = 0; i < xDimension - 1; i ++ ) {
for ( let j = 0; j < zDimension - 1; j ++ ) {
const index = i + j * ( xDimension - 1 );
const xn = normal[ index * 3 + 0 ];
 const yn = normal[ index * 3 + 1 ];
 const zn = normal[ index * 3 + 2 ];
// one normal per quad
normals.push( xn, yn, zn ); normals.push( xn, yn, zn ); normals.push( xn, yn, zn );
 normals.push( xn, yn, zn ); normals.push( xn, yn, zn ); normals.push( xn, yn, zn );
}
}
normalAttribute = new Float32BufferAttribute( normals, 3 );
} else {
normalAttribute = toNonIndexedAttribute( indices, new Float32BufferAttribute( normals, 3 ) );
}
} else {
normalAttribute = computeNormalAttribute( indices, vertices, creaseAngle );
}
// build geometry
const geometry = new BufferGeometry();
 geometry.setAttribute( 'position', positionAttribute );
 geometry.setAttribute( 'normal', normalAttribute );
 geometry.setAttribute( 'uv', uvAttribute );
if ( colorAttribute ) geometry.setAttribute( 'color', colorAttribute );
// "solid" influences the material so let's store it for later use
geometry._solid = solid;
 geometry._type = 'mesh';
return geometry;
}
function buildExtrusionNode( node ) {
let crossSection = [ 1, 1, 1, - 1, - 1, - 1, - 1, 1, 1, 1 ];
 let spine = [ 0, 0, 0, 0, 1, 0 ];
 let scale;
 let orientation;
let beginCap = true;
 let ccw = true;
 let creaseAngle = 0;
 let endCap = true;
 let solid = true;
const fields = node.fields;
for ( let i = 0, l = fields.length; i < l; i ++ ) {
const field = fields[ i ];
 const fieldName = field.name;
 const fieldValues = field.values;
switch ( fieldName ) {
case 'beginCap':
 beginCap = fieldValues[ 0 ];
 break;
case 'ccw':
 ccw = fieldValues[ 0 ];
 break;
case 'convex':
 // field not supported
 break;
case 'creaseAngle':
 creaseAngle = fieldValues[ 0 ];
 break;
case 'crossSection':
 crossSection = fieldValues;
 break;
case 'endCap':
 endCap = fieldValues[ 0 ];
 break;
case 'orientation':
 orientation = fieldValues;
 break;
case 'scale':
 scale = fieldValues;
 break;
case 'solid':
 solid = fieldValues[ 0 ];
 break;
case 'spine':
 spine = fieldValues; // only extrusion along the Y-axis are supported so far
 break;
default:
 console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 break;
}
}
const crossSectionClosed = ( crossSection[ 0 ] === crossSection[ crossSection.length - 2 ] && crossSection[ 1 ] === crossSection[ crossSection.length - 1 ] );
// vertices
const vertices = [];
 const spineVector = new Vector3();
 const scaling = new Vector3();
const axis = new Vector3();
 const vertex = new Vector3();
 const quaternion = new Quaternion();
for ( let i = 0, j = 0, o = 0, il = spine.length; i < il; i += 3, j += 2, o += 4 ) {
spineVector.fromArray( spine, i );
scaling.x = scale ? scale[ j + 0 ] : 1;
 scaling.y = 1;
 scaling.z = scale ? scale[ j + 1 ] : 1;
axis.x = orientation ? orientation[ o + 0 ] : 0;
 axis.y = orientation ? orientation[ o + 1 ] : 0;
 axis.z = orientation ? orientation[ o + 2 ] : 1;
 const angle = orientation ? orientation[ o + 3 ] : 0;
for ( let k = 0, kl = crossSection.length; k < kl; k += 2 ) {
vertex.x = crossSection[ k + 0 ];
 vertex.y = 0;
 vertex.z = crossSection[ k + 1 ];
// scale
vertex.multiply( scaling );
// rotate
quaternion.setFromAxisAngle( axis, angle );
 vertex.applyQuaternion( quaternion );
// translate
vertex.add( spineVector );
vertices.push( vertex.x, vertex.y, vertex.z );
}
}
// indices
const indices = [];
const spineCount = spine.length / 3;
 const crossSectionCount = crossSection.length / 2;
for ( let i = 0; i < spineCount - 1; i ++ ) {
for ( let j = 0; j < crossSectionCount - 1; j ++ ) {
const a = j + i * crossSectionCount;
 let b = ( j + 1 ) + i * crossSectionCount;
 const c = j + ( i + 1 ) * crossSectionCount;
 let d = ( j + 1 ) + ( i + 1 ) * crossSectionCount;
if ( ( j === crossSectionCount - 2 ) && ( crossSectionClosed === true ) ) {
b = i * crossSectionCount;
 d = ( i + 1 ) * crossSectionCount;
}
if ( ccw === true ) {
indices.push( a, b, c );
 indices.push( c, b, d );
} else {
indices.push( a, c, b );
 indices.push( c, d, b );
}
}
}
// triangulate cap
if ( beginCap === true || endCap === true ) {
const contour = [];
for ( let i = 0, l = crossSection.length; i < l; i += 2 ) {
contour.push( new Vector2( crossSection[ i ], crossSection[ i + 1 ] ) );
}
const faces = ShapeUtils.triangulateShape( contour, [] );
 const capIndices = [];
for ( let i = 0, l = faces.length; i < l; i ++ ) {
const face = faces[ i ];
capIndices.push( face[ 0 ], face[ 1 ], face[ 2 ] );
}
// begin cap
if ( beginCap === true ) {
for ( let i = 0, l = capIndices.length; i < l; i += 3 ) {
if ( ccw === true ) {
indices.push( capIndices[ i + 0 ], capIndices[ i + 1 ], capIndices[ i + 2 ] );
} else {
indices.push( capIndices[ i + 0 ], capIndices[ i + 2 ], capIndices[ i + 1 ] );
}
}
}
// end cap
if ( endCap === true ) {
const indexOffset = crossSectionCount * ( spineCount - 1 ); // references to the first vertex of the last cross section
for ( let i = 0, l = capIndices.length; i < l; i += 3 ) {
if ( ccw === true ) {
indices.push( indexOffset + capIndices[ i + 0 ], indexOffset + capIndices[ i + 2 ], indexOffset + capIndices[ i + 1 ] );
} else {
indices.push( indexOffset + capIndices[ i + 0 ], indexOffset + capIndices[ i + 1 ], indexOffset + capIndices[ i + 2 ] );
}
}
}
}
const positionAttribute = toNonIndexedAttribute( indices, new Float32BufferAttribute( vertices, 3 ) );
 const normalAttribute = computeNormalAttribute( indices, vertices, creaseAngle );
const geometry = new BufferGeometry();
 geometry.setAttribute( 'position', positionAttribute );
 geometry.setAttribute( 'normal', normalAttribute );
 // no uvs yet
// "solid" influences the material so let's store it for later use
geometry._solid = solid;
 geometry._type = 'mesh';
return geometry;
}
// helper functions
function resolveUSE( identifier ) {
const node = nodeMap[ identifier ];
 const build = getNode( node );
// because the same 3D objects can have different transformations, it's necessary to clone them.
 // materials can be influenced by the geometry (e.g. vertex normals). cloning is necessary to avoid
 // any side effects
return ( build.isObject3D || build.isMaterial ) ? build.clone() : build;
}
function parseFieldChildren( children, owner ) {
for ( let i = 0, l = children.length; i < l; i ++ ) {
const object = getNode( children[ i ] );
if ( object instanceof Object3D ) owner.add( object );
}
}
function triangulateFaceIndex( index, ccw ) {
const indices = [];
// since face defintions can have more than three vertices, it's necessary to
 // perform a simple triangulation
let start = 0;
for ( let i = 0, l = index.length; i < l; i ++ ) {
const i1 = index[ start ];
 const i2 = index[ i + ( ccw ? 1 : 2 ) ];
 const i3 = index[ i + ( ccw ? 2 : 1 ) ];
indices.push( i1, i2, i3 );
// an index of -1 indicates that the current face has ended and the next one begins
if ( index[ i + 3 ] === - 1 || i + 3 >= l ) {
i += 3;
 start = i + 1;
}
}
return indices;
}
function triangulateFaceData( data, index ) {
const triangulatedData = [];
let start = 0;
for ( let i = 0, l = index.length; i < l; i ++ ) {
const stride = start * 3;
const x = data[ stride ];
 const y = data[ stride + 1 ];
 const z = data[ stride + 2 ];
triangulatedData.push( x, y, z );
// an index of -1 indicates that the current face has ended and the next one begins
if ( index[ i + 3 ] === - 1 || i + 3 >= l ) {
i += 3;
 start ++;
}
}
return triangulatedData;
}
function flattenData( data, index ) {
const flattenData = [];
for ( let i = 0, l = index.length; i < l; i ++ ) {
const i1 = index[ i ];
const stride = i1 * 3;
const x = data[ stride ];
 const y = data[ stride + 1 ];
 const z = data[ stride + 2 ];
flattenData.push( x, y, z );
}
return flattenData;
}
function expandLineIndex( index ) {
const indices = [];
for ( let i = 0, l = index.length; i < l; i ++ ) {
const i1 = index[ i ];
 const i2 = index[ i + 1 ];
indices.push( i1, i2 );
// an index of -1 indicates that the current line has ended and the next one begins
if ( index[ i + 2 ] === - 1 || i + 2 >= l ) {
i += 2;
}
}
return indices;
}
function expandLineData( data, index ) {
const triangulatedData = [];
let start = 0;
for ( let i = 0, l = index.length; i < l; i ++ ) {
const stride = start * 3;
const x = data[ stride ];
 const y = data[ stride + 1 ];
 const z = data[ stride + 2 ];
triangulatedData.push( x, y, z );
// an index of -1 indicates that the current line has ended and the next one begins
if ( index[ i + 2 ] === - 1 || i + 2 >= l ) {
i += 2;
 start ++;
}
}
return triangulatedData;
}
const vA = new Vector3();
 const vB = new Vector3();
 const vC = new Vector3();
const uvA = new Vector2();
 const uvB = new Vector2();
 const uvC = new Vector2();
function computeAttributeFromIndexedData( coordIndex, index, data, itemSize ) {
const array = [];
// we use the coordIndex.length as delimiter since normalIndex must contain at least as many indices
for ( let i = 0, l = coordIndex.length; i < l; i += 3 ) {
const a = index[ i ];
 const b = index[ i + 1 ];
 const c = index[ i + 2 ];
if ( itemSize === 2 ) {
uvA.fromArray( data, a * itemSize );
 uvB.fromArray( data, b * itemSize );
 uvC.fromArray( data, c * itemSize );
array.push( uvA.x, uvA.y );
 array.push( uvB.x, uvB.y );
 array.push( uvC.x, uvC.y );
} else {
vA.fromArray( data, a * itemSize );
 vB.fromArray( data, b * itemSize );
 vC.fromArray( data, c * itemSize );
array.push( vA.x, vA.y, vA.z );
 array.push( vB.x, vB.y, vB.z );
 array.push( vC.x, vC.y, vC.z );
}
}
return new Float32BufferAttribute( array, itemSize );
}
function computeAttributeFromFaceData( index, faceData ) {
const array = [];
for ( let i = 0, j = 0, l = index.length; i < l; i += 3, j ++ ) {
vA.fromArray( faceData, j * 3 );
array.push( vA.x, vA.y, vA.z );
 array.push( vA.x, vA.y, vA.z );
 array.push( vA.x, vA.y, vA.z );
}
return new Float32BufferAttribute( array, 3 );
}
function computeAttributeFromLineData( index, lineData ) {
const array = [];
for ( let i = 0, j = 0, l = index.length; i < l; i += 2, j ++ ) {
vA.fromArray( lineData, j * 3 );
array.push( vA.x, vA.y, vA.z );
 array.push( vA.x, vA.y, vA.z );
}
return new Float32BufferAttribute( array, 3 );
}
function toNonIndexedAttribute( indices, attribute ) {
const array = attribute.array;
 const itemSize = attribute.itemSize;
const array2 = new array.constructor( indices.length * itemSize );
let index = 0, index2 = 0;
for ( let i = 0, l = indices.length; i < l; i ++ ) {
index = indices[ i ] * itemSize;
for ( let j = 0; j < itemSize; j ++ ) {
array2[ index2 ++ ] = array[ index ++ ];
}
}
return new Float32BufferAttribute( array2, itemSize );
}
const ab = new Vector3();
 const cb = new Vector3();
function computeNormalAttribute( index, coord, creaseAngle ) {
const faces = [];
 const vertexNormals = {};
// prepare face and raw vertex normals
for ( let i = 0, l = index.length; i < l; i += 3 ) {
const a = index[ i ];
 const b = index[ i + 1 ];
 const c = index[ i + 2 ];
const face = new Face( a, b, c );
vA.fromArray( coord, a * 3 );
 vB.fromArray( coord, b * 3 );
 vC.fromArray( coord, c * 3 );
cb.subVectors( vC, vB );
 ab.subVectors( vA, vB );
 cb.cross( ab );
cb.normalize();
face.normal.copy( cb );
if ( vertexNormals[ a ] === undefined ) vertexNormals[ a ] = [];
 if ( vertexNormals[ b ] === undefined ) vertexNormals[ b ] = [];
 if ( vertexNormals[ c ] === undefined ) vertexNormals[ c ] = [];
vertexNormals[ a ].push( face.normal );
 vertexNormals[ b ].push( face.normal );
 vertexNormals[ c ].push( face.normal );
faces.push( face );
}
// compute vertex normals and build final geometry
const normals = [];
for ( let i = 0, l = faces.length; i < l; i ++ ) {
const face = faces[ i ];
const nA = weightedNormal( vertexNormals[ face.a ], face.normal, creaseAngle );
 const nB = weightedNormal( vertexNormals[ face.b ], face.normal, creaseAngle );
 const nC = weightedNormal( vertexNormals[ face.c ], face.normal, creaseAngle );
vA.fromArray( coord, face.a * 3 );
 vB.fromArray( coord, face.b * 3 );
 vC.fromArray( coord, face.c * 3 );
normals.push( nA.x, nA.y, nA.z );
 normals.push( nB.x, nB.y, nB.z );
 normals.push( nC.x, nC.y, nC.z );
}
return new Float32BufferAttribute( normals, 3 );
}
function weightedNormal( normals, vector, creaseAngle ) {
const normal = new Vector3();
if ( creaseAngle === 0 ) {
normal.copy( vector );
} else {
for ( let i = 0, l = normals.length; i < l; i ++ ) {
if ( normals[ i ].angleTo( vector ) < creaseAngle ) {
normal.add( normals[ i ] );
}
}
}
return normal.normalize();
}
function toColorArray( colors ) {
const array = [];
for ( let i = 0, l = colors.length; i < l; i += 3 ) {
array.push( new Color( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] ) );
}
return array;
}
function convertColorsToLinearSRGB( attribute ) {
const color = new Color();
for ( let i = 0; i < attribute.count; i ++ ) {
color.fromBufferAttribute( attribute, i );
 color.convertSRGBToLinear();
attribute.setXYZ( i, color.r, color.g, color.b );
}
}
/**
 * Vertically paints the faces interpolating between the
 * specified colors at the specified angels. This is used for the Background
 * node, but could be applied to other nodes with multiple faces as well.
 *
 * When used with the Background node, default is directionIsDown is true if
 * interpolating the skyColor down from the Zenith. When interpolationg up from
 * the Nadir i.e. interpolating the groundColor, the directionIsDown is false.
 *
 * The first angle is never specified, it is the Zenith (0 rad). Angles are specified
 * in radians. The geometry is thought a sphere, but could be anything. The color interpolation
 * is linear along the Y axis in any case.
 *
 * You must specify one more color than you have angles at the beginning of the colors array.
 * This is the color of the Zenith (the top of the shape).
 *
 * @param {BufferGeometry} geometry
 * @param {number} radius
 * @param {array} angles
 * @param {array} colors
 * @param {boolean} topDown - Whether to work top down or bottom up.
 */
 function paintFaces( geometry, radius, angles, colors, topDown ) {
// compute threshold values
const thresholds = [];
 const startAngle = ( topDown === true ) ? 0 : Math.PI;
for ( let i = 0, l = colors.length; i < l; i ++ ) {
let angle = ( i === 0 ) ? 0 : angles[ i - 1 ];
 angle = ( topDown === true ) ? angle : ( startAngle - angle );
const point = new Vector3();
 point.setFromSphericalCoords( radius, angle, 0 );
thresholds.push( point );
}
// generate vertex colors
const indices = geometry.index;
 const positionAttribute = geometry.attributes.position;
 const colorAttribute = new BufferAttribute( new Float32Array( geometry.attributes.position.count * 3 ), 3 );
const position = new Vector3();
 const color = new Color();
for ( let i = 0; i < indices.count; i ++ ) {
const index = indices.getX( i );
 position.fromBufferAttribute( positionAttribute, index );
let thresholdIndexA, thresholdIndexB;
 let t = 1;
for ( let j = 1; j < thresholds.length; j ++ ) {
thresholdIndexA = j - 1;
 thresholdIndexB = j;
const thresholdA = thresholds[ thresholdIndexA ];
 const thresholdB = thresholds[ thresholdIndexB ];
if ( topDown === true ) {
// interpolation for sky color
if ( position.y <= thresholdA.y && position.y > thresholdB.y ) {
t = Math.abs( thresholdA.y - position.y ) / Math.abs( thresholdA.y - thresholdB.y );
break;
}
} else {
// interpolation for ground color
if ( position.y >= thresholdA.y && position.y < thresholdB.y ) {
t = Math.abs( thresholdA.y - position.y ) / Math.abs( thresholdA.y - thresholdB.y );
break;
}
}
}
const colorA = colors[ thresholdIndexA ];
 const colorB = colors[ thresholdIndexB ];
color.copy( colorA ).lerp( colorB, t ).convertSRGBToLinear();
colorAttribute.setXYZ( index, color.r, color.g, color.b );
}
geometry.setAttribute( 'color', colorAttribute );
}
//
const textureLoader = new TextureLoader( this.manager );
 textureLoader.setPath( this.resourcePath || path ).setCrossOrigin( this.crossOrigin );
// check version (only 2.0 is supported)
if ( data.indexOf( '#VRML V2.0' ) === - 1 ) {
throw Error( 'THREE.VRMLLexer: Version of VRML asset not supported.' );
}
// create JSON representing the tree structure of the VRML asset
const tree = generateVRMLTree( data );
// parse the tree structure to a three.js scene
const scene = parseTree( tree );
return scene;
}
}
class VRMLLexer {
constructor( tokens ) {
this.lexer = new chevrotain.Lexer( tokens );
}
lex( inputText ) {
const lexingResult = this.lexer.tokenize( inputText );
if ( lexingResult.errors.length > 0 ) {
console.error( lexingResult.errors );
throw Error( 'THREE.VRMLLexer: Lexing errors detected.' );
}
return lexingResult;
}
}
const CstParser = chevrotain.CstParser;
class VRMLParser extends CstParser {
constructor( tokenVocabulary ) {
super( tokenVocabulary );
const $ = this;
const Version = tokenVocabulary[ 'Version' ];
 const LCurly = tokenVocabulary[ 'LCurly' ];
 const RCurly = tokenVocabulary[ 'RCurly' ];
 const LSquare = tokenVocabulary[ 'LSquare' ];
 const RSquare = tokenVocabulary[ 'RSquare' ];
 const Identifier = tokenVocabulary[ 'Identifier' ];
 const RouteIdentifier = tokenVocabulary[ 'RouteIdentifier' ];
 const StringLiteral = tokenVocabulary[ 'StringLiteral' ];
 const HexLiteral = tokenVocabulary[ 'HexLiteral' ];
 const NumberLiteral = tokenVocabulary[ 'NumberLiteral' ];
 const TrueLiteral = tokenVocabulary[ 'TrueLiteral' ];
 const FalseLiteral = tokenVocabulary[ 'FalseLiteral' ];
 const NullLiteral = tokenVocabulary[ 'NullLiteral' ];
 const DEF = tokenVocabulary[ 'DEF' ];
 const USE = tokenVocabulary[ 'USE' ];
 const ROUTE = tokenVocabulary[ 'ROUTE' ];
 const TO = tokenVocabulary[ 'TO' ];
 const NodeName = tokenVocabulary[ 'NodeName' ];
$.RULE( 'vrml', function () {
$.SUBRULE( $.version );
 $.AT_LEAST_ONE( function () {
$.SUBRULE( $.node );
} );
 $.MANY( function () {
$.SUBRULE( $.route );
} );
} );
$.RULE( 'version', function () {
$.CONSUME( Version );
} );
$.RULE( 'node', function () {
$.OPTION( function () {
$.SUBRULE( $.def );
} );
$.CONSUME( NodeName );
 $.CONSUME( LCurly );
 $.MANY( function () {
$.SUBRULE( $.field );
} );
 $.CONSUME( RCurly );
} );
$.RULE( 'field', function () {
$.CONSUME( Identifier );
$.OR2( [
 { ALT: function () {
$.SUBRULE( $.singleFieldValue );
} },
 { ALT: function () {
$.SUBRULE( $.multiFieldValue );
} }
 ] );
} );
$.RULE( 'def', function () {
$.CONSUME( DEF );
 $.OR( [
 { ALT: function () {
$.CONSUME( Identifier );
} },
 { ALT: function () {
$.CONSUME( NodeName );
} }
 ] );
} );
$.RULE( 'use', function () {
$.CONSUME( USE );
 $.OR( [
 { ALT: function () {
$.CONSUME( Identifier );
} },
 { ALT: function () {
$.CONSUME( NodeName );
} }
 ] );
} );
$.RULE( 'singleFieldValue', function () {
$.AT_LEAST_ONE( function () {
$.OR( [
 { ALT: function () {
$.SUBRULE( $.node );
} },
 { ALT: function () {
$.SUBRULE( $.use );
} },
 { ALT: function () {
$.CONSUME( StringLiteral );
} },
 { ALT: function () {
$.CONSUME( HexLiteral );
} },
 { ALT: function () {
$.CONSUME( NumberLiteral );
} },
 { ALT: function () {
$.CONSUME( TrueLiteral );
} },
 { ALT: function () {
$.CONSUME( FalseLiteral );
} },
 { ALT: function () {
$.CONSUME( NullLiteral );
} }
 ] );
} );
} );
$.RULE( 'multiFieldValue', function () {
$.CONSUME( LSquare );
 $.MANY( function () {
$.OR( [
 { ALT: function () {
$.SUBRULE( $.node );
} },
 { ALT: function () {
$.SUBRULE( $.use );
} },
 { ALT: function () {
$.CONSUME( StringLiteral );
} },
 { ALT: function () {
$.CONSUME( HexLiteral );
} },
 { ALT: function () {
$.CONSUME( NumberLiteral );
} },
 { ALT: function () {
$.CONSUME( NullLiteral );
} }
 ] );
} );
 $.CONSUME( RSquare );
} );
$.RULE( 'route', function () {
$.CONSUME( ROUTE );
 $.CONSUME( RouteIdentifier );
 $.CONSUME( TO );
 $.CONSUME2( RouteIdentifier );
} );
this.performSelfAnalysis();
}
}
class Face {
constructor( a, b, c ) {
this.a = a;
 this.b = b;
 this.c = c;
 this.normal = new Vector3();
}
}
const TEXTURE_TYPE = {
 INTENSITY: 1,
 INTENSITY_ALPHA: 2,
 RGB: 3,
 RGBA: 4
};
export { VRMLLoader };

Xet Storage Details

Size:
73.2 kB
·
Xet hash:
f3082d02312fc8213ec403bc7efc50c98958ef378fd406813ddef950be25f873

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.