Copy disabled (too large)
Download .txt
Showing preview only (35,315K chars total). Download the full file to get everything.
Repository: Itee/three-full
Branch: dev
Commit: 7061c7cd93f1
Files: 1252
Total size: 33.4 MB
Directory structure:
gitextract_80_q7e8j/
├── .gitignore
├── .npmignore
├── LICENSE.md
├── README.md
├── builds/
│ ├── Three.amd.js
│ ├── Three.cjs.js
│ ├── Three.es.js
│ ├── Three.iife.js
│ └── Three.umd.js
├── configs/
│ ├── es6.conf.js
│ ├── eslint.conf.js
│ ├── karma.units.conf.js
│ ├── rollup.conf.js
│ ├── rollup.tests.conf.js
│ └── units.conf.js
├── es6-convertor.js
├── gulpfile.js
├── package.json
├── sources/
│ ├── ImageUtils.d.ts
│ ├── PMREMGenerator.d.ts
│ ├── ShapeUtils.d.ts
│ ├── Three.d.ts
│ ├── Three.js
│ ├── WebGL.d.ts
│ ├── animation/
│ │ ├── AnimationAction.d.ts
│ │ ├── AnimationAction.js
│ │ ├── AnimationClip.d.ts
│ │ ├── AnimationClip.js
│ │ ├── AnimationClipCreator.d.ts
│ │ ├── AnimationClipCreator.js
│ │ ├── AnimationMixer.d.ts
│ │ ├── AnimationMixer.js
│ │ ├── AnimationObjectGroup.d.ts
│ │ ├── AnimationObjectGroup.js
│ │ ├── AnimationUtils.d.ts
│ │ ├── AnimationUtils.js
│ │ ├── CCDIKSolver.d.ts
│ │ ├── CCDIKSolver.js
│ │ ├── KeyframeTrack.d.ts
│ │ ├── KeyframeTrack.js
│ │ ├── MMDAnimationHelper.d.ts
│ │ ├── MMDAnimationHelper.js
│ │ ├── MMDPhysics.d.ts
│ │ ├── MMDPhysics.js
│ │ ├── PropertyBinding.d.ts
│ │ ├── PropertyBinding.js
│ │ ├── PropertyMixer.d.ts
│ │ ├── PropertyMixer.js
│ │ ├── TimelinerController.d.ts
│ │ ├── TimelinerController.js
│ │ └── tracks/
│ │ ├── BooleanKeyframeTrack.d.ts
│ │ ├── BooleanKeyframeTrack.js
│ │ ├── ColorKeyframeTrack.d.ts
│ │ ├── ColorKeyframeTrack.js
│ │ ├── NumberKeyframeTrack.d.ts
│ │ ├── NumberKeyframeTrack.js
│ │ ├── QuaternionKeyframeTrack.d.ts
│ │ ├── QuaternionKeyframeTrack.js
│ │ ├── StringKeyframeTrack.d.ts
│ │ ├── StringKeyframeTrack.js
│ │ ├── VectorKeyframeTrack.d.ts
│ │ └── VectorKeyframeTrack.js
│ ├── audio/
│ │ ├── Audio.d.ts
│ │ ├── Audio.js
│ │ ├── AudioAnalyser.d.ts
│ │ ├── AudioAnalyser.js
│ │ ├── AudioContext.d.ts
│ │ ├── AudioContext.js
│ │ ├── AudioListener.d.ts
│ │ ├── AudioListener.js
│ │ ├── PositionalAudio.d.ts
│ │ ├── PositionalAudio.js
│ │ └── VolumeSlice.js
│ ├── cameras/
│ │ ├── ArrayCamera.d.ts
│ │ ├── ArrayCamera.js
│ │ ├── Camera.d.ts
│ │ ├── Camera.js
│ │ ├── CinematicCamera.d.ts
│ │ ├── CinematicCamera.js
│ │ ├── CubeCamera.d.ts
│ │ ├── CubeCamera.js
│ │ ├── OrthographicCamera.d.ts
│ │ ├── OrthographicCamera.js
│ │ ├── PerspectiveCamera.d.ts
│ │ ├── PerspectiveCamera.js
│ │ ├── StereoCamera.d.ts
│ │ └── StereoCamera.js
│ ├── constants.d.ts
│ ├── constants.js
│ ├── controls/
│ │ ├── DeviceOrientationControls.d.ts
│ │ ├── DeviceOrientationControls.js
│ │ ├── DragControls.d.ts
│ │ ├── DragControls.js
│ │ ├── FirstPersonControls.d.ts
│ │ ├── FirstPersonControls.js
│ │ ├── FlyControls.d.ts
│ │ ├── FlyControls.js
│ │ ├── OrbitControls.d.ts
│ │ ├── OrbitControls.js
│ │ ├── PointerLockControls.d.ts
│ │ ├── PointerLockControls.js
│ │ ├── TrackballControls.d.ts
│ │ ├── TrackballControls.js
│ │ ├── TransformControls.d.ts
│ │ └── TransformControls.js
│ ├── core/
│ │ ├── BufferAttribute.d.ts
│ │ ├── BufferAttribute.js
│ │ ├── BufferGeometry.d.ts
│ │ ├── BufferGeometry.js
│ │ ├── Clock.d.ts
│ │ ├── Clock.js
│ │ ├── Curve.d.ts
│ │ ├── CurvePath.d.ts
│ │ ├── CurvePath.js
│ │ ├── DirectGeometry.d.ts
│ │ ├── DirectGeometry.js
│ │ ├── EventDispatcher.d.ts
│ │ ├── EventDispatcher.js
│ │ ├── Face3.d.ts
│ │ ├── Face3.js
│ │ ├── Font.d.ts
│ │ ├── Font.js
│ │ ├── Geometry.d.ts
│ │ ├── Geometry.js
│ │ ├── InstancedBufferAttribute.d.ts
│ │ ├── InstancedBufferAttribute.js
│ │ ├── InstancedBufferGeometry.d.ts
│ │ ├── InstancedBufferGeometry.js
│ │ ├── InstancedInterleavedBuffer.d.ts
│ │ ├── InstancedInterleavedBuffer.js
│ │ ├── InterleavedBuffer.d.ts
│ │ ├── InterleavedBuffer.js
│ │ ├── InterleavedBufferAttribute.d.ts
│ │ ├── InterleavedBufferAttribute.js
│ │ ├── Interpolations.d.ts
│ │ ├── Interpolations.js
│ │ ├── Layers.d.ts
│ │ ├── Layers.js
│ │ ├── Object3D.d.ts
│ │ ├── Object3D.js
│ │ ├── Path.d.ts
│ │ ├── Path.js
│ │ ├── Raycaster.d.ts
│ │ ├── Raycaster.js
│ │ ├── Shape.d.ts
│ │ ├── Shape.js
│ │ ├── ShapePath.d.ts
│ │ ├── ShapePath.js
│ │ ├── Uniform.d.ts
│ │ └── Uniform.js
│ ├── curves/
│ │ ├── ArcCurve.d.ts
│ │ ├── ArcCurve.js
│ │ ├── CatmullRomCurve3.d.ts
│ │ ├── CatmullRomCurve3.js
│ │ ├── CubicBezierCurve.d.ts
│ │ ├── CubicBezierCurve.js
│ │ ├── CubicBezierCurve3.d.ts
│ │ ├── CubicBezierCurve3.js
│ │ ├── Curve.js
│ │ ├── CurveExtras.d.ts
│ │ ├── CurveExtras.js
│ │ ├── Curves.d.ts
│ │ ├── EllipseCurve.d.ts
│ │ ├── EllipseCurve.js
│ │ ├── LineCurve.d.ts
│ │ ├── LineCurve.js
│ │ ├── LineCurve3.d.ts
│ │ ├── LineCurve3.js
│ │ ├── NURBSCurve.d.ts
│ │ ├── NURBSCurve.js
│ │ ├── NURBSSurface.d.ts
│ │ ├── NURBSSurface.js
│ │ ├── NURBSUtils.d.ts
│ │ ├── NURBSUtils.js
│ │ ├── QuadraticBezierCurve.d.ts
│ │ ├── QuadraticBezierCurve.js
│ │ ├── QuadraticBezierCurve3.d.ts
│ │ ├── QuadraticBezierCurve3.js
│ │ ├── SplineCurve.d.ts
│ │ └── SplineCurve.js
│ ├── effects/
│ │ ├── AnaglyphEffect.d.ts
│ │ ├── AnaglyphEffect.js
│ │ ├── AsciiEffect.d.ts
│ │ ├── AsciiEffect.js
│ │ ├── OutlineEffect.d.ts
│ │ ├── OutlineEffect.js
│ │ ├── ParallaxBarrierEffect.d.ts
│ │ ├── ParallaxBarrierEffect.js
│ │ ├── PeppersGhostEffect.d.ts
│ │ ├── PeppersGhostEffect.js
│ │ ├── StereoEffect.d.ts
│ │ └── StereoEffect.js
│ ├── exporters/
│ │ ├── ColladaExporter.d.ts
│ │ ├── ColladaExporter.js
│ │ ├── DRACOExporter.d.ts
│ │ ├── DracoExporter.js
│ │ ├── GLTFExporter.d.ts
│ │ ├── GLTFExporter.js
│ │ ├── MMDExporter.d.ts
│ │ ├── MMDExporter.js
│ │ ├── OBJExporter.d.ts
│ │ ├── OBJExporter.js
│ │ ├── PLYExporter.d.ts
│ │ ├── PLYExporter.js
│ │ ├── STLExporter.d.ts
│ │ ├── STLExporter.js
│ │ ├── TypedGeometryExporter.d.ts
│ │ └── TypedGeometryExporter.js
│ ├── fonts/
│ │ ├── LICENSE
│ │ ├── droid/
│ │ │ ├── NOTICE
│ │ │ ├── droid_sans_bold.typeface.json
│ │ │ ├── droid_sans_mono_regular.typeface.json
│ │ │ ├── droid_sans_regular.typeface.json
│ │ │ ├── droid_serif_bold.typeface.json
│ │ │ └── droid_serif_regular.typeface.json
│ │ ├── gentilis_bold.typeface.json
│ │ ├── gentilis_regular.typeface.json
│ │ ├── helvetiker_bold.typeface.json
│ │ ├── helvetiker_regular.typeface.json
│ │ ├── optimer_bold.typeface.json
│ │ └── optimer_regular.typeface.json
│ ├── geometries/
│ │ ├── BoxGeometry.d.ts
│ │ ├── BoxGeometry.js
│ │ ├── BoxLineGeometry.d.ts
│ │ ├── BoxLineGeometry.js
│ │ ├── CircleGeometry.d.ts
│ │ ├── CircleGeometry.js
│ │ ├── ConeGeometry.d.ts
│ │ ├── ConeGeometry.js
│ │ ├── ConvexGeometry.d.ts
│ │ ├── ConvexGeometry.js
│ │ ├── CylinderGeometry.d.ts
│ │ ├── CylinderGeometry.js
│ │ ├── DecalGeometry.d.ts
│ │ ├── DecalGeometry.js
│ │ ├── DodecahedronGeometry.d.ts
│ │ ├── DodecahedronGeometry.js
│ │ ├── EdgesGeometry.d.ts
│ │ ├── EdgesGeometry.js
│ │ ├── ExtrudeGeometry.d.ts
│ │ ├── ExtrudeGeometry.js
│ │ ├── Geometries.d.ts
│ │ ├── IcosahedronGeometry.d.ts
│ │ ├── IcosahedronGeometry.js
│ │ ├── LatheGeometry.d.ts
│ │ ├── LatheGeometry.js
│ │ ├── LightningStrike.d.ts
│ │ ├── LightningStrike.js
│ │ ├── OctahedronGeometry.d.ts
│ │ ├── OctahedronGeometry.js
│ │ ├── ParametricGeometries.d.ts
│ │ ├── ParametricGeometries.js
│ │ ├── ParametricGeometry.d.ts
│ │ ├── ParametricGeometry.js
│ │ ├── PlaneGeometry.d.ts
│ │ ├── PlaneGeometry.js
│ │ ├── PolyhedronGeometry.d.ts
│ │ ├── PolyhedronGeometry.js
│ │ ├── RingGeometry.d.ts
│ │ ├── RingGeometry.js
│ │ ├── ShapeGeometry.d.ts
│ │ ├── ShapeGeometry.js
│ │ ├── SphereGeometry.d.ts
│ │ ├── SphereGeometry.js
│ │ ├── TeapotBufferGeometry.d.ts
│ │ ├── TeapotBufferGeometry.js
│ │ ├── TetrahedronGeometry.d.ts
│ │ ├── TetrahedronGeometry.js
│ │ ├── TextGeometry.d.ts
│ │ ├── TextGeometry.js
│ │ ├── TorusGeometry.d.ts
│ │ ├── TorusGeometry.js
│ │ ├── TorusKnotGeometry.d.ts
│ │ ├── TorusKnotGeometry.js
│ │ ├── TubeGeometry.d.ts
│ │ ├── TubeGeometry.js
│ │ ├── WireframeGeometry.d.ts
│ │ └── WireframeGeometry.js
│ ├── helpers/
│ │ ├── ArrowHelper.d.ts
│ │ ├── ArrowHelper.js
│ │ ├── AxesHelper.d.ts
│ │ ├── AxesHelper.js
│ │ ├── Box3Helper.d.ts
│ │ ├── Box3Helper.js
│ │ ├── BoxHelper.d.ts
│ │ ├── BoxHelper.js
│ │ ├── CameraHelper.d.ts
│ │ ├── CameraHelper.js
│ │ ├── DirectionalLightHelper.d.ts
│ │ ├── DirectionalLightHelper.js
│ │ ├── FaceNormalsHelper.d.ts
│ │ ├── FaceNormalsHelper.js
│ │ ├── GridHelper.d.ts
│ │ ├── GridHelper.js
│ │ ├── HemisphereLightHelper.d.ts
│ │ ├── HemisphereLightHelper.js
│ │ ├── LightProbeHelper.d.ts
│ │ ├── LightProbeHelper.js
│ │ ├── PlaneHelper.d.ts
│ │ ├── PlaneHelper.js
│ │ ├── PointLightHelper.d.ts
│ │ ├── PointLightHelper.js
│ │ ├── PolarGridHelper.d.ts
│ │ ├── PolarGridHelper.js
│ │ ├── PositionalAudioHelper.d.ts
│ │ ├── PositionalAudioHelper.js
│ │ ├── RectAreaLightHelper.d.ts
│ │ ├── RectAreaLightHelper.js
│ │ ├── SkeletonHelper.d.ts
│ │ ├── SkeletonHelper.js
│ │ ├── SpotLightHelper.d.ts
│ │ ├── SpotLightHelper.js
│ │ ├── VertexNormalsHelper.d.ts
│ │ ├── VertexNormalsHelper.js
│ │ ├── VertexTangentsHelper.d.ts
│ │ ├── VertexTangentsHelper.js
│ │ └── WebGL.js
│ ├── interactive/
│ │ ├── SelectionBox.d.ts
│ │ ├── SelectionBox.js
│ │ ├── SelectionHelper.d.ts
│ │ └── SelectionHelper.js
│ ├── libs/
│ │ ├── ammo.js
│ │ ├── basis/
│ │ │ ├── README.md
│ │ │ ├── basis_transcoder.js
│ │ │ └── basis_transcoder.wasm
│ │ ├── dat.gui.module.js
│ │ ├── draco/
│ │ │ ├── README.md
│ │ │ ├── draco_decoder.js
│ │ │ ├── draco_decoder.wasm
│ │ │ ├── draco_encoder.js
│ │ │ ├── draco_wasm_wrapper.js
│ │ │ └── gltf/
│ │ │ ├── draco_decoder.js
│ │ │ ├── draco_decoder.wasm
│ │ │ ├── draco_encoder.js
│ │ │ └── draco_wasm_wrapper.js
│ │ ├── mmdparser.module.js
│ │ ├── motion-controllers.module.js
│ │ └── stats.module.js
│ ├── lights/
│ │ ├── AmbientLight.d.ts
│ │ ├── AmbientLight.js
│ │ ├── AmbientLightProbe.d.ts
│ │ ├── AmbientLightProbe.js
│ │ ├── DirectionalLight.d.ts
│ │ ├── DirectionalLight.js
│ │ ├── DirectionalLightShadow.d.ts
│ │ ├── DirectionalLightShadow.js
│ │ ├── HemisphereLight.d.ts
│ │ ├── HemisphereLight.js
│ │ ├── HemisphereLightProbe.d.ts
│ │ ├── HemisphereLightProbe.js
│ │ ├── Light.d.ts
│ │ ├── Light.js
│ │ ├── LightProbe.d.ts
│ │ ├── LightProbe.js
│ │ ├── LightProbeGenerator.d.ts
│ │ ├── LightProbeGenerator.js
│ │ ├── LightShadow.d.ts
│ │ ├── LightShadow.js
│ │ ├── PointLight.d.ts
│ │ ├── PointLight.js
│ │ ├── PointLightShadow.d.ts
│ │ ├── PointLightShadow.js
│ │ ├── RectAreaLight.d.ts
│ │ ├── RectAreaLight.js
│ │ ├── RectAreaLightUniformsLib.d.ts
│ │ ├── RectAreaLightUniformsLib.js
│ │ ├── SpotLight.d.ts
│ │ ├── SpotLight.js
│ │ ├── SpotLightShadow.d.ts
│ │ └── SpotLightShadow.js
│ ├── lines/
│ │ ├── Line2.d.ts
│ │ ├── Line2.js
│ │ ├── LineGeometry.d.ts
│ │ ├── LineGeometry.js
│ │ ├── LineMaterial.d.ts
│ │ ├── LineMaterial.js
│ │ ├── LineSegments2.d.ts
│ │ ├── LineSegments2.js
│ │ ├── LineSegmentsGeometry.d.ts
│ │ ├── LineSegmentsGeometry.js
│ │ ├── Wireframe.d.ts
│ │ ├── Wireframe.js
│ │ ├── WireframeGeometry2.d.ts
│ │ └── WireframeGeometry2.js
│ ├── loaders/
│ │ ├── 3MFLoader.d.ts
│ │ ├── 3MFLoader.js
│ │ ├── AMFLoader.d.ts
│ │ ├── AMFLoader.js
│ │ ├── AWDLoader.d.ts
│ │ ├── AWDLoader.js
│ │ ├── AnimationLoader.d.ts
│ │ ├── AnimationLoader.js
│ │ ├── AssimpLoader.d.ts
│ │ ├── AssimpLoader.js
│ │ ├── AudioLoader.d.ts
│ │ ├── AudioLoader.js
│ │ ├── BVHLoader.d.ts
│ │ ├── BVHLoader.js
│ │ ├── BasisTextureLoader.d.ts
│ │ ├── BasisTextureLoader.js
│ │ ├── BufferGeometryLoader.d.ts
│ │ ├── BufferGeometryLoader.js
│ │ ├── Cache.d.ts
│ │ ├── Cache.js
│ │ ├── ColladaLoader.d.ts
│ │ ├── ColladaLoader.js
│ │ ├── CompressedTextureLoader.d.ts
│ │ ├── CompressedTextureLoader.js
│ │ ├── CubeTextureLoader.d.ts
│ │ ├── CubeTextureLoader.js
│ │ ├── DDSLoader.d.ts
│ │ ├── DDSLoader.js
│ │ ├── DRACOLoader.d.ts
│ │ ├── DRACOLoader.js
│ │ ├── DataTextureLoader.d.ts
│ │ ├── DataTextureLoader.js
│ │ ├── EXRLoader.d.ts
│ │ ├── EXRLoader.js
│ │ ├── FBXLoader.d.ts
│ │ ├── FBXLoader.js
│ │ ├── FileLoader.d.ts
│ │ ├── FileLoader.js
│ │ ├── FontLoader.d.ts
│ │ ├── FontLoader.js
│ │ ├── GCodeLoader.d.ts
│ │ ├── GCodeLoader.js
│ │ ├── GLTFLoader.d.ts
│ │ ├── GLTFLoader.js
│ │ ├── HDRCubeTextureLoader.d.ts
│ │ ├── HDRCubeTextureLoader.js
│ │ ├── ImageBitmapLoader.d.ts
│ │ ├── ImageBitmapLoader.js
│ │ ├── ImageLoader.d.ts
│ │ ├── ImageLoader.js
│ │ ├── KMZLoader.d.ts
│ │ ├── KMZLoader.js
│ │ ├── KTXLoader.d.ts
│ │ ├── KTXLoader.js
│ │ ├── LDrawLoader.d.ts
│ │ ├── LDrawLoader.js
│ │ ├── LWOLoader.d.ts
│ │ ├── LWOLoader.js
│ │ ├── Loader.d.ts
│ │ ├── Loader.js
│ │ ├── LoaderUtils.d.ts
│ │ ├── LoaderUtils.js
│ │ ├── LoadingManager.d.ts
│ │ ├── LoadingManager.js
│ │ ├── MD2Loader.d.ts
│ │ ├── MD2Loader.js
│ │ ├── MMDLoader.d.ts
│ │ ├── MMDLoader.js
│ │ ├── MTLLoader.d.ts
│ │ ├── MTLLoader.js
│ │ ├── MaterialLoader.d.ts
│ │ ├── MaterialLoader.js
│ │ ├── NRRDLoader.d.ts
│ │ ├── NRRDLoader.js
│ │ ├── NodeMaterialLoader.js
│ │ ├── OBJLoader.d.ts
│ │ ├── OBJLoader.js
│ │ ├── OBJLoader2.d.ts
│ │ ├── OBJLoader2.js
│ │ ├── OBJLoader2Parallel.d.ts
│ │ ├── OBJLoader2Parallel.js
│ │ ├── ObjectLoader.d.ts
│ │ ├── ObjectLoader.js
│ │ ├── PCDLoader.d.ts
│ │ ├── PCDLoader.js
│ │ ├── PDBLoader.d.ts
│ │ ├── PDBLoader.js
│ │ ├── PLYLoader.d.ts
│ │ ├── PLYLoader.js
│ │ ├── PRWMLoader.d.ts
│ │ ├── PRWMLoader.js
│ │ ├── PVRLoader.d.ts
│ │ ├── PVRLoader.js
│ │ ├── RGBELoader.d.ts
│ │ ├── RGBELoader.js
│ │ ├── STLLoader.d.ts
│ │ ├── STLLoader.js
│ │ ├── SVGLoader.d.ts
│ │ ├── SVGLoader.js
│ │ ├── TDSLoader.d.ts
│ │ ├── TDSLoader.js
│ │ ├── TGALoader.d.ts
│ │ ├── TGALoader.js
│ │ ├── TTFLoader.d.ts
│ │ ├── TTFLoader.js
│ │ ├── TextureLoader.d.ts
│ │ ├── TextureLoader.js
│ │ ├── VRMLoader.d.ts
│ │ ├── VRMLoader.js
│ │ ├── VTKLoader.d.ts
│ │ ├── VTKLoader.js
│ │ ├── XLoader.d.ts
│ │ ├── XLoader.js
│ │ └── obj2/
│ │ ├── bridge/
│ │ │ ├── MtlObjBridge.d.ts
│ │ │ └── MtlObjBridge.js
│ │ ├── shared/
│ │ │ ├── MaterialHandler.d.ts
│ │ │ ├── MaterialHandler.js
│ │ │ ├── MeshReceiver.d.ts
│ │ │ └── MeshReceiver.js
│ │ ├── utils/
│ │ │ ├── CodeSerializer.d.ts
│ │ │ └── CodeSerializer.js
│ │ └── worker/
│ │ ├── main/
│ │ │ ├── WorkerExecutionSupport.d.ts
│ │ │ └── WorkerExecutionSupport.js
│ │ └── parallel/
│ │ ├── OBJLoader2Parser.d.ts
│ │ ├── OBJLoader2Parser.js
│ │ ├── WorkerRunner.d.ts
│ │ ├── WorkerRunner.js
│ │ └── jsm/
│ │ └── OBJLoader2Worker.js
│ ├── materials/
│ │ ├── LineBasicMaterial.d.ts
│ │ ├── LineBasicMaterial.js
│ │ ├── LineDashedMaterial.d.ts
│ │ ├── LineDashedMaterial.js
│ │ ├── Material.d.ts
│ │ ├── Material.js
│ │ ├── Materials.d.ts
│ │ ├── MeshBasicMaterial.d.ts
│ │ ├── MeshBasicMaterial.js
│ │ ├── MeshDepthMaterial.d.ts
│ │ ├── MeshDepthMaterial.js
│ │ ├── MeshDistanceMaterial.d.ts
│ │ ├── MeshDistanceMaterial.js
│ │ ├── MeshLambertMaterial.d.ts
│ │ ├── MeshLambertMaterial.js
│ │ ├── MeshMatcapMaterial.d.ts
│ │ ├── MeshMatcapMaterial.js
│ │ ├── MeshNormalMaterial.d.ts
│ │ ├── MeshNormalMaterial.js
│ │ ├── MeshPhongMaterial.d.ts
│ │ ├── MeshPhongMaterial.js
│ │ ├── MeshPhysicalMaterial.d.ts
│ │ ├── MeshPhysicalMaterial.js
│ │ ├── MeshStandardMaterial.d.ts
│ │ ├── MeshStandardMaterial.js
│ │ ├── MeshToonMaterial.d.ts
│ │ ├── MeshToonMaterial.js
│ │ ├── PointsMaterial.d.ts
│ │ ├── PointsMaterial.js
│ │ ├── RawShaderMaterial.d.ts
│ │ ├── RawShaderMaterial.js
│ │ ├── ShaderMaterial.d.ts
│ │ ├── ShaderMaterial.js
│ │ ├── ShadowMaterial.d.ts
│ │ ├── ShadowMaterial.js
│ │ ├── SpriteMaterial.d.ts
│ │ └── SpriteMaterial.js
│ ├── math/
│ │ ├── Box2.d.ts
│ │ ├── Box2.js
│ │ ├── Box3.d.ts
│ │ ├── Box3.js
│ │ ├── Color.d.ts
│ │ ├── Color.js
│ │ ├── ColorConverter.d.ts
│ │ ├── ColorConverter.js
│ │ ├── ConvexHull.d.ts
│ │ ├── ConvexHull.js
│ │ ├── Cylindrical.d.ts
│ │ ├── Cylindrical.js
│ │ ├── Euler.d.ts
│ │ ├── Euler.js
│ │ ├── Frustum.d.ts
│ │ ├── Frustum.js
│ │ ├── ImprovedNoise.d.ts
│ │ ├── ImprovedNoise.js
│ │ ├── Interpolant.d.ts
│ │ ├── Interpolant.js
│ │ ├── Line3.d.ts
│ │ ├── Line3.js
│ │ ├── Lut.d.ts
│ │ ├── Lut.js
│ │ ├── MathUtils.d.ts
│ │ ├── MathUtils.js
│ │ ├── Matrix3.d.ts
│ │ ├── Matrix3.js
│ │ ├── Matrix4.d.ts
│ │ ├── Matrix4.js
│ │ ├── MeshSurfaceSampler.d.ts
│ │ ├── MeshSurfaceSampler.js
│ │ ├── Plane.d.ts
│ │ ├── Plane.js
│ │ ├── Quaternion.d.ts
│ │ ├── Quaternion.js
│ │ ├── Ray.d.ts
│ │ ├── Ray.js
│ │ ├── SimplexNoise.d.ts
│ │ ├── SimplexNoise.js
│ │ ├── Sphere.d.ts
│ │ ├── Sphere.js
│ │ ├── Spherical.d.ts
│ │ ├── Spherical.js
│ │ ├── SphericalHarmonics3.d.ts
│ │ ├── SphericalHarmonics3.js
│ │ ├── Triangle.d.ts
│ │ ├── Triangle.js
│ │ ├── Vector2.d.ts
│ │ ├── Vector2.js
│ │ ├── Vector3.d.ts
│ │ ├── Vector3.js
│ │ ├── Vector4.d.ts
│ │ ├── Vector4.js
│ │ └── interpolants/
│ │ ├── CubicInterpolant.d.ts
│ │ ├── CubicInterpolant.js
│ │ ├── DiscreteInterpolant.d.ts
│ │ ├── DiscreteInterpolant.js
│ │ ├── LinearInterpolant.d.ts
│ │ ├── LinearInterpolant.js
│ │ ├── QuaternionLinearInterpolant.d.ts
│ │ └── QuaternionLinearInterpolant.js
│ ├── misc/
│ │ ├── ConvexObjectBreaker.d.ts
│ │ ├── Earcut.js
│ │ ├── GPUComputationRenderer.d.ts
│ │ ├── Gyroscope.d.ts
│ │ ├── MD2Character.d.ts
│ │ ├── MD2CharacterComplex.d.ts
│ │ ├── MorphAnimMesh.d.ts
│ │ ├── MorphBlendMesh.d.ts
│ │ ├── Ocean.d.ts
│ │ ├── RollerCoaster.d.ts
│ │ ├── TubePainter.d.ts
│ │ ├── TubePainter.js
│ │ ├── Volume.d.ts
│ │ ├── Volume.js
│ │ └── VolumeSlice.d.ts
│ ├── modifiers/
│ │ ├── ConvexObjectBreaker.js
│ │ ├── ExplodeModifier.d.ts
│ │ ├── ExplodeModifier.js
│ │ ├── SimplifyModifier.d.ts
│ │ ├── SimplifyModifier.js
│ │ ├── SubdivisionModifier.d.ts
│ │ ├── SubdivisionModifier.js
│ │ ├── TessellateModifier.d.ts
│ │ └── TessellateModifier.js
│ ├── nodes/
│ │ ├── Nodes.d.ts
│ │ ├── accessors/
│ │ │ ├── CameraNode.d.ts
│ │ │ ├── CameraNode.js
│ │ │ ├── ColorsNode.d.ts
│ │ │ ├── ColorsNode.js
│ │ │ ├── LightNode.d.ts
│ │ │ ├── LightNode.js
│ │ │ ├── NormalNode.d.ts
│ │ │ ├── NormalNode.js
│ │ │ ├── PositionNode.d.ts
│ │ │ ├── PositionNode.js
│ │ │ ├── ReflectNode.d.ts
│ │ │ ├── ReflectNode.js
│ │ │ ├── ResolutionNode.d.ts
│ │ │ ├── ResolutionNode.js
│ │ │ ├── ScreenUVNode.d.ts
│ │ │ ├── ScreenUVNode.js
│ │ │ ├── UVNode.d.ts
│ │ │ └── UVNode.js
│ │ ├── core/
│ │ │ ├── AttributeNode.d.ts
│ │ │ ├── AttributeNode.js
│ │ │ ├── ConstNode.d.ts
│ │ │ ├── ConstNode.js
│ │ │ ├── ExpressionNode.d.ts
│ │ │ ├── ExpressionNode.js
│ │ │ ├── FunctionCallNode.d.ts
│ │ │ ├── FunctionCallNode.js
│ │ │ ├── FunctionNode.d.ts
│ │ │ ├── FunctionNode.js
│ │ │ ├── InputNode.d.ts
│ │ │ ├── InputNode.js
│ │ │ ├── Node.d.ts
│ │ │ ├── Node.js
│ │ │ ├── NodeBuilder.d.ts
│ │ │ ├── NodeBuilder.js
│ │ │ ├── NodeFrame.d.ts
│ │ │ ├── NodeFrame.js
│ │ │ ├── NodeLib.d.ts
│ │ │ ├── NodeLib.js
│ │ │ ├── NodeUniform.d.ts
│ │ │ ├── NodeUniform.js
│ │ │ ├── NodeUtils.d.ts
│ │ │ ├── NodeUtils.js
│ │ │ ├── StructNode.d.ts
│ │ │ ├── StructNode.js
│ │ │ ├── TempNode.d.ts
│ │ │ ├── TempNode.js
│ │ │ ├── VarNode.d.ts
│ │ │ └── VarNode.js
│ │ ├── effects/
│ │ │ ├── BlurNode.d.ts
│ │ │ ├── BlurNode.js
│ │ │ ├── ColorAdjustmentNode.d.ts
│ │ │ ├── ColorAdjustmentNode.js
│ │ │ ├── LuminanceNode.d.ts
│ │ │ └── LuminanceNode.js
│ │ ├── inputs/
│ │ │ ├── BoolNode.d.ts
│ │ │ ├── BoolNode.js
│ │ │ ├── ColorNode.d.ts
│ │ │ ├── ColorNode.js
│ │ │ ├── CubeTextureNode.d.ts
│ │ │ ├── CubeTextureNode.js
│ │ │ ├── FloatNode.d.ts
│ │ │ ├── FloatNode.js
│ │ │ ├── IntNode.d.ts
│ │ │ ├── IntNode.js
│ │ │ ├── Matrix3Node.d.ts
│ │ │ ├── Matrix3Node.js
│ │ │ ├── Matrix4Node.d.ts
│ │ │ ├── Matrix4Node.js
│ │ │ ├── PropertyNode.d.ts
│ │ │ ├── PropertyNode.js
│ │ │ ├── RTTNode.d.ts
│ │ │ ├── RTTNode.js
│ │ │ ├── ReflectorNode.d.ts
│ │ │ ├── ReflectorNode.js
│ │ │ ├── ScreenNode.d.ts
│ │ │ ├── ScreenNode.js
│ │ │ ├── TextureNode.d.ts
│ │ │ ├── TextureNode.js
│ │ │ ├── Vector2Node.d.ts
│ │ │ ├── Vector2Node.js
│ │ │ ├── Vector3Node.d.ts
│ │ │ ├── Vector3Node.js
│ │ │ ├── Vector4Node.d.ts
│ │ │ └── Vector4Node.js
│ │ ├── materials/
│ │ │ ├── MeshStandardNodeMaterial.d.ts
│ │ │ ├── MeshStandardNodeMaterial.js
│ │ │ ├── NodeMaterial.d.ts
│ │ │ ├── NodeMaterial.js
│ │ │ ├── PhongNodeMaterial.d.ts
│ │ │ ├── PhongNodeMaterial.js
│ │ │ ├── SpriteNodeMaterial.d.ts
│ │ │ ├── SpriteNodeMaterial.js
│ │ │ ├── StandardNodeMaterial.d.ts
│ │ │ ├── StandardNodeMaterial.js
│ │ │ └── nodes/
│ │ │ ├── MeshStandardNode.d.ts
│ │ │ ├── MeshStandardNode.js
│ │ │ ├── PhongNode.d.ts
│ │ │ ├── PhongNode.js
│ │ │ ├── RawNode.d.ts
│ │ │ ├── RawNode.js
│ │ │ ├── SpriteNode.d.ts
│ │ │ ├── SpriteNode.js
│ │ │ ├── StandardNode.d.ts
│ │ │ └── StandardNode.js
│ │ ├── math/
│ │ │ ├── CondNode.d.ts
│ │ │ ├── CondNode.js
│ │ │ ├── MathNode.d.ts
│ │ │ ├── MathNode.js
│ │ │ ├── OperatorNode.d.ts
│ │ │ └── OperatorNode.js
│ │ ├── misc/
│ │ │ ├── BumpMapNode.d.ts
│ │ │ ├── BumpMapNode.js
│ │ │ ├── NormalMapNode.d.ts
│ │ │ ├── NormalMapNode.js
│ │ │ ├── TextureCubeNode.d.ts
│ │ │ ├── TextureCubeNode.js
│ │ │ ├── TextureCubeUVNode.d.ts
│ │ │ └── TextureCubeUVNode.js
│ │ ├── postprocessing/
│ │ │ ├── NodePass.d.ts
│ │ │ ├── NodePass.js
│ │ │ ├── NodePostProcessing.d.ts
│ │ │ └── NodePostProcessing.js
│ │ ├── procedural/
│ │ │ ├── CheckerNode.d.ts
│ │ │ ├── CheckerNode.js
│ │ │ ├── NoiseNode.d.ts
│ │ │ └── NoiseNode.js
│ │ └── utils/
│ │ ├── BypassNode.d.ts
│ │ ├── BypassNode.js
│ │ ├── ColorSpaceNode.d.ts
│ │ ├── ColorSpaceNode.js
│ │ ├── JoinNode.d.ts
│ │ ├── JoinNode.js
│ │ ├── MaxMIPLevelNode.d.ts
│ │ ├── MaxMIPLevelNode.js
│ │ ├── SpecularMIPLevelNode.d.ts
│ │ ├── SpecularMIPLevelNode.js
│ │ ├── SubSlot.d.ts
│ │ ├── SubSlotNode.js
│ │ ├── SwitchNode.d.ts
│ │ ├── SwitchNode.js
│ │ ├── TimerNode.d.ts
│ │ ├── TimerNode.js
│ │ ├── UVTransformNode.d.ts
│ │ ├── UVTransformNode.js
│ │ ├── VelocityNode.d.ts
│ │ └── VelocityNode.js
│ ├── objects/
│ │ ├── Bone.d.ts
│ │ ├── Bone.js
│ │ ├── Fire.d.ts
│ │ ├── Fire.js
│ │ ├── Group.d.ts
│ │ ├── Group.js
│ │ ├── Gyroscope.js
│ │ ├── ImmediateRenderObject.d.ts
│ │ ├── ImmediateRenderObject.js
│ │ ├── InstancedMesh.d.ts
│ │ ├── InstancedMesh.js
│ │ ├── LOD.d.ts
│ │ ├── LOD.js
│ │ ├── Lensflare.d.ts
│ │ ├── Lensflare.js
│ │ ├── LightningStorm.d.ts
│ │ ├── LightningStorm.js
│ │ ├── Line.d.ts
│ │ ├── Line.js
│ │ ├── LineLoop.d.ts
│ │ ├── LineLoop.js
│ │ ├── LineSegments.d.ts
│ │ ├── LineSegments.js
│ │ ├── MD2Character.js
│ │ ├── MD2CharacterComplex.js
│ │ ├── MarchingCubes.d.ts
│ │ ├── MarchingCubes.js
│ │ ├── Mesh.d.ts
│ │ ├── Mesh.js
│ │ ├── MorphAnimMesh.js
│ │ ├── MorphBlendMesh.js
│ │ ├── Ocean.js
│ │ ├── Points.d.ts
│ │ ├── Points.js
│ │ ├── Reflector.d.ts
│ │ ├── Reflector.js
│ │ ├── ReflectorRTT.d.ts
│ │ ├── ReflectorRTT.js
│ │ ├── Refractor.d.ts
│ │ ├── Refractor.js
│ │ ├── RollerCoaster.js
│ │ ├── ShadowMesh.d.ts
│ │ ├── ShadowMesh.js
│ │ ├── Skeleton.d.ts
│ │ ├── Skeleton.js
│ │ ├── SkinnedMesh.d.ts
│ │ ├── SkinnedMesh.js
│ │ ├── Sky.d.ts
│ │ ├── Sky.js
│ │ ├── Sprite.d.ts
│ │ ├── Sprite.js
│ │ ├── Water.d.ts
│ │ ├── Water.js
│ │ ├── Water2.d.ts
│ │ └── Water2.js
│ ├── polyfills.d.ts
│ ├── polyfills.js
│ ├── postprocessing/
│ │ ├── AdaptiveToneMappingPass.d.ts
│ │ ├── AdaptiveToneMappingPass.js
│ │ ├── AfterimagePass.d.ts
│ │ ├── AfterimagePass.js
│ │ ├── BloomPass.d.ts
│ │ ├── BloomPass.js
│ │ ├── BokehPass.d.ts
│ │ ├── BokehPass.js
│ │ ├── ClearPass.d.ts
│ │ ├── ClearPass.js
│ │ ├── CubeTexturePass.d.ts
│ │ ├── CubeTexturePass.js
│ │ ├── DotScreenPass.d.ts
│ │ ├── DotScreenPass.js
│ │ ├── EffectComposer.d.ts
│ │ ├── EffectComposer.js
│ │ ├── FilmPass.d.ts
│ │ ├── FilmPass.js
│ │ ├── GlitchPass.d.ts
│ │ ├── GlitchPass.js
│ │ ├── HalftonePass.d.ts
│ │ ├── HalftonePass.js
│ │ ├── MaskPass.d.ts
│ │ ├── MaskPass.js
│ │ ├── OutlinePass.d.ts
│ │ ├── OutlinePass.js
│ │ ├── Pass.d.ts
│ │ ├── Pass.js
│ │ ├── RenderPass.d.ts
│ │ ├── RenderPass.js
│ │ ├── SAOPass.d.ts
│ │ ├── SAOPass.js
│ │ ├── SMAAPass.d.ts
│ │ ├── SMAAPass.js
│ │ ├── SSAARenderPass.d.ts
│ │ ├── SSAARenderPass.js
│ │ ├── SSAOPass.d.ts
│ │ ├── SSAOPass.js
│ │ ├── SavePass.d.ts
│ │ ├── SavePass.js
│ │ ├── ShaderPass.d.ts
│ │ ├── ShaderPass.js
│ │ ├── TAARenderPass.d.ts
│ │ ├── TAARenderPass.js
│ │ ├── TexturePass.d.ts
│ │ ├── TexturePass.js
│ │ ├── UnrealBloomPass.d.ts
│ │ └── UnrealBloomPass.js
│ ├── renderers/
│ │ ├── CSS2DRenderer.d.ts
│ │ ├── CSS2DRenderer.js
│ │ ├── CSS3DRenderer.d.ts
│ │ ├── CSS3DRenderer.js
│ │ ├── GPUComputationRenderer.js
│ │ ├── Projector.d.ts
│ │ ├── Projector.js
│ │ ├── SVGRenderer.d.ts
│ │ ├── SVGRenderer.js
│ │ ├── WebGLCubeRenderTarget.d.ts
│ │ ├── WebGLCubeRenderTarget.js
│ │ ├── WebGLMultisampleRenderTarget.d.ts
│ │ ├── WebGLMultisampleRenderTarget.js
│ │ ├── WebGLMultiviewRenderTarget.d.ts
│ │ ├── WebGLMultiviewRenderTarget.js
│ │ ├── WebGLRenderTarget.d.ts
│ │ ├── WebGLRenderTarget.js
│ │ ├── WebGLRenderer.d.ts
│ │ ├── WebGLRenderer.js
│ │ ├── shaders/
│ │ │ ├── ShaderChunk/
│ │ │ │ ├── alphamap_fragment.glsl.js
│ │ │ │ ├── alphamap_pars_fragment.glsl.js
│ │ │ │ ├── alphatest_fragment.glsl.js
│ │ │ │ ├── aomap_fragment.glsl.js
│ │ │ │ ├── aomap_pars_fragment.glsl.js
│ │ │ │ ├── begin_vertex.glsl.js
│ │ │ │ ├── beginnormal_vertex.glsl.js
│ │ │ │ ├── bsdfs.glsl.js
│ │ │ │ ├── bumpmap_pars_fragment.glsl.js
│ │ │ │ ├── clearcoat_normal_fragment_begin.glsl.js
│ │ │ │ ├── clearcoat_normal_fragment_maps.glsl.js
│ │ │ │ ├── clearcoat_normalmap_pars_fragment.glsl.js
│ │ │ │ ├── clipping_planes_fragment.glsl.js
│ │ │ │ ├── clipping_planes_pars_fragment.glsl.js
│ │ │ │ ├── clipping_planes_pars_vertex.glsl.js
│ │ │ │ ├── clipping_planes_vertex.glsl.js
│ │ │ │ ├── color_fragment.glsl.js
│ │ │ │ ├── color_pars_fragment.glsl.js
│ │ │ │ ├── color_pars_vertex.glsl.js
│ │ │ │ ├── color_vertex.glsl.js
│ │ │ │ ├── common.glsl.js
│ │ │ │ ├── cube_uv_reflection_fragment.glsl.js
│ │ │ │ ├── default_fragment.glsl.js
│ │ │ │ ├── default_vertex.glsl.js
│ │ │ │ ├── defaultnormal_vertex.glsl.js
│ │ │ │ ├── displacementmap_pars_vertex.glsl.js
│ │ │ │ ├── displacementmap_vertex.glsl.js
│ │ │ │ ├── dithering_fragment.glsl.js
│ │ │ │ ├── dithering_pars_fragment.glsl.js
│ │ │ │ ├── emissivemap_fragment.glsl.js
│ │ │ │ ├── emissivemap_pars_fragment.glsl.js
│ │ │ │ ├── encodings_fragment.glsl.js
│ │ │ │ ├── encodings_pars_fragment.glsl.js
│ │ │ │ ├── envmap_common_pars_fragment.glsl.js
│ │ │ │ ├── envmap_fragment.glsl.js
│ │ │ │ ├── envmap_pars_fragment.glsl.js
│ │ │ │ ├── envmap_pars_vertex.glsl.js
│ │ │ │ ├── envmap_physical_pars_fragment.glsl.js
│ │ │ │ ├── envmap_vertex.glsl.js
│ │ │ │ ├── fog_fragment.glsl.js
│ │ │ │ ├── fog_pars_fragment.glsl.js
│ │ │ │ ├── fog_pars_vertex.glsl.js
│ │ │ │ ├── fog_vertex.glsl.js
│ │ │ │ ├── gradientmap_pars_fragment.glsl.js
│ │ │ │ ├── lightmap_fragment.glsl.js
│ │ │ │ ├── lightmap_pars_fragment.glsl.js
│ │ │ │ ├── lights_fragment_begin.glsl.js
│ │ │ │ ├── lights_fragment_end.glsl.js
│ │ │ │ ├── lights_fragment_maps.glsl.js
│ │ │ │ ├── lights_lambert_vertex.glsl.js
│ │ │ │ ├── lights_pars_begin.glsl.js
│ │ │ │ ├── lights_phong_fragment.glsl.js
│ │ │ │ ├── lights_phong_pars_fragment.glsl.js
│ │ │ │ ├── lights_physical_fragment.glsl.js
│ │ │ │ ├── lights_physical_pars_fragment.glsl.js
│ │ │ │ ├── lights_toon_fragment.glsl.js
│ │ │ │ ├── lights_toon_pars_fragment.glsl.js
│ │ │ │ ├── logdepthbuf_fragment.glsl.js
│ │ │ │ ├── logdepthbuf_pars_fragment.glsl.js
│ │ │ │ ├── logdepthbuf_pars_vertex.glsl.js
│ │ │ │ ├── logdepthbuf_vertex.glsl.js
│ │ │ │ ├── map_fragment.glsl.js
│ │ │ │ ├── map_pars_fragment.glsl.js
│ │ │ │ ├── map_particle_fragment.glsl.js
│ │ │ │ ├── map_particle_pars_fragment.glsl.js
│ │ │ │ ├── metalnessmap_fragment.glsl.js
│ │ │ │ ├── metalnessmap_pars_fragment.glsl.js
│ │ │ │ ├── morphnormal_vertex.glsl.js
│ │ │ │ ├── morphtarget_pars_vertex.glsl.js
│ │ │ │ ├── morphtarget_vertex.glsl.js
│ │ │ │ ├── normal_fragment_begin.glsl.js
│ │ │ │ ├── normal_fragment_maps.glsl.js
│ │ │ │ ├── normalmap_pars_fragment.glsl.js
│ │ │ │ ├── packing.glsl.js
│ │ │ │ ├── premultiplied_alpha_fragment.glsl.js
│ │ │ │ ├── project_vertex.glsl.js
│ │ │ │ ├── roughnessmap_fragment.glsl.js
│ │ │ │ ├── roughnessmap_pars_fragment.glsl.js
│ │ │ │ ├── shadowmap_pars_fragment.glsl.js
│ │ │ │ ├── shadowmap_pars_vertex.glsl.js
│ │ │ │ ├── shadowmap_vertex.glsl.js
│ │ │ │ ├── shadowmask_pars_fragment.glsl.js
│ │ │ │ ├── skinbase_vertex.glsl.js
│ │ │ │ ├── skinning_pars_vertex.glsl.js
│ │ │ │ ├── skinning_vertex.glsl.js
│ │ │ │ ├── skinnormal_vertex.glsl.js
│ │ │ │ ├── specularmap_fragment.glsl.js
│ │ │ │ ├── specularmap_pars_fragment.glsl.js
│ │ │ │ ├── tonemapping_fragment.glsl.js
│ │ │ │ ├── tonemapping_pars_fragment.glsl.js
│ │ │ │ ├── uv2_pars_fragment.glsl.js
│ │ │ │ ├── uv2_pars_vertex.glsl.js
│ │ │ │ ├── uv2_vertex.glsl.js
│ │ │ │ ├── uv_pars_fragment.glsl.js
│ │ │ │ ├── uv_pars_vertex.glsl.js
│ │ │ │ ├── uv_vertex.glsl.js
│ │ │ │ └── worldpos_vertex.glsl.js
│ │ │ ├── ShaderChunk.d.ts
│ │ │ ├── ShaderChunk.js
│ │ │ ├── ShaderLib/
│ │ │ │ ├── background_frag.glsl.js
│ │ │ │ ├── background_vert.glsl.js
│ │ │ │ ├── cube_frag.glsl.js
│ │ │ │ ├── cube_vert.glsl.js
│ │ │ │ ├── depth_frag.glsl.js
│ │ │ │ ├── depth_vert.glsl.js
│ │ │ │ ├── distanceRGBA_frag.glsl.js
│ │ │ │ ├── distanceRGBA_vert.glsl.js
│ │ │ │ ├── equirect_frag.glsl.js
│ │ │ │ ├── equirect_vert.glsl.js
│ │ │ │ ├── linedashed_frag.glsl.js
│ │ │ │ ├── linedashed_vert.glsl.js
│ │ │ │ ├── meshbasic_frag.glsl.js
│ │ │ │ ├── meshbasic_vert.glsl.js
│ │ │ │ ├── meshlambert_frag.glsl.js
│ │ │ │ ├── meshlambert_vert.glsl.js
│ │ │ │ ├── meshmatcap_frag.glsl.js
│ │ │ │ ├── meshmatcap_vert.glsl.js
│ │ │ │ ├── meshphong_frag.glsl.js
│ │ │ │ ├── meshphong_vert.glsl.js
│ │ │ │ ├── meshphysical_frag.glsl.js
│ │ │ │ ├── meshphysical_vert.glsl.js
│ │ │ │ ├── meshtoon_frag.glsl.js
│ │ │ │ ├── meshtoon_vert.glsl.js
│ │ │ │ ├── normal_frag.glsl.js
│ │ │ │ ├── normal_vert.glsl.js
│ │ │ │ ├── points_frag.glsl.js
│ │ │ │ ├── points_vert.glsl.js
│ │ │ │ ├── shadow_frag.glsl.js
│ │ │ │ ├── shadow_vert.glsl.js
│ │ │ │ ├── sprite_frag.glsl.js
│ │ │ │ ├── sprite_vert.glsl.js
│ │ │ │ ├── vsm_frag.glsl.js
│ │ │ │ └── vsm_vert.glsl.js
│ │ │ ├── ShaderLib.d.ts
│ │ │ ├── ShaderLib.js
│ │ │ ├── UniformsLib.d.ts
│ │ │ ├── UniformsLib.js
│ │ │ ├── UniformsUtils.d.ts
│ │ │ └── UniformsUtils.js
│ │ ├── webgl/
│ │ │ ├── WebGLAnimation.d.ts
│ │ │ ├── WebGLAnimation.js
│ │ │ ├── WebGLAttributes.d.ts
│ │ │ ├── WebGLAttributes.js
│ │ │ ├── WebGLBackground.d.ts
│ │ │ ├── WebGLBackground.js
│ │ │ ├── WebGLBufferRenderer.d.ts
│ │ │ ├── WebGLBufferRenderer.js
│ │ │ ├── WebGLCapabilities.d.ts
│ │ │ ├── WebGLCapabilities.js
│ │ │ ├── WebGLClipping.d.ts
│ │ │ ├── WebGLClipping.js
│ │ │ ├── WebGLExtensions.d.ts
│ │ │ ├── WebGLExtensions.js
│ │ │ ├── WebGLGeometries.d.ts
│ │ │ ├── WebGLGeometries.js
│ │ │ ├── WebGLIndexedBufferRenderer.d.ts
│ │ │ ├── WebGLIndexedBufferRenderer.js
│ │ │ ├── WebGLInfo.d.ts
│ │ │ ├── WebGLInfo.js
│ │ │ ├── WebGLLights.d.ts
│ │ │ ├── WebGLLights.js
│ │ │ ├── WebGLMorphtargets.d.ts
│ │ │ ├── WebGLMorphtargets.js
│ │ │ ├── WebGLMultiview.d.ts
│ │ │ ├── WebGLMultiview.js
│ │ │ ├── WebGLObjects.d.ts
│ │ │ ├── WebGLObjects.js
│ │ │ ├── WebGLProgram.d.ts
│ │ │ ├── WebGLProgram.js
│ │ │ ├── WebGLPrograms.d.ts
│ │ │ ├── WebGLPrograms.js
│ │ │ ├── WebGLProperties.d.ts
│ │ │ ├── WebGLProperties.js
│ │ │ ├── WebGLRenderLists.d.ts
│ │ │ ├── WebGLRenderLists.js
│ │ │ ├── WebGLRenderStates.d.ts
│ │ │ ├── WebGLRenderStates.js
│ │ │ ├── WebGLShader.d.ts
│ │ │ ├── WebGLShader.js
│ │ │ ├── WebGLShadowMap.d.ts
│ │ │ ├── WebGLShadowMap.js
│ │ │ ├── WebGLState.d.ts
│ │ │ ├── WebGLState.js
│ │ │ ├── WebGLTextures.d.ts
│ │ │ ├── WebGLTextures.js
│ │ │ ├── WebGLUniforms.d.ts
│ │ │ ├── WebGLUniforms.js
│ │ │ ├── WebGLUtils.d.ts
│ │ │ └── WebGLUtils.js
│ │ └── webxr/
│ │ ├── WebXRManager.d.ts
│ │ └── WebXRManager.js
│ ├── scenes/
│ │ ├── Fog.d.ts
│ │ ├── Fog.js
│ │ ├── FogExp2.d.ts
│ │ ├── FogExp2.js
│ │ ├── Scene.d.ts
│ │ └── Scene.js
│ ├── shaders/
│ │ ├── AfterimageShader.d.ts
│ │ ├── AfterimageShader.js
│ │ ├── BasicShader.d.ts
│ │ ├── BasicShader.js
│ │ ├── BleachBypassShader.d.ts
│ │ ├── BleachBypassShader.js
│ │ ├── BlendShader.d.ts
│ │ ├── BlendShader.js
│ │ ├── BokehShader.d.ts
│ │ ├── BokehShader.js
│ │ ├── BokehShader2.d.ts
│ │ ├── BokehShader2.js
│ │ ├── BrightnessContrastShader.d.ts
│ │ ├── BrightnessContrastShader.js
│ │ ├── ColorCorrectionShader.d.ts
│ │ ├── ColorCorrectionShader.js
│ │ ├── ColorifyShader.d.ts
│ │ ├── ColorifyShader.js
│ │ ├── ConvolutionShader.d.ts
│ │ ├── ConvolutionShader.js
│ │ ├── CopyShader.d.ts
│ │ ├── CopyShader.js
│ │ ├── DOFMipMapShader.d.ts
│ │ ├── DOFMipMapShader.js
│ │ ├── DepthLimitedBlurShader.d.ts
│ │ ├── DepthLimitedBlurShader.js
│ │ ├── DigitalGlitch.d.ts
│ │ ├── DigitalGlitch.js
│ │ ├── DotScreenShader.d.ts
│ │ ├── DotScreenShader.js
│ │ ├── FXAAShader.d.ts
│ │ ├── FXAAShader.js
│ │ ├── FilmShader.d.ts
│ │ ├── FilmShader.js
│ │ ├── FocusShader.d.ts
│ │ ├── FocusShader.js
│ │ ├── FreiChenShader.d.ts
│ │ ├── FreiChenShader.js
│ │ ├── FresnelShader.d.ts
│ │ ├── FresnelShader.js
│ │ ├── GammaCorrectionShader.d.ts
│ │ ├── GammaCorrectionShader.js
│ │ ├── GodRaysShader.d.ts
│ │ ├── GodRaysShader.js
│ │ ├── HalftoneShader.d.ts
│ │ ├── HalftoneShader.js
│ │ ├── HorizontalBlurShader.d.ts
│ │ ├── HorizontalBlurShader.js
│ │ ├── HorizontalTiltShiftShader.d.ts
│ │ ├── HorizontalTiltShiftShader.js
│ │ ├── HueSaturationShader.d.ts
│ │ ├── HueSaturationShader.js
│ │ ├── KaleidoShader.d.ts
│ │ ├── KaleidoShader.js
│ │ ├── LuminosityHighPassShader.d.ts
│ │ ├── LuminosityHighPassShader.js
│ │ ├── LuminosityShader.d.ts
│ │ ├── LuminosityShader.js
│ │ ├── MirrorShader.d.ts
│ │ ├── MirrorShader.js
│ │ ├── NormalMapShader.d.ts
│ │ ├── NormalMapShader.js
│ │ ├── OceanShaders.d.ts
│ │ ├── OceanShaders.js
│ │ ├── ParallaxShader.d.ts
│ │ ├── ParallaxShader.js
│ │ ├── PixelShader.d.ts
│ │ ├── PixelShader.js
│ │ ├── RGBShiftShader.d.ts
│ │ ├── RGBShiftShader.js
│ │ ├── SAOShader.d.ts
│ │ ├── SAOShader.js
│ │ ├── SMAAShader.d.ts
│ │ ├── SMAAShader.js
│ │ ├── SSAOShader.d.ts
│ │ ├── SSAOShader.js
│ │ ├── SepiaShader.d.ts
│ │ ├── SepiaShader.js
│ │ ├── SobelOperatorShader.d.ts
│ │ ├── SobelOperatorShader.js
│ │ ├── TechnicolorShader.d.ts
│ │ ├── TechnicolorShader.js
│ │ ├── ToneMapShader.d.ts
│ │ ├── ToneMapShader.js
│ │ ├── ToonShader.d.ts
│ │ ├── ToonShader.js
│ │ ├── TranslucentShader.d.ts
│ │ ├── TranslucentShader.js
│ │ ├── TriangleBlurShader.d.ts
│ │ ├── TriangleBlurShader.js
│ │ ├── UnpackDepthRGBAShader.d.ts
│ │ ├── UnpackDepthRGBAShader.js
│ │ ├── VerticalBlurShader.d.ts
│ │ ├── VerticalBlurShader.js
│ │ ├── VerticalTiltShiftShader.d.ts
│ │ ├── VerticalTiltShiftShader.js
│ │ ├── VignetteShader.d.ts
│ │ ├── VignetteShader.js
│ │ ├── VolumeShader.d.ts
│ │ ├── VolumeShader.js
│ │ ├── WaterRefractionShader.d.ts
│ │ └── WaterRefractionShader.js
│ ├── textures/
│ │ ├── CanvasTexture.d.ts
│ │ ├── CanvasTexture.js
│ │ ├── CompressedTexture.d.ts
│ │ ├── CompressedTexture.js
│ │ ├── CubeTexture.d.ts
│ │ ├── CubeTexture.js
│ │ ├── DataTexture.d.ts
│ │ ├── DataTexture.js
│ │ ├── DataTexture2DArray.d.ts
│ │ ├── DataTexture2DArray.js
│ │ ├── DataTexture3D.d.ts
│ │ ├── DataTexture3D.js
│ │ ├── DepthTexture.d.ts
│ │ ├── DepthTexture.js
│ │ ├── Texture.d.ts
│ │ ├── Texture.js
│ │ ├── VideoTexture.d.ts
│ │ └── VideoTexture.js
│ ├── utils/
│ │ ├── BufferGeometryUtils.d.ts
│ │ ├── BufferGeometryUtils.js
│ │ ├── GeometryCompressionUtils.d.ts
│ │ ├── GeometryCompressionUtils.js
│ │ ├── GeometryUtils.d.ts
│ │ ├── GeometryUtils.js
│ │ ├── ImageUtils.js
│ │ ├── PMREMGenerator.js
│ │ ├── RoughnessMipmapper.d.ts
│ │ ├── RoughnessMipmapper.js
│ │ ├── SceneUtils.d.ts
│ │ ├── SceneUtils.js
│ │ ├── ShadowMapViewer.d.ts
│ │ ├── ShadowMapViewer.js
│ │ ├── ShapeUtils.js
│ │ ├── SkeletonUtils.d.ts
│ │ ├── SkeletonUtils.js
│ │ ├── TypedArrayUtils.d.ts
│ │ ├── TypedArrayUtils.js
│ │ ├── UVsDebug.d.ts
│ │ └── UVsDebug.js
│ ├── utils.d.ts
│ ├── utils.js
│ ├── vr/
│ │ └── HelioWebXRPolyfill.js
│ └── webxr/
│ ├── ARButton.d.ts
│ ├── ARButton.js
│ ├── VRButton.d.ts
│ └── VRButton.js
└── utils.js
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
/.idea/
/node_modules/
/tests/
================================================
FILE: .npmignore
================================================
/tests
/configs
/.idea
/es6-convertor.js
/gulpfile.js
!core
================================================
FILE: LICENSE.md
================================================
### MIT License
##### Copyright (c) 2017-Present, Itee, Valcke Tristan [https://github.com/Itee](https://github.com/Itee).
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.
================================================
FILE: README.md
================================================
three-full
================
[![License][license-badge]][license-badge-url]
**Deprecation note:**
> I am glad to annonce since Three release his examples files under JSM folder, this repository should be avoided. The first goal of this repository was to provided an alternative solution during this migration. From now, please consider to use Three.module.js instead even if i maintain this repository for my personal usage. Thanks for all ! Itee...
**The version 28.0.2 is now available under Three r0.113.2**
#### Extended Three JavaScript 3D library ####
Three.js come with lot of examples files, which are curently not usable as ES6 module.
The purpose of this project is to convert all examples files and includes them as part
of the library.
#### Setup ####
Assuming that npm and node are already installed.
Install:
````
npm install --save three-full
````
#### Usage ####
Like Three.js but with more, more and more available stuff.
###### Using ES6: ######
````javascript
import { WhatIWant } from 'node_modules/three-full/builds/Three.es.js'
// equivalent to
import { WhatIWant } from 'three-full'
// or directly from sources folder
import { Ocean } from 'node_modules/three-full/sources/Ocean'
````
###### Using Node/CommonJS: ######
````javascript
const Three = require('node_modules/three-full/builds/Three.cjs.js')
// equivalent to
const Three = require('three-full')
````
###### Using UMD: ######
````javascript
const Three = require('node_modules/three-full/builds/Three.umd.js')
````
###### Using AMD: ######
````javascript
require(['node_modules/three-full/builds/Three.amd.js'],
function( Three ){
//...
});
````
###### From HTML (not recommended): ######
````
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Three Full Es6</title>
</head>
<body>
<script src="node_modules/three-full/builds/Three.iife.js"></script>
<script>
alert('Three.REVISION: ' + Three.REVISION)
</script>
</body>
</html>
````
Note: You should copy the file in right server location to serve it correctly, and use Three.iife.min.js under production ! Importing the all library in HTML page should be avoided, use a proper module bundler like webpack or rollup using es6 module syntaxe !
#### Commands ####
In case you want participate, you need to known some commands below:
Help:
````
npm run help
````
Will display all you need to known about available commands in three-full package
Patch:
````
npm run patch
````
<span style="color:red">**Important:** After installing/reinstalling node_modules/three you need to apply patch only once, for fix some examples parts.</span>
Convert:
````
npm run convert
````
This command will convert all examples files as ES6 modules ([*](#miss)) and copy all three files at top level of the package in view to be build.
Build:<br>
````
npm run build
````
This command will build converted sources as UMD, AMD, ES ([*](#bug)), CJS and IIFE using [Rollup](https://rollupjs.org/)
#### <a id="miss"></a>Missings Files ####
This is the list of unsupported part of example, which cannot/won't be converted.
* **Intermediary exporter files**
* **Curves.js**
* **Geometries.js**
* **Materials.js**
* **Nodes.js**
* **Others**
* **examples\js** //*Good job was done in JSM folder, nice*
* **examples\jsm\controls\experimental** //*Duplicate exports*
* **Specific Files**
* **examples\js\loaders\VRMLLoader**
* **examples\js\loaders\NRRDLoader**
* **examples\js\renderers\RaytracingWorker**
#### <a id="miss"></a>Missings Imports ####
* **Scene** Could use \_\_THREE_DEVTOOLS__
* **WebGLRenderer** Could use \_\_THREE_DEVTOOLS__
* **MMDLoader** Require MMDParser available at three/examples/jsm/libs/mmdparser.module.js
* **MMDExporter** Require MMDParser available at three/examples/jsm/libs/mmdparser.module.js
* **FBXLoader** Require Zlib.Inflate available at three/examples/jsm/libs/inflate.module.min.js
* **EXRLoader** Require Zlib.Inflate available at three/examples/jsm/libs/inflate.module.min.js
* **NRRDLoader** Require Zlib.Inflate available at three/examples/jsm/libs/inflate.module.min.js
* **VTKLoader** Require Zlib.Inflate available at three/examples/jsm/libs/inflate.module.min.js
* **TTFLoader** Require opentype available at three/examples/js/libs/opentype.min.js
* **TimelinerController** Require Timeliner available at three/examples/js/libs/timeliner_gui.min.js
#### <a id="redirectedFiles"></a>Redirected Files ####
**All JSM files are mapped to their counter-part under sources folders except**
| Filename | New Location |
|------------------------|---------------------------------------|
| ConvexObjectBreaker | 'modifiers/ConvexObjectBreaker.js' |
| Curve | 'curves/Curve.js' |
| Earcut | 'misc/Earcut.js' |
| GPUComputationRenderer | 'renderers/GPUComputationRenderer.js' |
| Gyroscope | 'objects/Gyroscope.js' |
| ImageUtils | 'utils/ImageUtils.js' |
| MD2Character | 'objects/MD2Character.js' |
| MD2CharacterComplex | 'objects/MD2CharacterComplex.js' |
| MorphAnimMesh | 'objects/MorphAnimMesh.js' |
| MorphBlendMesh | 'objects/MorphBlendMesh.js' |
| Ocean | 'objects/Ocean.js' |
| PMREMGenerator | 'utils/PMREMGenerator.js' |
| RollerCoaster | 'objects/RollerCoaster.js' |
| ShapeUtils | 'utils/ShapeUtils.js' |
| VolumeSlice | 'audio/VolumeSlice.js' |
| WebGL | 'helpers/WebGL.js' |
#### Change log ####
##### 28.0.2:
* Fix WebGLShadowMap missing imports
##### 28.0.1:
* Fix banner deprecation warning
* Fix OBJLoader2Worker management
* Ignore XRControllerModelFactory
* Fix missing motion-controllers lib copy
* Fix multi-imports override from external file
##### 28.0.0:
* Support of Three r113.2
* Ignore experimental jsm folder
* Add eslint fix about StandardNode
* Fix SVGLoader imports
* Fix TypedArrayUtils imports
* Fix WebGLPrograms imports
##### 27.0.0:
* Support of Three r112.1
* Better redirection of TS files
* Add PMREMGenerator
* Add ShaderChunk light toon
* Add ShaderLib mesh toon
* Move WebXRManager into webxr folder
##### 26.0.0:
* Support of Three r111.0
* Remove OutlineEffect edgecase
* Remove LegacyGLTFLoader
* Remove LegacyJSONLoader
* Remove PaintViveController
* Remove ViveController
* Remove DaydreamController
* Remove GearVRController
##### 25.0.0:
* Support of Three r110.0
* Remove AssimpJSONLoader
* Remove EquirectangularToCubeGenerator
* Remove SoftwareRenderer
* Remove WebGL2Renderer
##### 24.0.0:
* Support of Three r109.0
* Add InstancedMesh
* Add WebGLMultiviewRenderTarget
* Add WebGLMultiview
* Remove EditorControls
* Remove OrthographicTrackballControls
* Remove AWDLoader
* Remove BabylonLoader
* Remove PlayCanvasLoader
##### 23.0.1:
* Fix missing branch merge
##### 23.0.0:
* Support of Three r108.0
* Add missing imports to WebGLPrograms
* Add missing libs folder
* Add PointLightShadow
* Add some ShaderChunk
* Add VSM shader
##### 22.0.0:
* Support of Three r107.0
* Fix FBXLoader imports
* Fix TypedArrayUtils imports
* Fix WebGL declaration
* Fix WebVR declaration
##### 21.0.0:
* Support of Three r106.2
* Ignore VRMLLoader due to incompatible AMD dependencies
* Add RectAreaLightUniformsLib
* Add CarControls
* Add MathNode
* Add GodRayShader
* Add OceanShader
* Add SkinShader
* Add TerrainShader
* Add ToonShader
* Add TranslucentShader
* Fix DRACOExporter name
* Fix ObjectLoader curves imports
* Fix TextureCubeUVNode imports
##### 20.0.0:
* Support of Three r105.2
* Add special treatment for HelioWebXRPolyfill
* Update Pass patch
* Add BasisTextureLoader
* Fix Lut export
* Fix NodeMaterialLoader export
* Fix SMAAShader export
* Fix WebGLDeferredRenderer export
##### 19.0.0:
* Support of Three r104
* Add LightProbeHelper
* Add AmbientLightProbe
* Add HemisphereLightProbe
* Add LightProbe
* Add LightProbeGenerator
* Add SphericalHarmonics3
##### 18.0.0:
* Support of Three r103
* Add DracoExporter
* Add LWOLoader
* Add DataTexture2DArray
* Move ImageUtils into utils folder
* Reintroduce ParametricGeometries
* Allow to remove exports from config file using negation
##### 17.2.0:
* Auto generate unit test files for karma and html
* Fix DRACOLoader, NormalNode, , Loader, Material naming (internal $1)
* Export EquirectangularToCubeGenerator
* Export cloneUniforms and mergeUniforms from UniformsUtils
* Unexport HDRLoader (Use RGBELoader instead)
##### 17.1.0:
* Add unit tests about the usability of each Three class
* Add new npm script 'test' to run unit under karma server
* Add new gulp tasks to auto-generate unit tests
* Generate an HTML report after 'npm run test'
##### 17.0.0:
* Support of Three r102
##### 16.0.1:
* Fix missing core folder due to NPM v6.8.0 [bug](https://npm.community/t/npm-pack-leaving-out-files-6-8-0-only/5382)
##### 16.0.0:
* Support of Three r101
* Add patch in BufferGeometryUtils againt for...of loop
##### 15.0.0:
* Support of Three r100
* Ignore ldraw folder
##### 14.0.0:
* Support of Three r99
* Allow new glsl support
##### 13.0.0:
* Support of Three r98
* Some trouble could come from LoaderSupport using eval (/!\)
* Ignore offscreen folder
##### 12.0.0:
* Support of Three r97
* Add cleaning step before right source files ( Remove extra blank lines and semi-colons)
* Remove some useless patch about Nodes
* Use new WebGL lib instead of Detector
##### 11.3.3:
* Fix warning for cjs build onky in debug mode and improve window global check
##### 11.3.2:
* Fix global window declaration for cjs build usage (again)
##### 11.3.1:
* Fix global window declaration for cjs build usage
##### 11.3.0:
* Fix ObjLoader2 worker code
* Build tests under a gulp task
* Allow to lint tests files
##### 11.2.0:
* Add banner management over all sources files to avoid PR on sources that are converted
##### 11.1.1:
* Fix SkeletonUtils eslint bug using replacements edge case
##### 11.1.0:
* Sources files are now linted
##### 11.0.0:
* Support of Three r96
* Update edgecase replacement for LoaderSupport
##### 10.0.0:
* Support of Three r95
* Use a generator function that iterate over all files under sources and create the rollup config to build them separatly
* Fix missing LoaderUtils import in OBJLoader2
* Fix missing TextureCubeNode import in NodeBuilder
* Fix missing _Math import in Node
* Fix missing BufferGeometryUtils import in GLTFLoader
* Fix missing BokehDepthShader import in CinematicCamera
* Fix missing UniformsUtils and HalftoneShader import in HalftonePass
* Fix missing UniformsUtils and AfterimageShader import in AfterimagePass
* Fix missing Uint8BufferAttribute, Int8BufferAttribute, Int16BufferAttribute, Int32BufferAttribute and Float32BufferAttribute import in DRACOLoader
* Ignore Nodes and THREE.Nodes intermediary files
* Move ShaderTranslucent in shader folder
##### 9.0.0:
* Support of Three r94
##### 8.0.0:
* Support of Three r93
##### 7.0.0:
* Support of Three r92
##### 6.0.0:
* Support of Three r91
* Fix DefaultLoadingManager import in OBJLoader2
* Fix ShaderLib, UniformsLib, and UniformsUtils imports in LineMaterial
* Fix DefaultLoadingManager, Uint16BufferAttribute and Uint32BufferAttribute imports in DRACOLoader
* Remove fix-camera-node task due to threejs fix
##### 5.0.7:
* Fix missings PropertyBinding imports in FBXLoader
* Fix missings PropertyBinding imports in GLTFExporter
* Fix missings AnimationClip imports in MorphAnimMesh
* Fix missings AnimationClip imports in MD2Loader
* Fix missings _Math imports in SoftwareRenderer
* Fix missings CameraNode imports in NodeMaterialLoader
* Fix missings Interpolant imports in MMDLoader
* Remove unnecessary _Math imports
##### 5.0.6:
* Add a window global variable check to avoid crach under nodejs
##### 5.0.5:
* Change default entry for main and module in package
##### 5.0.4:
* Fix #18, OBJLoader2 worker code
##### 5.0.3:
* Fix missings Geometries imports in ObjectLoader
* Fix missings Materials imports in LoaderMaterial
* Fix missings Curves imports in CurvePath
##### 5.0.2 (Thanks to Marc Bartels):
* Fix missings Loader imports in GLTFLoader
* Fix invalid module.export stuff inside Detector
##### 5.0.1 :
* Reintroduce LineSegment fix
##### 5.0.0 :
* Support of Three r90
* Move the example folder tree to source */!\ In case you're using direct source import, please check the '([Redirected Files](#redirectedFiles))' part*
* Fix Math (instead of _Math) issue
* Fix missings imports/exports
* Reintroduce RollerCoaster stuff
##### 4.2.4 :
* Fix Line/LineSegments circular dependency
( Be aware: Line constructor don't return LineSegments in case of wrong arguments, and log an error instead of a warning )
##### 4.2.3 :
* Fix Detector module.export code snippet
##### 4.2.2 :
* README.md fix wrong copy/paste
##### 4.2.1 :
* Ignore some dev files for npm
##### 4.2.0 :
* Change main entry point of package to Three.es.js
##### 4.1.1 :
* Fix NodeLib circular dependency with FunctionNode
##### 4.1.0 :
* Allow to build es module under production environment
* Fix node warning about unhandled promise rejection
* Fix rollup warning about indent option moved under output options
* Clean up sources
##### 4.0.0 :
* XLoader.js: is now ignored due to AMD module
* Add Earcut, Curves, EXRLoader, GCodeLoader, LoaderUtils
* Remove KeyframeTrackConstructor, KeyframeTrackPrototype, PathPrototype and ImageUtils
* Update imports statements
##### 3.0.0 :
* Cloth.js: is remove due to bad usage of global variable from his html example file
* Add two new fix for three package in CameraNode and NodeLib
* Fix almost all missings imports statements
* Note:
- MMDExporter and MMDLoader need external dependency from https://github.com/takahirox/mmd-parser
- FBXLoader and VTKLoader need external dependency from https://github.com/imaya/zlib.js
- TTFLoader need external dependency from https://github.com/nodebox/opentype.js
##### 2.2.0 :
* Add tests about every file to check their imports
##### 2.1.1 :
* Fix missing import statement in ShaderPass
##### 2.1.0 :
* Export and import statement support multilines
##### 2.0.0 :
* Support Three.js r88
* Reintroduce ColladaLoader in available modules
* Refactor the convert pipeline
[license-badge]: https://img.shields.io/npm/l/three.svg
[license-badge-url]: ./LICENSE.md
================================================
FILE: builds/Three.amd.js
================================================
// Made by Itee (https://github.com/Itee) with ES6 Convertor script
console.warn('[ThreeFull]: I am glad to annonce since Three release his examples files under JSM folder, this repository should be avoided. The first goal of this repository was to provided an alternative solution during this migration. From now, please consider to use Three.module.js instead even if i maintain this repository for my personal usage. Thanks for all ! Itee...');
define(['exports'], function (exports) { 'use strict';
// Polyfills
if ( Number.EPSILON === undefined ) {
Number.EPSILON = Math.pow( 2, - 52 );
}
if ( Number.isInteger === undefined ) {
// Missing in IE
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
Number.isInteger = function ( value ) {
return typeof value === 'number' && isFinite( value ) && Math.floor( value ) === value;
};
}
//
if ( Math.sign === undefined ) {
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign
Math.sign = function ( x ) {
return ( x < 0 ) ? - 1 : ( x > 0 ) ? 1 : + x;
};
}
if ( 'name' in Function.prototype === false ) {
// Missing in IE
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
Object.defineProperty( Function.prototype, 'name', {
get: function () {
return this.toString().match( /^\s*function\s*([^\(\s]*)/ )[ 1 ];
}
} );
}
if ( Object.assign === undefined ) {
// Missing in IE
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
Object.assign = function ( target ) {
var arguments$1 = arguments;
if ( target === undefined || target === null ) {
throw new TypeError( 'Cannot convert undefined or null to object' );
}
var output = Object( target );
for ( var index = 1; index < arguments.length; index ++ ) {
var source = arguments$1[ index ];
if ( source !== undefined && source !== null ) {
for ( var nextKey in source ) {
if ( Object.prototype.hasOwnProperty.call( source, nextKey ) ) {
output[ nextKey ] = source[ nextKey ];
}
}
}
}
return output;
};
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WARNING: This file was auto-generated, any change will be overridden in next release. Please use configs/es6.conf.js then run "npm run convert". //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author tschw
* @author Ben Houston / http://clara.io/
* @author David Sarno / http://lighthaus.us/
*/
var AnimationUtils = {
// same as Array.prototype.slice, but also works on typed arrays
arraySlice: function ( array, from, to ) {
if ( AnimationUtils.isTypedArray( array ) ) {
// in ios9 array.subarray(from, undefined) will return empty array
// but array.subarray(from) or array.subarray(from, len) is correct
return new array.constructor( array.subarray( from, to !== undefined ? to : array.length ) );
}
return array.slice( from, to );
},
// converts an array to a specific type
convertArray: function ( array, type, forceClone ) {
if ( ! array || // let 'undefined' and 'null' pass
! forceClone && array.constructor === type ) { return array; }
if ( typeof type.BYTES_PER_ELEMENT === 'number' ) {
return new type( array ); // create typed array
}
return Array.prototype.slice.call( array ); // create Array
},
isTypedArray: function ( object ) {
return ArrayBuffer.isView( object ) &&
! ( object instanceof DataView );
},
// returns an array by which times and values can be sorted
getKeyframeOrder: function ( times ) {
function compareTime( i, j ) {
return times[ i ] - times[ j ];
}
var n = times.length;
var result = new Array( n );
for ( var i = 0; i !== n; ++ i ) { result[ i ] = i; }
result.sort( compareTime );
return result;
},
// uses the array previously returned by 'getKeyframeOrder' to sort data
sortedArray: function ( values, stride, order ) {
var nValues = values.length;
var result = new values.constructor( nValues );
for ( var i = 0, dstOffset = 0; dstOffset !== nValues; ++ i ) {
var srcOffset = order[ i ] * stride;
for ( var j = 0; j !== stride; ++ j ) {
result[ dstOffset ++ ] = values[ srcOffset + j ];
}
}
return result;
},
// function for parsing AOS keyframe formats
flattenJSON: function ( jsonKeys, times, values, valuePropertyName ) {
var i = 1, key = jsonKeys[ 0 ];
while ( key !== undefined && key[ valuePropertyName ] === undefined ) {
key = jsonKeys[ i ++ ];
}
if ( key === undefined ) { return; } // no data
var value = key[ valuePropertyName ];
if ( value === undefined ) { return; } // no data
if ( Array.isArray( value ) ) {
do {
value = key[ valuePropertyName ];
if ( value !== undefined ) {
times.push( key.time );
values.push.apply( values, value ); // push all elements
}
key = jsonKeys[ i ++ ];
} while ( key !== undefined );
} else if ( value.toArray !== undefined ) {
// ...assume Math-ish
do {
value = key[ valuePropertyName ];
if ( value !== undefined ) {
times.push( key.time );
value.toArray( values, values.length );
}
key = jsonKeys[ i ++ ];
} while ( key !== undefined );
} else {
// otherwise push as-is
do {
value = key[ valuePropertyName ];
if ( value !== undefined ) {
times.push( key.time );
values.push( value );
}
key = jsonKeys[ i ++ ];
} while ( key !== undefined );
}
},
subclip: function ( sourceClip, name, startFrame, endFrame, fps ) {
fps = fps || 30;
var clip = sourceClip.clone();
clip.name = name;
var tracks = [];
for ( var i = 0; i < clip.tracks.length; ++ i ) {
var track = clip.tracks[ i ];
var valueSize = track.getValueSize();
var times = [];
var values = [];
for ( var j = 0; j < track.times.length; ++ j ) {
var frame = track.times[ j ] * fps;
if ( frame < startFrame || frame >= endFrame ) { continue; }
times.push( track.times[ j ] );
for ( var k = 0; k < valueSize; ++ k ) {
values.push( track.values[ j * valueSize + k ] );
}
}
if ( times.length === 0 ) { continue; }
track.times = AnimationUtils.convertArray( times, track.times.constructor );
track.values = AnimationUtils.convertArray( values, track.values.constructor );
tracks.push( track );
}
clip.tracks = tracks;
// find minimum .times value across all tracks in the trimmed clip
var minStartTime = Infinity;
for ( var i = 0; i < clip.tracks.length; ++ i ) {
if ( minStartTime > clip.tracks[ i ].times[ 0 ] ) {
minStartTime = clip.tracks[ i ].times[ 0 ];
}
}
// shift all tracks such that clip begins at t=0
for ( var i = 0; i < clip.tracks.length; ++ i ) {
clip.tracks[ i ].shift( - 1 * minStartTime );
}
clip.resetDuration();
return clip;
}
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WARNING: This file was auto-generated, any change will be overridden in next release. Please use configs/es6.conf.js then run "npm run convert". //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var REVISION = '113';
var MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 };
var TOUCH = { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 };
var CullFaceNone = 0;
var CullFaceBack = 1;
var CullFaceFront = 2;
var CullFaceFrontBack = 3;
var FrontFaceDirectionCW = 0;
var FrontFaceDirectionCCW = 1;
var BasicShadowMap = 0;
var PCFShadowMap = 1;
var PCFSoftShadowMap = 2;
var VSMShadowMap = 3;
var FrontSide = 0;
var BackSide = 1;
var DoubleSide = 2;
var FlatShading = 1;
var SmoothShading = 2;
var NoColors = 0;
var FaceColors = 1;
var VertexColors = 2;
var NoBlending = 0;
var NormalBlending = 1;
var AdditiveBlending = 2;
var SubtractiveBlending = 3;
var MultiplyBlending = 4;
var CustomBlending = 5;
var AddEquation = 100;
var SubtractEquation = 101;
var ReverseSubtractEquation = 102;
var MinEquation = 103;
var MaxEquation = 104;
var ZeroFactor = 200;
var OneFactor = 201;
var SrcColorFactor = 202;
var OneMinusSrcColorFactor = 203;
var SrcAlphaFactor = 204;
var OneMinusSrcAlphaFactor = 205;
var DstAlphaFactor = 206;
var OneMinusDstAlphaFactor = 207;
var DstColorFactor = 208;
var OneMinusDstColorFactor = 209;
var SrcAlphaSaturateFactor = 210;
var NeverDepth = 0;
var AlwaysDepth = 1;
var LessDepth = 2;
var LessEqualDepth = 3;
var EqualDepth = 4;
var GreaterEqualDepth = 5;
var GreaterDepth = 6;
var NotEqualDepth = 7;
var MultiplyOperation = 0;
var MixOperation = 1;
var AddOperation = 2;
var NoToneMapping = 0;
var LinearToneMapping = 1;
var ReinhardToneMapping = 2;
var Uncharted2ToneMapping = 3;
var CineonToneMapping = 4;
var ACESFilmicToneMapping = 5;
var UVMapping = 300;
var CubeReflectionMapping = 301;
var CubeRefractionMapping = 302;
var EquirectangularReflectionMapping = 303;
var EquirectangularRefractionMapping = 304;
var SphericalReflectionMapping = 305;
var CubeUVReflectionMapping = 306;
var CubeUVRefractionMapping = 307;
var RepeatWrapping = 1000;
var ClampToEdgeWrapping = 1001;
var MirroredRepeatWrapping = 1002;
var NearestFilter = 1003;
var NearestMipmapNearestFilter = 1004;
var NearestMipMapNearestFilter = 1004;
var NearestMipmapLinearFilter = 1005;
var NearestMipMapLinearFilter = 1005;
var LinearFilter = 1006;
var LinearMipmapNearestFilter = 1007;
var LinearMipMapNearestFilter = 1007;
var LinearMipmapLinearFilter = 1008;
var LinearMipMapLinearFilter = 1008;
var UnsignedByteType = 1009;
var ByteType = 1010;
var ShortType = 1011;
var UnsignedShortType = 1012;
var IntType = 1013;
var UnsignedIntType = 1014;
var FloatType = 1015;
var HalfFloatType = 1016;
var UnsignedShort4444Type = 1017;
var UnsignedShort5551Type = 1018;
var UnsignedShort565Type = 1019;
var UnsignedInt248Type = 1020;
var AlphaFormat = 1021;
var RGBFormat = 1022;
var RGBAFormat = 1023;
var LuminanceFormat = 1024;
var LuminanceAlphaFormat = 1025;
var RGBEFormat = RGBAFormat;
var DepthFormat = 1026;
var DepthStencilFormat = 1027;
var RedFormat = 1028;
var RedIntegerFormat = 1029;
var RGFormat = 1030;
var RGIntegerFormat = 1031;
var RGBIntegerFormat = 1032;
var RGBAIntegerFormat = 1033;
var RGB_S3TC_DXT1_Format = 33776;
var RGBA_S3TC_DXT1_Format = 33777;
var RGBA_S3TC_DXT3_Format = 33778;
var RGBA_S3TC_DXT5_Format = 33779;
var RGB_PVRTC_4BPPV1_Format = 35840;
var RGB_PVRTC_2BPPV1_Format = 35841;
var RGBA_PVRTC_4BPPV1_Format = 35842;
var RGBA_PVRTC_2BPPV1_Format = 35843;
var RGB_ETC1_Format = 36196;
var RGBA_ASTC_4x4_Format = 37808;
var RGBA_ASTC_5x4_Format = 37809;
var RGBA_ASTC_5x5_Format = 37810;
var RGBA_ASTC_6x5_Format = 37811;
var RGBA_ASTC_6x6_Format = 37812;
var RGBA_ASTC_8x5_Format = 37813;
var RGBA_ASTC_8x6_Format = 37814;
var RGBA_ASTC_8x8_Format = 37815;
var RGBA_ASTC_10x5_Format = 37816;
var RGBA_ASTC_10x6_Format = 37817;
var RGBA_ASTC_10x8_Format = 37818;
var RGBA_ASTC_10x10_Format = 37819;
var RGBA_ASTC_12x10_Format = 37820;
var RGBA_ASTC_12x12_Format = 37821;
var LoopOnce = 2200;
var LoopRepeat = 2201;
var LoopPingPong = 2202;
var InterpolateDiscrete = 2300;
var InterpolateLinear = 2301;
var InterpolateSmooth = 2302;
var ZeroCurvatureEnding = 2400;
var ZeroSlopeEnding = 2401;
var WrapAroundEnding = 2402;
var TrianglesDrawMode = 0;
var TriangleStripDrawMode = 1;
var TriangleFanDrawMode = 2;
var LinearEncoding = 3000;
var sRGBEncoding = 3001;
var GammaEncoding = 3007;
var RGBEEncoding = 3002;
var LogLuvEncoding = 3003;
var RGBM7Encoding = 3004;
var RGBM16Encoding = 3005;
var RGBDEncoding = 3006;
var BasicDepthPacking = 3200;
var RGBADepthPacking = 3201;
var TangentSpaceNormalMap = 0;
var ObjectSpaceNormalMap = 1;
var ZeroStencilOp = 0;
var KeepStencilOp = 7680;
var ReplaceStencilOp = 7681;
var IncrementStencilOp = 7682;
var DecrementStencilOp = 7683;
var IncrementWrapStencilOp = 34055;
var DecrementWrapStencilOp = 34056;
var InvertStencilOp = 5386;
var NeverStencilFunc = 512;
var LessStencilFunc = 513;
var EqualStencilFunc = 514;
var LessEqualStencilFunc = 515;
var GreaterStencilFunc = 516;
var NotEqualStencilFunc = 517;
var GreaterEqualStencilFunc = 518;
var AlwaysStencilFunc = 519;
var StaticDrawUsage = 35044;
var DynamicDrawUsage = 35048;
var StreamDrawUsage = 35040;
var StaticReadUsage = 35045;
var DynamicReadUsage = 35049;
var StreamReadUsage = 35041;
var StaticCopyUsage = 35046;
var DynamicCopyUsage = 35050;
var StreamCopyUsage = 35042;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WARNING: This file was auto-generated, any change will be overridden in next release. Please use configs/es6.conf.js then run "npm run convert". //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Abstract base class of interpolants over parametric samples.
*
* The parameter domain is one dimensional, typically the time or a path
* along a curve defined by the data.
*
* The sample values can have any dimensionality and derived classes may
* apply special interpretations to the data.
*
* This class provides the interval seek in a Template Method, deferring
* the actual interpolation to derived classes.
*
* Time complexity is O(1) for linear access crossing at most two points
* and O(log N) for random access, where N is the number of positions.
*
* References:
*
* http://www.oodesign.com/template-method-pattern.html
*
* @author tschw
*/
function Interpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
this.parameterPositions = parameterPositions;
this._cachedIndex = 0;
this.resultBuffer = resultBuffer !== undefined ?
resultBuffer : new sampleValues.constructor( sampleSize );
this.sampleValues = sampleValues;
this.valueSize = sampleSize;
}
Object.assign( Interpolant.prototype, {
evaluate: function ( t ) {
var pp = this.parameterPositions,
i1 = this._cachedIndex,
t1 = pp[ i1 ],
t0 = pp[ i1 - 1 ];
validate_interval: {
seek: {
var right;
linear_scan: {
//- See http://jsperf.com/comparison-to-undefined/3
//- slower code:
//-
//- if ( t >= t1 || t1 === undefined ) {
forward_scan: if ( ! ( t < t1 ) ) {
for ( var giveUpAt = i1 + 2; ; ) {
if ( t1 === undefined ) {
if ( t < t0 ) { break forward_scan; }
// after end
i1 = pp.length;
this._cachedIndex = i1;
return this.afterEnd_( i1 - 1, t, t0 );
}
if ( i1 === giveUpAt ) { break; } // this loop
t0 = t1;
t1 = pp[ ++ i1 ];
if ( t < t1 ) {
// we have arrived at the sought interval
break seek;
}
}
// prepare binary search on the right side of the index
right = pp.length;
break linear_scan;
}
//- slower code:
//- if ( t < t0 || t0 === undefined ) {
if ( ! ( t >= t0 ) ) {
// looping?
var t1global = pp[ 1 ];
if ( t < t1global ) {
i1 = 2; // + 1, using the scan for the details
t0 = t1global;
}
// linear reverse scan
for ( var giveUpAt = i1 - 2; ; ) {
if ( t0 === undefined ) {
// before start
this._cachedIndex = 0;
return this.beforeStart_( 0, t, t1 );
}
if ( i1 === giveUpAt ) { break; } // this loop
t1 = t0;
t0 = pp[ -- i1 - 1 ];
if ( t >= t0 ) {
// we have arrived at the sought interval
break seek;
}
}
// prepare binary search on the left side of the index
right = i1;
i1 = 0;
break linear_scan;
}
// the interval is valid
break validate_interval;
} // linear scan
// binary search
while ( i1 < right ) {
var mid = ( i1 + right ) >>> 1;
if ( t < pp[ mid ] ) {
right = mid;
} else {
i1 = mid + 1;
}
}
t1 = pp[ i1 ];
t0 = pp[ i1 - 1 ];
// check boundary cases, again
if ( t0 === undefined ) {
this._cachedIndex = 0;
return this.beforeStart_( 0, t, t1 );
}
if ( t1 === undefined ) {
i1 = pp.length;
this._cachedIndex = i1;
return this.afterEnd_( i1 - 1, t0, t );
}
} // seek
this._cachedIndex = i1;
this.intervalChanged_( i1, t0, t1 );
} // validate_interval
return this.interpolate_( i1, t0, t, t1 );
},
settings: null, // optional, subclass-specific settings structure
// Note: The indirection allows central control of many interpolants.
// --- Protected interface
DefaultSettings_: {},
getSettings_: function () {
return this.settings || this.DefaultSettings_;
},
copySampleValue_: function ( index ) {
// copies a sample value to the result buffer
var result = this.resultBuffer,
values = this.sampleValues,
stride = this.valueSize,
offset = index * stride;
for ( var i = 0; i !== stride; ++ i ) {
result[ i ] = values[ offset + i ];
}
return result;
},
// Template methods for derived classes:
interpolate_: function ( /* i1, t0, t, t1 */ ) {
throw new Error( 'call to abstract method' );
// implementations shall return this.resultBuffer
},
intervalChanged_: function ( /* i1, t0, t1 */ ) {
// empty
}
} );
//!\ DECLARE ALIAS AFTER assign prototype !
Object.assign( Interpolant.prototype, {
//( 0, t, t0 ), returns this.resultBuffer
beforeStart_: Interpolant.prototype.copySampleValue_,
//( N-1, tN-1, t ), returns this.resultBuffer
afterEnd_: Interpolant.prototype.copySampleValue_,
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Fast and simple cubic spline interpolant.
*
* It was derived from a Hermitian construction setting the first derivative
* at each sample position to the linear slope between neighboring positions
* over their parameter interval.
*
* @author tschw
*/
function CubicInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );
this._weightPrev = - 0;
this._offsetPrev = - 0;
this._weightNext = - 0;
this._offsetNext = - 0;
}
CubicInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {
constructor: CubicInterpolant,
DefaultSettings_: {
endingStart: ZeroCurvatureEnding,
endingEnd: ZeroCurvatureEnding
},
intervalChanged_: function ( i1, t0, t1 ) {
var pp = this.parameterPositions,
iPrev = i1 - 2,
iNext = i1 + 1,
tPrev = pp[ iPrev ],
tNext = pp[ iNext ];
if ( tPrev === undefined ) {
switch ( this.getSettings_().endingStart ) {
case ZeroSlopeEnding:
// f'(t0) = 0
iPrev = i1;
tPrev = 2 * t0 - t1;
break;
case WrapAroundEnding:
// use the other end of the curve
iPrev = pp.length - 2;
tPrev = t0 + pp[ iPrev ] - pp[ iPrev + 1 ];
break;
default: // ZeroCurvatureEnding
// f''(t0) = 0 a.k.a. Natural Spline
iPrev = i1;
tPrev = t1;
}
}
if ( tNext === undefined ) {
switch ( this.getSettings_().endingEnd ) {
case ZeroSlopeEnding:
// f'(tN) = 0
iNext = i1;
tNext = 2 * t1 - t0;
break;
case WrapAroundEnding:
// use the other end of the curve
iNext = 1;
tNext = t1 + pp[ 1 ] - pp[ 0 ];
break;
default: // ZeroCurvatureEnding
// f''(tN) = 0, a.k.a. Natural Spline
iNext = i1 - 1;
tNext = t0;
}
}
var halfDt = ( t1 - t0 ) * 0.5,
stride = this.valueSize;
this._weightPrev = halfDt / ( t0 - tPrev );
this._weightNext = halfDt / ( tNext - t1 );
this._offsetPrev = iPrev * stride;
this._offsetNext = iNext * stride;
},
interpolate_: function ( i1, t0, t, t1 ) {
var result = this.resultBuffer,
values = this.sampleValues,
stride = this.valueSize,
o1 = i1 * stride, o0 = o1 - stride,
oP = this._offsetPrev, oN = this._offsetNext,
wP = this._weightPrev, wN = this._weightNext,
p = ( t - t0 ) / ( t1 - t0 ),
pp = p * p,
ppp = pp * p;
// evaluate polynomials
var sP = - wP * ppp + 2 * wP * pp - wP * p;
var s0 = ( 1 + wP ) * ppp + ( - 1.5 - 2 * wP ) * pp + ( - 0.5 + wP ) * p + 1;
var s1 = ( - 1 - wN ) * ppp + ( 1.5 + wN ) * pp + 0.5 * p;
var sN = wN * ppp - wN * pp;
// combine data linearly
for ( var i = 0; i !== stride; ++ i ) {
result[ i ] =
sP * values[ oP + i ] +
s0 * values[ o0 + i ] +
s1 * values[ o1 + i ] +
sN * values[ oN + i ];
}
return result;
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author tschw
*/
function LinearInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );
}
LinearInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {
constructor: LinearInterpolant,
interpolate_: function ( i1, t0, t, t1 ) {
var result = this.resultBuffer,
values = this.sampleValues,
stride = this.valueSize,
offset1 = i1 * stride,
offset0 = offset1 - stride,
weight1 = ( t - t0 ) / ( t1 - t0 ),
weight0 = 1 - weight1;
for ( var i = 0; i !== stride; ++ i ) {
result[ i ] =
values[ offset0 + i ] * weight0 +
values[ offset1 + i ] * weight1;
}
return result;
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
*
* Interpolant that evaluates to the sample value at the position preceeding
* the parameter.
*
* @author tschw
*/
function DiscreteInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );
}
DiscreteInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {
constructor: DiscreteInterpolant,
interpolate_: function ( i1 /*, t0, t, t1 */ ) {
return this.copySampleValue_( i1 - 1 );
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
*
* A timed sequence of keyframes for a specific property.
*
*
* @author Ben Houston / http://clara.io/
* @author David Sarno / http://lighthaus.us/
* @author tschw
*/
function KeyframeTrack( name, times, values, interpolation ) {
if ( name === undefined ) { throw new Error( 'KeyframeTrack: track name is undefined' ); }
if ( times === undefined || times.length === 0 ) { throw new Error( 'KeyframeTrack: no keyframes in track named ' + name ); }
this.name = name;
this.times = AnimationUtils.convertArray( times, this.TimeBufferType );
this.values = AnimationUtils.convertArray( values, this.ValueBufferType );
this.setInterpolation( interpolation || this.DefaultInterpolation );
}
// Static methods
Object.assign( KeyframeTrack, {
// Serialization (in static context, because of constructor invocation
// and automatic invocation of .toJSON):
toJSON: function ( track ) {
var trackType = track.constructor;
var json;
// derived classes can define a static toJSON method
if ( trackType.toJSON !== undefined ) {
json = trackType.toJSON( track );
} else {
// by default, we assume the data can be serialized as-is
json = {
'name': track.name,
'times': AnimationUtils.convertArray( track.times, Array ),
'values': AnimationUtils.convertArray( track.values, Array )
};
var interpolation = track.getInterpolation();
if ( interpolation !== track.DefaultInterpolation ) {
json.interpolation = interpolation;
}
}
json.type = track.ValueTypeName; // mandatory
return json;
}
} );
Object.assign( KeyframeTrack.prototype, {
constructor: KeyframeTrack,
TimeBufferType: Float32Array,
ValueBufferType: Float32Array,
DefaultInterpolation: InterpolateLinear,
InterpolantFactoryMethodDiscrete: function ( result ) {
return new DiscreteInterpolant( this.times, this.values, this.getValueSize(), result );
},
InterpolantFactoryMethodLinear: function ( result ) {
return new LinearInterpolant( this.times, this.values, this.getValueSize(), result );
},
InterpolantFactoryMethodSmooth: function ( result ) {
return new CubicInterpolant( this.times, this.values, this.getValueSize(), result );
},
setInterpolation: function ( interpolation ) {
var factoryMethod;
switch ( interpolation ) {
case InterpolateDiscrete:
factoryMethod = this.InterpolantFactoryMethodDiscrete;
break;
case InterpolateLinear:
factoryMethod = this.InterpolantFactoryMethodLinear;
break;
case InterpolateSmooth:
factoryMethod = this.InterpolantFactoryMethodSmooth;
break;
}
if ( factoryMethod === undefined ) {
var message = "unsupported interpolation for " +
this.ValueTypeName + " keyframe track named " + this.name;
if ( this.createInterpolant === undefined ) {
// fall back to default, unless the default itself is messed up
if ( interpolation !== this.DefaultInterpolation ) {
this.setInterpolation( this.DefaultInterpolation );
} else {
throw new Error( message ); // fatal, in this case
}
}
console.warn( 'KeyframeTrack:', message );
return this;
}
this.createInterpolant = factoryMethod;
return this;
},
getInterpolation: function () {
switch ( this.createInterpolant ) {
case this.InterpolantFactoryMethodDiscrete:
return InterpolateDiscrete;
case this.InterpolantFactoryMethodLinear:
return InterpolateLinear;
case this.InterpolantFactoryMethodSmooth:
return InterpolateSmooth;
}
},
getValueSize: function () {
return this.values.length / this.times.length;
},
// move all keyframes either forwards or backwards in time
shift: function ( timeOffset ) {
if ( timeOffset !== 0.0 ) {
var times = this.times;
for ( var i = 0, n = times.length; i !== n; ++ i ) {
times[ i ] += timeOffset;
}
}
return this;
},
// scale all keyframe times by a factor (useful for frame <-> seconds conversions)
scale: function ( timeScale ) {
if ( timeScale !== 1.0 ) {
var times = this.times;
for ( var i = 0, n = times.length; i !== n; ++ i ) {
times[ i ] *= timeScale;
}
}
return this;
},
// removes keyframes before and after animation without changing any values within the range [startTime, endTime].
// IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values
trim: function ( startTime, endTime ) {
var times = this.times,
nKeys = times.length,
from = 0,
to = nKeys - 1;
while ( from !== nKeys && times[ from ] < startTime ) {
++ from;
}
while ( to !== - 1 && times[ to ] > endTime ) {
-- to;
}
++ to; // inclusive -> exclusive bound
if ( from !== 0 || to !== nKeys ) {
// empty tracks are forbidden, so keep at least one keyframe
if ( from >= to ) { to = Math.max( to, 1 ), from = to - 1; }
var stride = this.getValueSize();
this.times = AnimationUtils.arraySlice( times, from, to );
this.values = AnimationUtils.arraySlice( this.values, from * stride, to * stride );
}
return this;
},
// ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable
validate: function () {
var valid = true;
var valueSize = this.getValueSize();
if ( valueSize - Math.floor( valueSize ) !== 0 ) {
console.error( 'KeyframeTrack: Invalid value size in track.', this );
valid = false;
}
var times = this.times,
values = this.values,
nKeys = times.length;
if ( nKeys === 0 ) {
console.error( 'KeyframeTrack: Track is empty.', this );
valid = false;
}
var prevTime = null;
for ( var i = 0; i !== nKeys; i ++ ) {
var currTime = times[ i ];
if ( typeof currTime === 'number' && isNaN( currTime ) ) {
console.error( 'KeyframeTrack: Time is not a valid number.', this, i, currTime );
valid = false;
break;
}
if ( prevTime !== null && prevTime > currTime ) {
console.error( 'KeyframeTrack: Out of order keys.', this, i, currTime, prevTime );
valid = false;
break;
}
prevTime = currTime;
}
if ( values !== undefined ) {
if ( AnimationUtils.isTypedArray( values ) ) {
for ( var i = 0, n = values.length; i !== n; ++ i ) {
var value = values[ i ];
if ( isNaN( value ) ) {
console.error( 'KeyframeTrack: Value is not a valid number.', this, i, value );
valid = false;
break;
}
}
}
}
return valid;
},
// removes equivalent sequential keys as common in morph target sequences
// (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)
optimize: function () {
// times or values may be shared with other tracks, so overwriting is unsafe
var times = AnimationUtils.arraySlice( this.times ),
values = AnimationUtils.arraySlice( this.values ),
stride = this.getValueSize(),
smoothInterpolation = this.getInterpolation() === InterpolateSmooth,
writeIndex = 1,
lastIndex = times.length - 1;
for ( var i = 1; i < lastIndex; ++ i ) {
var keep = false;
var time = times[ i ];
var timeNext = times[ i + 1 ];
// remove adjacent keyframes scheduled at the same time
if ( time !== timeNext && ( i !== 1 || time !== time[ 0 ] ) ) {
if ( ! smoothInterpolation ) {
// remove unnecessary keyframes same as their neighbors
var offset = i * stride,
offsetP = offset - stride,
offsetN = offset + stride;
for ( var j = 0; j !== stride; ++ j ) {
var value = values[ offset + j ];
if ( value !== values[ offsetP + j ] ||
value !== values[ offsetN + j ] ) {
keep = true;
break;
}
}
} else {
keep = true;
}
}
// in-place compaction
if ( keep ) {
if ( i !== writeIndex ) {
times[ writeIndex ] = times[ i ];
var readOffset = i * stride,
writeOffset = writeIndex * stride;
for ( var j = 0; j !== stride; ++ j ) {
values[ writeOffset + j ] = values[ readOffset + j ];
}
}
++ writeIndex;
}
}
// flush last keyframe (compaction looks ahead)
if ( lastIndex > 0 ) {
times[ writeIndex ] = times[ lastIndex ];
for ( var readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++ j ) {
values[ writeOffset + j ] = values[ readOffset + j ];
}
++ writeIndex;
}
if ( writeIndex !== times.length ) {
this.times = AnimationUtils.arraySlice( times, 0, writeIndex );
this.values = AnimationUtils.arraySlice( values, 0, writeIndex * stride );
} else {
this.times = times;
this.values = values;
}
return this;
},
clone: function () {
var times = AnimationUtils.arraySlice( this.times, 0 );
var values = AnimationUtils.arraySlice( this.values, 0 );
var TypedKeyframeTrack = this.constructor;
var track = new TypedKeyframeTrack( this.name, times, values );
// Interpolant argument to constructor is not saved, so copy the factory method directly.
track.createInterpolant = this.createInterpolant;
return track;
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
*
* A Track of Boolean keyframe values.
*
*
* @author Ben Houston / http://clara.io/
* @author David Sarno / http://lighthaus.us/
* @author tschw
*/
function BooleanKeyframeTrack( name, times, values ) {
KeyframeTrack.call( this, name, times, values );
}
BooleanKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {
constructor: BooleanKeyframeTrack,
ValueTypeName: 'bool',
ValueBufferType: Array,
DefaultInterpolation: InterpolateDiscrete,
InterpolantFactoryMethodLinear: undefined,
InterpolantFactoryMethodSmooth: undefined
// Note: Actually this track could have a optimized / compressed
// representation of a single value and a custom interpolant that
// computes "firstValue ^ isOdd( index )".
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
*
* A Track of keyframe values that represent color.
*
*
* @author Ben Houston / http://clara.io/
* @author David Sarno / http://lighthaus.us/
* @author tschw
*/
function ColorKeyframeTrack( name, times, values, interpolation ) {
KeyframeTrack.call( this, name, times, values, interpolation );
}
ColorKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {
constructor: ColorKeyframeTrack,
ValueTypeName: 'color'
// ValueBufferType is inherited
// DefaultInterpolation is inherited
// Note: Very basic implementation and nothing special yet.
// However, this is the place for color space parameterization.
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
*
* A Track of numeric keyframe values.
*
* @author Ben Houston / http://clara.io/
* @author David Sarno / http://lighthaus.us/
* @author tschw
*/
function NumberKeyframeTrack( name, times, values, interpolation ) {
KeyframeTrack.call( this, name, times, values, interpolation );
}
NumberKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {
constructor: NumberKeyframeTrack,
ValueTypeName: 'number'
// ValueBufferType is inherited
// DefaultInterpolation is inherited
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WARNING: This file was auto-generated, any change will be overridden in next release. Please use configs/es6.conf.js then run "npm run convert". //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author alteredq / http://alteredqualia.com/
* @author mrdoob / http://mrdoob.com/
* @author WestLangley / http://github.com/WestLangley
* @author thezwap
*/
var _lut = [];
for ( var i = 0; i < 256; i ++ ) {
_lut[ i ] = ( i < 16 ? '0' : '' ) + ( i ).toString( 16 );
}
var MathUtils = {
DEG2RAD: Math.PI / 180,
RAD2DEG: 180 / Math.PI,
generateUUID: function () {
// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
var d0 = Math.random() * 0xffffffff | 0;
var d1 = Math.random() * 0xffffffff | 0;
var d2 = Math.random() * 0xffffffff | 0;
var d3 = Math.random() * 0xffffffff | 0;
var uuid = _lut[ d0 & 0xff ] + _lut[ d0 >> 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +
_lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +
_lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
_lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];
// .toUpperCase() here flattens concatenated strings to save heap memory space.
return uuid.toUpperCase();
},
clamp: function ( value, min, max ) {
return Math.max( min, Math.min( max, value ) );
},
// compute euclidian modulo of m % n
// https://en.wikipedia.org/wiki/Modulo_operation
euclideanModulo: function ( n, m ) {
return ( ( n % m ) + m ) % m;
},
// Linear mapping from range <a1, a2> to range <b1, b2>
mapLinear: function ( x, a1, a2, b1, b2 ) {
return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );
},
// https://en.wikipedia.org/wiki/Linear_interpolation
lerp: function ( x, y, t ) {
return ( 1 - t ) * x + t * y;
},
// http://en.wikipedia.org/wiki/Smoothstep
smoothstep: function ( x, min, max ) {
if ( x <= min ) { return 0; }
if ( x >= max ) { return 1; }
x = ( x - min ) / ( max - min );
return x * x * ( 3 - 2 * x );
},
smootherstep: function ( x, min, max ) {
if ( x <= min ) { return 0; }
if ( x >= max ) { return 1; }
x = ( x - min ) / ( max - min );
return x * x * x * ( x * ( x * 6 - 15 ) + 10 );
},
// Random integer from <low, high> interval
randInt: function ( low, high ) {
return low + Math.floor( Math.random() * ( high - low + 1 ) );
},
// Random float from <low, high> interval
randFloat: function ( low, high ) {
return low + Math.random() * ( high - low );
},
// Random float from <-range/2, range/2> interval
randFloatSpread: function ( range ) {
return range * ( 0.5 - Math.random() );
},
degToRad: function ( degrees ) {
return degrees * MathUtils.DEG2RAD;
},
radToDeg: function ( radians ) {
return radians * MathUtils.RAD2DEG;
},
isPowerOfTwo: function ( value ) {
return ( value & ( value - 1 ) ) === 0 && value !== 0;
},
ceilPowerOfTwo: function ( value ) {
return Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );
},
floorPowerOfTwo: function ( value ) {
return Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );
},
setQuaternionFromProperEuler: function ( q, a, b, c, order ) {
// Intrinsic Proper Euler Angles - see https://en.wikipedia.org/wiki/Euler_angles
// rotations are applied to the axes in the order specified by 'order'
// rotation by angle 'a' is applied first, then by angle 'b', then by angle 'c'
// angles are in radians
var cos = Math.cos;
var sin = Math.sin;
var c2 = cos( b / 2 );
var s2 = sin( b / 2 );
var c13 = cos( ( a + c ) / 2 );
var s13 = sin( ( a + c ) / 2 );
var c1_3 = cos( ( a - c ) / 2 );
var s1_3 = sin( ( a - c ) / 2 );
var c3_1 = cos( ( c - a ) / 2 );
var s3_1 = sin( ( c - a ) / 2 );
if ( order === 'XYX' ) {
q.set( c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13 );
} else if ( order === 'YZY' ) {
q.set( s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13 );
} else if ( order === 'ZXZ' ) {
q.set( s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13 );
} else if ( order === 'XZX' ) {
q.set( c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13 );
} else if ( order === 'YXY' ) {
q.set( s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13 );
} else if ( order === 'ZYZ' ) {
q.set( s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13 );
} else {
console.warn( 'MathUtils: .setQuaternionFromProperEuler() encountered an unknown order.' );
}
}
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author mikael emtinger / http://gomo.se/
* @author alteredq / http://alteredqualia.com/
* @author WestLangley / http://github.com/WestLangley
* @author bhouston / http://clara.io
*/
function Quaternion( x, y, z, w ) {
this._x = x || 0;
this._y = y || 0;
this._z = z || 0;
this._w = ( w !== undefined ) ? w : 1;
}
Object.assign( Quaternion, {
slerp: function ( qa, qb, qm, t ) {
return qm.copy( qa ).slerp( qb, t );
},
slerpFlat: function ( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {
// fuzz-free, array-based Quaternion SLERP operation
var x0 = src0[ srcOffset0 + 0 ],
y0 = src0[ srcOffset0 + 1 ],
z0 = src0[ srcOffset0 + 2 ],
w0 = src0[ srcOffset0 + 3 ],
x1 = src1[ srcOffset1 + 0 ],
y1 = src1[ srcOffset1 + 1 ],
z1 = src1[ srcOffset1 + 2 ],
w1 = src1[ srcOffset1 + 3 ];
if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {
var s = 1 - t,
cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
dir = ( cos >= 0 ? 1 : - 1 ),
sqrSin = 1 - cos * cos;
// Skip the Slerp for tiny steps to avoid numeric problems:
if ( sqrSin > Number.EPSILON ) {
var sin = Math.sqrt( sqrSin ),
len = Math.atan2( sin, cos * dir );
s = Math.sin( s * len ) / sin;
t = Math.sin( t * len ) / sin;
}
var tDir = t * dir;
x0 = x0 * s + x1 * tDir;
y0 = y0 * s + y1 * tDir;
z0 = z0 * s + z1 * tDir;
w0 = w0 * s + w1 * tDir;
// Normalize in case we just did a lerp:
if ( s === 1 - t ) {
var f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );
x0 *= f;
y0 *= f;
z0 *= f;
w0 *= f;
}
}
dst[ dstOffset ] = x0;
dst[ dstOffset + 1 ] = y0;
dst[ dstOffset + 2 ] = z0;
dst[ dstOffset + 3 ] = w0;
}
} );
Object.defineProperties( Quaternion.prototype, {
x: {
get: function () {
return this._x;
},
set: function ( value ) {
this._x = value;
this._onChangeCallback();
}
},
y: {
get: function () {
return this._y;
},
set: function ( value ) {
this._y = value;
this._onChangeCallback();
}
},
z: {
get: function () {
return this._z;
},
set: function ( value ) {
this._z = value;
this._onChangeCallback();
}
},
w: {
get: function () {
return this._w;
},
set: function ( value ) {
this._w = value;
this._onChangeCallback();
}
}
} );
Object.assign( Quaternion.prototype, {
isQuaternion: true,
set: function ( x, y, z, w ) {
this._x = x;
this._y = y;
this._z = z;
this._w = w;
this._onChangeCallback();
return this;
},
clone: function () {
return new this.constructor( this._x, this._y, this._z, this._w );
},
copy: function ( quaternion ) {
this._x = quaternion.x;
this._y = quaternion.y;
this._z = quaternion.z;
this._w = quaternion.w;
this._onChangeCallback();
return this;
},
setFromEuler: function ( euler, update ) {
if ( ! ( euler && euler.isEuler ) ) {
throw new Error( 'Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.' );
}
var x = euler._x, y = euler._y, z = euler._z, order = euler.order;
// http://www.mathworks.com/matlabcentral/fileexchange/
// 20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
// content/SpinCalc.m
var cos = Math.cos;
var sin = Math.sin;
var c1 = cos( x / 2 );
var c2 = cos( y / 2 );
var c3 = cos( z / 2 );
var s1 = sin( x / 2 );
var s2 = sin( y / 2 );
var s3 = sin( z / 2 );
if ( order === 'XYZ' ) {
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;
} else if ( order === 'YXZ' ) {
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;
} else if ( order === 'ZXY' ) {
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;
} else if ( order === 'ZYX' ) {
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;
} else if ( order === 'YZX' ) {
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;
} else if ( order === 'XZY' ) {
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;
}
if ( update !== false ) { this._onChangeCallback(); }
return this;
},
setFromAxisAngle: function ( axis, angle ) {
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
// assumes axis is normalized
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 );
this._onChangeCallback();
return this;
},
setFromRotationMatrix: function ( m ) {
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
var te = m.elements,
m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ],
trace = m11 + m22 + m33,
s;
if ( trace > 0 ) {
s = 0.5 / Math.sqrt( trace + 1.0 );
this._w = 0.25 / s;
this._x = ( m32 - m23 ) * s;
this._y = ( m13 - m31 ) * s;
this._z = ( m21 - m12 ) * s;
} else if ( m11 > m22 && m11 > m33 ) {
s = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 );
this._w = ( m32 - m23 ) / s;
this._x = 0.25 * s;
this._y = ( m12 + m21 ) / s;
this._z = ( m13 + m31 ) / s;
} else if ( m22 > m33 ) {
s = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 );
this._w = ( m13 - m31 ) / s;
this._x = ( m12 + m21 ) / s;
this._y = 0.25 * s;
this._z = ( m23 + m32 ) / s;
} else {
s = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 );
this._w = ( m21 - m12 ) / s;
this._x = ( m13 + m31 ) / s;
this._y = ( m23 + m32 ) / s;
this._z = 0.25 * s;
}
this._onChangeCallback();
return this;
},
setFromUnitVectors: function ( vFrom, vTo ) {
// assumes direction vectors vFrom and vTo are normalized
var EPS = 0.000001;
var r = vFrom.dot( vTo ) + 1;
if ( r < EPS ) {
r = 0;
if ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {
this._x = - vFrom.y;
this._y = vFrom.x;
this._z = 0;
this._w = r;
} else {
this._x = 0;
this._y = - vFrom.z;
this._z = vFrom.y;
this._w = r;
}
} else {
// crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
this._w = r;
}
return this.normalize();
},
angleTo: function ( q ) {
return 2 * Math.acos( Math.abs( MathUtils.clamp( this.dot( q ), - 1, 1 ) ) );
},
rotateTowards: function ( q, step ) {
var angle = this.angleTo( q );
if ( angle === 0 ) { return this; }
var t = Math.min( 1, step / angle );
this.slerp( q, t );
return this;
},
inverse: function () {
// quaternion is assumed to have unit length
return this.conjugate();
},
conjugate: function () {
this._x *= - 1;
this._y *= - 1;
this._z *= - 1;
this._onChangeCallback();
return this;
},
dot: function ( v ) {
return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
},
lengthSq: function () {
return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
},
length: function () {
return Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w );
},
normalize: function () {
var l = this.length();
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;
}
this._onChangeCallback();
return this;
},
multiply: function ( q, p ) {
if ( p !== undefined ) {
console.warn( 'Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.' );
return this.multiplyQuaternions( q, p );
}
return this.multiplyQuaternions( this, q );
},
premultiply: function ( q ) {
return this.multiplyQuaternions( q, this );
},
multiplyQuaternions: function ( a, b ) {
// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
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;
this._onChangeCallback();
return this;
},
slerp: function ( 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;
// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
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 sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
if ( sqrSinHalfTheta <= Number.EPSILON ) {
var s = 1 - t;
this._w = s * w + t * this._w;
this._x = s * x + t * this._x;
this._y = s * y + t * this._y;
this._z = s * z + t * this._z;
this.normalize();
this._onChangeCallback();
return this;
}
var sinHalfTheta = Math.sqrt( sqrSinHalfTheta );
var halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );
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 );
this._onChangeCallback();
return this;
},
equals: function ( quaternion ) {
return ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );
},
fromArray: function ( array, offset ) {
if ( offset === undefined ) { offset = 0; }
this._x = array[ offset ];
this._y = array[ offset + 1 ];
this._z = array[ offset + 2 ];
this._w = array[ offset + 3 ];
this._onChangeCallback();
return this;
},
toArray: function ( array, offset ) {
if ( array === undefined ) { array = []; }
if ( offset === undefined ) { offset = 0; }
array[ offset ] = this._x;
array[ offset + 1 ] = this._y;
array[ offset + 2 ] = this._z;
array[ offset + 3 ] = this._w;
return array;
},
_onChange: function ( callback ) {
this._onChangeCallback = callback;
return this;
},
_onChangeCallback: function () {}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* Spherical linear unit quaternion interpolant.
*
* @author tschw
*/
function QuaternionLinearInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );
}
QuaternionLinearInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {
constructor: QuaternionLinearInterpolant,
interpolate_: function ( i1, t0, t, t1 ) {
var result = this.resultBuffer,
values = this.sampleValues,
stride = this.valueSize,
offset = i1 * stride,
alpha = ( t - t0 ) / ( t1 - t0 );
for ( var end = offset + stride; offset !== end; offset += 4 ) {
Quaternion.slerpFlat( result, 0, values, offset - stride, values, offset, alpha );
}
return result;
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
*
* A Track of quaternion keyframe values.
*
* @author Ben Houston / http://clara.io/
* @author David Sarno / http://lighthaus.us/
* @author tschw
*/
function QuaternionKeyframeTrack( name, times, values, interpolation ) {
KeyframeTrack.call( this, name, times, values, interpolation );
}
QuaternionKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {
constructor: QuaternionKeyframeTrack,
ValueTypeName: 'quaternion',
// ValueBufferType is inherited
DefaultInterpolation: InterpolateLinear,
InterpolantFactoryMethodLinear: function ( result ) {
return new QuaternionLinearInterpolant( this.times, this.values, this.getValueSize(), result );
},
InterpolantFactoryMethodSmooth: undefined // not yet implemented
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
*
* A Track that interpolates Strings
*
*
* @author Ben Houston / http://clara.io/
* @author David Sarno / http://lighthaus.us/
* @author tschw
*/
function StringKeyframeTrack( name, times, values, interpolation ) {
KeyframeTrack.call( this, name, times, values, interpolation );
}
StringKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {
constructor: StringKeyframeTrack,
ValueTypeName: 'string',
ValueBufferType: Array,
DefaultInterpolation: InterpolateDiscrete,
InterpolantFactoryMethodLinear: undefined,
InterpolantFactoryMethodSmooth: undefined
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
*
* A Track of vectored keyframe values.
*
*
* @author Ben Houston / http://clara.io/
* @author David Sarno / http://lighthaus.us/
* @author tschw
*/
function VectorKeyframeTrack( name, times, values, interpolation ) {
KeyframeTrack.call( this, name, times, values, interpolation );
}
VectorKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {
constructor: VectorKeyframeTrack,
ValueTypeName: 'vector'
// ValueBufferType is inherited
// DefaultInterpolation is inherited
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
*
* Reusable set of Tracks that represent an animation.
*
* @author Ben Houston / http://clara.io/
* @author David Sarno / http://lighthaus.us/
*/
function AnimationClip( name, duration, tracks ) {
this.name = name;
this.tracks = tracks;
this.duration = ( duration !== undefined ) ? duration : - 1;
this.uuid = MathUtils.generateUUID();
// this means it should figure out its duration by scanning the tracks
if ( this.duration < 0 ) {
this.resetDuration();
}
}
function getTrackTypeForValueTypeName( typeName ) {
switch ( typeName.toLowerCase() ) {
case 'scalar':
case 'double':
case 'float':
case 'number':
case 'integer':
return NumberKeyframeTrack;
case 'vector':
case 'vector2':
case 'vector3':
case 'vector4':
return VectorKeyframeTrack;
case 'color':
return ColorKeyframeTrack;
case 'quaternion':
return QuaternionKeyframeTrack;
case 'bool':
case 'boolean':
return BooleanKeyframeTrack;
case 'string':
return StringKeyframeTrack;
}
throw new Error( 'KeyframeTrack: Unsupported typeName: ' + typeName );
}
function parseKeyframeTrack( json ) {
if ( json.type === undefined ) {
throw new Error( 'KeyframeTrack: track type undefined, can not parse' );
}
var trackType = getTrackTypeForValueTypeName( json.type );
if ( json.times === undefined ) {
var times = [], values = [];
AnimationUtils.flattenJSON( json.keys, times, values, 'value' );
json.times = times;
json.values = values;
}
// derived classes can define a static parse method
if ( trackType.parse !== undefined ) {
return trackType.parse( json );
} else {
// by default, we assume a constructor compatible with the base
return new trackType( json.name, json.times, json.values, json.interpolation );
}
}
Object.assign( AnimationClip, {
parse: function ( json ) {
var tracks = [],
jsonTracks = json.tracks,
frameTime = 1.0 / ( json.fps || 1.0 );
for ( var i = 0, n = jsonTracks.length; i !== n; ++ i ) {
tracks.push( parseKeyframeTrack( jsonTracks[ i ] ).scale( frameTime ) );
}
return new AnimationClip( json.name, json.duration, tracks );
},
toJSON: function ( clip ) {
var tracks = [],
clipTracks = clip.tracks;
var json = {
'name': clip.name,
'duration': clip.duration,
'tracks': tracks,
'uuid': clip.uuid
};
for ( var i = 0, n = clipTracks.length; i !== n; ++ i ) {
tracks.push( KeyframeTrack.toJSON( clipTracks[ i ] ) );
}
return json;
},
CreateFromMorphTargetSequence: function ( name, morphTargetSequence, fps, noLoop ) {
var numMorphTargets = morphTargetSequence.length;
var tracks = [];
for ( var i = 0; i < numMorphTargets; i ++ ) {
var times = [];
var values = [];
times.push(
( i + numMorphTargets - 1 ) % numMorphTargets,
i,
( i + 1 ) % numMorphTargets );
values.push( 0, 1, 0 );
var order = AnimationUtils.getKeyframeOrder( times );
times = AnimationUtils.sortedArray( times, 1, order );
values = AnimationUtils.sortedArray( values, 1, order );
// if there is a key at the first frame, duplicate it as the
// last frame as well for perfect loop.
if ( ! noLoop && times[ 0 ] === 0 ) {
times.push( numMorphTargets );
values.push( values[ 0 ] );
}
tracks.push(
new NumberKeyframeTrack(
'.morphTargetInfluences[' + morphTargetSequence[ i ].name + ']',
times, values
).scale( 1.0 / fps ) );
}
return new AnimationClip( name, - 1, tracks );
},
findByName: function ( objectOrClipArray, name ) {
var clipArray = objectOrClipArray;
if ( ! Array.isArray( objectOrClipArray ) ) {
var o = objectOrClipArray;
clipArray = o.geometry && o.geometry.animations || o.animations;
}
for ( var i = 0; i < clipArray.length; i ++ ) {
if ( clipArray[ i ].name === name ) {
return clipArray[ i ];
}
}
return null;
},
CreateClipsFromMorphTargetSequences: function ( morphTargets, fps, noLoop ) {
var animationToMorphTargets = {};
// tested with https://regex101.com/ on trick sequences
// such flamingo_flyA_003, flamingo_run1_003, crdeath0059
var pattern = /^([\w-]*?)([\d]+)$/;
// sort morph target names into animation groups based
// patterns like Walk_001, Walk_002, Run_001, Run_002
for ( var i = 0, il = morphTargets.length; i < il; i ++ ) {
var morphTarget = morphTargets[ i ];
var parts = morphTarget.name.match( pattern );
if ( parts && parts.length > 1 ) {
var name = parts[ 1 ];
var animationMorphTargets = animationToMorphTargets[ name ];
if ( ! animationMorphTargets ) {
animationToMorphTargets[ name ] = animationMorphTargets = [];
}
animationMorphTargets.push( morphTarget );
}
}
var clips = [];
for ( var name in animationToMorphTargets ) {
clips.push( AnimationClip.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) );
}
return clips;
},
// parse the animation.hierarchy format
parseAnimation: function ( animation, bones ) {
if ( ! animation ) {
console.error( 'AnimationClip: No animation in JSONLoader data.' );
return null;
}
var addNonemptyTrack = function ( trackType, trackName, animationKeys, propertyName, destTracks ) {
// only return track if there are actually keys.
if ( animationKeys.length !== 0 ) {
var times = [];
var values = [];
AnimationUtils.flattenJSON( animationKeys, times, values, propertyName );
// empty keys are filtered out, so check again
if ( times.length !== 0 ) {
destTracks.push( new trackType( trackName, times, values ) );
}
}
};
var tracks = [];
var clipName = animation.name || 'default';
// automatic length determination in AnimationClip.
var duration = animation.length || - 1;
var fps = animation.fps || 30;
var hierarchyTracks = animation.hierarchy || [];
for ( var h = 0; h < hierarchyTracks.length; h ++ ) {
var animationKeys = hierarchyTracks[ h ].keys;
// skip empty tracks
if ( ! animationKeys || animationKeys.length === 0 ) { continue; }
// process morph targets
if ( animationKeys[ 0 ].morphTargets ) {
// figure out all morph targets used in this track
var morphTargetNames = {};
for ( var k = 0; k < animationKeys.length; k ++ ) {
if ( animationKeys[ k ].morphTargets ) {
for ( var m = 0; m < animationKeys[ k ].morphTargets.length; m ++ ) {
morphTargetNames[ animationKeys[ k ].morphTargets[ m ] ] = - 1;
}
}
}
// create a track for each morph target with all zero
// morphTargetInfluences except for the keys in which
// the morphTarget is named.
for ( var morphTargetName in morphTargetNames ) {
var times = [];
var values = [];
for ( var m = 0; m !== animationKeys[ k ].morphTargets.length; ++ m ) {
var animationKey = animationKeys[ k ];
times.push( animationKey.time );
values.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 );
}
tracks.push( new NumberKeyframeTrack( '.morphTargetInfluence[' + morphTargetName + ']', times, values ) );
}
duration = morphTargetNames.length * ( fps || 1.0 );
} else {
// ...assume skeletal animation
var boneName = '.bones[' + bones[ h ].name + ']';
addNonemptyTrack(
VectorKeyframeTrack, boneName + '.position',
animationKeys, 'pos', tracks );
addNonemptyTrack(
QuaternionKeyframeTrack, boneName + '.quaternion',
animationKeys, 'rot', tracks );
addNonemptyTrack(
VectorKeyframeTrack, boneName + '.scale',
animationKeys, 'scl', tracks );
}
}
if ( tracks.length === 0 ) {
return null;
}
var clip = new AnimationClip( clipName, duration, tracks );
return clip;
}
} );
Object.assign( AnimationClip.prototype, {
resetDuration: function () {
var tracks = this.tracks, duration = 0;
for ( var i = 0, n = tracks.length; i !== n; ++ i ) {
var track = this.tracks[ i ];
duration = Math.max( duration, track.times[ track.times.length - 1 ] );
}
this.duration = duration;
return this;
},
trim: function () {
for ( var i = 0; i < this.tracks.length; i ++ ) {
this.tracks[ i ].trim( 0, this.duration );
}
return this;
},
validate: function () {
var valid = true;
for ( var i = 0; i < this.tracks.length; i ++ ) {
valid = valid && this.tracks[ i ].validate();
}
return valid;
},
optimize: function () {
for ( var i = 0; i < this.tracks.length; i ++ ) {
this.tracks[ i ].optimize();
}
return this;
},
clone: function () {
var tracks = [];
for ( var i = 0; i < this.tracks.length; i ++ ) {
tracks.push( this.tracks[ i ].clone() );
}
return new AnimationClip( this.name, this.duration, tracks );
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author mrdoob / http://mrdoob.com/
* @author kile / http://kile.stravaganza.org/
* @author philogb / http://blog.thejit.org/
* @author mikael emtinger / http://gomo.se/
* @author egraether / http://egraether.com/
* @author WestLangley / http://github.com/WestLangley
*/
var _vector = new Vector3();
var _quaternion = new Quaternion();
function Vector3( x, y, z ) {
this.x = x || 0;
this.y = y || 0;
this.z = z || 0;
}
Object.assign( Vector3.prototype, {
isVector3: true,
set: function ( x, y, z ) {
this.x = x;
this.y = y;
this.z = z;
return this;
},
setScalar: function ( scalar ) {
this.x = scalar;
this.y = scalar;
this.z = scalar;
return this;
},
setX: function ( x ) {
this.x = x;
return this;
},
setY: function ( y ) {
this.y = y;
return this;
},
setZ: function ( z ) {
this.z = z;
return this;
},
setComponent: function ( index, value ) {
switch ( index ) {
case 0: this.x = value; break;
case 1: this.y = value; break;
case 2: this.z = value; break;
default: throw new Error( 'index is out of range: ' + index );
}
return this;
},
getComponent: function ( index ) {
switch ( index ) {
case 0: return this.x;
case 1: return this.y;
case 2: return this.z;
default: throw new Error( 'index is out of range: ' + index );
}
},
clone: function () {
return new this.constructor( this.x, this.y, this.z );
},
copy: function ( v ) {
this.x = v.x;
this.y = v.y;
this.z = v.z;
return this;
},
add: function ( v, w ) {
if ( w !== undefined ) {
console.warn( 'Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
return this.addVectors( v, w );
}
this.x += v.x;
this.y += v.y;
this.z += v.z;
return this;
},
addScalar: function ( s ) {
this.x += s;
this.y += s;
this.z += s;
return this;
},
addVectors: function ( a, b ) {
this.x = a.x + b.x;
this.y = a.y + b.y;
this.z = a.z + b.z;
return this;
},
addScaledVector: function ( v, s ) {
this.x += v.x * s;
this.y += v.y * s;
this.z += v.z * s;
return this;
},
sub: function ( v, w ) {
if ( w !== undefined ) {
console.warn( 'Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
return this.subVectors( v, w );
}
this.x -= v.x;
this.y -= v.y;
this.z -= v.z;
return this;
},
subScalar: function ( s ) {
this.x -= s;
this.y -= s;
this.z -= s;
return this;
},
subVectors: function ( a, b ) {
this.x = a.x - b.x;
this.y = a.y - b.y;
this.z = a.z - b.z;
return this;
},
multiply: function ( v, w ) {
if ( w !== undefined ) {
console.warn( 'Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.' );
return this.multiplyVectors( v, w );
}
this.x *= v.x;
this.y *= v.y;
this.z *= v.z;
return this;
},
multiplyScalar: function ( scalar ) {
this.x *= scalar;
this.y *= scalar;
this.z *= scalar;
return this;
},
multiplyVectors: function ( a, b ) {
this.x = a.x * b.x;
this.y = a.y * b.y;
this.z = a.z * b.z;
return this;
},
applyEuler: function ( euler ) {
if ( ! ( euler && euler.isEuler ) ) {
console.error( 'Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.' );
}
return this.applyQuaternion( _quaternion.setFromEuler( euler ) );
},
applyAxisAngle: function ( axis, angle ) {
return this.applyQuaternion( _quaternion.setFromAxisAngle( axis, angle ) );
},
applyMatrix3: function ( m ) {
var x = this.x, y = this.y, z = this.z;
var e = m.elements;
this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;
this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;
this.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;
return this;
},
applyNormalMatrix: function ( m ) {
return this.applyMatrix3( m ).normalize();
},
applyMatrix4: function ( m ) {
var x = this.x, y = this.y, z = this.z;
var e = m.elements;
var w = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] );
this.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * w;
this.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * w;
this.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * w;
return this;
},
applyQuaternion: function ( q ) {
var x = this.x, y = this.y, z = this.z;
var qx = q.x, qy = q.y, qz = q.z, qw = q.w;
// calculate quat * vector
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;
// calculate result * inverse quat
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;
},
project: function ( camera ) {
return this.applyMatrix4( camera.matrixWorldInverse ).applyMatrix4( camera.projectionMatrix );
},
unproject: function ( camera ) {
return this.applyMatrix4( camera.projectionMatrixInverse ).applyMatrix4( camera.matrixWorld );
},
transformDirection: function ( m ) {
// input: Matrix4 affine matrix
// vector interpreted as a direction
var x = this.x, y = this.y, z = this.z;
var e = m.elements;
this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;
this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;
this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;
return this.normalize();
},
divide: function ( v ) {
this.x /= v.x;
this.y /= v.y;
this.z /= v.z;
return this;
},
divideScalar: function ( scalar ) {
return this.multiplyScalar( 1 / scalar );
},
min: function ( v ) {
this.x = Math.min( this.x, v.x );
this.y = Math.min( this.y, v.y );
this.z = Math.min( this.z, v.z );
return this;
},
max: function ( v ) {
this.x = Math.max( this.x, v.x );
this.y = Math.max( this.y, v.y );
this.z = Math.max( this.z, v.z );
return this;
},
clamp: function ( min, max ) {
// assumes min < max, componentwise
this.x = Math.max( min.x, Math.min( max.x, this.x ) );
this.y = Math.max( min.y, Math.min( max.y, this.y ) );
this.z = Math.max( min.z, Math.min( max.z, this.z ) );
return this;
},
clampScalar: function ( minVal, maxVal ) {
this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
this.z = Math.max( minVal, Math.min( maxVal, this.z ) );
return this;
},
clampLength: function ( min, max ) {
var length = this.length();
return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
},
floor: function () {
this.x = Math.floor( this.x );
this.y = Math.floor( this.y );
this.z = Math.floor( this.z );
return this;
},
ceil: function () {
this.x = Math.ceil( this.x );
this.y = Math.ceil( this.y );
this.z = Math.ceil( this.z );
return this;
},
round: function () {
this.x = Math.round( this.x );
this.y = Math.round( this.y );
this.z = Math.round( this.z );
return this;
},
roundToZero: function () {
this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
return this;
},
negate: function () {
this.x = - this.x;
this.y = - this.y;
this.z = - this.z;
return this;
},
dot: function ( v ) {
return this.x * v.x + this.y * v.y + this.z * v.z;
},
// TODO lengthSquared?
lengthSq: function () {
return this.x * this.x + this.y * this.y + this.z * this.z;
},
length: function () {
return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );
},
manhattanLength: function () {
return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );
},
normalize: function () {
return this.divideScalar( this.length() || 1 );
},
setLength: function ( length ) {
return this.normalize().multiplyScalar( length );
},
lerp: function ( v, alpha ) {
this.x += ( v.x - this.x ) * alpha;
this.y += ( v.y - this.y ) * alpha;
this.z += ( v.z - this.z ) * alpha;
return this;
},
lerpVectors: function ( v1, v2, alpha ) {
return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
},
cross: function ( v, w ) {
if ( w !== undefined ) {
console.warn( 'Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.' );
return this.crossVectors( v, w );
}
return this.crossVectors( this, v );
},
crossVectors: function ( 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;
},
projectOnVector: function ( v ) {
var denominator = v.lengthSq();
if ( denominator === 0 ) { return this.set( 0, 0, 0 ); }
var scalar = v.dot( this ) / denominator;
return this.copy( v ).multiplyScalar( scalar );
},
projectOnPlane: function ( planeNormal ) {
_vector.copy( this ).projectOnVector( planeNormal );
return this.sub( _vector );
},
reflect: function ( normal ) {
// reflect incident vector off plane orthogonal to normal
// normal is assumed to have unit length
return this.sub( _vector.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );
},
angleTo: function ( v ) {
var denominator = Math.sqrt( this.lengthSq() * v.lengthSq() );
if ( denominator === 0 ) { return Math.PI / 2; }
var theta = this.dot( v ) / denominator;
// clamp, to handle numerical problems
return Math.acos( MathUtils.clamp( theta, - 1, 1 ) );
},
distanceTo: function ( v ) {
return Math.sqrt( this.distanceToSquared( v ) );
},
distanceToSquared: function ( v ) {
var dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
return dx * dx + dy * dy + dz * dz;
},
manhattanDistanceTo: function ( v ) {
return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ) + Math.abs( this.z - v.z );
},
setFromSpherical: function ( s ) {
return this.setFromSphericalCoords( s.radius, s.phi, s.theta );
},
setFromSphericalCoords: function ( radius, phi, theta ) {
var sinPhiRadius = Math.sin( phi ) * radius;
this.x = sinPhiRadius * Math.sin( theta );
this.y = Math.cos( phi ) * radius;
this.z = sinPhiRadius * Math.cos( theta );
return this;
},
setFromCylindrical: function ( c ) {
return this.setFromCylindricalCoords( c.radius, c.theta, c.y );
},
setFromCylindricalCoords: function ( radius, theta, y ) {
this.x = radius * Math.sin( theta );
this.y = y;
this.z = radius * Math.cos( theta );
return this;
},
setFromMatrixPosition: function ( m ) {
var e = m.elements;
this.x = e[ 12 ];
this.y = e[ 13 ];
this.z = e[ 14 ];
return this;
},
setFromMatrixScale: function ( m ) {
var sx = this.setFromMatrixColumn( m, 0 ).length();
var sy = this.setFromMatrixColumn( m, 1 ).length();
var sz = this.setFromMatrixColumn( m, 2 ).length();
this.x = sx;
this.y = sy;
this.z = sz;
return this;
},
setFromMatrixColumn: function ( m, index ) {
return this.fromArray( m.elements, index * 4 );
},
setFromMatrix3Column: function ( m, index ) {
return this.fromArray( m.elements, index * 3 );
},
equals: function ( v ) {
return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) );
},
fromArray: function ( array, offset ) {
if ( offset === undefined ) { offset = 0; }
this.x = array[ offset ];
this.y = array[ offset + 1 ];
this.z = array[ offset + 2 ];
return this;
},
toArray: function ( array, offset ) {
if ( array === undefined ) { array = []; }
if ( offset === undefined ) { offset = 0; }
array[ offset ] = this.x;
array[ offset + 1 ] = this.y;
array[ offset + 2 ] = this.z;
return array;
},
fromBufferAttribute: function ( attribute, index, offset ) {
if ( offset !== undefined ) {
console.warn( 'Vector3: offset has been removed from .fromBufferAttribute().' );
}
this.x = attribute.getX( index );
this.y = attribute.getY( index );
this.z = attribute.getZ( index );
return this;
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
*
* Creator of typical test AnimationClips / KeyframeTracks
*
* @author Ben Houston / http://clara.io/
* @author David Sarno / http://lighthaus.us/
*/
var AnimationClipCreator = function () {};
AnimationClipCreator.CreateRotationAnimation = function ( period, axis ) {
var times = [ 0, period ], values = [ 0, 360 ];
axis = axis || 'x';
var trackName = '.rotation[' + axis + ']';
var track = new NumberKeyframeTrack( trackName, times, values );
return new AnimationClip( null, period, [ track ] );
};
AnimationClipCreator.CreateScaleAxisAnimation = function ( period, axis ) {
var times = [ 0, period ], values = [ 0, 1 ];
axis = axis || 'x';
var trackName = '.scale[' + axis + ']';
var track = new NumberKeyframeTrack( trackName, times, values );
return new AnimationClip( null, period, [ track ] );
};
AnimationClipCreator.CreateShakeAnimation = function ( duration, shakeScale ) {
var times = [], values = [], tmp = new Vector3();
for ( var i = 0; i < duration * 10; i ++ ) {
times.push( i / 10 );
tmp.set( Math.random() * 2.0 - 1.0, Math.random() * 2.0 - 1.0, Math.random() * 2.0 - 1.0 ).
multiply( shakeScale ).
toArray( values, values.length );
}
var trackName = '.position';
var track = new VectorKeyframeTrack( trackName, times, values );
return new AnimationClip( null, duration, [ track ] );
};
AnimationClipCreator.CreatePulsationAnimation = function ( duration, pulseScale ) {
var times = [], values = [], tmp = new Vector3();
for ( var i = 0; i < duration * 10; i ++ ) {
times.push( i / 10 );
var scaleFactor = Math.random() * pulseScale;
tmp.set( scaleFactor, scaleFactor, scaleFactor ).
toArray( values, values.length );
}
var trackName = '.scale';
var track = new VectorKeyframeTrack( trackName, times, values );
return new AnimationClip( null, duration, [ track ] );
};
AnimationClipCreator.CreateVisibilityAnimation = function ( duration ) {
var times = [ 0, duration / 2, duration ], values = [ true, false, true ];
var trackName = '.visible';
var track = new BooleanKeyframeTrack( trackName, times, values );
return new AnimationClip( null, duration, [ track ] );
};
AnimationClipCreator.CreateMaterialColorAnimation = function ( duration, colors ) {
var times = [], values = [],
timeStep = duration / colors.length;
for ( var i = 0; i <= colors.length; i ++ ) {
times.push( i * timeStep );
values.push( colors[ i % colors.length ] );
}
var trackName = '.material[0].color';
var track = new ColorKeyframeTrack( trackName, times, values );
return new AnimationClip( null, duration, [ track ] );
};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WARNING: This file was auto-generated, any change will be overridden in next release. Please use configs/es6.conf.js then run "npm run convert". //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author supereggbert / http://www.paulbrunt.co.uk/
* @author philogb / http://blog.thejit.org/
* @author mikael emtinger / http://gomo.se/
* @author egraether / http://egraether.com/
* @author WestLangley / http://github.com/WestLangley
*/
function Vector4( x, y, z, w ) {
this.x = x || 0;
this.y = y || 0;
this.z = z || 0;
this.w = ( w !== undefined ) ? w : 1;
}
Object.defineProperties( Vector4.prototype, {
"width": {
get: function () {
return this.z;
},
set: function ( value ) {
this.z = value;
}
},
"height": {
get: function () {
return this.w;
},
set: function ( value ) {
this.w = value;
}
}
} );
Object.assign( Vector4.prototype, {
isVector4: true,
set: function ( x, y, z, w ) {
this.x = x;
this.y = y;
this.z = z;
this.w = w;
return this;
},
setScalar: function ( scalar ) {
this.x = scalar;
this.y = scalar;
this.z = scalar;
this.w = scalar;
return this;
},
setX: function ( x ) {
this.x = x;
return this;
},
setY: function ( y ) {
this.y = y;
return this;
},
setZ: function ( z ) {
this.z = z;
return this;
},
setW: function ( w ) {
this.w = w;
return this;
},
setComponent: function ( index, value ) {
switch ( index ) {
case 0: this.x = value; break;
case 1: this.y = value; break;
case 2: this.z = value; break;
case 3: this.w = value; break;
default: throw new Error( 'index is out of range: ' + index );
}
return this;
},
getComponent: function ( index ) {
switch ( index ) {
case 0: return this.x;
case 1: return this.y;
case 2: return this.z;
case 3: return this.w;
default: throw new Error( 'index is out of range: ' + index );
}
},
clone: function () {
return new this.constructor( this.x, this.y, this.z, this.w );
},
copy: function ( v ) {
this.x = v.x;
this.y = v.y;
this.z = v.z;
this.w = ( v.w !== undefined ) ? v.w : 1;
return this;
},
add: function ( v, w ) {
if ( w !== undefined ) {
console.warn( 'Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
return this.addVectors( v, w );
}
this.x += v.x;
this.y += v.y;
this.z += v.z;
this.w += v.w;
return this;
},
addScalar: function ( s ) {
this.x += s;
this.y += s;
this.z += s;
this.w += s;
return this;
},
addVectors: function ( a, b ) {
this.x = a.x + b.x;
this.y = a.y + b.y;
this.z = a.z + b.z;
this.w = a.w + b.w;
return this;
},
addScaledVector: function ( v, s ) {
this.x += v.x * s;
this.y += v.y * s;
this.z += v.z * s;
this.w += v.w * s;
return this;
},
sub: function ( v, w ) {
if ( w !== undefined ) {
console.warn( 'Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
return this.subVectors( v, w );
}
this.x -= v.x;
this.y -= v.y;
this.z -= v.z;
this.w -= v.w;
return this;
},
subScalar: function ( s ) {
this.x -= s;
this.y -= s;
this.z -= s;
this.w -= s;
return this;
},
subVectors: function ( a, b ) {
this.x = a.x - b.x;
this.y = a.y - b.y;
this.z = a.z - b.z;
this.w = a.w - b.w;
return this;
},
multiplyScalar: function ( scalar ) {
this.x *= scalar;
this.y *= scalar;
this.z *= scalar;
this.w *= scalar;
return this;
},
applyMatrix4: function ( m ) {
var x = this.x, y = this.y, z = this.z, w = this.w;
var e = m.elements;
this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;
this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;
this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;
this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;
return this;
},
divideScalar: function ( scalar ) {
return this.multiplyScalar( 1 / scalar );
},
setAxisAngleFromQuaternion: function ( q ) {
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
// q is assumed to be normalized
this.w = 2 * Math.acos( q.w );
var s = Math.sqrt( 1 - q.w * q.w );
if ( s < 0.0001 ) {
this.x = 1;
this.y = 0;
this.z = 0;
} else {
this.x = q.x / s;
this.y = q.y / s;
this.z = q.z / s;
}
return this;
},
setAxisAngleFromRotationMatrix: function ( m ) {
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
var angle, x, y, z, // variables for result
epsilon = 0.01, // margin to allow for rounding errors
epsilon2 = 0.1, // margin to distinguish between 0 and 180 degrees
te = m.elements,
m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
if ( ( Math.abs( m12 - m21 ) < epsilon ) &&
( Math.abs( m13 - m31 ) < epsilon ) &&
( Math.abs( m23 - m32 ) < epsilon ) ) {
// singularity found
// first check for identity matrix which must have +1 for all terms
// in leading diagonal and zero in other terms
if ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&
( Math.abs( m13 + m31 ) < epsilon2 ) &&
( Math.abs( m23 + m32 ) < epsilon2 ) &&
( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {
// this singularity is identity matrix so angle = 0
this.set( 1, 0, 0, 0 );
return this; // zero angle, arbitrary axis
}
// otherwise this singularity is angle = 180
angle = Math.PI;
var xx = ( m11 + 1 ) / 2;
var yy = ( m22 + 1 ) / 2;
var zz = ( m33 + 1 ) / 2;
var xy = ( m12 + m21 ) / 4;
var xz = ( m13 + m31 ) / 4;
var yz = ( m23 + m32 ) / 4;
if ( ( xx > yy ) && ( xx > zz ) ) {
// m11 is the largest diagonal term
if ( xx < epsilon ) {
x = 0;
y = 0.707106781;
z = 0.707106781;
} else {
x = Math.sqrt( xx );
y = xy / x;
z = xz / x;
}
} else if ( yy > zz ) {
// m22 is the largest diagonal term
if ( yy < epsilon ) {
x = 0.707106781;
y = 0;
z = 0.707106781;
} else {
y = Math.sqrt( yy );
x = xy / y;
z = yz / y;
}
} else {
// m33 is the largest diagonal term so base result on this
if ( zz < epsilon ) {
x = 0.707106781;
y = 0.707106781;
z = 0;
} else {
z = Math.sqrt( zz );
x = xz / z;
y = yz / z;
}
}
this.set( x, y, z, angle );
return this; // return 180 deg rotation
}
// as we have reached here there are no singularities so we can handle normally
var s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +
( m13 - m31 ) * ( m13 - m31 ) +
( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize
if ( Math.abs( s ) < 0.001 ) { s = 1; }
// prevent divide by zero, should not happen if matrix is orthogonal and should be
// caught by singularity test above, but I've left it in just in case
this.x = ( m32 - m23 ) / s;
this.y = ( m13 - m31 ) / s;
this.z = ( m21 - m12 ) / s;
this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );
return this;
},
min: function ( v ) {
this.x = Math.min( this.x, v.x );
this.y = Math.min( this.y, v.y );
this.z = Math.min( this.z, v.z );
this.w = Math.min( this.w, v.w );
return this;
},
max: function ( v ) {
this.x = Math.max( this.x, v.x );
this.y = Math.max( this.y, v.y );
this.z = Math.max( this.z, v.z );
this.w = Math.max( this.w, v.w );
return this;
},
clamp: function ( min, max ) {
// assumes min < max, componentwise
this.x = Math.max( min.x, Math.min( max.x, this.x ) );
this.y = Math.max( min.y, Math.min( max.y, this.y ) );
this.z = Math.max( min.z, Math.min( max.z, this.z ) );
this.w = Math.max( min.w, Math.min( max.w, this.w ) );
return this;
},
clampScalar: function ( minVal, maxVal ) {
this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
this.z = Math.max( minVal, Math.min( maxVal, this.z ) );
this.w = Math.max( minVal, Math.min( maxVal, this.w ) );
return this;
},
clampLength: function ( min, max ) {
var length = this.length();
return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
},
floor: function () {
this.x = Math.floor( this.x );
this.y = Math.floor( this.y );
this.z = Math.floor( this.z );
this.w = Math.floor( this.w );
return this;
},
ceil: function () {
this.x = Math.ceil( this.x );
this.y = Math.ceil( this.y );
this.z = Math.ceil( this.z );
this.w = Math.ceil( this.w );
return this;
},
round: function () {
this.x = Math.round( this.x );
this.y = Math.round( this.y );
this.z = Math.round( this.z );
this.w = Math.round( this.w );
return this;
},
roundToZero: function () {
this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
this.w = ( this.w < 0 ) ? Math.ceil( this.w ) : Math.floor( this.w );
return this;
},
negate: function () {
this.x = - this.x;
this.y = - this.y;
this.z = - this.z;
this.w = - this.w;
return this;
},
dot: function ( v ) {
return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
},
lengthSq: function () {
return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
},
length: function () {
return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w );
},
manhattanLength: function () {
return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );
},
normalize: function () {
return this.divideScalar( this.length() || 1 );
},
setLength: function ( length ) {
return this.normalize().multiplyScalar( length );
},
lerp: function ( v, alpha ) {
this.x += ( v.x - this.x ) * alpha;
this.y += ( v.y - this.y ) * alpha;
this.z += ( v.z - this.z ) * alpha;
this.w += ( v.w - this.w ) * alpha;
return this;
},
lerpVectors: function ( v1, v2, alpha ) {
return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
},
equals: function ( v ) {
return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );
},
fromArray: function ( array, offset ) {
if ( offset === undefined ) { offset = 0; }
this.x = array[ offset ];
this.y = array[ offset + 1 ];
this.z = array[ offset + 2 ];
this.w = array[ offset + 3 ];
return this;
},
toArray: function ( array, offset ) {
if ( array === undefined ) { array = []; }
if ( offset === undefined ) { offset = 0; }
array[ offset ] = this.x;
array[ offset + 1 ] = this.y;
array[ offset + 2 ] = this.z;
array[ offset + 3 ] = this.w;
return array;
},
fromBufferAttribute: function ( attribute, index, offset ) {
if ( offset !== undefined ) {
console.warn( 'Vector4: offset has been removed from .fromBufferAttribute().' );
}
this.x = attribute.getX( index );
this.y = attribute.getY( index );
this.z = attribute.getZ( index );
this.w = attribute.getW( index );
return this;
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WARNING: This file was auto-generated, any change will be overridden in next release. Please use configs/es6.conf.js then run "npm run convert". //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author mrdoob / http://mrdoob.com/
* @author philogb / http://blog.thejit.org/
* @author egraether / http://egraether.com/
* @author zz85 / http://www.lab4games.net/zz85/blog
*/
function Vector2( x, y ) {
this.x = x || 0;
this.y = y || 0;
}
Object.defineProperties( Vector2.prototype, {
"width": {
get: function () {
return this.x;
},
set: function ( value ) {
this.x = value;
}
},
"height": {
get: function () {
return this.y;
},
set: function ( value ) {
this.y = value;
}
}
} );
Object.assign( Vector2.prototype, {
isVector2: true,
set: function ( x, y ) {
this.x = x;
this.y = y;
return this;
},
setScalar: function ( scalar ) {
this.x = scalar;
this.y = scalar;
return this;
},
setX: function ( x ) {
this.x = x;
return this;
},
setY: function ( y ) {
this.y = y;
return this;
},
setComponent: function ( index, value ) {
switch ( index ) {
case 0: this.x = value; break;
case 1: this.y = value; break;
default: throw new Error( 'index is out of range: ' + index );
}
return this;
},
getComponent: function ( index ) {
switch ( index ) {
case 0: return this.x;
case 1: return this.y;
default: throw new Error( 'index is out of range: ' + index );
}
},
clone: function () {
return new this.constructor( this.x, this.y );
},
copy: function ( v ) {
this.x = v.x;
this.y = v.y;
return this;
},
add: function ( v, w ) {
if ( w !== undefined ) {
console.warn( 'Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
return this.addVectors( v, w );
}
this.x += v.x;
this.y += v.y;
return this;
},
addScalar: function ( s ) {
this.x += s;
this.y += s;
return this;
},
addVectors: function ( a, b ) {
this.x = a.x + b.x;
this.y = a.y + b.y;
return this;
},
addScaledVector: function ( v, s ) {
this.x += v.x * s;
this.y += v.y * s;
return this;
},
sub: function ( v, w ) {
if ( w !== undefined ) {
console.warn( 'Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
return this.subVectors( v, w );
}
this.x -= v.x;
this.y -= v.y;
return this;
},
subScalar: function ( s ) {
this.x -= s;
this.y -= s;
return this;
},
subVectors: function ( a, b ) {
this.x = a.x - b.x;
this.y = a.y - b.y;
return this;
},
multiply: function ( v ) {
this.x *= v.x;
this.y *= v.y;
return this;
},
multiplyScalar: function ( scalar ) {
this.x *= scalar;
this.y *= scalar;
return this;
},
divide: function ( v ) {
this.x /= v.x;
this.y /= v.y;
return this;
},
divideScalar: function ( scalar ) {
return this.multiplyScalar( 1 / scalar );
},
applyMatrix3: function ( m ) {
var x = this.x, y = this.y;
var e = m.elements;
this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ];
this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ];
return this;
},
min: function ( v ) {
this.x = Math.min( this.x, v.x );
this.y = Math.min( this.y, v.y );
return this;
},
max: function ( v ) {
this.x = Math.max( this.x, v.x );
this.y = Math.max( this.y, v.y );
return this;
},
clamp: function ( min, max ) {
// assumes min < max, componentwise
this.x = Math.max( min.x, Math.min( max.x, this.x ) );
this.y = Math.max( min.y, Math.min( max.y, this.y ) );
return this;
},
clampScalar: function ( minVal, maxVal ) {
this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
return this;
},
clampLength: function ( min, max ) {
var length = this.length();
return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
},
floor: function () {
this.x = Math.floor( this.x );
this.y = Math.floor( this.y );
return this;
},
ceil: function () {
this.x = Math.ceil( this.x );
this.y = Math.ceil( this.y );
return this;
},
round: function () {
this.x = Math.round( this.x );
this.y = Math.round( this.y );
return this;
},
roundToZero: function () {
this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
return this;
},
negate: function () {
this.x = - this.x;
this.y = - this.y;
return this;
},
dot: function ( v ) {
return this.x * v.x + this.y * v.y;
},
cross: function ( v ) {
return this.x * v.y - this.y * v.x;
},
lengthSq: function () {
return this.x * this.x + this.y * this.y;
},
length: function () {
return Math.sqrt( this.x * this.x + this.y * this.y );
},
manhattanLength: function () {
return Math.abs( this.x ) + Math.abs( this.y );
},
normalize: function () {
return this.divideScalar( this.length() || 1 );
},
angle: function () {
// computes the angle in radians with respect to the positive x-axis
var angle = Math.atan2( this.y, this.x );
if ( angle < 0 ) { angle += 2 * Math.PI; }
return angle;
},
distanceTo: function ( v ) {
return Math.sqrt( this.distanceToSquared( v ) );
},
distanceToSquared: function ( v ) {
var dx = this.x - v.x, dy = this.y - v.y;
return dx * dx + dy * dy;
},
manhattanDistanceTo: function ( v ) {
return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );
},
setLength: function ( length ) {
return this.normalize().multiplyScalar( length );
},
lerp: function ( v, alpha ) {
this.x += ( v.x - this.x ) * alpha;
this.y += ( v.y - this.y ) * alpha;
return this;
},
lerpVectors: function ( v1, v2, alpha ) {
return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
},
equals: function ( v ) {
return ( ( v.x === this.x ) && ( v.y === this.y ) );
},
fromArray: function ( array, offset ) {
if ( offset === undefined ) { offset = 0; }
this.x = array[ offset ];
this.y = array[ offset + 1 ];
return this;
},
toArray: function ( array, offset ) {
if ( array === undefined ) { array = []; }
if ( offset === undefined ) { offset = 0; }
array[ offset ] = this.x;
array[ offset + 1 ] = this.y;
return array;
},
fromBufferAttribute: function ( attribute, index, offset ) {
if ( offset !== undefined ) {
console.warn( 'Vector2: offset has been removed from .fromBufferAttribute().' );
}
this.x = attribute.getX( index );
this.y = attribute.getY( index );
return this;
},
rotateAround: function ( center, angle ) {
var c = Math.cos( angle ), s = Math.sin( angle );
var x = this.x - center.x;
var y = this.y - center.y;
this.x = x * c - y * s + center.x;
this.y = x * s + y * c + center.y;
return this;
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author mrdoob / http://mrdoob.com/
*/
var _colorKeywords = { 'aliceblue': 0xF0F8FF, 'antiquewhite': 0xFAEBD7, 'aqua': 0x00FFFF, 'aquamarine': 0x7FFFD4, 'azure': 0xF0FFFF,
'beige': 0xF5F5DC, 'bisque': 0xFFE4C4, 'black': 0x000000, 'blanchedalmond': 0xFFEBCD, 'blue': 0x0000FF, 'blueviolet': 0x8A2BE2,
'brown': 0xA52A2A, 'burlywood': 0xDEB887, 'cadetblue': 0x5F9EA0, 'chartreuse': 0x7FFF00, 'chocolate': 0xD2691E, 'coral': 0xFF7F50,
'cornflowerblue': 0x6495ED, 'cornsilk': 0xFFF8DC, 'crimson': 0xDC143C, 'cyan': 0x00FFFF, 'darkblue': 0x00008B, 'darkcyan': 0x008B8B,
'darkgoldenrod': 0xB8860B, 'darkgray': 0xA9A9A9, 'darkgreen': 0x006400, 'darkgrey': 0xA9A9A9, 'darkkhaki': 0xBDB76B, 'darkmagenta': 0x8B008B,
'darkolivegreen': 0x556B2F, 'darkorange': 0xFF8C00, 'darkorchid': 0x9932CC, 'darkred': 0x8B0000, 'darksalmon': 0xE9967A, 'darkseagreen': 0x8FBC8F,
'darkslateblue': 0x483D8B, 'darkslategray': 0x2F4F4F, 'darkslategrey': 0x2F4F4F, 'darkturquoise': 0x00CED1, 'darkviolet': 0x9400D3,
'deeppink': 0xFF1493, 'deepskyblue': 0x00BFFF, 'dimgray': 0x696969, 'dimgrey': 0x696969, 'dodgerblue': 0x1E90FF, 'firebrick': 0xB22222,
'floralwhite': 0xFFFAF0, 'forestgreen': 0x228B22, 'fuchsia': 0xFF00FF, 'gainsboro': 0xDCDCDC, 'ghostwhite': 0xF8F8FF, 'gold': 0xFFD700,
'goldenrod': 0xDAA520, 'gray': 0x808080, 'green': 0x008000, 'greenyellow': 0xADFF2F, 'grey': 0x808080, 'honeydew': 0xF0FFF0, 'hotpink': 0xFF69B4,
'indianred': 0xCD5C5C, 'indigo': 0x4B0082, 'ivory': 0xFFFFF0, 'khaki': 0xF0E68C, 'lavender': 0xE6E6FA, 'lavenderblush': 0xFFF0F5, 'lawngreen': 0x7CFC00,
'lemonchiffon': 0xFFFACD, 'lightblue': 0xADD8E6, 'lightcoral': 0xF08080, 'lightcyan': 0xE0FFFF, 'lightgoldenrodyellow': 0xFAFAD2, 'lightgray': 0xD3D3D3,
'lightgreen': 0x90EE90, 'lightgrey': 0xD3D3D3, 'lightpink': 0xFFB6C1, 'lightsalmon': 0xFFA07A, 'lightseagreen': 0x20B2AA, 'lightskyblue': 0x87CEFA,
'lightslategray': 0x778899, 'lightslategrey': 0x778899, 'lightsteelblue': 0xB0C4DE, 'lightyellow': 0xFFFFE0, 'lime': 0x00FF00, 'limegreen': 0x32CD32,
'linen': 0xFAF0E6, 'magenta': 0xFF00FF, 'maroon': 0x800000, 'mediumaquamarine': 0x66CDAA, 'mediumblue': 0x0000CD, 'mediumorchid': 0xBA55D3,
'mediumpurple': 0x9370DB, 'mediumseagreen': 0x3CB371, 'mediumslateblue': 0x7B68EE, 'mediumspringgreen': 0x00FA9A, 'mediumturquoise': 0x48D1CC,
'mediumvioletred': 0xC71585, 'midnightblue': 0x191970, 'mintcream': 0xF5FFFA, 'mistyrose': 0xFFE4E1, 'moccasin': 0xFFE4B5, 'navajowhite': 0xFFDEAD,
'navy': 0x000080, 'oldlace': 0xFDF5E6, 'olive': 0x808000, 'olivedrab': 0x6B8E23, 'orange': 0xFFA500, 'orangered': 0xFF4500, 'orchid': 0xDA70D6,
'palegoldenrod': 0xEEE8AA, 'palegreen': 0x98FB98, 'paleturquoise': 0xAFEEEE, 'palevioletred': 0xDB7093, 'papayawhip': 0xFFEFD5, 'peachpuff': 0xFFDAB9,
'peru': 0xCD853F, 'pink': 0xFFC0CB, 'plum': 0xDDA0DD, 'powderblue': 0xB0E0E6, 'purple': 0x800080, 'rebeccapurple': 0x663399, 'red': 0xFF0000, 'rosybrown': 0xBC8F8F,
'royalblue': 0x4169E1, 'saddlebrown': 0x8B4513, 'salmon': 0xFA8072, 'sandybrown': 0xF4A460, 'seagreen': 0x2E8B57, 'seashell': 0xFFF5EE,
'sienna': 0xA0522D, 'silver': 0xC0C0C0, 'skyblue': 0x87CEEB, 'slateblue': 0x6A5ACD, 'slategray': 0x708090, 'slategrey': 0x708090, 'snow': 0xFFFAFA,
'springgreen': 0x00FF7F, 'steelblue': 0x4682B4, 'tan': 0xD2B48C, 'teal': 0x008080, 'thistle': 0xD8BFD8, 'tomato': 0xFF6347, 'turquoise': 0x40E0D0,
'violet': 0xEE82EE, 'wheat': 0xF5DEB3, 'white': 0xFFFFFF, 'whitesmoke': 0xF5F5F5, 'yellow': 0xFFFF00, 'yellowgreen': 0x9ACD32 };
var _hslA = { h: 0, s: 0, l: 0 };
var _hslB = { h: 0, s: 0, l: 0 };
function Color( r, g, b ) {
if ( g === undefined && b === undefined ) {
// r is Color, hex or string
return this.set( r );
}
return this.setRGB( r, g, b );
}
function hue2rgb( p, q, t ) {
if ( t < 0 ) { t += 1; }
if ( t > 1 ) { t -= 1; }
if ( t < 1 / 6 ) { return p + ( q - p ) * 6 * t; }
if ( t < 1 / 2 ) { return q; }
if ( t < 2 / 3 ) { return p + ( q - p ) * 6 * ( 2 / 3 - t ); }
return p;
}
function SRGBToLinear( c ) {
return ( c < 0.04045 ) ? c * 0.0773993808 : Math.pow( c * 0.9478672986 + 0.0521327014, 2.4 );
}
function LinearToSRGB( c ) {
return ( c < 0.0031308 ) ? c * 12.92 : 1.055 * ( Math.pow( c, 0.41666 ) ) - 0.055;
}
Object.assign( Color.prototype, {
isColor: true,
r: 1, g: 1, b: 1,
set: function ( value ) {
if ( value && value.isColor ) {
this.copy( value );
} else if ( typeof value === 'number' ) {
this.setHex( value );
} else if ( typeof value === 'string' ) {
this.setStyle( value );
}
return this;
},
setScalar: function ( scalar ) {
this.r = scalar;
this.g = scalar;
this.b = scalar;
return this;
},
setHex: function ( hex ) {
hex = Math.floor( hex );
this.r = ( hex >> 16 & 255 ) / 255;
this.g = ( hex >> 8 & 255 ) / 255;
this.b = ( hex & 255 ) / 255;
return this;
},
setRGB: function ( r, g, b ) {
this.r = r;
this.g = g;
this.b = b;
return this;
},
setHSL: function ( h, s, l ) {
// h,s,l ranges are in 0.0 - 1.0
h = MathUtils.euclideanModulo( h, 1 );
s = MathUtils.clamp( s, 0, 1 );
l = MathUtils.clamp( l, 0, 1 );
if ( s === 0 ) {
this.r = this.g = this.b = l;
} else {
var p = l <= 0.5 ? l * ( 1 + s ) : l + s - ( l * s );
var q = ( 2 * l ) - p;
this.r = hue2rgb( q, p, h + 1 / 3 );
this.g = hue2rgb( q, p, h );
this.b = hue2rgb( q, p, h - 1 / 3 );
}
return this;
},
setStyle: function ( style ) {
function handleAlpha( string ) {
if ( string === undefined ) { return; }
if ( parseFloat( string ) < 1 ) {
console.warn( 'Color: Alpha component of ' + style + ' will be ignored.' );
}
}
var m;
if ( m = /^((?:rgb|hsl)a?)\(\s*([^\)]*)\)/.exec( style ) ) {
// rgb / hsl
var color;
var name = m[ 1 ];
var components = m[ 2 ];
switch ( name ) {
case 'rgb':
case 'rgba':
if ( color = /^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) {
// rgb(255,0,0) rgba(255,0,0,0.5)
this.r = Math.min( 255, parseInt( color[ 1 ], 10 ) ) / 255;
this.g = Math.min( 255, parseInt( color[ 2 ], 10 ) ) / 255;
this.b = Math.min( 255, parseInt( color[ 3 ], 10 ) ) / 255;
handleAlpha( color[ 5 ] );
return this;
}
if ( color = /^(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) {
// rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)
this.r = Math.min( 100, parseInt( color[ 1 ], 10 ) ) / 100;
this.g = Math.min( 100, parseInt( color[ 2 ], 10 ) ) / 100;
this.b = Math.min( 100, parseInt( color[ 3 ], 10 ) ) / 100;
handleAlpha( color[ 5 ] );
return this;
}
break;
case 'hsl':
case 'hsla':
if ( color = /^([0-9]*\.?[0-9]+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) {
// hsl(120,50%,50%) hsla(120,50%,50%,0.5)
var h = parseFloat( color[ 1 ] ) / 360;
var s = parseInt( color[ 2 ], 10 ) / 100;
var l = parseInt( color[ 3 ], 10 ) / 100;
handleAlpha( color[ 5 ] );
return this.setHSL( h, s, l );
}
break;
}
} else if ( m = /^\#([A-Fa-f0-9]+)$/.exec( style ) ) {
// hex color
var hex = m[ 1 ];
var size = hex.length;
if ( size === 3 ) {
// #ff0
this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 0 ), 16 ) / 255;
this.g = parseInt( hex.charAt( 1 ) + hex.charAt( 1 ), 16 ) / 255;
this.b = parseInt( hex.charAt( 2 ) + hex.charAt( 2 ), 16 ) / 255;
return this;
} else if ( size === 6 ) {
// #ff0000
this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 1 ), 16 ) / 255;
this.g = parseInt( hex.charAt( 2 ) + hex.charAt( 3 ), 16 ) / 255;
this.b = parseInt( hex.charAt( 4 ) + hex.charAt( 5 ), 16 ) / 255;
return this;
}
}
if ( style && style.length > 0 ) {
return this.setColorName( style );
}
return this;
},
setColorName: function ( style ) {
// color keywords
var hex = _colorKeywords[ style ];
if ( hex !== undefined ) {
// red
this.setHex( hex );
} else {
// unknown color
console.warn( 'Color: Unknown color ' + style );
}
return this;
},
clone: function () {
return new this.constructor( this.r, this.g, this.b );
},
copy: function ( color ) {
this.r = color.r;
this.g = color.g;
this.b = color.b;
return this;
},
copyGammaToLinear: function ( color, gammaFactor ) {
if ( gammaFactor === undefined ) { gammaFactor = 2.0; }
this.r = Math.pow( color.r, gammaFactor );
this.g = Math.pow( color.g, gammaFactor );
this.b = Math.pow( color.b, gammaFactor );
return this;
},
copyLinearToGamma: function ( color, gammaFactor ) {
if ( gammaFactor === undefined ) { gammaFactor = 2.0; }
var safeInverse = ( gammaFactor > 0 ) ? ( 1.0 / gammaFactor ) : 1.0;
this.r = Math.pow( color.r, safeInverse );
this.g = Math.pow( color.g, safeInverse );
this.b = Math.pow( color.b, safeInverse );
return this;
},
convertGammaToLinear: function ( gammaFactor ) {
this.copyGammaToLinear( this, gammaFactor );
return this;
},
convertLinearToGamma: function ( gammaFactor ) {
this.copyLinearToGamma( this, gammaFactor );
return this;
},
copySRGBToLinear: function ( color ) {
this.r = SRGBToLinear( color.r );
this.g = SRGBToLinear( color.g );
this.b = SRGBToLinear( color.b );
return this;
},
copyLinearToSRGB: function ( color ) {
this.r = LinearToSRGB( color.r );
this.g = LinearToSRGB( color.g );
this.b = LinearToSRGB( color.b );
return this;
},
convertSRGBToLinear: function () {
this.copySRGBToLinear( this );
return this;
},
convertLinearToSRGB: function () {
this.copyLinearToSRGB( this );
return this;
},
getHex: function () {
return ( this.r * 255 ) << 16 ^ ( this.g * 255 ) << 8 ^ ( this.b * 255 ) << 0;
},
getHexString: function () {
return ( '000000' + this.getHex().toString( 16 ) ).slice( - 6 );
},
getHSL: function ( target ) {
// h,s,l ranges are in 0.0 - 1.0
if ( target === undefined ) {
console.warn( 'Color: .getHSL() target is now required' );
target = { h: 0, s: 0, l: 0 };
}
var r = this.r, g = this.g, b = this.b;
var max = Math.max( r, g, b );
var min = Math.min( r, g, b );
var hue, saturation;
var lightness = ( min + max ) / 2.0;
if ( min === max ) {
hue = 0;
saturation = 0;
} else {
var delta = max - min;
saturation = lightness <= 0.5 ? delta / ( max + min ) : delta / ( 2 - max - min );
switch ( max ) {
case r: hue = ( g - b ) / delta + ( g < b ? 6 : 0 ); break;
case g: hue = ( b - r ) / delta + 2; break;
case b: hue = ( r - g ) / delta + 4; break;
}
hue /= 6;
}
target.h = hue;
target.s = saturation;
target.l = lightness;
return target;
},
getStyle: function () {
return 'rgb(' + ( ( this.r * 255 ) | 0 ) + ',' + ( ( this.g * 255 ) | 0 ) + ',' + ( ( this.b * 255 ) | 0 ) + ')';
},
offsetHSL: function ( h, s, l ) {
this.getHSL( _hslA );
_hslA.h += h; _hslA.s += s; _hslA.l += l;
this.setHSL( _hslA.h, _hslA.s, _hslA.l );
return this;
},
add: function ( color ) {
this.r += color.r;
this.g += color.g;
this.b += color.b;
return this;
},
addColors: function ( color1, color2 ) {
this.r = color1.r + color2.r;
this.g = color1.g + color2.g;
this.b = color1.b + color2.b;
return this;
},
addScalar: function ( s ) {
this.r += s;
this.g += s;
this.b += s;
return this;
},
sub: function ( color ) {
this.r = Math.max( 0, this.r - color.r );
this.g = Math.max( 0, this.g - color.g );
this.b = Math.max( 0, this.b - color.b );
return this;
},
multiply: function ( color ) {
this.r *= color.r;
this.g *= color.g;
this.b *= color.b;
return this;
},
multiplyScalar: function ( s ) {
this.r *= s;
this.g *= s;
this.b *= s;
return this;
},
lerp: function ( color, alpha ) {
this.r += ( color.r - this.r ) * alpha;
this.g += ( color.g - this.g ) * alpha;
this.b += ( color.b - this.b ) * alpha;
return this;
},
lerpHSL: function ( color, alpha ) {
this.getHSL( _hslA );
color.getHSL( _hslB );
var h = MathUtils.lerp( _hslA.h, _hslB.h, alpha );
var s = MathUtils.lerp( _hslA.s, _hslB.s, alpha );
var l = MathUtils.lerp( _hslA.l, _hslB.l, alpha );
this.setHSL( h, s, l );
return this;
},
equals: function ( c ) {
return ( c.r === this.r ) && ( c.g === this.g ) && ( c.b === this.b );
},
fromArray: function ( array, offset ) {
if ( offset === undefined ) { offset = 0; }
this.r = array[ offset ];
this.g = array[ offset + 1 ];
this.b = array[ offset + 2 ];
return this;
},
toArray: function ( array, offset ) {
if ( array === undefined ) { array = []; }
if ( offset === undefined ) { offset = 0; }
array[ offset ] = this.r;
array[ offset + 1 ] = this.g;
array[ offset + 2 ] = this.b;
return array;
},
toJSON: function () {
return this.getHex();
}
} );
Color.NAMES = _colorKeywords;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author mrdoob / http://mrdoob.com/
*/
var _vector$1 = new Vector3();
function BufferAttribute( array, itemSize, normalized ) {
if ( Array.isArray( array ) ) {
throw new TypeError( 'BufferAttribute: array should be a Typed Array.' );
}
this.name = '';
this.array = array;
this.itemSize = itemSize;
this.count = array !== undefined ? array.length / itemSize : 0;
this.normalized = normalized === true;
this.usage = StaticDrawUsage;
this.updateRange = { offset: 0, count: - 1 };
this.version = 0;
}
Object.defineProperty( BufferAttribute.prototype, 'needsUpdate', {
set: function ( value ) {
if ( value === true ) { this.version ++; }
}
} );
Object.assign( BufferAttribute.prototype, {
isBufferAttribute: true,
onUploadCallback: function () {},
setUsage: function ( value ) {
this.usage = value;
return this;
},
copy: function ( source ) {
this.name = source.name;
this.array = new source.array.constructor( source.array );
this.itemSize = source.itemSize;
this.count = source.count;
this.normalized = source.normalized;
this.usage = source.usage;
return this;
},
copyAt: function ( index1, attribute, index2 ) {
index1 *= this.itemSize;
index2 *= attribute.itemSize;
for ( var i = 0, l = this.itemSize; i < l; i ++ ) {
this.array[ index1 + i ] = attribute.array[ index2 + i ];
}
return this;
},
copyArray: function ( array ) {
this.array.set( array );
return this;
},
copyColorsArray: function ( colors ) {
var array = this.array, offset = 0;
for ( var i = 0, l = colors.length; i < l; i ++ ) {
var color = colors[ i ];
if ( color === undefined ) {
console.warn( 'BufferAttribute.copyColorsArray(): color is undefined', i );
color = new Color();
}
array[ offset ++ ] = color.r;
array[ offset ++ ] = color.g;
array[ offset ++ ] = color.b;
}
return this;
},
copyVector2sArray: function ( vectors ) {
var array = this.array, offset = 0;
for ( var i = 0, l = vectors.length; i < l; i ++ ) {
var vector = vectors[ i ];
if ( vector === undefined ) {
console.warn( 'BufferAttribute.copyVector2sArray(): vector is undefined', i );
vector = new Vector2();
}
array[ offset ++ ] = vector.x;
array[ offset ++ ] = vector.y;
}
return this;
},
copyVector3sArray: function ( vectors ) {
var array = this.array, offset = 0;
for ( var i = 0, l = vectors.length; i < l; i ++ ) {
var vector = vectors[ i ];
if ( vector === undefined ) {
console.warn( 'BufferAttribute.copyVector3sArray(): vector is undefined', i );
vector = new Vector3();
}
array[ offset ++ ] = vector.x;
array[ offset ++ ] = vector.y;
array[ offset ++ ] = vector.z;
}
return this;
},
copyVector4sArray: function ( vectors ) {
var array = this.array, offset = 0;
for ( var i = 0, l = vectors.length; i < l; i ++ ) {
var vector = vectors[ i ];
if ( vector === undefined ) {
console.warn( 'BufferAttribute.copyVector4sArray(): vector is undefined', i );
vector = new Vector4();
}
array[ offset ++ ] = vector.x;
array[ offset ++ ] = vector.y;
array[ offset ++ ] = vector.z;
array[ offset ++ ] = vector.w;
}
return this;
},
applyMatrix3: function ( m ) {
for ( var i = 0, l = this.count; i < l; i ++ ) {
_vector$1.x = this.getX( i );
_vector$1.y = this.getY( i );
_vector$1.z = this.getZ( i );
_vector$1.applyMatrix3( m );
this.setXYZ( i, _vector$1.x, _vector$1.y, _vector$1.z );
}
return this;
},
applyMatrix4: function ( m ) {
for ( var i = 0, l = this.count; i < l; i ++ ) {
_vector$1.x = this.getX( i );
_vector$1.y = this.getY( i );
_vector$1.z = this.getZ( i );
_vector$1.applyMatrix4( m );
this.setXYZ( i, _vector$1.x, _vector$1.y, _vector$1.z );
}
return this;
},
applyNormalMatrix: function ( m ) {
for ( var i = 0, l = this.count; i < l; i ++ ) {
_vector$1.x = this.getX( i );
_vector$1.y = this.getY( i );
_vector$1.z = this.getZ( i );
_vector$1.applyNormalMatrix( m );
this.setXYZ( i, _vector$1.x, _vector$1.y, _vector$1.z );
}
return this;
},
transformDirection: function ( m ) {
for ( var i = 0, l = this.count; i < l; i ++ ) {
_vector$1.x = this.getX( i );
_vector$1.y = this.getY( i );
_vector$1.z = this.getZ( i );
_vector$1.transformDirection( m );
this.setXYZ( i, _vector$1.x, _vector$1.y, _vector$1.z );
}
return this;
},
set: function ( value, offset ) {
if ( offset === undefined ) { offset = 0; }
this.array.set( value, offset );
return this;
},
getX: function ( index ) {
return this.array[ index * this.itemSize ];
},
setX: function ( index, x ) {
this.array[ index * this.itemSize ] = x;
return this;
},
getY: function ( index ) {
return this.array[ index * this.itemSize + 1 ];
},
setY: function ( index, y ) {
this.array[ index * this.itemSize + 1 ] = y;
return this;
},
getZ: function ( index ) {
return this.array[ index * this.itemSize + 2 ];
},
setZ: function ( index, z ) {
this.array[ index * this.itemSize + 2 ] = z;
return this;
},
getW: function ( index ) {
return this.array[ index * this.itemSize + 3 ];
},
setW: function ( index, w ) {
this.array[ index * this.itemSize + 3 ] = w;
return this;
},
setXY: function ( index, x, y ) {
index *= this.itemSize;
this.array[ index + 0 ] = x;
this.array[ index + 1 ] = y;
return this;
},
setXYZ: function ( index, x, y, z ) {
index *= this.itemSize;
this.array[ index + 0 ] = x;
this.array[ index + 1 ] = y;
this.array[ index + 2 ] = z;
return this;
},
setXYZW: function ( index, x, y, z, w ) {
index *= this.itemSize;
this.array[ index + 0 ] = x;
this.array[ index + 1 ] = y;
this.array[ index + 2 ] = z;
this.array[ index + 3 ] = w;
return this;
},
onUpload: function ( callback ) {
this.onUploadCallback = callback;
return this;
},
clone: function () {
return new this.constructor( this.array, this.itemSize ).copy( this );
},
toJSON: function () {
return {
itemSize: this.itemSize,
type: this.array.constructor.name,
array: Array.prototype.slice.call( this.array ),
normalized: this.normalized
};
}
} );
//
function Int8BufferAttribute( array, itemSize, normalized ) {
BufferAttribute.call( this, new Int8Array( array ), itemSize, normalized );
}
Int8BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
Int8BufferAttribute.prototype.constructor = Int8BufferAttribute;
function Uint8BufferAttribute( array, itemSize, normalized ) {
BufferAttribute.call( this, new Uint8Array( array ), itemSize, normalized );
}
Uint8BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
Uint8BufferAttribute.prototype.constructor = Uint8BufferAttribute;
function Uint8ClampedBufferAttribute( array, itemSize, normalized ) {
BufferAttribute.call( this, new Uint8ClampedArray( array ), itemSize, normalized );
}
Uint8ClampedBufferAttribute.prototype = Object.create( BufferAttribute.prototype );
Uint8ClampedBufferAttribute.prototype.constructor = Uint8ClampedBufferAttribute;
function Int16BufferAttribute( array, itemSize, normalized ) {
BufferAttribute.call( this, new Int16Array( array ), itemSize, normalized );
}
Int16BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
Int16BufferAttribute.prototype.constructor = Int16BufferAttribute;
function Uint16BufferAttribute( array, itemSize, normalized ) {
BufferAttribute.call( this, new Uint16Array( array ), itemSize, normalized );
}
Uint16BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
Uint16BufferAttribute.prototype.constructor = Uint16BufferAttribute;
function Int32BufferAttribute( array, itemSize, normalized ) {
BufferAttribute.call( this, new Int32Array( array ), itemSize, normalized );
}
Int32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
Int32BufferAttribute.prototype.constructor = Int32BufferAttribute;
function Uint32BufferAttribute( array, itemSize, normalized ) {
BufferAttribute.call( this, new Uint32Array( array ), itemSize, normalized );
}
Uint32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
Uint32BufferAttribute.prototype.constructor = Uint32BufferAttribute;
function Float32BufferAttribute( array, itemSize, normalized ) {
BufferAttribute.call( this, new Float32Array( array ), itemSize, normalized );
}
Float32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
Float32BufferAttribute.prototype.constructor = Float32BufferAttribute;
function Float64BufferAttribute( array, itemSize, normalized ) {
BufferAttribute.call( this, new Float64Array( array ), itemSize, normalized );
}
Float64BufferAttribute.prototype = Object.create( BufferAttribute.prototype );
Float64BufferAttribute.prototype.constructor = Float64BufferAttribute;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var _points = [
new Vector3(),
new Vector3(),
new Vector3(),
new Vector3(),
new Vector3(),
new Vector3(),
new Vector3(),
new Vector3()
];
var _vector$2 = new Vector3();
var _box = new Box3();
// triangle centered vertices
var _v0 = new Vector3();
var _v1 = new Vector3();
var _v2 = new Vector3();
// triangle edge vectors
var _f0 = new Vector3();
var _f1 = new Vector3();
var _f2 = new Vector3();
var _center = new Vector3();
var _extents = new Vector3();
var _triangleNormal = new Vector3();
var _testAxis = new Vector3();
/**
* @author bhouston / http://clara.io
* @author WestLangley / http://github.com/WestLangley
*/
function Box3( min, max ) {
this.min = ( min !== undefined ) ? min : new Vector3( + Infinity, + Infinity, + Infinity );
this.max = ( max !== undefined ) ? max : new Vector3( - Infinity, - Infinity, - Infinity );
}
Object.assign( Box3.prototype, {
isBox3: true,
set: function ( min, max ) {
this.min.copy( min );
this.max.copy( max );
return this;
},
setFromArray: function ( array ) {
var minX = + Infinity;
var minY = + Infinity;
var minZ = + Infinity;
var maxX = - Infinity;
var maxY = - Infinity;
var maxZ = - Infinity;
for ( var i = 0, l = array.length; i < l; i += 3 ) {
var x = array[ i ];
var y = array[ i + 1 ];
var z = array[ i + 2 ];
if ( x < minX ) { minX = x; }
if ( y < minY ) { minY = y; }
if ( z < minZ ) { minZ = z; }
if ( x > maxX ) { maxX = x; }
if ( y > maxY ) { maxY = y; }
if ( z > maxZ ) { maxZ = z; }
}
this.min.set( minX, minY, minZ );
this.max.set( maxX, maxY, maxZ );
return this;
},
setFromBufferAttribute: function ( attribute ) {
var minX = + Infinity;
var minY = + Infinity;
var minZ = + Infinity;
var maxX = - Infinity;
var maxY = - Infinity;
var maxZ = - Infinity;
for ( var i = 0, l = attribute.count; i < l; i ++ ) {
var x = attribute.getX( i );
var y = attribute.getY( i );
var z = attribute.getZ( i );
if ( x < minX ) { minX = x; }
if ( y < minY ) { minY = y; }
if ( z < minZ ) { minZ = z; }
if ( x > maxX ) { maxX = x; }
if ( y > maxY ) { maxY = y; }
if ( z > maxZ ) { maxZ = z; }
}
this.min.set( minX, minY, minZ );
this.max.set( maxX, maxY, maxZ );
return this;
},
setFromPoints: function ( points ) {
this.makeEmpty();
for ( var i = 0, il = points.length; i < il; i ++ ) {
this.expandByPoint( points[ i ] );
}
return this;
},
setFromCenterAndSize: function ( center, size ) {
var halfSize = _vector$2.copy( size ).multiplyScalar( 0.5 );
this.min.copy( center ).sub( halfSize );
this.max.copy( center ).add( halfSize );
return this;
},
setFromObject: function ( object ) {
this.makeEmpty();
return this.expandByObject( object );
},
clone: function () {
return new this.constructor().copy( this );
},
copy: function ( box ) {
this.min.copy( box.min );
this.max.copy( box.max );
return this;
},
makeEmpty: function () {
this.min.x = this.min.y = this.min.z = + Infinity;
this.max.x = this.max.y = this.max.z = - Infinity;
return this;
},
isEmpty: function () {
// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z );
},
getCenter: function ( target ) {
if ( target === undefined ) {
console.warn( 'Box3: .getCenter() target is now required' );
target = new Vector3();
}
return this.isEmpty() ? target.set( 0, 0, 0 ) : target.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
},
getSize: function ( target ) {
if ( target === undefined ) {
console.warn( 'Box3: .getSize() target is now required' );
target = new Vector3();
}
return this.isEmpty() ? target.set( 0, 0, 0 ) : target.subVectors( this.max, this.min );
},
expandByPoint: function ( point ) {
this.min.min( point );
this.max.max( point );
return this;
},
expandByVector: function ( vector ) {
this.min.sub( vector );
this.max.add( vector );
return this;
},
expandByScalar: function ( scalar ) {
this.min.addScalar( - scalar );
this.max.addScalar( scalar );
return this;
},
expandByObject: function ( object ) {
// Computes the world-axis-aligned bounding box of an object (including its children),
// accounting for both the object's, and children's, world transforms
object.updateWorldMatrix( false, false );
var geometry = object.geometry;
if ( geometry !== undefined ) {
if ( geometry.boundingBox === null ) {
geometry.computeBoundingBox();
}
_box.copy( geometry.boundingBox );
_box.applyMatrix4( object.matrixWorld );
this.expandByPoint( _box.min );
this.expandByPoint( _box.max );
}
var children = object.children;
for ( var i = 0, l = children.length; i < l; i ++ ) {
this.expandByObject( children[ i ] );
}
return this;
},
containsPoint: function ( point ) {
return point.x < this.min.x || point.x > this.max.x ||
point.y < this.min.y || point.y > this.max.y ||
point.z < this.min.z || point.z > this.max.z ? false : true;
},
containsBox: function ( box ) {
return this.min.x <= box.min.x && box.max.x <= this.max.x &&
this.min.y <= box.min.y && box.max.y <= this.max.y &&
this.min.z <= box.min.z && box.max.z <= this.max.z;
},
getParameter: function ( point, target ) {
// This can potentially have a divide by zero if the box
// has a size dimension of 0.
if ( target === undefined ) {
console.warn( 'Box3: .getParameter() target is now required' );
target = new Vector3();
}
return target.set(
( point.x - this.min.x ) / ( this.max.x - this.min.x ),
( point.y - this.min.y ) / ( this.max.y - this.min.y ),
( point.z - this.min.z ) / ( this.max.z - this.min.z )
);
},
intersectsBox: function ( box ) {
// using 6 splitting planes to rule out intersections.
return box.max.x < this.min.x || box.min.x > this.max.x ||
box.max.y < this.min.y || box.min.y > this.max.y ||
box.max.z < this.min.z || box.min.z > this.max.z ? false : true;
},
intersectsSphere: function ( sphere ) {
// Find the point on the AABB closest to the sphere center.
this.clampPoint( sphere.center, _vector$2 );
// If that point is inside the sphere, the AABB and sphere intersect.
return _vector$2.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius );
},
intersectsPlane: function ( plane ) {
// We compute the minimum and maximum dot product values. If those values
// are on the same side (back or front) of the plane, then there is no intersection.
var min, max;
if ( plane.normal.x > 0 ) {
min = plane.normal.x * this.min.x;
max = plane.normal.x * this.max.x;
} else {
min = plane.normal.x * this.max.x;
max = plane.normal.x * this.min.x;
}
if ( plane.normal.y > 0 ) {
min += plane.normal.y * this.min.y;
max += plane.normal.y * this.max.y;
} else {
min += plane.normal.y * this.max.y;
max += plane.normal.y * this.min.y;
}
if ( plane.normal.z > 0 ) {
min += plane.normal.z * this.min.z;
max += plane.normal.z * this.max.z;
} else {
min += plane.normal.z * this.max.z;
max += plane.normal.z * this.min.z;
}
return ( min <= - plane.constant && max >= - plane.constant );
},
intersectsTriangle: function ( triangle ) {
if ( this.isEmpty() ) {
return false;
}
// compute box center and extents
this.getCenter( _center );
_extents.subVectors( this.max, _center );
// translate triangle to aabb origin
_v0.subVectors( triangle.a, _center );
_v1.subVectors( triangle.b, _center );
_v2.subVectors( triangle.c, _center );
// compute edge vectors for triangle
_f0.subVectors( _v1, _v0 );
_f1.subVectors( _v2, _v1 );
_f2.subVectors( _v0, _v2 );
// test against axes that are given by cross product combinations of the edges of the triangle and the edges of the aabb
// make an axis testing of each of the 3 sides of the aabb against each of the 3 sides of the triangle = 9 axis of separation
// axis_ij = u_i x f_j (u0, u1, u2 = face normals of aabb = x,y,z axes vectors since aabb is axis aligned)
var axes = [
0, - _f0.z, _f0.y, 0, - _f1.z, _f1.y, 0, - _f2.z, _f2.y,
_f0.z, 0, - _f0.x, _f1.z, 0, - _f1.x, _f2.z, 0, - _f2.x,
- _f0.y, _f0.x, 0, - _f1.y, _f1.x, 0, - _f2.y, _f2.x, 0
];
if ( ! satForAxes( axes, _v0, _v1, _v2, _extents ) ) {
return false;
}
// test 3 face normals from the aabb
axes = [ 1, 0, 0, 0, 1, 0, 0, 0, 1 ];
if ( ! satForAxes( axes, _v0, _v1, _v2, _extents ) ) {
return false;
}
// finally testing the face normal of the triangle
// use already existing triangle edge vectors here
_triangleNormal.crossVectors( _f0, _f1 );
axes = [ _triangleNormal.x, _triangleNormal.y, _triangleNormal.z ];
return satForAxes( axes, _v0, _v1, _v2, _extents );
},
clampPoint: function ( point, target ) {
if ( target === undefined ) {
console.warn( 'Box3: .clampPoint() target is now required' );
target = new Vector3();
}
return target.copy( point ).clamp( this.min, this.max );
},
distanceToPoint: function ( point ) {
var clampedPoint = _vector$2.copy( point ).clamp( this.min, this.max );
return clampedPoint.sub( point ).length();
},
getBoundingSphere: function ( target ) {
if ( target === undefined ) {
console.error( 'Box3: .getBoundingSphere() target is now required' );
//target = new Sphere(); // removed to avoid cyclic dependency
}
this.getCenter( target.center );
target.radius = this.getSize( _vector$2 ).length() * 0.5;
return target;
},
intersect: function ( box ) {
this.min.max( box.min );
this.max.min( box.max );
// ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.
if ( this.isEmpty() ) { this.makeEmpty(); }
return this;
},
union: function ( box ) {
this.min.min( box.min );
this.max.max( box.max );
return this;
},
applyMatrix4: function ( matrix ) {
// transform of empty box is an empty box.
if ( this.isEmpty() ) { return this; }
// NOTE: I am using a binary pattern to specify all 2^3 combinations below
_points[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000
_points[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001
_points[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010
_points[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011
_points[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100
_points[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101
_points[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110
_points[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 111
this.setFromPoints( _points );
return this;
},
translate: function ( offset ) {
this.min.add( offset );
this.max.add( offset );
return this;
},
equals: function ( box ) {
return box.min.equals( this.min ) && box.max.equals( this.max );
}
} );
function satForAxes( axes, v0, v1, v2, extents ) {
var i, j;
for ( i = 0, j = axes.length - 3; i <= j; i += 3 ) {
_testAxis.fromArray( axes, i );
// project the aabb onto the seperating axis
var r = extents.x * Math.abs( _testAxis.x ) + extents.y * Math.abs( _testAxis.y ) + extents.z * Math.abs( _testAxis.z );
// project all 3 vertices of the triangle onto the seperating axis
var p0 = v0.dot( _testAxis );
var p1 = v1.dot( _testAxis );
var p2 = v2.dot( _testAxis );
// actual test, basically see if either of the most extreme of the triangle points intersects r
if ( Math.max( - Math.max( p0, p1, p2 ), Math.min( p0, p1, p2 ) ) > r ) {
// points of the projected triangle are outside the projected half-length of the aabb
// the axis is seperating and we can exit
return false;
}
}
return true;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WARNING: This file was auto-generated, any change will be overridden in next release. Please use configs/es6.conf.js then run "npm run convert". //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* https://github.com/mrdoob/eventdispatcher.js/
*/
function EventDispatcher() {}
Object.assign( EventDispatcher.prototype, {
addEventListener: function ( type, listener ) {
if ( this._listeners === undefined ) { this._listeners = {}; }
var listeners = this._listeners;
if ( listeners[ type ] === undefined ) {
listeners[ type ] = [];
}
if ( listeners[ type ].indexOf( listener ) === - 1 ) {
listeners[ type ].push( listener );
}
},
hasEventListener: function ( type, listener ) {
if ( this._listeners === undefined ) { return false; }
var listeners = this._listeners;
return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;
},
removeEventListener: function ( type, listener ) {
if ( this._listeners === undefined ) { return; }
var listeners = this._listeners;
var listenerArray = listeners[ type ];
if ( listenerArray !== undefined ) {
var index = listenerArray.indexOf( listener );
if ( index !== - 1 ) {
listenerArray.splice( index, 1 );
}
}
},
dispatchEvent: function ( event ) {
if ( this._listeners === undefined ) { return; }
var listeners = this._listeners;
var listenerArray = listeners[ event.type ];
if ( listenerArray !== undefined ) {
event.target = this;
var array = listenerArray.slice( 0 );
for ( var i = 0, l = array.length; i < l; i ++ ) {
array[ i ].call( this, event );
}
}
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var _box$1 = new Box3();
/**
* @author bhouston / http://clara.io
* @author mrdoob / http://mrdoob.com/
*/
function Sphere( center, radius ) {
this.center = ( center !== undefined ) ? center : new Vector3();
this.radius = ( radius !== undefined ) ? radius : 0;
}
Object.assign( Sphere.prototype, {
set: function ( center, radius ) {
this.center.copy( center );
this.radius = radius;
return this;
},
setFromPoints: function ( points, optionalCenter ) {
var center = this.center;
if ( optionalCenter !== undefined ) {
center.copy( optionalCenter );
} else {
_box$1.setFromPoints( points ).getCenter( center );
}
var maxRadiusSq = 0;
for ( var i = 0, il = points.length; i < il; i ++ ) {
maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( points[ i ] ) );
}
this.radius = Math.sqrt( maxRadiusSq );
return this;
},
clone: function () {
return new this.constructor().copy( this );
},
copy: function ( sphere ) {
this.center.copy( sphere.center );
this.radius = sphere.radius;
return this;
},
empty: function () {
return ( this.radius <= 0 );
},
containsPoint: function ( point ) {
return ( point.distanceToSquared( this.center ) <= ( this.radius * this.radius ) );
},
distanceToPoint: function ( point ) {
return ( point.distanceTo( this.center ) - this.radius );
},
intersectsSphere: function ( sphere ) {
var radiusSum = this.radius + sphere.radius;
return sphere.center.distanceToSquared( this.center ) <= ( radiusSum * radiusSum );
},
intersectsBox: function ( box ) {
return box.intersectsSphere( this );
},
intersectsPlane: function ( plane ) {
return Math.abs( plane.distanceToPoint( this.center ) ) <= this.radius;
},
clampPoint: function ( point, target ) {
var deltaLengthSq = this.center.distanceToSquared( point );
if ( target === undefined ) {
console.warn( 'Sphere: .clampPoint() target is now required' );
target = new Vector3();
}
target.copy( point );
if ( deltaLengthSq > ( this.radius * this.radius ) ) {
target.sub( this.center ).normalize();
target.multiplyScalar( this.radius ).add( this.center );
}
return target;
},
getBoundingBox: function ( target ) {
if ( target === undefined ) {
console.warn( 'Sphere: .getBoundingBox() target is now required' );
target = new Box3();
}
target.set( this.center, this.center );
target.expandByScalar( this.radius );
return target;
},
applyMatrix4: function ( matrix ) {
this.center.applyMatrix4( matrix );
this.radius = this.radius * matrix.getMaxScaleOnAxis();
return this;
},
translate: function ( offset ) {
this.center.add( offset );
return this;
},
equals: function ( sphere ) {
return sphere.center.equals( this.center ) && ( sphere.radius === this.radius );
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author mrdoob / http://mrdoob.com/
*/
function DirectGeometry() {
this.vertices = [];
this.normals = [];
this.colors = [];
this.uvs = [];
this.uvs2 = [];
this.groups = [];
this.morphTargets = {};
this.skinWeights = [];
this.skinIndices = [];
// this.lineDistances = [];
this.boundingBox = null;
this.boundingSphere = null;
// update flags
this.verticesNeedUpdate = false;
this.normalsNeedUpdate = false;
this.colorsNeedUpdate = false;
this.uvsNeedUpdate = false;
this.groupsNeedUpdate = false;
}
Object.assign( DirectGeometry.prototype, {
computeGroups: function ( geometry ) {
var group;
var groups = [];
var materialIndex = undefined;
var faces = geometry.faces;
for ( var i = 0; i < faces.length; i ++ ) {
var face = faces[ i ];
// materials
if ( face.materialIndex !== materialIndex ) {
materialIndex = face.materialIndex;
if ( group !== undefined ) {
group.count = ( i * 3 ) - group.start;
groups.push( group );
}
group = {
start: i * 3,
materialIndex: materialIndex
};
}
}
if ( group !== undefined ) {
group.count = ( i * 3 ) - group.start;
groups.push( group );
}
this.groups = groups;
},
fromGeometry: function ( geometry ) {
var faces = geometry.faces;
var vertices = geometry.vertices;
var faceVertexUvs = geometry.faceVertexUvs;
var hasFaceVertexUv = faceVertexUvs[ 0 ] && faceVertexUvs[ 0 ].length > 0;
var hasFaceVertexUv2 = faceVertexUvs[ 1 ] && faceVertexUvs[ 1 ].length > 0;
// morphs
var morphTargets = geometry.morphTargets;
var morphTargetsLength = morphTargets.length;
var morphTargetsPosition;
if ( morphTargetsLength > 0 ) {
morphTargetsPosition = [];
for ( var i = 0; i < morphTargetsLength; i ++ ) {
morphTargetsPosition[ i ] = {
name: morphTargets[ i ].name,
data: []
};
}
this.morphTargets.position = morphTargetsPosition;
}
var morphNormals = geometry.morphNormals;
var morphNormalsLength = morphNormals.length;
var morphTargetsNormal;
if ( morphNormalsLength > 0 ) {
morphTargetsNormal = [];
for ( var i = 0; i < morphNormalsLength; i ++ ) {
morphTargetsNormal[ i ] = {
name: morphNormals[ i ].name,
data: []
};
}
this.morphTargets.normal = morphTargetsNormal;
}
// skins
var skinIndices = geometry.skinIndices;
var skinWeights = geometry.skinWeights;
var hasSkinIndices = skinIndices.length === vertices.length;
var hasSkinWeights = skinWeights.length === vertices.length;
//
if ( vertices.length > 0 && faces.length === 0 ) {
console.error( 'DirectGeometry: Faceless geometries are not supported.' );
}
for ( var i = 0; i < faces.length; i ++ ) {
var face = faces[ i ];
this.vertices.push( vertices[ face.a ], vertices[ face.b ], vertices[ face.c ] );
var vertexNormals = face.vertexNormals;
if ( vertexNormals.length === 3 ) {
this.normals.push( vertexNormals[ 0 ], vertexNormals[ 1 ], vertexNormals[ 2 ] );
} else {
var normal = face.normal;
this.normals.push( normal, normal, normal );
}
var vertexColors = face.vertexColors;
if ( vertexColors.length === 3 ) {
this.colors.push( vertexColors[ 0 ], vertexColors[ 1 ], vertexColors[ 2 ] );
} else {
var color = face.color;
this.colors.push( color, color, color );
}
if ( hasFaceVertexUv === true ) {
var vertexUvs = faceVertexUvs[ 0 ][ i ];
if ( vertexUvs !== undefined ) {
this.uvs.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] );
} else {
console.warn( 'DirectGeometry.fromGeometry(): Undefined vertexUv ', i );
this.uvs.push( new Vector2(), new Vector2(), new Vector2() );
}
}
if ( hasFaceVertexUv2 === true ) {
var vertexUvs = faceVertexUvs[ 1 ][ i ];
if ( vertexUvs !== undefined ) {
this.uvs2.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] );
} else {
console.warn( 'DirectGeometry.fromGeometry(): Undefined vertexUv2 ', i );
this.uvs2.push( new Vector2(), new Vector2(), new Vector2() );
}
}
// morphs
for ( var j = 0; j < morphTargetsLength; j ++ ) {
var morphTarget = morphTargets[ j ].vertices;
morphTargetsPosition[ j ].data.push( morphTarget[ face.a ], morphTarget[ face.b ], morphTarget[ face.c ] );
}
for ( var j = 0; j < morphNormalsLength; j ++ ) {
var morphNormal = morphNormals[ j ].vertexNormals[ i ];
morphTargetsNormal[ j ].data.push( morphNormal.a, morphNormal.b, morphNormal.c );
}
// skins
if ( hasSkinIndices ) {
this.skinIndices.push( skinIndices[ face.a ], skinIndices[ face.b ], skinIndices[ face.c ] );
}
if ( hasSkinWeights ) {
this.skinWeights.push( skinWeights[ face.a ], skinWeights[ face.b ], skinWeights[ face.c ] );
}
}
this.computeGroups( geometry );
this.verticesNeedUpdate = geometry.verticesNeedUpdate;
this.normalsNeedUpdate = geometry.normalsNeedUpdate;
this.colorsNeedUpdate = geometry.colorsNeedUpdate;
this.uvsNeedUpdate = geometry.uvsNeedUpdate;
this.groupsNeedUpdate = geometry.groupsNeedUpdate;
if ( geometry.boundingSphere !== null ) {
this.boundingSphere = geometry.boundingSphere.clone();
}
if ( geometry.boundingBox !== null ) {
this.boundingBox = geometry.boundingBox.clone();
}
return this;
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var _v1$1 = new Vector3();
var _m1 = new Matrix4();
var _zero = new Vector3( 0, 0, 0 );
var _one = new Vector3( 1, 1, 1 );
var _x = new Vector3();
var _y = new Vector3();
var _z = new Vector3();
/**
* @author mrdoob / http://mrdoob.com/
* @author supereggbert / http://www.paulbrunt.co.uk/
* @author philogb / http://blog.thejit.org/
* @author jordi_ros / http://plattsoft.com
* @author D1plo1d / http://github.com/D1plo1d
* @author alteredq / http://alteredqualia.com/
* @author mikael emtinger / http://gomo.se/
* @author timknip / http://www.floorplanner.com/
* @author bhouston / http://clara.io
* @author WestLangley / http://github.com/WestLangley
*/
function Matrix4() {
this.elements = [
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
];
if ( arguments.length > 0 ) {
console.error( 'Matrix4: the constructor no longer reads arguments. use .set() instead.' );
}
}
Object.assign( Matrix4.prototype, {
isMatrix4: true,
set: function ( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) {
var te = this.elements;
te[ 0 ] = n11; te[ 4 ] = n12; te[ 8 ] = n13; te[ 12 ] = n14;
te[ 1 ] = n21; te[ 5 ] = n22; te[ 9 ] = n23; te[ 13 ] = n24;
te[ 2 ] = n31; te[ 6 ] = n32; te[ 10 ] = n33; te[ 14 ] = n34;
te[ 3 ] = n41; te[ 7 ] = n42; te[ 11 ] = n43; te[ 15 ] = n44;
return this;
},
identity: function () {
this.set(
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
);
return this;
},
clone: function () {
return new Matrix4().fromArray( this.elements );
},
copy: function ( m ) {
var te = this.elements;
var me = m.elements;
te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ]; te[ 3 ] = me[ 3 ];
te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ]; te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ];
te[ 8 ] = me[ 8 ]; te[ 9 ] = me[ 9 ]; te[ 10 ] = me[ 10 ]; te[ 11 ] = me[ 11 ];
te[ 12 ] = me[ 12 ]; te[ 13 ] = me[ 13 ]; te[ 14 ] = me[ 14 ]; te[ 15 ] = me[ 15 ];
return this;
},
copyPosition: function ( m ) {
var te = this.elements, me = m.elements;
te[ 12 ] = me[ 12 ];
te[ 13 ] = me[ 13 ];
te[ 14 ] = me[ 14 ];
return this;
},
extractBasis: function ( xAxis, yAxis, zAxis ) {
xAxis.setFromMatrixColumn( this, 0 );
yAxis.setFromMatrixColumn( this, 1 );
zAxis.setFromMatrixColumn( this, 2 );
return this;
},
makeBasis: function ( xAxis, yAxis, zAxis ) {
this.set(
xAxis.x, yAxis.x, zAxis.x, 0,
xAxis.y, yAxis.y, zAxis.y, 0,
xAxis.z, yAxis.z, zAxis.z, 0,
0, 0, 0, 1
);
return this;
},
extractRotation: function ( m ) {
// this method does not support reflection matrices
var te = this.elements;
var me = m.elements;
var scaleX = 1 / _v1$1.setFromMatrixColumn( m, 0 ).length();
var scaleY = 1 / _v1$1.setFromMatrixColumn( m, 1 ).length();
var scaleZ = 1 / _v1$1.setFromMatrixColumn( m, 2 ).length();
te[ 0 ] = me[ 0 ] * scaleX;
te[ 1 ] = me[ 1 ] * scaleX;
te[ 2 ] = me[ 2 ] * scaleX;
te[ 3 ] = 0;
te[ 4 ] = me[ 4 ] * scaleY;
te[ 5 ] = me[ 5 ] * scaleY;
te[ 6 ] = me[ 6 ] * scaleY;
te[ 7 ] = 0;
te[ 8 ] = me[ 8 ] * scaleZ;
te[ 9 ] = me[ 9 ] * scaleZ;
te[ 10 ] = me[ 10 ] * scaleZ;
te[ 11 ] = 0;
te[ 12 ] = 0;
te[ 13 ] = 0;
te[ 14 ] = 0;
te[ 15 ] = 1;
return this;
},
makeRotationFromEuler: function ( euler ) {
if ( ! ( euler && euler.isEuler ) ) {
console.error( 'Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.' );
}
var te = this.elements;
var x = euler.x, y = euler.y, z = euler.z;
var a = Math.cos( x ), b = Math.sin( x );
var c = Math.cos( y ), d = Math.sin( y );
var e = Math.cos( z ), f = Math.sin( z );
if ( euler.order === 'XYZ' ) {
var ae = a * e, af = a * f, be = b * e, bf = b * f;
te[ 0 ] = c * e;
te[ 4 ] = - c * f;
te[ 8 ] = d;
te[ 1 ] = af + be * d;
te[ 5 ] = ae - bf * d;
te[ 9 ] = - b * c;
te[ 2 ] = bf - ae * d;
te[ 6 ] = be + af * d;
te[ 10 ] = a * c;
} else if ( euler.order === 'YXZ' ) {
var ce = c * e, cf = c * f, de = d * e, df = d * f;
te[ 0 ] = ce + df * b;
te[ 4 ] = de * b - cf;
te[ 8 ] = a * d;
te[ 1 ] = a * f;
te[ 5 ] = a * e;
te[ 9 ] = - b;
te[ 2 ] = cf * b - de;
te[ 6 ] = df + ce * b;
te[ 10 ] = a * c;
} else if ( euler.order === 'ZXY' ) {
var ce = c * e, cf = c * f, de = d * e, df = d * f;
te[ 0 ] = ce - df * b;
te[ 4 ] = - a * f;
te[ 8 ] = de + cf * b;
te[ 1 ] = cf + de * b;
te[ 5 ] = a * e;
te[ 9 ] = df - ce * b;
te[ 2 ] = - a * d;
te[ 6 ] = b;
te[ 10 ] = a * c;
} else if ( euler.order === 'ZYX' ) {
var ae = a * e, af = a * f, be = b * e, bf = b * f;
te[ 0 ] = c * e;
te[ 4 ] = be * d - af;
te[ 8 ] = ae * d + bf;
te[ 1 ] = c * f;
te[ 5 ] = bf * d + ae;
te[ 9 ] = af * d - be;
te[ 2 ] = - d;
te[ 6 ] = b * c;
te[ 10 ] = a * c;
} else if ( euler.order === 'YZX' ) {
var ac = a * c, ad = a * d, bc = b * c, bd = b * d;
te[ 0 ] = c * e;
te[ 4 ] = bd - ac * f;
te[ 8 ] = bc * f + ad;
te[ 1 ] = f;
te[ 5 ] = a * e;
te[ 9 ] = - b * e;
te[ 2 ] = - d * e;
te[ 6 ] = ad * f + bc;
te[ 10 ] = ac - bd * f;
} else if ( euler.order === 'XZY' ) {
var ac = a * c, ad = a * d, bc = b * c, bd = b * d;
te[ 0 ] = c * e;
te[ 4 ] = - f;
te[ 8 ] = d * e;
te[ 1 ] = ac * f + bd;
te[ 5 ] = a * e;
te[ 9 ] = ad * f - bc;
te[ 2 ] = bc * f - ad;
te[ 6 ] = b * e;
te[ 10 ] = bd * f + ac;
}
// bottom row
te[ 3 ] = 0;
te[ 7 ] = 0;
te[ 11 ] = 0;
// last column
te[ 12 ] = 0;
te[ 13 ] = 0;
te[ 14 ] = 0;
te[ 15 ] = 1;
return this;
},
makeRotationFromQuaternion: function ( q ) {
return this.compose( _zero, q, _one );
},
lookAt: function ( eye, target, up ) {
var te = this.elements;
_z.subVectors( eye, target );
if ( _z.lengthSq() === 0 ) {
// eye and target are in the same position
_z.z = 1;
}
_z.normalize();
_x.crossVectors( up, _z );
if ( _x.lengthSq() === 0 ) {
// up and z are 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 );
te[ 0 ] = _x.x; te[ 4 ] = _y.x; te[ 8 ] = _z.x;
te[ 1 ] = _x.y; te[ 5 ] = _y.y; te[ 9 ] = _z.y;
te[ 2 ] = _x.z; te[ 6 ] = _y.z; te[ 10 ] = _z.z;
return this;
},
multiply: function ( m, n ) {
if ( n !== undefined ) {
console.warn( 'Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead.' );
return this.multiplyMatrices( m, n );
}
return this.multiplyMatrices( this, m );
},
premultiply: function ( m ) {
return this.multiplyMatrices( m, this );
},
multiplyMatrices: function ( a, b ) {
var ae = a.elements;
var be = b.elements;
var te = this.elements;
var a11 = ae[ 0 ], a12 = ae[ 4 ], a13 = ae[ 8 ], a14 = ae[ 12 ];
var a21 = ae[ 1 ], a22 = ae[ 5 ], a23 = ae[ 9 ], a24 = ae[ 13 ];
var a31 = ae[ 2 ], a32 = ae[ 6 ], a33 = ae[ 10 ], a34 = ae[ 14 ];
var a41 = ae[ 3 ], a42 = ae[ 7 ], a43 = ae[ 11 ], a44 = ae[ 15 ];
var b11 = be[ 0 ], b12 = be[ 4 ], b13 = be[ 8 ], b14 = be[ 12 ];
var b21 = be[ 1 ], b22 = be[ 5 ], b23 = be[ 9 ], b24 = be[ 13 ];
var b31 = be[ 2 ], b32 = be[ 6 ], b33 = be[ 10 ], b34 = be[ 14 ];
var b41 = be[ 3 ], b42 = be[ 7 ], b43 = be[ 11 ], b44 = be[ 15 ];
te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
te[ 4 ] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
te[ 8 ] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
te[ 12 ] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
te[ 5 ] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
te[ 9 ] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
te[ 13 ] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
te[ 6 ] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
te[ 10 ] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
te[ 14 ] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
te[ 3 ] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
te[ 7 ] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
te[ 11 ] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
te[ 15 ] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
return this;
},
multiplyScalar: function ( s ) {
var te = this.elements;
te[ 0 ] *= s; te[ 4 ] *= s; te[ 8 ] *= s; te[ 12 ] *= s;
te[ 1 ] *= s; te[ 5 ] *= s; te[ 9 ] *= s; te[ 13 ] *= s;
te[ 2 ] *= s; te[ 6 ] *= s; te[ 10 ] *= s; te[ 14 ] *= s;
te[ 3 ] *= s; te[ 7 ] *= s; te[ 11 ] *= s; te[ 15 ] *= s;
return this;
},
determinant: function () {
var te = this.elements;
var n11 = te[ 0 ], n12 = te[ 4 ], n13 = te[ 8 ], n14 = te[ 12 ];
var n21 = te[ 1 ], n22 = te[ 5 ], n23 = te[ 9 ], n24 = te[ 13 ];
var n31 = te[ 2 ], n32 = te[ 6 ], n33 = te[ 10 ], n34 = te[ 14 ];
var n41 = te[ 3 ], n42 = te[ 7 ], n43 = te[ 11 ], n44 = te[ 15 ];
//TODO: make this more efficient
//( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )
return (
n41 * (
+ n14 * n23 * n32
- n13 * n24 * n32
- n14 * n22 * n33
+ n12 * n24 * n33
+ n13 * n22 * n34
- n12 * n23 * n34
) +
n42 * (
+ n11 * n23 * n34
- n11 * n24 * n33
+ n14 * n21 * n33
- n13 * n21 * n34
+ n13 * n24 * n31
- n14 * n23 * n31
) +
n43 * (
+ n11 * n24 * n32
- n11 * n22 * n34
- n14 * n21 * n32
+ n12 * n21 * n34
+ n14 * n22 * n31
- n12 * n24 * n31
) +
n44 * (
- n13 * n22 * n31
- n11 * n23 * n32
+ n11 * n22 * n33
+ n13 * n21 * n32
- n12 * n21 * n33
+ n12 * n23 * n31
)
);
},
transpose: function () {
var te = this.elements;
var tmp;
tmp = te[ 1 ]; te[ 1 ] = te[ 4 ]; te[ 4 ] = tmp;
tmp = te[ 2 ]; te[ 2 ] = te[ 8 ]; te[ 8 ] = tmp;
tmp = te[ 6 ]; te[ 6 ] = te[ 9 ]; te[ 9 ] = tmp;
tmp = te[ 3 ]; te[ 3 ] = te[ 12 ]; te[ 12 ] = tmp;
tmp = te[ 7 ]; te[ 7 ] = te[ 13 ]; te[ 13 ] = tmp;
tmp = te[ 11 ]; te[ 11 ] = te[ 14 ]; te[ 14 ] = tmp;
return this;
},
setPosition: function ( x, y, z ) {
var te = this.elements;
if ( x.isVector3 ) {
te[ 12 ] = x.x;
te[ 13 ] = x.y;
te[ 14 ] = x.z;
} else {
te[ 12 ] = x;
te[ 13 ] = y;
te[ 14 ] = z;
}
return this;
},
getInverse: function ( m, throwOnDegenerate ) {
// based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
var te = this.elements,
me = m.elements,
n11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ], n41 = me[ 3 ],
n12 = me[ 4 ], n22 = me[ 5 ], n32 = me[ 6 ], n42 = me[ 7 ],
n13 = me[ 8 ], n23 = me[ 9 ], n33 = me[ 10 ], n43 = me[ 11 ],
n14 = me[ 12 ], n24 = me[ 13 ], n34 = me[ 14 ], n44 = me[ 15 ],
t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,
t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,
t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,
t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
var det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
if ( det === 0 ) {
var msg = "Matrix4: .getInverse() can't invert matrix, determinant is 0";
if ( throwOnDegenerate === true ) {
throw new Error( msg );
} else {
console.warn( msg );
}
return this.identity();
}
var detInv = 1 / det;
te[ 0 ] = t11 * detInv;
te[ 1 ] = ( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * detInv;
te[ 2 ] = ( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * detInv;
te[ 3 ] = ( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * detInv;
te[ 4 ] = t12 * detInv;
te[ 5 ] = ( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * detInv;
te[ 6 ] = ( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * detInv;
te[ 7 ] = ( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * detInv;
te[ 8 ] = t13 * detInv;
te[ 9 ] = ( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * detInv;
te[ 10 ] = ( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * detInv;
te[ 11 ] = ( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * detInv;
te[ 12 ] = t14 * detInv;
te[ 13 ] = ( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * detInv;
te[ 14 ] = ( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * detInv;
te[ 15 ] = ( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * detInv;
return this;
},
scale: function ( v ) {
var te = this.elements;
var x = v.x, y = v.y, z = v.z;
te[ 0 ] *= x; te[ 4 ] *= y; te[ 8 ] *= z;
te[ 1 ] *= x; te[ 5 ] *= y; te[ 9 ] *= z;
te[ 2 ] *= x; te[ 6 ] *= y; te[ 10 ] *= z;
te[ 3 ] *= x; te[ 7 ] *= y; te[ 11 ] *= z;
return this;
},
getMaxScaleOnAxis: function () {
var te = this.elements;
var scaleXSq = te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ];
var scaleYSq = te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ];
var scaleZSq = te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ];
return Math.sqrt( Math.max( scaleXSq, scaleYSq, scaleZSq ) );
},
makeTranslation: function ( x, y, z ) {
this.set(
1, 0, 0, x,
0, 1, 0, y,
0, 0, 1, z,
0, 0, 0, 1
);
return this;
},
makeRotationX: function ( theta ) {
var c = Math.cos( theta ), s = Math.sin( theta );
this.set(
1, 0, 0, 0,
0, c, - s, 0,
0, s, c, 0,
0, 0, 0, 1
);
return this;
},
makeRotationY: function ( theta ) {
var c = Math.cos( theta ), s = Math.sin( theta );
this.set(
c, 0, s, 0,
0, 1, 0, 0,
- s, 0, c, 0,
0, 0, 0, 1
);
return this;
},
makeRotationZ: function ( theta ) {
var c = Math.cos( theta ), s = Math.sin( theta );
this.set(
c, - s, 0, 0,
s, c, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
);
return this;
},
makeRotationAxis: function ( axis, angle ) {
// Based on http://www.gamedev.net/reference/articles/article1199.asp
var c = Math.cos( angle );
var s = Math.sin( angle );
var t = 1 - c;
var x = axis.x, y = axis.y, z = axis.z;
var tx = t * x, ty = t * y;
this.set(
tx * x + c, tx * y - s * z, tx * z + s * y, 0,
tx * y + s * z, ty * y + c, ty * z - s * x, 0,
tx * z - s * y, ty * z + s * x, t * z * z + c, 0,
0, 0, 0, 1
);
return this;
},
makeScale: function ( x, y, z ) {
this.set(
x, 0, 0, 0,
0, y, 0, 0,
0, 0, z, 0,
0, 0, 0, 1
);
return this;
},
makeShear: function ( x, y, z ) {
this.set(
1, y, z, 0,
x, 1, z, 0,
x, y, 1, 0,
0, 0, 0, 1
);
return this;
},
compose: function ( position, quaternion, scale ) {
var te = this.elements;
var x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;
var x2 = x + x, y2 = y + y, z2 = z + z;
var xx = x * x2, xy = x * y2, xz = x * z2;
var yy = y * y2, yz = y * z2, zz = z * z2;
var wx = w * x2, wy = w * y2, wz = w * z2;
var sx = scale.x, sy = scale.y, sz = scale.z;
te[ 0 ] = ( 1 - ( yy + zz ) ) * sx;
te[ 1 ] = ( xy + wz ) * sx;
te[ 2 ] = ( xz - wy ) * sx;
te[ 3 ] = 0;
te[ 4 ] = ( xy - wz ) * sy;
te[ 5 ] = ( 1 - ( xx + zz ) ) * sy;
te[ 6 ] = ( yz + wx ) * sy;
te[ 7 ] = 0;
te[ 8 ] = ( xz + wy ) * sz;
te[ 9 ] = ( yz - wx ) * sz;
te[ 10 ] = ( 1 - ( xx + yy ) ) * sz;
te[ 11 ] = 0;
te[ 12 ] = position.x;
te[ 13 ] = position.y;
te[ 14 ] = position.z;
te[ 15 ] = 1;
return this;
},
decompose: function ( position, quaternion, scale ) {
var te = this.elements;
var sx = _v1$1.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();
var sy = _v1$1.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();
var sz = _v1$1.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();
// if determine is negative, we need to invert one scale
var det = this.determinant();
if ( det < 0 ) { sx = - sx; }
position.x = te[ 12 ];
position.y = te[ 13 ];
position.z = te[ 14 ];
// scale the rotation part
_m1.copy( this );
var invSX = 1 / sx;
var invSY = 1 / sy;
var invSZ = 1 / sz;
_m1.elements[ 0 ] *= invSX;
_m1.elements[ 1 ] *= invSX;
_m1.elements[ 2 ] *= invSX;
_m1.elements[ 4 ] *= invSY;
_m1.elements[ 5 ] *= invSY;
_m1.elements[ 6 ] *= invSY;
_m1.elements[ 8 ] *= invSZ;
_m1.elements[ 9 ] *= invSZ;
_m1.elements[ 10 ] *= invSZ;
quaternion.setFromRotationMatrix( _m1 );
scale.x = sx;
scale.y = sy;
scale.z = sz;
return this;
},
makePerspective: function ( left, right, top, bottom, near, far ) {
if ( far === undefined ) {
console.warn( 'Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.' );
}
var te = this.elements;
var x = 2 * near / ( right - left );
var y = 2 * near / ( top - bottom );
var a = ( right + left ) / ( right - left );
var b = ( top + bottom ) / ( top - bottom );
var c = - ( far + near ) / ( far - near );
var d = - 2 * far * near / ( far - near );
te[ 0 ] = x; te[ 4 ] = 0; te[ 8 ] = a; te[ 12 ] = 0;
te[ 1 ] = 0; te[ 5 ] = y; te[ 9 ] = b; te[ 13 ] = 0;
te[ 2 ] = 0; te[ 6 ] = 0; te[ 10 ] = c; te[ 14 ] = d;
te[ 3 ] = 0; te[ 7 ] = 0; te[ 11 ] = - 1; te[ 15 ] = 0;
return this;
},
makeOrthographic: function ( left, right, top, bottom, near, far ) {
var te = this.elements;
var w = 1.0 / ( right - left );
var h = 1.0 / ( top - bottom );
var p = 1.0 / ( far - near );
var x = ( right + left ) * w;
var y = ( top + bottom ) * h;
var z = ( far + near ) * p;
te[ 0 ] = 2 * w; te[ 4 ] = 0; te[ 8 ] = 0; te[ 12 ] = - x;
te[ 1 ] = 0; te[ 5 ] = 2 * h; te[ 9 ] = 0; te[ 13 ] = - y;
te[ 2 ] = 0; te[ 6 ] = 0; te[ 10 ] = - 2 * p; te[ 14 ] = - z;
te[ 3 ] = 0; te[ 7 ] = 0; te[ 11 ] = 0; te[ 15 ] = 1;
return this;
},
equals: function ( matrix ) {
var te = this.elements;
var me = matrix.elements;
for ( var i = 0; i < 16; i ++ ) {
if ( te[ i ] !== me[ i ] ) { return false; }
}
return true;
},
fromArray: function ( array, offset ) {
if ( offset === undefined ) { offset = 0; }
for ( var i = 0; i < 16; i ++ ) {
this.elements[ i ] = array[ i + offset ];
}
return this;
},
toArray: function ( array, offset ) {
if ( array === undefined ) { array = []; }
if ( offset === undefined ) { offset = 0; }
var te = this.elements;
array[ offset ] = te[ 0 ];
array[ offset + 1 ] = te[ 1 ];
array[ offset + 2 ] = te[ 2 ];
array[ offset + 3 ] = te[ 3 ];
array[ offset + 4 ] = te[ 4 ];
array[ offset + 5 ] = te[ 5 ];
array[ offset + 6 ] = te[ 6 ];
array[ offset + 7 ] = te[ 7 ];
array[ offset + 8 ] = te[ 8 ];
array[ offset + 9 ] = te[ 9 ];
array[ offset + 10 ] = te[ 10 ];
array[ offset + 11 ] = te[ 11 ];
array[ offset + 12 ] = te[ 12 ];
array[ offset + 13 ] = te[ 13 ];
array[ offset + 14 ] = te[ 14 ];
array[ offset + 15 ] = te[ 15 ];
return array;
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author mrdoob / http://mrdoob.com/
* @author WestLangley / http://github.com/WestLangley
* @author bhouston / http://clara.io
*/
var _matrix = new Matrix4();
var _quaternion$1 = new Quaternion();
function Euler( x, y, z, order ) {
this._x = x || 0;
this._y = y || 0;
this._z = z || 0;
this._order = order || Euler.DefaultOrder;
}
Euler.RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ];
Euler.DefaultOrder = 'XYZ';
Object.defineProperties( Euler.prototype, {
x: {
get: function () {
return this._x;
},
set: function ( value ) {
this._x = value;
this._onChangeCallback();
}
},
y: {
get: function () {
return this._y;
},
set: function ( value ) {
this._y = value;
this._onChangeCallback();
}
},
z: {
get: function () {
return this._z;
},
set: function ( value ) {
this._z = value;
this._onChangeCallback();
}
},
order: {
get: function () {
return this._order;
},
set: function ( value ) {
this._order = value;
this._onChangeCallback();
}
}
} );
Object.assign( Euler.prototype, {
isEuler: true,
set: function ( x, y, z, order ) {
this._x = x;
this._y = y;
this._z = z;
this._order = order || this._order;
this._onChangeCallback();
return this;
},
clone: function () {
return new this.constructor( this._x, this._y, this._z, this._order );
},
copy: function ( euler ) {
this._x = euler._x;
this._y = euler._y;
this._z = euler._z;
this._order = euler._order;
this._onChangeCallback();
return this;
},
setFromRotationMatrix: function ( m, order, update ) {
var clamp = MathUtils.clamp;
// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
var te = m.elements;
var m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ];
var m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ];
var m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
order = order || this._order;
if ( order === 'XYZ' ) {
this._y = Math.asin( clamp( m13, - 1, 1 ) );
if ( Math.abs( m13 ) < 0.9999999 ) {
this._x = Math.atan2( - m23, m33 );
this._z = Math.atan2( - m12, m11 );
} else {
this._x = Math.atan2( m32, m22 );
this._z = 0;
}
} else if ( order === 'YXZ' ) {
this._x = Math.asin( - clamp( m23, - 1, 1 ) );
if ( Math.abs( m23 ) < 0.9999999 ) {
this._y = Math.atan2( m13, m33 );
this._z = Math.atan2( m21, m22 );
} else {
this._y = Math.atan2( - m31, m11 );
this._z = 0;
}
} else if ( order === 'ZXY' ) {
this._x = Math.asin( clamp( m32, - 1, 1 ) );
if ( Math.abs( m32 ) < 0.9999999 ) {
this._y = Math.atan2( - m31, m33 );
this._z = Math.atan2( - m12, m22 );
} else {
this._y = 0;
this._z = Math.atan2( m21, m11 );
}
} else if ( order === 'ZYX' ) {
this._y = Math.asin( - clamp( m31, - 1, 1 ) );
if ( Math.abs( m31 ) < 0.9999999 ) {
this._x = Math.atan2( m32, m33 );
this._z = Math.atan2( m21, m11 );
} else {
this._x = 0;
this._z = Math.atan2( - m12, m22 );
}
} else if ( order === 'YZX' ) {
this._z = Math.asin( clamp( m21, - 1, 1 ) );
if ( Math.abs( m21 ) < 0.9999999 ) {
this._x = Math.atan2( - m23, m22 );
this._y = Math.atan2( - m31, m11 );
} else {
this._x = 0;
this._y = Math.atan2( m13, m33 );
}
} else if ( order === 'XZY' ) {
this._z = Math.asin( - clamp( m12, - 1, 1 ) );
if ( Math.abs( m12 ) < 0.9999999 ) {
this._x = Math.atan2( m32, m22 );
this._y = Math.atan2( m13, m11 );
} else {
this._x = Math.atan2( - m23, m33 );
this._y = 0;
}
} else {
console.warn( 'Euler: .setFromRotationMatrix() given unsupported order: ' + order );
}
this._order = order;
if ( update !== false ) { this._onChangeCallback(); }
return this;
},
setFromQuaternion: function ( q, order, update ) {
_matrix.makeRotationFromQuaternion( q );
return this.setFromRotationMatrix( _matrix, order, update );
},
setFromVector3: function ( v, order ) {
return this.set( v.x, v.y, v.z, order || this._order );
},
reorder: function ( newOrder ) {
// WARNING: this discards revolution information -bhouston
_quaternion$1.setFromEuler( this );
return this.setFromQuaternion( _quaternion$1, newOrder );
},
equals: function ( euler ) {
return ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );
},
fromArray: function ( array ) {
this._x = array[ 0 ];
this._y = array[ 1 ];
this._z = array[ 2 ];
if ( array[ 3 ] !== undefined ) { this._order = array[ 3 ]; }
this._onChangeCallback();
return this;
},
toArray: function ( array, offset ) {
if ( array === undefined ) { array = []; }
if ( offset === undefined ) { offset = 0; }
array[ offset ] = this._x;
array[ offset + 1 ] = this._y;
array[ offset + 2 ] = this._z;
array[ offset + 3 ] = this._order;
return array;
},
toVector3: function ( optionalResult ) {
if ( optionalResult ) {
return optionalResult.set( this._x, this._y, this._z );
} else {
return new Vector3( this._x, this._y, this._z );
}
},
_onChange: function ( callback ) {
this._onChangeCallback = callback;
return this;
},
_onChangeCallback: function () {}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WARNING: This file was auto-generated, any change will be overridden in next release. Please use configs/es6.conf.js then run "npm run convert". //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author mrdoob / http://mrdoob.com/
*/
function Layers() {
this.mask = 1 | 0;
}
Object.assign( Layers.prototype, {
set: function ( channel ) {
this.mask = 1 << channel | 0;
},
enable: function ( channel ) {
this.mask |= 1 << channel | 0;
},
enableAll: function () {
this.mask = 0xffffffff | 0;
},
toggle: function ( channel ) {
this.mask ^= 1 << channel | 0;
},
disable: function ( channel ) {
this.mask &= ~ ( 1 << channel | 0 );
},
disableAll: function () {
this.mask = 0;
},
test: function ( layers ) {
return ( this.mask & layers.mask ) !== 0;
}
} );
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WARNING: This file was auto-generated, any change will be overridden in next release. Please use configs/es6.conf.js then run "npm run convert". //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* @author alteredq / http://alteredqualia.com/
* @author WestLangley / http://github.com/WestLangley
* @author bhouston / http://clara.io
* @author tschw
*/
function Matrix3() {
this.elements = [
1, 0, 0,
0, 1, 0,
0, 0, 1
];
if ( arguments.length > 0 ) {
console.error( 'Matrix3: the constructor no longer reads arguments. use .set() instead.' );
}
}
Object.assign( Matrix3.prototype, {
isMatrix3: true,
set: function ( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
var te = this.elements;
te[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;
te[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;
te[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;
return this;
},
identity: function () {
this.set(
1, 0, 0,
0, 1, 0,
0, 0, 1
);
return this;
},
clone: function () {
return new this.constructor().fromArray( this.elements );
},
copy: function ( m ) {
var te = this.elements;
var me = m.elements;
te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];
te[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];
te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];
return this;
},
setFromMatrix4: function ( m ) {
var me = m.elements;
this.set(
me[ 0 ], me[ 4 ], me[ 8 ],
me[ 1 ], me[ 5 ], me[ 9 ],
me[ 2 ], me[ 6 ], me[ 10 ]
);
return this;
},
multiply: function ( m ) {
return this.multiplyMatrices( this, m );
},
premultiply: function ( m ) {
return this.multiplyMatrices( m, this );
},
multiplyMatrices: function ( a, b ) {
var ae = a.elements;
var be = b.elements;
var te = this.elements;
var a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];
var a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];
var a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];
var b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];
var b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];
var b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];
te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;
te[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;
te[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;
te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;
te[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;
te[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;
te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;
te[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;
te[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;
return this;
},
multiplyScalar: function ( s ) {
var te = this.elements;
te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;
te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;
te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;
return this;
},
determinant: function () {
var te = this.elements;
var a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],
d = te[ 3 ], e = te[ 4 ], f = te[ 5 ],
g = te[ 6 ], h = te[ 7 ], i = te[ 8 ];
return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
},
getInverse: function ( matrix, throwOnDegenerate ) {
if ( matrix && matrix.isMatrix4 ) {
console.error( "Matrix3: .getInverse() no longer takes a Matrix4 argument." );
}
var me = matrix.elements,
te = this.elements,
n11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ],
n12 = me[ 3 ], n22 = me[ 4 ], n32 = me[ 5 ],
n13 = me[ 6 ], n23 = me[ 7 ], n33 = me
gitextract_80_q7e8j/ ├── .gitignore ├── .npmignore ├── LICENSE.md ├── README.md ├── builds/ │ ├── Three.amd.js │ ├── Three.cjs.js │ ├── Three.es.js │ ├── Three.iife.js │ └── Three.umd.js ├── configs/ │ ├── es6.conf.js │ ├── eslint.conf.js │ ├── karma.units.conf.js │ ├── rollup.conf.js │ ├── rollup.tests.conf.js │ └── units.conf.js ├── es6-convertor.js ├── gulpfile.js ├── package.json ├── sources/ │ ├── ImageUtils.d.ts │ ├── PMREMGenerator.d.ts │ ├── ShapeUtils.d.ts │ ├── Three.d.ts │ ├── Three.js │ ├── WebGL.d.ts │ ├── animation/ │ │ ├── AnimationAction.d.ts │ │ ├── AnimationAction.js │ │ ├── AnimationClip.d.ts │ │ ├── AnimationClip.js │ │ ├── AnimationClipCreator.d.ts │ │ ├── AnimationClipCreator.js │ │ ├── AnimationMixer.d.ts │ │ ├── AnimationMixer.js │ │ ├── AnimationObjectGroup.d.ts │ │ ├── AnimationObjectGroup.js │ │ ├── AnimationUtils.d.ts │ │ ├── AnimationUtils.js │ │ ├── CCDIKSolver.d.ts │ │ ├── CCDIKSolver.js │ │ ├── KeyframeTrack.d.ts │ │ ├── KeyframeTrack.js │ │ ├── MMDAnimationHelper.d.ts │ │ ├── MMDAnimationHelper.js │ │ ├── MMDPhysics.d.ts │ │ ├── MMDPhysics.js │ │ ├── PropertyBinding.d.ts │ │ ├── PropertyBinding.js │ │ ├── PropertyMixer.d.ts │ │ ├── PropertyMixer.js │ │ ├── TimelinerController.d.ts │ │ ├── TimelinerController.js │ │ └── tracks/ │ │ ├── BooleanKeyframeTrack.d.ts │ │ ├── BooleanKeyframeTrack.js │ │ ├── ColorKeyframeTrack.d.ts │ │ ├── ColorKeyframeTrack.js │ │ ├── NumberKeyframeTrack.d.ts │ │ ├── NumberKeyframeTrack.js │ │ ├── QuaternionKeyframeTrack.d.ts │ │ ├── QuaternionKeyframeTrack.js │ │ ├── StringKeyframeTrack.d.ts │ │ ├── StringKeyframeTrack.js │ │ ├── VectorKeyframeTrack.d.ts │ │ └── VectorKeyframeTrack.js │ ├── audio/ │ │ ├── Audio.d.ts │ │ ├── Audio.js │ │ ├── AudioAnalyser.d.ts │ │ ├── AudioAnalyser.js │ │ ├── AudioContext.d.ts │ │ ├── AudioContext.js │ │ ├── AudioListener.d.ts │ │ ├── AudioListener.js │ │ ├── PositionalAudio.d.ts │ │ ├── PositionalAudio.js │ │ └── VolumeSlice.js │ ├── cameras/ │ │ ├── ArrayCamera.d.ts │ │ ├── ArrayCamera.js │ │ ├── Camera.d.ts │ │ ├── Camera.js │ │ ├── CinematicCamera.d.ts │ │ ├── CinematicCamera.js │ │ ├── CubeCamera.d.ts │ │ ├── CubeCamera.js │ │ ├── OrthographicCamera.d.ts │ │ ├── OrthographicCamera.js │ │ ├── PerspectiveCamera.d.ts │ │ ├── PerspectiveCamera.js │ │ ├── StereoCamera.d.ts │ │ └── StereoCamera.js │ ├── constants.d.ts │ ├── constants.js │ ├── controls/ │ │ ├── DeviceOrientationControls.d.ts │ │ ├── DeviceOrientationControls.js │ │ ├── DragControls.d.ts │ │ ├── DragControls.js │ │ ├── FirstPersonControls.d.ts │ │ ├── FirstPersonControls.js │ │ ├── FlyControls.d.ts │ │ ├── FlyControls.js │ │ ├── OrbitControls.d.ts │ │ ├── OrbitControls.js │ │ ├── PointerLockControls.d.ts │ │ ├── PointerLockControls.js │ │ ├── TrackballControls.d.ts │ │ ├── TrackballControls.js │ │ ├── TransformControls.d.ts │ │ └── TransformControls.js │ ├── core/ │ │ ├── BufferAttribute.d.ts │ │ ├── BufferAttribute.js │ │ ├── BufferGeometry.d.ts │ │ ├── BufferGeometry.js │ │ ├── Clock.d.ts │ │ ├── Clock.js │ │ ├── Curve.d.ts │ │ ├── CurvePath.d.ts │ │ ├── CurvePath.js │ │ ├── DirectGeometry.d.ts │ │ ├── DirectGeometry.js │ │ ├── EventDispatcher.d.ts │ │ ├── EventDispatcher.js │ │ ├── Face3.d.ts │ │ ├── Face3.js │ │ ├── Font.d.ts │ │ ├── Font.js │ │ ├── Geometry.d.ts │ │ ├── Geometry.js │ │ ├── InstancedBufferAttribute.d.ts │ │ ├── InstancedBufferAttribute.js │ │ ├── InstancedBufferGeometry.d.ts │ │ ├── InstancedBufferGeometry.js │ │ ├── InstancedInterleavedBuffer.d.ts │ │ ├── InstancedInterleavedBuffer.js │ │ ├── InterleavedBuffer.d.ts │ │ ├── InterleavedBuffer.js │ │ ├── InterleavedBufferAttribute.d.ts │ │ ├── InterleavedBufferAttribute.js │ │ ├── Interpolations.d.ts │ │ ├── Interpolations.js │ │ ├── Layers.d.ts │ │ ├── Layers.js │ │ ├── Object3D.d.ts │ │ ├── Object3D.js │ │ ├── Path.d.ts │ │ ├── Path.js │ │ ├── Raycaster.d.ts │ │ ├── Raycaster.js │ │ ├── Shape.d.ts │ │ ├── Shape.js │ │ ├── ShapePath.d.ts │ │ ├── ShapePath.js │ │ ├── Uniform.d.ts │ │ └── Uniform.js │ ├── curves/ │ │ ├── ArcCurve.d.ts │ │ ├── ArcCurve.js │ │ ├── CatmullRomCurve3.d.ts │ │ ├── CatmullRomCurve3.js │ │ ├── CubicBezierCurve.d.ts │ │ ├── CubicBezierCurve.js │ │ ├── CubicBezierCurve3.d.ts │ │ ├── CubicBezierCurve3.js │ │ ├── Curve.js │ │ ├── CurveExtras.d.ts │ │ ├── CurveExtras.js │ │ ├── Curves.d.ts │ │ ├── EllipseCurve.d.ts │ │ ├── EllipseCurve.js │ │ ├── LineCurve.d.ts │ │ ├── LineCurve.js │ │ ├── LineCurve3.d.ts │ │ ├── LineCurve3.js │ │ ├── NURBSCurve.d.ts │ │ ├── NURBSCurve.js │ │ ├── NURBSSurface.d.ts │ │ ├── NURBSSurface.js │ │ ├── NURBSUtils.d.ts │ │ ├── NURBSUtils.js │ │ ├── QuadraticBezierCurve.d.ts │ │ ├── QuadraticBezierCurve.js │ │ ├── QuadraticBezierCurve3.d.ts │ │ ├── QuadraticBezierCurve3.js │ │ ├── SplineCurve.d.ts │ │ └── SplineCurve.js │ ├── effects/ │ │ ├── AnaglyphEffect.d.ts │ │ ├── AnaglyphEffect.js │ │ ├── AsciiEffect.d.ts │ │ ├── AsciiEffect.js │ │ ├── OutlineEffect.d.ts │ │ ├── OutlineEffect.js │ │ ├── ParallaxBarrierEffect.d.ts │ │ ├── ParallaxBarrierEffect.js │ │ ├── PeppersGhostEffect.d.ts │ │ ├── PeppersGhostEffect.js │ │ ├── StereoEffect.d.ts │ │ └── StereoEffect.js │ ├── exporters/ │ │ ├── ColladaExporter.d.ts │ │ ├── ColladaExporter.js │ │ ├── DRACOExporter.d.ts │ │ ├── DracoExporter.js │ │ ├── GLTFExporter.d.ts │ │ ├── GLTFExporter.js │ │ ├── MMDExporter.d.ts │ │ ├── MMDExporter.js │ │ ├── OBJExporter.d.ts │ │ ├── OBJExporter.js │ │ ├── PLYExporter.d.ts │ │ ├── PLYExporter.js │ │ ├── STLExporter.d.ts │ │ ├── STLExporter.js │ │ ├── TypedGeometryExporter.d.ts │ │ └── TypedGeometryExporter.js │ ├── fonts/ │ │ ├── LICENSE │ │ ├── droid/ │ │ │ ├── NOTICE │ │ │ ├── droid_sans_bold.typeface.json │ │ │ ├── droid_sans_mono_regular.typeface.json │ │ │ ├── droid_sans_regular.typeface.json │ │ │ ├── droid_serif_bold.typeface.json │ │ │ └── droid_serif_regular.typeface.json │ │ ├── gentilis_bold.typeface.json │ │ ├── gentilis_regular.typeface.json │ │ ├── helvetiker_bold.typeface.json │ │ ├── helvetiker_regular.typeface.json │ │ ├── optimer_bold.typeface.json │ │ └── optimer_regular.typeface.json │ ├── geometries/ │ │ ├── BoxGeometry.d.ts │ │ ├── BoxGeometry.js │ │ ├── BoxLineGeometry.d.ts │ │ ├── BoxLineGeometry.js │ │ ├── CircleGeometry.d.ts │ │ ├── CircleGeometry.js │ │ ├── ConeGeometry.d.ts │ │ ├── ConeGeometry.js │ │ ├── ConvexGeometry.d.ts │ │ ├── ConvexGeometry.js │ │ ├── CylinderGeometry.d.ts │ │ ├── CylinderGeometry.js │ │ ├── DecalGeometry.d.ts │ │ ├── DecalGeometry.js │ │ ├── DodecahedronGeometry.d.ts │ │ ├── DodecahedronGeometry.js │ │ ├── EdgesGeometry.d.ts │ │ ├── EdgesGeometry.js │ │ ├── ExtrudeGeometry.d.ts │ │ ├── ExtrudeGeometry.js │ │ ├── Geometries.d.ts │ │ ├── IcosahedronGeometry.d.ts │ │ ├── IcosahedronGeometry.js │ │ ├── LatheGeometry.d.ts │ │ ├── LatheGeometry.js │ │ ├── LightningStrike.d.ts │ │ ├── LightningStrike.js │ │ ├── OctahedronGeometry.d.ts │ │ ├── OctahedronGeometry.js │ │ ├── ParametricGeometries.d.ts │ │ ├── ParametricGeometries.js │ │ ├── ParametricGeometry.d.ts │ │ ├── ParametricGeometry.js │ │ ├── PlaneGeometry.d.ts │ │ ├── PlaneGeometry.js │ │ ├── PolyhedronGeometry.d.ts │ │ ├── PolyhedronGeometry.js │ │ ├── RingGeometry.d.ts │ │ ├── RingGeometry.js │ │ ├── ShapeGeometry.d.ts │ │ ├── ShapeGeometry.js │ │ ├── SphereGeometry.d.ts │ │ ├── SphereGeometry.js │ │ ├── TeapotBufferGeometry.d.ts │ │ ├── TeapotBufferGeometry.js │ │ ├── TetrahedronGeometry.d.ts │ │ ├── TetrahedronGeometry.js │ │ ├── TextGeometry.d.ts │ │ ├── TextGeometry.js │ │ ├── TorusGeometry.d.ts │ │ ├── TorusGeometry.js │ │ ├── TorusKnotGeometry.d.ts │ │ ├── TorusKnotGeometry.js │ │ ├── TubeGeometry.d.ts │ │ ├── TubeGeometry.js │ │ ├── WireframeGeometry.d.ts │ │ └── WireframeGeometry.js │ ├── helpers/ │ │ ├── ArrowHelper.d.ts │ │ ├── ArrowHelper.js │ │ ├── AxesHelper.d.ts │ │ ├── AxesHelper.js │ │ ├── Box3Helper.d.ts │ │ ├── Box3Helper.js │ │ ├── BoxHelper.d.ts │ │ ├── BoxHelper.js │ │ ├── CameraHelper.d.ts │ │ ├── CameraHelper.js │ │ ├── DirectionalLightHelper.d.ts │ │ ├── DirectionalLightHelper.js │ │ ├── FaceNormalsHelper.d.ts │ │ ├── FaceNormalsHelper.js │ │ ├── GridHelper.d.ts │ │ ├── GridHelper.js │ │ ├── HemisphereLightHelper.d.ts │ │ ├── HemisphereLightHelper.js │ │ ├── LightProbeHelper.d.ts │ │ ├── LightProbeHelper.js │ │ ├── PlaneHelper.d.ts │ │ ├── PlaneHelper.js │ │ ├── PointLightHelper.d.ts │ │ ├── PointLightHelper.js │ │ ├── PolarGridHelper.d.ts │ │ ├── PolarGridHelper.js │ │ ├── PositionalAudioHelper.d.ts │ │ ├── PositionalAudioHelper.js │ │ ├── RectAreaLightHelper.d.ts │ │ ├── RectAreaLightHelper.js │ │ ├── SkeletonHelper.d.ts │ │ ├── SkeletonHelper.js │ │ ├── SpotLightHelper.d.ts │ │ ├── SpotLightHelper.js │ │ ├── VertexNormalsHelper.d.ts │ │ ├── VertexNormalsHelper.js │ │ ├── VertexTangentsHelper.d.ts │ │ ├── VertexTangentsHelper.js │ │ └── WebGL.js │ ├── interactive/ │ │ ├── SelectionBox.d.ts │ │ ├── SelectionBox.js │ │ ├── SelectionHelper.d.ts │ │ └── SelectionHelper.js │ ├── libs/ │ │ ├── ammo.js │ │ ├── basis/ │ │ │ ├── README.md │ │ │ ├── basis_transcoder.js │ │ │ └── basis_transcoder.wasm │ │ ├── dat.gui.module.js │ │ ├── draco/ │ │ │ ├── README.md │ │ │ ├── draco_decoder.js │ │ │ ├── draco_decoder.wasm │ │ │ ├── draco_encoder.js │ │ │ ├── draco_wasm_wrapper.js │ │ │ └── gltf/ │ │ │ ├── draco_decoder.js │ │ │ ├── draco_decoder.wasm │ │ │ ├── draco_encoder.js │ │ │ └── draco_wasm_wrapper.js │ │ ├── mmdparser.module.js │ │ ├── motion-controllers.module.js │ │ └── stats.module.js │ ├── lights/ │ │ ├── AmbientLight.d.ts │ │ ├── AmbientLight.js │ │ ├── AmbientLightProbe.d.ts │ │ ├── AmbientLightProbe.js │ │ ├── DirectionalLight.d.ts │ │ ├── DirectionalLight.js │ │ ├── DirectionalLightShadow.d.ts │ │ ├── DirectionalLightShadow.js │ │ ├── HemisphereLight.d.ts │ │ ├── HemisphereLight.js │ │ ├── HemisphereLightProbe.d.ts │ │ ├── HemisphereLightProbe.js │ │ ├── Light.d.ts │ │ ├── Light.js │ │ ├── LightProbe.d.ts │ │ ├── LightProbe.js │ │ ├── LightProbeGenerator.d.ts │ │ ├── LightProbeGenerator.js │ │ ├── LightShadow.d.ts │ │ ├── LightShadow.js │ │ ├── PointLight.d.ts │ │ ├── PointLight.js │ │ ├── PointLightShadow.d.ts │ │ ├── PointLightShadow.js │ │ ├── RectAreaLight.d.ts │ │ ├── RectAreaLight.js │ │ ├── RectAreaLightUniformsLib.d.ts │ │ ├── RectAreaLightUniformsLib.js │ │ ├── SpotLight.d.ts │ │ ├── SpotLight.js │ │ ├── SpotLightShadow.d.ts │ │ └── SpotLightShadow.js │ ├── lines/ │ │ ├── Line2.d.ts │ │ ├── Line2.js │ │ ├── LineGeometry.d.ts │ │ ├── LineGeometry.js │ │ ├── LineMaterial.d.ts │ │ ├── LineMaterial.js │ │ ├── LineSegments2.d.ts │ │ ├── LineSegments2.js │ │ ├── LineSegmentsGeometry.d.ts │ │ ├── LineSegmentsGeometry.js │ │ ├── Wireframe.d.ts │ │ ├── Wireframe.js │ │ ├── WireframeGeometry2.d.ts │ │ └── WireframeGeometry2.js │ ├── loaders/ │ │ ├── 3MFLoader.d.ts │ │ ├── 3MFLoader.js │ │ ├── AMFLoader.d.ts │ │ ├── AMFLoader.js │ │ ├── AWDLoader.d.ts │ │ ├── AWDLoader.js │ │ ├── AnimationLoader.d.ts │ │ ├── AnimationLoader.js │ │ ├── AssimpLoader.d.ts │ │ ├── AssimpLoader.js │ │ ├── AudioLoader.d.ts │ │ ├── AudioLoader.js │ │ ├── BVHLoader.d.ts │ │ ├── BVHLoader.js │ │ ├── BasisTextureLoader.d.ts │ │ ├── BasisTextureLoader.js │ │ ├── BufferGeometryLoader.d.ts │ │ ├── BufferGeometryLoader.js │ │ ├── Cache.d.ts │ │ ├── Cache.js │ │ ├── ColladaLoader.d.ts │ │ ├── ColladaLoader.js │ │ ├── CompressedTextureLoader.d.ts │ │ ├── CompressedTextureLoader.js │ │ ├── CubeTextureLoader.d.ts │ │ ├── CubeTextureLoader.js │ │ ├── DDSLoader.d.ts │ │ ├── DDSLoader.js │ │ ├── DRACOLoader.d.ts │ │ ├── DRACOLoader.js │ │ ├── DataTextureLoader.d.ts │ │ ├── DataTextureLoader.js │ │ ├── EXRLoader.d.ts │ │ ├── EXRLoader.js │ │ ├── FBXLoader.d.ts │ │ ├── FBXLoader.js │ │ ├── FileLoader.d.ts │ │ ├── FileLoader.js │ │ ├── FontLoader.d.ts │ │ ├── FontLoader.js │ │ ├── GCodeLoader.d.ts │ │ ├── GCodeLoader.js │ │ ├── GLTFLoader.d.ts │ │ ├── GLTFLoader.js │ │ ├── HDRCubeTextureLoader.d.ts │ │ ├── HDRCubeTextureLoader.js │ │ ├── ImageBitmapLoader.d.ts │ │ ├── ImageBitmapLoader.js │ │ ├── ImageLoader.d.ts │ │ ├── ImageLoader.js │ │ ├── KMZLoader.d.ts │ │ ├── KMZLoader.js │ │ ├── KTXLoader.d.ts │ │ ├── KTXLoader.js │ │ ├── LDrawLoader.d.ts │ │ ├── LDrawLoader.js │ │ ├── LWOLoader.d.ts │ │ ├── LWOLoader.js │ │ ├── Loader.d.ts │ │ ├── Loader.js │ │ ├── LoaderUtils.d.ts │ │ ├── LoaderUtils.js │ │ ├── LoadingManager.d.ts │ │ ├── LoadingManager.js │ │ ├── MD2Loader.d.ts │ │ ├── MD2Loader.js │ │ ├── MMDLoader.d.ts │ │ ├── MMDLoader.js │ │ ├── MTLLoader.d.ts │ │ ├── MTLLoader.js │ │ ├── MaterialLoader.d.ts │ │ ├── MaterialLoader.js │ │ ├── NRRDLoader.d.ts │ │ ├── NRRDLoader.js │ │ ├── NodeMaterialLoader.js │ │ ├── OBJLoader.d.ts │ │ ├── OBJLoader.js │ │ ├── OBJLoader2.d.ts │ │ ├── OBJLoader2.js │ │ ├── OBJLoader2Parallel.d.ts │ │ ├── OBJLoader2Parallel.js │ │ ├── ObjectLoader.d.ts │ │ ├── ObjectLoader.js │ │ ├── PCDLoader.d.ts │ │ ├── PCDLoader.js │ │ ├── PDBLoader.d.ts │ │ ├── PDBLoader.js │ │ ├── PLYLoader.d.ts │ │ ├── PLYLoader.js │ │ ├── PRWMLoader.d.ts │ │ ├── PRWMLoader.js │ │ ├── PVRLoader.d.ts │ │ ├── PVRLoader.js │ │ ├── RGBELoader.d.ts │ │ ├── RGBELoader.js │ │ ├── STLLoader.d.ts │ │ ├── STLLoader.js │ │ ├── SVGLoader.d.ts │ │ ├── SVGLoader.js │ │ ├── TDSLoader.d.ts │ │ ├── TDSLoader.js │ │ ├── TGALoader.d.ts │ │ ├── TGALoader.js │ │ ├── TTFLoader.d.ts │ │ ├── TTFLoader.js │ │ ├── TextureLoader.d.ts │ │ ├── TextureLoader.js │ │ ├── VRMLoader.d.ts │ │ ├── VRMLoader.js │ │ ├── VTKLoader.d.ts │ │ ├── VTKLoader.js │ │ ├── XLoader.d.ts │ │ ├── XLoader.js │ │ └── obj2/ │ │ ├── bridge/ │ │ │ ├── MtlObjBridge.d.ts │ │ │ └── MtlObjBridge.js │ │ ├── shared/ │ │ │ ├── MaterialHandler.d.ts │ │ │ ├── MaterialHandler.js │ │ │ ├── MeshReceiver.d.ts │ │ │ └── MeshReceiver.js │ │ ├── utils/ │ │ │ ├── CodeSerializer.d.ts │ │ │ └── CodeSerializer.js │ │ └── worker/ │ │ ├── main/ │ │ │ ├── WorkerExecutionSupport.d.ts │ │ │ └── WorkerExecutionSupport.js │ │ └── parallel/ │ │ ├── OBJLoader2Parser.d.ts │ │ ├── OBJLoader2Parser.js │ │ ├── WorkerRunner.d.ts │ │ ├── WorkerRunner.js │ │ └── jsm/ │ │ └── OBJLoader2Worker.js │ ├── materials/ │ │ ├── LineBasicMaterial.d.ts │ │ ├── LineBasicMaterial.js │ │ ├── LineDashedMaterial.d.ts │ │ ├── LineDashedMaterial.js │ │ ├── Material.d.ts │ │ ├── Material.js │ │ ├── Materials.d.ts │ │ ├── MeshBasicMaterial.d.ts │ │ ├── MeshBasicMaterial.js │ │ ├── MeshDepthMaterial.d.ts │ │ ├── MeshDepthMaterial.js │ │ ├── MeshDistanceMaterial.d.ts │ │ ├── MeshDistanceMaterial.js │ │ ├── MeshLambertMaterial.d.ts │ │ ├── MeshLambertMaterial.js │ │ ├── MeshMatcapMaterial.d.ts │ │ ├── MeshMatcapMaterial.js │ │ ├── MeshNormalMaterial.d.ts │ │ ├── MeshNormalMaterial.js │ │ ├── MeshPhongMaterial.d.ts │ │ ├── MeshPhongMaterial.js │ │ ├── MeshPhysicalMaterial.d.ts │ │ ├── MeshPhysicalMaterial.js │ │ ├── MeshStandardMaterial.d.ts │ │ ├── MeshStandardMaterial.js │ │ ├── MeshToonMaterial.d.ts │ │ ├── MeshToonMaterial.js │ │ ├── PointsMaterial.d.ts │ │ ├── PointsMaterial.js │ │ ├── RawShaderMaterial.d.ts │ │ ├── RawShaderMaterial.js │ │ ├── ShaderMaterial.d.ts │ │ ├── ShaderMaterial.js │ │ ├── ShadowMaterial.d.ts │ │ ├── ShadowMaterial.js │ │ ├── SpriteMaterial.d.ts │ │ └── SpriteMaterial.js │ ├── math/ │ │ ├── Box2.d.ts │ │ ├── Box2.js │ │ ├── Box3.d.ts │ │ ├── Box3.js │ │ ├── Color.d.ts │ │ ├── Color.js │ │ ├── ColorConverter.d.ts │ │ ├── ColorConverter.js │ │ ├── ConvexHull.d.ts │ │ ├── ConvexHull.js │ │ ├── Cylindrical.d.ts │ │ ├── Cylindrical.js │ │ ├── Euler.d.ts │ │ ├── Euler.js │ │ ├── Frustum.d.ts │ │ ├── Frustum.js │ │ ├── ImprovedNoise.d.ts │ │ ├── ImprovedNoise.js │ │ ├── Interpolant.d.ts │ │ ├── Interpolant.js │ │ ├── Line3.d.ts │ │ ├── Line3.js │ │ ├── Lut.d.ts │ │ ├── Lut.js │ │ ├── MathUtils.d.ts │ │ ├── MathUtils.js │ │ ├── Matrix3.d.ts │ │ ├── Matrix3.js │ │ ├── Matrix4.d.ts │ │ ├── Matrix4.js │ │ ├── MeshSurfaceSampler.d.ts │ │ ├── MeshSurfaceSampler.js │ │ ├── Plane.d.ts │ │ ├── Plane.js │ │ ├── Quaternion.d.ts │ │ ├── Quaternion.js │ │ ├── Ray.d.ts │ │ ├── Ray.js │ │ ├── SimplexNoise.d.ts │ │ ├── SimplexNoise.js │ │ ├── Sphere.d.ts │ │ ├── Sphere.js │ │ ├── Spherical.d.ts │ │ ├── Spherical.js │ │ ├── SphericalHarmonics3.d.ts │ │ ├── SphericalHarmonics3.js │ │ ├── Triangle.d.ts │ │ ├── Triangle.js │ │ ├── Vector2.d.ts │ │ ├── Vector2.js │ │ ├── Vector3.d.ts │ │ ├── Vector3.js │ │ ├── Vector4.d.ts │ │ ├── Vector4.js │ │ └── interpolants/ │ │ ├── CubicInterpolant.d.ts │ │ ├── CubicInterpolant.js │ │ ├── DiscreteInterpolant.d.ts │ │ ├── DiscreteInterpolant.js │ │ ├── LinearInterpolant.d.ts │ │ ├── LinearInterpolant.js │ │ ├── QuaternionLinearInterpolant.d.ts │ │ └── QuaternionLinearInterpolant.js │ ├── misc/ │ │ ├── ConvexObjectBreaker.d.ts │ │ ├── Earcut.js │ │ ├── GPUComputationRenderer.d.ts │ │ ├── Gyroscope.d.ts │ │ ├── MD2Character.d.ts │ │ ├── MD2CharacterComplex.d.ts │ │ ├── MorphAnimMesh.d.ts │ │ ├── MorphBlendMesh.d.ts │ │ ├── Ocean.d.ts │ │ ├── RollerCoaster.d.ts │ │ ├── TubePainter.d.ts │ │ ├── TubePainter.js │ │ ├── Volume.d.ts │ │ ├── Volume.js │ │ └── VolumeSlice.d.ts │ ├── modifiers/ │ │ ├── ConvexObjectBreaker.js │ │ ├── ExplodeModifier.d.ts │ │ ├── ExplodeModifier.js │ │ ├── SimplifyModifier.d.ts │ │ ├── SimplifyModifier.js │ │ ├── SubdivisionModifier.d.ts │ │ ├── SubdivisionModifier.js │ │ ├── TessellateModifier.d.ts │ │ └── TessellateModifier.js │ ├── nodes/ │ │ ├── Nodes.d.ts │ │ ├── accessors/ │ │ │ ├── CameraNode.d.ts │ │ │ ├── CameraNode.js │ │ │ ├── ColorsNode.d.ts │ │ │ ├── ColorsNode.js │ │ │ ├── LightNode.d.ts │ │ │ ├── LightNode.js │ │ │ ├── NormalNode.d.ts │ │ │ ├── NormalNode.js │ │ │ ├── PositionNode.d.ts │ │ │ ├── PositionNode.js │ │ │ ├── ReflectNode.d.ts │ │ │ ├── ReflectNode.js │ │ │ ├── ResolutionNode.d.ts │ │ │ ├── ResolutionNode.js │ │ │ ├── ScreenUVNode.d.ts │ │ │ ├── ScreenUVNode.js │ │ │ ├── UVNode.d.ts │ │ │ └── UVNode.js │ │ ├── core/ │ │ │ ├── AttributeNode.d.ts │ │ │ ├── AttributeNode.js │ │ │ ├── ConstNode.d.ts │ │ │ ├── ConstNode.js │ │ │ ├── ExpressionNode.d.ts │ │ │ ├── ExpressionNode.js │ │ │ ├── FunctionCallNode.d.ts │ │ │ ├── FunctionCallNode.js │ │ │ ├── FunctionNode.d.ts │ │ │ ├── FunctionNode.js │ │ │ ├── InputNode.d.ts │ │ │ ├── InputNode.js │ │ │ ├── Node.d.ts │ │ │ ├── Node.js │ │ │ ├── NodeBuilder.d.ts │ │ │ ├── NodeBuilder.js │ │ │ ├── NodeFrame.d.ts │ │ │ ├── NodeFrame.js │ │ │ ├── NodeLib.d.ts │ │ │ ├── NodeLib.js │ │ │ ├── NodeUniform.d.ts │ │ │ ├── NodeUniform.js │ │ │ ├── NodeUtils.d.ts │ │ │ ├── NodeUtils.js │ │ │ ├── StructNode.d.ts │ │ │ ├── StructNode.js │ │ │ ├── TempNode.d.ts │ │ │ ├── TempNode.js │ │ │ ├── VarNode.d.ts │ │ │ └── VarNode.js │ │ ├── effects/ │ │ │ ├── BlurNode.d.ts │ │ │ ├── BlurNode.js │ │ │ ├── ColorAdjustmentNode.d.ts │ │ │ ├── ColorAdjustmentNode.js │ │ │ ├── LuminanceNode.d.ts │ │ │ └── LuminanceNode.js │ │ ├── inputs/ │ │ │ ├── BoolNode.d.ts │ │ │ ├── BoolNode.js │ │ │ ├── ColorNode.d.ts │ │ │ ├── ColorNode.js │ │ │ ├── CubeTextureNode.d.ts │ │ │ ├── CubeTextureNode.js │ │ │ ├── FloatNode.d.ts │ │ │ ├── FloatNode.js │ │ │ ├── IntNode.d.ts │ │ │ ├── IntNode.js │ │ │ ├── Matrix3Node.d.ts │ │ │ ├── Matrix3Node.js │ │ │ ├── Matrix4Node.d.ts │ │ │ ├── Matrix4Node.js │ │ │ ├── PropertyNode.d.ts │ │ │ ├── PropertyNode.js │ │ │ ├── RTTNode.d.ts │ │ │ ├── RTTNode.js │ │ │ ├── ReflectorNode.d.ts │ │ │ ├── ReflectorNode.js │ │ │ ├── ScreenNode.d.ts │ │ │ ├── ScreenNode.js │ │ │ ├── TextureNode.d.ts │ │ │ ├── TextureNode.js │ │ │ ├── Vector2Node.d.ts │ │ │ ├── Vector2Node.js │ │ │ ├── Vector3Node.d.ts │ │ │ ├── Vector3Node.js │ │ │ ├── Vector4Node.d.ts │ │ │ └── Vector4Node.js │ │ ├── materials/ │ │ │ ├── MeshStandardNodeMaterial.d.ts │ │ │ ├── MeshStandardNodeMaterial.js │ │ │ ├── NodeMaterial.d.ts │ │ │ ├── NodeMaterial.js │ │ │ ├── PhongNodeMaterial.d.ts │ │ │ ├── PhongNodeMaterial.js │ │ │ ├── SpriteNodeMaterial.d.ts │ │ │ ├── SpriteNodeMaterial.js │ │ │ ├── StandardNodeMaterial.d.ts │ │ │ ├── StandardNodeMaterial.js │ │ │ └── nodes/ │ │ │ ├── MeshStandardNode.d.ts │ │ │ ├── MeshStandardNode.js │ │ │ ├── PhongNode.d.ts │ │ │ ├── PhongNode.js │ │ │ ├── RawNode.d.ts │ │ │ ├── RawNode.js │ │ │ ├── SpriteNode.d.ts │ │ │ ├── SpriteNode.js │ │ │ ├── StandardNode.d.ts │ │ │ └── StandardNode.js │ │ ├── math/ │ │ │ ├── CondNode.d.ts │ │ │ ├── CondNode.js │ │ │ ├── MathNode.d.ts │ │ │ ├── MathNode.js │ │ │ ├── OperatorNode.d.ts │ │ │ └── OperatorNode.js │ │ ├── misc/ │ │ │ ├── BumpMapNode.d.ts │ │ │ ├── BumpMapNode.js │ │ │ ├── NormalMapNode.d.ts │ │ │ ├── NormalMapNode.js │ │ │ ├── TextureCubeNode.d.ts │ │ │ ├── TextureCubeNode.js │ │ │ ├── TextureCubeUVNode.d.ts │ │ │ └── TextureCubeUVNode.js │ │ ├── postprocessing/ │ │ │ ├── NodePass.d.ts │ │ │ ├── NodePass.js │ │ │ ├── NodePostProcessing.d.ts │ │ │ └── NodePostProcessing.js │ │ ├── procedural/ │ │ │ ├── CheckerNode.d.ts │ │ │ ├── CheckerNode.js │ │ │ ├── NoiseNode.d.ts │ │ │ └── NoiseNode.js │ │ └── utils/ │ │ ├── BypassNode.d.ts │ │ ├── BypassNode.js │ │ ├── ColorSpaceNode.d.ts │ │ ├── ColorSpaceNode.js │ │ ├── JoinNode.d.ts │ │ ├── JoinNode.js │ │ ├── MaxMIPLevelNode.d.ts │ │ ├── MaxMIPLevelNode.js │ │ ├── SpecularMIPLevelNode.d.ts │ │ ├── SpecularMIPLevelNode.js │ │ ├── SubSlot.d.ts │ │ ├── SubSlotNode.js │ │ ├── SwitchNode.d.ts │ │ ├── SwitchNode.js │ │ ├── TimerNode.d.ts │ │ ├── TimerNode.js │ │ ├── UVTransformNode.d.ts │ │ ├── UVTransformNode.js │ │ ├── VelocityNode.d.ts │ │ └── VelocityNode.js │ ├── objects/ │ │ ├── Bone.d.ts │ │ ├── Bone.js │ │ ├── Fire.d.ts │ │ ├── Fire.js │ │ ├── Group.d.ts │ │ ├── Group.js │ │ ├── Gyroscope.js │ │ ├── ImmediateRenderObject.d.ts │ │ ├── ImmediateRenderObject.js │ │ ├── InstancedMesh.d.ts │ │ ├── InstancedMesh.js │ │ ├── LOD.d.ts │ │ ├── LOD.js │ │ ├── Lensflare.d.ts │ │ ├── Lensflare.js │ │ ├── LightningStorm.d.ts │ │ ├── LightningStorm.js │ │ ├── Line.d.ts │ │ ├── Line.js │ │ ├── LineLoop.d.ts │ │ ├── LineLoop.js │ │ ├── LineSegments.d.ts │ │ ├── LineSegments.js │ │ ├── MD2Character.js │ │ ├── MD2CharacterComplex.js │ │ ├── MarchingCubes.d.ts │ │ ├── MarchingCubes.js │ │ ├── Mesh.d.ts │ │ ├── Mesh.js │ │ ├── MorphAnimMesh.js │ │ ├── MorphBlendMesh.js │ │ ├── Ocean.js │ │ ├── Points.d.ts │ │ ├── Points.js │ │ ├── Reflector.d.ts │ │ ├── Reflector.js │ │ ├── ReflectorRTT.d.ts │ │ ├── ReflectorRTT.js │ │ ├── Refractor.d.ts │ │ ├── Refractor.js │ │ ├── RollerCoaster.js │ │ ├── ShadowMesh.d.ts │ │ ├── ShadowMesh.js │ │ ├── Skeleton.d.ts │ │ ├── Skeleton.js │ │ ├── SkinnedMesh.d.ts │ │ ├── SkinnedMesh.js │ │ ├── Sky.d.ts │ │ ├── Sky.js │ │ ├── Sprite.d.ts │ │ ├── Sprite.js │ │ ├── Water.d.ts │ │ ├── Water.js │ │ ├── Water2.d.ts │ │ └── Water2.js │ ├── polyfills.d.ts │ ├── polyfills.js │ ├── postprocessing/ │ │ ├── AdaptiveToneMappingPass.d.ts │ │ ├── AdaptiveToneMappingPass.js │ │ ├── AfterimagePass.d.ts │ │ ├── AfterimagePass.js │ │ ├── BloomPass.d.ts │ │ ├── BloomPass.js │ │ ├── BokehPass.d.ts │ │ ├── BokehPass.js │ │ ├── ClearPass.d.ts │ │ ├── ClearPass.js │ │ ├── CubeTexturePass.d.ts │ │ ├── CubeTexturePass.js │ │ ├── DotScreenPass.d.ts │ │ ├── DotScreenPass.js │ │ ├── EffectComposer.d.ts │ │ ├── EffectComposer.js │ │ ├── FilmPass.d.ts │ │ ├── FilmPass.js │ │ ├── GlitchPass.d.ts │ │ ├── GlitchPass.js │ │ ├── HalftonePass.d.ts │ │ ├── HalftonePass.js │ │ ├── MaskPass.d.ts │ │ ├── MaskPass.js │ │ ├── OutlinePass.d.ts │ │ ├── OutlinePass.js │ │ ├── Pass.d.ts │ │ ├── Pass.js │ │ ├── RenderPass.d.ts │ │ ├── RenderPass.js │ │ ├── SAOPass.d.ts │ │ ├── SAOPass.js │ │ ├── SMAAPass.d.ts │ │ ├── SMAAPass.js │ │ ├── SSAARenderPass.d.ts │ │ ├── SSAARenderPass.js │ │ ├── SSAOPass.d.ts │ │ ├── SSAOPass.js │ │ ├── SavePass.d.ts │ │ ├── SavePass.js │ │ ├── ShaderPass.d.ts │ │ ├── ShaderPass.js │ │ ├── TAARenderPass.d.ts │ │ ├── TAARenderPass.js │ │ ├── TexturePass.d.ts │ │ ├── TexturePass.js │ │ ├── UnrealBloomPass.d.ts │ │ └── UnrealBloomPass.js │ ├── renderers/ │ │ ├── CSS2DRenderer.d.ts │ │ ├── CSS2DRenderer.js │ │ ├── CSS3DRenderer.d.ts │ │ ├── CSS3DRenderer.js │ │ ├── GPUComputationRenderer.js │ │ ├── Projector.d.ts │ │ ├── Projector.js │ │ ├── SVGRenderer.d.ts │ │ ├── SVGRenderer.js │ │ ├── WebGLCubeRenderTarget.d.ts │ │ ├── WebGLCubeRenderTarget.js │ │ ├── WebGLMultisampleRenderTarget.d.ts │ │ ├── WebGLMultisampleRenderTarget.js │ │ ├── WebGLMultiviewRenderTarget.d.ts │ │ ├── WebGLMultiviewRenderTarget.js │ │ ├── WebGLRenderTarget.d.ts │ │ ├── WebGLRenderTarget.js │ │ ├── WebGLRenderer.d.ts │ │ ├── WebGLRenderer.js │ │ ├── shaders/ │ │ │ ├── ShaderChunk/ │ │ │ │ ├── alphamap_fragment.glsl.js │ │ │ │ ├── alphamap_pars_fragment.glsl.js │ │ │ │ ├── alphatest_fragment.glsl.js │ │ │ │ ├── aomap_fragment.glsl.js │ │ │ │ ├── aomap_pars_fragment.glsl.js │ │ │ │ ├── begin_vertex.glsl.js │ │ │ │ ├── beginnormal_vertex.glsl.js │ │ │ │ ├── bsdfs.glsl.js │ │ │ │ ├── bumpmap_pars_fragment.glsl.js │ │ │ │ ├── clearcoat_normal_fragment_begin.glsl.js │ │ │ │ ├── clearcoat_normal_fragment_maps.glsl.js │ │ │ │ ├── clearcoat_normalmap_pars_fragment.glsl.js │ │ │ │ ├── clipping_planes_fragment.glsl.js │ │ │ │ ├── clipping_planes_pars_fragment.glsl.js │ │ │ │ ├── clipping_planes_pars_vertex.glsl.js │ │ │ │ ├── clipping_planes_vertex.glsl.js │ │ │ │ ├── color_fragment.glsl.js │ │ │ │ ├── color_pars_fragment.glsl.js │ │ │ │ ├── color_pars_vertex.glsl.js │ │ │ │ ├── color_vertex.glsl.js │ │ │ │ ├── common.glsl.js │ │ │ │ ├── cube_uv_reflection_fragment.glsl.js │ │ │ │ ├── default_fragment.glsl.js │ │ │ │ ├── default_vertex.glsl.js │ │ │ │ ├── defaultnormal_vertex.glsl.js │ │ │ │ ├── displacementmap_pars_vertex.glsl.js │ │ │ │ ├── displacementmap_vertex.glsl.js │ │ │ │ ├── dithering_fragment.glsl.js │ │ │ │ ├── dithering_pars_fragment.glsl.js │ │ │ │ ├── emissivemap_fragment.glsl.js │ │ │ │ ├── emissivemap_pars_fragment.glsl.js │ │ │ │ ├── encodings_fragment.glsl.js │ │ │ │ ├── encodings_pars_fragment.glsl.js │ │ │ │ ├── envmap_common_pars_fragment.glsl.js │ │ │ │ ├── envmap_fragment.glsl.js │ │ │ │ ├── envmap_pars_fragment.glsl.js │ │ │ │ ├── envmap_pars_vertex.glsl.js │ │ │ │ ├── envmap_physical_pars_fragment.glsl.js │ │ │ │ ├── envmap_vertex.glsl.js │ │ │ │ ├── fog_fragment.glsl.js │ │ │ │ ├── fog_pars_fragment.glsl.js │ │ │ │ ├── fog_pars_vertex.glsl.js │ │ │ │ ├── fog_vertex.glsl.js │ │ │ │ ├── gradientmap_pars_fragment.glsl.js │ │ │ │ ├── lightmap_fragment.glsl.js │ │ │ │ ├── lightmap_pars_fragment.glsl.js │ │ │ │ ├── lights_fragment_begin.glsl.js │ │ │ │ ├── lights_fragment_end.glsl.js │ │ │ │ ├── lights_fragment_maps.glsl.js │ │ │ │ ├── lights_lambert_vertex.glsl.js │ │ │ │ ├── lights_pars_begin.glsl.js │ │ │ │ ├── lights_phong_fragment.glsl.js │ │ │ │ ├── lights_phong_pars_fragment.glsl.js │ │ │ │ ├── lights_physical_fragment.glsl.js │ │ │ │ ├── lights_physical_pars_fragment.glsl.js │ │ │ │ ├── lights_toon_fragment.glsl.js │ │ │ │ ├── lights_toon_pars_fragment.glsl.js │ │ │ │ ├── logdepthbuf_fragment.glsl.js │ │ │ │ ├── logdepthbuf_pars_fragment.glsl.js │ │ │ │ ├── logdepthbuf_pars_vertex.glsl.js │ │ │ │ ├── logdepthbuf_vertex.glsl.js │ │ │ │ ├── map_fragment.glsl.js │ │ │ │ ├── map_pars_fragment.glsl.js │ │ │ │ ├── map_particle_fragment.glsl.js │ │ │ │ ├── map_particle_pars_fragment.glsl.js │ │ │ │ ├── metalnessmap_fragment.glsl.js │ │ │ │ ├── metalnessmap_pars_fragment.glsl.js │ │ │ │ ├── morphnormal_vertex.glsl.js │ │ │ │ ├── morphtarget_pars_vertex.glsl.js │ │ │ │ ├── morphtarget_vertex.glsl.js │ │ │ │ ├── normal_fragment_begin.glsl.js │ │ │ │ ├── normal_fragment_maps.glsl.js │ │ │ │ ├── normalmap_pars_fragment.glsl.js │ │ │ │ ├── packing.glsl.js │ │ │ │ ├── premultiplied_alpha_fragment.glsl.js │ │ │ │ ├── project_vertex.glsl.js │ │ │ │ ├── roughnessmap_fragment.glsl.js │ │ │ │ ├── roughnessmap_pars_fragment.glsl.js │ │ │ │ ├── shadowmap_pars_fragment.glsl.js │ │ │ │ ├── shadowmap_pars_vertex.glsl.js │ │ │ │ ├── shadowmap_vertex.glsl.js │ │ │ │ ├── shadowmask_pars_fragment.glsl.js │ │ │ │ ├── skinbase_vertex.glsl.js │ │ │ │ ├── skinning_pars_vertex.glsl.js │ │ │ │ ├── skinning_vertex.glsl.js │ │ │ │ ├── skinnormal_vertex.glsl.js │ │ │ │ ├── specularmap_fragment.glsl.js │ │ │ │ ├── specularmap_pars_fragment.glsl.js │ │ │ │ ├── tonemapping_fragment.glsl.js │ │ │ │ ├── tonemapping_pars_fragment.glsl.js │ │ │ │ ├── uv2_pars_fragment.glsl.js │ │ │ │ ├── uv2_pars_vertex.glsl.js │ │ │ │ ├── uv2_vertex.glsl.js │ │ │ │ ├── uv_pars_fragment.glsl.js │ │ │ │ ├── uv_pars_vertex.glsl.js │ │ │ │ ├── uv_vertex.glsl.js │ │ │ │ └── worldpos_vertex.glsl.js │ │ │ ├── ShaderChunk.d.ts │ │ │ ├── ShaderChunk.js │ │ │ ├── ShaderLib/ │ │ │ │ ├── background_frag.glsl.js │ │ │ │ ├── background_vert.glsl.js │ │ │ │ ├── cube_frag.glsl.js │ │ │ │ ├── cube_vert.glsl.js │ │ │ │ ├── depth_frag.glsl.js │ │ │ │ ├── depth_vert.glsl.js │ │ │ │ ├── distanceRGBA_frag.glsl.js │ │ │ │ ├── distanceRGBA_vert.glsl.js │ │ │ │ ├── equirect_frag.glsl.js │ │ │ │ ├── equirect_vert.glsl.js │ │ │ │ ├── linedashed_frag.glsl.js │ │ │ │ ├── linedashed_vert.glsl.js │ │ │ │ ├── meshbasic_frag.glsl.js │ │ │ │ ├── meshbasic_vert.glsl.js │ │ │ │ ├── meshlambert_frag.glsl.js │ │ │ │ ├── meshlambert_vert.glsl.js │ │ │ │ ├── meshmatcap_frag.glsl.js │ │ │ │ ├── meshmatcap_vert.glsl.js │ │ │ │ ├── meshphong_frag.glsl.js │ │ │ │ ├── meshphong_vert.glsl.js │ │ │ │ ├── meshphysical_frag.glsl.js │ │ │ │ ├── meshphysical_vert.glsl.js │ │ │ │ ├── meshtoon_frag.glsl.js │ │ │ │ ├── meshtoon_vert.glsl.js │ │ │ │ ├── normal_frag.glsl.js │ │ │ │ ├── normal_vert.glsl.js │ │ │ │ ├── points_frag.glsl.js │ │ │ │ ├── points_vert.glsl.js │ │ │ │ ├── shadow_frag.glsl.js │ │ │ │ ├── shadow_vert.glsl.js │ │ │ │ ├── sprite_frag.glsl.js │ │ │ │ ├── sprite_vert.glsl.js │ │ │ │ ├── vsm_frag.glsl.js │ │ │ │ └── vsm_vert.glsl.js │ │ │ ├── ShaderLib.d.ts │ │ │ ├── ShaderLib.js │ │ │ ├── UniformsLib.d.ts │ │ │ ├── UniformsLib.js │ │ │ ├── UniformsUtils.d.ts │ │ │ └── UniformsUtils.js │ │ ├── webgl/ │ │ │ ├── WebGLAnimation.d.ts │ │ │ ├── WebGLAnimation.js │ │ │ ├── WebGLAttributes.d.ts │ │ │ ├── WebGLAttributes.js │ │ │ ├── WebGLBackground.d.ts │ │ │ ├── WebGLBackground.js │ │ │ ├── WebGLBufferRenderer.d.ts │ │ │ ├── WebGLBufferRenderer.js │ │ │ ├── WebGLCapabilities.d.ts │ │ │ ├── WebGLCapabilities.js │ │ │ ├── WebGLClipping.d.ts │ │ │ ├── WebGLClipping.js │ │ │ ├── WebGLExtensions.d.ts │ │ │ ├── WebGLExtensions.js │ │ │ ├── WebGLGeometries.d.ts │ │ │ ├── WebGLGeometries.js │ │ │ ├── WebGLIndexedBufferRenderer.d.ts │ │ │ ├── WebGLIndexedBufferRenderer.js │ │ │ ├── WebGLInfo.d.ts │ │ │ ├── WebGLInfo.js │ │ │ ├── WebGLLights.d.ts │ │ │ ├── WebGLLights.js │ │ │ ├── WebGLMorphtargets.d.ts │ │ │ ├── WebGLMorphtargets.js │ │ │ ├── WebGLMultiview.d.ts │ │ │ ├── WebGLMultiview.js │ │ │ ├── WebGLObjects.d.ts │ │ │ ├── WebGLObjects.js │ │ │ ├── WebGLProgram.d.ts │ │ │ ├── WebGLProgram.js │ │ │ ├── WebGLPrograms.d.ts │ │ │ ├── WebGLPrograms.js │ │ │ ├── WebGLProperties.d.ts │ │ │ ├── WebGLProperties.js │ │ │ ├── WebGLRenderLists.d.ts │ │ │ ├── WebGLRenderLists.js │ │ │ ├── WebGLRenderStates.d.ts │ │ │ ├── WebGLRenderStates.js │ │ │ ├── WebGLShader.d.ts │ │ │ ├── WebGLShader.js │ │ │ ├── WebGLShadowMap.d.ts │ │ │ ├── WebGLShadowMap.js │ │ │ ├── WebGLState.d.ts │ │ │ ├── WebGLState.js │ │ │ ├── WebGLTextures.d.ts │ │ │ ├── WebGLTextures.js │ │ │ ├── WebGLUniforms.d.ts │ │ │ ├── WebGLUniforms.js │ │ │ ├── WebGLUtils.d.ts │ │ │ └── WebGLUtils.js │ │ └── webxr/ │ │ ├── WebXRManager.d.ts │ │ └── WebXRManager.js │ ├── scenes/ │ │ ├── Fog.d.ts │ │ ├── Fog.js │ │ ├── FogExp2.d.ts │ │ ├── FogExp2.js │ │ ├── Scene.d.ts │ │ └── Scene.js │ ├── shaders/ │ │ ├── AfterimageShader.d.ts │ │ ├── AfterimageShader.js │ │ ├── BasicShader.d.ts │ │ ├── BasicShader.js │ │ ├── BleachBypassShader.d.ts │ │ ├── BleachBypassShader.js │ │ ├── BlendShader.d.ts │ │ ├── BlendShader.js │ │ ├── BokehShader.d.ts │ │ ├── BokehShader.js │ │ ├── BokehShader2.d.ts │ │ ├── BokehShader2.js │ │ ├── BrightnessContrastShader.d.ts │ │ ├── BrightnessContrastShader.js │ │ ├── ColorCorrectionShader.d.ts │ │ ├── ColorCorrectionShader.js │ │ ├── ColorifyShader.d.ts │ │ ├── ColorifyShader.js │ │ ├── ConvolutionShader.d.ts │ │ ├── ConvolutionShader.js │ │ ├── CopyShader.d.ts │ │ ├── CopyShader.js │ │ ├── DOFMipMapShader.d.ts │ │ ├── DOFMipMapShader.js │ │ ├── DepthLimitedBlurShader.d.ts │ │ ├── DepthLimitedBlurShader.js │ │ ├── DigitalGlitch.d.ts │ │ ├── DigitalGlitch.js │ │ ├── DotScreenShader.d.ts │ │ ├── DotScreenShader.js │ │ ├── FXAAShader.d.ts │ │ ├── FXAAShader.js │ │ ├── FilmShader.d.ts │ │ ├── FilmShader.js │ │ ├── FocusShader.d.ts │ │ ├── FocusShader.js │ │ ├── FreiChenShader.d.ts │ │ ├── FreiChenShader.js │ │ ├── FresnelShader.d.ts │ │ ├── FresnelShader.js │ │ ├── GammaCorrectionShader.d.ts │ │ ├── GammaCorrectionShader.js │ │ ├── GodRaysShader.d.ts │ │ ├── GodRaysShader.js │ │ ├── HalftoneShader.d.ts │ │ ├── HalftoneShader.js │ │ ├── HorizontalBlurShader.d.ts │ │ ├── HorizontalBlurShader.js │ │ ├── HorizontalTiltShiftShader.d.ts │ │ ├── HorizontalTiltShiftShader.js │ │ ├── HueSaturationShader.d.ts │ │ ├── HueSaturationShader.js │ │ ├── KaleidoShader.d.ts │ │ ├── KaleidoShader.js │ │ ├── LuminosityHighPassShader.d.ts │ │ ├── LuminosityHighPassShader.js │ │ ├── LuminosityShader.d.ts │ │ ├── LuminosityShader.js │ │ ├── MirrorShader.d.ts │ │ ├── MirrorShader.js │ │ ├── NormalMapShader.d.ts │ │ ├── NormalMapShader.js │ │ ├── OceanShaders.d.ts │ │ ├── OceanShaders.js │ │ ├── ParallaxShader.d.ts │ │ ├── ParallaxShader.js │ │ ├── PixelShader.d.ts │ │ ├── PixelShader.js │ │ ├── RGBShiftShader.d.ts │ │ ├── RGBShiftShader.js │ │ ├── SAOShader.d.ts │ │ ├── SAOShader.js │ │ ├── SMAAShader.d.ts │ │ ├── SMAAShader.js │ │ ├── SSAOShader.d.ts │ │ ├── SSAOShader.js │ │ ├── SepiaShader.d.ts │ │ ├── SepiaShader.js │ │ ├── SobelOperatorShader.d.ts │ │ ├── SobelOperatorShader.js │ │ ├── TechnicolorShader.d.ts │ │ ├── TechnicolorShader.js │ │ ├── ToneMapShader.d.ts │ │ ├── ToneMapShader.js │ │ ├── ToonShader.d.ts │ │ ├── ToonShader.js │ │ ├── TranslucentShader.d.ts │ │ ├── TranslucentShader.js │ │ ├── TriangleBlurShader.d.ts │ │ ├── TriangleBlurShader.js │ │ ├── UnpackDepthRGBAShader.d.ts │ │ ├── UnpackDepthRGBAShader.js │ │ ├── VerticalBlurShader.d.ts │ │ ├── VerticalBlurShader.js │ │ ├── VerticalTiltShiftShader.d.ts │ │ ├── VerticalTiltShiftShader.js │ │ ├── VignetteShader.d.ts │ │ ├── VignetteShader.js │ │ ├── VolumeShader.d.ts │ │ ├── VolumeShader.js │ │ ├── WaterRefractionShader.d.ts │ │ └── WaterRefractionShader.js │ ├── textures/ │ │ ├── CanvasTexture.d.ts │ │ ├── CanvasTexture.js │ │ ├── CompressedTexture.d.ts │ │ ├── CompressedTexture.js │ │ ├── CubeTexture.d.ts │ │ ├── CubeTexture.js │ │ ├── DataTexture.d.ts │ │ ├── DataTexture.js │ │ ├── DataTexture2DArray.d.ts │ │ ├── DataTexture2DArray.js │ │ ├── DataTexture3D.d.ts │ │ ├── DataTexture3D.js │ │ ├── DepthTexture.d.ts │ │ ├── DepthTexture.js │ │ ├── Texture.d.ts │ │ ├── Texture.js │ │ ├── VideoTexture.d.ts │ │ └── VideoTexture.js │ ├── utils/ │ │ ├── BufferGeometryUtils.d.ts │ │ ├── BufferGeometryUtils.js │ │ ├── GeometryCompressionUtils.d.ts │ │ ├── GeometryCompressionUtils.js │ │ ├── GeometryUtils.d.ts │ │ ├── GeometryUtils.js │ │ ├── ImageUtils.js │ │ ├── PMREMGenerator.js │ │ ├── RoughnessMipmapper.d.ts │ │ ├── RoughnessMipmapper.js │ │ ├── SceneUtils.d.ts │ │ ├── SceneUtils.js │ │ ├── ShadowMapViewer.d.ts │ │ ├── ShadowMapViewer.js │ │ ├── ShapeUtils.js │ │ ├── SkeletonUtils.d.ts │ │ ├── SkeletonUtils.js │ │ ├── TypedArrayUtils.d.ts │ │ ├── TypedArrayUtils.js │ │ ├── UVsDebug.d.ts │ │ └── UVsDebug.js │ ├── utils.d.ts │ ├── utils.js │ ├── vr/ │ │ └── HelioWebXRPolyfill.js │ └── webxr/ │ ├── ARButton.d.ts │ ├── ARButton.js │ ├── VRButton.d.ts │ └── VRButton.js └── utils.js
Showing preview only (1,273K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (14191 symbols across 870 files)
FILE: builds/Three.amd.js
function compareTime (line 154) | function compareTime( i, j ) {
function Interpolant (line 555) | function Interpolant( parameterPositions, sampleValues, sampleSize, resu...
function CubicInterpolant (line 801) | function CubicInterpolant( parameterPositions, sampleValues, sampleSize,...
function LinearInterpolant (line 946) | function LinearInterpolant( parameterPositions, sampleValues, sampleSize...
function DiscreteInterpolant (line 991) | function DiscreteInterpolant( parameterPositions, sampleValues, sampleSi...
function KeyframeTrack (line 1020) | function KeyframeTrack( name, times, values, interpolation ) {
function BooleanKeyframeTrack (line 1485) | function BooleanKeyframeTrack( name, times, values ) {
function ColorKeyframeTrack (line 1520) | function ColorKeyframeTrack( name, times, values, interpolation ) {
function NumberKeyframeTrack (line 1551) | function NumberKeyframeTrack( name, times, values, interpolation ) {
function Quaternion (line 1784) | function Quaternion( x, y, z, w ) {
function QuaternionLinearInterpolant (line 2416) | function QuaternionLinearInterpolant( parameterPositions, sampleValues, ...
function QuaternionKeyframeTrack (line 2458) | function QuaternionKeyframeTrack( name, times, values, interpolation ) {
function StringKeyframeTrack (line 2495) | function StringKeyframeTrack( name, times, values, interpolation ) {
function VectorKeyframeTrack (line 2527) | function VectorKeyframeTrack( name, times, values, interpolation ) {
function AnimationClip (line 2554) | function AnimationClip( name, duration, tracks ) {
function getTrackTypeForValueTypeName (line 2571) | function getTrackTypeForValueTypeName( typeName ) {
function parseKeyframeTrack (line 2613) | function parseKeyframeTrack( json ) {
function Vector3 (line 3014) | function Vector3( x, y, z ) {
function Vector4 (line 3838) | function Vector4( x, y, z, w ) {
function Vector2 (line 4492) | function Vector2( x, y ) {
function Color (line 5008) | function Color( r, g, b ) {
function hue2rgb (line 5021) | function hue2rgb( p, q, t ) {
function SRGBToLinear (line 5032) | function SRGBToLinear( c ) {
function LinearToSRGB (line 5038) | function LinearToSRGB( c ) {
function handleAlpha (line 5130) | function handleAlpha( string ) {
function BufferAttribute (line 5571) | function BufferAttribute( array, itemSize, normalized ) {
function Int8BufferAttribute (line 5957) | function Int8BufferAttribute( array, itemSize, normalized ) {
function Uint8BufferAttribute (line 5965) | function Uint8BufferAttribute( array, itemSize, normalized ) {
function Uint8ClampedBufferAttribute (line 5973) | function Uint8ClampedBufferAttribute( array, itemSize, normalized ) {
function Int16BufferAttribute (line 5981) | function Int16BufferAttribute( array, itemSize, normalized ) {
function Uint16BufferAttribute (line 5989) | function Uint16BufferAttribute( array, itemSize, normalized ) {
function Int32BufferAttribute (line 5997) | function Int32BufferAttribute( array, itemSize, normalized ) {
function Uint32BufferAttribute (line 6005) | function Uint32BufferAttribute( array, itemSize, normalized ) {
function Float32BufferAttribute (line 6013) | function Float32BufferAttribute( array, itemSize, normalized ) {
function Float64BufferAttribute (line 6021) | function Float64BufferAttribute( array, itemSize, normalized ) {
function Box3 (line 6068) | function Box3( min, max ) {
function satForAxes (line 6560) | function satForAxes( axes, v0, v1, v2, extents ) {
function EventDispatcher (line 6595) | function EventDispatcher() {}
function Sphere (line 6683) | function Sphere( center, radius ) {
function DirectGeometry (line 6852) | function DirectGeometry() {
function Matrix4 (line 7152) | function Matrix4() {
function Euler (line 8041) | function Euler( x, y, z, order ) {
function Layers (line 8375) | function Layers() {
function Matrix3 (line 8437) | function Matrix3() {
function Object3D (line 8817) | function Object3D() {
function serialize (line 9478) | function serialize( library, element ) {
function extractFromCache (line 9579) | function extractFromCache( cache ) {
function arrayMin (line 9654) | function arrayMin( array ) {
function arrayMax (line 9670) | function arrayMax( array ) {
function BufferGeometry (line 9701) | function BufferGeometry() {
function convertBufferAttribute (line 10564) | function convertBufferAttribute( attribute, indices ) {
function Ray (line 10929) | function Ray( origin, direction ) {
function Material (line 11435) | function Material() {
function extractFromCache (line 11727) | function extractFromCache( cache ) {
function LineBasicMaterial (line 11873) | function LineBasicMaterial( parameters ) {
function Line (line 11919) | function Line( geometry, material, mode ) {
function Plane (line 12154) | function Plane( normal, constant ) {
function Triangle (line 12390) | function Triangle( a, b, c ) {
function Face3 (line 12709) | function Face3( a, b, c, normal, color, materialIndex ) {
function MeshBasicMaterial (line 12798) | function MeshBasicMaterial( parameters ) {
function Mesh (line 12906) | function Mesh( geometry, material ) {
function checkIntersection (line 13214) | function checkIntersection( object, material, raycaster, ray, pA, pB, pC...
function checkBufferGeometryIntersection (line 13245) | function checkBufferGeometryIntersection( object, material, raycaster, r...
function Geometry (line 13342) | function Geometry() {
function addFace (line 13534) | function addFace( a, b, c, materialIndex ) {
function materialIndexSort (line 14220) | function materialIndexSort( a, b ) {
function setBit (line 14376) | function setBit( value, position, enabled ) {
function getNormalIndex (line 14382) | function getNormalIndex( normal ) {
function getColorIndex (line 14399) | function getColorIndex( color ) {
function getUvIndex (line 14416) | function getUvIndex( uv ) {
function SphereGeometry (line 14726) | function SphereGeometry( radius, widthSegments, heightSegments, phiStart...
function SphereBufferGeometry (line 14752) | function SphereBufferGeometry( radius, widthSegments, heightSegments, ph...
function CCDIKSolver (line 14906) | function CCDIKSolver( mesh, iks ) {
function CCDIKHelper (line 15129) | function CCDIKHelper( mesh, iks ) {
function getPosition (line 15185) | function getPosition( bone, matrixWorldInv ) {
function setPositionOfBoneToAttributeArray (line 15193) | function setPositionOfBoneToAttributeArray( array, index, bone, matrixWo...
function createLineGeometry (line 15275) | function createLineGeometry( ik ) {
function createTargetMesh (line 15285) | function createTargetMesh() {
function createEffectorMesh (line 15291) | function createEffectorMesh() {
function createLinkMesh (line 15297) | function createLinkMesh() {
function createLine (line 15303) | function createLine( ik ) {
function AnimationAction (line 15346) | function AnimationAction( mixer, clip, localRoot ) {
function Composite (line 16068) | function Composite( targetGroup, path, optionalParsedPath ) {
function PropertyBinding (line 16128) | function PropertyBinding( rootNode, path, parsedPath ) {
function PropertyMixer (line 16740) | function PropertyMixer( binding, typeName, valueSize ) {
function AnimationMixer (line 16944) | function AnimationMixer( root ) {
method total (line 17120) | get total() {
method inUse (line 17125) | get inUse() {
method total (line 17132) | get total() {
method inUse (line 17137) | get inUse() {
method total (line 17144) | get total() {
method inUse (line 17149) | get inUse() {
function Bone (line 17695) | function Bone() {
function BoxGeometry (line 17720) | function BoxGeometry( width, height, depth, widthSegments, heightSegment...
function BoxBufferGeometry (line 17750) | function BoxBufferGeometry( width, height, depth, widthSegments, heightS...
function CylinderGeometry (line 17926) | function CylinderGeometry( radiusTop, radiusBottom, height, radialSegmen...
function CylinderBufferGeometry (line 17953) | function CylinderBufferGeometry( radiusTop, radiusBottom, height, radial...
function MMDPhysics (line 18254) | function MMDPhysics( mesh, rigidBodyParams, constraintParams, params ) {
function ResourceManager (line 18566) | function ResourceManager() {
function RigidBody (line 19022) | function RigidBody( mesh, world, params, manager ) {
function generateShape (line 19110) | function generateShape( p ) {
function Constraint (line 19331) | function Constraint( mesh, world, bodyA, bodyB, params, manager ) {
function MMDPhysicsHelper (line 19465) | function MMDPhysicsHelper( mesh, physics ) {
function createGeometry (line 19583) | function createGeometry( param ) {
function createCapsuleGeometry (line 19604) | function createCapsuleGeometry( radius, cylinderHeight, segmentsRadius, ...
function MMDAnimationHelper (line 19662) | function MMDAnimationHelper( params ) {
function AudioManager (line 20537) | function AudioManager( audio, params ) {
function GrantSolver (line 20609) | function GrantSolver( mesh, grants ) {
function Camera (line 20958) | function Camera() {
function OrthographicCamera (line 21037) | function OrthographicCamera( left, right, top, bottom, near, far ) {
function PerspectiveCamera (line 21180) | function PerspectiveCamera( fov, aspect, near, far ) {
function PlaneGeometry (line 21419) | function PlaneGeometry( width, height, widthSegments, heightSegments ) {
function PlaneBufferGeometry (line 21442) | function PlaneBufferGeometry( width, height, widthSegments, heightSegmen...
function Scene (line 21537) | function Scene() {
function cloneUniforms (line 21609) | function cloneUniforms( src ) {
function mergeUniforms (line 21646) | function mergeUniforms( uniforms ) {
function ShaderMaterial (line 21702) | function ShaderMaterial( parameters ) {
function Texture (line 21954) | function Texture( image, mapping, wrapS, wrapT, magFilter, minFilter, fo...
function WebGLRenderTarget (line 22273) | function WebGLRenderTarget( width, height, options ) {
function Raycaster (line 23239) | function Raycaster( origin, direction, near, far ) {
function ascSort (line 23269) | function ascSort( a, b ) {
function intersectObject (line 23275) | function intersectObject( object, raycaster, intersects, recursive ) {
function activate (line 23390) | function activate() {
function deactivate (line 23402) | function deactivate() {
function dispose (line 23414) | function dispose() {
function onDocumentMouseMove (line 23420) | function onDocumentMouseMove( event ) {
function onDocumentMouseDown (line 23479) | function onDocumentMouseDown( event ) {
function onDocumentMouseCancel (line 23505) | function onDocumentMouseCancel( event ) {
function onDocumentTouchMove (line 23521) | function onDocumentTouchMove( event ) {
function onDocumentTouchStart (line 23549) | function onDocumentTouchStart( event ) {
function onDocumentTouchEnd (line 23583) | function onDocumentTouchEnd( event ) {
function Spherical (line 23625) | function Spherical( radius, phi, theta ) {
function contextmenu (line 23995) | function contextmenu( event ) {
function bind (line 24027) | function bind( scope, fn ) {
function setOrientation (line 24037) | function setOrientation( controls ) {
function bind (line 24297) | function bind( scope, fn ) {
function contextmenu (line 24307) | function contextmenu( event ) {
function getAutoRotationAngle (line 24655) | function getAutoRotationAngle() {
function getZoomScale (line 24661) | function getZoomScale() {
function rotateLeft (line 24667) | function rotateLeft( angle ) {
function rotateUp (line 24673) | function rotateUp( angle ) {
function dollyIn (line 24760) | function dollyIn( dollyScale ) {
function dollyOut (line 24781) | function dollyOut( dollyScale ) {
function handleMouseDownRotate (line 24806) | function handleMouseDownRotate( event ) {
function handleMouseDownDolly (line 24812) | function handleMouseDownDolly( event ) {
function handleMouseDownPan (line 24818) | function handleMouseDownPan( event ) {
function handleMouseMoveRotate (line 24824) | function handleMouseMoveRotate( event ) {
function handleMouseMoveDolly (line 24842) | function handleMouseMoveDolly( event ) {
function handleMouseMovePan (line 24864) | function handleMouseMovePan( event ) {
function handleMouseWheel (line 24878) | function handleMouseWheel( event ) {
function handleKeyDown (line 24894) | function handleKeyDown( event ) {
function handleTouchStartRotate (line 24932) | function handleTouchStartRotate( event ) {
function handleTouchStartPan (line 24949) | function handleTouchStartPan( event ) {
function handleTouchStartDolly (line 24966) | function handleTouchStartDolly( event ) {
function handleTouchStartDollyPan (line 24977) | function handleTouchStartDollyPan( event ) {
function handleTouchStartDollyRotate (line 24985) | function handleTouchStartDollyRotate( event ) {
function handleTouchMoveRotate (line 24993) | function handleTouchMoveRotate( event ) {
function handleTouchMovePan (line 25020) | function handleTouchMovePan( event ) {
function handleTouchMoveDolly (line 25043) | function handleTouchMoveDolly( event ) {
function handleTouchMoveDollyPan (line 25060) | function handleTouchMoveDollyPan( event ) {
function handleTouchMoveDollyRotate (line 25068) | function handleTouchMoveDollyRotate( event ) {
function onMouseDown (line 25080) | function onMouseDown( event ) {
function onMouseMove (line 25190) | function onMouseMove( event ) {
function onMouseUp (line 25226) | function onMouseUp( event ) {
function onMouseWheel (line 25239) | function onMouseWheel( event ) {
function onKeyDown (line 25254) | function onKeyDown( event ) {
function onTouchStart (line 25262) | function onTouchStart( event ) {
function onTouchMove (line 25348) | function onTouchMove( event ) {
function onTouchEnd (line 25405) | function onTouchEnd( event ) {
function onContextMenu (line 25415) | function onContextMenu( event ) {
function onMouseMove (line 25509) | function onMouseMove( event ) {
function onPointerlockChange (line 25529) | function onPointerlockChange() {
function onPointerlockError (line 25547) | function onPointerlockError() {
function keydown (line 26032) | function keydown( event ) {
function keyup (line 26058) | function keyup() {
function mousedown (line 26068) | function mousedown( event ) {
function mousemove (line 26124) | function mousemove( event ) {
function mouseup (line 26150) | function mouseup( event ) {
function mousewheel (line 26165) | function mousewheel( event ) {
function touchstart (line 26198) | function touchstart( event ) {
function touchmove (line 26230) | function touchmove( event ) {
function touchend (line 26258) | function touchend( event ) {
function contextmenu (line 26280) | function contextmenu( event ) {
function PolyhedronGeometry (line 26337) | function PolyhedronGeometry( vertices, indices, radius, detail ) {
function PolyhedronBufferGeometry (line 26360) | function PolyhedronBufferGeometry( vertices, indices, radius, detail ) {
function OctahedronGeometry (line 26667) | function OctahedronGeometry( radius, detail ) {
function OctahedronBufferGeometry (line 26688) | function OctahedronBufferGeometry( radius, detail ) {
function TorusGeometry (line 26724) | function TorusGeometry( radius, tube, radialSegments, tubularSegments, a...
function TorusBufferGeometry (line 26748) | function TorusBufferGeometry( radius, tube, radialSegments, tubularSegme...
function defineProperty (line 27019) | function defineProperty( propName, defaultValue ) {
function getPointer (line 27420) | function getPointer( event ) {
function onPointerHover (line 27448) | function onPointerHover( event ) {
function onPointerDown (line 27456) | function onPointerDown( event ) {
function onPointerMove (line 27467) | function onPointerMove( event ) {
function onPointerUp (line 27475) | function onPointerUp( event ) {
function Curve (line 28479) | function Curve() {
function GrannyKnot (line 28877) | function GrannyKnot() {
function HeartCurve (line 28902) | function HeartCurve( scale ) {
function VivianiCurve (line 28929) | function VivianiCurve( scale ) {
function KnotCurve (line 28957) | function KnotCurve() {
function HelixCurve (line 28985) | function HelixCurve() {
function TrefoilKnot (line 29013) | function TrefoilKnot( scale ) {
function TorusKnot (line 29040) | function TorusKnot( scale ) {
function CinquefoilKnot (line 29070) | function CinquefoilKnot( scale ) {
function TrefoilPolynomialKnot (line 29100) | function TrefoilPolynomialKnot( scale ) {
function FigureEightPolynomialKnot (line 29134) | function FigureEightPolynomialKnot( scale ) {
function DecoratedTorusKnot4a (line 29161) | function DecoratedTorusKnot4a( scale ) {
function DecoratedTorusKnot4b (line 29188) | function DecoratedTorusKnot4b( scale ) {
function DecoratedTorusKnot5a (line 29215) | function DecoratedTorusKnot5a( scale ) {
function DecoratedTorusKnot5c (line 29242) | function DecoratedTorusKnot5c( scale ) {
function StereoCamera (line 29845) | function StereoCamera() {
function initAsciiSize (line 30172) | function initAsciiSize() {
function asciifyImage (line 30271) | function asciifyImage( canvasRenderer, oAscii ) {
function createMaterial (line 30724) | function createMaterial() {
function getOutlineMaterialFromCache (line 30740) | function getOutlineMaterialFromCache( originalMaterial ) {
function getOutlineMaterial (line 30763) | function getOutlineMaterial( originalMaterial ) {
function isCompatible (line 30775) | function isCompatible( object ) {
function setOutlineMaterial (line 30798) | function setOutlineMaterial( object ) {
function restoreOriginalMaterial (line 30821) | function restoreOriginalMaterial( object ) {
function onBeforeRender (line 30843) | function onBeforeRender( renderer, scene, camera, geometry, material ) {
function updateUniforms (line 30854) | function updateUniforms( material, originalMaterial ) {
function updateOutlineMaterial (line 30878) | function updateOutlineMaterial( material, originalMaterial ) {
function cleanupCache (line 30931) | function cleanupCache() {
function MeshLambertMaterial (line 31461) | function MeshLambertMaterial( parameters ) {
function format (line 31595) | function format( urdf ) {
function base64ToBuffer (line 31630) | function base64ToBuffer( str ) {
function imageToData (line 31646) | function imageToData( image, ext ) {
function attrBufferToArray (line 31668) | function attrBufferToArray( attr ) {
function subArray (line 31697) | function subArray( arr, st, ct ) {
function getAttribute (line 31705) | function getAttribute( attr, name, params, type ) {
function getTransform (line 31730) | function getTransform( o ) {
function processGeometry (line 31745) | function processGeometry( g ) {
function processTexture (line 31852) | function processTexture( tex ) {
function processMaterial (line 31894) | function processMaterial( m ) {
function processObject (line 32058) | function processObject( o ) {
function getUID (line 32522) | function getUID( object ) {
function equalArray (line 32536) | function equalArray( array1, array2 ) {
function stringToArrayBuffer (line 32551) | function stringToArrayBuffer( text ) {
function getMinMax (line 32581) | function getMinMax( attribute, start, count ) {
function isPowerOfTwo (line 32613) | function isPowerOfTwo( image ) {
function isNormalizedNormalAttribute (line 32626) | function isNormalizedNormalAttribute( normal ) {
function createNormalizedNormalAttribute (line 32654) | function createNormalizedNormalAttribute( normal ) {
function getPaddedBufferSize (line 32699) | function getPaddedBufferSize( bufferSize ) {
function getPaddedArrayBuffer (line 32712) | function getPaddedArrayBuffer( arrayBuffer, paddingByte ) {
function serializeUserData (line 32747) | function serializeUserData( object, gltfProperty ) {
function applyTextureTransform (line 32797) | function applyTextureTransform( mapDef, texture ) {
function processBuffer (line 32838) | function processBuffer( buffer ) {
function processBufferView (line 32862) | function processBufferView( attribute, componentType, start, count, targ...
function processBufferViewImage (line 32962) | function processBufferViewImage( blob ) {
function processAccessor (line 33004) | function processAccessor( attribute, geometry, start, count ) {
function processImage (line 33111) | function processImage( image, format, flipY ) {
function processSampler (line 33208) | function processSampler( map ) {
function processTexture (line 33236) | function processTexture( map ) {
function processMaterial (line 33277) | function processMaterial( material ) {
function processMesh (line 33518) | function processMesh( mesh ) {
function processCamera (line 33859) | function processCamera( camera ) {
function processAnimation (line 33921) | function processAnimation( clip, root ) {
function processSkin (line 34030) | function processSkin( object ) {
function processLight (line 34073) | function processLight( light ) {
function processNode (line 34131) | function processNode( object ) {
function processScene (line 34272) | function processScene( scene ) {
function processObjects (line 34335) | function processObjects( objects ) {
function processInput (line 34352) | function processInput( input ) {
function unicodeToShiftjis (line 34694) | function unicodeToShiftjis( str ) {
function getBindBones (line 34746) | function getBindBones( skin ) {
function toStringsFromNumber (line 34782) | function toStringsFromNumber( num ) {
function toStringsFromArray (line 34805) | function toStringsFromArray( array ) {
function traverseMeshes (line 35189) | function traverseMeshes( cb ) {
function Line3 (line 35984) | function Line3( start, end ) {
function ConvexHull (line 36135) | function ConvexHull() {
function Face (line 37061) | function Face() {
function HalfEdge (line 37160) | function HalfEdge( vertex, face ) {
function VertexNode (line 37227) | function VertexNode( point ) {
function VertexList (line 37238) | function VertexList() {
function generate (line 37557) | function generate() {
function pushDecalVertex (line 37651) | function pushDecalVertex( decalVertices, vertex, normal ) {
function clipGeometry (line 37664) | function clipGeometry( inVertices, plane ) {
function clip (line 37804) | function clip( v0, v1, p, s ) {
function ArrowHelper (line 39290) | function ArrowHelper( dir, origin, length, color, headLength, headWidth ) {
function ParametricGeometry (line 39404) | function ParametricGeometry( func, slices, stacks ) {
function ParametricBufferGeometry (line 39426) | function ParametricBufferGeometry( func, slices, stacks ) {
function TorusKnotCurve (line 39721) | function TorusKnotCurve() {
function sphere (line 39763) | function sphere( u, v, target ) {
function plane (line 39790) | function plane( u, v, target ) {
function LineSegments (line 40528) | function LineSegments( geometry, material ) {
function FaceNormalsHelper (line 40606) | function FaceNormalsHelper( object, size, hex, linewidth ) {
function LightProbeHelper (line 40707) | function LightProbeHelper( lightProbe, size ) {
function PositionalAudioHelper (line 40832) | function PositionalAudioHelper( audio, range, divisionsInnerAngle, divis...
function generateSegment (line 40880) | function generateSegment( from, to, divisions, materialIndex ) {
function RectAreaLightHelper (line 40937) | function RectAreaLightHelper( light, color ) {
function VertexNormalsHelper (line 41016) | function VertexNormalsHelper( object, size, hex, linewidth ) {
function VertexTangentsHelper (line 41153) | function VertexTangentsHelper( object, size, hex, linewidth ) {
function Frustum (line 41249) | function Frustum( p0, p1, p2, p3, p4, p5 ) {
function SelectionBox (line 41434) | function SelectionBox( camera, scene, deep ) {
function SelectionHelper (line 41554) | function SelectionHelper( selectionBox, renderer, cssClassName ) {
function SphericalHarmonics3 (line 41646) | function SphericalHarmonics3() {
function Light (line 41878) | function Light( color, intensity ) {
function LightProbe (line 41937) | function LightProbe( sh, intensity ) {
function DataTexture (line 42224) | function DataTexture( data, width, height, format, type, mapping, wrapS,...
function InterleavedBuffer (line 43373) | function InterleavedBuffer( array, stride ) {
function InstancedInterleavedBuffer (line 43467) | function InstancedInterleavedBuffer( array, stride, meshPerAttribute ) {
function InterleavedBufferAttribute (line 43500) | function InterleavedBufferAttribute( interleavedBuffer, itemSize, offset...
function InstancedBufferGeometry (line 43655) | function InstancedBufferGeometry() {
function WireframeGeometry (line 43706) | function WireframeGeometry( geometry ) {
function LoadingManager (line 44769) | function LoadingManager( onLoad, onProgress, onError ) {
function Loader (line 44911) | function Loader( manager ) {
function FileLoader (line 44957) | function FileLoader( manager ) {
function Group (line 45267) | function Group() {
function MeshPhongMaterial (line 45390) | function MeshPhongMaterial( parameters ) {
function MeshStandardMaterial (line 45556) | function MeshStandardMaterial( parameters ) {
function ImageLoader (line 45682) | function ImageLoader( manager ) {
function onImageLoad (line 45720) | function onImageLoad() {
function onImageError (line 45733) | function onImageError( event ) {
function TextureLoader (line 45769) | function TextureLoader( manager ) {
function loadDocument (line 45863) | function loadDocument( data ) {
function parseRelsXml (line 45996) | function parseRelsXml( relsFileText ) {
function parseMetadataNodes (line 46022) | function parseMetadataNodes( metadataNodes ) {
function parseBasematerialsNode (line 46053) | function parseBasematerialsNode( basematerialsNode ) {
function parseTexture2DNode (line 46075) | function parseTexture2DNode( texture2DNode ) {
function parseTextures2DGroupNode (line 46090) | function parseTextures2DGroupNode( texture2DGroupNode ) {
function parseColorGroupNode (line 46118) | function parseColorGroupNode( colorGroupNode ) {
function parseMetallicDisplaypropertiesNode (line 46148) | function parseMetallicDisplaypropertiesNode( metallicDisplaypropetiesNod...
function parseBasematerialNode (line 46176) | function parseBasematerialNode( basematerialNode ) {
function parseMeshNode (line 46188) | function parseMeshNode( meshNode ) {
function parseComponentsNode (line 46272) | function parseComponentsNode( componentsNode ) {
function parseComponentNode (line 46290) | function parseComponentNode( componentNode ) {
function parseTransform (line 46308) | function parseTransform( transform ) {
function parseObjectNode (line 46329) | function parseObjectNode( objectNode ) {
function parseResourcesNode (line 46403) | function parseResourcesNode( resourcesNode ) {
function parseBuildNode (line 46487) | function parseBuildNode( buildNode ) {
function parseModelNode (line 46514) | function parseModelNode( modelNode ) {
function buildTexture (line 46545) | function buildTexture( texture2dgroup, objects, modelData, textureData ) {
function buildBasematerialsMeshes (line 46642) | function buildBasematerialsMeshes( basematerials, triangleProperties, mo...
function buildTexturedMesh (line 46709) | function buildTexturedMesh( texture2dgroup, triangleProperties, modelDat...
function buildVertexColorMesh (line 46767) | function buildVertexColorMesh( colorgroup, triangleProperties, modelData...
function buildDefaultMesh (line 46834) | function buildDefaultMesh( meshData ) {
function buildMeshes (line 46848) | function buildMeshes( resourceMap, modelData, meshData, textureData, obj...
function getResourceType (line 46897) | function getResourceType( pid, modelData ) {
function analyzeObject (line 46923) | function analyzeObject( modelData, meshData, objectData ) {
function buildGroup (line 46948) | function buildGroup( meshData, objects, modelData, textureData, objectDa...
function applyExtensions (line 46965) | function applyExtensions( extensions, meshData, modelXml ) {
function getBuild (line 47003) | function getBuild( data, objects, modelData, textureData, objectData, bu...
function buildBasematerial (line 47013) | function buildBasematerial( materialData, objects, modelData ) {
function buildComposite (line 47059) | function buildComposite( compositeData, objects, modelData, textureData ) {
function buildObject (line 47095) | function buildObject( objectId, objects, modelData, textureData ) {
function buildObjects (line 47120) | function buildObjects( data3mf ) {
function build (line 47170) | function build( objects, data3mf ) {
function loadDocument (line 47263) | function loadDocument( data ) {
function loadDocumentScale (line 47319) | function loadDocumentScale( node ) {
function loadMaterials (line 47349) | function loadMaterials( node ) {
function loadColor (line 47394) | function loadColor( node ) {
function loadMeshVolume (line 47426) | function loadMeshVolume( node ) {
function loadMeshVertices (line 47470) | function loadMeshVertices( node ) {
function loadObject (line 47515) | function loadObject( node ) {
function Skeleton (line 47716) | function Skeleton( bones, boneInverses ) {
function SkinnedMesh (line 47885) | function SkinnedMesh( geometry, material ) {
function find (line 48254) | function find( node, name ) {
function ASSBIN_MESH_HAS_TEXCOORD (line 48466) | function ASSBIN_MESH_HAS_TEXCOORD( n ) {
function ASSBIN_MESH_HAS_COLOR (line 48472) | function ASSBIN_MESH_HAS_COLOR( n ) {
function markBones (line 48478) | function markBones( scene ) {
function cloneTreeToBones (line 48494) | function cloneTreeToBones( root, scene ) {
function sortWeights (line 48519) | function sortWeights( indexes, weights ) {
function findMatchingBone (line 48569) | function findMatchingBone( root, name ) {
function aiMesh (line 48587) | function aiMesh() {
function aiFace (line 48758) | function aiFace() {
function aiVector3D (line 48765) | function aiVector3D() {
function aiColor3D (line 48779) | function aiColor3D() {
function aiQuaternion (line 48793) | function aiQuaternion() {
function aiVertexWeight (line 48807) | function aiVertexWeight() {
function aiString (line 48814) | function aiString() {
function aiVectorKey (line 48831) | function aiVectorKey() {
function aiQuatKey (line 48838) | function aiQuatKey() {
function aiNode (line 48845) | function aiNode() {
function aiBone (line 48881) | function aiBone() {
function aiMaterialProperty (line 48889) | function aiMaterialProperty() {
function aiMaterial (line 48991) | function aiMaterial() {
function veclerp (line 49037) | function veclerp( v1, v2, l ) {
function quatlerp (line 49048) | function quatlerp( q1, q2, l ) {
function sampleTrack (line 49054) | function sampleTrack( keys, time, lne, lerp ) {
function aiNodeAnim (line 49103) | function aiNodeAnim() {
function aiAnimation (line 49208) | function aiAnimation() {
function aiTexture (line 49245) | function aiTexture() {
function aiLight (line 49254) | function aiLight() {
function aiCamera (line 49269) | function aiCamera() {
function aiScene (line 49282) | function aiScene() {
function aiMatrix4 (line 49350) | function aiMatrix4() {
function readFloat (line 49380) | function readFloat( dataview ) {
function Read_double (line 49388) | function Read_double( dataview ) {
function Read_uint8_t (line 49396) | function Read_uint8_t( dataview ) {
function Read_uint16_t (line 49404) | function Read_uint16_t( dataview ) {
function Read_unsigned_int (line 49412) | function Read_unsigned_int( dataview ) {
function Read_uint32_t (line 49420) | function Read_uint32_t( dataview ) {
function Read_aiVector3D (line 49428) | function Read_aiVector3D( stream ) {
function Read_aiColor3D (line 49438) | function Read_aiColor3D( stream ) {
function Read_aiQuaternion (line 49448) | function Read_aiQuaternion( stream ) {
function Read_aiString (line 49459) | function Read_aiString( stream ) {
function Read_aiVertexWeight (line 49468) | function Read_aiVertexWeight( stream ) {
function Read_aiMatrix4x4 (line 49477) | function Read_aiMatrix4x4( stream ) {
function Read_aiVectorKey (line 49495) | function Read_aiVectorKey( stream ) {
function Read_aiQuatKey (line 49504) | function Read_aiQuatKey( stream ) {
function ReadArray_aiVertexWeight (line 49513) | function ReadArray_aiVertexWeight( stream, data, size ) {
function ReadArray_aiVectorKey (line 49519) | function ReadArray_aiVectorKey( stream, data, size ) {
function ReadArray_aiQuatKey (line 49525) | function ReadArray_aiQuatKey( stream, data, size ) {
function ReadBounds (line 49531) | function ReadBounds( stream, T /*p*/, n ) {
function ai_assert (line 49538) | function ai_assert( bool ) {
function ReadBinaryNode (line 49545) | function ReadBinaryNode( stream, parent, depth ) {
function ReadBinaryBone (line 49590) | function ReadBinaryBone( stream, b ) {
function ReadBinaryMesh (line 49618) | function ReadBinaryMesh( stream, mesh ) {
function ReadBinaryMaterialProperty (line 49818) | function ReadBinaryMaterialProperty( stream, prop ) {
function ReadBinaryMaterial (line 49836) | function ReadBinaryMaterial( stream, mat ) {
function ReadBinaryNodeAnim (line 49865) | function ReadBinaryNodeAnim( stream, nd ) {
function ReadBinaryAnim (line 49931) | function ReadBinaryAnim( stream, anim ) {
function ReadBinaryTexture (line 49957) | function ReadBinaryTexture( stream, tex ) {
function ReadBinaryLight (line 49985) | function ReadBinaryLight( stream, l ) {
function ReadBinaryCamera (line 50015) | function ReadBinaryCamera( stream, cam ) {
function ReadBinaryScene (line 50032) | function ReadBinaryScene( stream, scene ) {
function extendStream (line 50131) | function extendStream( stream ) {
function InternReadFile (line 50193) | function InternReadFile( pFiledata ) {
function Block (line 50289) | function Block() {
function AWDProperties (line 50298) | function AWDProperties() {}
function CompressedTexture (line 51433) | function CompressedTexture( mipmaps, width, height, format, type, mappin...
function init (line 51880) | function init( wasmBinary ) {
function transcode (line 51901) | function transcode( buffer ) {
function readBvh (line 52026) | function readBvh( lines ) {
function readFrameData (line 52092) | function readFrameData( data, frameTime, bone ) {
function readNode (line 52167) | function readNode( lines, firstline, list ) {
function toTHREEBone (line 52270) | function toTHREEBone( source, list ) {
function toTHREEAnimation (line 52299) | function toTHREEAnimation( bones ) {
function nextLine (line 52359) | function nextLine( lines ) {
function AmbientLight (line 52393) | function AmbientLight( color, intensity ) {
function LightShadow (line 52416) | function LightShadow( camera ) {
function DirectionalLightShadow (line 52545) | function DirectionalLightShadow() {
function DirectionalLight (line 52571) | function DirectionalLight( color, intensity ) {
function PointLightShadow (line 52607) | function PointLightShadow() {
function PointLight (line 52693) | function PointLight( color, intensity, distance, decay ) {
function SpotLightShadow (line 52749) | function SpotLightShadow() {
function SpotLight (line 52789) | function SpotLight( color, intensity, distance, angle, penumbra, decay ) {
function tgaCheckHeader (line 52899) | function tgaCheckHeader( header ) {
function tgaParse (line 52960) | function tgaParse( use_rle, use_pal, header, offset, data ) {
function tgaGetImageData8bits (line 53048) | function tgaGetImageData8bits( imageData, y_start, y_step, y_end, x_star...
function tgaGetImageData16bits (line 53072) | function tgaGetImageData16bits( imageData, y_start, y_step, y_end, x_sta...
function tgaGetImageData24bits (line 53095) | function tgaGetImageData24bits( imageData, y_start, y_step, y_end, x_sta...
function tgaGetImageData32bits (line 53117) | function tgaGetImageData32bits( imageData, y_start, y_step, y_end, x_sta...
function tgaGetImageDataGrey8bits (line 53139) | function tgaGetImageDataGrey8bits( imageData, y_start, y_step, y_end, x_...
function tgaGetImageDataGrey16bits (line 53162) | function tgaGetImageDataGrey16bits( imageData, y_start, y_step, y_end, x...
function getTgaRGBA (line 53184) | function getTgaRGBA( data, width, height, image, palette ) {
function Node (line 53401) | function Node( type ) {
method convertUpAxis (line 53621) | set convertUpAxis( value ) {
function getElementsByTagName (line 53631) | function getElementsByTagName( xml, name ) {
function parseStrings (line 53654) | function parseStrings( text ) {
function parseFloats (line 53671) | function parseFloats( text ) {
function parseInts (line 53688) | function parseInts( text ) {
function parseId (line 53705) | function parseId( text ) {
function generateId (line 53711) | function generateId() {
function isEmpty (line 53717) | function isEmpty( object ) {
function parseAsset (line 53725) | function parseAsset( xml ) {
function parseAssetUnit (line 53734) | function parseAssetUnit( xml ) {
function parseAssetUpAxis (line 53748) | function parseAssetUpAxis( xml ) {
function parseLibrary (line 53756) | function parseLibrary( xml, libraryName, nodeName, parser ) {
function buildLibrary (line 53774) | function buildLibrary( data, builder ) {
function getBuild (line 53787) | function getBuild( data, builder ) {
function parseAnimation (line 53799) | function parseAnimation( xml ) {
function parseAnimationSampler (line 53843) | function parseAnimationSampler( xml ) {
function parseAnimationChannel (line 53871) | function parseAnimationChannel( xml ) {
function buildAnimation (line 53926) | function buildAnimation( data ) {
function getAnimation (line 53959) | function getAnimation( id ) {
function buildAnimationChannel (line 53965) | function buildAnimationChannel( channel, inputSource, outputSource ) {
function prepareAnimationData (line 54038) | function prepareAnimationData( data, defaultMatrix ) {
function createKeyframeTracks (line 54078) | function createKeyframeTracks( animation, tracks ) {
function transformAnimationData (line 54113) | function transformAnimationData( keyframes, property, defaultValue ) {
function createMissingKeyframes (line 54160) | function createMissingKeyframes( keyframes, property ) {
function getPrev (line 54195) | function getPrev( keyframes, i, property ) {
function getNext (line 54211) | function getNext( keyframes, i, property ) {
function interpolate (line 54227) | function interpolate( key, prev, next, property ) {
function parseAnimationClip (line 54242) | function parseAnimationClip( xml ) {
function buildAnimationClip (line 54271) | function buildAnimationClip( data ) {
function getAnimationClip (line 54295) | function getAnimationClip( id ) {
function parseController (line 54303) | function parseController( xml ) {
function parseSkin (line 54334) | function parseSkin( xml ) {
function parseJoints (line 54373) | function parseJoints( xml ) {
function parseVertexWeights (line 54401) | function parseVertexWeights( xml ) {
function buildController (line 54438) | function buildController( data ) {
function buildSkin (line 54461) | function buildSkin( data ) {
function getController (line 54575) | function getController( id ) {
function parseImage (line 54583) | function parseImage( xml ) {
function buildImage (line 54593) | function buildImage( data ) {
function getImage (line 54601) | function getImage( id ) {
function parseEffect (line 54619) | function parseEffect( xml ) {
function parseEffectProfileCOMMON (line 54643) | function parseEffectProfileCOMMON( xml ) {
function parseEffectNewparam (line 54678) | function parseEffectNewparam( xml, data ) {
function parseEffectSurface (line 54704) | function parseEffectSurface( xml ) {
function parseEffectSampler (line 54728) | function parseEffectSampler( xml ) {
function parseEffectTechnique (line 54752) | function parseEffectTechnique( xml ) {
function parseEffectParameters (line 54780) | function parseEffectParameters( xml ) {
function parseEffectParameter (line 54816) | function parseEffectParameter( xml ) {
function parseEffectParameterTexture (line 54848) | function parseEffectParameterTexture( xml ) {
function parseEffectParameterTextureExtra (line 54874) | function parseEffectParameterTextureExtra( xml, data ) {
function parseEffectParameterTextureExtraTechnique (line 54894) | function parseEffectParameterTextureExtraTechnique( xml, data ) {
function parseEffectExtra (line 54938) | function parseEffectExtra( xml ) {
function parseEffectExtraTechnique (line 54962) | function parseEffectExtraTechnique( xml ) {
function buildEffect (line 54986) | function buildEffect( data ) {
function getEffect (line 54992) | function getEffect( id ) {
function parseMaterial (line 55000) | function parseMaterial( xml ) {
function getTextureLoader (line 55026) | function getTextureLoader( image ) {
function buildMaterial (line 55048) | function buildMaterial( data ) {
function getMaterial (line 55255) | function getMaterial( id ) {
function parseCamera (line 55263) | function parseCamera( xml ) {
function parseCameraOptics (line 55289) | function parseCameraOptics( xml ) {
function parseCameraTechnique (line 55308) | function parseCameraTechnique( xml ) {
function parseCameraParameters (line 55334) | function parseCameraParameters( xml ) {
function buildCamera (line 55362) | function buildCamera( data ) {
function getCamera (line 55407) | function getCamera( id ) {
function parseLight (line 55425) | function parseLight( xml ) {
function parseLightTechnique (line 55449) | function parseLightTechnique( xml ) {
function parseLightParameters (line 55477) | function parseLightParameters( xml ) {
function buildLight (line 55511) | function buildLight( data ) {
function getLight (line 55542) | function getLight( id ) {
function parseGeometry (line 55560) | function parseGeometry( xml ) {
function parseSource (line 55615) | function parseSource( xml ) {
function parseGeometryVertices (line 55656) | function parseGeometryVertices( xml ) {
function parseGeometryPrimitive (line 55674) | function parseGeometryPrimitive( xml ) {
function groupPrimitives (line 55720) | function groupPrimitives( primitives ) {
function checkUVCoordinates (line 55738) | function checkUVCoordinates( primitives ) {
function buildGeometry (line 55762) | function buildGeometry( data ) {
function buildGeometryType (line 55795) | function buildGeometryType( primitives, sources, vertices ) {
function buildGeometryData (line 55993) | function buildGeometryData( primitive, source, offset, array ) {
function getGeometry (line 56071) | function getGeometry( id ) {
function parseKinematicsModel (line 56079) | function parseKinematicsModel( xml ) {
function buildKinematicsModel (line 56107) | function buildKinematicsModel( data ) {
function getKinematicsModel (line 56115) | function getKinematicsModel( id ) {
function parseKinematicsTechniqueCommon (line 56121) | function parseKinematicsTechniqueCommon( xml, data ) {
function parseKinematicsJoint (line 56145) | function parseKinematicsJoint( xml ) {
function parseKinematicsJointParameter (line 56170) | function parseKinematicsJointParameter( xml, data ) {
function parseKinematicsLink (line 56226) | function parseKinematicsLink( xml ) {
function parseKinematicsAttachment (line 56261) | function parseKinematicsAttachment( xml ) {
function parseKinematicsTransform (line 56295) | function parseKinematicsTransform( xml ) {
function parsePhysicsModel (line 56329) | function parsePhysicsModel( xml ) {
function parsePhysicsRigidBody (line 56357) | function parsePhysicsRigidBody( xml, data ) {
function parsePhysicsTechniqueCommon (line 56377) | function parsePhysicsTechniqueCommon( xml, data ) {
function parseKinematicsScene (line 56403) | function parseKinematicsScene( xml ) {
function parseKinematicsBindJointAxis (line 56429) | function parseKinematicsBindJointAxis( xml ) {
function buildKinematicsScene (line 56458) | function buildKinematicsScene( data ) {
function getKinematicsScene (line 56466) | function getKinematicsScene( id ) {
function setupKinematics (line 56472) | function setupKinematics() {
function buildTransformList (line 56648) | function buildTransformList( node ) {
function prepareNodes (line 56705) | function prepareNodes( xml ) {
function parseNode (line 56728) | function parseNode( xml ) {
function parseNodeInstance (line 56828) | function parseNodeInstance( xml ) {
function buildSkeleton (line 56869) | function buildSkeleton( skeletons, joints ) {
function buildBoneHierarchy (line 56971) | function buildBoneHierarchy( root, joints, boneData ) {
function buildNode (line 57016) | function buildNode( data ) {
function resolveMaterialBinding (line 57157) | function resolveMaterialBinding( keys, instanceMaterials ) {
function buildObjects (line 57182) | function buildObjects( geometries, instanceMaterials ) {
function hasNode (line 57263) | function hasNode( id ) {
function getNode (line 57269) | function getNode( id ) {
function parseVisualScene (line 57277) | function parseVisualScene( xml ) {
function buildVisualScene (line 57298) | function buildVisualScene( data ) {
function hasVisualScene (line 57317) | function hasVisualScene( id ) {
function getVisualScene (line 57323) | function getVisualScene( id ) {
function parseScene (line 57331) | function parseScene( xml ) {
function setupAnimations (line 57338) | function setupAnimations() {
function parserErrorToText (line 57381) | function parserErrorToText( parserError ) {
function CompressedTextureLoader (line 57543) | function CompressedTextureLoader( manager ) {
function loadTexture (line 57566) | function loadTexture( i ) {
function fourCCToInt32 (line 57702) | function fourCCToInt32( value ) {
function int32ToFourCC (line 57711) | function int32ToFourCC( value ) {
function loadARGBMip (line 57722) | function loadARGBMip( buffer, dataOffset, width, height ) {
function decodeGeometry (line 58399) | function decodeGeometry( draco, decoder, decoderBuffer, taskConfig ) {
function decodeAttribute (line 58497) | function decodeAttribute( draco, decoder, dracoGeometry, attributeName, ...
function DataTextureLoader (line 58614) | function DataTextureLoader( manager ) {
function reverseLutFromBitmap (line 58814) | function reverseLutFromBitmap( bitmap, lut ) {
function hufClearDecTable (line 58836) | function hufClearDecTable( hdec ) {
function getBits (line 58851) | function getBits( nBits, c, lc, uInt8Array, inOffset ) {
function hufCanonicalCodeTable (line 58870) | function hufCanonicalCodeTable( hcode ) {
function hufUnpackEncTable (line 58894) | function hufUnpackEncTable( uInt8Array, inDataView, inOffset, ni, im, iM...
function hufLength (line 58958) | function hufLength( code ) {
function hufCode (line 58964) | function hufCode( code ) {
function hufBuildDecTable (line 58970) | function hufBuildDecTable( hcode, im, iM, hdecod ) {
function getChar (line 59045) | function getChar( c, lc, uInt8Array, inOffset ) {
function getCode (line 59057) | function getCode( po, rlc, c, lc, uInt8Array, inDataView, inOffset, outB...
function UInt16 (line 59103) | function UInt16( value ) {
function Int16 (line 59109) | function Int16( value ) {
function wdec14 (line 59118) | function wdec14( l, h ) {
function wav2Decode (line 59134) | function wav2Decode( buffer, j, nx, ox, ny, oy ) {
function hufDecode (line 59233) | function hufDecode( encodingTable, decodingTable, uInt8Array, inDataView...
function hufUncompress (line 59345) | function hufUncompress( uInt8Array, inDataView, inOffset, nCompressed, o...
function applyLut (line 59386) | function applyLut( lut, data, nData ) {
function predictor (line 59396) | function predictor( source ) {
function interleaveScalar (line 59407) | function interleaveScalar( source, out ) {
function decodeRunLength (line 59426) | function decodeRunLength( source ) {
function lossyDctDecode (line 59469) | function lossyDctDecode( cscSet, rowPtrs, channelData, acBuffer, dcBuffe...
function unRleAC (line 59630) | function unRleAC( currAcComp, acBuffer, halfZigBlock ) {
function unZigZag (line 59660) | function unZigZag( src, dst ) {
function dctInverse (line 59735) | function dctInverse( data ) {
function csc709Inverse (line 59823) | function csc709Inverse( data ) {
function convertToHalf (line 59839) | function convertToHalf( src, dst, idx ) {
function toLinear (line 59849) | function toLinear( float ) {
function uncompressRAW (line 59863) | function uncompressRAW( info ) {
function uncompressRLE (line 59869) | function uncompressRLE( info ) {
function uncompressZIP (line 59884) | function uncompressZIP( info ) {
function uncompressPIZ (line 59907) | function uncompressPIZ( info ) {
function uncompressDWA (line 60008) | function uncompressDWA( info ) {
function parseNullTerminatedString (line 60225) | function parseNullTerminatedString( buffer, offset ) {
function parseFixedLengthString (line 60246) | function parseFixedLengthString( buffer, offset, size ) {
function parseUlong (line 60258) | function parseUlong( dataView, offset ) {
function parseUint32 (line 60268) | function parseUint32( dataView, offset ) {
function parseUint8Array (line 60278) | function parseUint8Array( uInt8Array, offset ) {
function parseUint8 (line 60288) | function parseUint8( dataView, offset ) {
function parseInt64 (line 60298) | function parseInt64( dataView, offset ) {
function parseFloat32 (line 60308) | function parseFloat32( dataView, offset ) {
function decodeFloat16 (line 60319) | function decodeFloat16( binary ) {
function parseUint16 (line 60391) | function parseUint16( dataView, offset ) {
function parseFloat16 (line 60401) | function parseFloat16( buffer, offset ) {
function parseChlist (line 60407) | function parseChlist( dataView, buffer, offset, size ) {
function parseChromaticities (line 60437) | function parseChromaticities( dataView, offset ) {
function parseCompression (line 60452) | function parseCompression( dataView, offset ) {
function parseBox2i (line 60473) | function parseBox2i( dataView, offset ) {
function parseLineOrder (line 60484) | function parseLineOrder( dataView, offset ) {
function parseV2f (line 60496) | function parseV2f( dataView, offset ) {
function parseValue (line 60505) | function parseValue( dataView, buffer, offset, type, size ) {
function onLoadCallback (line 60826) | function onLoadCallback( texture, texData ) {
function FBXLoader (line 60887) | function FBXLoader( manager ) {
function FBXTreeParser (line 60966) | function FBXTreeParser( textureLoader, manager ) {
function GeometryParser (line 62337) | function GeometryParser() {}
function AnimationParser (line 63165) | function AnimationParser() {}
function TextParser (line 63748) | function TextParser() {}
function BinaryParser (line 64086) | function BinaryParser() {}
function BinaryReader (line 64414) | function BinaryReader( buffer, littleEndian ) {
function FBXTree (line 64661) | function FBXTree() {}
function isFbxFormatBinary (line 64677) | function isFbxFormatBinary( buffer ) {
function isFbxFormatASCII (line 64685) | function isFbxFormatASCII( text ) {
function getFbxVersion (line 64715) | function getFbxVersion( text ) {
function convertFBXTimeToSeconds (line 64730) | function convertFBXTimeToSeconds( time ) {
function getData (line 64739) | function getData( polygonVertexIndex, polygonIndex, vertexIndex, infoObj...
function generateTransform (line 64777) | function generateTransform( transformData ) {
function getEulerOrder (line 64883) | function getEulerOrder( order ) {
function parseNumberArray (line 64908) | function parseNumberArray( value ) {
function convertArrayBufferToString (line 64920) | function convertArrayBufferToString( buffer, from, to ) {
function append (line 64929) | function append( a, b ) {
function slice (line 64939) | function slice( a, b, from, to ) {
function inject (line 64952) | function inject( a1, index, a2 ) {
function newLayer (line 65013) | function newLayer( line ) {
function addSegment (line 65021) | function addSegment( p1, p2 ) {
function delta (line 65043) | function delta( v1, v2 ) {
function absolute (line 65049) | function absolute( v1, v2 ) {
function addObject (line 65128) | function addObject( vertex, extruding ) {
function LineLoop (line 65183) | function LineLoop( geometry, material ) {
function PointsMaterial (line 65217) | function PointsMaterial( parameters ) {
function Points (line 65272) | function Points( geometry, material ) {
function testPoint (line 65415) | function testPoint( point, index, localThresholdSq, matrixWorld, raycast...
function GLTFLoader (line 65456) | function GLTFLoader( manager ) {
function GLTFRegistry (line 65670) | function GLTFRegistry() {
function GLTFTextureDDSExtension (line 65725) | function GLTFTextureDDSExtension( ddsLoader ) {
function GLTFLightsExtension (line 65743) | function GLTFLightsExtension( json ) {
function GLTFMaterialsUnlitExtension (line 65812) | function GLTFMaterialsUnlitExtension() {
function GLTFBinaryExtension (line 65861) | function GLTFBinaryExtension( data ) {
function GLTFDracoMeshCompressionExtension (line 65927) | function GLTFDracoMeshCompressionExtension( json, dracoLoader ) {
function GLTFTextureTransformExtension (line 66006) | function GLTFTextureTransformExtension() {
function GLTFMeshStandardSGMaterial (line 66058) | function GLTFMeshStandardSGMaterial( params ) {
function GLTFMaterialsPbrSpecularGlossinessExtension (line 66202) | function GLTFMaterialsPbrSpecularGlossinessExtension() {
function GLTFMeshQuantizationExtension (line 66343) | function GLTFMeshQuantizationExtension() {
function GLTFCubicSplineInterpolant (line 66355) | function GLTFCubicSplineInterpolant( parameterPositions, sampleValues, s...
function resolveURL (line 66528) | function resolveURL( url, path ) {
function createDefaultMaterial (line 66557) | function createDefaultMaterial( cache ) {
function addUnknownExtensionsToUserData (line 66577) | function addUnknownExtensionsToUserData( knownExtensions, object, object...
function assignExtrasToUserData (line 66598) | function assignExtrasToUserData( object, gltfDef ) {
function addMorphTargets (line 66624) | function addMorphTargets( geometry, targets, parser ) {
function updateMorphTargets (line 66693) | function updateMorphTargets( mesh, meshDef ) {
function createPrimitiveKey (line 66732) | function createPrimitiveKey( primitiveDef ) {
function createAttributesKey (line 66753) | function createAttributesKey( attributes ) {
function GLTFParser (line 66771) | function GLTFParser( json, extensions, options ) {
function computeBounds (line 67628) | function computeBounds( geometry, primitiveDef, parser ) {
function addPrimitiveAttributes (line 67719) | function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
function toTrianglesDrawMode (line 67778) | function toTrianglesDrawMode( geometry, drawMode ) {
function createDracoPrimitive (line 67879) | function createDracoPrimitive( primitive ) {
function buildNodeHierachy (line 68490) | function buildNodeHierachy( nodeId, parentObject, json, parser ) {
function CubeTexture (line 68629) | function CubeTexture( images, mapping, wrapS, wrapT, magFilter, minFilte...
function toHalf (line 69002) | function toHalf( val ) {
function onLoadCallback (line 69145) | function onLoadCallback( texture, texData ) {
function loadHDRData (line 69261) | function loadHDRData( i, onLoad, onProgress, onError ) {
function findFile (line 69353) | function findFile( url ) {
function KhronosTextureContainer (line 69473) | function KhronosTextureContainer( arrayBuffer, facesExpected /*, threeDE...
function smoothNormals (line 69616) | function smoothNormals( triangles, lineSegments ) {
function isPrimitiveType (line 69803) | function isPrimitiveType( type ) {
function LineParser (line 69809) | function LineParser( line, lineNumber ) {
function sortByMaterial (line 69893) | function sortByMaterial( a, b ) {
function createObject (line 69911) | function createObject( elements, elementSize, isConditionalSegments ) {
function LDrawLoader (line 70046) | function LDrawLoader( manager ) {
function parseColourCode (line 70594) | function parseColourCode( lineParser, forEdge ) {
function parseVector (line 70623) | function parseVector( lp ) {
function onSubobjectFinish (line 71175) | function onSubobjectFinish() {
function finalizeObject (line 71203) | function finalizeObject() {
function loadSubobject (line 71319) | function loadSubobject( subobject ) {
function onSubobjectLoaded (line 71422) | function onSubobjectLoaded( subobjectGroup, subobject ) {
function onSubobjectError (line 71436) | function onSubobjectError( err, subobject ) {
function MeshPhysicalMaterial (line 71467) | function MeshPhysicalMaterial( parameters ) {
function LWO2Parser (line 71549) | function LWO2Parser( IFFParser ) {
function LWO3Parser (line 71963) | function LWO3Parser( IFFParser ) {
function IFFParser (line 72371) | function IFFParser( ) {
function DataViewReader (line 73228) | function DataViewReader( buffer ) {
function Debugger (line 73434) | function Debugger( ) {
function isEven (line 73517) | function isEven( num ) {
function stringOffset (line 73525) | function stringOffset( string ) {
function printBuffer (line 73533) | function printBuffer( buffer, from, to ) {
function LWOTreeParser (line 73593) | function LWOTreeParser( textureLoader ) {
function MaterialParser (line 73779) | function MaterialParser( textureLoader ) {
function GeometryParser (line 74264) | function GeometryParser() {}
function extractParentUrl (line 74536) | function extractParentUrl( url, dir ) {
function MeshToonMaterial (line 74971) | function MeshToonMaterial( parameters ) {
function MMDLoader (line 75115) | function MMDLoader( manager ) {
function MeshBuilder (line 75414) | function MeshBuilder( manager ) {
function initBones (line 75468) | function initBones( mesh ) {
function GeometryBuilder (line 75532) | function GeometryBuilder() {
function updateAttributes (line 75805) | function updateAttributes( attribute, morph, ratio ) {
function MaterialBuilder (line 75995) | function MaterialBuilder( manager ) {
function checkAlphaMorph (line 76240) | function checkAlphaMorph( elements, materials ) {
function createImageData (line 76433) | function createImageData( image ) {
function detectImageTransparency (line 76446) | function detectImageTransparency( image, uvs, indices ) {
function getAlphaByUv (line 76489) | function getAlphaByUv( image, uv ) {
function AnimationBuilder (line 76529) | function AnimationBuilder() {
function pushInterpolation (line 76566) | function pushInterpolation( array, interpolation, index ) {
function pushVector3 (line 76703) | function pushVector3( array, vec ) {
function pushQuaternion (line 76711) | function pushQuaternion( array, q ) {
function pushInterpolation (line 76720) | function pushInterpolation( array, interpolation, index ) {
function CubicBezierInterpolation (line 76891) | function CubicBezierInterpolation( parameterPositions, sampleValues, sam...
function resolveURL (line 77341) | function resolveURL( baseUrl, url ) {
function setMapForType (line 77353) | function setMapForType( mapType, value ) {
function TempNode (line 77568) | function TempNode( type, params ) {
function InputNode (line 77712) | function InputNode( type, params ) {
function ConstNode (line 77807) | function ConstNode( src, useDefine ) {
function VarNode (line 77930) | function VarNode( type, value ) {
function StructNode (line 77999) | function StructNode( src ) {
function AttributeNode (line 78101) | function AttributeNode( name, type ) {
function FunctionNode (line 78243) | function FunctionNode( src, includes, extensions, keywords, type ) {
function ExpressionNode (line 78517) | function ExpressionNode( src, type, keywords, extensions, includes ) {
function FunctionCallNode (line 78532) | function FunctionCallNode( func, inputs ) {
function applyShortcut (line 78648) | function applyShortcut( proxy, property, subProperty ) {
function NodeFrame (line 78719) | function NodeFrame( time ) {
function NodeUniform (line 78779) | function NodeUniform( params ) {
function Vector2Node (line 78815) | function Vector2Node( x, y ) {
function Vector3Node (line 78869) | function Vector3Node( x, y, z ) {
function Vector4Node (line 78924) | function Vector4Node( x, y, z, w ) {
function UVNode (line 78980) | function UVNode( index ) {
function FloatNode (line 79046) | function FloatNode( value ) {
function ColorSpaceNode (line 79097) | function ColorSpaceNode( input, method ) {
function TextureNode (line 79398) | function TextureNode( value, uv, bias, project ) {
function PositionNode (line 79510) | function PositionNode( scope ) {
function NormalNode (line 79661) | function NormalNode( scope ) {
function ReflectNode (line 79799) | function ReflectNode( scope ) {
function CubeTextureNode (line 79954) | function CubeTextureNode( value, uv, bias ) {
function OperatorNode (line 80059) | function OperatorNode( a, b, op ) {
function MathNode (line 80145) | function MathNode( a, bOrMethod, cOrMethod, method ) {
function TextureCubeUVNode (line 80413) | function TextureCubeUVNode( value, uv, bias ) {
function TextureCubeNode (line 80603) | function TextureCubeNode( value, uv, bias ) {
function NodeBuilder (line 80710) | function NodeBuilder() {
function sortByPosition (line 81357) | function sortByPosition( a, b ) {
function BoolNode (line 81640) | function BoolNode( value ) {
function IntNode (line 81691) | function IntNode( value ) {
function ColorNode (line 81742) | function ColorNode( color, g, b ) {
function Matrix3Node (line 81797) | function Matrix3Node( matrix ) {
function Matrix4Node (line 81865) | function Matrix4Node( matrix ) {
function ScreenNode (line 81934) | function ScreenNode( uv ) {
function ReflectorNode (line 81961) | function ReflectorNode( mirror ) {
function PropertyNode (line 82046) | function PropertyNode( object, property, type ) {
function RawNode (line 82101) | function RawNode( value ) {
function NodeMaterial (line 82163) | function NodeMaterial( vertex, fragment ) {
function RTTNode (line 82374) | function RTTNode( width, height, input, options ) {
function ColorsNode (line 82523) | function ColorsNode( index ) {
function CameraNode (line 82576) | function CameraNode( scope, camera ) {
function LightNode (line 82809) | function LightNode( scope ) {
function ResolutionNode (line 82870) | function ResolutionNode() {
function ScreenUVNode (line 82932) | function ScreenUVNode( resolution ) {
function CondNode (line 82995) | function CondNode( a, b, op, ifNode, elseNode ) {
function NoiseNode (line 83121) | function NoiseNode( uv ) {
function CheckerNode (line 83188) | function CheckerNode( uv ) {
function NormalMapNode (line 83261) | function NormalMapNode( value, scale ) {
function BumpMapNode (line 83356) | function BumpMapNode( value, scale ) {
function BypassNode (line 83518) | function BypassNode( code, value ) {
function JoinNode (line 83605) | function JoinNode( x, y, z, w ) {
function SwitchNode (line 83714) | function SwitchNode( node, components ) {
function TimerNode (line 83816) | function TimerNode( scale, scope, timeScale ) {
function VelocityNode (line 83920) | function VelocityNode( target, params ) {
function UVTransformNode (line 84094) | function UVTransformNode( uv, position ) {
function MaxMIPLevelNode (line 84158) | function MaxMIPLevelNode( texture ) {
function SpecularMIPLevelNode (line 84219) | function SpecularMIPLevelNode( roughness, texture ) {
function SubSlotNode (line 84317) | function SubSlotNode( slots ) {
function BlurNode (line 84394) | function BlurNode( value, uv, radius, size ) {
function LuminanceNode (line 84556) | function LuminanceNode( rgb ) {
function ColorAdjustmentNode (line 84627) | function ColorAdjustmentNode( rgb, adjustment, method ) {
function SpriteNode (line 84757) | function SpriteNode() {
function PhongNode (line 84986) | function PhongNode() {
function StandardNode (line 85394) | function StandardNode() {
function MeshStandardNode (line 85990) | function MeshStandardNode() {
function SpriteNodeMaterial (line 86097) | function SpriteNodeMaterial() {
function PhongNodeMaterial (line 86123) | function PhongNodeMaterial() {
function StandardNodeMaterial (line 86158) | function StandardNodeMaterial() {
function MeshStandardNodeMaterial (line 86197) | function MeshStandardNodeMaterial() {
function NodePostProcessing (line 86227) | function NodePostProcessing( renderer, renderTarget ) {
function scan (line 87401) | function scan( type, chunks ) {
function flipEndianness (line 87479) | function flipEndianness( array, chunkSize ) {
function parseHeader (line 87499) | function parseHeader( header ) {
function parseDataAsText (line 87562) | function parseDataAsText( data, start, end ) {
function LineDashedMaterial (line 88007) | function LineDashedMaterial( parameters ) {
function MeshDepthMaterial (line 88062) | function MeshDepthMaterial( parameters ) {
function MeshDistanceMaterial (line 88143) | function MeshDistanceMaterial( parameters ) {
function MeshNormalMaterial (line 88226) | function MeshNormalMaterial( parameters ) {
function RawShaderMaterial (line 88292) | function RawShaderMaterial( parameters ) {
function ShadowMaterial (line 88314) | function ShadowMaterial( parameters ) {
function SpriteMaterial (line 88355) | function SpriteMaterial( parameters ) {
function MaterialLoader (line 88422) | function MaterialLoader( manager ) {
function getTexture (line 88452) | function getTexture( name ) {
function ParserState (line 91273) | function ParserState() {
function OBJLoader (line 91625) | function OBJLoader( manager ) {
function interceptOnLoad (line 92526) | function interceptOnLoad( object3d, message ) {
function scopedOnLoad (line 92573) | function scopedOnLoad( message ) {
function decompressLZF (line 92675) | function decompressLZF( inData, outLength ) {
function parseHeader (line 92727) | function parseHeader( data ) {
function trim (line 93047) | function trim( text ) {
function capitalize (line 93053) | function capitalize( text ) {
function hash (line 93059) | function hash( s, e ) {
function parseBond (line 93065) | function parseBond( start, length ) {
function buildGeometry (line 93084) | function buildGeometry() {
function parseHeader (line 93271) | function parseHeader( data ) {
function parseASCIINumber (line 93385) | function parseASCIINumber( n, type ) {
function parseASCIIElement (line 93402) | function parseASCIIElement( properties, line ) {
function parseASCII (line 93435) | function parseASCII( data, header ) {
function postProcess (line 93491) | function postProcess( buffer ) {
function handleElement (line 93538) | function handleElement( buffer, elementName, element ) {
function binaryRead (line 93590) | function binaryRead( dataview, at, type, little_endian ) {
function binaryReadElement (line 93608) | function binaryReadElement( dataview, at, properties, little_endian ) {
function parseBinary (line 93647) | function parseBinary( data, header ) {
function isBigEndianPlatform (line 93718) | function isBigEndianPlatform() {
function copyFromBuffer (line 93760) | function copyFromBuffer( sourceArrayBuffer, viewType, position, length, ...
function decodePrwm (line 93789) | function decodePrwm( buffer ) {
function PRWMLoader (line 93925) | function PRWMLoader( manager ) {
function isBinary (line 94329) | function isBinary( data ) {
function matchDataViewAt (line 94369) | function matchDataViewAt( query, reader, offset ) {
function parseBinary (line 94383) | function parseBinary( data ) {
function parseASCII (line 94489) | function parseASCII( data ) {
function ensureString (line 94577) | function ensureString( buffer ) {
function ensureBinary (line 94589) | function ensureBinary( buffer ) {
function EllipseCurve (line 94621) | function EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle,...
function ArcCurve (line 94772) | function ArcCurve( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
function CubicPoly (line 94806) | function CubicPoly() {
function CatmullRomCurve3 (line 94866) | function CatmullRomCurve3( points, closed, curveType, tension ) {
function CatmullRom (line 95044) | function CatmullRom( t, p0, p1, p2, p3 ) {
function QuadraticBezierP0 (line 95056) | function QuadraticBezierP0( t, p ) {
function QuadraticBezierP1 (line 95063) | function QuadraticBezierP1( t, p ) {
function QuadraticBezierP2 (line 95069) | function QuadraticBezierP2( t, p ) {
function QuadraticBezier (line 95075) | function QuadraticBezier( t, p0, p1, p2 ) {
function CubicBezierP0 (line 95084) | function CubicBezierP0( t, p ) {
function CubicBezierP1 (line 95091) | function CubicBezierP1( t, p ) {
function CubicBezierP2 (line 95098) | function CubicBezierP2( t, p ) {
function CubicBezierP3 (line 95104) | function CubicBezierP3( t, p ) {
function CubicBezier (line 95110) | function CubicBezier( t, p0, p1, p2, p3 ) {
function CubicBezierCurve (line 95118) | function CubicBezierCurve( v0, v1, v2, v3 ) {
function CubicBezierCurve3 (line 95191) | function CubicBezierCurve3( v0, v1, v2, v3 ) {
function LineCurve (line 95265) | function LineCurve( v1, v2 ) {
function LineCurve3 (line 95350) | function LineCurve3( v1, v2 ) {
function QuadraticBezierCurve (line 95427) | function QuadraticBezierCurve( v0, v1, v2 ) {
function QuadraticBezierCurve3 (line 95496) | function QuadraticBezierCurve3( v0, v1, v2 ) {
function SplineCurve (line 95566) | function SplineCurve( points /* array of Vector2 */ ) {
function CurvePath (line 95694) | function CurvePath() {
function Path (line 95946) | function Path( points ) {
function Shape (line 96146) | function Shape( points ) {
function linkedList (line 96302) | function linkedList( data, start, end, dim, clockwise ) {
function filterPoints (line 96328) | function filterPoints( start, end ) {
function earcutLinked (line 96359) | function earcutLinked( ear, triangles, dim, minX, minY, invSize, pass ) {
function isEar (line 96426) | function isEar( ear ) {
function isEarHashed (line 96449) | function isEarHashed( ear, minX, minY, invSize ) {
function cureLocalIntersections (line 96510) | function cureLocalIntersections( start, triangles, dim ) {
function splitEarcut (line 96541) | function splitEarcut( start, triangles, dim, minX, minY, invSize ) {
function eliminateHoles (line 96577) | function eliminateHoles( data, holeIndices, outerNode, dim ) {
function compareX (line 96606) | function compareX( a, b ) {
function eliminateHole (line 96613) | function eliminateHole( hole, outerNode ) {
function findHoleBridge (line 96626) | function findHoleBridge( hole, outerNode ) {
function indexCurve (line 96702) | function indexCurve( start, minX, minY, invSize ) {
function sortLinked (line 96723) | function sortLinked( list ) {
function zOrder (line 96788) | function zOrder( x, y, minX, minY, invSize ) {
function getLeftmost (line 96809) | function getLeftmost( start ) {
function pointInTriangle (line 96825) | function pointInTriangle( ax, ay, bx, by, cx, cy, px, py ) {
function isValidDiagonal (line 96834) | function isValidDiagonal( a, b ) {
function area (line 96842) | function area( p, q, r ) {
function equals (line 96849) | function equals( p1, p2 ) {
function intersects (line 96856) | function intersects( p1, q1, p2, q2 ) {
function intersectsPolygon (line 96866) | function intersectsPolygon( a, b ) {
function locallyInside (line 96882) | function locallyInside( a, b ) {
function middleInside (line 96891) | function middleInside( a, b ) {
function splitPolygon (line 96912) | function splitPolygon( a, b ) {
function insertNode (line 96936) | function insertNode( i, x, y, last ) {
function removeNode (line 96958) | function removeNode( p ) {
function Node$1 (line 96968) | function Node$1( i, x, y ) {
function signedArea (line 96993) | function signedArea( data, start, end, dim ) {
function removeDupEndPts (line 97078) | function removeDupEndPts( points ) {
function addContour (line 97090) | function addContour( vertices, contour ) {
function ShapePath (line 97107) | function ShapePath() {
function toShapesNoHoles (line 97164) | function toShapesNoHoles( inSubpaths ) {
function isPointInsidePolygon (line 97183) | function isPointInsidePolygon( inPt, inPolygon ) {
function parseNode (line 97428) | function parseNode( node, style ) {
function parsePathNode (line 97527) | function parsePathNode( node ) {
function parseArcCommand (line 97957) | function parseArcCommand( path, rx, ry, x_axis_rotation, large_arc_flag,...
function svgAngle (line 98010) | function svgAngle( ux, uy, vx, vy ) {
function parseRectNode (line 98024) | function parseRectNode( node ) {
function parsePolygonNode (line 98059) | function parsePolygonNode( node ) {
function parsePolylineNode (line 98094) | function parsePolylineNode( node ) {
function parseCircleNode (line 98129) | function parseCircleNode( node ) {
function parseEllipseNode (line 98145) | function parseEllipseNode( node ) {
function parseLineNode (line 98162) | function parseLineNode( node ) {
function parseStyle (line 98180) | function parseStyle( node, style ) {
function getReflection (line 98224) | function getReflection( a, b ) {
function parseFloats (line 98230) | function parseFloats( string ) {
function parseFloatWithUnits (line 98313) | function parseFloatWithUnits( string ) {
function getNodeTransform (line 98364) | function getNodeTransform( node ) {
function parseNodeTransform (line 98387) | function parseNodeTransform( node ) {
function transformPath (line 98534) | function transformPath( path, m ) {
function isTransformRotated (line 98599) | function isTransformRotated( m ) {
function getTransformScaleX (line 98605) | function getTransformScaleX( m ) {
function getTransformScaleY (line 98612) | function getTransformScaleY( m ) {
function getNormal (line 99134) | function getNormal( p1, p2, result ) {
function addVertex (line 99141) | function addVertex( position, u, v ) {
function makeCircularSector (line 99174) | function makeCircularSector( center, p1, p2, u, v ) {
function makeSegmentTriangles (line 99208) | function makeSegmentTriangles() {
function makeSegmentWithBevelJoin (line 99220) | function makeSegmentWithBevelJoin( joinIsOnLeftSide, innerSideModified, ...
function createSegmentTrianglesWithMiddleSection (line 99286) | function createSegmentTrianglesWithMiddleSection( joinIsOnLeftSide, inne...
function addCapGeometry (line 99332) | function addCapGeometry( center, p1, p2, joinIsOnLeftSide, start, u ) {
function removeDuplicatedPoints (line 99411) | function removeDuplicatedPoints( points ) {
function convert (line 100513) | function convert( font, reversed ) {
function reverseCommands (line 100598) | function reverseCommands( commands ) {
function VRMLoader (line 100686) | function VRMLoader( manager ) {
function parseASCII (line 100780) | function parseASCII( data ) {
function parseBinary (line 101065) | function parseBinary( data ) {
function Float32Concat (line 101266) | function Float32Concat( first, second ) {
function Int32Concat (line 101277) | function Int32Concat( first, second ) {
function parseXML (line 101288) | function parseXML( stringFile ) {
function getStringFile (line 101871) | function getStringFile( data ) {
function defineProperties (line 101928) | function defineProperties( target, props ) {
function XAnimationObj (line 101981) | function XAnimationObj( _flags ) {
function XLoader (line 102111) | function XLoader( manager ) {
function fade (line 103669) | function fade( t ) {
function lerp (line 103675) | function lerp( t, a, b ) {
function grad (line 103681) | function grad( hash, x, y, z ) {
function MeshSurfaceSampler (line 103927) | function MeshSurfaceSampler( mesh ) {
function subdivideRadial (line 104198) | function subdivideRadial( subObject, startAngle, endAngle, numIterations...
function getVertexIndex (line 104287) | function getVertexIndex( faceIdx, vert ) {
function addResolutionDefine (line 104878) | function addResolutionDefine( materialShader ) {
function createShaderMaterial (line 104886) | function createShaderMaterial( computeFragmentShader, uniforms ) {
function getPassThroughVertexShader (line 104966) | function getPassThroughVertexShader() {
function getPassThroughFragmentShader (line 104976) | function getPassThroughFragmentShader() {
function loadTextures (line 105269) | function loadTextures( baseUrl, textureUrls ) {
function createPart (line 105287) | function createPart( geometry, skinMap ) {
function checkLoadingComplete (line 105309) | function checkLoadingComplete() {
function loadTextures (line 106143) | function loadTextures( baseUrl, textureUrls ) {
function createPart (line 106161) | function createPart( geometry, skinMap ) {
function checkLoadingComplete (line 106184) | function checkLoadingComplete() {
function exponentialEaseOut (line 106191) | function exponentialEaseOut( k ) {
function optionalParameter (line 106666) | function optionalParameter( value, defaultValue ) {
function drawShape (line 107100) | function drawShape( shape, color ) {
function extrudeShape (line 107142) | function extrudeShape( shape, offset, color ) {
function extrudeShape (line 107296) | function extrudeShape( shape, fromPoint, toPoint ) {
function TubePainter (line 107584) | function TubePainter() {
function pushIfUnique (line 107839) | function pushIfUnique( array, object ) {
function removeFromArray (line 107845) | function removeFromArray( array, object ) {
function computeEdgeCollapseCost (line 107852) | function computeEdgeCollapseCost( u, v ) {
function computeEdgeCostAtVertex (line 107913) | function computeEdgeCostAtVertex( v ) {
function removeVertex (line 107968) | function removeVertex( v, vertices ) {
function removeFace (line 107983) | function removeFace( f, faces ) {
function collapse (line 108009) | function collapse( vertices, faces, u, v ) { // u and v are pointers to ...
function minimumCostEdge (line 108056) | function minimumCostEdge( vertices ) {
function Triangle (line 108078) | function Triangle( v1, v2, v3, a, b, c ) {
function Vertex (line 108155) | function Vertex( v, id ) {
function getEdge (line 108364) | function getEdge( a, b, map ) {
function processEdge (line 108374) | function processEdge( a, b, vertices, map, face, metaVertices ) {
function generateLookups (line 108413) | function generateLookups( vertices, faces, metaVertices, edges ) {
function newFace (line 108435) | function newFace( newFaces, a, b, c, materialIndex ) {
function midpoint (line 108441) | function midpoint( a, b ) {
function newUv (line 108447) | function newUv( newUvs, a, b, c ) {
function Pass (line 108938) | function Pass() {
function NodePass (line 109088) | function NodePass() {
function Clock (line 109180) | function Clock( autoStart ) {
function Box2 (line 110277) | function Box2( min, max ) {
function ImmediateRenderObject (line 111125) | function ImmediateRenderObject( material ) {
function lerp (line 111222) | function lerp( a, b, t ) {
function VIntX (line 111228) | function VIntX( q, offset, isol, x, y, z, valp1, valp2, c_offset1, c_off...
function VIntY (line 111247) | function VIntY( q, offset, isol, x, y, z, valp1, valp2, c_offset1, c_off...
function VIntZ (line 111268) | function VIntZ( q, offset, isol, x, y, z, valp1, valp2, c_offset1, c_off...
function compNorm (line 111289) | function compNorm( q ) {
function polygonize (line 111308) | function polygonize( fx, fy, fz, q, isol, renderCallback ) {
function posnormtriv (line 111521) | function posnormtriv( pos, norm, colors, o1, o2, o3, renderCallback ) {
function concatenate (line 112048) | function concatenate( a, b, length ) {
function updateTextureMatrix (line 112847) | function updateTextureMatrix( camera ) {
function render (line 112870) | function render( renderer, scene, camera ) {
function Water2 (line 113625) | function Water2( geometry, options ) {
function gauss (line 114720) | function gauss( x, sigma ) {
function replaceDepthToViewZ (line 116443) | function replaceDepthToViewZ( string, camera ) {
function gatherSelectedMeshesCallBack (line 116492) | function gatherSelectedMeshesCallBack( object ) {
function gatherSelectedMeshesCallBack (line 116525) | function gatherSelectedMeshesCallBack( object ) {
function VisibilityChangeCallBack (line 116538) | function VisibilityChangeCallBack( object ) {
function DepthTexture (line 117001) | function DepthTexture( width, height, type, mapping, wrapS, wrapT, magFi...
function epsilon (line 120371) | function epsilon( value ) {
function getCameraCSSMatrix (line 120377) | function getCameraCSSMatrix( matrix ) {
function getObjectCSSMatrix (line 120402) | function getObjectCSSMatrix( matrix, cameraCSSMatrix ) {
function renderObject (line 120437) | function renderObject( object, scene, camera, cameraCSSMatrix ) {
function filterAndFlatten (line 120521) | function filterAndFlatten( scene ) {
function zOrder (line 120535) | function zOrder( scene ) {
function Sprite (line 120644) | function Sprite( material ) {
function transformVertex (line 120773) | function transformVertex( vertexPosition, mvPosition, center, scale, sin...
function setObject (line 120961) | function setObject( value ) {
function projectVertex (line 120973) | function projectVertex( vertex ) {
function pushVertex (line 120994) | function pushVertex( x, y, z ) {
function pushNormal (line 121003) | function pushNormal( x, y, z ) {
function pushColor (line 121009) | function pushColor( r, g, b ) {
function pushUv (line 121015) | function pushUv( x, y ) {
function checkTriangleVisibility (line 121021) | function checkTriangleVisibility( v1, v2, v3 ) {
function checkBackfaceCulling (line 121033) | function checkBackfaceCulling( v1, v2, v3 ) {
function pushLine (line 121042) | function pushLine( a, b ) {
function pushTriangle (line 121080) | function pushTriangle( a, b, c, material ) {
function projectObject (line 121152) | function projectObject( object ) {
function addObject (line 121186) | function addObject( object ) {
function pushPoint (line 121710) | function pushPoint( _vector4, object, camera ) {
function getNextObjectInPool (line 121741) | function getNextObjectInPool() {
function getNextVertexInPool (line 121757) | function getNextVertexInPool() {
function getNextFaceInPool (line 121773) | function getNextFaceInPool() {
function getNextLineInPool (line 121788) | function getNextLineInPool() {
function getNextSpriteInPool (line 121804) | function getNextSpriteInPool() {
function painterSort (line 121822) | function painterSort( a, b ) {
function clipLine (line 121844) | function clipLine( s1, s2 ) {
function removeChildNodes (line 122026) | function removeChildNodes() {
function convert (line 122038) | function convert( c ) {
function calculateLights (line 122184) | function calculateLights( lights ) {
function calculateLight (line 122219) | function calculateLight( lights, position, normal, color ) {
function renderSprite (line 122264) | function renderSprite( v1, element, material ) {
function renderLine (line 122289) | function renderLine( v1, v2, element, material ) {
function renderFace3 (line 122309) | function renderFace3( v1, v2, v3, element, material ) {
function expand (line 122369) | function expand( v1, v2, pixels ) {
function addPath (line 122385) | function addPath( style, path ) {
function flushPath (line 122402) | function flushPath() {
function getPathNode (line 122418) | function getPathNode( id ) {
function handleTriangle (line 126729) | function handleTriangle( a, b, c ) {
function handleVertex (line 126798) | function handleVertex( v ) {
function octEncodeVec3 (line 127753) | function octEncodeVec3(x0, y0, z0, xfunc, yfunc) {
function octDecodeVec2 (line 127788) | function octDecodeVec2(oct) {
function dot (line 127816) | function dot(x, y, z, vec3) {
function PackedPhongMaterial (line 127943) | function PackedPhongMaterial(parameters) {
function _getMipmapMaterial (line 128381) | function _getMipmapMaterial() {
function resetPosition (line 128544) | function resetPosition() {
function getBoneList (line 128654) | function getBoneList( object ) {
function SkeletonHelper (line 128674) | function SkeletonHelper( object ) {
function parallelTraverse (line 129325) | function parallelTraverse( a, b, callback ) {
function buildTree (line 129532) | function buildTree( points, depth, parent, pos ) {
function nearestSearch (line 129590) | function nearestSearch( node ) {
function processFace (line 130053) | function processFace( face, uvs, index ) {
function showStartAR (line 130239) | function showStartAR( /*device*/ ) {
function disableButton (line 130309) | function disableButton() {
function showARNotSupported (line 130324) | function showARNotSupported() {
function stylizeElement (line 130332) | function stylizeElement( element ) {
function showEnterVR (line 130411) | function showEnterVR( /*device*/ ) {
function disableButton (line 130482) | function disableButton() {
function showWebXRNotFound (line 130497) | function showWebXRNotFound() {
function stylizeElement (line 130505) | function stylizeElement( element ) {
function AnimationObjectGroup (line 130598) | function AnimationObjectGroup() {
function Audio (line 130957) | function Audio( listener ) {
function AudioAnalyser (line 131340) | function AudioAnalyser( audio, fftSize ) {
function AudioListener (line 131418) | function AudioListener() {
function PositionalAudio (line 131555) | function PositionalAudio( listener ) {
function ArrayCamera (line 131682) | function ArrayCamera( array ) {
function WebGLCubeRenderTarget (line 131704) | function WebGLCubeRenderTarget( size, options, dummy ) {
function CubeCamera (line 131826) | function CubeCamera( near, far, cubeResolution, options ) {
function InstancedBufferAttribute (line 131930) | function InstancedBufferAttribute( array, itemSize, normalized, meshPerA...
function Uniform (line 131985) | function Uniform( value ) {
function Font (line 132010) | function Font( data ) {
function createPaths (line 132041) | function createPaths( text, size, data ) {
function createPath (line 132074) | function createPath( char, scale, offsetX, offsetY, data ) {
function PMREMGenerator (line 132219) | function PMREMGenerator( renderer ) {
function _createPlanes (line 132342) | function _createPlanes() {
function _allocateTargets (line 132415) | function _allocateTargets( equirectangular ) {
function _cleanup (line 132434) | function _cleanup( outputTarget ) {
function _sceneToCubeUV (line 132444) | function _sceneToCubeUV( scene, near, far, cubeUVRenderTarget ) {
function _textureToCubeUV (line 132511) | function _textureToCubeUV( texture, cubeUVRenderTarget ) {
function _compileMaterial (line 132550) | function _compileMaterial( material ) {
function _createRenderTarget (line 132558) | function _createRenderTarget( params ) {
function _setViewport (line 132568) | function _setViewport( target, x, y, width, height ) {
function _applyPMREM (line 132575) | function _applyPMREM( cubeUVRenderTarget ) {
function _blur (line 132602) | function _blur( cubeUVRenderTarget, lodIn, lodOut, sigma, poleAxis ) {
function _halfBlur (line 132624) | function _halfBlur( targetIn, targetOut, lodIn, lodOut, sigmaRadians, di...
function _getBlurShader (line 132704) | function _getBlurShader( maxSamples ) {
function _getEquirectShader (line 132740) | function _getEquirectShader() {
function _getCubemapShader (line 132768) | function _getCubemapShader() {
function _getCommonVertexShader (line 132794) | function _getCommonVertexShader() {
function _getEncodings (line 132800) | function _getEncodings() {
function CircleGeometry (line 132815) | function CircleGeometry( radius, segments, thetaStart, thetaLength ) {
function CircleBufferGeometry (line 132838) | function CircleBufferGeometry( radius, segments, thetaStart, thetaLength...
function ConeGeometry (line 132927) | function ConeGeometry( radius, height, radialSegments, heightSegments, o...
function ConeBufferGeometry (line 132950) | function ConeBufferGeometry( radius, height, radialSegments, heightSegme...
function DodecahedronGeometry (line 132979) | function DodecahedronGeometry( radius, detail ) {
function DodecahedronBufferGeometry (line 133000) | function DodecahedronBufferGeometry( radius, detail ) {
function EdgesGeometry (line 133061) | function EdgesGeometry( geometry, thresholdAngle ) {
function ExtrudeGeometry (line 133189) | function ExtrudeGeometry( shapes, options ) {
function ExtrudeBufferGeometry (line 133221) | function ExtrudeBufferGeometry( shapes, options ) {
function toJSON (line 133933) | function toJSON( shapes, options, data ) {
function IcosahedronGeometry (line 133971) | function IcosahedronGeometry( radius, detail ) {
function IcosahedronBufferGeometry (line 133992) | function IcosahedronBufferGeometry( radius, detail ) {
function LatheGeometry (line 134032) | function LatheGeometry( points, segments, phiStart, phiLength ) {
function LatheBufferGeometry (line 134055) | function LatheBufferGeometry( points, segments, phiStart, phiLength ) {
function RingGeometry (line 134205) | function RingGeometry( innerRadius, outerRadius, thetaSegments, phiSegme...
function RingBufferGeometry (line 134230) | function RingBufferGeometry( innerRadius, outerRadius, thetaSegments, ph...
function ShapeGeometry (line 134350) | function ShapeGeometry( shapes, curveSegments ) {
function ShapeBufferGeometry (line 134389) | function ShapeBufferGeometry( shapes, curveSegments ) {
function toJSON$1 (line 134530) | function toJSON$1( shapes, data ) {
function TetrahedronGeometry (line 134562) | function TetrahedronGeometry( radius, detail ) {
function TetrahedronBufferGeometry (line 134583) | function TetrahedronBufferGeometry( radius, detail ) {
function TextGeometry (line 134630) | function TextGeometry( text, parameters ) {
function TextBufferGeometry (line 134651) | function TextBufferGeometry( text, parameters ) {
function TorusKnotGeometry (line 134695) | function TorusKnotGeometry( radius, tube, tubularSegments, radialSegment...
function TorusKnotBufferGeometry (line 134722) | function TorusKnotBufferGeometry( radius, tube, tubularSegments, radialS...
function TubeGeometry (line 134886) | function TubeGeometry( path, tubularSegments, radius, radialSegments, cl...
function TubeBufferGeometry (line 134922) | function TubeBufferGeometry( path, tubularSegments, radius, radialSegmen...
function AxesHelper (line 135105) | function AxesHelper( size ) {
function Box3Helper (line 135139) | function Box3Helper( box, color ) {
function BoxHelper (line 135190) | function BoxHelper( object, color ) {
function CameraHelper (line 135305) | function CameraHelper( camera ) {
function setPoint (line 135465) | function setPoint( point, pointMap, geometry, camera, x, y, z ) {
function DirectionalLightHelper (line 135496) | function DirectionalLightHelper( light, size, color ) {
function GridHelper (line 135576) | function GridHelper( size, divisions, color1, color2 ) {
function HemisphereLightHelper (line 135647) | function HemisphereLightHelper( light, size, color ) {
function PlaneHelper (line 135722) | function PlaneHelper( plane, size, hex ) {
function PointLightHelper (line 135777) | function PointLightHelper( light, sphereSize, color ) {
function PolarGridHelper (line 135863) | function PolarGridHelper( radius, radials, circles, divisions, color1, c...
function SpotLightHelper (line 135953) | function SpotLightHelper( light, color ) {
function AmbientLightProbe (line 136038) | function AmbientLightProbe( color, intensity ) {
function HemisphereLight (line 136080) | function HemisphereLight( skyColor, groundColor, intensity ) {
function HemisphereLightProbe (line 136118) | function HemisphereLightProbe( skyColor, groundColor, intensity ) {
function RectAreaLight (line 136168) | function RectAreaLight( color, intensity, width, height ) {
function AnimationLoader (line 136214) | function AnimationLoader( manager ) {
function AudioLoader (line 136261) | function AudioLoader( manager ) {
function BufferGeometryLoader (line 136300) | function BufferGeometryLoader( manager ) {
function CubeTextureLoader (line 136442) | function CubeTextureLoader( manager ) {
function loadTexture (line 136462) | function loadTexture( i ) {
function FontLoader (line 136499) | function FontLoader( manager ) {
function ImageBitmapLoader (line 136551) | function ImageBitmapLoader( manager ) {
function InstancedMesh (line 136663) | function InstancedMesh( geometry, material, count ) {
function LOD (line 136750) | function LOD() {
function Fog (line 136930) | function Fog( color, near, far ) {
function FogExp2 (line 136970) | function FogExp2( color, density ) {
function ObjectLoader (line 137073) | function ObjectLoader( manager ) {
function loadImage (line 137545) | function loadImage( url ) {
function parseConstant (line 137610) | function parseConstant( value, type ) {
function getGeometry (line 137699) | function getGeometry( name ) {
function getMaterial (line 137711) | function getMaterial( name ) {
function MeshMatcapMaterial (line 138052) | function MeshMatcapMaterial( parameters ) {
function Cylindrical (line 138135) | function Cylindrical( radius, theta, y ) {
function WebGLAnimation (line 138198) | function WebGLAnimation() {
function WebGLAttributes (line 138256) | function WebGLAttributes( gl, capabilities ) {
function WebGLBackground (line 138413) | function WebGLBackground( renderer, state, objects, premultipliedAlpha ) {
function WebGLBufferRenderer (line 138627) | function WebGLBufferRenderer( gl, extensions, info, capabilities ) {
function WebGLCapabilities (line 138693) | function WebGLCapabilities( gl, extensions, parameters ) {
function WebGLClipping (line 138815) | function WebGLClipping() {
function WebGLExtensions (line 138975) | function WebGLExtensions( gl ) {
function WebGLGeometries (line 139035) | function WebGLGeometries( gl, attributes, info ) {
function WebGLIndexedBufferRenderer (line 139248) | function WebGLIndexedBufferRenderer( gl, extensions, info, capabilities ) {
function WebGLInfo (line 139324) | function WebGLInfo( gl ) {
function UniformsCache (line 139401) | function UniformsCache() {
function shadowCastingLightsFirst (line 139496) | function shadowCastingLightsFirst( lightA, lightB ) {
function WebGLLights (line 139502) | function WebGLLights() {
function absNumericalSort (line 139806) | function absNumericalSort( a, b ) {
function WebGLMorphtargets (line 139812) | function WebGLMorphtargets( gl ) {
function WebGLMultiviewRenderTarget (line 139929) | function WebGLMultiviewRenderTarget( width, height, numViews, options ) {
function WebGLMultiview (line 139977) | function WebGLMultiview( renderer, gl ) {
function WebGLObjects (line 140197) | function WebGLObjects( gl, geometries, attributes, info ) {
function DataTexture2DArray (line 140254) | function DataTexture2DArray( data, width, height, depth ) {
function DataTexture3D (line 140281) | function DataTexture3D( data, width, height, depth ) {
function flatten (line 140378) | function flatten( array, nBlocks, blockSize ) {
function arraysEqual (line 140413) | function arraysEqual( a, b ) {
function copyArray (line 140427) | function copyArray( a, b ) {
function allocTexUnits (line 140439) | function allocTexUnits( textures, n ) {
function setValueV1f (line 140464) | function setValueV1f( gl, v ) {
function setValueV2f (line 140478) | function setValueV2f( gl, v ) {
function setValueV3f (line 140505) | function setValueV3f( gl, v ) {
function setValueV4f (line 140545) | function setValueV4f( gl, v ) {
function setValueM2 (line 140576) | function setValueM2( gl, v ) {
function setValueM3 (line 140603) | function setValueM3( gl, v ) {
function setValueM4 (line 140630) | function setValueM4( gl, v ) {
function setValueT1 (line 140659) | function setValueT1( gl, v, textures ) {
function setValueT2DArray1 (line 140675) | function setValueT2DArray1( gl, v, textures ) {
function setValueT3D1 (line 140691) | function setValueT3D1( gl, v, textures ) {
function setValueT6 (line 140707) | function setValueT6( gl, v, textures ) {
function setValueV1i (line 140725) | function setValueV1i( gl, v ) {
function setValueV2i (line 140737) | function setValueV2i( gl, v ) {
function setValueV3i (line 140749) | function setValueV3i( gl, v ) {
function setValueV4i (line 140761) | function setValueV4i( gl, v ) {
function setValueV1ui (line 140775) | function setValueV1ui( gl, v ) {
function getSingularSetter (line 140789) | function getSingularSetter( type ) {
function setValueV1fArray (line 140838) | function setValueV1fArray( gl, v ) {
function setValueV1iArray (line 140845) | function setValueV1iArray( gl, v ) {
function setValueV2iArray (line 140851) | function setValueV2iArray( gl, v ) {
function setValueV3iArray (line 140857) | function setValueV3iArray( gl, v ) {
function setValueV4iArray (line 140863) | function setValueV4iArray( gl, v ) {
function setValueV2fArray (line 140870) | function setValueV2fArray( gl, v ) {
function setValueV3fArray (line 140878) | function setValueV3fArray( gl, v ) {
function setValueV4fArray (line 140886) | function setValueV4fArray( gl, v ) {
function setValueM2Array (line 140896) | function setValueM2Array( gl, v ) {
function setValueM3Array (line 140904) | function setValueM3Array( gl, v ) {
function setValueM4Array (line 140912) | function setValueM4Array( gl, v ) {
function setValueT1Array (line 140922) | function setValueT1Array( gl, v, textures ) {
function setValueT6Array (line 140938) | function setValueT6Array( gl, v, textures ) {
function getPureArraySetter (line 140956) | function getPureArraySetter( type ) {
function SingleUniform (line 140993) | function SingleUniform( id, activeInfo, addr ) {
function PureArrayUniform (line 141004) | function PureArrayUniform( id, activeInfo, addr ) {
function StructuredUniform (line 141030) | function StructuredUniform( id ) {
function addUniform (line 141067) | function addUniform( container, uniformObject ) {
function parseUniform (line 141074) | function parseUniform( activeInfo, addr, container ) {
function WebGLUniforms (line 141126) | function WebGLUniforms( gl, program ) {
function WebGLShader (line 141201) | function WebGLShader( gl, type, string ) {
function addLineNumbers (line 141219) | function addLineNumbers( string ) {
function getEncodingComponents (line 141233) | function getEncodingComponents( encoding ) {
function getShaderErrors (line 141260) | function getShaderErrors( gl, shader, type ) {
function getTexelDecodingFunction (line 141276) | function getTexelDecodingFunction( functionName, encoding ) {
function getTexelEncodingFunction (line 141283) | function getTexelEncodingFunction( functionName, encoding ) {
function getToneMappingFunction (line 141290) | function getToneMappingFunction( functionName, toneMapping ) {
function generateExtensions (line 141325) | function generateExtensions( parameters ) {
function generateDefines (line 141338) | function generateDefines( defines ) {
function fetchAttributeLocations (line 141356) | function fetchAttributeLocations( gl, program ) {
function filterEmptyLine (line 141377) | function filterEmptyLine( string ) {
function replaceLightNums (line 141383) | function replaceLightNums( string, parameters ) {
function replaceClippingPlaneNums (line 141397) | function replaceClippingPlaneNums( string, parameters ) {
function resolveIncludes (line 141409) | function resolveIncludes( string ) {
function includeReplacer (line 141415) | function includeReplacer( match, include ) {
function unrollLoops (line 141433) | function unrollLoops( string ) {
function loopReplacer (line 141439) | function loopReplacer( match, start, end, snippet ) {
function generatePrecision (line 141457) | function generatePrecision( parameters ) {
function generateShadowMapTypeDefine (line 141479) | function generateShadowMapTypeDefine( parameters ) {
function generateEnvMapTypeDefine (line 141501) | function generateEnvMapTypeDefine( parameters ) {
function generateEnvMapModeDefine (line 141536) | function generateEnvMapModeDefine( parameters ) {
function generateEnvMapBlendingDefine (line 141557) | function generateEnvMapBlendingDefine( parameters ) {
function WebGLProgram (line 141585) | function WebGLProgram( renderer, cacheKey, parameters ) {
function WebGLPrograms (line 142110) | function WebGLPrograms( renderer, extensions, capabilities ) {
function WebGLProperties (line 142503) | function WebGLProperties() {
function painterSortStable (line 142556) | function painterSortStable( a, b ) {
function reversePainterSortStable (line 142586) | function reversePainterSortStable( a, b ) {
function WebGLRenderList (line 142607) | function WebGLRenderList() {
function WebGLRenderLists (line 142702) | function WebGLRenderLists() {
function WebGLRenderState (line 142762) | function WebGLRenderState() {
function WebGLRenderStates (line 142812) | function WebGLRenderStates() {
function WebGLShadowMap (line 142886) | function WebGLShadowMap( _renderer, _objects, maxTextureSize ) {
function WebGLState (line 143331) | function WebGLState( gl, extensions, capabilities ) {
function WebGLTextures (line 144341) | function WebGLTextures( _gl, extensions, state, properties, capabilities...
function WebGLUtils (line 145628) | function WebGLUtils( gl, extensions, capabilities ) {
function WebGLMultisampleRenderTarget (line 145791) | function WebGLMultisampleRenderTarget( width, height, options ) {
function WebXRManager (line 145822) | function WebXRManager( renderer, gl ) {
function WebGLRenderer (line 146352) | function WebGLRenderer( parameters ) {
function CanvasTexture (line 149143) | function CanvasTexture( canvas, mapping, wrapS, wrapT, magFilter, minFil...
function VideoTexture (line 149160) | function VideoTexture( video, mapping, wrapS, wrapT, magFilter, minFilte...
FILE: builds/Three.cjs.js
function getGlobalWindowObject (line 7) | function getGlobalWindowObject() {
function compareTime (line 209) | function compareTime( i, j ) {
function Interpolant (line 610) | function Interpolant( parameterPositions, sampleValues, sampleSize, resu...
function CubicInterpolant (line 856) | function CubicInterpolant( parameterPositions, sampleValues, sampleSize,...
function LinearInterpolant (line 1001) | function LinearInterpolant( parameterPositions, sampleValues, sampleSize...
function DiscreteInterpolant (line 1046) | function DiscreteInterpolant( parameterPositions, sampleValues, sampleSi...
function KeyframeTrack (line 1075) | function KeyframeTrack( name, times, values, interpolation ) {
function BooleanKeyframeTrack (line 1540) | function BooleanKeyframeTrack( name, times, values ) {
function ColorKeyframeTrack (line 1575) | function ColorKeyframeTrack( name, times, values, interpolation ) {
function NumberKeyframeTrack (line 1606) | function NumberKeyframeTrack( name, times, values, interpolation ) {
function Quaternion (line 1839) | function Quaternion( x, y, z, w ) {
function QuaternionLinearInterpolant (line 2471) | function QuaternionLinearInterpolant( parameterPositions, sampleValues, ...
function QuaternionKeyframeTrack (line 2513) | function QuaternionKeyframeTrack( name, times, values, interpolation ) {
function StringKeyframeTrack (line 2550) | function StringKeyframeTrack( name, times, values, interpolation ) {
function VectorKeyframeTrack (line 2582) | function VectorKeyframeTrack( name, times, values, interpolation ) {
function AnimationClip (line 2609) | function AnimationClip( name, duration, tracks ) {
function getTrackTypeForValueTypeName (line 2626) | function getTrackTypeForValueTypeName( typeName ) {
function parseKeyframeTrack (line 2668) | function parseKeyframeTrack( json ) {
function Vector3 (line 3069) | function Vector3( x, y, z ) {
function Vector4 (line 3893) | function Vector4( x, y, z, w ) {
function Vector2 (line 4547) | function Vector2( x, y ) {
function Color (line 5063) | function Color( r, g, b ) {
function hue2rgb (line 5076) | function hue2rgb( p, q, t ) {
function SRGBToLinear (line 5087) | function SRGBToLinear( c ) {
function LinearToSRGB (line 5093) | function LinearToSRGB( c ) {
function handleAlpha (line 5185) | function handleAlpha( string ) {
function BufferAttribute (line 5626) | function BufferAttribute( array, itemSize, normalized ) {
function Int8BufferAttribute (line 6012) | function Int8BufferAttribute( array, itemSize, normalized ) {
function Uint8BufferAttribute (line 6020) | function Uint8BufferAttribute( array, itemSize, normalized ) {
function Uint8ClampedBufferAttribute (line 6028) | function Uint8ClampedBufferAttribute( array, itemSize, normalized ) {
function Int16BufferAttribute (line 6036) | function Int16BufferAttribute( array, itemSize, normalized ) {
function Uint16BufferAttribute (line 6044) | function Uint16BufferAttribute( array, itemSize, normalized ) {
function Int32BufferAttribute (line 6052) | function Int32BufferAttribute( array, itemSize, normalized ) {
function Uint32BufferAttribute (line 6060) | function Uint32BufferAttribute( array, itemSize, normalized ) {
function Float32BufferAttribute (line 6068) | function Float32BufferAttribute( array, itemSize, normalized ) {
function Float64BufferAttribute (line 6076) | function Float64BufferAttribute( array, itemSize, normalized ) {
function Box3 (line 6123) | function Box3( min, max ) {
function satForAxes (line 6615) | function satForAxes( axes, v0, v1, v2, extents ) {
function EventDispatcher (line 6650) | function EventDispatcher() {}
function Sphere (line 6738) | function Sphere( center, radius ) {
function DirectGeometry (line 6907) | function DirectGeometry() {
function Matrix4 (line 7207) | function Matrix4() {
function Euler (line 8096) | function Euler( x, y, z, order ) {
function Layers (line 8430) | function Layers() {
function Matrix3 (line 8492) | function Matrix3() {
function Object3D (line 8872) | function Object3D() {
function serialize (line 9533) | function serialize( library, element ) {
function extractFromCache (line 9634) | function extractFromCache( cache ) {
function arrayMin (line 9709) | function arrayMin( array ) {
function arrayMax (line 9725) | function arrayMax( array ) {
function BufferGeometry (line 9756) | function BufferGeometry() {
function convertBufferAttribute (line 10619) | function convertBufferAttribute( attribute, indices ) {
function Ray (line 10984) | function Ray( origin, direction ) {
function Material (line 11490) | function Material() {
function extractFromCache (line 11782) | function extractFromCache( cache ) {
function LineBasicMaterial (line 11928) | function LineBasicMaterial( parameters ) {
function Line (line 11974) | function Line( geometry, material, mode ) {
function Plane (line 12209) | function Plane( normal, constant ) {
function Triangle (line 12445) | function Triangle( a, b, c ) {
function Face3 (line 12764) | function Face3( a, b, c, normal, color, materialIndex ) {
function MeshBasicMaterial (line 12853) | function MeshBasicMaterial( parameters ) {
function Mesh (line 12961) | function Mesh( geometry, material ) {
function checkIntersection (line 13269) | function checkIntersection( object, material, raycaster, ray, pA, pB, pC...
function checkBufferGeometryIntersection (line 13300) | function checkBufferGeometryIntersection( object, material, raycaster, r...
function Geometry (line 13397) | function Geometry() {
function addFace (line 13589) | function addFace( a, b, c, materialIndex ) {
function materialIndexSort (line 14275) | function materialIndexSort( a, b ) {
function setBit (line 14431) | function setBit( value, position, enabled ) {
function getNormalIndex (line 14437) | function getNormalIndex( normal ) {
function getColorIndex (line 14454) | function getColorIndex( color ) {
function getUvIndex (line 14471) | function getUvIndex( uv ) {
function SphereGeometry (line 14781) | function SphereGeometry( radius, widthSegments, heightSegments, phiStart...
function SphereBufferGeometry (line 14807) | function SphereBufferGeometry( radius, widthSegments, heightSegments, ph...
function CCDIKSolver (line 14961) | function CCDIKSolver( mesh, iks ) {
function CCDIKHelper (line 15184) | function CCDIKHelper( mesh, iks ) {
function getPosition (line 15240) | function getPosition( bone, matrixWorldInv ) {
function setPositionOfBoneToAttributeArray (line 15248) | function setPositionOfBoneToAttributeArray( array, index, bone, matrixWo...
function createLineGeometry (line 15330) | function createLineGeometry( ik ) {
function createTargetMesh (line 15340) | function createTargetMesh() {
function createEffectorMesh (line 15346) | function createEffectorMesh() {
function createLinkMesh (line 15352) | function createLinkMesh() {
function createLine (line 15358) | function createLine( ik ) {
function AnimationAction (line 15401) | function AnimationAction( mixer, clip, localRoot ) {
function Composite (line 16123) | function Composite( targetGroup, path, optionalParsedPath ) {
function PropertyBinding (line 16183) | function PropertyBinding( rootNode, path, parsedPath ) {
function PropertyMixer (line 16795) | function PropertyMixer( binding, typeName, valueSize ) {
function AnimationMixer (line 16999) | function AnimationMixer( root ) {
method total (line 17175) | get total() {
method inUse (line 17180) | get inUse() {
method total (line 17187) | get total() {
method inUse (line 17192) | get inUse() {
method total (line 17199) | get total() {
method inUse (line 17204) | get inUse() {
function Bone (line 17750) | function Bone() {
function BoxGeometry (line 17775) | function BoxGeometry( width, height, depth, widthSegments, heightSegment...
function BoxBufferGeometry (line 17805) | function BoxBufferGeometry( width, height, depth, widthSegments, heightS...
function CylinderGeometry (line 17981) | function CylinderGeometry( radiusTop, radiusBottom, height, radialSegmen...
function CylinderBufferGeometry (line 18008) | function CylinderBufferGeometry( radiusTop, radiusBottom, height, radial...
function MMDPhysics (line 18309) | function MMDPhysics( mesh, rigidBodyParams, constraintParams, params ) {
function ResourceManager (line 18621) | function ResourceManager() {
function RigidBody (line 19077) | function RigidBody( mesh, world, params, manager ) {
function generateShape (line 19165) | function generateShape( p ) {
function Constraint (line 19386) | function Constraint( mesh, world, bodyA, bodyB, params, manager ) {
function MMDPhysicsHelper (line 19520) | function MMDPhysicsHelper( mesh, physics ) {
function createGeometry (line 19638) | function createGeometry( param ) {
function createCapsuleGeometry (line 19659) | function createCapsuleGeometry( radius, cylinderHeight, segmentsRadius, ...
function MMDAnimationHelper (line 19717) | function MMDAnimationHelper( params ) {
function AudioManager (line 20592) | function AudioManager( audio, params ) {
function GrantSolver (line 20664) | function GrantSolver( mesh, grants ) {
function Camera (line 21013) | function Camera() {
function OrthographicCamera (line 21092) | function OrthographicCamera( left, right, top, bottom, near, far ) {
function PerspectiveCamera (line 21235) | function PerspectiveCamera( fov, aspect, near, far ) {
function PlaneGeometry (line 21474) | function PlaneGeometry( width, height, widthSegments, heightSegments ) {
function PlaneBufferGeometry (line 21497) | function PlaneBufferGeometry( width, height, widthSegments, heightSegmen...
function Scene (line 21592) | function Scene() {
function cloneUniforms (line 21664) | function cloneUniforms( src ) {
function mergeUniforms (line 21701) | function mergeUniforms( uniforms ) {
function ShaderMaterial (line 21757) | function ShaderMaterial( parameters ) {
function Texture (line 22009) | function Texture( image, mapping, wrapS, wrapT, magFilter, minFilter, fo...
function WebGLRenderTarget (line 22328) | function WebGLRenderTarget( width, height, options ) {
function Raycaster (line 23294) | function Raycaster( origin, direction, near, far ) {
function ascSort (line 23324) | function ascSort( a, b ) {
function intersectObject (line 23330) | function intersectObject( object, raycaster, intersects, recursive ) {
function activate (line 23445) | function activate() {
function deactivate (line 23457) | function deactivate() {
function dispose (line 23469) | function dispose() {
function onDocumentMouseMove (line 23475) | function onDocumentMouseMove( event ) {
function onDocumentMouseDown (line 23534) | function onDocumentMouseDown( event ) {
function onDocumentMouseCancel (line 23560) | function onDocumentMouseCancel( event ) {
function onDocumentTouchMove (line 23576) | function onDocumentTouchMove( event ) {
function onDocumentTouchStart (line 23604) | function onDocumentTouchStart( event ) {
function onDocumentTouchEnd (line 23638) | function onDocumentTouchEnd( event ) {
function Spherical (line 23680) | function Spherical( radius, phi, theta ) {
function contextmenu (line 24050) | function contextmenu( event ) {
function bind (line 24082) | function bind( scope, fn ) {
function setOrientation (line 24092) | function setOrientation( controls ) {
function bind (line 24352) | function bind( scope, fn ) {
function contextmenu (line 24362) | function contextmenu( event ) {
function getAutoRotationAngle (line 24710) | function getAutoRotationAngle() {
function getZoomScale (line 24716) | function getZoomScale() {
function rotateLeft (line 24722) | function rotateLeft( angle ) {
function rotateUp (line 24728) | function rotateUp( angle ) {
function dollyIn (line 24815) | function dollyIn( dollyScale ) {
function dollyOut (line 24836) | function dollyOut( dollyScale ) {
function handleMouseDownRotate (line 24861) | function handleMouseDownRotate( event ) {
function handleMouseDownDolly (line 24867) | function handleMouseDownDolly( event ) {
function handleMouseDownPan (line 24873) | function handleMouseDownPan( event ) {
function handleMouseMoveRotate (line 24879) | function handleMouseMoveRotate( event ) {
function handleMouseMoveDolly (line 24897) | function handleMouseMoveDolly( event ) {
function handleMouseMovePan (line 24919) | function handleMouseMovePan( event ) {
function handleMouseWheel (line 24933) | function handleMouseWheel( event ) {
function handleKeyDown (line 24949) | function handleKeyDown( event ) {
function handleTouchStartRotate (line 24987) | function handleTouchStartRotate( event ) {
function handleTouchStartPan (line 25004) | function handleTouchStartPan( event ) {
function handleTouchStartDolly (line 25021) | function handleTouchStartDolly( event ) {
function handleTouchStartDollyPan (line 25032) | function handleTouchStartDollyPan( event ) {
function handleTouchStartDollyRotate (line 25040) | function handleTouchStartDollyRotate( event ) {
function handleTouchMoveRotate (line 25048) | function handleTouchMoveRotate( event ) {
function handleTouchMovePan (line 25075) | function handleTouchMovePan( event ) {
function handleTouchMoveDolly (line 25098) | function handleTouchMoveDolly( event ) {
function handleTouchMoveDollyPan (line 25115) | function handleTouchMoveDollyPan( event ) {
function handleTouchMoveDollyRotate (line 25123) | function handleTouchMoveDollyRotate( event ) {
function onMouseDown (line 25135) | function onMouseDown( event ) {
function onMouseMove (line 25245) | function onMouseMove( event ) {
function onMouseUp (line 25281) | function onMouseUp( event ) {
function onMouseWheel (line 25294) | function onMouseWheel( event ) {
function onKeyDown (line 25309) | function onKeyDown( event ) {
function onTouchStart (line 25317) | function onTouchStart( event ) {
function onTouchMove (line 25403) | function onTouchMove( event ) {
function onTouchEnd (line 25460) | function onTouchEnd( event ) {
function onContextMenu (line 25470) | function onContextMenu( event ) {
function onMouseMove (line 25564) | function onMouseMove( event ) {
function onPointerlockChange (line 25584) | function onPointerlockChange() {
function onPointerlockError (line 25602) | function onPointerlockError() {
function keydown (line 26087) | function keydown( event ) {
function keyup (line 26113) | function keyup() {
function mousedown (line 26123) | function mousedown( event ) {
function mousemove (line 26179) | function mousemove( event ) {
function mouseup (line 26205) | function mouseup( event ) {
function mousewheel (line 26220) | function mousewheel( event ) {
function touchstart (line 26253) | function touchstart( event ) {
function touchmove (line 26285) | function touchmove( event ) {
function touchend (line 26313) | function touchend( event ) {
function contextmenu (line 26335) | function contextmenu( event ) {
function PolyhedronGeometry (line 26392) | function PolyhedronGeometry( vertices, indices, radius, detail ) {
function PolyhedronBufferGeometry (line 26415) | function PolyhedronBufferGeometry( vertices, indices, radius, detail ) {
function OctahedronGeometry (line 26722) | function OctahedronGeometry( radius, detail ) {
function OctahedronBufferGeometry (line 26743) | function OctahedronBufferGeometry( radius, detail ) {
function TorusGeometry (line 26779) | function TorusGeometry( radius, tube, radialSegments, tubularSegments, a...
function TorusBufferGeometry (line 26803) | function TorusBufferGeometry( radius, tube, radialSegments, tubularSegme...
function defineProperty (line 27074) | function defineProperty( propName, defaultValue ) {
function getPointer (line 27475) | function getPointer( event ) {
function onPointerHover (line 27503) | function onPointerHover( event ) {
function onPointerDown (line 27511) | function onPointerDown( event ) {
function onPointerMove (line 27522) | function onPointerMove( event ) {
function onPointerUp (line 27530) | function onPointerUp( event ) {
function Curve (line 28534) | function Curve() {
function GrannyKnot (line 28932) | function GrannyKnot() {
function HeartCurve (line 28957) | function HeartCurve( scale ) {
function VivianiCurve (line 28984) | function VivianiCurve( scale ) {
function KnotCurve (line 29012) | function KnotCurve() {
function HelixCurve (line 29040) | function HelixCurve() {
function TrefoilKnot (line 29068) | function TrefoilKnot( scale ) {
function TorusKnot (line 29095) | function TorusKnot( scale ) {
function CinquefoilKnot (line 29125) | function CinquefoilKnot( scale ) {
function TrefoilPolynomialKnot (line 29155) | function TrefoilPolynomialKnot( scale ) {
function FigureEightPolynomialKnot (line 29189) | function FigureEightPolynomialKnot( scale ) {
function DecoratedTorusKnot4a (line 29216) | function DecoratedTorusKnot4a( scale ) {
function DecoratedTorusKnot4b (line 29243) | function DecoratedTorusKnot4b( scale ) {
function DecoratedTorusKnot5a (line 29270) | function DecoratedTorusKnot5a( scale ) {
function DecoratedTorusKnot5c (line 29297) | function DecoratedTorusKnot5c( scale ) {
function StereoCamera (line 29900) | function StereoCamera() {
function initAsciiSize (line 30227) | function initAsciiSize() {
function asciifyImage (line 30326) | function asciifyImage( canvasRenderer, oAscii ) {
function createMaterial (line 30779) | function createMaterial() {
function getOutlineMaterialFromCache (line 30795) | function getOutlineMaterialFromCache( originalMaterial ) {
function getOutlineMaterial (line 30818) | function getOutlineMaterial( originalMaterial ) {
function isCompatible (line 30830) | function isCompatible( object ) {
function setOutlineMaterial (line 30853) | function setOutlineMaterial( object ) {
function restoreOriginalMaterial (line 30876) | function restoreOriginalMaterial( object ) {
function onBeforeRender (line 30898) | function onBeforeRender( renderer, scene, camera, geometry, material ) {
function updateUniforms (line 30909) | function updateUniforms( material, originalMaterial ) {
function updateOutlineMaterial (line 30933) | function updateOutlineMaterial( material, originalMaterial ) {
function cleanupCache (line 30986) | function cleanupCache() {
function MeshLambertMaterial (line 31516) | function MeshLambertMaterial( parameters ) {
function format (line 31650) | function format( urdf ) {
function base64ToBuffer (line 31685) | function base64ToBuffer( str ) {
function imageToData (line 31701) | function imageToData( image, ext ) {
function attrBufferToArray (line 31723) | function attrBufferToArray( attr ) {
function subArray (line 31752) | function subArray( arr, st, ct ) {
function getAttribute (line 31760) | function getAttribute( attr, name, params, type ) {
function getTransform (line 31785) | function getTransform( o ) {
function processGeometry (line 31800) | function processGeometry( g ) {
function processTexture (line 31907) | function processTexture( tex ) {
function processMaterial (line 31949) | function processMaterial( m ) {
function processObject (line 32113) | function processObject( o ) {
function getUID (line 32577) | function getUID( object ) {
function equalArray (line 32591) | function equalArray( array1, array2 ) {
function stringToArrayBuffer (line 32606) | function stringToArrayBuffer( text ) {
function getMinMax (line 32636) | function getMinMax( attribute, start, count ) {
function isPowerOfTwo (line 32668) | function isPowerOfTwo( image ) {
function isNormalizedNormalAttribute (line 32681) | function isNormalizedNormalAttribute( normal ) {
function createNormalizedNormalAttribute (line 32709) | function createNormalizedNormalAttribute( normal ) {
function getPaddedBufferSize (line 32754) | function getPaddedBufferSize( bufferSize ) {
function getPaddedArrayBuffer (line 32767) | function getPaddedArrayBuffer( arrayBuffer, paddingByte ) {
function serializeUserData (line 32802) | function serializeUserData( object, gltfProperty ) {
function applyTextureTransform (line 32852) | function applyTextureTransform( mapDef, texture ) {
function processBuffer (line 32893) | function processBuffer( buffer ) {
function processBufferView (line 32917) | function processBufferView( attribute, componentType, start, count, targ...
function processBufferViewImage (line 33017) | function processBufferViewImage( blob ) {
function processAccessor (line 33059) | function processAccessor( attribute, geometry, start, count ) {
function processImage (line 33166) | function processImage( image, format, flipY ) {
function processSampler (line 33263) | function processSampler( map ) {
function processTexture (line 33291) | function processTexture( map ) {
function processMaterial (line 33332) | function processMaterial( material ) {
function processMesh (line 33573) | function processMesh( mesh ) {
function processCamera (line 33914) | function processCamera( camera ) {
function processAnimation (line 33976) | function processAnimation( clip, root ) {
function processSkin (line 34085) | function processSkin( object ) {
function processLight (line 34128) | function processLight( light ) {
function processNode (line 34186) | function processNode( object ) {
function processScene (line 34327) | function processScene( scene ) {
function processObjects (line 34390) | function processObjects( objects ) {
function processInput (line 34407) | function processInput( input ) {
function unicodeToShiftjis (line 34749) | function unicodeToShiftjis( str ) {
function getBindBones (line 34801) | function getBindBones( skin ) {
function toStringsFromNumber (line 34837) | function toStringsFromNumber( num ) {
function toStringsFromArray (line 34860) | function toStringsFromArray( array ) {
function traverseMeshes (line 35244) | function traverseMeshes( cb ) {
function Line3 (line 36039) | function Line3( start, end ) {
function ConvexHull (line 36190) | function ConvexHull() {
function Face (line 37116) | function Face() {
function HalfEdge (line 37215) | function HalfEdge( vertex, face ) {
function VertexNode (line 37282) | function VertexNode( point ) {
function VertexList (line 37293) | function VertexList() {
function generate (line 37612) | function generate() {
function pushDecalVertex (line 37706) | function pushDecalVertex( decalVertices, vertex, normal ) {
function clipGeometry (line 37719) | function clipGeometry( inVertices, plane ) {
function clip (line 37859) | function clip( v0, v1, p, s ) {
function ArrowHelper (line 39345) | function ArrowHelper( dir, origin, length, color, headLength, headWidth ) {
function ParametricGeometry (line 39459) | function ParametricGeometry( func, slices, stacks ) {
function ParametricBufferGeometry (line 39481) | function ParametricBufferGeometry( func, slices, stacks ) {
function TorusKnotCurve (line 39776) | function TorusKnotCurve() {
function sphere (line 39818) | function sphere( u, v, target ) {
function plane (line 39845) | function plane( u, v, target ) {
function LineSegments (line 40583) | function LineSegments( geometry, material ) {
function FaceNormalsHelper (line 40661) | function FaceNormalsHelper( object, size, hex, linewidth ) {
function LightProbeHelper (line 40762) | function LightProbeHelper( lightProbe, size ) {
function PositionalAudioHelper (line 40887) | function PositionalAudioHelper( audio, range, divisionsInnerAngle, divis...
function generateSegment (line 40935) | function generateSegment( from, to, divisions, materialIndex ) {
function RectAreaLightHelper (line 40992) | function RectAreaLightHelper( light, color ) {
function VertexNormalsHelper (line 41071) | function VertexNormalsHelper( object, size, hex, linewidth ) {
function VertexTangentsHelper (line 41208) | function VertexTangentsHelper( object, size, hex, linewidth ) {
function Frustum (line 41304) | function Frustum( p0, p1, p2, p3, p4, p5 ) {
function SelectionBox (line 41489) | function SelectionBox( camera, scene, deep ) {
function SelectionHelper (line 41609) | function SelectionHelper( selectionBox, renderer, cssClassName ) {
function SphericalHarmonics3 (line 41701) | function SphericalHarmonics3() {
function Light (line 41933) | function Light( color, intensity ) {
function LightProbe (line 41992) | function LightProbe( sh, intensity ) {
function DataTexture (line 42279) | function DataTexture( data, width, height, format, type, mapping, wrapS,...
function InterleavedBuffer (line 43428) | function InterleavedBuffer( array, stride ) {
function InstancedInterleavedBuffer (line 43522) | function InstancedInterleavedBuffer( array, stride, meshPerAttribute ) {
function InterleavedBufferAttribute (line 43555) | function InterleavedBufferAttribute( interleavedBuffer, itemSize, offset...
function InstancedBufferGeometry (line 43710) | function InstancedBufferGeometry() {
function WireframeGeometry (line 43761) | function WireframeGeometry( geometry ) {
function LoadingManager (line 44824) | function LoadingManager( onLoad, onProgress, onError ) {
function Loader (line 44966) | function Loader( manager ) {
function FileLoader (line 45012) | function FileLoader( manager ) {
function Group (line 45322) | function Group() {
function MeshPhongMaterial (line 45445) | function MeshPhongMaterial( parameters ) {
function MeshStandardMaterial (line 45611) | function MeshStandardMaterial( parameters ) {
function ImageLoader (line 45737) | function ImageLoader( manager ) {
function onImageLoad (line 45775) | function onImageLoad() {
function onImageError (line 45788) | function onImageError( event ) {
function TextureLoader (line 45824) | function TextureLoader( manager ) {
function loadDocument (line 45918) | function loadDocument( data ) {
function parseRelsXml (line 46051) | function parseRelsXml( relsFileText ) {
function parseMetadataNodes (line 46077) | function parseMetadataNodes( metadataNodes ) {
function parseBasematerialsNode (line 46108) | function parseBasematerialsNode( basematerialsNode ) {
function parseTexture2DNode (line 46130) | function parseTexture2DNode( texture2DNode ) {
function parseTextures2DGroupNode (line 46145) | function parseTextures2DGroupNode( texture2DGroupNode ) {
function parseColorGroupNode (line 46173) | function parseColorGroupNode( colorGroupNode ) {
function parseMetallicDisplaypropertiesNode (line 46203) | function parseMetallicDisplaypropertiesNode( metallicDisplaypropetiesNod...
function parseBasematerialNode (line 46231) | function parseBasematerialNode( basematerialNode ) {
function parseMeshNode (line 46243) | function parseMeshNode( meshNode ) {
function parseComponentsNode (line 46327) | function parseComponentsNode( componentsNode ) {
function parseComponentNode (line 46345) | function parseComponentNode( componentNode ) {
function parseTransform (line 46363) | function parseTransform( transform ) {
function parseObjectNode (line 46384) | function parseObjectNode( objectNode ) {
function parseResourcesNode (line 46458) | function parseResourcesNode( resourcesNode ) {
function parseBuildNode (line 46542) | function parseBuildNode( buildNode ) {
function parseModelNode (line 46569) | function parseModelNode( modelNode ) {
function buildTexture (line 46600) | function buildTexture( texture2dgroup, objects, modelData, textureData ) {
function buildBasematerialsMeshes (line 46697) | function buildBasematerialsMeshes( basematerials, triangleProperties, mo...
function buildTexturedMesh (line 46764) | function buildTexturedMesh( texture2dgroup, triangleProperties, modelDat...
function buildVertexColorMesh (line 46822) | function buildVertexColorMesh( colorgroup, triangleProperties, modelData...
function buildDefaultMesh (line 46889) | function buildDefaultMesh( meshData ) {
function buildMeshes (line 46903) | function buildMeshes( resourceMap, modelData, meshData, textureData, obj...
function getResourceType (line 46952) | function getResourceType( pid, modelData ) {
function analyzeObject (line 46978) | function analyzeObject( modelData, meshData, objectData ) {
function buildGroup (line 47003) | function buildGroup( meshData, objects, modelData, textureData, objectDa...
function applyExtensions (line 47020) | function applyExtensions( extensions, meshData, modelXml ) {
function getBuild (line 47058) | function getBuild( data, objects, modelData, textureData, objectData, bu...
function buildBasematerial (line 47068) | function buildBasematerial( materialData, objects, modelData ) {
function buildComposite (line 47114) | function buildComposite( compositeData, objects, modelData, textureData ) {
function buildObject (line 47150) | function buildObject( objectId, objects, modelData, textureData ) {
function buildObjects (line 47175) | function buildObjects( data3mf ) {
function build (line 47225) | function build( objects, data3mf ) {
function loadDocument (line 47318) | function loadDocument( data ) {
function loadDocumentScale (line 47374) | function loadDocumentScale( node ) {
function loadMaterials (line 47404) | function loadMaterials( node ) {
function loadColor (line 47449) | function loadColor( node ) {
function loadMeshVolume (line 47481) | function loadMeshVolume( node ) {
function loadMeshVertices (line 47525) | function loadMeshVertices( node ) {
function loadObject (line 47570) | function loadObject( node ) {
function Skeleton (line 47771) | function Skeleton( bones, boneInverses ) {
function SkinnedMesh (line 47940) | function SkinnedMesh( geometry, material ) {
function find (line 48309) | function find( node, name ) {
function ASSBIN_MESH_HAS_TEXCOORD (line 48521) | function ASSBIN_MESH_HAS_TEXCOORD( n ) {
function ASSBIN_MESH_HAS_COLOR (line 48527) | function ASSBIN_MESH_HAS_COLOR( n ) {
function markBones (line 48533) | function markBones( scene ) {
function cloneTreeToBones (line 48549) | function cloneTreeToBones( root, scene ) {
function sortWeights (line 48574) | function sortWeights( indexes, weights ) {
function findMatchingBone (line 48624) | function findMatchingBone( root, name ) {
function aiMesh (line 48642) | function aiMesh() {
function aiFace (line 48813) | function aiFace() {
function aiVector3D (line 48820) | function aiVector3D() {
function aiColor3D (line 48834) | function aiColor3D() {
function aiQuaternion (line 48848) | function aiQuaternion() {
function aiVertexWeight (line 48862) | function aiVertexWeight() {
function aiString (line 48869) | function aiString() {
function aiVectorKey (line 48886) | function aiVectorKey() {
function aiQuatKey (line 48893) | function aiQuatKey() {
function aiNode (line 48900) | function aiNode() {
function aiBone (line 48936) | function aiBone() {
function aiMaterialProperty (line 48944) | function aiMaterialProperty() {
function aiMaterial (line 49046) | function aiMaterial() {
function veclerp (line 49092) | function veclerp( v1, v2, l ) {
function quatlerp (line 49103) | function quatlerp( q1, q2, l ) {
function sampleTrack (line 49109) | function sampleTrack( keys, time, lne, lerp ) {
function aiNodeAnim (line 49158) | function aiNodeAnim() {
function aiAnimation (line 49263) | function aiAnimation() {
function aiTexture (line 49300) | function aiTexture() {
function aiLight (line 49309) | function aiLight() {
function aiCamera (line 49324) | function aiCamera() {
function aiScene (line 49337) | function aiScene() {
function aiMatrix4 (line 49405) | function aiMatrix4() {
function readFloat (line 49435) | function readFloat( dataview ) {
function Read_double (line 49443) | function Read_double( dataview ) {
function Read_uint8_t (line 49451) | function Read_uint8_t( dataview ) {
function Read_uint16_t (line 49459) | function Read_uint16_t( dataview ) {
function Read_unsigned_int (line 49467) | function Read_unsigned_int( dataview ) {
function Read_uint32_t (line 49475) | function Read_uint32_t( dataview ) {
function Read_aiVector3D (line 49483) | function Read_aiVector3D( stream ) {
function Read_aiColor3D (line 49493) | function Read_aiColor3D( stream ) {
function Read_aiQuaternion (line 49503) | function Read_aiQuaternion( stream ) {
function Read_aiString (line 49514) | function Read_aiString( stream ) {
function Read_aiVertexWeight (line 49523) | function Read_aiVertexWeight( stream ) {
function Read_aiMatrix4x4 (line 49532) | function Read_aiMatrix4x4( stream ) {
function Read_aiVectorKey (line 49550) | function Read_aiVectorKey( stream ) {
function Read_aiQuatKey (line 49559) | function Read_aiQuatKey( stream ) {
function ReadArray_aiVertexWeight (line 49568) | function ReadArray_aiVertexWeight( stream, data, size ) {
function ReadArray_aiVectorKey (line 49574) | function ReadArray_aiVectorKey( stream, data, size ) {
function ReadArray_aiQuatKey (line 49580) | function ReadArray_aiQuatKey( stream, data, size ) {
function ReadBounds (line 49586) | function ReadBounds( stream, T /*p*/, n ) {
function ai_assert (line 49593) | function ai_assert( bool ) {
function ReadBinaryNode (line 49600) | function ReadBinaryNode( stream, parent, depth ) {
function ReadBinaryBone (line 49645) | function ReadBinaryBone( stream, b ) {
function ReadBinaryMesh (line 49673) | function ReadBinaryMesh( stream, mesh ) {
function ReadBinaryMaterialProperty (line 49873) | function ReadBinaryMaterialProperty( stream, prop ) {
function ReadBinaryMaterial (line 49891) | function ReadBinaryMaterial( stream, mat ) {
function ReadBinaryNodeAnim (line 49920) | function ReadBinaryNodeAnim( stream, nd ) {
function ReadBinaryAnim (line 49986) | function ReadBinaryAnim( stream, anim ) {
function ReadBinaryTexture (line 50012) | function ReadBinaryTexture( stream, tex ) {
function ReadBinaryLight (line 50040) | function ReadBinaryLight( stream, l ) {
function ReadBinaryCamera (line 50070) | function ReadBinaryCamera( stream, cam ) {
function ReadBinaryScene (line 50087) | function ReadBinaryScene( stream, scene ) {
function extendStream (line 50186) | function extendStream( stream ) {
function InternReadFile (line 50248) | function InternReadFile( pFiledata ) {
function Block (line 50344) | function Block() {
function AWDProperties (line 50353) | function AWDProperties() {}
function CompressedTexture (line 51488) | function CompressedTexture( mipmaps, width, height, format, type, mappin...
function init (line 51935) | function init( wasmBinary ) {
function transcode (line 51956) | function transcode( buffer ) {
function readBvh (line 52081) | function readBvh( lines ) {
function readFrameData (line 52147) | function readFrameData( data, frameTime, bone ) {
function readNode (line 52222) | function readNode( lines, firstline, list ) {
function toTHREEBone (line 52325) | function toTHREEBone( source, list ) {
function toTHREEAnimation (line 52354) | function toTHREEAnimation( bones ) {
function nextLine (line 52414) | function nextLine( lines ) {
function AmbientLight (line 52448) | function AmbientLight( color, intensity ) {
function LightShadow (line 52471) | function LightShadow( camera ) {
function DirectionalLightShadow (line 52600) | function DirectionalLightShadow() {
function DirectionalLight (line 52626) | function DirectionalLight( color, intensity ) {
function PointLightShadow (line 52662) | function PointLightShadow() {
function PointLight (line 52748) | function PointLight( color, intensity, distance, decay ) {
function SpotLightShadow (line 52804) | function SpotLightShadow() {
function SpotLight (line 52844) | function SpotLight( color, intensity, distance, angle, penumbra, decay ) {
function tgaCheckHeader (line 52954) | function tgaCheckHeader( header ) {
function tgaParse (line 53015) | function tgaParse( use_rle, use_pal, header, offset, data ) {
function tgaGetImageData8bits (line 53103) | function tgaGetImageData8bits( imageData, y_start, y_step, y_end, x_star...
function tgaGetImageData16bits (line 53127) | function tgaGetImageData16bits( imageData, y_start, y_step, y_end, x_sta...
function tgaGetImageData24bits (line 53150) | function tgaGetImageData24bits( imageData, y_start, y_step, y_end, x_sta...
function tgaGetImageData32bits (line 53172) | function tgaGetImageData32bits( imageData, y_start, y_step, y_end, x_sta...
function tgaGetImageDataGrey8bits (line 53194) | function tgaGetImageDataGrey8bits( imageData, y_start, y_step, y_end, x_...
function tgaGetImageDataGrey16bits (line 53217) | function tgaGetImageDataGrey16bits( imageData, y_start, y_step, y_end, x...
function getTgaRGBA (line 53239) | function getTgaRGBA( data, width, height, image, palette ) {
function Node (line 53456) | function Node( type ) {
method convertUpAxis (line 53676) | set convertUpAxis( value ) {
function getElementsByTagName (line 53686) | function getElementsByTagName( xml, name ) {
function parseStrings (line 53709) | function parseStrings( text ) {
function parseFloats (line 53726) | function parseFloats( text ) {
function parseInts (line 53743) | function parseInts( text ) {
function parseId (line 53760) | function parseId( text ) {
function generateId (line 53766) | function generateId() {
function isEmpty (line 53772) | function isEmpty( object ) {
function parseAsset (line 53780) | function parseAsset( xml ) {
function parseAssetUnit (line 53789) | function parseAssetUnit( xml ) {
function parseAssetUpAxis (line 53803) | function parseAssetUpAxis( xml ) {
function parseLibrary (line 53811) | function parseLibrary( xml, libraryName, nodeName, parser ) {
function buildLibrary (line 53829) | function buildLibrary( data, builder ) {
function getBuild (line 53842) | function getBuild( data, builder ) {
function parseAnimation (line 53854) | function parseAnimation( xml ) {
function parseAnimationSampler (line 53898) | function parseAnimationSampler( xml ) {
function parseAnimationChannel (line 53926) | function parseAnimationChannel( xml ) {
function buildAnimation (line 53981) | function buildAnimation( data ) {
function getAnimation (line 54014) | function getAnimation( id ) {
function buildAnimationChannel (line 54020) | function buildAnimationChannel( channel, inputSource, outputSource ) {
function prepareAnimationData (line 54093) | function prepareAnimationData( data, defaultMatrix ) {
function createKeyframeTracks (line 54133) | function createKeyframeTracks( animation, tracks ) {
function transformAnimationData (line 54168) | function transformAnimationData( keyframes, property, defaultValue ) {
function createMissingKeyframes (line 54215) | function createMissingKeyframes( keyframes, property ) {
function getPrev (line 54250) | function getPrev( keyframes, i, property ) {
function getNext (line 54266) | function getNext( keyframes, i, property ) {
function interpolate (line 54282) | function interpolate( key, prev, next, property ) {
function parseAnimationClip (line 54297) | function parseAnimationClip( xml ) {
function buildAnimationClip (line 54326) | function buildAnimationClip( data ) {
function getAnimationClip (line 54350) | function getAnimationClip( id ) {
function parseController (line 54358) | function parseController( xml ) {
function parseSkin (line 54389) | function parseSkin( xml ) {
function parseJoints (line 54428) | function parseJoints( xml ) {
function parseVertexWeights (line 54456) | function parseVertexWeights( xml ) {
function buildController (line 54493) | function buildController( data ) {
function buildSkin (line 54516) | function buildSkin( data ) {
function getController (line 54630) | function getController( id ) {
function parseImage (line 54638) | function parseImage( xml ) {
function buildImage (line 54648) | function buildImage( data ) {
function getImage (line 54656) | function getImage( id ) {
function parseEffect (line 54674) | function parseEffect( xml ) {
function parseEffectProfileCOMMON (line 54698) | function parseEffectProfileCOMMON( xml ) {
function parseEffectNewparam (line 54733) | function parseEffectNewparam( xml, data ) {
function parseEffectSurface (line 54759) | function parseEffectSurface( xml ) {
function parseEffectSampler (line 54783) | function parseEffectSampler( xml ) {
function parseEffectTechnique (line 54807) | function parseEffectTechnique( xml ) {
function parseEffectParameters (line 54835) | function parseEffectParameters( xml ) {
function parseEffectParameter (line 54871) | function parseEffectParameter( xml ) {
function parseEffectParameterTexture (line 54903) | function parseEffectParameterTexture( xml ) {
function parseEffectParameterTextureExtra (line 54929) | function parseEffectParameterTextureExtra( xml, data ) {
function parseEffectParameterTextureExtraTechnique (line 54949) | function parseEffectParameterTextureExtraTechnique( xml, data ) {
function parseEffectExtra (line 54993) | function parseEffectExtra( xml ) {
function parseEffectExtraTechnique (line 55017) | function parseEffectExtraTechnique( xml ) {
function buildEffect (line 55041) | function buildEffect( data ) {
function getEffect (line 55047) | function getEffect( id ) {
function parseMaterial (line 55055) | function parseMaterial( xml ) {
function getTextureLoader (line 55081) | function getTextureLoader( image ) {
function buildMaterial (line 55103) | function buildMaterial( data ) {
function getMaterial (line 55310) | function getMaterial( id ) {
function parseCamera (line 55318) | function parseCamera( xml ) {
function parseCameraOptics (line 55344) | function parseCameraOptics( xml ) {
function parseCameraTechnique (line 55363) | function parseCameraTechnique( xml ) {
function parseCameraParameters (line 55389) | function parseCameraParameters( xml ) {
function buildCamera (line 55417) | function buildCamera( data ) {
function getCamera (line 55462) | function getCamera( id ) {
function parseLight (line 55480) | function parseLight( xml ) {
function parseLightTechnique (line 55504) | function parseLightTechnique( xml ) {
function parseLightParameters (line 55532) | function parseLightParameters( xml ) {
function buildLight (line 55566) | function buildLight( data ) {
function getLight (line 55597) | function getLight( id ) {
function parseGeometry (line 55615) | function parseGeometry( xml ) {
function parseSource (line 55670) | function parseSource( xml ) {
function parseGeometryVertices (line 55711) | function parseGeometryVertices( xml ) {
function parseGeometryPrimitive (line 55729) | function parseGeometryPrimitive( xml ) {
function groupPrimitives (line 55775) | function groupPrimitives( primitives ) {
function checkUVCoordinates (line 55793) | function checkUVCoordinates( primitives ) {
function buildGeometry (line 55817) | function buildGeometry( data ) {
function buildGeometryType (line 55850) | function buildGeometryType( primitives, sources, vertices ) {
function buildGeometryData (line 56048) | function buildGeometryData( primitive, source, offset, array ) {
function getGeometry (line 56126) | function getGeometry( id ) {
function parseKinematicsModel (line 56134) | function parseKinematicsModel( xml ) {
function buildKinematicsModel (line 56162) | function buildKinematicsModel( data ) {
function getKinematicsModel (line 56170) | function getKinematicsModel( id ) {
function parseKinematicsTechniqueCommon (line 56176) | function parseKinematicsTechniqueCommon( xml, data ) {
function parseKinematicsJoint (line 56200) | function parseKinematicsJoint( xml ) {
function parseKinematicsJointParameter (line 56225) | function parseKinematicsJointParameter( xml, data ) {
function parseKinematicsLink (line 56281) | function parseKinematicsLink( xml ) {
function parseKinematicsAttachment (line 56316) | function parseKinematicsAttachment( xml ) {
function parseKinematicsTransform (line 56350) | function parseKinematicsTransform( xml ) {
function parsePhysicsModel (line 56384) | function parsePhysicsModel( xml ) {
function parsePhysicsRigidBody (line 56412) | function parsePhysicsRigidBody( xml, data ) {
function parsePhysicsTechniqueCommon (line 56432) | function parsePhysicsTechniqueCommon( xml, data ) {
function parseKinematicsScene (line 56458) | function parseKinematicsScene( xml ) {
function parseKinematicsBindJointAxis (line 56484) | function parseKinematicsBindJointAxis( xml ) {
function buildKinematicsScene (line 56513) | function buildKinematicsScene( data ) {
function getKinematicsScene (line 56521) | function getKinematicsScene( id ) {
function setupKinematics (line 56527) | function setupKinematics() {
function buildTransformList (line 56703) | function buildTransformList( node ) {
function prepareNodes (line 56760) | function prepareNodes( xml ) {
function parseNode (line 56783) | function parseNode( xml ) {
function parseNodeInstance (line 56883) | function parseNodeInstance( xml ) {
function buildSkeleton (line 56924) | function buildSkeleton( skeletons, joints ) {
function buildBoneHierarchy (line 57026) | function buildBoneHierarchy( root, joints, boneData ) {
function buildNode (line 57071) | function buildNode( data ) {
function resolveMaterialBinding (line 57212) | function resolveMaterialBinding( keys, instanceMaterials ) {
function buildObjects (line 57237) | function buildObjects( geometries, instanceMaterials ) {
function hasNode (line 57318) | function hasNode( id ) {
function getNode (line 57324) | function getNode( id ) {
function parseVisualScene (line 57332) | function parseVisualScene( xml ) {
function buildVisualScene (line 57353) | function buildVisualScene( data ) {
function hasVisualScene (line 57372) | function hasVisualScene( id ) {
function getVisualScene (line 57378) | function getVisualScene( id ) {
function parseScene (line 57386) | function parseScene( xml ) {
function setupAnimations (line 57393) | function setupAnimations() {
function parserErrorToText (line 57436) | function parserErrorToText( parserError ) {
function CompressedTextureLoader (line 57598) | function CompressedTextureLoader( manager ) {
function loadTexture (line 57621) | function loadTexture( i ) {
function fourCCToInt32 (line 57757) | function fourCCToInt32( value ) {
function int32ToFourCC (line 57766) | function int32ToFourCC( value ) {
function loadARGBMip (line 57777) | function loadARGBMip( buffer, dataOffset, width, height ) {
function decodeGeometry (line 58454) | function decodeGeometry( draco, decoder, decoderBuffer, taskConfig ) {
function decodeAttribute (line 58552) | function decodeAttribute( draco, decoder, dracoGeometry, attributeName, ...
function DataTextureLoader (line 58669) | function DataTextureLoader( manager ) {
function reverseLutFromBitmap (line 58869) | function reverseLutFromBitmap( bitmap, lut ) {
function hufClearDecTable (line 58891) | function hufClearDecTable( hdec ) {
function getBits (line 58906) | function getBits( nBits, c, lc, uInt8Array, inOffset ) {
function hufCanonicalCodeTable (line 58925) | function hufCanonicalCodeTable( hcode ) {
function hufUnpackEncTable (line 58949) | function hufUnpackEncTable( uInt8Array, inDataView, inOffset, ni, im, iM...
function hufLength (line 59013) | function hufLength( code ) {
function hufCode (line 59019) | function hufCode( code ) {
function hufBuildDecTable (line 59025) | function hufBuildDecTable( hcode, im, iM, hdecod ) {
function getChar (line 59100) | function getChar( c, lc, uInt8Array, inOffset ) {
function getCode (line 59112) | function getCode( po, rlc, c, lc, uInt8Array, inDataView, inOffset, outB...
function UInt16 (line 59158) | function UInt16( value ) {
function Int16 (line 59164) | function Int16( value ) {
function wdec14 (line 59173) | function wdec14( l, h ) {
function wav2Decode (line 59189) | function wav2Decode( buffer, j, nx, ox, ny, oy ) {
function hufDecode (line 59288) | function hufDecode( encodingTable, decodingTable, uInt8Array, inDataView...
function hufUncompress (line 59400) | function hufUncompress( uInt8Array, inDataView, inOffset, nCompressed, o...
function applyLut (line 59441) | function applyLut( lut, data, nData ) {
function predictor (line 59451) | function predictor( source ) {
function interleaveScalar (line 59462) | function interleaveScalar( source, out ) {
function decodeRunLength (line 59481) | function decodeRunLength( source ) {
function lossyDctDecode (line 59524) | function lossyDctDecode( cscSet, rowPtrs, channelData, acBuffer, dcBuffe...
function unRleAC (line 59685) | function unRleAC( currAcComp, acBuffer, halfZigBlock ) {
function unZigZag (line 59715) | function unZigZag( src, dst ) {
function dctInverse (line 59790) | function dctInverse( data ) {
function csc709Inverse (line 59878) | function csc709Inverse( data ) {
function convertToHalf (line 59894) | function convertToHalf( src, dst, idx ) {
function toLinear (line 59904) | function toLinear( float ) {
function uncompressRAW (line 59918) | function uncompressRAW( info ) {
function uncompressRLE (line 59924) | function uncompressRLE( info ) {
function uncompressZIP (line 59939) | function uncompressZIP( info ) {
function uncompressPIZ (line 59962) | function uncompressPIZ( info ) {
function uncompressDWA (line 60063) | function uncompressDWA( info ) {
function parseNullTerminatedString (line 60280) | function parseNullTerminatedString( buffer, offset ) {
function parseFixedLengthString (line 60301) | function parseFixedLengthString( buffer, offset, size ) {
function parseUlong (line 60313) | function parseUlong( dataView, offset ) {
function parseUint32 (line 60323) | function parseUint32( dataView, offset ) {
function parseUint8Array (line 60333) | function parseUint8Array( uInt8Array, offset ) {
function parseUint8 (line 60343) | function parseUint8( dataView, offset ) {
function parseInt64 (line 60353) | function parseInt64( dataView, offset ) {
function parseFloat32 (line 60363) | function parseFloat32( dataView, offset ) {
function decodeFloat16 (line 60374) | function decodeFloat16( binary ) {
function parseUint16 (line 60446) | function parseUint16( dataView, offset ) {
function parseFloat16 (line 60456) | function parseFloat16( buffer, offset ) {
function parseChlist (line 60462) | function parseChlist( dataView, buffer, offset, size ) {
function parseChromaticities (line 60492) | function parseChromaticities( dataView, offset ) {
function parseCompression (line 60507) | function parseCompression( dataView, offset ) {
function parseBox2i (line 60528) | function parseBox2i( dataView, offset ) {
function parseLineOrder (line 60539) | function parseLineOrder( dataView, offset ) {
function parseV2f (line 60551) | function parseV2f( dataView, offset ) {
function parseValue (line 60560) | function parseValue( dataView, buffer, offset, type, size ) {
function onLoadCallback (line 60881) | function onLoadCallback( texture, texData ) {
function FBXLoader (line 60942) | function FBXLoader( manager ) {
function FBXTreeParser (line 61021) | function FBXTreeParser( textureLoader, manager ) {
function GeometryParser (line 62392) | function GeometryParser() {}
function AnimationParser (line 63220) | function AnimationParser() {}
function TextParser (line 63803) | function TextParser() {}
function BinaryParser (line 64141) | function BinaryParser() {}
function BinaryReader (line 64469) | function BinaryReader( buffer, littleEndian ) {
function FBXTree (line 64716) | function FBXTree() {}
function isFbxFormatBinary (line 64732) | function isFbxFormatBinary( buffer ) {
function isFbxFormatASCII (line 64740) | function isFbxFormatASCII( text ) {
function getFbxVersion (line 64770) | function getFbxVersion( text ) {
function convertFBXTimeToSeconds (line 64785) | function convertFBXTimeToSeconds( time ) {
function getData (line 64794) | function getData( polygonVertexIndex, polygonIndex, vertexIndex, infoObj...
function generateTransform (line 64832) | function generateTransform( transformData ) {
function getEulerOrder (line 64938) | function getEulerOrder( order ) {
function parseNumberArray (line 64963) | function parseNumberArray( value ) {
function convertArrayBufferToString (line 64975) | function convertArrayBufferToString( buffer, from, to ) {
function append (line 64984) | function append( a, b ) {
function slice (line 64994) | function slice( a, b, from, to ) {
function inject (line 65007) | function inject( a1, index, a2 ) {
function newLayer (line 65068) | function newLayer( line ) {
function addSegment (line 65076) | function addSegment( p1, p2 ) {
function delta (line 65098) | function delta( v1, v2 ) {
function absolute (line 65104) | function absolute( v1, v2 ) {
function addObject (line 65183) | function addObject( vertex, extruding ) {
function LineLoop (line 65238) | function LineLoop( geometry, material ) {
function PointsMaterial (line 65272) | function PointsMaterial( parameters ) {
function Points (line 65327) | function Points( geometry, material ) {
function testPoint (line 65470) | function testPoint( point, index, localThresholdSq, matrixWorld, raycast...
function GLTFLoader (line 65511) | function GLTFLoader( manager ) {
function GLTFRegistry (line 65725) | function GLTFRegistry() {
function GLTFTextureDDSExtension (line 65780) | function GLTFTextureDDSExtension( ddsLoader ) {
function GLTFLightsExtension (line 65798) | function GLTFLightsExtension( json ) {
function GLTFMaterialsUnlitExtension (line 65867) | function GLTFMaterialsUnlitExtension() {
function GLTFBinaryExtension (line 65916) | function GLTFBinaryExtension( data ) {
function GLTFDracoMeshCompressionExtension (line 65982) | function GLTFDracoMeshCompressionExtension( json, dracoLoader ) {
function GLTFTextureTransformExtension (line 66061) | function GLTFTextureTransformExtension() {
function GLTFMeshStandardSGMaterial (line 66113) | function GLTFMeshStandardSGMaterial( params ) {
function GLTFMaterialsPbrSpecularGlossinessExtension (line 66257) | function GLTFMaterialsPbrSpecularGlossinessExtension() {
function GLTFMeshQuantizationExtension (line 66398) | function GLTFMeshQuantizationExtension() {
function GLTFCubicSplineInterpolant (line 66410) | function GLTFCubicSplineInterpolant( parameterPositions, sampleValues, s...
function resolveURL (line 66583) | function resolveURL( url, path ) {
function createDefaultMaterial (line 66612) | function createDefaultMaterial( cache ) {
function addUnknownExtensionsToUserData (line 66632) | function addUnknownExtensionsToUserData( knownExtensions, object, object...
function assignExtrasToUserData (line 66653) | function assignExtrasToUserData( object, gltfDef ) {
function addMorphTargets (line 66679) | function addMorphTargets( geometry, targets, parser ) {
function updateMorphTargets (line 66748) | function updateMorphTargets( mesh, meshDef ) {
function createPrimitiveKey (line 66787) | function createPrimitiveKey( primitiveDef ) {
function createAttributesKey (line 66808) | function createAttributesKey( attributes ) {
function GLTFParser (line 66826) | function GLTFParser( json, extensions, options ) {
function computeBounds (line 67683) | function computeBounds( geometry, primitiveDef, parser ) {
function addPrimitiveAttributes (line 67774) | function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
function toTrianglesDrawMode (line 67833) | function toTrianglesDrawMode( geometry, drawMode ) {
function createDracoPrimitive (line 67934) | function createDracoPrimitive( primitive ) {
function buildNodeHierachy (line 68545) | function buildNodeHierachy( nodeId, parentObject, json, parser ) {
function CubeTexture (line 68684) | function CubeTexture( images, mapping, wrapS, wrapT, magFilter, minFilte...
function toHalf (line 69057) | function toHalf( val ) {
function onLoadCallback (line 69200) | function onLoadCallback( texture, texData ) {
function loadHDRData (line 69316) | function loadHDRData( i, onLoad, onProgress, onError ) {
function findFile (line 69408) | function findFile( url ) {
function KhronosTextureContainer (line 69528) | function KhronosTextureContainer( arrayBuffer, facesExpected /*, threeDE...
function smoothNormals (line 69671) | function smoothNormals( triangles, lineSegments ) {
function isPrimitiveType (line 69858) | function isPrimitiveType( type ) {
function LineParser (line 69864) | function LineParser( line, lineNumber ) {
function sortByMaterial (line 69948) | function sortByMaterial( a, b ) {
function createObject (line 69966) | function createObject( elements, elementSize, isConditionalSegments ) {
function LDrawLoader (line 70101) | function LDrawLoader( manager ) {
function parseColourCode (line 70649) | function parseColourCode( lineParser, forEdge ) {
function parseVector (line 70678) | function parseVector( lp ) {
function onSubobjectFinish (line 71230) | function onSubobjectFinish() {
function finalizeObject (line 71258) | function finalizeObject() {
function loadSubobject (line 71374) | function loadSubobject( subobject ) {
function onSubobjectLoaded (line 71477) | function onSubobjectLoaded( subobjectGroup, subobject ) {
function onSubobjectError (line 71491) | function onSubobjectError( err, subobject ) {
function MeshPhysicalMaterial (line 71522) | function MeshPhysicalMaterial( parameters ) {
function LWO2Parser (line 71604) | function LWO2Parser( IFFParser ) {
function LWO3Parser (line 72018) | function LWO3Parser( IFFParser ) {
function IFFParser (line 72426) | function IFFParser( ) {
function DataViewReader (line 73283) | function DataViewReader( buffer ) {
function Debugger (line 73489) | function Debugger( ) {
function isEven (line 73572) | function isEven( num ) {
function stringOffset (line 73580) | function stringOffset( string ) {
function printBuffer (line 73588) | function printBuffer( buffer, from, to ) {
function LWOTreeParser (line 73648) | function LWOTreeParser( textureLoader ) {
function MaterialParser (line 73834) | function MaterialParser( textureLoader ) {
function GeometryParser (line 74319) | function GeometryParser() {}
function extractParentUrl (line 74591) | function extractParentUrl( url, dir ) {
function MeshToonMaterial (line 75026) | function MeshToonMaterial( parameters ) {
function MMDLoader (line 75170) | function MMDLoader( manager ) {
function MeshBuilder (line 75469) | function MeshBuilder( manager ) {
function initBones (line 75523) | function initBones( mesh ) {
function GeometryBuilder (line 75587) | function GeometryBuilder() {
function updateAttributes (line 75860) | function updateAttributes( attribute, morph, ratio ) {
function MaterialBuilder (line 76050) | function MaterialBuilder( manager ) {
function checkAlphaMorph (line 76295) | function checkAlphaMorph( elements, materials ) {
function createImageData (line 76488) | function createImageData( image ) {
function detectImageTransparency (line 76501) | function detectImageTransparency( image, uvs, indices ) {
function getAlphaByUv (line 76544) | function getAlphaByUv( image, uv ) {
function AnimationBuilder (line 76584) | function AnimationBuilder() {
function pushInterpolation (line 76621) | function pushInterpolation( array, interpolation, index ) {
function pushVector3 (line 76758) | function pushVector3( array, vec ) {
function pushQuaternion (line 76766) | function pushQuaternion( array, q ) {
function pushInterpolation (line 76775) | function pushInterpolation( array, interpolation, index ) {
function CubicBezierInterpolation (line 76946) | function CubicBezierInterpolation( parameterPositions, sampleValues, sam...
function resolveURL (line 77396) | function resolveURL( baseUrl, url ) {
function setMapForType (line 77408) | function setMapForType( mapType, value ) {
function TempNode (line 77623) | function TempNode( type, params ) {
function InputNode (line 77767) | function InputNode( type, params ) {
function ConstNode (line 77862) | function ConstNode( src, useDefine ) {
function VarNode (line 77985) | function VarNode( type, value ) {
function StructNode (line 78054) | function StructNode( src ) {
function AttributeNode (line 78156) | function AttributeNode( name, type ) {
function FunctionNode (line 78298) | function FunctionNode( src, includes, extensions, keywords, type ) {
function ExpressionNode (line 78572) | function ExpressionNode( src, type, keywords, extensions, includes ) {
function FunctionCallNode (line 78587) | function FunctionCallNode( func, inputs ) {
function applyShortcut (line 78703) | function applyShortcut( proxy, property, subProperty ) {
function NodeFrame (line 78774) | function NodeFrame( time ) {
function NodeUniform (line 78834) | function NodeUniform( params ) {
function Vector2Node (line 78870) | function Vector2Node( x, y ) {
function Vector3Node (line 78924) | function Vector3Node( x, y, z ) {
function Vector4Node (line 78979) | function Vector4Node( x, y, z, w ) {
function UVNode (line 79035) | function UVNode( index ) {
function FloatNode (line 79101) | function FloatNode( value ) {
function ColorSpaceNode (line 79152) | function ColorSpaceNode( input, method ) {
function TextureNode (line 79453) | function TextureNode( value, uv, bias, project ) {
function PositionNode (line 79565) | function PositionNode( scope ) {
function NormalNode (line 79716) | function NormalNode( scope ) {
function ReflectNode (line 79854) | function ReflectNode( scope ) {
function CubeTextureNode (line 80009) | function CubeTextureNode( value, uv, bias ) {
function OperatorNode (line 80114) | function OperatorNode( a, b, op ) {
function MathNode (line 80200) | function MathNode( a, bOrMethod, cOrMethod, method ) {
function TextureCubeUVNode (line 80468) | function TextureCubeUVNode( value, uv, bias ) {
function TextureCubeNode (line 80658) | function TextureCubeNode( value, uv, bias ) {
function NodeBuilder (line 80765) | function NodeBuilder() {
function sortByPosition (line 81412) | function sortByPosition( a, b ) {
function BoolNode (line 81695) | function BoolNode( value ) {
function IntNode (line 81746) | function IntNode( value ) {
function ColorNode (line 81797) | function ColorNode( color, g, b ) {
function Matrix3Node (line 81852) | function Matrix3Node( matrix ) {
function Matrix4Node (line 81920) | function Matrix4Node( matrix ) {
function ScreenNode (line 81989) | function ScreenNode( uv ) {
function ReflectorNode (line 82016) | function ReflectorNode( mirror ) {
function PropertyNode (line 82101) | function PropertyNode( object, property, type ) {
function RawNode (line 82156) | function RawNode( value ) {
function NodeMaterial (line 82218) | function NodeMaterial( vertex, fragment ) {
function RTTNode (line 82429) | function RTTNode( width, height, input, options ) {
function ColorsNode (line 82578) | function ColorsNode( index ) {
function CameraNode (line 82631) | function CameraNode( scope, camera ) {
function LightNode (line 82864) | function LightNode( scope ) {
function ResolutionNode (line 82925) | function ResolutionNode() {
function ScreenUVNode (line 82987) | function ScreenUVNode( resolution ) {
function CondNode (line 83050) | function CondNode( a, b, op, ifNode, elseNode ) {
function NoiseNode (line 83176) | function NoiseNode( uv ) {
function CheckerNode (line 83243) | function CheckerNode( uv ) {
function NormalMapNode (line 83316) | function NormalMapNode( value, scale ) {
function BumpMapNode (line 83411) | function BumpMapNode( value, scale ) {
function BypassNode (line 83573) | function BypassNode( code, value ) {
function JoinNode (line 83660) | function JoinNode( x, y, z, w ) {
function SwitchNode (line 83769) | function SwitchNode( node, components ) {
function TimerNode (line 83871) | function TimerNode( scale, scope, timeScale ) {
function VelocityNode (line 83975) | function VelocityNode( target, params ) {
function UVTransformNode (line 84149) | function UVTransformNode( uv, position ) {
function MaxMIPLevelNode (line 84213) | function MaxMIPLevelNode( texture ) {
function SpecularMIPLevelNode (line 84274) | function SpecularMIPLevelNode( roughness, texture ) {
function SubSlotNode (line 84372) | function SubSlotNode( slots ) {
function BlurNode (line 84449) | function BlurNode( value, uv, radius, size ) {
function LuminanceNode (line 84611) | function LuminanceNode( rgb ) {
function ColorAdjustmentNode (line 84682) | function ColorAdjustmentNode( rgb, adjustment, method ) {
function SpriteNode (line 84812) | function SpriteNode() {
function PhongNode (line 85041) | function PhongNode() {
function StandardNode (line 85449) | function StandardNode() {
function MeshStandardNode (line 86045) | function MeshStandardNode() {
function SpriteNodeMaterial (line 86152) | function SpriteNodeMaterial() {
function PhongNodeMaterial (line 86178) | function PhongNodeMaterial() {
function StandardNodeMaterial (line 86213) | function StandardNodeMaterial() {
function MeshStandardNodeMaterial (line 86252) | function MeshStandardNodeMaterial() {
function NodePostProcessing (line 86282) | function NodePostProcessing( renderer, renderTarget ) {
function scan (line 87456) | function scan( type, chunks ) {
function flipEndianness (line 87534) | function flipEndianness( array, chunkSize ) {
function parseHeader (line 87554) | function parseHeader( header ) {
function parseDataAsText (line 87617) | function parseDataAsText( data, start, end ) {
function LineDashedMaterial (line 88062) | function LineDashedMaterial( parameters ) {
function MeshDepthMaterial (line 88117) | function MeshDepthMaterial( parameters ) {
function MeshDistanceMaterial (line 88198) | function MeshDistanceMaterial( parameters ) {
function MeshNormalMaterial (line 88281) | function MeshNormalMaterial( parameters ) {
function RawShaderMaterial (line 88347) | function RawShaderMaterial( parameters ) {
function ShadowMaterial (line 88369) | function ShadowMaterial( parameters ) {
function SpriteMaterial (line 88410) | function SpriteMaterial( parameters ) {
function MaterialLoader (line 88477) | function MaterialLoader( manager ) {
function getTexture (line 88507) | function getTexture( name ) {
function ParserState (line 91328) | function ParserState() {
function OBJLoader (line 91680) | function OBJLoader( manager ) {
function interceptOnLoad (line 92581) | function interceptOnLoad( object3d, message ) {
function scopedOnLoad (line 92628) | function scopedOnLoad( message ) {
function decompressLZF (line 92730) | function decompressLZF( inData, outLength ) {
function parseHeader (line 92782) | function parseHeader( data ) {
function trim (line 93102) | function trim( text ) {
function capitalize (line 93108) | function capitalize( text ) {
function hash (line 93114) | function hash( s, e ) {
function parseBond (line 93120) | function parseBond( start, length ) {
function buildGeometry (line 93139) | function buildGeometry() {
function parseHeader (line 93326) | function parseHeader( data ) {
function parseASCIINumber (line 93440) | function parseASCIINumber( n, type ) {
function parseASCIIElement (line 93457) | function parseASCIIElement( properties, line ) {
function parseASCII (line 93490) | function parseASCII( data, header ) {
function postProcess (line 93546) | function postProcess( buffer ) {
function handleElement (line 93593) | function handleElement( buffer, elementName, element ) {
function binaryRead (line 93645) | function binaryRead( dataview, at, type, little_endian ) {
function binaryReadElement (line 93663) | function binaryReadElement( dataview, at, properties, little_endian ) {
function parseBinary (line 93702) | function parseBinary( data, header ) {
function isBigEndianPlatform (line 93773) | function isBigEndianPlatform() {
function copyFromBuffer (line 93815) | function copyFromBuffer( sourceArrayBuffer, viewType, position, length, ...
function decodePrwm (line 93844) | function decodePrwm( buffer ) {
function PRWMLoader (line 93980) | function PRWMLoader( manager ) {
function isBinary (line 94384) | function isBinary( data ) {
function matchDataViewAt (line 94424) | function matchDataViewAt( query, reader, offset ) {
function parseBinary (line 94438) | function parseBinary( data ) {
function parseASCII (line 94544) | function parseASCII( data ) {
function ensureString (line 94632) | function ensureString( buffer ) {
function ensureBinary (line 94644) | function ensureBinary( buffer ) {
function EllipseCurve (line 94676) | function EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle,...
function ArcCurve (line 94827) | function ArcCurve( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
function CubicPoly (line 94861) | function CubicPoly() {
function CatmullRomCurve3 (line 94921) | function CatmullRomCurve3( points, closed, curveType, tension ) {
function CatmullRom (line 95099) | function CatmullRom( t, p0, p1, p2, p3 ) {
function QuadraticBezierP0 (line 95111) | function QuadraticBezierP0( t, p ) {
function QuadraticBezierP1 (line 95118) | function QuadraticBezierP1( t, p ) {
function QuadraticBezierP2 (line 95124) | function QuadraticBezierP2( t, p ) {
function QuadraticBezier (line 95130) | function QuadraticBezier( t, p0, p1, p2 ) {
function CubicBezierP0 (line 95139) | function CubicBezierP0( t, p ) {
function CubicBezierP1 (line 95146) | function CubicBezierP1( t, p ) {
function CubicBezierP2 (line 95153) | function CubicBezierP2( t, p ) {
function CubicBezierP3 (line 95159) | function CubicBezierP3( t, p ) {
function CubicBezier (line 95165) | function CubicBezier( t, p0, p1, p2, p3 ) {
function CubicBezierCurve (line 95173) | function CubicBezierCurve( v0, v1, v2, v3 ) {
function CubicBezierCurve3 (line 95246) | function CubicBezierCurve3( v0, v1, v2, v3 ) {
function LineCurve (line 95320) | function LineCurve( v1, v2 ) {
function LineCurve3 (line 95405) | function LineCurve3( v1, v2 ) {
function QuadraticBezierCurve (line 95482) | function QuadraticBezierCurve( v0, v1, v2 ) {
function QuadraticBezierCurve3 (line 95551) | function QuadraticBezierCurve3( v0, v1, v2 ) {
function SplineCurve (line 95621) | function SplineCurve( points /* array of Vector2 */ ) {
function CurvePath (line 95749) | function CurvePath() {
function Path (line 96001) | function Path( points ) {
function Shape (line 96201) | function Shape( points ) {
function linkedList (line 96357) | function linkedList( data, start, end, dim, clockwise ) {
function filterPoints (line 96383) | function filterPoints( start, end ) {
function earcutLinked (line 96414) | function earcutLinked( ear, triangles, dim, minX, minY, invSize, pass ) {
function isEar (line 96481) | function isEar( ear ) {
function isEarHashed (line 96504) | function isEarHashed( ear, minX, minY, invSize ) {
function cureLocalIntersections (line 96565) | function cureLocalIntersections( start, triangles, dim ) {
function splitEarcut (line 96596) | function splitEarcut( start, triangles, dim, minX, minY, invSize ) {
function eliminateHoles (line 96632) | function eliminateHoles( data, holeIndices, outerNode, dim ) {
function compareX (line 96661) | function compareX( a, b ) {
function eliminateHole (line 96668) | function eliminateHole( hole, outerNode ) {
function findHoleBridge (line 96681) | function findHoleBridge( hole, outerNode ) {
function indexCurve (line 96757) | function indexCurve( start, minX, minY, invSize ) {
function sortLinked (line 96778) | function sortLinked( list ) {
function zOrder (line 96843) | function zOrder( x, y, minX, minY, invSize ) {
function getLeftmost (line 96864) | function getLeftmost( start ) {
function pointInTriangle (line 96880) | function pointInTriangle( ax, ay, bx, by, cx, cy, px, py ) {
function isValidDiagonal (line 96889) | function isValidDiagonal( a, b ) {
function area (line 96897) | function area( p, q, r ) {
function equals (line 96904) | function equals( p1, p2 ) {
function intersects (line 96911) | function intersects( p1, q1, p2, q2 ) {
function intersectsPolygon (line 96921) | function intersectsPolygon( a, b ) {
function locallyInside (line 96937) | function locallyInside( a, b ) {
function middleInside (line 96946) | function middleInside( a, b ) {
function splitPolygon (line 96967) | function splitPolygon( a, b ) {
function insertNode (line 96991) | function insertNode( i, x, y, last ) {
function removeNode (line 97013) | function removeNode( p ) {
function Node$1 (line 97023) | function Node$1( i, x, y ) {
function signedArea (line 97048) | function signedArea( data, start, end, dim ) {
function removeDupEndPts (line 97133) | function removeDupEndPts( points ) {
function addContour (line 97145) | function addContour( vertices, contour ) {
function ShapePath (line 97162) | function ShapePath() {
function toShapesNoHoles (line 97219) | function toShapesNoHoles( inSubpaths ) {
function isPointInsidePolygon (line 97238) | function isPointInsidePolygon( inPt, inPolygon ) {
function parseNode (line 97483) | function parseNode( node, style ) {
function parsePathNode (line 97582) | function parsePathNode( node ) {
function parseArcCommand (line 98012) | function parseArcCommand( path, rx, ry, x_axis_rotation, large_arc_flag,...
function svgAngle (line 98065) | function svgAngle( ux, uy, vx, vy ) {
function parseRectNode (line 98079) | function parseRectNode( node ) {
function parsePolygonNode (line 98114) | function parsePolygonNode( node ) {
function parsePolylineNode (line 98149) | function parsePolylineNode( node ) {
function parseCircleNode (line 98184) | function parseCircleNode( node ) {
function parseEllipseNode (line 98200) | function parseEllipseNode( node ) {
function parseLineNode (line 98217) | function parseLineNode( node ) {
function parseStyle (line 98235) | function parseStyle( node, style ) {
function getReflection (line 98279) | function getReflection( a, b ) {
function parseFloats (line 98285) | function parseFloats( string ) {
function parseFloatWithUnits (line 98368) | function parseFloatWithUnits( string ) {
function getNodeTransform (line 98419) | function getNodeTransform( node ) {
function parseNodeTransform (line 98442) | function parseNodeTransform( node ) {
function transformPath (line 98589) | function transformPath( path, m ) {
function isTransformRotated (line 98654) | function isTransformRotated( m ) {
function getTransformScaleX (line 98660) | function getTransformScaleX( m ) {
function getTransformScaleY (line 98667) | function getTransformScaleY( m ) {
function getNormal (line 99189) | function getNormal( p1, p2, result ) {
function addVertex (line 99196) | function addVertex( position, u, v ) {
function makeCircularSector (line 99229) | function makeCircularSector( center, p1, p2, u, v ) {
function makeSegmentTriangles (line 99263) | function makeSegmentTriangles() {
function makeSegmentWithBevelJoin (line 99275) | function makeSegmentWithBevelJoin( joinIsOnLeftSide, innerSideModified, ...
function createSegmentTrianglesWithMiddleSection (line 99341) | function createSegmentTrianglesWithMiddleSection( joinIsOnLeftSide, inne...
function addCapGeometry (line 99387) | function addCapGeometry( center, p1, p2, joinIsOnLeftSide, start, u ) {
function removeDuplicatedPoints (line 99466) | function removeDuplicatedPoints( points ) {
function convert (line 100568) | function convert( font, reversed ) {
function reverseCommands (line 100653) | function reverseCommands( commands ) {
function VRMLoader (line 100741) | function VRMLoader( manager ) {
function parseASCII (line 100835) | function parseASCII( data ) {
function parseBinary (line 101120) | function parseBinary( data ) {
function Float32Concat (line 101321) | function Float32Concat( first, second ) {
function Int32Concat (line 101332) | function Int32Concat( first, second ) {
function parseXML (line 101343) | function parseXML( stringFile ) {
function getStringFile (line 101926) | function getStringFile( data ) {
function defineProperties (line 101983) | function defineProperties( target, props ) {
function XAnimationObj (line 102036) | function XAnimationObj( _flags ) {
function XLoader (line 102166) | function XLoader( manager ) {
function fade (line 103724) | function fade( t ) {
function lerp (line 103730) | function lerp( t, a, b ) {
function grad (line 103736) | function grad( hash, x, y, z ) {
function MeshSurfaceSampler (line 103982) | function MeshSurfaceSampler( mesh ) {
function subdivideRadial (line 104253) | function subdivideRadial( subObject, startAngle, endAngle, numIterations...
function getVertexIndex (line 104342) | function getVertexIndex( faceIdx, vert ) {
function addResolutionDefine (line 104933) | function addResolutionDefine( materialShader ) {
function createShaderMaterial (line 104941) | function createShaderMaterial( computeFragmentShader, uniforms ) {
function getPassThroughVertexShader (line 105021) | function getPassThroughVertexShader() {
function getPassThroughFragmentShader (line 105031) | function getPassThroughFragmentShader() {
function loadTextures (line 105324) | function loadTextures( baseUrl, textureUrls ) {
function createPart (line 105342) | function createPart( geometry, skinMap ) {
function checkLoadingComplete (line 105364) | function checkLoadingComplete() {
function loadTextures (line 106198) | function loadTextures( baseUrl, textureUrls ) {
function createPart (line 106216) | function createPart( geometry, skinMap ) {
function checkLoadingComplete (line 106239) | function checkLoadingComplete() {
function exponentialEaseOut (line 106246) | function exponentialEaseOut( k ) {
function optionalParameter (line 106721) | function optionalParameter( value, defaultValue ) {
function drawShape (line 107155) | function drawShape( shape, color ) {
function extrudeShape (line 107197) | function extrudeShape( shape, offset, color ) {
function extrudeShape (line 107351) | function extrudeShape( shape, fromPoint, toPoint ) {
function TubePainter (line 107639) | function TubePainter() {
function pushIfUnique (line 107894) | function pushIfUnique( array, object ) {
function removeFromArray (line 107900) | function removeFromArray( array, object ) {
function computeEdgeCollapseCost (line 107907) | function computeEdgeCollapseCost( u, v ) {
function computeEdgeCostAtVertex (line 107968) | function computeEdgeCostAtVertex( v ) {
function removeVertex (line 108023) | function removeVertex( v, vertices ) {
function removeFace (line 108038) | function removeFace( f, faces ) {
function collapse (line 108064) | function collapse( vertices, faces, u, v ) { // u and v are pointers to ...
function minimumCostEdge (line 108111) | function minimumCostEdge( vertices ) {
function Triangle (line 108133) | function Triangle( v1, v2, v3, a, b, c ) {
function Vertex (line 108210) | function Vertex( v, id ) {
function getEdge (line 108419) | function getEdge( a, b, map ) {
function processEdge (line 108429) | function processEdge( a, b, vertices, map, face, metaVertices ) {
function generateLookups (line 108468) | function generateLookups( vertices, faces, metaVertices, edges ) {
function newFace (line 108490) | function newFace( newFaces, a, b, c, materialIndex ) {
function midpoint (line 108496) | function midpoint( a, b ) {
function newUv (line 108502) | function newUv( newUvs, a, b, c ) {
function Pass (line 108993) | function Pass() {
function NodePass (line 109143) | function NodePass() {
function Clock (line 109235) | function Clock( autoStart ) {
function Box2 (line 110332) | function Box2( min, max ) {
function ImmediateRenderObject (line 111180) | function ImmediateRenderObject( material ) {
function lerp (line 111277) | function lerp( a, b, t ) {
function VIntX (line 111283) | function VIntX( q, offset, isol, x, y, z, valp1, valp2, c_offset1, c_off...
function VIntY (line 111302) | function VIntY( q, offset, isol, x, y, z, valp1, valp2, c_offset1, c_off...
function VIntZ (line 111323) | function VIntZ( q, offset, isol, x, y, z, valp1, valp2, c_offset1, c_off...
function compNorm (line 111344) | function compNorm( q ) {
function polygonize (line 111363) | function polygonize( fx, fy, fz, q, isol, renderCallback ) {
function posnormtriv (line 111576) | function posnormtriv( pos, norm, colors, o1, o2, o3, renderCallback ) {
function concatenate (line 112103) | function concatenate( a, b, length ) {
function updateTextureMatrix (line 112902) | function updateTextureMatrix( camera ) {
function render (line 112925) | function render( renderer, scene, camera ) {
function Water2 (line 113680) | function Water2( geometry, options ) {
function gauss (line 114775) | function gauss( x, sigma ) {
function replaceDepthToViewZ (line 116498) | function replaceDepthToViewZ( string, camera ) {
function gatherSelectedMeshesCallBack (line 116547) | function gatherSelectedMeshesCallBack( object ) {
function gatherSelectedMeshesCallBack (line 116580) | function gatherSelectedMeshesCallBack( object ) {
function VisibilityChangeCallBack (line 116593) | function VisibilityChangeCallBack( object ) {
function DepthTexture (line 117056) | function DepthTexture( width, height, type, mapping, wrapS, wrapT, magFi...
function epsilon (line 120426) | function epsilon( value ) {
function getCameraCSSMatrix (line 120432) | function getCameraCSSMatrix( matrix ) {
function getObjectCSSMatrix (line 120457) | function getObjectCSSMatrix( matrix, cameraCSSMatrix ) {
function renderObject (line 120492) | function renderObject( object, scene, camera, cameraCSSMatrix ) {
function filterAndFlatten (line 120576) | function filterAndFlatten( scene ) {
function zOrder (line 120590) | function zOrder( scene ) {
function Sprite (line 120699) | function Sprite( material ) {
function transformVertex (line 120828) | function transformVertex( vertexPosition, mvPosition, center, scale, sin...
function setObject (line 121016) | function setObject( value ) {
function projectVertex (line 121028) | function projectVertex( vertex ) {
function pushVertex (line 121049) | function pushVertex( x, y, z ) {
function pushNormal (line 121058) | function pushNormal( x, y, z ) {
function pushColor (line 121064) | function pushColor( r, g, b ) {
function pushUv (line 121070) | function pushUv( x, y ) {
function checkTriangleVisibility (line 121076) | function checkTriangleVisibility( v1, v2, v3 ) {
function checkBackfaceCulling (line 121088) | function checkBackfaceCulling( v1, v2, v3 ) {
function pushLine (line 121097) | function pushLine( a, b ) {
function pushTriangle (line 121135) | function pushTriangle( a, b, c, material ) {
function projectObject (line 121207) | function projectObject( object ) {
function addObject (line 121241) | function addObject( object ) {
function pushPoint (line 121765) | function pushPoint( _vector4, object, camera ) {
function getNextObjectInPool (line 121796) | function getNextObjectInPool() {
function getNextVertexInPool (line 121812) | function getNextVertexInPool() {
function getNextFaceInPool (line 121828) | function getNextFaceInPool() {
function getNextLineInPool (line 121843) | function getNextLineInPool() {
function getNextSpriteInPool (line 121859) | function getNextSpriteInPool() {
function painterSort (line 121877) | function painterSort( a, b ) {
function clipLine (line 121899) | function clipLine( s1, s2 ) {
function removeChildNodes (line 122081) | function removeChildNodes() {
function convert (line 122093) | function convert( c ) {
function calculateLights (line 122239) | function calculateLights( lights ) {
function calculateLight (line 122274) | function calculateLight( lights, position, normal, color ) {
function renderSprite (line 122319) | function renderSprite( v1, element, material ) {
function renderLine (line 122344) | function renderLine( v1, v2, element, material ) {
function renderFace3 (line 122364) | function renderFace3( v1, v2, v3, element, material ) {
function expand (line 122424) | function expand( v1, v2, pixels ) {
function addPath (line 122440) | function addPath( style, path ) {
function flushPath (line 122457) | function flushPath() {
function getPathNode (line 122473) | function getPathNode( id ) {
function handleTriangle (line 126784) | function handleTriangle( a, b, c ) {
function handleVertex (line 126853) | function handleVertex( v ) {
function octEncodeVec3 (line 127808) | function octEncodeVec3(x0, y0, z0, xfunc, yfunc) {
function octDecodeVec2 (line 127843) | function octDecodeVec2(oct) {
function dot (line 127871) | function dot(x, y, z, vec3) {
function PackedPhongMaterial (line 127998) | function PackedPhongMaterial(parameters) {
function _getMipmapMaterial (line 128436) | function _getMipmapMaterial() {
function resetPosition (line 128599) | function resetPosition() {
function getBoneList (line 128709) | function getBoneList( object ) {
function SkeletonHelper (line 128729) | function SkeletonHelper( object ) {
function parallelTraverse (line 129380) | function parallelTraverse( a, b, callback ) {
function buildTree (line 129587) | function buildTree( points, depth, parent, pos ) {
function nearestSearch (line 129645) | function nearestSearch( node ) {
function processFace (line 130108) | function processFace( face, uvs, index ) {
function showStartAR (line 130294) | function showStartAR( /*device*/ ) {
function disableButton (line 130364) | function disableButton() {
function showARNotSupported (line 130379) | function showARNotSupported() {
function stylizeElement (line 130387) | function stylizeElement( element ) {
function showEnterVR (line 130466) | function showEnterVR( /*device*/ ) {
function disableButton (line 130537) | function disableButton() {
function showWebXRNotFound (line 130552) | function showWebXRNotFound() {
function stylizeElement (line 130560) | function stylizeElement( element ) {
function AnimationObjectGroup (line 130653) | function AnimationObjectGroup() {
function Audio (line 131012) | function Audio( listener ) {
function AudioAnalyser (line 131395) | function AudioAnalyser( audio, fftSize ) {
function AudioListener (line 131473) | function AudioListener() {
function PositionalAudio (line 131610) | function PositionalAudio( listener ) {
function ArrayCamera (line 131737) | function ArrayCamera( array ) {
function WebGLCubeRenderTarget (line 131759) | function WebGLCubeRenderTarget( size, options, dummy ) {
function CubeCamera (line 131881) | function CubeCamera( near, far, cubeResolution, options ) {
function InstancedBufferAttribute (line 131985) | function InstancedBufferAttribute( array, itemSize, normalized, meshPerA...
function Uniform (line 132040) | function Uniform( value ) {
function Font (line 132065) | function Font( data ) {
function createPaths (line 132096) | function createPaths( text, size, data ) {
function createPath (line 132129) | function createPath( char, scale, offsetX, offsetY, data ) {
function PMREMGenerator (line 132274) | function PMREMGenerator( renderer ) {
function _createPlanes (line 132397) | function _createPlanes() {
function _allocateTargets (line 132470) | function _allocateTargets( equirectangular ) {
function _cleanup (line 132489) | function _cleanup( outputTarget ) {
function _sceneToCubeUV (line 132499) | function _sceneToCubeUV( scene, near, far, cubeUVRenderTarget ) {
function _textureToCubeUV (line 132566) | function _textureToCubeUV( texture, cubeUVRenderTarget ) {
function _compileMaterial (line 132605) | function _compileMaterial( material ) {
function _createRenderTarget (line 132613) | function _createRenderTarget( params ) {
function _setViewport (line 132623) | function _setViewport( target, x, y, width, height ) {
function _applyPMREM (line 132630) | function _applyPMREM( cubeUVRenderTarget ) {
function _blur (line 132657) | function _blur( cubeUVRenderTarget, lodIn, lodOut, sigma, poleAxis ) {
function _halfBlur (line 132679) | function _halfBlur( targetIn, targetOut, lodIn, lodOut, sigmaRadians, di...
function _getBlurShader (line 132759) | function _getBlurShader( maxSamples ) {
function _getEquirectShader (line 132795) | function _getEquirectShader() {
function _getCubemapShader (line 132823) | function _getCubemapShader() {
function _getCommonVertexShader (line 132849) | function _getCommonVertexShader() {
function _getEncodings (line 132855) | function _getEncodings() {
function CircleGeometry (line 132870) | function CircleGeometry( radius, segments, thetaStart, thetaLength ) {
function CircleBufferGeometry (line 132893) | function CircleBufferGeometry( radius, segments, thetaStart, thetaLength...
function ConeGeometry (line 132982) | function ConeGeometry( radius, height, radialSegments, heightSegments, o...
function ConeBufferGeometry (line 133005) | function ConeBufferGeometry( radius, height, radialSegments, heightSegme...
function DodecahedronGeometry (line 133034) | function DodecahedronGeometry( radius, detail ) {
function DodecahedronBufferGeometry (line 133055) | function DodecahedronBufferGeometry( radius, detail ) {
function EdgesGeometry (line 133116) | function EdgesGeometry( geometry, thresholdAngle ) {
function ExtrudeGeometry (line 133244) | function ExtrudeGeometry( shapes, options ) {
function ExtrudeBufferGeometry (line 133276) | function ExtrudeBufferGeometry( shapes, options ) {
function toJSON (line 133988) | function toJSON( shapes, options, data ) {
function IcosahedronGeometry (line 134026) | function IcosahedronGeometry( radius, detail ) {
function IcosahedronBufferGeometry (line 134047) | function IcosahedronBufferGeometry( radius, detail ) {
function LatheGeometry (line 134087) | function LatheGeometry( points, segments, phiStart, phiLength ) {
function LatheBufferGeometry (line 134110) | function LatheBufferGeometry( points, segments, phiStart, phiLength ) {
function RingGeometry (line 134260) | function RingGeometry( innerRadius, outerRadius, thetaSegments, phiSegme...
function RingBufferGeometry (line 134285) | function RingBufferGeometry( innerRadius, outerRadius, thetaSegments, ph...
function ShapeGeometry (line 134405) | function ShapeGeometry( shapes, curveSegments ) {
function ShapeBufferGeometry (line 134444) | function ShapeBufferGeometry( shapes, curveSegments ) {
function toJSON$1 (line 134585) | function toJSON$1( shapes, data ) {
function TetrahedronGeometry (line 134617) | function TetrahedronGeometry( radius, detail ) {
function TetrahedronBufferGeometry (line 134638) | function TetrahedronBufferGeometry( radius, detail ) {
function TextGeometry (line 134685) | function TextGeometry( text, parameters ) {
function TextBufferGeometry (line 134706) | function TextBufferGeometry( text, parameters ) {
function TorusKnotGeometry (line 134750) | function TorusKnotGeometry( radius, tube, tubularSegments, radialSegment...
function TorusKnotBufferGeometry (line 134777) | function TorusKnotBufferGeometry( radius, tube, tubularSegments, radialS...
function TubeGeometry (line 134941) | function TubeGeometry( path, tubularSegments, radius, radialSegments, cl...
function TubeBufferGeometry (line 134977) | function TubeBufferGeometry( path, tubularSegments, radius, radialSegmen...
function AxesHelper (line 135160) | function AxesHelper( size ) {
function Box3Helper (line 135194) | function Box3Helper( box, color ) {
function BoxHelper (line 135245) | function BoxHelper( object, color ) {
function CameraHelper (line 135360) | function CameraHelper( camera ) {
function setPoint (line 135520) | function setPoint( point, pointMap, geometry, camera, x, y, z ) {
function DirectionalLightHelper (line 135551) | function DirectionalLightHelper( light, size, color ) {
function GridHelper (line 135631) | function GridHelper( size, divisions, color1, color2 ) {
function HemisphereLightHelper (line 135702) | function HemisphereLightHelper( light, size, color ) {
function PlaneHelper (line 135777) | function PlaneHelper( plane, size, hex ) {
function PointLightHelper (line 135832) | function PointLightHelper( light, sphereSize, color ) {
function PolarGridHelper (line 135918) | function PolarGridHelper( radius, radials, circles, divisions, color1, c...
function SpotLightHelper (line 136008) | function SpotLightHelper( light, color ) {
function AmbientLightProbe (line 136093) | function AmbientLightProbe( color, intensity ) {
function HemisphereLight (line 136135) | function HemisphereLight( skyColor, groundColor, intensity ) {
function HemisphereLightProbe (line 136173) | function HemisphereLightProbe( skyColor, groundColor, intensity ) {
function RectAreaLight (line 136223) | function RectAreaLight( color, intensity, width, height ) {
function AnimationLoader (line 136269) | function AnimationLoader( manager ) {
function AudioLoader (line 136316) | function AudioLoader( manager ) {
function BufferGeometryLoader (line 136355) | function BufferGeometryLoader( manager ) {
function CubeTextureLoader (line 136497) | function CubeTextureLoader( manager ) {
function loadTexture (line 136517) | function loadTexture( i ) {
function FontLoader (line 136554) | function FontLoader( manager ) {
function ImageBitmapLoader (line 136606) | function ImageBitmapLoader( manager ) {
function InstancedMesh (line 136718) | function InstancedMesh( geometry, material, count ) {
function LOD (line 136805) | function LOD() {
function Fog (line 136985) | function Fog( color, near, far ) {
function FogExp2 (line 137025) | function FogExp2( color, density ) {
function ObjectLoader (line 137128) | function ObjectLoader( manager ) {
function loadImage (line 137600) | function loadImage( url ) {
function parseConstant (line 137665) | function parseConstant( value, type ) {
function getGeometry (line 137754) | function getGeometry( name ) {
function getMaterial (line 137766) | function getMaterial( name ) {
function MeshMatcapMaterial (line 138107) | function MeshMatcapMaterial( parameters ) {
function Cylindrical (line 138190) | function Cylindrical( radius, theta, y ) {
function WebGLAnimation (line 138253) | function WebGLAnimation() {
function WebGLAttributes (line 138311) | function WebGLAttributes( gl, capabilities ) {
function WebGLBackground (line 138468) | function WebGLBackground( renderer, state, objects, premultipliedAlpha ) {
functi
Copy disabled (too large)
Download .json
Condensed preview — 1252 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (37,776K chars).
[
{
"path": ".gitignore",
"chars": 31,
"preview": "/.idea/\n/node_modules/\n/tests/\n"
},
{
"path": ".npmignore",
"chars": 60,
"preview": "/tests\n/configs\n/.idea\n/es6-convertor.js\n/gulpfile.js\n!core\n"
},
{
"path": "LICENSE.md",
"chars": 1155,
"preview": "### MIT License\n\n##### Copyright (c) 2017-Present, Itee, Valcke Tristan [https://github.com/Itee](https://github.com/Ite"
},
{
"path": "README.md",
"chars": 14724,
"preview": "three-full\n================\n\n[![License][license-badge]][license-badge-url]\n\n**Deprecation note:**\n> I am glad to annonc"
},
{
"path": "builds/Three.amd.js",
"chars": 4289450,
"preview": "// Made by Itee (https://github.com/Itee) with ES6 Convertor script\n\nconsole.warn('[ThreeFull]: I am glad to annonce sin"
},
{
"path": "builds/Three.cjs.js",
"chars": 4101840,
"preview": "// Made by Itee (https://github.com/Itee) with ES6 Convertor script\n\nconsole.warn('[ThreeFull]: I am glad to annonce sin"
},
{
"path": "builds/Three.es.js",
"chars": 4079262,
"preview": "// Made by Itee (https://github.com/Itee) with ES6 Convertor script\n\nconsole.warn('[ThreeFull]: I am glad to annonce sin"
},
{
"path": "builds/Three.iife.js",
"chars": 4289403,
"preview": "// Made by Itee (https://github.com/Itee) with ES6 Convertor script\n\nconsole.warn('[ThreeFull]: I am glad to annonce sin"
},
{
"path": "builds/Three.umd.js",
"chars": 4289690,
"preview": "// Made by Itee (https://github.com/Itee) with ES6 Convertor script\n\nconsole.warn('[ThreeFull]: I am glad to annonce sin"
},
{
"path": "configs/es6.conf.js",
"chars": 21783,
"preview": "/**\n * @file The main configuration file for es6-convertor\n *\n * @author Itee <valcketristan@gmail.com>\n * @license MIT\n"
},
{
"path": "configs/eslint.conf.js",
"chars": 924,
"preview": "/**\n * @author [Tristan Valcke]{@link https://github.com/Itee}\n * @license [BSD-3-Clause]{@link https://opensource.org/l"
},
{
"path": "configs/karma.units.conf.js",
"chars": 3070,
"preview": "/**\n * @author [Tristan Valcke]{@link https://github.com/Itee}\n * @license [BSD-3-Clause]{@link https://opensource.org/l"
},
{
"path": "configs/rollup.conf.js",
"chars": 6970,
"preview": "const path = require( 'path' )\nconst buble = require( 'rollup-plugin-buble' )\nconst terser = require( 'rollup-plugin-"
},
{
"path": "configs/rollup.tests.conf.js",
"chars": 6055,
"preview": "/**\n * @file Todo\n *\n * @author Itee <valcketristan@gmail.com>\n * @license MIT\n */\n\nconst fs = require( 'fs' )\nconst p"
},
{
"path": "configs/units.conf.js",
"chars": 2546,
"preview": "/**\n * @author [Tristan Valcke]{@link https://github.com/Itee}\n * @license [BSD-3-Clause]{@link https://opensource.org/l"
},
{
"path": "es6-convertor.js",
"chars": 54297,
"preview": "/**\n * @file The threejs convertor\n *\n * @author Itee <valcketristan@gmail.com>\n * @license MIT\n */\n\nconst fs = requi"
},
{
"path": "gulpfile.js",
"chars": 32408,
"preview": "/**\n * @file The gulp tasks file\n *\n * @author Itee <valcketristan@gmail.com>\n * @license MIT\n */\n\nconst fs = requi"
},
{
"path": "package.json",
"chars": 1444,
"preview": "{\n \"name\": \"three-full\",\n \"version\": \"28.0.2\",\n \"description\": \"The famous ThreeJs library with integrated examples a"
},
{
"path": "sources/ImageUtils.d.ts",
"chars": 990,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/PMREMGenerator.d.ts",
"chars": 1099,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/ShapeUtils.d.ts",
"chars": 716,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/Three.d.ts",
"chars": 7660,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/Three.js",
"chars": 37688,
"preview": "import './polyfills.js';\n\nexport { AnimationClipCreator } from './animation/AnimationClipCreator.js'\nexport { CCDIKSolve"
},
{
"path": "sources/WebGL.d.ts",
"chars": 750,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationAction.d.ts",
"chars": 2137,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationAction.js",
"chars": 13162,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationClip.d.ts",
"chars": 1446,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationClip.js",
"chars": 9903,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationClipCreator.d.ts",
"chars": 1071,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationClipCreator.js",
"chars": 3491,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationMixer.d.ts",
"chars": 1236,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationMixer.js",
"chars": 17179,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationObjectGroup.d.ts",
"chars": 776,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationObjectGroup.js",
"chars": 9647,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationUtils.d.ts",
"chars": 1178,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/AnimationUtils.js",
"chars": 4984,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/CCDIKSolver.d.ts",
"chars": 862,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/CCDIKSolver.js",
"chars": 10979,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/KeyframeTrack.d.ts",
"chars": 1686,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/KeyframeTrack.js",
"chars": 9972,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/MMDAnimationHelper.d.ts",
"chars": 2341,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/MMDAnimationHelper.js",
"chars": 21764,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/MMDPhysics.d.ts",
"chars": 3508,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/MMDPhysics.js",
"chars": 31585,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/PropertyBinding.d.ts",
"chars": 1636,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/PropertyBinding.js",
"chars": 16453,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/PropertyMixer.d.ts",
"chars": 825,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/PropertyMixer.js",
"chars": 4552,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/TimelinerController.d.ts",
"chars": 1041,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/TimelinerController.js",
"chars": 6040,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/BooleanKeyframeTrack.d.ts",
"chars": 627,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/BooleanKeyframeTrack.js",
"chars": 1363,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/ColorKeyframeTrack.d.ts",
"chars": 724,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/ColorKeyframeTrack.js",
"chars": 1205,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/NumberKeyframeTrack.d.ts",
"chars": 725,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/NumberKeyframeTrack.js",
"chars": 1067,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/QuaternionKeyframeTrack.d.ts",
"chars": 729,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/QuaternionKeyframeTrack.js",
"chars": 1478,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/StringKeyframeTrack.d.ts",
"chars": 725,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/StringKeyframeTrack.js",
"chars": 1212,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/VectorKeyframeTrack.d.ts",
"chars": 725,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/animation/tracks/VectorKeyframeTrack.js",
"chars": 1071,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/Audio.d.ts",
"chars": 1897,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/Audio.js",
"chars": 6530,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/AudioAnalyser.d.ts",
"chars": 706,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/AudioAnalyser.js",
"chars": 1157,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/AudioContext.d.ts",
"chars": 494,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/AudioContext.js",
"chars": 794,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/AudioListener.d.ts",
"chars": 933,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/AudioListener.js",
"chars": 3513,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/PositionalAudio.d.ts",
"chars": 1196,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/PositionalAudio.js",
"chars": 3218,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/audio/VolumeSlice.js",
"chars": 6849,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/ArrayCamera.d.ts",
"chars": 678,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/ArrayCamera.js",
"chars": 827,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/Camera.d.ts",
"chars": 863,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/Camera.js",
"chars": 2177,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/CinematicCamera.d.ts",
"chars": 1182,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/CinematicCamera.js",
"chars": 7674,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/CubeCamera.d.ts",
"chars": 1124,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/CubeCamera.js",
"chars": 3657,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/OrthographicCamera.d.ts",
"chars": 1216,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/OrthographicCamera.js",
"chars": 3653,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/PerspectiveCamera.d.ts",
"chars": 1402,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/PerspectiveCamera.js",
"chars": 6216,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/StereoCamera.d.ts",
"chars": 771,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/cameras/StereoCamera.js",
"chars": 3115,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/constants.d.ts",
"chars": 10519,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/constants.js",
"chars": 9172,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/DeviceOrientationControls.d.ts",
"chars": 764,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/DeviceOrientationControls.js",
"chars": 3908,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/DragControls.d.ts",
"chars": 760,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/DragControls.js",
"chars": 6747,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/FirstPersonControls.d.ts",
"chars": 1113,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/FirstPersonControls.js",
"chars": 7780,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/FlyControls.d.ts",
"chars": 789,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/FlyControls.js",
"chars": 7664,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/OrbitControls.d.ts",
"chars": 1930,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/OrbitControls.js",
"chars": 24904,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/PointerLockControls.d.ts",
"chars": 924,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/PointerLockControls.js",
"chars": 3742,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/TrackballControls.d.ts",
"chars": 1271,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/TrackballControls.js",
"chars": 16506,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/TransformControls.d.ts",
"chars": 1338,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/controls/TransformControls.js",
"chars": 45382,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/BufferAttribute.d.ts",
"chars": 5114,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/BufferAttribute.js",
"chars": 9865,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/BufferGeometry.d.ts",
"chars": 3430,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/BufferGeometry.js",
"chars": 24402,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Clock.d.ts",
"chars": 694,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Clock.js",
"chars": 1516,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Curve.d.ts",
"chars": 1040,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/CurvePath.d.ts",
"chars": 1138,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/CurvePath.js",
"chars": 7216,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/DirectGeometry.d.ts",
"chars": 1513,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/DirectGeometry.js",
"chars": 5927,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/EventDispatcher.d.ts",
"chars": 902,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/EventDispatcher.js",
"chars": 1924,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Face3.d.ts",
"chars": 1266,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Face3.js",
"chars": 1711,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Font.d.ts",
"chars": 615,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Font.js",
"chars": 3305,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Geometry.d.ts",
"chars": 2987,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Geometry.js",
"chars": 28085,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/InstancedBufferAttribute.d.ts",
"chars": 1247,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/InstancedBufferAttribute.js",
"chars": 1564,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/InstancedBufferGeometry.d.ts",
"chars": 748,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/InstancedBufferGeometry.js",
"chars": 1366,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/InstancedInterleavedBuffer.d.ts",
"chars": 702,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/InstancedInterleavedBuffer.js",
"chars": 1139,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/InterleavedBuffer.d.ts",
"chars": 1125,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/InterleavedBuffer.js",
"chars": 1952,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/InterleavedBufferAttribute.d.ts",
"chars": 1606,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/InterleavedBufferAttribute.js",
"chars": 3030,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Interpolations.d.ts",
"chars": 777,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Interpolations.js",
"chars": 1717,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Layers.d.ts",
"chars": 721,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Layers.js",
"chars": 1090,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Object3D.d.ts",
"chars": 4297,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Object3D.js",
"chars": 16325,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Path.d.ts",
"chars": 1854,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Path.js",
"chars": 4413,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Raycaster.d.ts",
"chars": 1609,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Raycaster.js",
"chars": 3241,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Shape.d.ts",
"chars": 1077,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Shape.js",
"chars": 2365,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/ShapePath.d.ts",
"chars": 991,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/ShapePath.js",
"chars": 6663,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Uniform.d.ts",
"chars": 674,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/core/Uniform.js",
"chars": 843,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/ArcCurve.d.ts",
"chars": 680,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/ArcCurve.js",
"chars": 863,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/CatmullRomCurve3.d.ts",
"chars": 1236,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/CatmullRomCurve3.js",
"chars": 6092,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/CubicBezierCurve.d.ts",
"chars": 727,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/CubicBezierCurve.js",
"chars": 2060,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/CubicBezierCurve3.d.ts",
"chars": 762,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/CubicBezierCurve3.js",
"chars": 2116,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/Curve.js",
"chars": 8653,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/CurveExtras.d.ts",
"chars": 2007,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/CurveExtras.js",
"chars": 10275,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/Curves.d.ts",
"chars": 793,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/EllipseCurve.d.ts",
"chars": 914,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/EllipseCurve.js",
"chars": 3414,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/LineCurve.d.ts",
"chars": 666,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/LineCurve.js",
"chars": 1969,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/LineCurve3.d.ts",
"chars": 701,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/LineCurve3.js",
"chars": 1843,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/NURBSCurve.d.ts",
"chars": 717,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/NURBSCurve.js",
"chars": 2547,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/NURBSSurface.d.ts",
"chars": 756,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/NURBSSurface.js",
"chars": 1950,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/NURBSUtils.d.ts",
"chars": 1445,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/NURBSUtils.js",
"chars": 8462,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/QuadraticBezierCurve.d.ts",
"chars": 704,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/QuadraticBezierCurve.js",
"chars": 1969,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/QuadraticBezierCurve3.d.ts",
"chars": 739,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/QuadraticBezierCurve3.js",
"chars": 2023,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/SplineCurve.d.ts",
"chars": 654,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/curves/SplineCurve.js",
"chars": 2376,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/AnaglyphEffect.d.ts",
"chars": 812,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/AnaglyphEffect.js",
"chars": 5160,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/AsciiEffect.d.ts",
"chars": 920,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/AsciiEffect.js",
"chars": 7185,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/OutlineEffect.d.ts",
"chars": 1568,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/OutlineEffect.js",
"chars": 14205,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/ParallaxBarrierEffect.d.ts",
"chars": 703,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/ParallaxBarrierEffect.js",
"chars": 3105,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/PeppersGhostEffect.d.ts",
"chars": 753,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/PeppersGhostEffect.js",
"chars": 3943,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/StereoEffect.d.ts",
"chars": 737,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/effects/StereoEffect.js",
"chars": 1754,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/exporters/ColladaExporter.d.ts",
"chars": 882,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/exporters/ColladaExporter.js",
"chars": 17583,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/exporters/DRACOExporter.d.ts",
"chars": 870,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/exporters/DracoExporter.js",
"chars": 5447,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/exporters/GLTFExporter.d.ts",
"chars": 952,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/exporters/GLTFExporter.js",
"chars": 54268,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/exporters/MMDExporter.d.ts",
"chars": 646,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
},
{
"path": "sources/exporters/MMDExporter.js",
"chars": 4583,
"preview": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
}
]
// ... and 1052 more files (download for full content)
About this extraction
This page contains the full source code of the Itee/three-full GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1252 files (33.4 MB), approximately 8.8M tokens, and a symbol index with 14191 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.