Copy disabled (too large)
Download .txt
Showing preview only (12,323K chars total). Download the full file to get everything.
Repository: uinosoft/t3d.js
Branch: dev
Commit: aab1a3c9c603
Files: 864
Total size: 11.6 MB
Directory structure:
gitextract_bg_rxfqd/
├── .editorconfig
├── .gitattributes
├── .github/
│ ├── contributing.md
│ └── workflows/
│ └── deploy-to-pages.yml
├── .gitignore
├── .vscode/
│ └── extensions.json
├── LICENSE
├── README.md
├── build/
│ ├── t3d.js
│ └── t3d.module.js
├── eslint.config.mjs
├── examples/
│ ├── animation_blending_additive.html
│ ├── animation_bone_attach.html
│ ├── animation_crossfade.html
│ ├── animation_interpolant.html
│ ├── animation_keyframe_animation.html
│ ├── animation_morphtargets.html
│ ├── animation_multiple.html
│ ├── animation_skinned_instancing.html
│ ├── animation_skinned_mesh.html
│ ├── animation_snake.html
│ ├── camera_multiple.html
│ ├── camera_projection.html
│ ├── canvas2d_canvas2d.html
│ ├── controls_camera_fly.html
│ ├── controls_camera_free.html
│ ├── controls_camera_orbit.html
│ ├── controls_camera_view.html
│ ├── controls_transform.html
│ ├── custompass_bloom.html
│ ├── custompass_blur.html
│ ├── custompass_car.html
│ ├── custompass_deferred.html
│ ├── custompass_depth_buffer_share.html
│ ├── custompass_depth_texture_share.html
│ ├── custompass_dof.html
│ ├── custompass_gbuffer.html
│ ├── custompass_gpupick.html
│ ├── custompass_lensflare.html
│ ├── custompass_motion_blur.html
│ ├── custompass_motion_blur2.html
│ ├── custompass_msaa.html
│ ├── custompass_oit.html
│ ├── custompass_rendertarget_2d.html
│ ├── custompass_rendertarget_3d.html
│ ├── custompass_shadow_planar.html
│ ├── custompass_sketch.html
│ ├── custompass_ssao.html
│ ├── custompass_ssr.html
│ ├── custompass_taa.html
│ ├── custompass_transmission.html
│ ├── custompass_unrealbloom.html
│ ├── custompass_xray.html
│ ├── exporter_draco.html
│ ├── exporter_gltf.html
│ ├── files/
│ │ ├── fonts/
│ │ │ ├── OFL-hind.txt
│ │ │ └── OFL-montserrat.txt
│ │ └── main.css
│ ├── files.json
│ ├── geometry_boundings.html
│ ├── geometry_builder_edges.html
│ ├── geometry_builder_lines.html
│ ├── geometry_builder_shapes.html
│ ├── geometry_geometries.html
│ ├── geometry_groups.html
│ ├── geometry_loader_assimp2json.html
│ ├── geometry_loader_gltf.html
│ ├── geometry_loader_gltf2.html
│ ├── geometry_loader_gltf3.html
│ ├── geometry_loader_gltf_avif.html
│ ├── geometry_loader_gltf_camera.html
│ ├── geometry_loader_gltf_draco.html
│ ├── geometry_loader_gltf_helmat.html
│ ├── geometry_loader_gltf_instancing.html
│ ├── geometry_loader_gltf_lights.html
│ ├── geometry_loader_gltf_materials_clearcoat.html
│ ├── geometry_loader_gltf_materials_dispersion.html
│ ├── geometry_loader_gltf_materials_transmission.html
│ ├── geometry_loader_gltf_materials_unlit.html
│ ├── geometry_loader_gltf_meshopt.html
│ ├── geometry_loader_gltf_morphtargets.html
│ ├── geometry_loader_gltf_pointer.html
│ ├── geometry_loader_gltf_skinning.html
│ ├── geometry_loader_gltf_tangent.html
│ ├── geometry_loader_gltf_uvtransform.html
│ ├── geometry_loader_vox.html
│ ├── index.html
│ ├── jsm/
│ │ ├── Clock.js
│ │ ├── DynamicFont.js
│ │ ├── GBuffer.js
│ │ ├── PickBuffer.js
│ │ ├── Raycaster.js
│ │ ├── SHGenerator.js
│ │ ├── SceneUtils.js
│ │ ├── SkeletonUtils.js
│ │ ├── SuperSampling.js
│ │ ├── VoxMeshBuilder.js
│ │ ├── WaterSimulation.js
│ │ ├── WorkerPool.js
│ │ ├── animation/
│ │ │ ├── CCDIKSolver.js
│ │ │ └── LockedTrack.js
│ │ ├── canvas2d/
│ │ │ ├── Canvas2D.js
│ │ │ ├── Object2D.js
│ │ │ └── Sprite2D.js
│ │ ├── controls/
│ │ │ ├── FlyControls.js
│ │ │ ├── FreeControls.js
│ │ │ ├── OrbitControls.js
│ │ │ ├── TransformControls.js
│ │ │ └── ViewControls.js
│ │ ├── exporters/
│ │ │ ├── DRACOExporter.js
│ │ │ └── GLTFExporter.js
│ │ ├── geometries/
│ │ │ ├── BitmapTextGeometry.js
│ │ │ ├── CapsuleGeometry.js
│ │ │ ├── CircleGeometry.js
│ │ │ ├── GeometryUtils.js
│ │ │ └── builders/
│ │ │ ├── Earcut.js
│ │ │ ├── EdgesBuilder.js
│ │ │ ├── ExtrudeShapeBuilder.js
│ │ │ ├── Font.js
│ │ │ ├── GeometryBuilderUtils.js
│ │ │ ├── LatheBuilder.js
│ │ │ ├── PolygonBuilder.js
│ │ │ ├── PolyhedronBuilder.js
│ │ │ ├── RouteBuilder.js
│ │ │ ├── TorusBuilder.js
│ │ │ └── TubeBuilder.js
│ │ ├── impostor/
│ │ │ ├── OctahedralImpostor.js
│ │ │ └── OctahedralTextureGenerator.js
│ │ ├── lights/
│ │ │ ├── LightShadowAdapter.js
│ │ │ └── RectAreaLightLTC.js
│ │ ├── loaders/
│ │ │ ├── AssimpJsonLoader.js
│ │ │ ├── DDSLoader.js
│ │ │ ├── DRACOLoader.js
│ │ │ ├── EXRLoader.js
│ │ │ ├── EnvLoader.js
│ │ │ ├── ImageBitmapLoader.js
│ │ │ ├── KTX2Loader.js
│ │ │ ├── PVRLoader.js
│ │ │ ├── RGBELoader.js
│ │ │ ├── TGALoader.js
│ │ │ ├── Texture2DLoader.js
│ │ │ ├── TextureCubeLoader.js
│ │ │ └── glTF/
│ │ │ ├── Constants.js
│ │ │ ├── GLTFLoader.js
│ │ │ ├── GLTFResource.js
│ │ │ ├── GLTFUtils.js
│ │ │ ├── extensions/
│ │ │ │ ├── EXT_mesh_gpu_instancing.js
│ │ │ │ ├── EXT_meshopt_compression.js
│ │ │ │ ├── KHR_animation_pointer.js
│ │ │ │ ├── KHR_draco_mesh_compression.js
│ │ │ │ ├── KHR_lights_punctual.js
│ │ │ │ ├── KHR_materials_clearcoat.js
│ │ │ │ ├── KHR_materials_dispersion.js
│ │ │ │ ├── KHR_materials_ior.js
│ │ │ │ ├── KHR_materials_pbrSpecularGlossiness.js
│ │ │ │ ├── KHR_materials_transmission.js
│ │ │ │ ├── KHR_materials_unlit.js
│ │ │ │ ├── KHR_materials_volume.js
│ │ │ │ ├── KHR_texture_basisu.js
│ │ │ │ └── KHR_texture_transform.js
│ │ │ └── parsers/
│ │ │ ├── AccessorParser.js
│ │ │ ├── AnimationParser.js
│ │ │ ├── BufferParser.js
│ │ │ ├── BufferViewParser.js
│ │ │ ├── ImageParser.js
│ │ │ ├── IndexParser.js
│ │ │ ├── MaterialParser.js
│ │ │ ├── NodeParser.js
│ │ │ ├── PrimitiveParser.js
│ │ │ ├── ReferenceParser.js
│ │ │ ├── SceneParser.js
│ │ │ ├── SkinParser.js
│ │ │ ├── TextureParser.js
│ │ │ └── Validator.js
│ │ ├── materials/
│ │ │ ├── AlphaHashedPBRMaterial.js
│ │ │ ├── AttenuationMaterial.js
│ │ │ ├── BatchedMaterial.js
│ │ │ ├── BatchedPBRMaterial.js
│ │ │ ├── BitmapTextMaterial.js
│ │ │ ├── InstancedBasicMaterial.js
│ │ │ ├── InstancedMaterial.js
│ │ │ ├── InstancedPBRMaterial.js
│ │ │ ├── PlanarReflectionMaterial.js
│ │ │ └── TransmissionPBRMaterial.js
│ │ ├── math/
│ │ │ ├── ColorGradient.js
│ │ │ ├── DistanceTransform.js
│ │ │ ├── OBB.js
│ │ │ ├── Octree.js
│ │ │ ├── TriangleSoup.js
│ │ │ ├── TrianglesOctree.js
│ │ │ ├── VirtualGroup.js
│ │ │ └── curves/
│ │ │ ├── CubicBezierCurve2.js
│ │ │ ├── CubicBezierCurve3.js
│ │ │ ├── Curve.js
│ │ │ ├── CurvePath.js
│ │ │ ├── CurvePath2.js
│ │ │ ├── CurvePath3.js
│ │ │ ├── CurveUtils.js
│ │ │ ├── Curves.js
│ │ │ ├── LineCurve2.js
│ │ │ ├── LineCurve3.js
│ │ │ ├── QuadraticBezierCurve2.js
│ │ │ └── QuadraticBezierCurve3.js
│ │ ├── misc/
│ │ │ ├── OcclusionProxyManager.js
│ │ │ └── Timer.js
│ │ ├── navigation/
│ │ │ ├── AStar.js
│ │ │ ├── Pathfinding.js
│ │ │ ├── PathfindingHelper.js
│ │ │ ├── Utils.js
│ │ │ └── Zone.js
│ │ ├── objects/
│ │ │ ├── AxisHelper.js
│ │ │ ├── Background.js
│ │ │ ├── BatchedMesh.js
│ │ │ ├── Box3Helper.js
│ │ │ ├── BoxHelper.js
│ │ │ ├── CameraHelper.js
│ │ │ ├── DirectionalLightHelper.js
│ │ │ ├── GradientSky.js
│ │ │ ├── GridHelper.js
│ │ │ ├── HemisphereLightHelper.js
│ │ │ ├── InstancedLine.js
│ │ │ ├── LayeredVolumeMesh.js
│ │ │ ├── LegacySkeletonHelper.js
│ │ │ ├── LightShadowAdapterHelper.js
│ │ │ ├── LineChartFillMesh.js
│ │ │ ├── OcclusionTester.js
│ │ │ ├── OctreeHelper.js
│ │ │ ├── ParticleContainer.js
│ │ │ ├── PointLightHelper.js
│ │ │ ├── PolarGridHelper.js
│ │ │ ├── RectAreaLightHelper.js
│ │ │ ├── SkeletonHelper.js
│ │ │ ├── Sky.js
│ │ │ ├── SkyBox.js
│ │ │ ├── SphereHelper.js
│ │ │ ├── SpotLightHelper.js
│ │ │ ├── Sprite.js
│ │ │ ├── Terrain.js
│ │ │ ├── TriangleSoupHelper.js
│ │ │ ├── VertexNormalsHelper.js
│ │ │ ├── VertexTangentsHelper.js
│ │ │ └── Water.js
│ │ ├── ocean/
│ │ │ ├── Butterfly.js
│ │ │ ├── OceanField.js
│ │ │ ├── OceanFieldBuilder.js
│ │ │ ├── OceanMaterial.js
│ │ │ ├── Utils.js
│ │ │ ├── index.js
│ │ │ └── shaders/
│ │ │ ├── FFT2HShader.js
│ │ │ ├── FFT2VShader.js
│ │ │ ├── H0Shader.js
│ │ │ ├── HkShader.js
│ │ │ └── PostFFT2Shader.js
│ │ ├── pass/
│ │ │ ├── BlurPass.js
│ │ │ ├── DepthPeelingOITPass.js
│ │ │ ├── SSAOPass.js
│ │ │ ├── UnrealBloomPass.js
│ │ │ └── WeightedBlendedOITPass.js
│ │ ├── probes/
│ │ │ ├── PlanarReflectionProbe.js
│ │ │ └── ReflectionProbe.js
│ │ ├── render/
│ │ │ ├── DeferredRenderer.js
│ │ │ └── ForwardRenderer.js
│ │ ├── shaders/
│ │ │ ├── BlendShader.js
│ │ │ ├── BlurShader.js
│ │ │ ├── BokehShader.js
│ │ │ ├── ClusteredDebugShader.js
│ │ │ ├── ColorAdjustShader.js
│ │ │ ├── CopyShader.js
│ │ │ ├── DeferredShader.js
│ │ │ ├── DepthLinearShader.js
│ │ │ ├── FXAAShader.js
│ │ │ ├── FastGaussianBlurShader.js
│ │ │ ├── FilmShader.js
│ │ │ ├── GroundProjectedSkyboxShader.js
│ │ │ ├── InfiniteGridShader.js
│ │ │ ├── LineDashedShader.js
│ │ │ ├── LuminosityHighPassShader.js
│ │ │ ├── MSDFTextShader.js
│ │ │ ├── MatcapShader.js
│ │ │ ├── MotionBlur2Shader.js
│ │ │ ├── MotionBlurShader.js
│ │ │ ├── OutputShader.js
│ │ │ ├── PlanarShadowShader.js
│ │ │ ├── SDFTextShader.js
│ │ │ ├── SSAOShader.js
│ │ │ ├── SSRShader.js
│ │ │ ├── ShadowShader.js
│ │ │ ├── SketchShader.js
│ │ │ ├── SkyShader.js
│ │ │ ├── TAAShader.js
│ │ │ ├── TextureVariationShader.js
│ │ │ ├── VolumeShader.js
│ │ │ ├── WaterShader.js
│ │ │ └── XRayShader.js
│ │ ├── stereo/
│ │ │ ├── AnaglyphRenderer.js
│ │ │ ├── StereoCamera.js
│ │ │ ├── StereoRenderer.js
│ │ │ ├── WebVRControls.js
│ │ │ └── WebXRControls.js
│ │ └── textures/
│ │ ├── GradientTextureGenerator.js
│ │ ├── HeatmapGenerator.js
│ │ ├── IDWMapGenerator.js
│ │ ├── PMREMGenerator.js
│ │ └── RGBDDecoder.js
│ ├── lab_clouds.html
│ ├── lab_clouds_shader.html
│ ├── lab_earth.html
│ ├── lab_geometry_grass.html
│ ├── lab_geometry_images.html
│ ├── lab_gltf_grass.html
│ ├── lab_ground.html
│ ├── lab_histogram.html
│ ├── lab_ik.html
│ ├── lab_impostor_octahedral.html
│ ├── lab_impostor_octahedral_instancing.html
│ ├── lab_linechart_fill.html
│ ├── lab_ocean.html
│ ├── lab_ocean_fft.html
│ ├── lab_terrain.html
│ ├── lab_texture_variation.html
│ ├── lab_water_simulation.html
│ ├── libs/
│ │ ├── ammo.wasm.js
│ │ ├── ammo.wasm.wasm
│ │ ├── basis/
│ │ │ ├── README.md
│ │ │ ├── basis_transcoder.js
│ │ │ └── basis_transcoder.wasm
│ │ ├── cannon.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
│ │ ├── es-module-shims.js
│ │ ├── fflate.module.js
│ │ ├── ktx-parse.module.js
│ │ ├── meshopt_decoder.module.js
│ │ ├── nanobar.js
│ │ ├── simplex-noise.js
│ │ ├── stats.module.js
│ │ ├── tween.module.js
│ │ ├── webvr-polyfill.js
│ │ └── zstddec.module.js
│ ├── light_directlight.html
│ ├── light_group.html
│ ├── light_hemispherelight.html
│ ├── light_pointlight.html
│ ├── light_rectarealight.html
│ ├── light_shadow.html
│ ├── light_shadow_adapter.html
│ ├── light_softshadow.html
│ ├── light_sphericalharmonicslight.html
│ ├── light_spotlight.html
│ ├── lines_dashedlines.html
│ ├── lines_instancedlines.html
│ ├── lines_lines.html
│ ├── main.css
│ ├── material_alphahash.html
│ ├── material_alphamask.html
│ ├── material_blending.html
│ ├── material_bumpmap.html
│ ├── material_clearcoat.html
│ ├── material_clippingplanes.html
│ ├── material_depth.html
│ ├── material_emissivemap.html
│ ├── material_envmap.html
│ ├── material_flatshading.html
│ ├── material_lightmap.html
│ ├── material_materials.html
│ ├── material_normalmap.html
│ ├── material_pbr.html
│ ├── material_shader_background.html
│ ├── material_shader_extend.html
│ ├── material_shader_fakeInterior.html
│ ├── material_shader_grid.html
│ ├── material_shader_matcap.html
│ ├── material_shader_shadow.html
│ ├── material_shader_sky.html
│ ├── material_shader_sky2.html
│ ├── material_shader_sky_gradient.html
│ ├── material_shader_skybox.html
│ ├── material_shader_skybox_filter.html
│ ├── material_shader_skybox_groundprojected.html
│ ├── material_shader_volume.html
│ ├── material_shader_volume_layered.html
│ ├── material_shader_water.html
│ ├── material_shader_water_pbr.html
│ ├── material_shader_xray.html
│ ├── material_shadermaterial.html
│ ├── material_transparent.html
│ ├── material_uvcoord.html
│ ├── material_uvtransform.html
│ ├── material_vertexcolors.html
│ ├── math_curve.html
│ ├── math_curve_motion.html
│ ├── math_obb.html
│ ├── math_octree.html
│ ├── navigation_pathfinding.html
│ ├── navigation_recast_crowd.html
│ ├── navigation_recast_generation.html
│ ├── navigation_recast_obstacles.html
│ ├── navigation_recast_walking.html
│ ├── particle_particle.html
│ ├── physics_ammo.html
│ ├── physics_ammo_softbody_volume.html
│ ├── physics_cannon.html
│ ├── physics_ik.html
│ ├── physics_rapier.html
│ ├── physics_rapier_character_controller.html
│ ├── points_sprites.html
│ ├── probes_reflection.html
│ ├── probes_reflection_planar.html
│ ├── raycast_raycaster.html
│ ├── renderer_clustered_lighting.html
│ ├── renderer_culling_contribution.html
│ ├── renderer_culling_frustum.html
│ ├── renderer_deferred.html
│ ├── renderer_deferred_lighting.html
│ ├── resources/
│ │ ├── 3d/
│ │ │ └── Readme.txt
│ │ ├── compressed/
│ │ │ ├── 2d_astc_6x6.ktx2
│ │ │ ├── 2d_etc1s.ktx2
│ │ │ ├── 2d_rgba16_linear.ktx2
│ │ │ ├── 2d_rgba32_linear.ktx2
│ │ │ ├── 2d_rgba8.ktx2
│ │ │ ├── 2d_rgba8_displayp3.ktx2
│ │ │ ├── 2d_rgba8_linear.ktx2
│ │ │ ├── 2d_uastc.ktx2
│ │ │ ├── Mountains.dds
│ │ │ ├── Mountains_argb_mip.dds
│ │ │ ├── Mountains_argb_nomip.dds
│ │ │ ├── disturb_2bpp_rgb.pvr
│ │ │ ├── disturb_4bpp_rgb.pvr
│ │ │ ├── disturb_4bpp_rgb_mips.pvr
│ │ │ ├── disturb_4bpp_rgb_v3.pvr
│ │ │ ├── disturb_argb_mip.dds
│ │ │ ├── disturb_argb_nomip.dds
│ │ │ ├── disturb_dxt1_mip.dds
│ │ │ ├── disturb_dxt1_nomip.dds
│ │ │ ├── explosion_dxt5_mip.dds
│ │ │ ├── flare_2bpp_rgba.pvr
│ │ │ ├── flare_4bpp_rgba.pvr
│ │ │ ├── hepatica_dxt3_mip.dds
│ │ │ ├── park3_cube_mip_2bpp_rgb_v3.pvr
│ │ │ └── park3_cube_nomip_4bpp_rgb.pvr
│ │ ├── crate_color8.tga
│ │ ├── fonts/
│ │ │ ├── msdf/
│ │ │ │ └── roboto-regular.fnt
│ │ │ └── typeface/
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── helvetiker_bold.typeface.json
│ │ │ ├── helvetiker_regular.typeface.json
│ │ │ ├── optimer_bold.typeface.json
│ │ │ └── optimer_regular.typeface.json
│ │ ├── hdr/
│ │ │ ├── Grand_Canyon_C.env
│ │ │ ├── Grand_Canyon_C.hdr
│ │ │ ├── blouberg_sunrise_2_1k.hdr
│ │ │ ├── hall.hdr
│ │ │ ├── memorial.exr
│ │ │ ├── memorial.hdr
│ │ │ ├── pisa.hdr
│ │ │ ├── pisaHDR/
│ │ │ │ ├── nx.hdr
│ │ │ │ ├── ny.hdr
│ │ │ │ ├── nz.hdr
│ │ │ │ ├── px.hdr
│ │ │ │ ├── py.hdr
│ │ │ │ └── pz.hdr
│ │ │ └── royal_esplanade_1k.env
│ │ ├── lensflare/
│ │ │ └── LICENSE.txt
│ │ ├── models/
│ │ │ ├── assimp/
│ │ │ │ ├── interior/
│ │ │ │ │ ├── interior.3ds
│ │ │ │ │ └── interior.assimp.json
│ │ │ │ └── jeep/
│ │ │ │ ├── jeep.assimp.json
│ │ │ │ ├── jeep1.ms3d
│ │ │ │ └── jeep1.readme.txt
│ │ │ ├── gltf/
│ │ │ │ ├── BotSkinned/
│ │ │ │ │ └── glTF-MaterialsUnlit/
│ │ │ │ │ └── Bot_Skinned.gltf
│ │ │ │ ├── CesiumMan/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── glTF/
│ │ │ │ │ │ └── CesiumMan.gltf
│ │ │ │ │ ├── glTF-Binary/
│ │ │ │ │ │ └── CesiumMan.glb
│ │ │ │ │ ├── glTF-Draco/
│ │ │ │ │ │ └── CesiumMan.gltf
│ │ │ │ │ └── glTF-Embedded/
│ │ │ │ │ └── CesiumMan.gltf
│ │ │ │ ├── ClearCoatTest.glb
│ │ │ │ ├── CornellBox.glb
│ │ │ │ ├── DamagedHelmet/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── DamagedHelmet.gltf
│ │ │ │ ├── DispersionTest.glb
│ │ │ │ ├── DragonAttenuation/
│ │ │ │ │ └── DragonAttenuation.gltf
│ │ │ │ ├── Duck/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── glTF/
│ │ │ │ │ │ └── Duck.gltf
│ │ │ │ │ ├── glTF-Binary/
│ │ │ │ │ │ └── Duck.glb
│ │ │ │ │ ├── glTF-Draco/
│ │ │ │ │ │ └── Duck.gltf
│ │ │ │ │ ├── glTF-Embedded/
│ │ │ │ │ │ └── Duck.gltf
│ │ │ │ │ └── glTF-pbrSpecularGlossiness/
│ │ │ │ │ └── Duck.gltf
│ │ │ │ ├── Flamingo.glb
│ │ │ │ ├── GlamVelvetSofa/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── glTF/
│ │ │ │ │ │ └── GlamVelvetSofa.gltf
│ │ │ │ │ └── glTF-Binary/
│ │ │ │ │ └── GlamVelvetSofa.glb
│ │ │ │ ├── IKTest.glb
│ │ │ │ ├── InterpolationTest.glb
│ │ │ │ ├── IridescentDishWithOlives.glb
│ │ │ │ ├── LeePerrySmith/
│ │ │ │ │ ├── LeePerrySmith.glb
│ │ │ │ │ └── LeePerrySmith_License.txt
│ │ │ │ ├── LittlestTokyo.glb
│ │ │ │ ├── Michelle.glb
│ │ │ │ ├── NormalTangentMirrorTest/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── NormalTangentMirrorTest.gltf
│ │ │ │ ├── NormalTangentTest/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── NormalTangentTest.gltf
│ │ │ │ ├── PointerTest.glb
│ │ │ │ ├── PrimaryIonDrive.glb
│ │ │ │ ├── Soldier.glb
│ │ │ │ ├── Spheres/
│ │ │ │ │ └── Spheres.gltf
│ │ │ │ ├── TextureTransformTest/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── TextureTransformTest.gltf
│ │ │ │ ├── UinoDog/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── robot.gltf
│ │ │ │ ├── UinoHelmet/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── UinoHelmet.gltf
│ │ │ │ ├── UinoMan/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── UinoMan.gltf
│ │ │ │ ├── UinoSpaceman/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── glTF/
│ │ │ │ │ │ └── UinoSpaceman.gltf
│ │ │ │ │ └── glTF-Binary/
│ │ │ │ │ └── UinoSpaceman.glb
│ │ │ │ ├── Xbot.glb
│ │ │ │ ├── asteroid.glb
│ │ │ │ ├── bust_of_woman/
│ │ │ │ │ ├── glTF/
│ │ │ │ │ │ └── bust_of_woman.gltf
│ │ │ │ │ └── glTF-Binary/
│ │ │ │ │ └── bust_of_woman.glb
│ │ │ │ ├── coffeemat.glb
│ │ │ │ ├── ferrari/
│ │ │ │ │ └── ferrari.glb
│ │ │ │ ├── forest_house.glb
│ │ │ │ ├── grass/
│ │ │ │ │ └── grass.gltf
│ │ │ │ ├── lighthouse.glb
│ │ │ │ ├── pool.glb
│ │ │ │ ├── robot_arm/
│ │ │ │ │ └── glTF/
│ │ │ │ │ ├── license.txt
│ │ │ │ │ └── scene.gltf
│ │ │ │ ├── sea_shell.glb
│ │ │ │ ├── suzanne/
│ │ │ │ │ └── suzanne.gltf
│ │ │ │ ├── teapots_galore/
│ │ │ │ │ └── teapots_galore.gltf
│ │ │ │ └── tree.glb
│ │ │ └── vox/
│ │ │ ├── castle.vox
│ │ │ ├── largedata.vox
│ │ │ ├── menger.vox
│ │ │ ├── monu1.vox
│ │ │ ├── monu10.vox
│ │ │ ├── monu9.vox
│ │ │ ├── p1.vox
│ │ │ ├── p2.vox
│ │ │ ├── p3.vox
│ │ │ ├── p4.vox
│ │ │ ├── p5.vox
│ │ │ ├── p6.vox
│ │ │ ├── p7.vox
│ │ │ └── ship.vox
│ │ ├── navigation/
│ │ │ ├── level.glb
│ │ │ └── level.nav.glb
│ │ ├── sintel.ogv
│ │ └── skybox/
│ │ ├── Bridge2/
│ │ │ └── readme.txt
│ │ ├── Park2/
│ │ │ └── readme.txt
│ │ ├── mp_cloud9/
│ │ │ ├── Cloud 9.nfo
│ │ │ ├── cloud9_bk.tga
│ │ │ ├── cloud9_dn.tga
│ │ │ ├── cloud9_ft.tga
│ │ │ ├── cloud9_lf.tga
│ │ │ ├── cloud9_rt.tga
│ │ │ ├── cloud9_up.tga
│ │ │ ├── license.txt
│ │ │ └── mp_cloud9.shader
│ │ └── skyboxsun25deg/
│ │ └── skyboxsun25degtest.txt
│ ├── scene_anchor.html
│ ├── scene_clippingplanes.html
│ ├── scene_fog.html
│ ├── scene_gamma_correction.html
│ ├── sprite_sprites.html
│ ├── stereo_anaglyph.html
│ ├── stereo_webvr_car.html
│ ├── stereo_webxr_vr_car.html
│ ├── text_bitmap.html
│ ├── text_bitmap_dynamic.html
│ ├── text_sdf.html
│ ├── text_sdf_dynamic.html
│ ├── text_typeface.html
│ ├── texture_2darray.html
│ ├── texture_3d.html
│ ├── texture_anisotropic.html
│ ├── texture_depth.html
│ ├── texture_generator_heatmap.html
│ ├── texture_generator_idwmap.html
│ ├── texture_integer.html
│ ├── texture_loader_compressed_dds.html
│ ├── texture_loader_compressed_pvr.html
│ ├── texture_loader_env.html
│ ├── texture_loader_exr.html
│ ├── texture_loader_hdr.html
│ ├── texture_loader_hdr_cube.html
│ ├── texture_loader_hdr_panorama.html
│ ├── texture_loader_imagebitmap.html
│ ├── texture_loader_ktx2.html
│ ├── texture_loader_tga.html
│ ├── texture_mipmap.html
│ ├── texture_video.html
│ ├── webgl_canvas_transparent.html
│ ├── webgl_clipculldistance.html
│ ├── webgl_contextlost.html
│ ├── webgl_depthfunc.html
│ ├── webgl_external_buffer.html
│ ├── webgl_external_texture.html
│ ├── webgl_helpers.html
│ ├── webgl_instanced_draw.html
│ ├── webgl_logarithmicDepthBuffer.html
│ ├── webgl_mesh_batch.html
│ ├── webgl_multi_draw.html
│ ├── webgl_polygonoffset.html
│ ├── webgl_primitive_restart.html
│ ├── webgl_query_occlusion.html
│ ├── webgl_query_occlusion_proxy.html
│ ├── webgl_query_timer.html
│ ├── webgl_renderinfo.html
│ ├── webgl_shader_compile.html
│ ├── webgl_shader_precompile.html
│ └── webgl_stencil.html
├── package.json
├── rollup.config.js
├── src/
│ ├── EventDispatcher.js
│ ├── animation/
│ │ ├── AnimationAction.js
│ │ ├── AnimationMixer.js
│ │ ├── KeyframeClip.js
│ │ ├── KeyframeInterpolants.js
│ │ ├── KeyframeTrack.js
│ │ ├── PropertyBindingMixer.js
│ │ └── tracks/
│ │ ├── BooleanKeyframeTrack.js
│ │ ├── ColorKeyframeTrack.js
│ │ ├── NumberKeyframeTrack.js
│ │ ├── QuaternionKeyframeTrack.js
│ │ ├── StringKeyframeTrack.js
│ │ └── VectorKeyframeTrack.js
│ ├── base.js
│ ├── const.js
│ ├── legacy.js
│ ├── loaders/
│ │ ├── FileLoader.js
│ │ ├── ImageLoader.js
│ │ ├── Loader.js
│ │ └── LoadingManager.js
│ ├── main.js
│ ├── math/
│ │ ├── Box2.js
│ │ ├── Box3.js
│ │ ├── Color3.js
│ │ ├── Color4.js
│ │ ├── Euler.js
│ │ ├── Frustum.js
│ │ ├── MathUtils.js
│ │ ├── Matrix3.js
│ │ ├── Matrix4.js
│ │ ├── Plane.js
│ │ ├── Quaternion.js
│ │ ├── Ray.js
│ │ ├── Sphere.js
│ │ ├── Spherical.js
│ │ ├── SphericalHarmonics3.js
│ │ ├── Triangle.js
│ │ ├── Vector2.js
│ │ ├── Vector3.js
│ │ └── Vector4.js
│ ├── render/
│ │ ├── LightingData.js
│ │ ├── LightingGroup.js
│ │ ├── PropertyMap.js
│ │ ├── RenderCollector.js
│ │ ├── RenderInfo.js
│ │ ├── RenderQueue.js
│ │ ├── RenderQueueLayer.js
│ │ ├── RenderStates.js
│ │ ├── SceneData.js
│ │ ├── ThinRenderer.js
│ │ └── passes/
│ │ ├── ShaderPostPass.js
│ │ └── ShadowMapPass.js
│ ├── resources/
│ │ ├── QuerySet.js
│ │ ├── Raycaster.js
│ │ ├── RenderBuffer.js
│ │ ├── Skeleton.js
│ │ ├── TransformUV.js
│ │ ├── fogs/
│ │ │ ├── Fog.js
│ │ │ └── FogExp2.js
│ │ ├── geometries/
│ │ │ ├── Attribute.js
│ │ │ ├── BoxGeometry.js
│ │ │ ├── Buffer.js
│ │ │ ├── CylinderGeometry.js
│ │ │ ├── Geometry.js
│ │ │ ├── PlaneGeometry.js
│ │ │ ├── SphereGeometry.js
│ │ │ └── TorusKnotGeometry.js
│ │ ├── materials/
│ │ │ ├── BasicMaterial.js
│ │ │ ├── DepthMaterial.js
│ │ │ ├── DistanceMaterial.js
│ │ │ ├── LambertMaterial.js
│ │ │ ├── LineMaterial.js
│ │ │ ├── Material.js
│ │ │ ├── PBR2Material.js
│ │ │ ├── PBRMaterial.js
│ │ │ ├── PhongMaterial.js
│ │ │ ├── PointsMaterial.js
│ │ │ └── ShaderMaterial.js
│ │ ├── projections/
│ │ │ ├── CameraProjection.js
│ │ │ ├── OrthographicProjection.js
│ │ │ └── PerspectiveProjection.js
│ │ ├── targets/
│ │ │ ├── OffscreenRenderTarget.js
│ │ │ ├── RenderTargetBase.js
│ │ │ └── ScreenRenderTarget.js
│ │ └── textures/
│ │ ├── Texture2D.js
│ │ ├── Texture2DArray.js
│ │ ├── Texture3D.js
│ │ ├── TextureBase.js
│ │ └── TextureCube.js
│ ├── scenes/
│ │ ├── Bone.js
│ │ ├── Camera.js
│ │ ├── Light.js
│ │ ├── Mesh.js
│ │ ├── Object3D.js
│ │ ├── Scene.js
│ │ ├── SkinnedMesh.js
│ │ └── lights/
│ │ ├── AmbientLight.js
│ │ ├── DirectionalLight.js
│ │ ├── DirectionalLightShadow.js
│ │ ├── HemisphereLight.js
│ │ ├── LightShadow.js
│ │ ├── PointLight.js
│ │ ├── PointLightShadow.js
│ │ ├── RectAreaLight.js
│ │ ├── SphericalHarmonicsLight.js
│ │ ├── SpotLight.js
│ │ └── SpotLightShadow.js
│ ├── shaders/
│ │ ├── ShaderChunk.js
│ │ ├── ShaderLib.js
│ │ ├── shaderChunk/
│ │ │ ├── alphaTest_frag.glsl
│ │ │ ├── alphaTest_pars_frag.glsl
│ │ │ ├── alphamap_frag.glsl
│ │ │ ├── alphamap_pars_frag.glsl
│ │ │ ├── alphamap_pars_vert.glsl
│ │ │ ├── alphamap_vert.glsl
│ │ │ ├── aoMap_frag.glsl
│ │ │ ├── aoMap_pars_frag.glsl
│ │ │ ├── aoMap_pars_vert.glsl
│ │ │ ├── aoMap_vert.glsl
│ │ │ ├── begin_frag.glsl
│ │ │ ├── begin_vert.glsl
│ │ │ ├── bsdfs.glsl
│ │ │ ├── bumpMap_pars_frag.glsl
│ │ │ ├── clearcoat_pars_frag.glsl
│ │ │ ├── clippingPlanes_frag.glsl
│ │ │ ├── clippingPlanes_pars_frag.glsl
│ │ │ ├── color_frag.glsl
│ │ │ ├── color_pars_frag.glsl
│ │ │ ├── color_pars_vert.glsl
│ │ │ ├── color_vert.glsl
│ │ │ ├── common_frag.glsl
│ │ │ ├── common_vert.glsl
│ │ │ ├── diffuseMap_frag.glsl
│ │ │ ├── diffuseMap_pars_frag.glsl
│ │ │ ├── diffuseMap_pars_vert.glsl
│ │ │ ├── diffuseMap_vert.glsl
│ │ │ ├── dithering_frag.glsl
│ │ │ ├── dithering_pars_frag.glsl
│ │ │ ├── emissiveMap_frag.glsl
│ │ │ ├── emissiveMap_pars_frag.glsl
│ │ │ ├── emissiveMap_pars_vert.glsl
│ │ │ ├── emissiveMap_vert.glsl
│ │ │ ├── encodings_frag.glsl
│ │ │ ├── encodings_pars_frag.glsl
│ │ │ ├── end_frag.glsl
│ │ │ ├── envMap_frag.glsl
│ │ │ ├── envMap_pars_frag.glsl
│ │ │ ├── envMap_pars_vert.glsl
│ │ │ ├── envMap_vert.glsl
│ │ │ ├── fog_frag.glsl
│ │ │ ├── fog_pars_frag.glsl
│ │ │ ├── inverse.glsl
│ │ │ ├── light_frag.glsl
│ │ │ ├── light_pars_frag.glsl
│ │ │ ├── logdepthbuf_frag.glsl
│ │ │ ├── logdepthbuf_pars_frag.glsl
│ │ │ ├── logdepthbuf_pars_vert.glsl
│ │ │ ├── logdepthbuf_vert.glsl
│ │ │ ├── modelPos_pars_frag.glsl
│ │ │ ├── modelPos_pars_vert.glsl
│ │ │ ├── modelPos_vert.glsl
│ │ │ ├── morphnormal_vert.glsl
│ │ │ ├── morphtarget_pars_vert.glsl
│ │ │ ├── morphtarget_vert.glsl
│ │ │ ├── normalMap_pars_frag.glsl
│ │ │ ├── normal_frag.glsl
│ │ │ ├── normal_pars_frag.glsl
│ │ │ ├── normal_pars_vert.glsl
│ │ │ ├── normal_vert.glsl
│ │ │ ├── packing.glsl
│ │ │ ├── premultipliedAlpha_frag.glsl
│ │ │ ├── pvm_vert.glsl
│ │ │ ├── shadow.glsl
│ │ │ ├── shadowMap_frag.glsl
│ │ │ ├── shadowMap_pars_frag.glsl
│ │ │ ├── shadowMap_pars_vert.glsl
│ │ │ ├── shadowMap_vert.glsl
│ │ │ ├── skinning_pars_vert.glsl
│ │ │ ├── skinning_vert.glsl
│ │ │ ├── skinnormal_vert.glsl
│ │ │ ├── specularMap_frag.glsl
│ │ │ ├── specularMap_pars_frag.glsl
│ │ │ ├── transpose.glsl
│ │ │ ├── tsn.glsl
│ │ │ ├── uv_pars_frag.glsl
│ │ │ ├── uv_pars_vert.glsl
│ │ │ └── uv_vert.glsl
│ │ └── shaderLib/
│ │ ├── basic_frag.glsl
│ │ ├── basic_vert.glsl
│ │ ├── depth_frag.glsl
│ │ ├── depth_vert.glsl
│ │ ├── distance_frag.glsl
│ │ ├── distance_vert.glsl
│ │ ├── lambert_frag.glsl
│ │ ├── lambert_vert.glsl
│ │ ├── normaldepth_frag.glsl
│ │ ├── normaldepth_vert.glsl
│ │ ├── pbr2_frag.glsl
│ │ ├── pbr_frag.glsl
│ │ ├── pbr_vert.glsl
│ │ ├── phong_frag.glsl
│ │ ├── phong_vert.glsl
│ │ ├── point_frag.glsl
│ │ └── point_vert.glsl
│ └── webgl/
│ ├── WebGLAttribute.js
│ ├── WebGLBuffers.js
│ ├── WebGLCapabilities.js
│ ├── WebGLClusteredLighting.js
│ ├── WebGLConstants.js
│ ├── WebGLGeometries.js
│ ├── WebGLLights.js
│ ├── WebGLMaterials.js
│ ├── WebGLProgram.js
│ ├── WebGLPrograms.js
│ ├── WebGLQuerySets.js
│ ├── WebGLRenderBuffers.js
│ ├── WebGLRenderTargets.js
│ ├── WebGLRenderer.js
│ ├── WebGLState.js
│ ├── WebGLTextures.js
│ ├── WebGLUniforms.js
│ └── WebGLVertexArrayBindings.js
├── tests/
│ ├── index.html
│ └── unit/
│ ├── source.unit.js
│ ├── src/
│ │ ├── EventDispatcher.tests.js
│ │ └── math/
│ │ ├── Box2.tests.js
│ │ ├── Box3.tests.js
│ │ ├── Color3.tests.js
│ │ ├── Color4.tests.js
│ │ ├── MathUtils.tests.js
│ │ ├── Matrix3.tests.js
│ │ ├── Matrix4.tests.js
│ │ ├── Plane.tests.js
│ │ ├── Quaternion.tests.js
│ │ ├── Ray.tests.js
│ │ ├── Sphere.tests.js
│ │ ├── Vector2.tests.js
│ │ ├── Vector3.tests.js
│ │ └── Vector4.tests.js
│ └── utils/
│ └── math-constants.js
└── tools/
├── assimp2json
└── doc.config.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
# http://editorconfig.org
root = true
[*]
end_of_line = lf
insert_final_newline = false
[*.{js,ts,html}]
charset = utf-8
indent_style = tab
indent_size = 4
[*.{js,ts}]
trim_trailing_whitespace = true
================================================
FILE: .gitattributes
================================================
# Set the default behavior, in case people don't have core.autocrlf set.
* text=auto
================================================
FILE: .github/contributing.md
================================================
# t3d.js Contributing Guide
## Issue Reporting Guidelines
Welcome to use [Github](https://github.com/uinosoft/t3d.js/issues) to report a issues, request a feature, or ask a question.
## Pull Request Guidelines
- Don't send PRs to the `master` branch, send them to the `dev` branch instead.
- Make sure your code lints (`npm run lint` ...).
- Branch naming convention: use kebab naming, and start with `build|ci|docs|feat|fix|perf|refactor|test`, for example: `refactor-addons-pmrem`.
- It's OK to have multiple small commits as you work on the PR - GitHub can automatically squash them before merging.
## Development Setup
You will need [Node.js](https://nodejs.org), and NPM (which comes with Node.js) installed on your computer.
After cloning the repository, run `npm install` to install all dependencies.
## Scripts
- `npm run build` - Build the core library to `build/t3d.js` and `build/t3d.module.js`
- `npm run dev` - This will watch the source files and rebuild the library whenever they change
- `npm run doc` - This will build the api documentation to `docs/`
- `npm run lint` - This will lint the source files using ESLint
- `npm run server` - This will start a local server where you can view the examples or docs
## Git Commit Message Convention
Currently follows [Angular's commit convention](https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit).
## Code Formatting
Currently, we use eslint to perform code specification and style checks to ensure code uniformity.
You can use npm scripts to lint the code, but it is more recommended to use an editor plug-in for automatic code formatting.
If you use VSCode, you can install the [ESLint](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint) plug-in and enable the auto-fix option in the settings:
````json
{
"editor.codeActionsOnSave": {
"source.fixAll.eslint": true
}
}
````
## Naming Conventions
- Variable names use camelCase notation, for example: `camera`, `renderer`.
- Class file name, class name uses camel case nomenclature, for example: `OrbitControls.js`, `OrbitControls`.
- Use kebab naming for folder names, for example: `kebab`, `kebab-case`.
## Comments
We use [JSDoc](https://jsdoc.app/) to generate api documentation, so all the public methods and properties should be documented with JSDoc.
## Project Structure
A overview of project structure:
```bash
├─ 📁 .github/ # Github related files
│ ├─ 📁 workflows/ # Github ci workflows
| ├─ 📄 contributing.md # Contributing guide
├─ 📁 build/ # Build output
├─ 📁 docs/ # Documentation output (not tracked by git)
├─ 📁 examples/ # Examples
│ ├─ 📁 jsm/ # Addons for t3d.js, exported to `t3d/addons/`
├─ 📂 node_modules/ # Dependencies (not tracked by git)
│ ├─ 📁 rollup # Rollup dependencies
│ └─ 📁 ... # Other dependencies (@eslint, @jsdoc, etc.)
├─ 📁 src/ # Source code for core package
│ ├─ 📁 ... # The core source files in sub category
│ ├─ 📄 main.js # The entry root, export all modules from /src
├─ 📁 tests/ # Tests
├─ 📁 tools/ # Some build tools
│ ├─ 📄 doc.config.json # JSDoc config
│ ├─ 📄 ... # Other tools
├─ 📄 .editorconfig # Editor config
├─ 📄 .eslintrc.cjs # ESLint config
├─ 📄 .gitignore # Git ignore
├─ 📄 icon.jpg # Icon for t3d.js
├─ 📄 LICENSE # License
├─ 📄 package.json # Package.json for core package
├─ 📄 README.md # Readme
└─ 📄 rollup.config.js # Rollup config
```
## Credits
Thank you to all the people who have already contributed to t3d.js!
<a href="https://github.com/uinosoft/t3d.js/graphs/contributors">
<img src="https://contrib.rocks/image?repo=uinosoft/t3d.js" />
</a>
================================================
FILE: .github/workflows/deploy-to-pages.yml
================================================
name: Deploy examples and docs to Pages
on:
push:
branches: ['dev']
paths-ignore:
- 'build/**'
workflow_dispatch:
permissions:
contents: read
pages: write
id-token: write
concurrency:
group: 'pages'
cancel-in-progress: true
jobs:
build:
name: 'Build job'
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Setup Node
uses: actions/setup-node@v4
with:
node-version: 20
cache: 'npm'
- name: Install Packages
run: npm ci
- name: Build Docs
run: npm run doc
- name: Setup Pages
uses: actions/configure-pages@v5
- name: Upload artifact
uses: actions/upload-pages-artifact@v3
with:
path: '.'
deploy:
environment:
name: github-pages
url: ${{ steps.deployment.outputs.page_url }}
runs-on: ubuntu-latest
needs: build
steps:
- name: Deploy to GitHub Pages
id: deployment
uses: actions/deploy-pages@v4
================================================
FILE: .gitignore
================================================
.DS_Store
*.swp
# Editor directories and files
.vscode/*
!.vscode/extensions.json
.idea
.project
*.suo
*.ntvs*
*.njsproj
*.sln
*.user
.vs/
*.sw?
# Logs
npm-debug.log
/docs
**/node_modules
*.local
.jshintrc
================================================
FILE: .vscode/extensions.json
================================================
{
"recommendations": [
"dbaeumer.vscode-eslint"
]
}
================================================
FILE: LICENSE
================================================
BSD 3-Clause License
Copyright (c) 2021-present, uino
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: README.md
================================================
# ThingJS 3D Engine
[![NPM Package][npm]][npm-url]
![npm-size][npm-size-url]
[![Issues][issues-badge]][issues-badge-url]
[![DeepScan grade][deepscan]][deepscan-url]
[![Discord][discord]][discord-url]
[](https://deepwiki.com/uinosoft/t3d.js)
ThingJS 3D Engine (t3d) is a lightweight, web-first, and extendable 3D rendering library. It is used by ThingJS for web3d rendering, but can also be used as a standalone library.
t3d's API borrows the look and feel of three.js—familiar and easy to use—but it is not fully compatible or a drop-in replacement. It keeps a simple, flexible design while adding modern features and extra hooks for real‑time workflows, such as customizable rendering callbacks for finer control and post‑processing, clustered lighting for scalable many‑light scenes, light groups for organizing reusable lights, and other performance-minded optimizations.
[Examples](https://uinosoft.github.io/t3d.js/examples/) —
[Docs](https://uinosoft.github.io/t3d.js/docs/) —
[Discord](https://discord.gg/urB54PPXc4)
## Import
Use `t3d.js` or `t3d.min.js` in your page:
````html
<script src="t3d.min.js"></script>
````
or import as es6 module:
````javascript
import * as t3d from 't3d.module.js';
````
## Npm
t3d is published on npm. To install, use:
````
npm install t3d --save
````
This will allow you to import t3d entirely using:
````javascript
import * as t3d from 't3d';
````
or individual classes using:
````javascript
import { Scene, Renderer } from 't3d';
````
Since v0.2.0, the JavaScript files in `examples/jsm` can be imported like this:
````javascript
import { OrbitControls } from 't3d/addons/controls/OrbitControls.js';
````
## CDN
* https://unpkg.com/t3d@latest/build/t3d.min.js
* https://unpkg.com/t3d@latest/build/t3d.module.js
* https://cdn.jsdelivr.net/npm/t3d@latest/build/t3d.min.js
* https://cdn.jsdelivr.net/npm/t3d@latest/build/t3d.module.min.js
## Quick Start
Create a simple rotating cube with PBR materials:
````javascript
// Initialize renderer with WebGL2
const width = window.innerWidth || 2;
const height = window.innerHeight || 2;
const canvas = document.createElement('canvas');
canvas.width = width;
canvas.height = height;
document.body.appendChild(canvas);
// Create WebGL2 context and renderer
const gl = canvas.getContext('webgl2', {
antialias: true,
alpha: false
});
const renderer = new t3d.WebGLRenderer(gl);
const screenRenderTarget = new t3d.ScreenRenderTarget(canvas);
screenRenderTarget.setColorClearValue(0.1, 0.1, 0.1, 1);
// Create scene
const scene = new t3d.Scene();
// Create mesh with PBR material
const geometry = new t3d.BoxGeometry(8, 8, 8);
const material = new t3d.PBRMaterial();
const mesh = new t3d.Mesh(geometry, material);
scene.add(mesh);
// Add lighting
const ambientLight = new t3d.AmbientLight(0xffffff);
scene.add(ambientLight);
const directionalLight = new t3d.DirectionalLight(0xffffff);
directionalLight.position.set(-5, 5, 5);
directionalLight.lookAt(new t3d.Vector3(), new t3d.Vector3(0, 1, 0));
scene.add(directionalLight);
// Set up camera
const camera = new t3d.Camera();
camera.position.set(0, 10, 30);
camera.lookAt(new t3d.Vector3(0, 0, 0), new t3d.Vector3(0, 1, 0));
camera.setPerspective(45 / 180 * Math.PI, width / height, 1, 1000);
scene.add(camera);
// Animation loop
function loop(count) {
requestAnimationFrame(loop);
// Rotate cube
mesh.euler.y = count / 1000 * .5;
scene.updateMatrix();
scene.updateRenderStates(camera);
scene.updateRenderQueue(camera);
renderer.renderScene(scene, camera, screenRenderTarget);
}
requestAnimationFrame(loop);
````
## Extensions
* [t3d-effect-composer](https://github.com/uinosoft/t3d-effect-composer) - Post Effects extension for t3d.js.
* [t3d-particle](https://github.com/uinosoft/t3d-particle) - This is a particle system developed based on t3d.js.
* [t3d-pano](https://github.com/uinosoft/t3d-pano) - Panorama extension for t3d.
* [t3d-3dtiles](https://github.com/uinosoft/t3d-3dtiles) - A 3dtile extension based on t3d.js.
* [t3d-dynamic-sky](https://github.com/uinosoft/t3d-dynamic-sky) - Dynamic sky addon for t3d.
* [t3d-gaussian-splatting](https://github.com/uinosoft/t3d-gaussian-splatting) - A t3d-based implementation of 3D Gaussian Splatting.
## Tools
* [t3d-model-viewer](https://uinosoft.github.io/t3d-model-viewer/) - A Model Viewer based on t3d.js and t3d-effect-composer.
* [t3d-particle-editor](https://uinosoft.github.io/t3d-particle/editor) - A particle editor based on t3d.js and t3d-particle.
* [t3d-ibl-baker](https://uinosoft.github.io/t3d-ibl-baker/) - This is a simple tool to bake IBL maps for t3d.
## Contributing
Please make sure to read the [Contributing Guide](./.github/contributing.md) before making a pull request.
[npm]: https://img.shields.io/npm/v/t3d
[npm-url]: https://www.npmjs.com/package/t3d
[npm-size-url]: https://img.shields.io/bundlephobia/minzip/t3d
[issues-badge]: https://img.shields.io/github/issues/uinosoft/t3d.js.svg
[issues-badge-url]: https://github.com/uinosoft/t3d.js/issues
[deepscan]: https://deepscan.io/api/teams/20241/projects/25542/branches/800776/badge/grade.svg
[deepscan-url]: https://deepscan.io/dashboard#view=project&tid=20241&pid=25542&bid=800776
[discord]: https://img.shields.io/discord/1069800954494464043
[discord-url]: https://discord.gg/urB54PPXc4
================================================
FILE: build/t3d.js
================================================
/**
* @license
* Copyright 2021-present uino
* SPDX-License-Identifier: BSD-3-Clause
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.t3d = {}));
})(this, (function (exports) { 'use strict';
/**
* An utility class for mathematical operations.
*/
class MathUtils {
/**
* Method for generate uuid.
* http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
* @returns {string} - The uuid.
*/
static generateUUID() {
const d0 = Math.random() * 0xffffffff | 0;
const d1 = Math.random() * 0xffffffff | 0;
const d2 = Math.random() * 0xffffffff | 0;
const d3 = Math.random() * 0xffffffff | 0;
const 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();
}
/**
* Returns a value linearly interpolated from two known points based on the given interval - t = 0 will return x and t = 1 will return y.
* @param {number} x - The first value.
* @param {number} y - The second value.
* @param {number} t - The interpolation factor.
* @returns {number} - The interpolated value.
*/
static lerp(x, y, t) {
return x + (y - x) * t;
}
/**
* Clamps the value to be between min and max.
* @param {number} value - Value to be clamped.
* @param {number} min - The minimum value.
* @param {number} max - The maximum value.
* @returns {number} - The clamped value.
*/
static clamp(value, min, max) {
return Math.max(min, Math.min(max, value));
}
/**
* Compute euclidean modulo of m % n.
* Refer to: https://en.wikipedia.org/wiki/Modulo_operation
* @param {number} n - The dividend.
* @param {number} m - The divisor.
* @returns {number} - The result of the modulo operation.
*/
static euclideanModulo(n, m) {
return (n % m + m) % m;
}
/**
* Performs a linear mapping from range `<a1, a2>` to range `<b1, b2>`
* for the given value.
* @param {number} x - The value to be mapped.
* @param {number} a1 - Minimum value for range A.
* @param {number} a2 - Maximum value for range A.
* @param {number} b1 - Minimum value for range B.
* @param {number} b2 - Maximum value for range B.
* @returns {number} The mapped value.
*/
static mapLinear(x, a1, a2, b1, b2) {
return b1 + (x - a1) * (b2 - b1) / (a2 - a1);
}
/**
* Is this number a power of two.
* @param {number} value - The input number.
* @returns {boolean} - Is this number a power of two.
*/
static isPowerOfTwo(value) {
return (value & value - 1) === 0 && value !== 0;
}
/**
* Return the nearest power of two number of this number.
* @param {number} value - The input number.
* @returns {number} - The result number.
*/
static nearestPowerOfTwo(value) {
return Math.pow(2, Math.round(Math.log(value) / Math.LN2));
}
/**
* Return the next power of two number of this number.
* @param {number} value - The input number.
* @returns {number} - The result number.
*/
static nextPowerOfTwo(value) {
value--;
value |= value >> 1;
value |= value >> 2;
value |= value >> 4;
value |= value >> 8;
value |= value >> 16;
value++;
return value;
}
/**
* Return the next power of two square size of this number.
* This method is usually used to calculate the minimum 2d texture size based on the pixel length.
* @param {number} value - The input number.
* @returns {number} - The result size.
*/
static nextPowerOfTwoSquareSize(value) {
return this.nextPowerOfTwo(Math.ceil(Math.sqrt(value)));
}
/**
* Denormalizes a value based on the type of the provided array.
* @param {number} value - The value to be denormalized.
* @param {TypedArray} array - The typed array to determine the normalization factor.
* @returns {number} - The denormalized value.
* @throws {Error} - Throws an error if the array type is invalid.
*/
static denormalize(value, array) {
switch (array.constructor) {
case Float32Array:
return value;
case Uint32Array:
return value / 4294967295.0;
case Uint16Array:
return value / 65535.0;
case Uint8Array:
return value / 255.0;
case Int32Array:
return Math.max(value / 2147483647.0, -1);
case Int16Array:
return Math.max(value / 32767.0, -1);
case Int8Array:
return Math.max(value / 127.0, -1);
default:
throw new Error('Invalid component type.');
}
}
/**
* Normalizes a value based on the type of the provided array.
* @param {number} value - The value to be normalized.
* @param {TypedArray} array - The typed array to determine the normalization factor.
* @returns {number} - The normalized value.
* @throws {Error} - Throws an error if the array type is invalid.
*/
static normalize(value, array) {
switch (array.constructor) {
case Float32Array:
return value;
case Uint32Array:
return Math.round(value * 4294967295.0);
case Uint16Array:
return Math.round(value * 65535.0);
case Uint8Array:
return Math.round(value * 255.0);
case Int32Array:
return Math.round(value * 2147483647.0);
case Int16Array:
return Math.round(value * 32767.0);
case Int8Array:
return Math.round(value * 127.0);
default:
throw new Error('Invalid component type.');
}
}
/**
* Converts float to half float.
* @param {number} val - The float value.
* @returns {number} - The half float value.
*/
static toHalfFloat(val) {
if (Math.abs(val) > 65504) {
console.warn('MathUtils.toHalfFloat(): Value out of range.');
val = this.clamp(val, -65504, 65504);
}
_tables.floatView[0] = val;
const f = _tables.uint32View[0];
const e = f >> 23 & 0x1ff;
return _tables.baseTable[e] + ((f & 0x007fffff) >> _tables.shiftTable[e]);
}
/**
* Converts half float to float.
* @param {number} val - The half float value.
* @returns {number} - The float value.
*/
static fromHalfFloat(val) {
const m = val >> 10;
_tables.uint32View[0] = _tables.mantissaTable[_tables.offsetTable[m] + (val & 0x3ff)] + _tables.exponentTable[m];
return _tables.floatView[0];
}
}
const _lut = [];
for (let i = 0; i < 256; i++) {
_lut[i] = (i < 16 ? '0' : '') + i.toString(16);
}
// Fast Half Float Conversions, http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
const _tables = _generateTables();
function _generateTables() {
// float32 to float16 helpers
const buffer = new ArrayBuffer(4);
const floatView = new Float32Array(buffer);
const uint32View = new Uint32Array(buffer);
const baseTable = new Uint32Array(512);
const shiftTable = new Uint32Array(512);
for (let i = 0; i < 256; ++i) {
const e = i - 127;
if (e < -27) {
// very small number (0, -0)
baseTable[i] = 0x0000;
baseTable[i | 0x100] = 0x8000;
shiftTable[i] = 24;
shiftTable[i | 0x100] = 24;
} else if (e < -14) {
// small number (denorm)
baseTable[i] = 0x0400 >> -e - 14;
baseTable[i | 0x100] = 0x0400 >> -e - 14 | 0x8000;
shiftTable[i] = -e - 1;
shiftTable[i | 0x100] = -e - 1;
} else if (e <= 15) {
// normal number
baseTable[i] = e + 15 << 10;
baseTable[i | 0x100] = e + 15 << 10 | 0x8000;
shiftTable[i] = 13;
shiftTable[i | 0x100] = 13;
} else if (e < 128) {
// large number (Infinity, -Infinity)
baseTable[i] = 0x7c00;
baseTable[i | 0x100] = 0xfc00;
shiftTable[i] = 24;
shiftTable[i | 0x100] = 24;
} else {
// stay (NaN, Infinity, -Infinity)
baseTable[i] = 0x7c00;
baseTable[i | 0x100] = 0xfc00;
shiftTable[i] = 13;
shiftTable[i | 0x100] = 13;
}
}
// float16 to float32 helpers
const mantissaTable = new Uint32Array(2048);
const exponentTable = new Uint32Array(64);
const offsetTable = new Uint32Array(64);
for (let i = 1; i < 1024; ++i) {
let m = i << 13; // zero pad mantissa bits
let e = 0; // zero exponent
// normalized
while ((m & 0x00800000) === 0) {
m <<= 1;
e -= 0x00800000; // decrement exponent
}
m &= -8388609; // clear leading 1 bit
e += 0x38800000; // adjust bias
mantissaTable[i] = m | e;
}
for (let i = 1024; i < 2048; ++i) {
mantissaTable[i] = 0x38000000 + (i - 1024 << 13);
}
for (let i = 1; i < 31; ++i) {
exponentTable[i] = i << 23;
}
exponentTable[31] = 0x47800000;
exponentTable[32] = 0x80000000;
for (let i = 33; i < 63; ++i) {
exponentTable[i] = 0x80000000 + (i - 32 << 23);
}
exponentTable[63] = 0xc7800000;
for (let i = 1; i < 64; ++i) {
if (i !== 32) {
offsetTable[i] = 1024;
}
}
return {
floatView: floatView,
uint32View: uint32View,
baseTable: baseTable,
shiftTable: shiftTable,
mantissaTable: mantissaTable,
exponentTable: exponentTable,
offsetTable: offsetTable
};
}
/**
* Class representing a 3D vector.
*/
class Vector3 {
/**
* Constructs a new 3D vector.
* @param {number} [x=0] - The x value of this vector.
* @param {number} [y=0] - The y value of this vector.
* @param {number} [z=0] - The z value of this vector.
*/
constructor(x = 0, y = 0, z = 0) {
/**
* The x value of this vector.
* @type {number}
*/
this.x = x;
/**
* The y value of this vector.
* @type {number}
*/
this.y = y;
/**
* The z value of this vector.
* @type {number}
*/
this.z = z;
}
/**
* Sets the vector components.
* @param {number} x - The value of the x component.
* @param {number} y - The value of the y component.
* @param {number} z - The value of the z component.
* @returns {Vector3} A reference to this vector.
*/
set(x = 0, y = 0, z = 0) {
this.x = x;
this.y = y;
this.z = z;
return this;
}
/**
* Sets the vector components to the same value.
* @param {number} scalar - The value to set for all vector components.
* @returns {Vector3} A reference to this vector.
*/
setScalar(scalar) {
this.x = scalar;
this.y = scalar;
this.z = scalar;
return this;
}
/**
* Returns a new vector with copied values from this instance.
* @returns {Vector3} A clone of this instance.
*/
clone() {
return new Vector3(this.x, this.y, this.z);
}
/**
* Copies the values of the given vector to this instance.
* @param {Vector3} v - The vector to copy.
* @returns {Vector3} A reference to this vector.
*/
copy(v) {
this.x = v.x;
this.y = v.y;
this.z = v.z;
return this;
}
/**
* Adds the given vector to this instance.
* @param {Vector3} v - The vector to add.
* @returns {Vector3} A reference to this vector.
*/
add(v) {
this.x += v.x;
this.y += v.y;
this.z += v.z;
return this;
}
/**
* Adds the given scalar value to all components of this instance.
* @param {number} s - The scalar to add.
* @returns {Vector3} A reference to this vector.
*/
addScalar(s) {
this.x += s;
this.y += s;
this.z += s;
return this;
}
/**
* Adds the given vectors and stores the result in this instance.
* @param {Vector3} a - The first vector.
* @param {Vector3} b - The second vector.
* @returns {Vector3} A reference to this vector.
*/
addVectors(a, b) {
this.x = a.x + b.x;
this.y = a.y + b.y;
this.z = a.z + b.z;
return this;
}
/**
* Adds the given vector scaled by the given factor to this instance.
* @param {Vector3|Vector4} v - The vector.
* @param {number} s - The factor that scales `v`.
* @returns {Vector3} A reference to this vector.
*/
addScaledVector(v, s) {
this.x += v.x * s;
this.y += v.y * s;
this.z += v.z * s;
return this;
}
/**
* Subtracts the given vector from this instance.
* @param {Vector3} v - The vector to subtract.
* @returns {Vector3} A reference to this vector.
*/
sub(v) {
this.x -= v.x;
this.y -= v.y;
this.z -= v.z;
return this;
}
/**
* Subtracts the given vectors and stores the result in this instance.
* @param {Vector3} a - The first vector.
* @param {Vector3} b - The second vector.
* @returns {Vector3} A reference to this vector.
*/
subVectors(a, b) {
this.x = a.x - b.x;
this.y = a.y - b.y;
this.z = a.z - b.z;
return this;
}
/**
* Multiplies the given vector with this instance.
* @param {Vector3} v - The vector to multiply.
* @returns {Vector3} A reference to this vector.
*/
multiply(v) {
this.x *= v.x;
this.y *= v.y;
this.z *= v.z;
return this;
}
/**
* Multiplies the given scalar value with all components of this instance.
* @param {number} scalar - The scalar to multiply.
* @returns {Vector3} A reference to this vector.
*/
multiplyScalar(scalar) {
this.x *= scalar;
this.y *= scalar;
this.z *= scalar;
return this;
}
/**
* Multiplies this vector with the given 3x3 matrix.
* @param {Matrix3} m - The 3x3 matrix.
* @returns {Vector3} A reference to this vector.
*/
applyMatrix3(m) {
const x = this.x,
y = this.y,
z = this.z;
const 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;
}
/**
* Multiplies this vector (with an implicit 1 in the 4th dimension) by m, and
* divides by perspective.
* @param {Matrix4} m - The matrix to apply.
* @returns {Vector3} A reference to this vector.
*/
applyMatrix4(m) {
const x = this.x,
y = this.y,
z = this.z;
const e = m.elements;
const 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;
}
/**
* Applies the given Quaternion to this vector.
* @param {Quaternion} q - The Quaternion.
* @returns {Vector3} A reference to this vector.
*/
applyQuaternion(q) {
const x = this.x,
y = this.y,
z = this.z;
const qx = q._x,
qy = q._y,
qz = q._z,
qw = q._w;
// calculate quat * vector
const ix = qw * x + qy * z - qz * y;
const iy = qw * y + qz * x - qx * z;
const iz = qw * z + qx * y - qy * x;
const 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;
}
/**
* Projects this vector from world space into the camera's normalized
* device coordinate (NDC) space.
* @param {Camera} camera - The camera.
* @returns {Vector3} A reference to this vector.
*/
project(camera) {
return this.applyMatrix4(camera.projectionViewMatrix);
}
/**
* Unprojects this vector from the camera's normalized device coordinate (NDC)
* space into world space.
* @param {Camera} camera - The camera.
* @returns {Vector3} A reference to this vector.
*/
unproject(camera) {
return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.worldMatrix);
}
/**
* Transforms the direction of this vector by a matrix (the upper left 3 x 3
* subset of the given 4x4 matrix and then normalizes the result.
* @param {Matrix4} m - The matrix.
* @returns {Vector3} A reference to this vector.
*/
transformDirection(m) {
// input: Matrix4 affine matrix
// vector interpreted as a direction
const x = this.x,
y = this.y,
z = this.z;
const 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();
}
/**
* If this vector's x, y or z value is greater than the given vector's x, y or z
* value, replace that value with the corresponding min value.
* @param {Vector3} v - The vector.
* @returns {Vector3} A reference to this vector.
*/
min(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;
}
/**
* If this vector's x, y or z value is less than the given vector's x, y or z
* value, replace that value with the corresponding max value.
* @param {Vector3} v - The vector.
* @returns {Vector3} A reference to this vector.
*/
max(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;
}
/**
* Inverts this vector - i.e. sets x = -x, y = -y and z = -z.
* @returns {Vector3} A reference to this vector.
*/
negate() {
this.x = -this.x;
this.y = -this.y;
this.z = -this.z;
return this;
}
/**
* Calculates the dot product of the given vector with this instance.
* @param {Vector3} v - The vector to compute the dot product with.
* @returns {number} The result of the dot product.
*/
dot(v) {
return this.x * v.x + this.y * v.y + this.z * v.z;
}
/**
* Computes the square of the Euclidean length (straight-line length) from
* (0, 0, 0) to (x, y, z). If you are comparing the lengths of vectors, you should
* compare the length squared instead as it is slightly more efficient to calculate.
* @returns {number} The square length of this vector.
*/
getLengthSquared() {
return this.x * this.x + this.y * this.y + this.z * this.z;
}
/**
* Computes the Euclidean length (straight-line length) from (0, 0, 0) to (x, y, z).
* @returns {number} The length of this vector.
*/
getLength() {
return Math.sqrt(this.getLengthSquared());
}
/**
* Converts this vector to a unit vector - that is, sets it equal to a vector
* with the same direction as this one, but with a vector length of `1`.
* @param {number} [thickness=1]
* @returns {Vector3} A reference to this vector.
*/
normalize(thickness = 1) {
const length = this.getLength() || 1;
const invLength = thickness / length;
this.x *= invLength;
this.y *= invLength;
this.z *= invLength;
return this;
}
/**
* Linearly interpolates between the given vector and this instance, where
* alpha is the percent distance along the line - alpha = 0 will be this
* vector, and alpha = 1 will be the given one.
* @param {Vector3} v - The vector to interpolate towards.
* @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
* @returns {Vector3} A reference to this vector.
*/
lerp(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;
}
/**
* Linearly interpolates between the given vectors, where alpha is the percent
* distance along the line - alpha = 0 will be first vector, and alpha = 1 will
* be the second one. The result is stored in this instance.
* @param {Vector3} v1 - The first vector.
* @param {Vector3} v2 - The second vector.
* @param {number} alpha - The interpolation factor, typically in the closed interval `[0, 1]`.
* @returns {Vector3} A reference to this vector.
*/
lerpVectors(v1, v2, alpha) {
this.x = v1.x + (v2.x - v1.x) * alpha;
this.y = v1.y + (v2.y - v1.y) * alpha;
this.z = v1.z + (v2.z - v1.z) * alpha;
return this;
}
/**
* Calculates the cross product of the given vector with this instance.
* @param {Vector3} v - The vector to compute the cross product with.
* @returns {Vector3} The result of the cross product.
*/
cross(v) {
return this.crossVectors(this, v);
}
/**
* Calculates the cross product of the given vectors and stores the result
* in this instance.
* @param {Vector3} a - The first vector.
* @param {Vector3} b - The second vector.
* @returns {Vector3} A reference to this vector.
*/
crossVectors(a, b) {
const ax = a.x,
ay = a.y,
az = a.z;
const 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;
}
/**
* Reflects this vector off a plane orthogonal to the given normal vector.
* @param {Vector3} normal - The (normalized) normal vector.
* @returns {Vector3} A reference to this vector.
*/
reflect(normal) {
return this.sub(_vector$2.copy(normal).multiplyScalar(2 * this.dot(normal)));
}
/**
* Scales this vector along the given direction vector by the given scale factor.
* @param {Vector3} direction - The (normalized) direction vector to scale along.
* @param {number} scale - The scale factor.
* @returns {Vector3} A reference to this vector.
*/
scaleAlong(direction, scale) {
_vector$2.copy(direction).multiplyScalar(this.dot(direction));
return this.sub(_vector$2).addScaledVector(_vector$2, scale);
}
/**
* Returns the angle between the given vector and this instance in radians.
* @param {Vector3} v - The vector to compute the angle with.
* @returns {number} The angle in radians.
*/
angleTo(v) {
const denominator = Math.sqrt(this.getLengthSquared() * v.getLengthSquared());
if (denominator === 0) return Math.PI / 2;
const theta = this.dot(v) / denominator;
// clamp, to handle numerical problems
return Math.acos(MathUtils.clamp(theta, -1, 1));
}
/**
* Computes the distance from the given vector to this instance.
* @param {Vector3} v - The vector to compute the distance to.
* @returns {number} The distance.
*/
distanceTo(v) {
return Math.sqrt(this.distanceToSquared(v));
}
/**
* Computes the squared distance from the given vector to this instance.
* If you are just comparing the distance with another distance, you should compare
* the distance squared instead as it is slightly more efficient to calculate.
* @param {Vector3} v - The vector to compute the squared distance to.
* @returns {number} The squared distance.
*/
distanceToSquared(v) {
const dx = this.x - v.x,
dy = this.y - v.y,
dz = this.z - v.z;
return dx * dx + dy * dy + dz * dz;
}
/**
* Sets the vector components from the given spherical coordinates.
* @param {Spherical} s - The spherical coordinates.
* @returns {Vector3} A reference to this vector.
*/
setFromSpherical(s) {
const sinPhiRadius = Math.sin(s.phi) * s.radius;
this.x = sinPhiRadius * Math.sin(s.theta);
this.y = Math.cos(s.phi) * s.radius;
this.z = sinPhiRadius * Math.cos(s.theta);
return this;
}
/**
* Sets the vector components to the position elements of the
* given transformation matrix.
* @param {Matrix4} m - The 4x4 matrix.
* @returns {Vector3} A reference to this vector.
*/
setFromMatrixPosition(m) {
const e = m.elements;
this.x = e[12];
this.y = e[13];
this.z = e[14];
return this;
}
/**
* Sets the vector components to the scale elements of the
* given transformation matrix.
* @param {Matrix4} m - The 4x4 matrix.
* @returns {Vector3} A reference to this vector.
*/
setFromMatrixScale(m) {
const sx = this.setFromMatrixColumn(m, 0).getLength();
const sy = this.setFromMatrixColumn(m, 1).getLength();
const sz = this.setFromMatrixColumn(m, 2).getLength();
return this.set(sx, sy, sz);
}
/**
* Sets the vector components from the specified matrix column.
* @param {Matrix4} m - The 4x4 matrix.
* @param {number} index - The column index.
* @returns {Vector3} A reference to this vector.
*/
setFromMatrixColumn(m, index) {
return this.fromArray(m.elements, index * 4);
}
/**
* Returns `true` if this vector is equal with the given one.
* @param {Vector3} v - The vector to test for equality.
* @returns {boolean} Whether this vector is equal with the given one.
*/
equals(v) {
return v.x === this.x && v.y === this.y && v.z === this.z;
}
/**
* Sets this vector's x value to be `array[ offset ]`, y value to be `array[ offset + 1 ]`
* and z value to be `array[ offset + 2 ]`.
* @param {Array<number>} array - An array holding the vector component values.
* @param {number} [offset=0] - The offset into the array.
* @param {boolean} [denormalize=false] - If true, denormalize the values, and array should be a typed array.
* @returns {Vector3} A reference to this vector.
*/
fromArray(array, offset = 0, denormalize = false) {
let x = array[offset],
y = array[offset + 1],
z = array[offset + 2];
if (denormalize) {
x = MathUtils.denormalize(x, array);
y = MathUtils.denormalize(y, array);
z = MathUtils.denormalize(z, array);
}
this.x = x;
this.y = y;
this.z = z;
return this;
}
/**
* Writes the components of this vector to the given array. If no array is provided,
* the method returns a new instance.
* @param {Array<number>} [array=[]] - The target array holding the vector components.
* @param {number} [offset=0] - Index of the first element in the array.
* @param {boolean} [normalize=false] - if true, normalize the values, and array should be a typed array.
* @returns {Array<number>} The vector components.
*/
toArray(array = [], offset = 0, normalize = false) {
let x = this.x,
y = this.y,
z = this.z;
if (normalize) {
x = MathUtils.normalize(x, array);
y = MathUtils.normalize(y, array);
z = MathUtils.normalize(z, array);
}
array[offset] = x;
array[offset + 1] = y;
array[offset + 2] = z;
return array;
}
*[Symbol.iterator]() {
yield this.x;
yield this.y;
yield this.z;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Vector3.prototype.isVector3 = true;
const _vector$2 = new Vector3();
/**
* Represents a 4x4 matrix.
*/
class Matrix4 {
/**
* Constructs a new 4x4 matrix.
*/
constructor() {
/**
* A column-major list of matrix values.
* @type {Array<number>}
*/
this.elements = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
}
/**
* Sets the elements of the matrix.The arguments are supposed to be
* in row-major order.
* @param {number} [n11] - 1-1 matrix element.
* @param {number} [n12] - 1-2 matrix element.
* @param {number} [n13] - 1-3 matrix element.
* @param {number} [n14] - 1-4 matrix element.
* @param {number} [n21] - 2-1 matrix element.
* @param {number} [n22] - 2-2 matrix element.
* @param {number} [n23] - 2-3 matrix element.
* @param {number} [n24] - 2-4 matrix element.
* @param {number} [n31] - 3-1 matrix element.
* @param {number} [n32] - 3-2 matrix element.
* @param {number} [n33] - 3-3 matrix element.
* @param {number} [n34] - 3-4 matrix element.
* @param {number} [n41] - 4-1 matrix element.
* @param {number} [n42] - 4-2 matrix element.
* @param {number} [n43] - 4-3 matrix element.
* @param {number} [n44] - 4-4 matrix element.
* @returns {Matrix4} A reference to this matrix.
*/
set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) {
const ele = this.elements;
ele[0] = n11;
ele[4] = n12;
ele[8] = n13;
ele[12] = n14;
ele[1] = n21;
ele[5] = n22;
ele[9] = n23;
ele[13] = n24;
ele[2] = n31;
ele[6] = n32;
ele[10] = n33;
ele[14] = n34;
ele[3] = n41;
ele[7] = n42;
ele[11] = n43;
ele[15] = n44;
return this;
}
/**
* Sets this matrix to the 4x4 identity matrix.
* @returns {Matrix4} A reference to this matrix.
*/
identity() {
return this.set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
}
/**
* Checks if the matrix is an identity matrix.
* @returns {boolean} - True if the matrix is an identity matrix, false otherwise.
*/
isIdentity() {
const te = this.elements;
return te[0] === 1 && te[4] === 0 && te[8] === 0 && te[12] === 0 && te[1] === 0 && te[5] === 1 && te[9] === 0 && te[13] === 0 && te[2] === 0 && te[6] === 0 && te[10] === 1 && te[14] === 0 && te[3] === 0 && te[7] === 0 && te[11] === 0 && te[15] === 1;
}
/**
* Returns a matrix with copied values from this instance.
* @returns {Matrix4} A clone of this instance.
*/
clone() {
return new Matrix4().fromArray(this.elements);
}
/**
* Copies the values of the given matrix to this instance.
* @param {Matrix4} m - The matrix to copy.
* @returns {Matrix4} A reference to this matrix.
*/
copy(m) {
const te = this.elements;
const 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;
}
/**
* Set the upper 3x3 elements of this matrix to the values of given 3x3 matrix.
* @param {Matrix3} m - The 3x3 matrix.
* @returns {Matrix4} A reference to this matrix.
*/
setFromMatrix3(m) {
const me = m.elements;
return this.set(me[0], me[3], me[6], 0, me[1], me[4], me[7], 0, me[2], me[5], me[8], 0, 0, 0, 0, 1);
}
/**
* Extracts the basis of this matrix into the three axis vectors provided.
* @param {Vector3} xAxis - The basis's x axis.
* @param {Vector3} yAxis - The basis's y axis.
* @param {Vector3} zAxis - The basis's z axis.
* @returns {Matrix4} A reference to this matrix.
*/
extractBasis(xAxis, yAxis, zAxis) {
xAxis.setFromMatrixColumn(this, 0);
yAxis.setFromMatrixColumn(this, 1);
zAxis.setFromMatrixColumn(this, 2);
return this;
}
/**
* Sets the given basis vectors to this matrix.
* @param {Vector3} xAxis - The basis's x axis.
* @param {Vector3} yAxis - The basis's y axis.
* @param {Vector3} zAxis - The basis's z axis.
* @returns {Matrix4} A reference to this matrix.
*/
makeBasis(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;
}
/**
* Extracts the rotation component of the given matrix
* into this matrix's rotation component.
*
* Note: This method does not support reflection matrices.
* @param {Matrix4} m - The matrix.
* @returns {Matrix4} A reference to this matrix.
*/
extractRotation(m) {
const te = this.elements;
const me = m.elements;
const scaleX = 1 / _vec3_1$6.setFromMatrixColumn(m, 0).getLength();
const scaleY = 1 / _vec3_1$6.setFromMatrixColumn(m, 1).getLength();
const scaleZ = 1 / _vec3_1$6.setFromMatrixColumn(m, 2).getLength();
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;
}
/**
* Sets the rotation component (the upper left 3x3 matrix) of this matrix to
* the rotation specified by the given Euler angles. The rest of
* the matrix is set to the identity. Depending on the {@link Euler#order},
* there are six possible outcomes. See [this page]{@link https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix}
* for a complete list.
* @param {Euler} euler - The Euler angles.
* @returns {Matrix4} A reference to this matrix.
*/
makeRotationFromEuler(euler) {
const te = this.elements;
const x = euler.x,
y = euler.y,
z = euler.z;
const a = Math.cos(x),
b = Math.sin(x);
const c = Math.cos(y),
d = Math.sin(y);
const e = Math.cos(z),
f = Math.sin(z);
if (euler.order === 'XYZ') {
const 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') {
const 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') {
const 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') {
const 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') {
const 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') {
const 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;
}
/**
* Sets the rotation component of this matrix to the rotation specified by q, as outlined here.
* @param {Quaternion} q
* @returns {Matrix4}
*/
makeRotationFromQuaternion(q) {
return this.compose(_zero, q, _one);
}
/**
* Constructs a rotation matrix, looking from eye towards center oriented by the up vector.
* @param {Vector3} eye - The eye vector.
* @param {Vector3} target - The target vector.
* @param {Vector3} up - The up vector.
* @returns {Matrix4} A reference to this matrix.
*/
lookAtRH(eye, target, up) {
const te = this.elements;
_z.subVectors(eye, target);
if (_z.getLengthSquared() === 0) {
// eye and target are in the same position
_z.z = 1;
}
_z.normalize();
_x.crossVectors(up, _z);
if (_x.getLengthSquared() === 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;
}
/**
* Post-multiplies this matrix by the given 4x4 matrix.
* @param {Matrix4} m - The matrix to multiply with.
* @returns {Matrix4} A reference to this matrix.
*/
multiply(m) {
return this.multiplyMatrices(this, m);
}
/**
* Pre-multiplies this matrix by the given 4x4 matrix.
* @param {Matrix4} m - The matrix to multiply with.
* @returns {Matrix4} A reference to this matrix.
*/
premultiply(m) {
return this.multiplyMatrices(m, this);
}
/**
* Multiples the given 4x4 matrices and stores the result
* in this matrix.
* @param {Matrix4} a - The first matrix.
* @param {Matrix4} b - The second matrix.
* @returns {Matrix4} A reference to this matrix.
*/
multiplyMatrices(a, b) {
const ae = a.elements;
const be = b.elements;
const te = this.elements;
const a11 = ae[0],
a12 = ae[4],
a13 = ae[8],
a14 = ae[12];
const a21 = ae[1],
a22 = ae[5],
a23 = ae[9],
a24 = ae[13];
const a31 = ae[2],
a32 = ae[6],
a33 = ae[10],
a34 = ae[14];
const a41 = ae[3],
a42 = ae[7],
a43 = ae[11],
a44 = ae[15];
const b11 = be[0],
b12 = be[4],
b13 = be[8],
b14 = be[12];
const b21 = be[1],
b22 = be[5],
b23 = be[9],
b24 = be[13];
const b31 = be[2],
b32 = be[6],
b33 = be[10],
b34 = be[14];
const 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;
}
/**
* Computes and returns the determinant of this matrix.
* Based on the method outlined [here]{@link http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.html}.
* @returns {number} The determinant.
*/
determinant() {
const te = this.elements;
const n11 = te[0],
n12 = te[4],
n13 = te[8],
n14 = te[12];
const n21 = te[1],
n22 = te[5],
n23 = te[9],
n24 = te[13];
const n31 = te[2],
n32 = te[6],
n33 = te[10],
n34 = te[14];
const n41 = te[3],
n42 = te[7],
n43 = te[11],
n44 = te[15];
// TODO: make this more efficient
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);
}
/**
* Transposes this matrix in place.
* @returns {Matrix4} A reference to this matrix.
*/
transpose() {
const te = this.elements;
let 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;
}
/**
* Sets the position component for this matrix from the given vector,
* without affecting the rest of the matrix.
* @param {number|Vector3} x - The x component of the vector or alternatively the vector object.
* @param {number} y - The y component of the vector.
* @param {number} z - The z component of the vector.
* @returns {Matrix4} A reference to this matrix.
*/
setPosition(x, y, z) {
const 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;
}
/**
* Inverts this matrix, using the [analytic method]{@link https://en.wikipedia.org/wiki/Invertible_matrix#Analytic_solution}.
* You can not invert with a determinant of zero. If you attempt this, the method produces
* a zero matrix instead.
* @returns {Matrix4} A reference to this matrix.
*/
invert() {
// based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
const te = this.elements,
n11 = te[0],
n21 = te[1],
n31 = te[2],
n41 = te[3],
n12 = te[4],
n22 = te[5],
n32 = te[6],
n42 = te[7],
n13 = te[8],
n23 = te[9],
n33 = te[10],
n43 = te[11],
n14 = te[12],
n24 = te[13],
n34 = te[14],
n44 = te[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;
const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
const 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;
}
/**
* Gets the maximum scale value of the three axes.
* @returns {number} The maximum scale.
*/
getMaxScaleOnAxis() {
const te = this.elements;
const scaleXSq = te[0] * te[0] + te[1] * te[1] + te[2] * te[2];
const scaleYSq = te[4] * te[4] + te[5] * te[5] + te[6] * te[6];
const scaleZSq = te[8] * te[8] + te[9] * te[9] + te[10] * te[10];
return Math.sqrt(Math.max(scaleXSq, scaleYSq, scaleZSq));
}
/**
* Sets this matrix as a translation transform from the given vector.
* @param {number|Vector3} x - The amount to translate in the X axis or alternatively a translation vector.
* @param {number} y - The amount to translate in the Y axis.
* @param {number} z - The amount to translate in the z axis.
* @returns {Matrix4} A reference to this matrix.
*/
makeTranslation(x, y, z) {
if (x.isVector3) {
this.set(1, 0, 0, x.x, 0, 1, 0, x.y, 0, 0, 1, x.z, 0, 0, 0, 1);
} else {
this.set(1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1);
}
return this;
}
/**
* Sets this matrix as a rotational transformation around the given axis by
* the given angle.
* This is a somewhat controversial but mathematically sound alternative to
* rotating via Quaternions. See the discussion [here]{@link https://www.gamedev.net/articles/programming/math-and-physics/do-we-really-need-quaternions-r1199}.
* @param {Vector3} axis - The normalized rotation axis.
* @param {number} angle - The rotation in radians.
* @returns {Matrix4} A reference to this matrix.
*/
makeRotationAxis(axis, angle) {
// Based on http://www.gamedev.net/reference/articles/article1199.asp
const c = Math.cos(angle);
const s = Math.sin(angle);
const t = 1 - c;
const x = axis.x,
y = axis.y,
z = axis.z;
const tx = t * x,
ty = t * y;
return 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);
}
/**
* Sets this matrix as a scale transformation.
* @param {number} x - The amount to scale in the X axis.
* @param {number} y - The amount to scale in the Y axis.
* @param {number} z - The amount to scale in the Z axis.
* @returns {Matrix4} A reference to this matrix.
*/
makeScale(x, y, z) {
return this.set(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1);
}
/**
* Sets this matrix to the transformation composed of the given position,
* rotation (Quaternion) and scale.
* @param {Vector3} position - The position vector.
* @param {Quaternion} quaternion - The rotation as a Quaternion.
* @param {Vector3} scale - The scale vector.
* @returns {Matrix4} A reference to this matrix.
*/
compose(position, quaternion, scale) {
const te = this.elements;
const x = quaternion._x,
y = quaternion._y,
z = quaternion._z,
w = quaternion._w;
const x2 = x + x,
y2 = y + y,
z2 = z + z;
const xx = x * x2,
xy = x * y2,
xz = x * z2;
const yy = y * y2,
yz = y * z2,
zz = z * z2;
const wx = w * x2,
wy = w * y2,
wz = w * z2;
const 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;
}
/**
* Decomposes this matrix into its position, rotation and scale components
* and provides the result in the given objects.
* Note: Not all matrices are decomposable in this way. For example, if an
* object has a non-uniformly scaled parent, then the object's world matrix
* may not be decomposable, and this method may not be appropriate.
* @param {Vector3} position - The position vector.
* @param {Quaternion} quaternion - The rotation as a Quaternion.
* @param {Vector3} scale - The scale vector.
* @returns {Matrix4} A reference to this matrix.
*/
decompose(position, quaternion, scale) {
const te = this.elements;
let sx = _vec3_1$6.set(te[0], te[1], te[2]).getLength();
const sy = _vec3_1$6.set(te[4], te[5], te[6]).getLength();
const sz = _vec3_1$6.set(te[8], te[9], te[10]).getLength();
// if determine is negative, we need to invert one scale
const det = this.determinant();
if (det < 0) {
sx = -sx;
}
position.x = te[12];
position.y = te[13];
position.z = te[14];
// scale the rotation part
_mat4_1$3.copy(this);
const invSX = 1 / sx;
const invSY = 1 / sy;
const invSZ = 1 / sz;
_mat4_1$3.elements[0] *= invSX;
_mat4_1$3.elements[1] *= invSX;
_mat4_1$3.elements[2] *= invSX;
_mat4_1$3.elements[4] *= invSY;
_mat4_1$3.elements[5] *= invSY;
_mat4_1$3.elements[6] *= invSY;
_mat4_1$3.elements[8] *= invSZ;
_mat4_1$3.elements[9] *= invSZ;
_mat4_1$3.elements[10] *= invSZ;
quaternion.setFromRotationMatrix(_mat4_1$3);
scale.x = sx;
scale.y = sy;
scale.z = sz;
return this;
}
/**
* Returns `true` if this matrix is equal with the given one.
* @param {Matrix4} matrix - The matrix to test for equality.
* @returns {boolean} Whether this matrix is equal with the given one.
*/
equals(matrix) {
const te = this.elements;
const me = matrix.elements;
for (let i = 0; i < 16; i++) {
if (te[i] !== me[i]) return false;
}
return true;
}
/**
* Sets the elements of the matrix from the given array.
* @param {Array<number>} array - The matrix elements in column-major order.
* @param {number} [offset=0] - Index of the first element in the array.
* @returns {Matrix4} A reference to this matrix.
*/
fromArray(array, offset = 0) {
for (let i = 0; i < 16; i++) {
this.elements[i] = array[i + offset];
}
return this;
}
/**
* Writes the elements of this matrix to the given array. If no array is provided,
* the method returns a new instance.
* @param {Array<number>} [array=[]] - The target array holding the matrix elements in column-major order.
* @param {number} [offset=0] - Index of the first element in the array.
* @returns {Array<number>} The matrix elements in column-major order.
*/
toArray(array = [], offset = 0) {
const 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;
}
/**
* Linearly interpolates between two matrix4.
* @param {Matrix4} m1
* @param {Matrix4} m2
* @param {number} ratio
* @returns {Matrix4}
*/
lerpMatrices(m1, m2, ratio) {
if (ratio === 0) return this.copy(m1);
if (ratio === 1) return this.copy(m2);
const te = this.elements,
te1 = m1.elements,
te2 = m2.elements;
for (let i = 0; i < 16; i++) {
te[i] = te1[i] * (1 - ratio) + te2[i] * ratio;
}
return this;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Matrix4.prototype.isMatrix4 = true;
const _vec3_1$6 = new Vector3();
const _mat4_1$3 = new Matrix4();
const _zero = new Vector3(0, 0, 0);
const _one = new Vector3(1, 1, 1);
const _x = new Vector3();
const _y = new Vector3();
const _z = new Vector3();
/**
* Class for representing a Quaternion.
*/
class Quaternion {
/**
* Constructs a new quaternion.
* @param {number} [x=0] - The x value of this quaternion.
* @param {number} [y=0] - The y value of this quaternion.
* @param {number} [z=0] - The z value of this quaternion.
* @param {number} [w=1] - The w value of this quaternion.
*/
constructor(x = 0, y = 0, z = 0, w = 1) {
this._x = x;
this._y = y;
this._z = z;
this._w = w;
}
/**
* Interpolates between two quaternions via SLERP. This implementation assumes the
* quaternion data are managed in flat arrays.
* @param {Array<number>} dst - The destination array.
* @param {number} dstOffset - An offset into the destination array.
* @param {Array<number>} src0 - The source array of the first quaternion.
* @param {number} srcOffset0 - An offset into the first source array.
* @param {Array<number>} src1 - The source array of the second quaternion.
* @param {number} srcOffset1 - An offset into the second source array.
* @param {number} t - The interpolation factor in the range `[0,1]`.
* @see {@link Quaternion#slerp}
*/
static slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
let x0 = src0[srcOffset0 + 0],
y0 = src0[srcOffset0 + 1],
z0 = src0[srcOffset0 + 2],
w0 = src0[srcOffset0 + 3];
let x1 = src1[srcOffset1 + 0],
y1 = src1[srcOffset1 + 1],
z1 = src1[srcOffset1 + 2],
w1 = src1[srcOffset1 + 3];
if (t <= 0) {
dst[dstOffset + 0] = x0;
dst[dstOffset + 1] = y0;
dst[dstOffset + 2] = z0;
dst[dstOffset + 3] = w0;
return;
}
if (t >= 1) {
dst[dstOffset + 0] = x1;
dst[dstOffset + 1] = y1;
dst[dstOffset + 2] = z1;
dst[dstOffset + 3] = w1;
return;
}
if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
let dot = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1;
if (dot < 0) {
x1 = -x1;
y1 = -y1;
z1 = -z1;
w1 = -w1;
dot = -dot;
}
let s = 1 - t;
if (dot < 0.9995) {
// slerp
const theta = Math.acos(dot);
const sin = Math.sin(theta);
s = Math.sin(s * theta) / sin;
t = Math.sin(t * theta) / sin;
x0 = x0 * s + x1 * t;
y0 = y0 * s + y1 * t;
z0 = z0 * s + z1 * t;
w0 = w0 * s + w1 * t;
} else {
// for small angles, lerp then normalize
x0 = x0 * s + x1 * t;
y0 = y0 * s + y1 * t;
z0 = z0 * s + z1 * t;
w0 = w0 * s + w1 * t;
const 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;
}
/**
* Multiplies two quaternions. This implementation assumes the quaternion data are managed
* in flat arrays.
* @param {Array<number>} dst - The destination array.
* @param {number} dstOffset - An offset into the destination array.
* @param {Array<number>} src0 - The source array of the first quaternion.
* @param {number} srcOffset0 - An offset into the first source array.
* @param {Array<number>} src1 - The source array of the second quaternion.
* @param {number} srcOffset1 - An offset into the second source array.
* @returns {Array<number>} The destination array.
* @see {@link Quaternion#multiplyQuaternions}
*/
static multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
const x0 = src0[srcOffset0];
const y0 = src0[srcOffset0 + 1];
const z0 = src0[srcOffset0 + 2];
const w0 = src0[srcOffset0 + 3];
const x1 = src1[srcOffset1];
const y1 = src1[srcOffset1 + 1];
const z1 = src1[srcOffset1 + 2];
const w1 = src1[srcOffset1 + 3];
dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
return dst;
}
/**
* The x value of this quaternion.
* @type {number}
* @default 0
*/
get x() {
return this._x;
}
set x(value) {
this._x = value;
this.onChangeCallback();
}
/**
* The y value of this quaternion.
* @type {number}
* @default 0
*/
get y() {
return this._y;
}
set y(value) {
this._y = value;
this.onChangeCallback();
}
/**
* The z value of this quaternion.
* @type {number}
* @default 0
*/
get z() {
return this._z;
}
set z(value) {
this._z = value;
this.onChangeCallback();
}
/**
* The w value of this quaternion.
* @type {number}
* @default 1
*/
get w() {
return this._w;
}
set w(value) {
this._w = value;
this.onChangeCallback();
}
/**
* Sets the quaternion components.
* @param {number} x - The x value of this quaternion.
* @param {number} y - The y value of this quaternion.
* @param {number} z - The z value of this quaternion.
* @param {number} w - The w value of this quaternion.
* @returns {Quaternion} A reference to this quaternion.
*/
set(x, y, z, w) {
this._x = x;
this._y = y;
this._z = z;
this._w = w;
this.onChangeCallback();
return this;
}
/**
* Returns a new quaternion with copied values from this instance.
* @returns {Quaternion} A clone of this instance.
*/
clone() {
return new Quaternion(this._x, this._y, this._z, this._w);
}
/**
* Copies the values of the given quaternion to this instance.
* @param {Quaternion} quaternion - The quaternion to copy.
* @returns {Quaternion} A reference to this quaternion.
*/
copy(quaternion) {
this._x = quaternion.x;
this._y = quaternion.y;
this._z = quaternion.z;
this._w = quaternion.w;
this.onChangeCallback();
return this;
}
/**
* Sets this quaternion from the rotation specified by the given
* Euler angles.
* @param {Euler} euler - The Euler angles.
* @param {boolean} [update=true] - Whether the internal `onChange` callback should be executed or not.
* @returns {Quaternion} A reference to this quaternion.
*/
setFromEuler(euler, update = true) {
const c1 = Math.cos(euler._x / 2);
const c2 = Math.cos(euler._y / 2);
const c3 = Math.cos(euler._z / 2);
const s1 = Math.sin(euler._x / 2);
const s2 = Math.sin(euler._y / 2);
const s3 = Math.sin(euler._z / 2);
const order = euler._order;
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 === true) this.onChangeCallback();
return this;
}
/**
* Sets this quaternion from the given axis and angle.
* @param {Vector3} axis - The normalized axis.
* @param {number} angle - The angle in radians.
* @returns {Quaternion} A reference to this quaternion.
*/
setFromAxisAngle(axis, angle) {
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
const 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;
}
/**
* Sets this quaternion from the given rotation matrix.
* @param {Matrix4} m - A 4x4 matrix of which the upper 3x3 of matrix is a pure rotation matrix (i.e. unscaled).
* @returns {Quaternion} A reference to this quaternion.
*/
setFromRotationMatrix(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)
const 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;
let 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;
}
/**
* Sets this quaternion to the rotation required to rotate the direction vector
* `vFrom` to the direction vector `vTo`.
* @param {Vector3} vFrom - The first (normalized) direction vector.
* @param {Vector3} vTo - The second (normalized) direction vector.
* @returns {Quaternion} A reference to this quaternion.
*/
setFromUnitVectors(vFrom, vTo) {
// assumes direction vectors vFrom and vTo are normalized
let r = vFrom.dot(vTo) + 1;
if (r < 1e-8) {
// vFrom and vTo point in opposite directions
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();
}
/**
* Returns the angle between this quaternion and the given one in radians.
* @param {Quaternion} q - The quaternion to compute the angle with.
* @returns {number} The angle in radians.
*/
angleTo(q) {
return 2 * Math.acos(Math.abs(MathUtils.clamp(this.dot(q), -1, 1)));
}
/**
* Sets this quaternion to the identity quaternion; that is, to the
* quaternion that represents "no rotation".
* @returns {Quaternion} A reference to this quaternion.
*/
identity() {
return this.set(0, 0, 0, 1);
}
/**
* Returns the rotational conjugate of this quaternion. The conjugate of a
* quaternion represents the same rotation in the opposite direction about
* the rotational axis.
* @returns {Quaternion} A reference to this quaternion.
*/
conjugate() {
this._x *= -1;
this._y *= -1;
this._z *= -1;
this.onChangeCallback();
return this;
}
/**
* Calculates the dot product of this quaternion and the given one.
* @param {Quaternion} v - The quaternion to compute the dot product with.
* @returns {number} The result of the dot product.
*/
dot(v) {
return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
}
/**
* Computes the squared Euclidean length (straight-line length) of this quaternion,
* considered as a 4 dimensional vector. This can be useful if you are comparing the
* lengths of two quaternions, as this is a slightly more efficient calculation than
* {@link Quaternion#length}.
* @returns {number} The squared Euclidean length.
*/
lengthSq() {
return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
}
/**
* Computes the Euclidean length (straight-line length) of this quaternion,
* considered as a 4 dimensional vector.
* @returns {number} The Euclidean length.
*/
length() {
return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w);
}
/**
* Normalizes this quaternion - that is, calculated the quaternion that performs
* the same rotation as this one, but has a length equal to `1`.
* @returns {Quaternion} A reference to this quaternion.
*/
normalize() {
let 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;
}
/**
* Multiplies this quaternion by the given one.
* @param {Quaternion} q - The quaternion.
* @returns {Quaternion} A reference to this quaternion.
*/
multiply(q) {
return this.multiplyQuaternions(this, q);
}
/**
* Pre-multiplies this quaternion by the given one.
* @param {Quaternion} q - The quaternion.
* @returns {Quaternion} A reference to this quaternion.
*/
premultiply(q) {
return this.multiplyQuaternions(q, this);
}
/**
* Multiplies the given quaternions and stores the result in this instance.
* @param {Quaternion} a - The first quaternion.
* @param {Quaternion} b - The second quaternion.
* @returns {Quaternion} A reference to this quaternion.
*/
multiplyQuaternions(a, b) {
// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
const qax = a._x,
qay = a._y,
qaz = a._z,
qaw = a._w;
const 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;
}
/**
* Linearly interpolates between two quaternions.
* @param {Quaternion} q1
* @param {Quaternion} q2
* @param {number} ratio
* @returns {Quaternion}
*/
lerpQuaternions(q1, q2, ratio) {
if (ratio === 0) return this.copy(q1);
if (ratio === 1) return this.copy(q2);
const w1 = q1._w,
x1 = q1._x,
y1 = q1._y,
z1 = q1._z;
let w2 = q2._w,
x2 = q2._x,
y2 = q2._y,
z2 = q2._z;
const dot = w1 * w2 + x1 * x2 + y1 * y2 + z1 * z2;
// shortest direction
if (dot < 0) {
w2 = -w2;
x2 = -x2;
y2 = -y2;
z2 = -z2;
}
this._w = w1 + ratio * (w2 - w1);
this._x = x1 + ratio * (x2 - x1);
this._y = y1 + ratio * (y2 - y1);
this._z = z1 + ratio * (z2 - z1);
const len = 1.0 / Math.sqrt(this._w * this._w + this._x * this._x + this._y * this._y + this._z * this._z);
this._w *= len;
this._x *= len;
this._y *= len;
this._z *= len;
this.onChangeCallback();
return this;
}
/**
* Performs a spherical linear interpolation between quaternions.
* @param {Quaternion} qb - The target quaternion.
* @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
* @returns {Quaternion} A reference to this quaternion.
*/
slerp(qb, t) {
if (t <= 0) return this;
if (t >= 1) return this.copy(qb); // copy calls onChangeCallback()
let x = qb._x,
y = qb._y,
z = qb._z,
w = qb._w;
let dot = this.dot(qb);
if (dot < 0) {
x = -x;
y = -y;
z = -z;
w = -w;
dot = -dot;
}
let s = 1 - t;
if (dot < 0.9995) {
// slerp
const theta = Math.acos(dot);
const sin = Math.sin(theta);
s = Math.sin(s * theta) / sin;
t = Math.sin(t * theta) / sin;
this._x = this._x * s + x * t;
this._y = this._y * s + y * t;
this._z = this._z * s + z * t;
this._w = this._w * s + w * t;
this.onChangeCallback();
} else {
// for small angles, lerp then normalize
this._x = this._x * s + x * t;
this._y = this._y * s + y * t;
this._z = this._z * s + z * t;
this._w = this._w * s + w * t;
this.normalize(); // normalize calls onChangeCallback()
}
return this;
}
/**
* Performs a spherical linear interpolation between the given quaternions
* and stores the result in this quaternion.
* @param {Quaternion} qa - The source quaternion.
* @param {Quaternion} qb - The target quaternion.
* @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
* @returns {Quaternion} A reference to this quaternion.
*/
slerpQuaternions(qa, qb, t) {
return this.copy(qa).slerp(qb, t);
}
/**
* Returns `true` if this quaternion is equal with the given one.
* @param {Quaternion} quaternion - The quaternion to test for equality.
* @returns {boolean} Whether this quaternion is equal with the given one.
*/
equals(quaternion) {
return quaternion._x === this._x && quaternion._y === this._y && quaternion._z === this._z && quaternion._w === this._w;
}
/**
* Sets this quaternion's components from the given array.
* @param {Array<number>} array - An array holding the quaternion component values.
* @param {number} [offset=0] - The offset into the array.
* @param {boolean} [denormalize=false] - If true, denormalize the values, and array should be a typed array.
* @returns {Quaternion} A reference to this quaternion.
*/
fromArray(array, offset = 0, denormalize = false) {
let x = array[offset],
y = array[offset + 1],
z = array[offset + 2],
w = array[offset + 3];
if (denormalize) {
x = MathUtils.denormalize(x, array);
y = MathUtils.denormalize(y, array);
z = MathUtils.denormalize(z, array);
w = MathUtils.denormalize(w, array);
}
this._x = x;
this._y = y;
this._z = z;
this._w = w;
this.onChangeCallback();
return this;
}
/**
* Writes the components of this quaternion to the given array. If no array is provided,
* the method returns a new instance.
* @param {Array<number>} [array=[]] - The target array holding the quaternion components.
* @param {number} [offset=0] - Index of the first element in the array.
* @param {boolean} [normalize=false] - If true, normalize the values, and array should be a typed array.
* @returns {Quaternion} The quaternion components.
*/
toArray(array = [], offset = 0, normalize = false) {
let x = this._x,
y = this._y,
z = this._z,
w = this._w;
if (normalize) {
x = MathUtils.normalize(x, array);
y = MathUtils.normalize(y, array);
z = MathUtils.normalize(z, array);
w = MathUtils.normalize(w, array);
}
array[offset] = x;
array[offset + 1] = y;
array[offset + 2] = z;
array[offset + 3] = w;
return array;
}
/**
* Convert the current quaternion to a matrix4.
* @param {Matrix4} target - The target matrix to write the quaternion data to.
* @returns {Matrix4} The target matrix with the quaternion data written to it.
*/
toMatrix4(target = new Matrix4()) {
const ele = target.elements;
const xy2 = 2.0 * this._x * this._y,
xz2 = 2.0 * this._x * this._z,
xw2 = 2.0 * this._x * this._w;
const yz2 = 2.0 * this._y * this._z,
yw2 = 2.0 * this._y * this._w,
zw2 = 2.0 * this._z * this._w;
const xx = this._x * this._x,
yy = this._y * this._y,
zz = this._z * this._z,
ww = this._w * this._w;
ele[0] = xx - yy - zz + ww;
ele[4] = xy2 - zw2;
ele[8] = xz2 + yw2;
ele[12] = 0;
ele[1] = xy2 + zw2;
ele[5] = -xx + yy - zz + ww;
ele[9] = yz2 - xw2;
ele[13] = 0;
ele[2] = xz2 - yw2;
ele[6] = yz2 + xw2;
ele[10] = -xx - yy + zz + ww;
ele[14] = 0;
ele[3] = 0.0;
ele[7] = 0.0;
ele[11] = 0;
ele[15] = 1;
return target;
}
/**
* Registers a callback that is called whenever the quaternion's
* angle value changes.
* @param {Function} callback - When the Quaternion angle value changes, the callback method is triggered
* @returns {Quaternion} A reference to this quaternion.
*/
onChange(callback) {
this.onChangeCallback = callback;
return this;
}
onChangeCallback() {}
*[Symbol.iterator]() {
yield this._x;
yield this._y;
yield this._z;
yield this._w;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Quaternion.prototype.isQuaternion = true;
/**
* Interpolant serves as the base class for all interpolation algorithms.
* It defines a set of static methods that are intended to be invoked by a keyframe track for the purpose of interpolation.
* @abstract
*/
class KeyframeInterpolant {
/**
* Get the value size for keyframe values.
* @returns {number} - the value size.
*/
static getValueSize() {
return this.values.length / this.times.length;
}
/**
* Interpolate the value for the specified time.
* @param {number} index0 - the index of the first keyframe.
* @param {number} ratio - the ratio (0-1) of the time passed between the first keyframe and the next keyframe.
* @param {number} duration - the duration time between the first keyframe and the next keyframe.
* @param {Array} outBuffer - the output buffer to store the interpolated value.
* @returns {Array} - the output buffer to store the interpolated value.
*/
static interpolate(index0, ratio, duration, outBuffer) {
throw new Error('Interpolant: call to abstract method');
}
/**
* Copy the value for the specified index.
* @param {number} index - the index of the keyframe.
* @param {Array} outBuffer - the output buffer to store the copied value.
* @returns {Array} - the output buffer to store the copied value.
*/
static copyValue(index, outBuffer) {
const values = this.values,
valueSize = this.valueSize,
offset = valueSize * index;
for (let i = 0; i < valueSize; i++) {
outBuffer[i] = values[offset + i];
}
return outBuffer;
}
}
/**
* Step (Discrete) interpolation of keyframe values.
* @extends KeyframeInterpolant
*/
class StepInterpolant extends KeyframeInterpolant {
static interpolate(index0, ratio, duration, outBuffer) {
const values = this.values,
valueSize = this.valueSize,
offset = valueSize * index0;
for (let i = 0; i < valueSize; i++) {
outBuffer[i] = values[offset + i];
}
return outBuffer;
}
}
/**
* Linear interpolation of keyframe values.
* @extends KeyframeInterpolant
*/
class LinearInterpolant extends KeyframeInterpolant {
static interpolate(index0, ratio, duration, outBuffer) {
const values = this.values,
valueSize = this.valueSize,
offset0 = index0 * valueSize,
offset1 = (index0 + 1) * valueSize;
let value1, value2;
for (let i = 0; i < valueSize; i++) {
value1 = values[offset0 + i];
value2 = values[offset1 + i];
if (value1 !== undefined && value2 !== undefined) {
outBuffer[i] = value1 * (1 - ratio) + value2 * ratio;
} else {
outBuffer[i] = value1;
}
}
return outBuffer;
}
}
/**
* Quaternion Linear interpolation of keyframe values.
* @extends KeyframeInterpolant
*/
class QuaternionLinearInterpolant extends KeyframeInterpolant {
static interpolate(index0, ratio, duration, outBuffer) {
const values = this.values,
valueSize = this.valueSize;
Quaternion.slerpFlat(outBuffer, 0, values, index0 * valueSize, values, (index0 + 1) * valueSize, ratio);
return outBuffer;
}
}
/**
* Cubic spline interpolation of keyframe values.
* @extends KeyframeInterpolant
*/
class CubicSplineInterpolant extends KeyframeInterpolant {
static getValueSize() {
return this.values.length / this.times.length / 3;
}
static interpolate(index0, ratio, duration, outBuffer) {
const values = this.values,
valueSize = this.valueSize,
valueSize2 = valueSize * 2,
valueSize3 = valueSize * 3,
rr = ratio * ratio,
rrr = rr * ratio,
offset0 = index0 * valueSize3,
offset1 = offset0 + valueSize3,
s2 = -2 * rrr + 3 * rr,
s3 = rrr - rr,
s0 = 1 - s2,
s1 = s3 - rr + ratio;
// Layout of keyframe output values for CUBICSPLINE animations:
// [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
for (let i = 0; i < valueSize; i++) {
const p0 = values[offset0 + i + valueSize],
// splineVertex_k
m0 = values[offset0 + i + valueSize2] * duration,
// outTangent_k * (t_k+1 - t_k)
p1 = values[offset1 + i + valueSize],
// splineVertex_k+1
m1 = values[offset1 + i] * duration; // inTangent_k+1 * (t_k+1 - t_k)
outBuffer[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
}
return outBuffer;
}
static copyValue(index, outBuffer) {
const values = this.values,
valueSize = this.valueSize,
offset = valueSize * index * 3 + valueSize;
for (let i = 0; i < valueSize; i++) {
outBuffer[i] = values[offset + i];
}
return outBuffer;
}
}
/**
* Quaternion Cubic spline interpolation of keyframe values.
* @extends CubicSplineInterpolant
*/
class QuaternionCubicSplineInterpolant extends CubicSplineInterpolant {
static interpolate(index0, ratio, duration, outBuffer) {
const result = super.interpolate(index0, ratio, duration, outBuffer);
_q.fromArray(result).normalize().toArray(result);
return result;
}
}
const _q = new Quaternion();
/**
* Base class for property track.
* @abstract
*/
class KeyframeTrack {
/**
* @param {Object3D|Material} target
* @param {string} propertyPath
* @param {Array} times
* @param {Array} values
* @param {KeyframeInterpolant.constructor} [interpolant=LinearInterpolant]
*/
constructor(target, propertyPath, times, values, interpolant = LinearInterpolant) {
this.target = target;
this.propertyPath = propertyPath;
this.name = this.target.uuid + '.' + propertyPath;
this.times = times;
this.values = values;
this.valueSize = 0;
this.interpolant = null;
// since 0.2.2, remove this after few versions later
if (interpolant === true) {
interpolant = LinearInterpolant;
} else if (interpolant === false) {
interpolant = StepInterpolant;
}
this.setInterpolant(interpolant);
}
/**
* Set interpolant for this keyframe track.
* @param {KeyframeInterpolant.constructor} interpolant
* @returns {KeyframeTrack}
*/
setInterpolant(interpolant) {
this.valueSize = interpolant.getValueSize.call(this);
this.interpolant = interpolant;
return this;
}
/**
* Get value at time.
* The value will be interpolated by interpolant if time is between keyframes.
* @param {number} t - time
* @param {Array} outBuffer - output buffer
* @returns {Array} output buffer
*/
getValue(t, outBuffer) {
const interpolant = this.interpolant,
times = this.times,
tl = times.length;
if (t <= times[0]) {
return interpolant.copyValue.call(this, 0, outBuffer);
} else if (t >= times[tl - 1]) {
return interpolant.copyValue.call(this, tl - 1, outBuffer);
}
// TODO use index cache for better performance
// https://github.com/mrdoob/three.js/blob/dev/src/math/Interpolant.js
let i0 = tl - 1;
while (t < times[i0] && i0 > 0) {
i0--;
}
const duration = times[i0 + 1] - times[i0];
const ratio = (t - times[i0]) / duration;
return interpolant.interpolate.call(this, i0, ratio, duration, outBuffer);
}
}
/**
* Used for boolean property track.
* @extends KeyframeTrack
*/
class BooleanKeyframeTrack extends KeyframeTrack {
/**
* @param {Object3D} target
* @param {string} propertyPath
* @param {Array} times
* @param {Array} values
* @param {KeyframeInterpolant.constructor} [interpolant=StepInterpolant]
*/
constructor(target, propertyPath, times, values, interpolant = StepInterpolant) {
// since 0.2.2, remove this after few versions later
if (interpolant === true) {
interpolant = StepInterpolant;
}
super(target, propertyPath, times, values, interpolant);
}
}
/**
* @readonly
* @type {string}
* @default 'bool'
*/
BooleanKeyframeTrack.prototype.valueTypeName = 'bool';
/**
* Used for color property track.
* @extends KeyframeTrack
*/
class ColorKeyframeTrack extends KeyframeTrack {
/**
* @param {Object3D} target
* @param {string} propertyPath
* @param {Array} times
* @param {Array} values
* @param {KeyframeInterpolant.constructor} [interpolant=LinearInterpolant]
*/
constructor(target, propertyPath, times, values, interpolant) {
super(target, propertyPath, times, values, interpolant);
}
}
/**
* @readonly
* @type {string}
* @default 'color'
*/
ColorKeyframeTrack.prototype.valueTypeName = 'color';
/**
* Used for number property track.
* @extends KeyframeTrack
*/
class NumberKeyframeTrack extends KeyframeTrack {
/**
* @param {Object3D} target
* @param {string} propertyPath
* @param {Array} times
* @param {Array} values
* @param {KeyframeInterpolant.constructor} [interpolant=LinearInterpolant]
*/
constructor(target, propertyPath, times, values, interpolant) {
super(target, propertyPath, times, values, interpolant);
}
}
/**
* @readonly
* @type {string}
* @default 'number'
*/
NumberKeyframeTrack.prototype.valueTypeName = 'number';
/**
* Used for quaternion property track.
* @extends KeyframeTrack
*/
class QuaternionKeyframeTrack extends KeyframeTrack {
/**
* @param {Object3D} target
* @param {string} propertyPath
* @param {Array} times
* @param {Array} values
* @param {KeyframeInterpolant.constructor} [interpolant=QuaternionLinearInterpolant]
*/
constructor(target, propertyPath, times, values, interpolant = QuaternionLinearInterpolant) {
// since 0.2.2, remove this after few versions later
if (interpolant === true) {
interpolant = QuaternionLinearInterpolant;
}
super(target, propertyPath, times, values, interpolant);
}
}
/**
* @readonly
* @type {string}
* @default 'quaternion'
*/
QuaternionKeyframeTrack.prototype.valueTypeName = 'quaternion';
/**
* Used for string property track.
* @extends KeyframeTrack
*/
class StringKeyframeTrack extends KeyframeTrack {
/**
* @param {Object3D} target
* @param {string} propertyPath
* @param {Array} times
* @param {Array} values
* @param {KeyframeInterpolant.constructor} [interpolant=StepInterpolant]
*/
constructor(target, propertyPath, times, values, interpolant = StepInterpolant) {
// since 0.2.2, remove this after few versions later
if (interpolant === true) {
interpolant = StepInterpolant;
}
super(target, propertyPath, times, values, interpolant);
}
}
/**
* @readonly
* @type {string}
* @default 'string'
*/
StringKeyframeTrack.prototype.valueTypeName = 'string';
/**
* Used for vector property track.
* @extends KeyframeTrack
*/
class VectorKeyframeTrack extends KeyframeTrack {
/**
* @param {Object3D} target
* @param {string} propertyPath
* @param {Array} times
* @param {Array} values
* @param {KeyframeInterpolant.constructor} [interpolant=LinearInterpolant]
*/
constructor(target, propertyPath, times, values, interpolant) {
super(target, propertyPath, times, values, interpolant);
}
}
/**
* @readonly
* @type {string}
* @default 'vector'
*/
VectorKeyframeTrack.prototype.valueTypeName = 'vector';
/**
* Enum for material Type.
* @readonly
* @enum {string}
*/
const MATERIAL_TYPE = {
BASIC: 'basic',
LAMBERT: 'lambert',
PHONG: 'phong',
PBR: 'pbr',
PBR2: 'pbr2',
POINT: 'point',
LINE: 'line',
SHADER: 'shader',
DEPTH: 'depth',
DISTANCE: 'distance'
};
/**
* Enum for blend Type.
* @readonly
* @enum {string}
*/
const BLEND_TYPE = {
NONE: 'none',
NORMAL: 'normal',
ADD: 'add',
SUB: 'sub',
MUL: 'mul',
CUSTOM: 'custom'
};
/**
* Enum for blend equation.
* @readonly
* @enum {number}
*/
const BLEND_EQUATION = {
ADD: 100,
SUBTRACT: 101,
REVERSE_SUBTRACT: 102,
/** Only webgl2 */
MIN: 103,
MAX: 104
};
/**
* Enum for blend factor.
* @readonly
* @enum {number}
*/
const BLEND_FACTOR = {
ZERO: 200,
ONE: 201,
SRC_COLOR: 202,
SRC_ALPHA: 203,
SRC_ALPHA_SATURATE: 204,
DST_COLOR: 205,
DST_ALPHA: 206,
ONE_MINUS_SRC_COLOR: 207,
ONE_MINUS_SRC_ALPHA: 208,
ONE_MINUS_DST_COLOR: 209,
ONE_MINUS_DST_ALPHA: 210
};
/**
* Enum for cull face Type.
* @readonly
* @enum {string}
*/
const CULL_FACE_TYPE = {
NONE: 'none',
FRONT: 'front',
BACK: 'back',
FRONT_AND_BACK: 'front_and_back'
};
/**
* Enum for draw side.
* @readonly
* @enum {string}
*/
const DRAW_SIDE = {
FRONT: 'front',
BACK: 'back',
DOUBLE: 'double'
};
/**
* Enum for shading side.
* @readonly
* @enum {string}
*/
const SHADING_TYPE = {
SMOOTH_SHADING: 'smooth_shading',
FLAT_SHADING: 'flat_shading'
};
/**
* Enum for pixel format.
* @readonly
* @enum {number}
*/
const PIXEL_FORMAT = {
DEPTH_COMPONENT: 1000,
DEPTH_STENCIL: 1001,
STENCIL_INDEX8: 1002,
ALPHA: 1003,
RED: 1004,
RGB: 1005,
RGBA: 1006,
LUMINANCE: 1007,
LUMINANCE_ALPHA: 1008,
/** Only webgl2 */
RED_INTEGER: 1010,
RG: 1011,
RG_INTEGER: 1012,
RGB_INTEGER: 1013,
RGBA_INTEGER: 1014,
/** Only internal formats and webgl2 */
R32F: 1100,
R16F: 1101,
R8: 1102,
RG32F: 1103,
RG16F: 1104,
RG8: 1105,
RGB32F: 1106,
RGB16F: 1107,
RGB8: 1108,
RGBA32F: 1109,
RGBA16F: 1110,
RGBA8: 1111,
RGBA4: 1112,
RGB5_A1: 1113,
DEPTH_COMPONENT32F: 1114,
DEPTH_COMPONENT24: 1115,
DEPTH_COMPONENT16: 1116,
DEPTH24_STENCIL8: 1117,
DEPTH32F_STENCIL8: 1118,
R11F_G11F_B10F: 1119,
/** For compressed texture formats */
RGB_S3TC_DXT1: 1200,
RGBA_S3TC_DXT1: 1201,
RGBA_S3TC_DXT3: 1202,
RGBA_S3TC_DXT5: 1203,
RGB_PVRTC_4BPPV1: 1204,
RGB_PVRTC_2BPPV1: 1205,
RGBA_PVRTC_4BPPV1: 1206,
RGBA_PVRTC_2BPPV1: 1207,
RGB_ETC1: 1208,
RGBA_ASTC_4x4: 1209,
RGBA_BPTC: 1210,
RGB_BPTC_SIGNED_FORMAT: 1211,
RGB_BPTC_UNSIGNED_FORMAT: 1212
};
/**
* Enum for pixel Type.
* @readonly
* @enum {number}
*/
const PIXEL_TYPE = {
UNSIGNED_BYTE: 1500,
UNSIGNED_SHORT_5_6_5: 1501,
UNSIGNED_SHORT_4_4_4_4: 1502,
UNSIGNED_SHORT_5_5_5_1: 1503,
UNSIGNED_SHORT: 1504,
UNSIGNED_INT: 1505,
UNSIGNED_INT_24_8: 1506,
FLOAT: 1507,
HALF_FLOAT: 1508,
FLOAT_32_UNSIGNED_INT_24_8_REV: 1509,
BYTE: 1510,
SHORT: 1511,
INT: 1512
};
/**
* Enum for texture filter.
* @readonly
* @enum {number}
*/
const TEXTURE_FILTER = {
NEAREST: 1600,
LINEAR: 1601,
NEAREST_MIPMAP_NEAREST: 1602,
LINEAR_MIPMAP_NEAREST: 1603,
NEAREST_MIPMAP_LINEAR: 1604,
LINEAR_MIPMAP_LINEAR: 1605
};
/**
* Enum for texture wrap.
* @readonly
* @enum {number}
*/
const TEXTURE_WRAP = {
REPEAT: 1700,
CLAMP_TO_EDGE: 1701,
MIRRORED_REPEAT: 1702
};
/**
* Enum for compare function.
* @readonly
* @enum {number}
*/
const COMPARE_FUNC = {
LEQUAL: 0x0203,
GEQUAL: 0x0206,
LESS: 0x0201,
GREATER: 0x0204,
EQUAL: 0x0202,
NOTEQUAL: 0x0205,
ALWAYS: 0x0207,
NEVER: 0x0200
};
/**
* Enum for operation.
* @readonly
* @enum {number}
*/
const OPERATION = {
KEEP: 0x1E00,
REPLACE: 0x1E01,
INCR: 0x1E02,
DECR: 0x1E03,
INVERT: 0x150A,
INCR_WRAP: 0x8507,
DECR_WRAP: 0x8508
};
/**
* Enum for Shadow Type.
* @readonly
* @enum {string}
*/
const SHADOW_TYPE = {
HARD: 'hard',
POISSON_SOFT: 'poisson_soft',
VOGEL5_SOFT: 'vogel5_soft',
PCF3_SOFT: 'pcf3_soft',
PCF5_SOFT: 'pcf5_soft',
/** Only webgl2 */
PCSS16_SOFT: 'pcss16_soft',
PCSS32_SOFT: 'pcss32_soft',
PCSS64_SOFT: 'pcss64_soft'
};
/**
* Enum for Texel Encoding Type.
* @readonly
* @enum {string}
*/
const TEXEL_ENCODING_TYPE = {
LINEAR: 'linear',
SRGB: 'sRGB',
GAMMA: 'Gamma'
};
/**
* Enum for Envmap Combine Type.
* @readonly
* @enum {string}
*/
const ENVMAP_COMBINE_TYPE = {
MULTIPLY: 'ENVMAP_BLENDING_MULTIPLY',
MIX: 'ENVMAP_BLENDING_MIX',
ADD: 'ENVMAP_BLENDING_ADD'
};
/**
* Enum for Draw Mode.
* @readonly
* @enum {number}
*/
const DRAW_MODE = {
POINTS: 0,
LINES: 1,
LINE_LOOP: 2,
LINE_STRIP: 3,
TRIANGLES: 4,
TRIANGLE_STRIP: 5,
TRIANGLE_FAN: 6
};
/**
* Enum for Vertex Color.
* @readonly
* @enum {number}
*/
const VERTEX_COLOR = {
NONE: 0,
RGB: 1,
RGBA: 2
};
/**
* Enum for ATTACHMENT
* @readonly
* @enum {number}
*/
const ATTACHMENT = {
COLOR_ATTACHMENT0: 2000,
COLOR_ATTACHMENT1: 2001,
COLOR_ATTACHMENT2: 2002,
COLOR_ATTACHMENT3: 2003,
COLOR_ATTACHMENT4: 2004,
COLOR_ATTACHMENT5: 2005,
COLOR_ATTACHMENT6: 2006,
COLOR_ATTACHMENT7: 2007,
COLOR_ATTACHMENT8: 2008,
COLOR_ATTACHMENT9: 2009,
COLOR_ATTACHMENT10: 2010,
COLOR_ATTACHMENT11: 2011,
COLOR_ATTACHMENT12: 2012,
COLOR_ATTACHMENT13: 2013,
COLOR_ATTACHMENT14: 2014,
COLOR_ATTACHMENT15: 2015,
DEPTH_ATTACHMENT: 2020,
STENCIL_ATTACHMENT: 2021,
DEPTH_STENCIL_ATTACHMENT: 2030
};
/**
* Enum for BUFFER_USAGE
* @readonly
* @enum {number}
*/
const BUFFER_USAGE = {
STREAM_DRAW: 35040,
STREAM_READ: 35041,
STREAM_COPY: 35042,
STATIC_DRAW: 35044,
STATIC_READ: 35045,
STATIC_COPY: 35046,
DYNAMIC_DRAW: 35048,
DYNAMIC_READ: 35049,
DYNAMIC_COPY: 35050
};
/**
* Enum for QUERYSET_TYPE
* @readonly
* @enum {number}
*/
const QUERYSET_TYPE = {
OCCLUSION: 8000,
TIMESTAMP: 8001
};
/**
* JavaScript events for custom objects.
*/
class EventDispatcher {
/**
* Adds a listener to an event type.
* @param {string} type - The type of event to listen to.
* @param {Function} listener - The function that gets called when the event is fired.
*/
addEventListener(type, listener) {
if (this._listeners === undefined) this._listeners = {};
const listeners = this._listeners;
if (listeners[type] === undefined) {
listeners[type] = [];
}
if (listeners[type].indexOf(listener) === -1) {
listeners[type].push(listener);
}
}
/**
* Removes a listener from an event type.
* @param {string} type - The type of the listener that gets removed.
* @param {Function} listener - The listener function that gets removed.
*/
removeEventListener(type, listener) {
const listeners = this._listeners;
if (listeners === undefined) return;
const listenerArray = listeners[type];
if (listenerArray !== undefined) {
const index = listenerArray.indexOf(listener);
if (index !== -1) {
listenerArray.splice(index, 1);
}
}
}
/**
* Fire an event.
* @param {object} event - The event that gets fired.
*/
dispatchEvent(event) {
const listeners = this._listeners;
if (listeners === undefined) return;
const listenerArray = listeners[event.type];
if (listenerArray !== undefined) {
event.target = this;
// Make a copy, in case listeners are removed while iterating.
const array = listenerArray.slice(0);
for (let i = 0, l = array.length; i < l; i++) {
array[i].call(this, event);
}
event.target = null;
}
}
}
/**
* AnimationAction wraps AnimationClip and is mainly responsible for the update logic of time.
* You can extend other functions by inheriting this class, such as repeat playback, pingpang, etc.
* And since this class inherits from EventDispatcher, animation events can also be extended.
* @extends EventDispatcher
*/
class AnimationAction extends EventDispatcher {
/**
* @param {KeyframeClip} clip - The keyframe clip for this action.
*/
constructor(clip) {
super();
/**
* The keyframe clip for this action.
* @type {KeyframeClip}
*/
this.clip = clip;
/**
* The degree of influence of this action (in the interval [0, 1]).
* Values can be used to blend between several actions.
* @type {number}
* @default 0
*/
this.weight = 0;
/**
* The local time of this action (in seconds).
* @type {number}
*/
this.time = 0;
/**
* The blend mode for this action, currently only two values BLEND_TYPE.NORMAL and BLEND_TYPE.ADD are available.
* @type {BLEND_TYPE}
* @default {BLEND_TYPE.NORMAL}
*/
this.blendMode = BLEND_TYPE.NORMAL;
}
/**
* Update time.
* @param {number} deltaTime - The delta time in seconds.
*/
update(deltaTime) {
this.time += deltaTime;
const endTime = this.clip.duration;
if (endTime === 0) {
this.time = 0;
return;
}
if (this.time > endTime) {
this.time = this.time % endTime;
}
if (this.time < 0) {
this.time = this.time % endTime + endTime;
}
}
}
/**
* This holds a reference to a real property in the scene graph; used internally.
* Binding property and value, mixer for multiple values.
*/
class PropertyBindingMixer {
/**
* @param {Object3D|Material} target
* @param {string} propertyPath
* @param {string} typeName - vector/bool/string/quaternion/number/color
* @param {number} valueSize
*/
constructor(target, propertyPath, typeName, valueSize) {
this.target = null;
this.property = '';
this.parseBinding(target, propertyPath);
this.valueSize = valueSize;
let BufferType = Float64Array;
let mixFunction, mixFunctionAdditive, setIdentity;
switch (typeName) {
case 'quaternion':
mixFunction = slerp;
mixFunctionAdditive = slerpAdditive;
setIdentity = setIdentityQuaternion;
break;
case 'string':
case 'bool':
BufferType = Array;
mixFunction = select;
mixFunctionAdditive = select;
setIdentity = setIdentityOther;
break;
default:
mixFunction = lerp;
mixFunctionAdditive = lerpAdditive;
setIdentity = setIdentityNumeric;
}
// [ incoming | accu | orig | addAccu ]
this.buffer = new BufferType(valueSize * 4);
this._mixBufferFunction = mixFunction;
this._mixBufferFunctionAdditive = mixFunctionAdditive;
this._setIdentity = setIdentity;
this.cumulativeWeight = 0;
this.cumulativeWeightAdditive = 0;
// cache whether the bound property should be treated as an array-like value
// (treat existing arrays or types with toArray/fromArray as array bindings,
// or when valueSize > 1)
const boundValue = this.target && this.target[this.property];
this._isArrayProperty = this.valueSize > 1 || Array.isArray(boundValue) || boundValue && (typeof boundValue.toArray === 'function' || typeof boundValue.fromArray === 'function');
}
parseBinding(target, propertyPath) {
propertyPath = propertyPath.split('.');
if (propertyPath.length > 1) {
let property = target[propertyPath[0]];
for (let index = 1; index < propertyPath.length - 1; index++) {
property = property[propertyPath[index]];
}
this.property = propertyPath[propertyPath.length - 1];
this.target = property;
} else {
this.property = propertyPath[0];
this.target = target;
}
}
/**
* Remember the state of the bound property and copy it to both accus.
*/
saveOriginalState() {
const buffer = this.buffer,
stride = this.valueSize,
originalValueOffset = stride * 2;
// get value
if (this._isArrayProperty) {
if (this.target[this.property].toArray) {
this.target[this.property].toArray(buffer, originalValueOffset);
} else {
setArray(buffer, this.target[this.property], originalValueOffset, stride);
}
} else {
this.target[this.property] = buffer[originalValueOffset];
}
// accu[0..1] := orig -- initially detect changes against the original
for (let i = stride, e = originalValueOffset; i !== e; ++i) {
buffer[i] = buffer[originalValueOffset + i % stride];
}
// Add to identify for additive
this._setIdentity(buffer, stride * 3, stride, originalValueOffset);
this.cumulativeWeight = 0;
this.cumulativeWeightAdditive = 0;
}
/**
* Apply the state previously taken via 'saveOriginalState' to the binding.
*/
restoreOriginalState() {
const buffer = this.buffer,
stride = this.valueSize,
originalValueOffset = stride * 2;
// accu[0..1] := orig -- initially detect changes against the original
for (let i = stride, e = originalValueOffset; i !== e; ++i) {
buffer[i] = buffer[originalValueOffset + i % stride];
}
this.apply();
}
/**
* Accumulate value.
* @param {number} weight
*/
accumulate(weight) {
const buffer = this.buffer,
stride = this.valueSize,
offset = stride;
let currentWeight = this.cumulativeWeight;
if (currentWeight === 0) {
for (let i = 0; i !== stride; ++i) {
buffer[offset + i] = buffer[i];
}
currentWeight = weight;
} else {
currentWeight += weight;
const mix = weight / currentWeight;
this._mixBufferFunction(buffer, offset, 0, mix, stride);
}
this.cumulativeWeight = currentWeight;
}
/**
* Additive Accumulate value.
* @param {number} weight
*/
accumulateAdditive(weight) {
const buffer = this.buffer,
stride = this.valueSize,
offset = stride * 3;
if (this.cumulativeWeightAdditive === 0) {
this._setIdentity(buffer, offset, stride, stride * 2);
}
this._mixBufferFunctionAdditive(buffer, offset, 0, weight, stride);
this.cumulativeWeightAdditive += weight;
}
/**
* Apply to scene graph.
*/
apply() {
const buffer = this.buffer,
stride = this.valueSize,
weight = this.cumulativeWeight,
weightAdditive = this.cumulativeWeightAdditive;
this.cumulativeWeight = 0;
this.cumulativeWeightAdditive = 0;
if (weight < 1) {
// accuN := accuN + original * ( 1 - cumulativeWeight )
const originalValueOffset = stride * 2;
this._mixBufferFunction(buffer, stride, originalValueOffset, 1 - weight, stride);
}
if (weightAdditive > 0) {
// accuN := accuN + additive accuN
this._mixBufferFunctionAdditive(buffer, stride, 3 * stride, 1, stride);
}
// set value
if (this._isArrayProperty) {
if (this.target[this.property].fromArray) {
this.target[this.property].fromArray(buffer, stride);
} else {
getArray(this.target[this.property], buffer, stride, stride);
}
} else {
this.target[this.property] = buffer[stride];
}
if (this.target.isTransformUV) {
this.target.needsUpdate = true;
}
}
}
// Mix functions
function select(buffer, dstOffset, srcOffset, t, stride) {
if (t >= 0.5) {
for (let i = 0; i !== stride; ++i) {
buffer[dstOffset + i] = buffer[srcOffset + i];
}
}
}
function slerp(buffer, dstOffset, srcOffset, t) {
Quaternion.slerpFlat(buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t);
}
const tempQuternionBuffer = new Float64Array(4);
function slerpAdditive(buffer, dstOffset, srcOffset, t) {
// Store result in tempQuternionBuffer
Quaternion.multiplyQuaternionsFlat(tempQuternionBuffer, 0, buffer, dstOffset, buffer, srcOffset);
// Slerp to the result
Quaternion.slerpFlat(buffer, dstOffset, buffer, dstOffset, tempQuternionBuffer, 0, t);
}
function lerp(buffer, dstOffset, srcOffset, t, stride) {
const s = 1 - t;
for (let i = 0; i !== stride; ++i) {
const j = dstOffset + i;
buffer[j] = buffer[j] * s + buffer[srcOffset + i] * t;
}
}
function lerpAdditive(buffer, dstOffset, srcOffset, t, stride) {
for (let i = 0; i !== stride; ++i) {
const j = dstOffset + i;
buffer[j] = buffer[j] + buffer[srcOffset + i] * t;
}
}
// identity
function setIdentityNumeric(buffer, offset, stride) {
for (let i = 0; i < stride; i++) {
buffer[offset + i] = 0;
}
}
function setIdentityQuaternion(buffer, offset) {
setIdentityNumeric(buffer, offset, 3);
buffer[offset + 3] = 1;
}
function setIdentityOther(buffer, offset, stride, copyOffset) {
for (let i = 0; i < stride; i++) {
buffer[offset + i] = buffer[copyOffset + i];
}
}
// get array
function getArray(target, source, stride, count) {
for (let i = 0; i < count; i++) {
target[i] = source[stride + i];
}
}
function setArray(target, source, stride, count) {
for (let i = 0; i < count; i++) {
target[stride + i] = source[i];
}
}
/**
* The AnimationMixer is a player for animations on a particular object in the scene.
* When multiple objects in the scene are animated independently, one AnimationMixer may be used for each object.
*/
class AnimationMixer {
constructor() {
this._actions = [];
this._bindings = {};
}
/**
* Add an action to this mixer.
* @param {AnimationAction} action - The action to add.
*/
addAction(action) {
if (this._actions.indexOf(action) !== -1) {
console.warn('AnimationMixer.addAction(): already has the action, clip name is <' + action.clip.name + '>.');
return;
}
this._actions.push(action);
const tracks = action.clip.tracks;
for (let i = 0; i < tracks.length; i++) {
const track = tracks[i];
const trackName = track.name;
if (!this._bindings[trackName]) {
const binding = new PropertyBindingMixer(track.target, track.propertyPath, track.valueTypeName, track.valueSize);
this._bindings[trackName] = {
binding,
referenceCount: 0,
active: false,
cachedActive: false
};
}
this._bindings[trackName].referenceCount++;
}
}
/**
* Remove an action from this mixer.
* @param {AnimationAction} action - The action to be removed.
*/
removeAction(action) {
const index = this._actions.indexOf(action);
if (index === -1) {
console.warn('AnimationMixer.removeAction(): action not found in this mixer, clip name is <' + action.clip.name + '>.');
return;
}
if (action.weight > 0) {
console.warn('AnimationMixer.removeAction(): make sure action\'s weight is zero before removing it.');
return;
}
this._actions.splice(index, 1);
const tracks = action.clip.tracks;
for (let i = 0; i < tracks.length; i++) {
const trackName = tracks[i].name;
const bindingInfo = this._bindings[trackName];
if (bindingInfo) {
if (--bindingInfo.referenceCount <= 0) {
if (bindingInfo.cachedActive) {
bindingInfo.binding.restoreOriginalState();
}
delete this._bindings[trackName];
}
}
}
}
/**
* Whether has this action.
* @param {AnimationAction} action - The action.
* @returns {boolean}
*/
hasAction(action) {
return this._actions.indexOf(action) > -1;
}
/**
* Get all actions.
* @returns {AnimationAction[]}
*/
getActions() {
return this._actions;
}
/**
* Advances the global mixer time and updates the animation.
* @param {number} deltaTime - The delta time in seconds.
*/
update(deltaTime) {
// Mark active to false for all bindings.
for (const bindingName in this._bindings) {
this._bindings[bindingName].active = false;
}
// Update the time of actions with a weight greater than 1
// And accumulate those bindings
for (let i = 0, l = this._actions.length; i < l; i++) {
const action = this._actions[i];
if (action.weight > 0) {
action.update(deltaTime);
const tracks = action.clip.tracks;
for (let j = 0, tl = tracks.length; j < tl; j++) {
const track = tracks[j];
const bindingInfo = this._bindings[track.name];
const binding = bindingInfo.binding;
bindingInfo.active = true;
if (!bindingInfo.cachedActive) {
bindingInfo.binding.saveOriginalState();
bindingInfo.cachedActive = true;
}
track.getValue(action.time, binding.buffer);
if (action.blendMode === BLEND_TYPE.ADD) {
binding.accumulateAdditive(action.weight);
} else {
binding.accumulate(action.weight);
}
}
}
}
// Apply all bindings.
for (const bindingName in this._bindings) {
const bindingInfo = this._bindings[bindingName];
if (bindingInfo.active) {
bindingInfo.binding.apply();
} else {
if (bindingInfo.cachedActive) {
bindingInfo.binding.restoreOriginalState();
bindingInfo.cachedActive = false;
}
}
}
}
}
/**
* An KeyframeClip is a reusable set of keyframe tracks which represent an animation.
*/
class KeyframeClip {
/**
* @param {string} [name=''] - A name for this clip.
* @param {KeyframeTrack[]} [tracks=[]] - An array of KeyframeTracks.
* @param {number} [duration] - The duration of this clip (in seconds). If not passed, the duration will be calculated from the passed tracks array.
*/
constructor(name = '', tracks = [], duration = -1) {
/**
* A name for this clip.
* @type {string}
*/
this.name = name;
/**
* An array of KeyframeTracks.
* @type {KeyframeTrack[]}
*/
this.tracks = tracks;
/**
* The duration of this clip (in seconds).
* If a negative value is passed, the duration will be calculated from the passed tracks array.
* @type {number}
*/
this.duration = duration;
if (this.duration < 0) {
this.resetDuration();
}
}
/**
* Sets the duration of the clip to the duration of its longest KeyframeTrack.
* @returns {KeyframeClip}
*/
resetDuration() {
const tracks = this.tracks;
let duration = 0;
for (let i = 0, l = tracks.length; i < l; i++) {
const track = tracks[i];
duration = Math.max(duration, track.times[track.times.length - 1]);
}
this.duration = duration;
return this;
}
}
/**
* Handles and keeps track of loaded and pending data. A default global
* instance of this class is created and used by loaders if not supplied
* manually.
* In general that should be sufficient, however there are times when it can
* be useful to have separate loaders - for example if you want to show
* separate loading bars for objects and textures.
* ```js
* const manager = new LoadingManager(
* () => console.log('All items loaded!'),
* (url, itemsLoaded, itemsTotal) => {
* console.log(`Loaded ${itemsLoaded} of ${itemsTotal} items`);
* },
* url => console.error(`Error loading ${url}`)
* );
* ```
*/
class LoadingManager {
/**
* Constructs a new loading manager.
* @param {Function} [onLoad] - Executes when all items have been loaded.
* @param {Function} [onProgress] - Executes when single items have been loaded.
* @param {Function} [onError] - Executes when an error occurs.
*/
constructor(onLoad, onProgress, onError) {
this.isLoading = false;
this.itemsLoaded = 0;
this.itemsTotal = 0;
this.urlModifier = undefined;
/**
* Executes when an item starts loading.
* @type {Function|undefined}
* @default undefined
*/
this.onStart = undefined;
/**
* Executes when all items have been loaded.
* @type {Function|undefined}
* @default undefined
*/
this.onLoad = onLoad;
/**
* Executes when single items have been loaded.
* @type {Function|undefined}
* @default undefined
*/
this.onProgress = onProgress;
/**
* Executes when an error occurs.
* @type {Function|undefined}
* @default undefined
*/
this.onError = onError;
}
/**
* This should be called by any loader using the manager when the loader
* starts loading an item.
* @param {string} url - The URL to load.
*/
itemStart(url) {
this.itemsTotal++;
if (this.isLoading === false) {
if (this.onStart !== undefined) {
this.onStart(url, this.itemsLoaded, this.itemsTotal);
}
}
this.isLoading = true;
}
/**
* This should be called by any loader using the manager when the loader
* ended loading an item.
* @param {string} url - The URL of the loaded item.
*/
itemEnd(url) {
this.itemsLoaded++;
if (this.onProgress !== undefined) {
this.onProgress(url, this.itemsLoaded, this.itemsTotal);
}
if (this.itemsLoaded === this.itemsTotal) {
this.isLoading = false;
if (this.onLoad !== undefined) {
this.onLoad();
}
}
}
/**
* This should be called by any loader using the manager when the loader
* encounters an error when loading an item.
* @param {string} url - The URL of the item that produces an error.
*/
itemError(url) {
if (this.onError !== undefined) {
this.onError(url);
}
}
/**
* Given a URL, uses the URL modifier callback (if any) and returns a
* resolved URL. If no URL modifier is set, returns the original URL.
* @param {string} url - The URL to load.
* @returns {string} The resolved URL.
*/
resolveURL(url) {
if (this.urlModifier) {
return this.urlModifier(url);
}
return url;
}
/**
* If provided, the callback will be passed each resource URL before a
* request is sent. The callback may return the original URL, or a new URL to
* override loading behavior. This behavior can be used to load assets from
* .ZIP files, drag-and-drop APIs, and Data URIs.
* @param {Function} transform - URL modifier callback. Called with an URL and must return a resolved URL.
* @returns {LoadingManager} A reference to this loading manager.
* @example
* const blobs = { 'fish.gltf': blob1, 'diffuse.png': blob2, 'normal.png': blob3 };
*
* const manager = new LoadingManager();
*
* // Initialize loading manager with URL callback.
* const objectURLs = [];
* manager.setURLModifier(url => {
* url = URL.createObjectURL(blobs[url]);
* objectURLs.push(url);
* return url;
* });
*
* // Load as usual, then revoke the blob URLs.
* const loader = new GLTFLoader(manager);
* loader.load('fish.gltf', gltf => {
* scene.add(gltf.scene);
* objectURLs.forEach(url => URL.revokeObjectURL(url));
* });
*/
setURLModifier(transform) {
this.urlModifier = transform;
return this;
}
}
/**
* The global default loading manager.
* @type {LoadingManager}
*/
const DefaultLoadingManager = new LoadingManager();
/**
* Abstract base class for loaders.
* @abstract
*/
class Loader {
/**
* Constructs a new Loader.
* @param {LoadingManager} [manager=DefaultLoadingManager] - The loading manager.
*/
constructor(manager) {
/**
* The loading manager.
* @type {LoadingManager}
* @default DefaultLoadingManager
*/
this.manager = manager !== undefined ? manager : DefaultLoadingManager;
/**
* The crossOrigin string to implement CORS for loading the url from a
* different domain that allows CORS.
* @type {string}
* @default 'anonymous'
*/
this.crossOrigin = 'anonymous';
/**
* Whether the XMLHttpRequest uses credentials.
* @type {boolean}
* @default false
*/
this.withCredentials = false;
/**
* The base path from which the asset will be loaded.
* @type {string}
* @default ''
*/
this.path = '';
/**
* The [request header]{@link https://developer.mozilla.org/en-US/docs/Glossary/Request_header}
* used in HTTP request.
* @type {object}
* @default {}
*/
this.requestHeader = {};
}
/**
* This method needs to be implement by all concrete loaders.
* It holds the logic for loading the asset from the backend.
* @param {string} url - The path/URL of the file to be loaded.
* @param {Function} onLoad - Executed when the loading process has been finished.
* @param {onProgressCallback} [onProgress] - Executed while the loading is in progress.
* @param {onErrorCallback} [onError] - Executed when errors occur.
*/
load(url, onLoad, onProgress, onError) {}
/**
* A async version of {@link Loader#load}.
* @param {string} url - The path/URL of the file to be loaded.
* @param {Function} [onProgress] - Executed while the loading is in progress.
* @returns {Promise} A Promise that resolves when the asset has been loaded.
*/
loadAsync(url, onProgress) {
const scope = this;
return new Promise(function (resolve, reject) {
scope.load(url, resolve, onProgress, reject);
});
}
/**
* Sets the `crossOrigin` String to implement CORS for loading the URL
* from a different domain that allows CORS.
* @param {string} crossOrigin - The `crossOrigin` value.
* @returns {Loader} A reference to this instance.
*/
setCrossOrigin(crossOrigin) {
this.crossOrigin = crossOrigin;
return this;
}
/**
* Whether the XMLHttpRequest uses credentials such as cookies, authorization
* headers or TLS client certificates, see [XMLHttpRequest.withCredentials]{@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials}.
* Note: This setting has no effect if you are loading files locally or from the same domain.
* @param {boolean} value - The `withCredentials` value.
* @returns {Loader} A reference to this instance.
*/
setWithCredentials(value) {
this.withCredentials = value;
return this;
}
/**
* Sets the base path for the asset.
* @param {string} path - The base path.
* @returns {Loader} A reference to this instance.
*/
setPath(path) {
this.path = path;
return this;
}
/**
* Sets the given request header.
* @param {object} requestHeader - A [request header]{@link https://developer.mozilla.org/en-US/docs/Glossary/Request_header}
* for configuring the HTTP request.
* @returns {Loader} A reference to this instance.
*/
setRequestHeader(requestHeader) {
this.requestHeader = requestHeader;
return this;
}
}
/**
* A low level class for loading resources with the Fetch API, used internally by
* most loaders. It can also be used directly to load any file type that does
* not have a loader.
* ```js
* const loader = new FileLoader();
* const data = await loader.loadAsync('example.txt');
* ```
* @extends Loader
*/
class FileLoader extends Loader {
/**
* Constructs a new file loader.
* @param {LoadingManager} [manager] - The loading manager.
*/
constructor(manager) {
super(manager);
/**
* The expected response type. See {@link FileLoader.setResponseType}.
* @type {'arraybuffer'|'blob'|'document'|'json'|''}
* @default ''
*/
this.responseType = '';
/**
* The expected mimeType. See {@link FileLoader.setMimeType}.
* @type {string}
* @default ''
*/
this.mimeType = '';
}
/**
* Starts loading from the given URL and pass the loaded response to the `onLoad()` callback.
* @param {string} url — The path/URL of the file to be loaded. This can also be a data URI.
* @param {Function} [onLoad] — Executed when the loading process has been finished. The argument is the loaded data.
* @param {onProgressCallback} [onProgress] — Executed while the loading is in progress.
* @param {onErrorCallback} [onError] — Executed when errors occur.
*/
load(url, onLoad, onProgress, onError) {
if (url === undefined) url = '';
if (this.path != undefined) url = this.path + url;
url = this.manager.resolveURL(url);
// create request
const req = new Request(url, {
headers: new Headers(this.requestHeader),
credentials: this.withCredentials ? 'include' : 'same-origin'
// An abort controller could be added within a future PR
});
// record states ( avoid data race )
const mimeType = this.mimeType;
const responseType = this.responseType;
// start the fetch
fetch(req).then(response => {
if (response.status === 200 || response.status === 0) {
// Some browsers return HTTP Status 0 when using non-http protocol
// e.g. 'file://' or 'data://'. Handle as success.
if (response.status === 0) {
console.warn('FileLoader: HTTP Status 0 received.');
}
// Workaround: Checking if response.body === undefined for Alipay browser #23548
if (typeof ReadableStream === 'undefined' || response.body === undefined || response.body.getReader === undefined) {
return response;
}
const reader = response.body.getReader();
// Nginx needs X-File-Size check
// https://serverfault.com/questions/482875/why-does-nginx-remove-content-length-header-for-chunked-content
const contentLength = response.headers.get('X-File-Size') || response.headers.get('Content-Length');
const total = contentLength ? parseInt(contentLength) : 0;
const lengthComputable = total !== 0;
let loaded = 0;
// periodically read data into the new stream tracking while download progress
const stream = new ReadableStream({
start(controller) {
readData();
function readData() {
reader.read().then(({
done,
value
}) => {
if (done) {
controller.close();
} else {
loaded += value.byteLength;
const event = new ProgressEvent('progress', {
lengthComputable,
loaded,
total
});
if (onProgress) onProgress(event);
controller.enqueue(value);
readData();
}
}, error => {
controller.error(error);
});
}
}
});
return new Response(stream);
} else {
throw new HttpError(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`, response);
}
}).then(response => {
switch (responseType) {
case 'arraybuffer':
return response.arrayBuffer();
case 'blob':
return response.blob();
case 'document':
return response.text().then(text => {
const parser = new DOMParser();
return parser.parseFromString(text, mimeType);
});
case 'json':
return response.json();
default:
if (mimeType === '') {
return response.text();
} else {
// sniff encoding
const re = /charset="?([^;"\s]*)"?/i;
const exec = re.exec(mimeType);
const label = exec && exec[1] ? exec[1].toLowerCase() : undefined;
const decoder = new TextDecoder(label);
return response.arrayBuffer().then(ab => decoder.decode(ab));
}
}
}).then(data => {
if (onLoad) onLoad(data);
}).catch(err => {
onError && onError(err);
this.manager.itemError(url);
}).finally(() => {
this.manager.itemEnd(url);
});
this.manager.itemStart(url);
}
/**
* Sets the expected response type.
* @param {'arraybuffer'|'blob'|'document'|'json'|''} value - The response type.
* @returns {FileLoader} A reference to this file loader.
*/
setResponseType(value) {
this.responseType = value;
return this;
}
/**
* Sets the expected mime type of the loaded file.
* @param {string} value - The mime type.
* @returns {FileLoader} A reference to this file loader.
*/
setMimeType(value) {
this.mimeType = value;
return this;
}
}
class HttpError extends Error {
constructor(message, response) {
super(message);
this.response = response;
}
}
/**
* A loader for loading images. The class loads images with the HTML `Image` API.
* Please note that 'ImageLoader' not support progress events.
* ```js
* const loader = new ImageLoader();
* const image = await loader.loadAsync('image.png');
* ```
* @extends Loader
*/
class ImageLoader extends Loader {
/**
* Constructs a new image loader.
* @param {LoadingManager} [manager] - The loading manager.
*/
constructor(manager) {
super(manager);
}
/**
* Starts loading from the given URL and passes the loaded image
* to the `onLoad()` callback. The method also returns a new `Image` object which can
* directly be used for texture creation. If you do it this way, the texture
* may pop up in your scene once the respective loading process is finished.
* @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
* @param {Function} [onLoad] - Executed when the loading process has been finished. The argument is an `HTMLImageElement`.
* @param {onProgressCallback} [onProgress] - Unsupported in this loader.
* @param {onErrorCallback} [onError] - Executed when errors occur.
* @returns {HTMLImageElement} The image.
*/
load(url, onLoad, onProgress, onError) {
if (url === undefined) url = '';
if (this.path !== undefined) url = this.path + url;
url = this.manager.resolveURL(url);
const scope = this;
const image = document.createElementNS('http://www.w3.org/1999/xhtml', 'img');
function onImageLoad() {
removeEventListeners();
if (onLoad) onLoad(this);
scope.manager.itemEnd(url);
}
function onImageError(event) {
removeEventListeners();
if (onError) onError(event);
scope.manager.itemError(url);
scope.manager.itemEnd(url);
}
function removeEventListeners() {
image.removeEventListener('load', onImageLoad, false);
image.removeEventListener('error', onImageError, false);
}
image.addEventListener('load', onImageLoad, false);
image.addEventListener('error', onImageError, false);
if (url.slice(0, 5) !== 'data:') {
if (this.crossOrigin !== undefined) image.crossOrigin = this.crossOrigin;
}
scope.manager.itemStart(url);
image.src = url;
return image;
}
}
/**
* The vector 2 class
*/
class Vector2 {
/**
* @param {number} [x=0] - the x value of this vector.
* @param {number} [y=0] - the y value of this vector.
*/
constructor(x = 0, y = 0) {
this.x = x;
this.y = y;
}
/**
* Sets the x and y components of this vector.
* @param {number} x
* @param {number} y
* @returns {Vector2}
*/
set(x = 0, y = 0) {
this.x = x;
this.y = y;
return this;
}
/**
* Sets this vector to be the vector linearly interpolated between v1 and v2
* where ratio is the percent distance along the line connecting the two vectors
* - ratio = 0 will be v1, and ratio = 1 will be v2.
* @param {Vector2} v1 - the starting Vector2.
* @param {Vector2} v2 - Vector2 to interpolate towards.
* @param {number} ratio - interpolation factor, typically in the closed interval [0, 1].
* @returns {Vector2}
*/
lerpVectors(v1, v2, ratio) {
return this.subVectors(v2, v1).multiplyScalar(ratio).add(v1);
}
/**
* If this vector's x or y value is greater than v's x or y value, replace that value with the corresponding min value.
* @param {Vector2} v
* @returns {Vector2}
*/
min(v) {
this.x = Math.min(this.x, v.x);
this.y = Math.min(this.y, v.y);
return this;
}
/**
* If this vector's x or y value is less than v's x or y value, replace that value with the corresponding max value.
* @param {Vector2} v
* @returns {Vector2}
*/
max(v) {
this.x = Math.max(this.x, v.x);
this.y = Math.max(this.y, v.y);
return this;
}
/**
* Computes the Euclidean length (straight-line length) from (0, 0) to (x, y).
* @returns {number}
*/
getLength() {
return Math.sqrt(this.getLengthSquared());
}
/**
* Computes the square of the Euclidean length (straight-line length) from (0, 0) to (x, y).
* If you are comparing the lengths of vectors, you should compare the length squared instead
* as it is slightly more efficient to calculate.
* @returns {number}
*/
getLengthSquared() {
return this.x * this.x + this.y * this.y;
}
/**
* Converts this vector to a unit vector - that is, sets it equal to a vector with the same direction as this one, but length 1.
* @param {number} [thickness=1]
* @returns {Vector2}
*/
normalize(thickness = 1) {
const length = this.getLength() || 1;
const invLength = thickness / length;
this.x *= invLength;
this.y *= invLength;
return this;
}
/**
* Subtracts v from the vector.
* @param {Vector2} a
* @param {Vector2} target - the result vector2
* @returns {Vector2}
*/
subtract(a, target = new Vector2()) {
return target.set(this.x - a.x, this.y - a.y);
}
/**
* Subtracts v from this vector.
* @param {Vector2} v
* @returns {Vector2}
*/
sub(v) {
this.x -= v.x;
this.y -= v.y;
return this;
}
/**
* Copies the values of the passed Vector2's x and y properties to this Vector2.
* @param {Vector2} v
* @returns {Vector2}
*/
copy(v) {
this.x = v.x;
this.y = v.y;
return this;
}
/**
* Sets this vector to a + b.
* @param {Vector2} a
* @param {Vector2} b
* @returns {Vector2}
*/
addVectors(a, b) {
this.x = a.x + b.x;
this.y = a.y + b.y;
return this;
}
/**
* Sets this vector to a - b.
* @param {Vector2} a
* @param {Vector2} b
* @returns {Vector2}
*/
subVectors(a, b) {
this.x = a.x - b.x;
this.y = a.y - b.y;
return this;
}
/**
* Multiplies this vector by scalar.
* @param {number} scalar
* @returns {Vector2}
*/
multiplyScalar(scalar) {
this.x *= scalar;
this.y *= scalar;
return this;
}
/**
* Computes the squared distance from this vector to v. If you are just comparing the distance with
* another distance, you should compare the distance squared instead as it is slightly more efficient to calculate.
* @param {Vector2} v
* @returns {number}
*/
distanceToSquared(v) {
const dx = this.x - v.x,
dy = this.y - v.y;
return dx * dx + dy * dy;
}
/**
* Computes the distance from this vector to v.
* @param {Vector2} v
* @returns {number}
*/
distanceTo(v) {
return Math.sqrt(this.distanceToSquared(v));
}
/**
* Sets this vector's x value to be array[ offset ] and y value to be array[ offset + 1 ].
* @param {number[]} array - the source array.
* @param {number} [offset=0] - offset into the array.
* @param {boolean} [denormalize=false] - if true, denormalize the values, and array should be a typed array.
* @returns {Vector2}
*/
fromArray(array, offset = 0, denormalize = false) {
let x = array[offset],
y = array[offset + 1];
if (denormalize) {
x = MathUtils.denormalize(x, array);
y = MathUtils.denormalize(y, array);
}
this.x = x;
this.y = y;
return this;
}
/**
* Sets this array[ offset ] value to be vector's x and array[ offset + 1 ] to be vector's y.
* @param {number[]} [array] - the target array.
* @param {number} [offset=0] - offset into the array.
* @param {boolean} [normalize=false] - if true, normalize the values, and array should be a typed array.
* @returns {number[]}
*/
toArray(array = [], offset = 0, normalize = false) {
let x = this.x,
y = this.y;
if (normalize) {
x = MathUtils.normalize(x, array);
y = MathUtils.normalize(y, array);
}
array[offset] = x;
array[offset + 1] = y;
return array;
}
/**
* Adds v to this vector.
* @param {Vector2} v
* @returns {Vector2}
*/
add(v) {
this.x += v.x;
this.y += v.y;
return this;
}
/**
* Computes the angle in radians of this vector with respect to the positive x-axis.
* @returns {number}
*/
angle() {
// computes the angle in radians with respect to the positive x-axis
// let angle = Math.atan2(this.y, this.x);
// if (angle < 0) angle += 2 * Math.PI;
// return angle;
return Math.atan2(-this.y, -this.x) + Math.PI;
}
/**
* Inverts this vector - i.e. sets x = -x, y = -y.
* @returns {Vector2}
*/
negate() {
this.x = -this.x;
this.y = -this.y;
return this;
}
/**
* Calculate the dot product of this vector and v.
* @param {Vector2} a
* @returns {number}
*/
dot(a) {
return this.x * a.x + this.y * a.y;
}
/**
* Checks for strict equality of this vector and v.
* @param {Vector2} v
* @returns {boolean}
*/
equals(v) {
return v.x === this.x && v.y === this.y;
}
/**
* Returns a new Vector2 with the same x and y values as this one.
* @returns {Vector2}
*/
clone() {
return new Vector2(this.x, this.y);
}
*[Symbol.iterator]() {
yield this.x;
yield this.y;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Vector2.prototype.isVector2 = true;
/**
* Represents an axis-aligned bounding box (AABB) in 2D space.
*/
class Box2 {
/**
* @param {Vector2} min - (optional) Vector2 representing the lower (x, y) boundary of the box.
* Default is ( + Infinity, + Infinity ).
* @param {Vector2} max - (optional) Vector2 representing the upper (x, y) boundary of the box.
* Default is ( - Infinity, - Infinity ).
*/
constructor(min, max) {
this.min = min !== undefined ? min : new Vector2(+Infinity, +Infinity);
this.max = max !== undefined ? max : new Vector2(-Infinity, -Infinity);
}
/**
* @param {number} x1
* @param {number} y1
* @param {number} x2
* @param {number} y2
*/
set(x1, y1, x2, y2) {
this.min.set(x1, y1);
this.max.set(x2, y2);
}
/**
* Returns a new Box2 with the same min and max as this one.
* @returns {Box2}
*/
clone() {
return new Box2().copy(this);
}
/**
* Copies the min and max from box to this box.
* @param {Box2} box
* @returns {Box2}
*/
copy(box) {
this.min.copy(box.min);
this.max.copy(box.max);
return this;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Box2.prototype.isBox2 = true;
/**
* Represents an axis-aligned bounding box (AABB) in 3D space.
*/
class Box3 {
/**
* @param {Vector3} min - (optional) Vector3 representing the lower (x, y, z) boundary of the box.
* Default is ( + Infinity, + Infinity, + Infinity ).
* @param {Vector3} max - (optional) Vector3 representing the upper (x, y, z) boundary of the box.
* Default is ( - Infinity, - Infinity, - Infinity ).
*/
constructor(min, max) {
this.min = min !== undefined ? min : new Vector3(+Infinity, +Infinity, +Infinity);
this.max = max !== undefined ? max : new Vector3(-Infinity, -Infinity, -Infinity);
}
/**
* Sets the lower and upper (x, y, z) boundaries of this box.
* @param {Vector3} min - Vector3 representing the lower (x, y, z) boundary of the box.
* @param {Vector3} max - Vector3 representing the lower upper (x, y, z) boundary of the box.
*/
set(min, max) {
this.min.copy(min);
this.max.copy(max);
}
/**
* Sets the upper and lower bounds of this box to include all of the points in points.
* @param {Vector3[]} points - Array of Vector3s that the resulting box will contain.
* @returns {Box3}
*/
setFromPoints(points) {
this.makeEmpty();
for (let i = 0, il = points.length; i < il; i++) {
this.expandByPoint(points[i]);
}
return this;
}
/**
* Makes this box empty.
* @returns {Box3}
*/
makeEmpty() {
this.min.x = this.min.y = this.min.z = +Infinity;
this.max.x = this.max.y = this.max.z = -Infinity;
return this;
}
/**
* Expands the boundaries of this box to include point.
* @param {Vector3} point - Vector3 that should be included in the box.
* @returns {Box3}
*/
expandByPoint(point) {
this.min.min(point);
this.max.max(point);
return this;
}
/**
* Expands each dimension of the box by scalar. If negative, the dimensions of the box will be contracted.
* @param {number} scalar - Distance to expand the box by.
* @returns {Box3}
*/
expandByScalar(scalar) {
this.min.addScalar(-scalar);
this.max.addScalar(scalar);
return this;
}
/**
* Expands the boundaries of this box to include box3.
* @param {Box3} box3 - Box that will be unioned with this box.
* @returns {Box3}
*/
expandByBox3(box3) {
this.min.min(box3.min);
this.max.max(box3.max);
return this;
}
/**
* Sets the upper and lower bounds of this box to include all of the data in array.
* @param {number[]} array - An array of position data that the resulting box will envelop.
* @param {number} [gap=3] - The number of elements between the start of each position in the array.
* @param {number} [offset=0] - The offset in each gap where the position data starts.
* @param {boolean} [denormalize=false] - Whether to denormalize the values in the array.
* @returns {Box3} A reference to this box.
*/
setFromArray(array, gap = 3, offset = 0, denormalize = false) {
let minX = +Infinity;
let minY = +Infinity;
let minZ = +Infinity;
let maxX = -Infinity;
let maxY = -Infinity;
let maxZ = -Infinity;
for (let i = 0, l = array.length; i < l; i += gap) {
let x = array[i + offset];
let y = array[i + offset + 1];
let z = array[i + offset + 2];
if (denormalize) {
x = MathUtils.denormalize(x, array);
y = MathUtils.denormalize(y, array);
z = MathUtils.denormalize(z, array);
}
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;
}
/**
* Clamps the point within the bounds of this box.
* @param {Vector3} point - Vector3 to clamp.
* @param {Vector3} target - Vector3 to store the result in.
* @returns {Vector3}
*/
clampPoint(point, target) {
return target.copy(point).min(this.max).max(this.min);
}
/**
* Returns the distance from any edge of this box to the specified point.
* If the point lies inside of this box, the distance will be 0.
* @param {Vector3} point - Vector3 to measure the distance to.
* @returns {number}
*/
distanceToPoint(point) {
return this.clampPoint(point, _vec3_1$5).distanceTo(point);
}
/**
* Returns aMinimum Bounding Sphere for the box.
* @param {Sphere} target — the result will be copied into this Sphere.
* @returns {Sphere}
*/
getBoundingSphere(target) {
if (this.isEmpty()) {
target.makeEmpty();
} else {
this.getCenter(target.center);
target.radius = this.getSize(_vec3_1$5).getLength() * 0.5;
}
return target;
}
/**
* Returns true if this box includes zero points within its bounds.
* @returns {boolean}
*/
isEmpty() {
// 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;
}
/**
* Returns true if this box and box share the same lower and upper bounds.
* @param {Box3} box - Box to compare with this one.
* @returns {boolean}
*/
equals(box) {
return box.min.equals(this.min) && box.max.equals(this.max);
}
/**
* Returns the center point of the box as a Vector3.
* @param {Vector3} target - the result will be copied into this Vector3.
* @returns {Vector3}
*/
getCenter(target = new Vector3()) {
return this.isEmpty() ? target.set(0, 0, 0) : target.addVectors(this.min, this.max).multiplyScalar(0.5);
}
/**
* Returns the width, height and depth of this box.
* @param {Vector3} target - the result will be copied into this Vector3.
* @returns {Vector3}
*/
getSize(target = new Vector3()) {
return this.isEmpty() ? target.set(0, 0, 0) : target.subVectors(this.max, this.min);
}
/**
* Get the 8 corner points of the bounding box, the order is as follows:
* 7-------3
* /| /|
* 4-------0 |
* | | | |
* | 6-----|-2
* |/ |/
* 5-------1
* @param {Vector3[]} points - The array to store the points.
* @returns {Vector3[]} The array of points.
*/
getPoints(points) {
const minX = this.min.x,
minY = this.min.y,
minZ = this.min.z;
const maxX = this.max.x,
maxY = this.max.y,
maxZ = this.max.z;
points[0].set(maxX, maxY, maxZ);
points[1].set(maxX, minY, maxZ);
points[2].set(maxX, minY, minZ);
points[3].set(maxX, maxY, minZ);
points[4].set(minX, maxY, maxZ);
points[5].set(minX, minY, maxZ);
points[6].set(minX, minY, minZ);
points[7].set(minX, maxY, minZ);
return points;
}
/**
* Computes the union of this box and box,
* setting the upper bound of this box to the greater of the two boxes' upper bounds and the lower bound of this box to the lesser of the two boxes' lower bounds.
* @param {Box3} box - Box that will be unioned with this box.
* @returns {Box3}
*/
union(box) {
this.min.min(box.min);
this.max.max(box.max);
return this;
}
/**
* Transforms this Box3 with the supplied matrix.
* @param {Matrix4} matrix - The Matrix4 to apply
* @returns {Box3}
*/
applyMatrix4(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;
}
/**
* Returns true if the specified point lies within or on the boundaries of this box.
* @param {Vector3} point - Vector3 to check for inclusion.
* @returns {boolean}
*/
containsPoint(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;
}
/**
* Determines whether or not this box intersects triangle.
* @param {Triangle} triangle - Triangle to check for intersection against.
* @returns {boolean}
*/
intersectsTriangle(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$1.subVectors(triangle.a, _center);
_v1$1.subVectors(triangle.b, _center);
_v2$1.subVectors(triangle.c, _center);
// compute edge vectors for triangle
_f0.subVectors(_v1$1, _v0$1);
_f1.subVectors(_v2$1, _v1$1);
_f2.subVectors(_v0$1, _v2$1);
// 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)
let 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$1, _v1$1, _v2$1, _extents)) {
return false;
}
// test 3 face normals from the aabb
axes = [1, 0, 0, 0, 1, 0, 0, 0, 1];
if (!satForAxes(axes, _v0$1, _v1$1, _v2$1, _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$1, _v1$1, _v2$1, _extents);
}
/**
* Returns a new Box3 with the same min and max as this one.
* @returns {Box3}
*/
clone() {
return new Box3().copy(this);
}
/**
* Copies the min and max from box to this box.
* @param {Box3} box - Box3 to copy.
* @returns {Box3}
*/
copy(box) {
this.min.copy(box.min);
this.max.copy(box.max);
return this;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Box3.prototype.isBox3 = true;
const _points = [new Vector3(), new Vector3(), new Vector3(), new Vector3(), new Vector3(), new Vector3(), new Vector3(), new Vector3()];
const _vec3_1$5 = new Vector3();
// triangle centered vertices
const _v0$1 = new Vector3();
const _v1$1 = new Vector3();
const _v2$1 = new Vector3();
// triangle edge vectors
const _f0 = new Vector3();
const _f1 = new Vector3();
const _f2 = new Vector3();
const _center = new Vector3();
const _extents = new Vector3();
const _triangleNormal = new Vector3();
const _testAxis = new Vector3();
function satForAxes(axes, v0, v1, v2, extents) {
for (let i = 0, j = axes.length - 3; i <= j; i += 3) {
_testAxis.fromArray(axes, i);
// project the aabb onto the separating axis
const 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 separating axis
const p0 = v0.dot(_testAxis);
const p1 = v1.dot(_testAxis);
const 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 separating and we can exit
return false;
}
}
return true;
}
/**
* A Color3 instance is represented by RGB components.
*/
class Color3 {
/**
* Constructs a new three-component color.
* @param {number} [r] - The red component of the color. If `g` and `b` are not provided, it can be a hexadecimal triplet.
* @param {number} [g] - The green component.
* @param {number} [b] - The blue component.
*/
constructor(r, g, b) {
/**
* The red component.
* @type {number}
* @default 0
*/
this.r = 0;
/**
* The green component.
* @type {number}
* @default 0
*/
this.g = 0;
/**
* The blue component.
* @type {number}
* @default 0
*/
this.b = 0;
if (g === undefined && b === undefined) {
this.setHex(r);
} else {
this.setRGB(r, g, b);
}
}
/**
* Sets this color from a hexadecimal value.
* @param {number} hex - The hexadecimal value.
* @returns {Color3} A reference to this color.
*/
setHex(hex) {
hex = Math.floor(hex);
this.r = (hex >> 16 & 255) / 255;
this.g = (hex >> 8 & 255) / 255;
this.b = (hex & 255) / 255;
return this;
}
/**
* Sets this color from RGB values.
* @param {number} r - Red channel value between 0.0 and 1.0.
* @param {number} g - Green channel value between 0.0 and 1.0.
* @param {number} b - Blue channel value between 0.0 and 1.0.
* @returns {Color3} A reference to this color.
*/
setRGB(r, g, b) {
this.r = r;
this.g = g;
this.b = b;
return this;
}
/**
* Set this color from HSL values.
* @param {number} h - Hue value between 0.0 and 1.0.
* @param {number} s - Saturation value between 0.0 and 1.0.
* @param {number} l - Lightness value between 0.0 and 1.0.
* @returns {Color3} A reference to this color.
*/
setHSL(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 {
const p = l <= 0.5 ? l * (1 + s) : l + s - l * s;
const 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;
}
/**
* Returns a new color with copied values from this instance.
* @returns {Color3} A clone of this instance.
*/
clone() {
return new this.constructor(this.r, this.g, this.b);
}
/**
* Copies the values of the given color to this instance.
* @param {Color3} color - The color to copy.
* @returns {Color3} A reference to this color.
*/
copy(color) {
this.r = color.r;
this.g = color.g;
this.b = color.b;
return this;
}
/**
* Converts this color from sRGB space to linear space.
* @returns {Color3} A reference to this color.
*/
convertSRGBToLinear() {
this.r = SRGBToLinear(this.r);
this.g = SRGBToLinear(this.g);
this.b = SRGBToLinear(this.b);
return this;
}
/**
* Converts this color from linear space to sRGB space.
* @returns {Color3} A reference to this color.
*/
convertLinearToSRGB() {
this.r = LinearToSRGB(this.r);
this.g = LinearToSRGB(this.g);
this.b = LinearToSRGB(this.b);
return this;
}
/**
* Returns the hexadecimal value of this color.
* @returns {number} The hexadecimal value.
*/
getHex() {
return MathUtils.clamp(this.r * 255, 0, 255) << 16 ^ MathUtils.clamp(this.g * 255, 0, 255) << 8 ^ MathUtils.clamp(this.b * 255, 0, 255) << 0;
}
/**
* Linearly interpolates this color's RGB values toward the RGB values of the
* given color. The alpha argument can be thought of as the ratio between
* the two colors, where 0.0 is this color and 1.0 is the first argument.
* @param {Color3} color - The color to converge on.
* @param {number} alpha - The interpolation factor in the closed interval [0,1].
* @returns {Color3} A reference to this color.
*/
lerp(color, alpha) {
return this.lerpColors(this, color, alpha);
}
/**
* Linearly interpolates between the given colors and stores the result in this instance.
* The alpha argument can be thought of as the ratio between the two colors, where 0.0
* is the first and 1.0 is the second color.
* @param {Color3} color1 - The first color.
* @param {Color3} color2 - The second color.
* @param {number} alpha - The interpolation factor in the closed interval [0,1].
* @returns {Color3} A reference to this color.
*/
lerpColors(color1, color2, alpha) {
this.r = MathUtils.lerp(color1.r, color2.r, alpha);
this.g = MathUtils.lerp(color1.g, color2.g, alpha);
this.b = MathUtils.lerp(color1.b, color2.b, alpha);
return this;
}
/**
* Sets this color's RGB components from the given array.
* @param {number[]} array - An array holding the RGB values.
* @param {number} [offset=0] - The offset into the array.
* @param {boolean} [denormalize=false] - If true, denormalize the values, and array should be a typed array.
* @returns {Color3} A reference to this color.
*/
fromArray(array, offset = 0, denormalize = false) {
let r = array[offset],
g = array[offset + 1],
b = array[offset + 2];
if (denormalize) {
r = MathUtils.denormalize(r, array);
g = MathUtils.denormalize(g, array);
b = MathUtils.denormalize(b, array);
}
this.r = r;
this.g = g;
this.b = b;
return this;
}
/**
* Writes the RGB components of this color to the given array. If no array is provided,
* the method returns a new instance.
* @param {number[]} [array=[]] - The target array holding the color components.
* @param {number} [offset=0] - Index of the first element in the array.
* @param {boolean} [normalize=false] - If true, normalize the values, and array should be a typed array.
* @returns {number[]} The color components.
*/
toArray(array = [], offset = 0, normalize = false) {
let r = this.r,
g = this.g,
b = this.b;
if (normalize) {
r = MathUtils.normalize(r, array);
g = MathUtils.normalize(g, array);
b = MathUtils.normalize(b, array);
}
array[offset] = r;
array[offset + 1] = g;
array[offset + 2] = b;
return array;
}
*[Symbol.iterator]() {
yield this.r;
yield this.g;
yield this.b;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Color3.prototype.isColor3 = true;
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;
}
/**
* A Color4 instance is represented by RGBA components.
*/
class Color4 {
/**
* Constructs a new four-component color.
* @param {number} [r=0] - The red value.
* @param {number} [g=0] - The green value.
* @param {number} [b=0] - The blue value.
* @param {number} [a=1] - The alpha value.
*/
constructor(r = 0, g = 0, b = 0, a = 1) {
/**
* The red component.
* @type {number}
* @default 0
*/
this.r = r;
/**
* The green component.
* @type {number}
* @default 0
*/
this.g = g;
/**
* The blue component.
* @type {number}
* @default 0
*/
this.b = b;
/**
* The alpha component.
* @type {number}
* @default 1
*/
this.a = a;
}
/**
* Sets this color from RGBA values.
* @param {number} r - Red channel value between 0.0 and 1.0.
* @param {number} g - Green channel value between 0.0 and 1.0.
* @param {number} b - Blue channel value between 0.0 and 1.0.
* @param {number} a - Alpha channel value between 0.0 and 1.0.
* @returns {Color4} A reference to this color.
*/
setRGBA(r, g, b, a) {
this.r = r;
this.g = g;
this.b = b;
this.a = a;
return this;
}
/**
* Returns a new color with copied values from this instance.
* @returns {Color4} A clone of this instance.
*/
clone() {
return new Color4(this.r, this.g, this.b, this.a);
}
/**
* Copies the values of the given color to this instance.
* @param {Color4} color - The color to copy.
* @returns {Color4} A clone of this instance.
*/
copy(color) {
this.r = color.r;
this.g = color.g;
this.b = color.b;
this.a = color.a;
return this;
}
/**
* Sets this color's RGBA components from the given array.
* @param {number[]} array - An array holding the RGBA values.
* @param {number} [offset=0] - The offset into the array.
* @param {boolean} [denormalize=false] - If true, denormalize the values, and array should be a typed array.
* @returns {Color4} A reference to this color.
*/
fromArray(array, offset = 0, denormalize = false) {
let r = array[offset],
g = array[offset + 1],
b = array[offset + 2],
a = array[offset + 3];
if (denormalize) {
r = MathUtils.denormalize(r, array);
g = MathUtils.denormalize(g, array);
b = MathUtils.denormalize(b, array);
a = MathUtils.denormalize(a, array);
}
this.r = r;
this.g = g;
this.b = b;
this.a = a;
return this;
}
/**
* Writes the RGBA components of this color to the given array. If no array is provided,
* the method returns a new instance.
* @param {number[]} [array=[]] - The target array holding the color components.
* @param {number} [offset=0] - Index of the first element in the array.
* @param {boolean} [normalize=false] - If true, normalize the values, and array should be a typed array.
* @returns {number[]} The color components.
*/
toArray(array = [], offset = 0, normalize = false) {
let r = this.r,
g = this.g,
b = this.b,
a = this.a;
if (normalize) {
r = MathUtils.normalize(r, array);
g = MathUtils.normalize(g, array);
b = MathUtils.normalize(b, array);
a = MathUtils.normalize(a, array);
}
array[offset] = r;
array[offset + 1] = g;
array[offset + 2] = b;
array[offset + 3] = a;
return array;
}
*[Symbol.iterator]() {
yield this.r;
yield this.g;
yield this.b;
yield this.a;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Color4.prototype.isColor4 = true;
const _matrix$1 = new Matrix4();
/**
* Euler class.
*/
class Euler {
/**
* @param {number} [x=0]
* @param {number} [y=0]
* @param {number} [z=0]
* @param {string} [order=Euler.DefaultOrder]
*/
constructor(x = 0, y = 0, z = 0, order = Euler.DefaultOrder) {
this._x = x;
this._y = y;
this._z = z;
this._order = order;
}
/**
* @type {number}
*/
get x() {
return this._x;
}
/**
* @type {number}
*/
set x(value) {
this._x = value;
this.onChangeCallback();
}
/**
* @type {number}
*/
get y() {
return this._y;
}
/**
* @type {number}
*/
set y(value) {
this._y = value;
this.onChangeCallback();
}
/**
* @type {number}
*/
get z() {
return this._z;
}
/**
* @type {number}
*/
set z(value) {
this._z = value;
this.onChangeCallback();
}
/**
* @type {string}
*/
get order() {
return this._order;
}
/**
* @type {string}
*/
set order(value) {
this._order = value;
this.onChangeCallback();
}
/**
* Returns a new Euler with the same parameters as this one.
* @returns {Euler}
*/
clone() {
return new Euler(this._x, this._y, this._z, this._order);
}
/**
* Copies value of euler to this euler.
* @param {Euler} euler
* @returns {Euler}
*/
copy(euler) {
this._x = euler._x;
this._y = euler._y;
this._z = euler._z;
this._order = euler._order;
this.onChangeCallback();
return this;
}
/**
* @param {number} x - the angle of the x axis in radians.
* @param {number} y - the angle of the y axis in radians.
* @param {number} z - the angle of the z axis in radians.
* @param {string} order - (optional) a string representing the order that the rotations are applied.
* @returns {Euler}
*/
set(x = 0, y = 0, z = 0, order = this._order) {
this._x = x;
this._y = y;
this._z = z;
this._order = order;
this.onChangeCallback();
return this;
}
/**
* Sets the angles of this euler transform from a pure rotation matrix based on the orientation specified by order.
* @param {Matrix4} m - a Matrix4 of which the upper 3x3 of matrix is a pure rotation matrix
* @param {string} order - (optional) a string representing the order that the rotations are applied.
* @param {boolean} [update=true] - Whether to notify Euler angle has changed
* @returns {Euler}
*/
setFromRotationMatrix(m, order = this._order, update = true) {
// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
const te = m.elements;
const m11 = te[0],
m12 = te[4],
m13 = te[8];
const m21 = te[1],
m22 = te[5],
m23 = te[9];
const m31 = te[2],
m32 = te[6],
m33 = te[10];
if (order === 'XYZ') {
this._y = Math.asin(MathUtils.clamp(m13, -1, 1));
if (Math.abs(m13) < 0.99999) {
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(-MathUtils.clamp(m23, -1, 1));
if (Math.abs(m23) < 0.99999) {
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(MathUtils.clamp(m32, -1, 1));
if (Math.abs(m32) < 0.99999) {
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(-MathUtils.clamp(m31, -1, 1));
if (Math.abs(m31) < 0.99999) {
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(MathUtils.clamp(m21, -1, 1));
if (Math.abs(m21) < 0.99999) {
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(-MathUtils.clamp(m12, -1, 1));
if (Math.abs(m12) < 0.99999) {
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('given unsupported order: ' + order);
}
this._order = order;
if (update === true) this.onChangeCallback();
return this;
}
/**
* Sets the angles of this euler transform from a normalized quaternion based on the orientation specified by order.
* @param {Quaternion} q - a normalized quaternion.
* @param {string} order - (optional) a string representing the order that the rotations are applied.
* @param {boolean} [update=true] - Whether to notify Euler angle has changed
* @returns {Euler}
*/
setFromQuaternion(q, order, update) {
q.toMatrix4(_matrix$1);
return this.setFromRotationMatrix(_matrix$1, order, update);
}
/**
* @param {Function} callback - When the Euler angle value changes, the callback method is triggered
* @returns {Euler}
*/
onChange(callback) {
this.onChangeCallback = callback;
return this;
}
onChangeCallback() {}
*[Symbol.iterator]() {
yield this._x;
yield this._y;
yield this._z;
yield this._order;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Euler.prototype.isEuler = true;
/**
* The order in which to apply rotations.
* @readonly
*/
Euler.RotationOrders = ['XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX'];
/**
* The default order in which to apply rotations.
* @readonly
*/
Euler.DefaultOrder = 'XYZ';
/**
* The 3x3 matrix class.
*/
class Matrix3 {
/**
* Create a 3x3 matrix.
*/
constructor() {
this.elements = [1, 0, 0, 0, 1, 0, 0, 0, 1];
}
/**
* Sets the 3x3 matrix values to the given row-major sequence of values.
* @param {number} n11 - value to put in row 1, col 1.
* @param {number} n12 - value to put in row 1, col 2.
* @param {number} n13 - value to put in row 1, col 3.
* @param {number} n21 - value to put in row 2, col 1.
* @param {number} n22 - value to put in row 2, col 2.
* @param {number} n23 - value to put in row 2, col 3.
* @param {number} n31 - value to put in row 3, col 1.
* @param {number} n32 - value to put in row 3, col 2.
* @param {number} n33 - value to put in row 3, col 3.
* @returns {Matrix3}
*/
set(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
const ele = this.elements;
ele[0] = n11;
ele[3] = n12;
ele[6] = n13;
ele[1] = n21;
ele[4] = n22;
ele[7] = n23;
ele[2] = n31;
ele[5] = n32;
ele[8] = n33;
return this;
}
/**
* Resets this matrix to the 3x3 identity matrix
* @returns {Matrix3}
*/
identity() {
return this.set(1, 0, 0, 0, 1, 0, 0, 0, 1);
}
/**
* Checks if the matrix is an identity matrix.
* @returns {boolean} - True if the matrix is an identity matrix, false otherwise.
*/
isIdentity() {
const te = this.elements;
return te[0] === 1 && te[3] === 0 && te[6] === 0 && te[1] === 0 && te[4] === 1 && te[7] === 0 && te[2] === 0 && te[5] === 0 && te[8] === 1;
}
/**
* Computes and returns the determinant of this matrix.
* @returns {number} The determinant.
*/
determinant() {
const te = this.elements;
const 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;
}
/**
* Inverts this matrix, using the [analytic method]{@link https://en.wikipedia.org/wiki/Invertible_matrix#Analytic_solution}.
* You can not invert with a determinant of zero. If you attempt this, the method produces
* a zero matrix instead.
* @returns {Matrix3} A reference to this matrix.
*/
invert() {
const te = this.elements,
n11 = te[0],
n21 = te[1],
n31 = te[2],
n12 = te[3],
n22 = te[4],
n32 = te[5],
n13 = te[6],
n23 = te[7],
n33 = te[8],
t11 = n33 * n22 - n32 * n23,
t12 = n32 * n13 - n33 * n12,
t13 = n23 * n12 - n22 * n13,
det = n11 * t11 + n21 * t12 + n31 * t13;
if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0);
const detInv = 1 / det;
te[0] = t11 * detInv;
te[1] = (n31 * n23 - n33 * n21) * detInv;
te[2] = (n32 * n21 - n31 * n22) * detInv;
te[3] = t12 * detInv;
te[4] = (n33 * n11 - n31 * n13) * detInv;
te[5] = (n31 * n12 - n32 * n11) * detInv;
te[6] = t13 * detInv;
te[7] = (n21 * n13 - n23 * n11) * detInv;
te[8] = (n22 * n11 - n21 * n12) * detInv;
return this;
}
/**
* Transposes this matrix in place.
* @returns {Matrix3}
*/
transpose() {
let tmp;
const m = this.elements;
tmp = m[1];
m[1] = m[3];
m[3] = tmp;
tmp = m[2];
m[2] = m[6];
m[6] = tmp;
tmp = m[5];
m[5] = m[7];
m[7] = tmp;
return this;
}
/**
* Return true if this matrix and m are equal.
* @param {Matrix3} matrix
* @returns {boolean}
*/
equals(matrix) {
const te = this.elements;
const me = matrix.elements;
for (let i = 0; i < 9; i++) {
if (te[i] !== me[i]) return false;
}
return true;
}
/**
* Sets the elements of this matrix based on an array in column-major format.
* @param {number[]} array
* @param {number} [offset=0]
* @returns {Matrix3}
*/
fromArray(array, offset = 0) {
for (let i = 0; i < 9; i++) {
this.elements[i] = array[i + offset];
}
return this;
}
/**
* Writes the elements of this matrix to an array in column-major format.
* @param {number[]} [array]
* @param {number} [offset=0]
* @returns {number[]}
*/
toArray(array = [], offset = 0) {
const 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];
return array;
}
/**
* Creates a new Matrix3 and with identical elements to this one.
* @returns {Matrix3}
*/
clone() {
return new Matrix3().fromArray(this.elements);
}
/**
* Copies the elements of matrix m into this matrix.
* @param {Matrix3} m
* @returns {Matrix3}
*/
copy(m) {
const te = this.elements;
const 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;
}
/**
* Post-multiplies this matrix by m.
* @param {Matrix3} m
* @returns {Matrix3}
*/
multiply(m) {
return this.multiplyMatrices(this, m);
}
/**
* Pre-multiplies this matrix by m.
* @param {Matrix3} m
* @returns {Matrix3}
*/
premultiply(m) {
return this.multiplyMatrices(m, this);
}
/**
* Sets this matrix to a x b.
* @param {Matrix3} a
* @param {Matrix3} b
* @returns {Matrix3}
*/
multiplyMatrices(a, b) {
const ae = a.elements;
const be = b.elements;
const te = this.elements;
const a11 = ae[0],
a12 = ae[3],
a13 = ae[6];
const a21 = ae[1],
a22 = ae[4],
a23 = ae[7];
const a31 = ae[2],
a32 = ae[5],
a33 = ae[8];
const b11 = be[0],
b12 = be[3],
b13 = be[6];
const b21 = be[1],
b22 = be[4],
b23 = be[7];
const 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;
}
/**
* Transform 2D
* @param {number} x - position.x
* @param {number} y - position.y
* @param {number} scaleX - scale.x
* @param {number} scaleY - scale.y
* @param {number} rotation - rotation
* @param {number} anchorX - anchor.x
* @param {number} anchorY - anchor.y
* @returns {Matrix3}
*/
transform(x, y, scaleX, scaleY, rotation, anchorX, anchorY) {
const te = this.elements;
const cr = Math.cos(rotation);
const sr = Math.sin(rotation);
te[0] = cr * scaleX;
te[3] = -sr * scaleY;
te[6] = x;
te[1] = sr * scaleX;
te[4] = cr * scaleY;
te[7] = y;
te[2] = 0;
te[5] = 0;
te[8] = 1;
if (anchorX || anchorY) {
// prepend the anchor offset:
te[6] -= anchorX * te[0] + anchorY * te[3];
te[7] -= anchorX * te[1] + anchorY * te[4];
}
return this;
}
/**
* Set the transformation matrix of uv coordinates
* @param {number} tx
* @param {number} ty
* @param {number} sx
* @param {number} sy
* @param {number} rotation
* @param {number} cx
* @param {number} cy
* @returns {Matrix3}
*/
setUvTransform(tx, ty, sx, sy, rotation, cx, cy) {
const c = Math.cos(rotation);
const s = Math.sin(rotation);
return this.set(sx * c, sx * s, -sx * (c * cx + s * cy) + cx + tx, -sy * s, sy * c, -sy * (-s * cx + c * cy) + cy + ty, 0, 0, 1);
}
/**
* Sets the matri3 planes from the matrix4.
* @param {Matrix4} m
* @returns {Matrix3}
*/
setFromMatrix4(m) {
const me = m.elements;
return this.set(me[0], me[4], me[8], me[1], me[5], me[9], me[2], me[6], me[10]);
}
/**
* Extracts the basis vectors from the matrix.
* @param {Vector3} xAxis
* @param {Vector3} yAxis
* @param {Vector3} zAxis
* @returns {Matrix3}
*/
extractBasis(xAxis, yAxis, zAxis) {
const te = this.elements;
xAxis.fromArray(te);
yAxis.fromArray(te, 3);
zAxis.fromArray(te, 6);
return this;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Matrix3.prototype.isMatrix3 = true;
const _vec3_1$4 = new Vector3();
const _vec3_2$1 = new Vector3();
const _mat3_1$1 = new Matrix3();
/**
* A two dimensional surface that extends infinitely in 3d space,
* represented in Hessian normal form by a unit length normal vector and a constant.
*/
class Plane {
/**
* Constructs a new Plane.
* @param {Vector3} [normal=Vector3(1, 0, 0)] - A unit length Vector3 defining the normal of the plane.
* @param {number} [constant=0] - The signed distance from the origin to the plane.
*/
constructor(normal = new Vector3(1, 0, 0), constant = 0) {
this.normal = normal;
this.constant = constant;
}
/**
* Solve a system of equations to find the point where the three planes intersect.
* @param {Plane} p1 - The first plane.
* @param {Plane} p2 - The second plane.
* @param {Plane} p3 - The third plane.
* @param {Vector3} target - The result will be copied into this Vector3.
* @returns {Vector3}
*/
static intersectPlanes(p1, p2, p3, target) {
// Create the matrix using the normals of the planes as rows
_mat3_1$1.set(p1.normal.x, p1.normal.y, p1.normal.z, p2.normal.x, p2.normal.y, p2.normal.z, p3.normal.x, p3.normal.y, p3.normal.z);
// Create the vector using the constants of the planes
target.set(-p1.constant, -p2.constant, -p3.constant);
// Solve for X by applying the inverse matrix to vector
target.applyMatrix3(_mat3_1$1.invert());
return target;
}
/**
* Sets this plane's normal and constant properties by copying the values from the given normal.
* @param {Vector3} normal - a unit length Vector3 defining the normal of the plane.
* @param {number} constant - the signed distance from the origin to the plane. Default is 0.
* @returns {Plane}
*/
set(normal, constant) {
this.normal.copy(normal);
this.constant = constant;
return this;
}
/**
* Set the individual components that define the plane.
* @param {number} x - x value of the unit length normal vector.
* @param {number} y - y value of the unit length normal vector.
* @param {number} z - z value of the unit length normal vector.
* @param {number} w - the value of the plane's constant property.
* @returns {Plane}
*/
setComponents(x, y, z, w) {
this.normal.set(x, y, z);
this.constant = w;
return this;
}
/**
* Sets the plane's properties as defined by a normal and an arbitrary coplanar point.
* @param {Vector3} normal - a unit length Vector3 defining the normal of the plane.
* @param {Vector3} point - Vector3
* @returns {Plane}
*/
setFromNormalAndCoplanarPoint(normal, point) {
this.normal.copy(normal);
this.constant = -point.dot(this.normal);
return this;
}
/**
* Defines the plane based on the 3 provided points.
* The winding order is assumed to be counter-clockwise, and determines the direction of the normal.
* @param {Vector3} a - first point on the plane.
* @param {Vector3} b - second point on the plane.
* @param {Vector3} c - third point on the plane.
* @returns {Plane}
*/
setFromCoplanarPoints(a, b, c) {
const normal = _vec3_1$4.subVectors(c, b).cross(_vec3_2$1.subVectors(a, b)).normalize();
// Q: should an error be thrown if normal is zero (e.g. degenerate plane)?
this.setFromNormalAndCoplanarPoint(normal, a);
return this;
}
/**
* Normalizes the normal vector, and adjusts the constant value accordingly.
* @returns {Plane}
*/
normalize() {
// Note: will lead to a divide by zero if the plane is invalid.
const inverseNormalLength = 1.0 / this.normal.getLength();
this.normal.multiplyScalar(inverseNormalLength);
this.constant *= inverseNormalLength;
return this;
}
/**
* Returns the signed distance from the point to the plane.
* @param {Vector3} point
* @returns {number}
*/
distanceToPoint(point) {
return this.normal.dot(point) + this.constant;
}
/**
* Projects a point onto the plane.
* @param {Vector3} point - the Vector3 to project onto the plane.
* @param {Vector3} [target] - the result will be copied into this Vector3.
* @returns {Vector3}
*/
projectPoint(point, target = new Vector3()) {
return target.copy(point).addScaledVector(this.normal, -this.distanceToPoint(point));
}
/**
* Reflects a point through the plane.
* @param {Vector3} point - the Vector3 to reflect through the plane.
* @param {Vector3} [target] - the result will be copied into this Vector3.
* @returns {Vector3}
*/
mirrorPoint(point, target = new Vector3()) {
const distance = this.distanceToPoint(point);
return target.copy(point).addScaledVector(this.normal, -2 * distance);
}
/**
* Returns a Vector3 coplanar to the plane, by calculating the projection of the normal vector at the origin onto the plane.
* @param {Vector3} [target]
* @returns {Vector3}
*/
coplanarPoint(target = new Vector3()) {
return target.copy(this.normal).multiplyScalar(-this.constant);
}
/**
* Returns a new plane with the same normal and constant as this one.
* @returns {Plane}
*/
clone() {
return new Plane().copy(this);
}
/**
* Copies the values of the passed plane's normal and constant properties to this plane.
* @param {Plane} plane
* @returns {Plane}
*/
copy(plane) {
this.normal.copy(plane.normal);
this.constant = plane.constant;
return this;
}
/**
* Apply a Matrix4 to the plane. The matrix must be an affine, homogeneous transform.
* @param {Matrix4} matrix - the Matrix4 to apply.
* @param {Matrix3} [optionalNormalMatrix] - (optional) pre-computed normal Matrix3 of the Matrix4 being applied.
* @returns {Plane}
*/
applyMatrix4(matrix, optionalNormalMatrix) {
const normalMatrix = optionalNormalMatrix || _mat3_1$1.setFromMatrix4(matrix).invert().transpose();
const referencePoint = this.coplanarPoint(_vec3_1$4).applyMatrix4(matrix);
const normal = this.normal.applyMatrix3(normalMatrix).normalize();
this.constant = -referencePoint.dot(normal);
return this;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Plane.prototype.isPlane = true;
const _vec3_1$3 = new Vector3();
const _mat3_1 = new Matrix3();
/**
* Frustums are used to determine what is inside the camera's field of view.
* They help speed up the rendering process - objects which lie outside a camera's frustum can safely be excluded from rendering.
*/
class Frustum {
/**
* @param {Plane} p0 - (optional) defaults to a new Plane.
* @param {Plane} p1 - (optional) defaults to a new Plane.
* @param {Plane} p2 - (optional) defaults to a new Plane.
* @param {Plane} p3 - (optional) defaults to a new Plane.
* @param {Plane} p4 - (optional) defaults to a new Plane.
* @param {Plane} p5 - (optional) defaults to a new Plane.
*/
constructor(p0 = new Plane(), p1 = new Plane(), p2 = new Plane(), p3 = new Plane(), p4 = new Plane(), p5 = new Plane()) {
this.planes = [p0, p1, p2, p3, p4, p5];
}
/**
* Sets the frustum from the passed planes. No plane order is implied.
* @param {Plane} p0 - (optional) defaults to a new Plane.
* @param {Plane} p1 - (optional) defaults to a new Plane.
* @param {Plane} p2 - (optional) defaults to a new Plane.
* @param {Plane} p3 - (optional) defaults to a new Plane.
* @param {Plane} p4 - (optional) defaults to a new Plane.
* @param {Plane} p5 - (optional) defaults to a new Plane.
* @returns {Frustum}
*/
set(p0, p1, p2, p3, p4, p5) {
const planes = this.planes;
planes[0].copy(p0);
planes[1].copy(p1);
planes[2].copy(p2);
planes[3].copy(p3);
planes[4].copy(p4);
planes[5].copy(p5);
return this;
}
/**
* Sets the frustum planes from the matrix.
* @param {Matrix4} m - a Matrix4 used to set the planes
* @returns {Frustum}
*/
setFromMatrix(m) {
const planes = this.planes;
const me = m.elements;
const me0 = me[0],
me1 = me[1],
me2 = me[2],
me3 = me[3];
const me4 = me[4],
me5 = me[5],
me6 = me[6],
me7 = me[7];
const me8 = me[8],
me9 = me[9],
me10 = me[10],
me11 = me[11];
const me12 = me[12],
me13 = me[13],
me14 = me[14],
me15 = me[15];
planes[0].setComponents(me3 - me0, me7 - me4, me11 - me8, me15 - me12).normalize();
planes[1].setComponents(me3 + me0, me7 + me4, me11 + me8, me15 + me12).normalize();
planes[2].setComponents(me3 + me1, me7 + me5, me11 + me9, me15 + me13).normalize();
planes[3].setComponents(me3 - me1, me7 - me5, me11 - me9, me15 - me13).normalize();
planes[4].setComponents(me3 - me2, me7 - me6, me11 - me10, me15 - me14).normalize();
planes[5].setComponents(me3 + me2, me7 + me6, me11 + me10, me15 + me14).normalize();
return this;
}
/**
* Return true if sphere intersects with this frustum.
* @param {Sphere} sphere - Sphere to check for intersection.
* @returns {boolean}
*/
intersectsSphere(sphere) {
const planes = this.planes;
const center = sphere.center;
const negRadius = -sphere.radius;
for (let i = 0; i < 6; i++) {
const distance = planes[i].distanceToPoint(center);
if (distance < negRadius) {
return false;
}
}
return true;
}
/**
* Return true if box intersects with this frustum.
* @param {Box3} box - Box3 to check for intersection.
* @returns {boolean}
*/
intersectsBox(box) {
const planes = this.planes;
for (let i = 0; i < 6; i++) {
const plane = planes[i];
// corner at max distance
_vec3_1$3.x = plane.normal.x > 0 ? box.max.x : box.min.x;
_vec3_1$3.y = plane.normal.y > 0 ? box.max.y : box.min.y;
_vec3_1$3.z = plane.normal.z > 0 ? box.max.z : box.min.z;
// if both outside plane, no intersection
if (plane.distanceToPoint(_vec3_1$3) < 0) {
return false;
}
}
return true;
}
/**
* Apply a matrix4x4 to the frustum.
* @param {Matrix4} matrix - Matrix4 to apply to the frustum.
* @returns {Frustum}
*/
applyMatrix4(matrix) {
const planes = this.planes;
const normalMatrix = _mat3_1.setFromMatrix4(matrix).invert().transpose();
for (let i = 0; i < 6; i++) {
planes[i].applyMatrix4(matrix, normalMatrix);
}
return this;
}
/**
* Return a new Frustum with the same parameters as this one.
* @returns {Frustum}
*/
clone() {
return new this.constructor().copy(this);
}
/**
* Copies the properties of the passed frustum into this one.
* @param {Frustum} frustum - The frustum to copy
* @returns {Frustum}
*/
copy(frustum) {
const planes = this.planes;
for (let i = 0; i < 6; i++) {
planes[i].copy(frustum.planes[i]);
}
return this;
}
}
/**
* This flag can be used for type testing.
* @readonly
* @type {boolean}
* @default true
*/
Frustum.prototype.isFrustum = true;
const _vec3_1$2 = new Vector3();
const _diff = new Vector3();
const _edge1 = new Vector3();
const _edge2 = new Vector3();
const _normal = new Vector3();
/**
* A ray that emits from an origin in a certain direction. This is used by
* {@link Raycaster} to assist with raycasting. Raycasting is used for
* mouse picking (working out what objects in the 3D space the mouse is over)
* amongst other things.
*/
class Ray {
/**
* Constructs a new ray.
* @param {Vector3} [origin=(0,0,0)] - The origin of the ray.
* @param {Vector3} [direction=(0,0,-1)] - The (normalized) direction of the ray.
*/
constructor(origin = new Vector3(), direction = new Vector3(0, 0, -1)) {
/**
* The origin of the ray.
* @type {Vector3}
*/
this.origin = origin;
/**
* The (normalized) direction of the ray.
* @type {Vector3}
*/
this.direction = direction;
}
/**
* Sets the ray's components by copying the given values.
* @param {Vector3} origin - The origin.
* @param {Vector3} direction - The direction.
* @returns {Ray} A reference to this ray.
*/
set(origin, direction) {
this.origin.copy(origin);
this.direction.copy(direction);
return this;
}
/**
* Copies the values of the given ray to this instance.
* @param {Ray} ray - The ray to copy.
* @returns {Ray} A reference to this ray.
*/
copy(ray) {
this.origin.copy(ray.origin);
this.direction.copy(ray.direction);
return this;
}
/**
* Returns a vector that is located at a given distance along this ray.
* @param {number} t - The distance along the ray to retrieve a position for.
* @param {Vector3} target - The target vector that is used to store the method's result.
* @returns {Vector3} A position on the ray.
*/
at(t, target = new Vector3()) {
return target.copy(this.origin).addScaledVector(this.direction, t);
}
/**
* Shift the origin of this ray along its direction by the given distance.
* @param {number} t - The distance along the ray to interpolate.
* @returns {Ray} A reference to this ray.
*/
recast(t) {
this.origin.copy(this.at(t, _vec3_1$2));
return this;
}
/**
* Returns the point along this ray that is closest to the given point.
* @param {Vector3} point - A point in 3D space to get the closet location on the ray for.
* @param {Vector3} target - The target vector that is used to store the method's result.
* @returns {Vector3} The closest point on this ray.
*/
closestPointToPoint(point, target) {
target.subVectors(point, this.origin);
const directionDistance = target.dot(this.direction);
if (directionDistance < 0) {
return target.copy(this.origin);
}
return target.copy(this.origin).addScaledVector(this.direction, directionDistance);
}
/**
* Returns the distance of the closest approach between this ray and the given point.
* @param {Vector3} point - A point in 3D space to compute the distance to.
* @returns {number} The distance.
*/
distanceToPoint(point) {
return Math.sqrt(this.distanceSqToPoint(point));
}
/**
* Returns the squared distance of the closest approach between this ray and the given point.
* @param {Vector3} point - A point in 3D space to compute the distance to.
* @returns {number} The squared distance.
*/
distanceSqToPoint(point) {
const directionDistance = _vec3_1$2.subVectors(point, this.origin).dot(this.direction);
if (directionDistance < 0) {
return this.origin.distanceToSquared(point);
}
_vec3_1$2.copy(this.direction).multiplyScalar(directionDistance).add(this.origin);
return _vec3_1$2.distanceToSquared(point);
}
/**
* Intersects this ray with the given sphere, returning the intersection
* point or `null` if there is no intersection.
* @param {Sphere} sphere - The sphere to intersect.
* @param {Vector3} target - The target vector that is used to store the method's result.
* @returns {?Vector3} The intersection point.
*/
intersectSphere(sphere, target) {
_vec3_1$2.subVectors(sphere.center, this.origin);
const tca = _vec3_1$2.dot(this.direction);
const d2 = _vec3_1$2.dot(_vec3_1$2) - tca * tca;
const radius2 = sphere.radius * sphere.radius;
if (d2 > radius2) {
return null;
}
const thc = Math.sqrt(radius2 - d2);
// t0 = first intersect point - entrance on front of sphere
const t0 = tca - thc;
// t1 = second intersect point - exit point on back of sphere
const t1 = tca + thc;
// test to see if both t0 and t1 are behind the ray - if so, return null
if (t0 < 0 && t1 < 0) {
return null;
}
// test to see if t0 is behind the ray:
// if it is, the ray is inside the sphere, so return the second exit point scaled by t1,
// in order to always return an intersect point that is in front of the ray.
if (t0 < 0) {
return this.at(t1, target);
}
// else t0 is in front of the ray, so return the first collision point scaled by t0
return this.at(t0, target);
}
/**
* Returns `true` if this ray intersects with the given sphere.
* @param {Sphere} sphere - The sphere to intersect.
* @returns {boolean} Whether this ray intersects with the given sphere or not.
*/
intersectsSphere(sphere) {
if (sphere.radius < 0) return false; // handle empty spheres
return this.distanceSqToPoint(sphere.center) <= sphere.radius * sphere.radius;
}
/**
* Computes the distance from the ray's origin to the given plane. Returns `null` if the ray
* does not intersect with the plane.
* @param {Plane} plane - The plane to compute the distance to.
* @returns {?number} Whether this ray intersects with the given sphere or not.
*/
distanceToPlane(plane) {
const denominator = plane.normal.dot(this.direction);
if (denominator === 0) {
// line is coplanar, return origin
if (plane.distanceToPoint(this.origin) === 0) {
return 0;
}
// Null is preferable to undefined since undefined means.... it is undefined
return null;
}
const t = -(this.origin.dot(plane.normal) + plane.constant) / denominator;
// Return if the ray never intersects the plane
return t >= 0 ? t : null;
}
/**
* Intersects this ray with the given plane, returning the intersection
* point or `null` if there is no intersection.
* @param {Plane} plane - The plane to intersect.
* @param {Vector3} target - The target vector that is used to store the method's result.
* @returns {?Vector3} The intersection point.
*/
intersectPlane(plane, target) {
const t = this.distanceToPlane(plane);
if (t === null) {
return null;
}
return this.at(t, target);
}
/**
* Returns `true` if this ray intersects with the given plane.
* @param {Plane} plane - The plane to intersect.
* @returns {boolean} Whether this ray intersects with the given plane or not.
*/
intersectsPlane(plane) {
// check if the ray lies on the plane first
const distToPoint = plane.distanceToPoint(this.origin);
if (distToPoint === 0) {
return true;
}
const denominator = plane.normal.dot(this.direction);
if (denominator * distToPoint < 0) {
return true;
}
// ray origin is behind the plane (and is pointing behind it)
return false;
}
/**
* Intersects this ray with the given bounding box, returning the intersection
* point or `null` if there is no intersection.
* @param {Box3} box - The box to intersect.
* @param {Vector3} target - The target vector that is used to store the method's result.
* @returns {?Vector3} The intersection point.
*/
intersectBox(box, target) {
let tmin, tmax, tymin, tymax, tzmin, tzmax;
const invdirx = 1 / this.direction.x,
invdiry = 1 / this.direction.y,
invdirz = 1 / this.direction.z;
const origin = this.origin;
if (invdirx >= 0) {
tmin = (box.min.x - origin.x) * invdirx;
tmax = (box.max.x - origin.x) * invdirx;
} else {
tmin = (box.max.x - origin.x) * invdirx;
tmax = (box.min.x - origin.x) * invdirx;
}
if (invdiry >= 0) {
tymin = (box.min.y - origin.y) * invdiry;
tymax = (box.max.y - origin.y) * invdiry;
} else {
tymin = (box.max.y - origin.y) * invdiry;
tymax = (box.min.y - origin.y) * invdiry;
}
if (tmin > tymax || tymin > tmax) return null;
// These lines also handle the case where tmin or tmax is NaN
// (result of 0 * Infinity). x !== x returns true if x is NaN
if (tymin > tmin || tmin !== tmin) tmin = tymin;
if (tymax < tmax || tmax !== tmax) tmax = tymax;
if (invdirz >= 0) {
tzmin = (box.min.z - origin.z) * invdirz;
tzmax = (box.max.z - origin.z) * invdirz;
} else {
tzmin = (box.max.z - origin.z) * invdirz;
tzmax = (box.min.z - origin.z) * invdirz;
}
if (tmin > tzmax || tzmin > tmax) return null;
if (tzmin > tmin || tmin !== tmin) tmin = tzmin;
if (tzmax < tmax || tmax !== tmax) tmax = tzmax;
// return point closest to the ray (positive side)
if (tmax < 0) return null;
return this.at(tmin >= 0 ? tmin : tmax, target);
}
/**
* Returns `true` if this ray intersects with the given box.
* @param {Box3} box - The box to intersect.
* @returns {boolean} Whether this ray intersects with the given box or not.
*/
intersectsBox(box) {
return this.intersectBox(box, _vec3_1$2) !== null;
}
/**
* Intersects this ray with the given triangle, returning the intersection
* point or `null` if there is no intersection.
* @param {Vector3} a - The first vertex of the triangle.
* @param {Vector3} b - The second vertex of the triangle.
* @param {Vector3} c - The third vertex of the triangle.
* @param {boolean} backfaceCulling - Whether to use backface culling or not.
* @param {Vector3} target - The target vector that is used to store the meth
gitextract_bg_rxfqd/
├── .editorconfig
├── .gitattributes
├── .github/
│ ├── contributing.md
│ └── workflows/
│ └── deploy-to-pages.yml
├── .gitignore
├── .vscode/
│ └── extensions.json
├── LICENSE
├── README.md
├── build/
│ ├── t3d.js
│ └── t3d.module.js
├── eslint.config.mjs
├── examples/
│ ├── animation_blending_additive.html
│ ├── animation_bone_attach.html
│ ├── animation_crossfade.html
│ ├── animation_interpolant.html
│ ├── animation_keyframe_animation.html
│ ├── animation_morphtargets.html
│ ├── animation_multiple.html
│ ├── animation_skinned_instancing.html
│ ├── animation_skinned_mesh.html
│ ├── animation_snake.html
│ ├── camera_multiple.html
│ ├── camera_projection.html
│ ├── canvas2d_canvas2d.html
│ ├── controls_camera_fly.html
│ ├── controls_camera_free.html
│ ├── controls_camera_orbit.html
│ ├── controls_camera_view.html
│ ├── controls_transform.html
│ ├── custompass_bloom.html
│ ├── custompass_blur.html
│ ├── custompass_car.html
│ ├── custompass_deferred.html
│ ├── custompass_depth_buffer_share.html
│ ├── custompass_depth_texture_share.html
│ ├── custompass_dof.html
│ ├── custompass_gbuffer.html
│ ├── custompass_gpupick.html
│ ├── custompass_lensflare.html
│ ├── custompass_motion_blur.html
│ ├── custompass_motion_blur2.html
│ ├── custompass_msaa.html
│ ├── custompass_oit.html
│ ├── custompass_rendertarget_2d.html
│ ├── custompass_rendertarget_3d.html
│ ├── custompass_shadow_planar.html
│ ├── custompass_sketch.html
│ ├── custompass_ssao.html
│ ├── custompass_ssr.html
│ ├── custompass_taa.html
│ ├── custompass_transmission.html
│ ├── custompass_unrealbloom.html
│ ├── custompass_xray.html
│ ├── exporter_draco.html
│ ├── exporter_gltf.html
│ ├── files/
│ │ ├── fonts/
│ │ │ ├── OFL-hind.txt
│ │ │ └── OFL-montserrat.txt
│ │ └── main.css
│ ├── files.json
│ ├── geometry_boundings.html
│ ├── geometry_builder_edges.html
│ ├── geometry_builder_lines.html
│ ├── geometry_builder_shapes.html
│ ├── geometry_geometries.html
│ ├── geometry_groups.html
│ ├── geometry_loader_assimp2json.html
│ ├── geometry_loader_gltf.html
│ ├── geometry_loader_gltf2.html
│ ├── geometry_loader_gltf3.html
│ ├── geometry_loader_gltf_avif.html
│ ├── geometry_loader_gltf_camera.html
│ ├── geometry_loader_gltf_draco.html
│ ├── geometry_loader_gltf_helmat.html
│ ├── geometry_loader_gltf_instancing.html
│ ├── geometry_loader_gltf_lights.html
│ ├── geometry_loader_gltf_materials_clearcoat.html
│ ├── geometry_loader_gltf_materials_dispersion.html
│ ├── geometry_loader_gltf_materials_transmission.html
│ ├── geometry_loader_gltf_materials_unlit.html
│ ├── geometry_loader_gltf_meshopt.html
│ ├── geometry_loader_gltf_morphtargets.html
│ ├── geometry_loader_gltf_pointer.html
│ ├── geometry_loader_gltf_skinning.html
│ ├── geometry_loader_gltf_tangent.html
│ ├── geometry_loader_gltf_uvtransform.html
│ ├── geometry_loader_vox.html
│ ├── index.html
│ ├── jsm/
│ │ ├── Clock.js
│ │ ├── DynamicFont.js
│ │ ├── GBuffer.js
│ │ ├── PickBuffer.js
│ │ ├── Raycaster.js
│ │ ├── SHGenerator.js
│ │ ├── SceneUtils.js
│ │ ├── SkeletonUtils.js
│ │ ├── SuperSampling.js
│ │ ├── VoxMeshBuilder.js
│ │ ├── WaterSimulation.js
│ │ ├── WorkerPool.js
│ │ ├── animation/
│ │ │ ├── CCDIKSolver.js
│ │ │ └── LockedTrack.js
│ │ ├── canvas2d/
│ │ │ ├── Canvas2D.js
│ │ │ ├── Object2D.js
│ │ │ └── Sprite2D.js
│ │ ├── controls/
│ │ │ ├── FlyControls.js
│ │ │ ├── FreeControls.js
│ │ │ ├── OrbitControls.js
│ │ │ ├── TransformControls.js
│ │ │ └── ViewControls.js
│ │ ├── exporters/
│ │ │ ├── DRACOExporter.js
│ │ │ └── GLTFExporter.js
│ │ ├── geometries/
│ │ │ ├── BitmapTextGeometry.js
│ │ │ ├── CapsuleGeometry.js
│ │ │ ├── CircleGeometry.js
│ │ │ ├── GeometryUtils.js
│ │ │ └── builders/
│ │ │ ├── Earcut.js
│ │ │ ├── EdgesBuilder.js
│ │ │ ├── ExtrudeShapeBuilder.js
│ │ │ ├── Font.js
│ │ │ ├── GeometryBuilderUtils.js
│ │ │ ├── LatheBuilder.js
│ │ │ ├── PolygonBuilder.js
│ │ │ ├── PolyhedronBuilder.js
│ │ │ ├── RouteBuilder.js
│ │ │ ├── TorusBuilder.js
│ │ │ └── TubeBuilder.js
│ │ ├── impostor/
│ │ │ ├── OctahedralImpostor.js
│ │ │ └── OctahedralTextureGenerator.js
│ │ ├── lights/
│ │ │ ├── LightShadowAdapter.js
│ │ │ └── RectAreaLightLTC.js
│ │ ├── loaders/
│ │ │ ├── AssimpJsonLoader.js
│ │ │ ├── DDSLoader.js
│ │ │ ├── DRACOLoader.js
│ │ │ ├── EXRLoader.js
│ │ │ ├── EnvLoader.js
│ │ │ ├── ImageBitmapLoader.js
│ │ │ ├── KTX2Loader.js
│ │ │ ├── PVRLoader.js
│ │ │ ├── RGBELoader.js
│ │ │ ├── TGALoader.js
│ │ │ ├── Texture2DLoader.js
│ │ │ ├── TextureCubeLoader.js
│ │ │ └── glTF/
│ │ │ ├── Constants.js
│ │ │ ├── GLTFLoader.js
│ │ │ ├── GLTFResource.js
│ │ │ ├── GLTFUtils.js
│ │ │ ├── extensions/
│ │ │ │ ├── EXT_mesh_gpu_instancing.js
│ │ │ │ ├── EXT_meshopt_compression.js
│ │ │ │ ├── KHR_animation_pointer.js
│ │ │ │ ├── KHR_draco_mesh_compression.js
│ │ │ │ ├── KHR_lights_punctual.js
│ │ │ │ ├── KHR_materials_clearcoat.js
│ │ │ │ ├── KHR_materials_dispersion.js
│ │ │ │ ├── KHR_materials_ior.js
│ │ │ │ ├── KHR_materials_pbrSpecularGlossiness.js
│ │ │ │ ├── KHR_materials_transmission.js
│ │ │ │ ├── KHR_materials_unlit.js
│ │ │ │ ├── KHR_materials_volume.js
│ │ │ │ ├── KHR_texture_basisu.js
│ │ │ │ └── KHR_texture_transform.js
│ │ │ └── parsers/
│ │ │ ├── AccessorParser.js
│ │ │ ├── AnimationParser.js
│ │ │ ├── BufferParser.js
│ │ │ ├── BufferViewParser.js
│ │ │ ├── ImageParser.js
│ │ │ ├── IndexParser.js
│ │ │ ├── MaterialParser.js
│ │ │ ├── NodeParser.js
│ │ │ ├── PrimitiveParser.js
│ │ │ ├── ReferenceParser.js
│ │ │ ├── SceneParser.js
│ │ │ ├── SkinParser.js
│ │ │ ├── TextureParser.js
│ │ │ └── Validator.js
│ │ ├── materials/
│ │ │ ├── AlphaHashedPBRMaterial.js
│ │ │ ├── AttenuationMaterial.js
│ │ │ ├── BatchedMaterial.js
│ │ │ ├── BatchedPBRMaterial.js
│ │ │ ├── BitmapTextMaterial.js
│ │ │ ├── InstancedBasicMaterial.js
│ │ │ ├── InstancedMaterial.js
│ │ │ ├── InstancedPBRMaterial.js
│ │ │ ├── PlanarReflectionMaterial.js
│ │ │ └── TransmissionPBRMaterial.js
│ │ ├── math/
│ │ │ ├── ColorGradient.js
│ │ │ ├── DistanceTransform.js
│ │ │ ├── OBB.js
│ │ │ ├── Octree.js
│ │ │ ├── TriangleSoup.js
│ │ │ ├── TrianglesOctree.js
│ │ │ ├── VirtualGroup.js
│ │ │ └── curves/
│ │ │ ├── CubicBezierCurve2.js
│ │ │ ├── CubicBezierCurve3.js
│ │ │ ├── Curve.js
│ │ │ ├── CurvePath.js
│ │ │ ├── CurvePath2.js
│ │ │ ├── CurvePath3.js
│ │ │ ├── CurveUtils.js
│ │ │ ├── Curves.js
│ │ │ ├── LineCurve2.js
│ │ │ ├── LineCurve3.js
│ │ │ ├── QuadraticBezierCurve2.js
│ │ │ └── QuadraticBezierCurve3.js
│ │ ├── misc/
│ │ │ ├── OcclusionProxyManager.js
│ │ │ └── Timer.js
│ │ ├── navigation/
│ │ │ ├── AStar.js
│ │ │ ├── Pathfinding.js
│ │ │ ├── PathfindingHelper.js
│ │ │ ├── Utils.js
│ │ │ └── Zone.js
│ │ ├── objects/
│ │ │ ├── AxisHelper.js
│ │ │ ├── Background.js
│ │ │ ├── BatchedMesh.js
│ │ │ ├── Box3Helper.js
│ │ │ ├── BoxHelper.js
│ │ │ ├── CameraHelper.js
│ │ │ ├── DirectionalLightHelper.js
│ │ │ ├── GradientSky.js
│ │ │ ├── GridHelper.js
│ │ │ ├── HemisphereLightHelper.js
│ │ │ ├── InstancedLine.js
│ │ │ ├── LayeredVolumeMesh.js
│ │ │ ├── LegacySkeletonHelper.js
│ │ │ ├── LightShadowAdapterHelper.js
│ │ │ ├── LineChartFillMesh.js
│ │ │ ├── OcclusionTester.js
│ │ │ ├── OctreeHelper.js
│ │ │ ├── ParticleContainer.js
│ │ │ ├── PointLightHelper.js
│ │ │ ├── PolarGridHelper.js
│ │ │ ├── RectAreaLightHelper.js
│ │ │ ├── SkeletonHelper.js
│ │ │ ├── Sky.js
│ │ │ ├── SkyBox.js
│ │ │ ├── SphereHelper.js
│ │ │ ├── SpotLightHelper.js
│ │ │ ├── Sprite.js
│ │ │ ├── Terrain.js
│ │ │ ├── TriangleSoupHelper.js
│ │ │ ├── VertexNormalsHelper.js
│ │ │ ├── VertexTangentsHelper.js
│ │ │ └── Water.js
│ │ ├── ocean/
│ │ │ ├── Butterfly.js
│ │ │ ├── OceanField.js
│ │ │ ├── OceanFieldBuilder.js
│ │ │ ├── OceanMaterial.js
│ │ │ ├── Utils.js
│ │ │ ├── index.js
│ │ │ └── shaders/
│ │ │ ├── FFT2HShader.js
│ │ │ ├── FFT2VShader.js
│ │ │ ├── H0Shader.js
│ │ │ ├── HkShader.js
│ │ │ └── PostFFT2Shader.js
│ │ ├── pass/
│ │ │ ├── BlurPass.js
│ │ │ ├── DepthPeelingOITPass.js
│ │ │ ├── SSAOPass.js
│ │ │ ├── UnrealBloomPass.js
│ │ │ └── WeightedBlendedOITPass.js
│ │ ├── probes/
│ │ │ ├── PlanarReflectionProbe.js
│ │ │ └── ReflectionProbe.js
│ │ ├── render/
│ │ │ ├── DeferredRenderer.js
│ │ │ └── ForwardRenderer.js
│ │ ├── shaders/
│ │ │ ├── BlendShader.js
│ │ │ ├── BlurShader.js
│ │ │ ├── BokehShader.js
│ │ │ ├── ClusteredDebugShader.js
│ │ │ ├── ColorAdjustShader.js
│ │ │ ├── CopyShader.js
│ │ │ ├── DeferredShader.js
│ │ │ ├── DepthLinearShader.js
│ │ │ ├── FXAAShader.js
│ │ │ ├── FastGaussianBlurShader.js
│ │ │ ├── FilmShader.js
│ │ │ ├── GroundProjectedSkyboxShader.js
│ │ │ ├── InfiniteGridShader.js
│ │ │ ├── LineDashedShader.js
│ │ │ ├── LuminosityHighPassShader.js
│ │ │ ├── MSDFTextShader.js
│ │ │ ├── MatcapShader.js
│ │ │ ├── MotionBlur2Shader.js
│ │ │ ├── MotionBlurShader.js
│ │ │ ├── OutputShader.js
│ │ │ ├── PlanarShadowShader.js
│ │ │ ├── SDFTextShader.js
│ │ │ ├── SSAOShader.js
│ │ │ ├── SSRShader.js
│ │ │ ├── ShadowShader.js
│ │ │ ├── SketchShader.js
│ │ │ ├── SkyShader.js
│ │ │ ├── TAAShader.js
│ │ │ ├── TextureVariationShader.js
│ │ │ ├── VolumeShader.js
│ │ │ ├── WaterShader.js
│ │ │ └── XRayShader.js
│ │ ├── stereo/
│ │ │ ├── AnaglyphRenderer.js
│ │ │ ├── StereoCamera.js
│ │ │ ├── StereoRenderer.js
│ │ │ ├── WebVRControls.js
│ │ │ └── WebXRControls.js
│ │ └── textures/
│ │ ├── GradientTextureGenerator.js
│ │ ├── HeatmapGenerator.js
│ │ ├── IDWMapGenerator.js
│ │ ├── PMREMGenerator.js
│ │ └── RGBDDecoder.js
│ ├── lab_clouds.html
│ ├── lab_clouds_shader.html
│ ├── lab_earth.html
│ ├── lab_geometry_grass.html
│ ├── lab_geometry_images.html
│ ├── lab_gltf_grass.html
│ ├── lab_ground.html
│ ├── lab_histogram.html
│ ├── lab_ik.html
│ ├── lab_impostor_octahedral.html
│ ├── lab_impostor_octahedral_instancing.html
│ ├── lab_linechart_fill.html
│ ├── lab_ocean.html
│ ├── lab_ocean_fft.html
│ ├── lab_terrain.html
│ ├── lab_texture_variation.html
│ ├── lab_water_simulation.html
│ ├── libs/
│ │ ├── ammo.wasm.js
│ │ ├── ammo.wasm.wasm
│ │ ├── basis/
│ │ │ ├── README.md
│ │ │ ├── basis_transcoder.js
│ │ │ └── basis_transcoder.wasm
│ │ ├── cannon.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
│ │ ├── es-module-shims.js
│ │ ├── fflate.module.js
│ │ ├── ktx-parse.module.js
│ │ ├── meshopt_decoder.module.js
│ │ ├── nanobar.js
│ │ ├── simplex-noise.js
│ │ ├── stats.module.js
│ │ ├── tween.module.js
│ │ ├── webvr-polyfill.js
│ │ └── zstddec.module.js
│ ├── light_directlight.html
│ ├── light_group.html
│ ├── light_hemispherelight.html
│ ├── light_pointlight.html
│ ├── light_rectarealight.html
│ ├── light_shadow.html
│ ├── light_shadow_adapter.html
│ ├── light_softshadow.html
│ ├── light_sphericalharmonicslight.html
│ ├── light_spotlight.html
│ ├── lines_dashedlines.html
│ ├── lines_instancedlines.html
│ ├── lines_lines.html
│ ├── main.css
│ ├── material_alphahash.html
│ ├── material_alphamask.html
│ ├── material_blending.html
│ ├── material_bumpmap.html
│ ├── material_clearcoat.html
│ ├── material_clippingplanes.html
│ ├── material_depth.html
│ ├── material_emissivemap.html
│ ├── material_envmap.html
│ ├── material_flatshading.html
│ ├── material_lightmap.html
│ ├── material_materials.html
│ ├── material_normalmap.html
│ ├── material_pbr.html
│ ├── material_shader_background.html
│ ├── material_shader_extend.html
│ ├── material_shader_fakeInterior.html
│ ├── material_shader_grid.html
│ ├── material_shader_matcap.html
│ ├── material_shader_shadow.html
│ ├── material_shader_sky.html
│ ├── material_shader_sky2.html
│ ├── material_shader_sky_gradient.html
│ ├── material_shader_skybox.html
│ ├── material_shader_skybox_filter.html
│ ├── material_shader_skybox_groundprojected.html
│ ├── material_shader_volume.html
│ ├── material_shader_volume_layered.html
│ ├── material_shader_water.html
│ ├── material_shader_water_pbr.html
│ ├── material_shader_xray.html
│ ├── material_shadermaterial.html
│ ├── material_transparent.html
│ ├── material_uvcoord.html
│ ├── material_uvtransform.html
│ ├── material_vertexcolors.html
│ ├── math_curve.html
│ ├── math_curve_motion.html
│ ├── math_obb.html
│ ├── math_octree.html
│ ├── navigation_pathfinding.html
│ ├── navigation_recast_crowd.html
│ ├── navigation_recast_generation.html
│ ├── navigation_recast_obstacles.html
│ ├── navigation_recast_walking.html
│ ├── particle_particle.html
│ ├── physics_ammo.html
│ ├── physics_ammo_softbody_volume.html
│ ├── physics_cannon.html
│ ├── physics_ik.html
│ ├── physics_rapier.html
│ ├── physics_rapier_character_controller.html
│ ├── points_sprites.html
│ ├── probes_reflection.html
│ ├── probes_reflection_planar.html
│ ├── raycast_raycaster.html
│ ├── renderer_clustered_lighting.html
│ ├── renderer_culling_contribution.html
│ ├── renderer_culling_frustum.html
│ ├── renderer_deferred.html
│ ├── renderer_deferred_lighting.html
│ ├── resources/
│ │ ├── 3d/
│ │ │ └── Readme.txt
│ │ ├── compressed/
│ │ │ ├── 2d_astc_6x6.ktx2
│ │ │ ├── 2d_etc1s.ktx2
│ │ │ ├── 2d_rgba16_linear.ktx2
│ │ │ ├── 2d_rgba32_linear.ktx2
│ │ │ ├── 2d_rgba8.ktx2
│ │ │ ├── 2d_rgba8_displayp3.ktx2
│ │ │ ├── 2d_rgba8_linear.ktx2
│ │ │ ├── 2d_uastc.ktx2
│ │ │ ├── Mountains.dds
│ │ │ ├── Mountains_argb_mip.dds
│ │ │ ├── Mountains_argb_nomip.dds
│ │ │ ├── disturb_2bpp_rgb.pvr
│ │ │ ├── disturb_4bpp_rgb.pvr
│ │ │ ├── disturb_4bpp_rgb_mips.pvr
│ │ │ ├── disturb_4bpp_rgb_v3.pvr
│ │ │ ├── disturb_argb_mip.dds
│ │ │ ├── disturb_argb_nomip.dds
│ │ │ ├── disturb_dxt1_mip.dds
│ │ │ ├── disturb_dxt1_nomip.dds
│ │ │ ├── explosion_dxt5_mip.dds
│ │ │ ├── flare_2bpp_rgba.pvr
│ │ │ ├── flare_4bpp_rgba.pvr
│ │ │ ├── hepatica_dxt3_mip.dds
│ │ │ ├── park3_cube_mip_2bpp_rgb_v3.pvr
│ │ │ └── park3_cube_nomip_4bpp_rgb.pvr
│ │ ├── crate_color8.tga
│ │ ├── fonts/
│ │ │ ├── msdf/
│ │ │ │ └── roboto-regular.fnt
│ │ │ └── typeface/
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── helvetiker_bold.typeface.json
│ │ │ ├── helvetiker_regular.typeface.json
│ │ │ ├── optimer_bold.typeface.json
│ │ │ └── optimer_regular.typeface.json
│ │ ├── hdr/
│ │ │ ├── Grand_Canyon_C.env
│ │ │ ├── Grand_Canyon_C.hdr
│ │ │ ├── blouberg_sunrise_2_1k.hdr
│ │ │ ├── hall.hdr
│ │ │ ├── memorial.exr
│ │ │ ├── memorial.hdr
│ │ │ ├── pisa.hdr
│ │ │ ├── pisaHDR/
│ │ │ │ ├── nx.hdr
│ │ │ │ ├── ny.hdr
│ │ │ │ ├── nz.hdr
│ │ │ │ ├── px.hdr
│ │ │ │ ├── py.hdr
│ │ │ │ └── pz.hdr
│ │ │ └── royal_esplanade_1k.env
│ │ ├── lensflare/
│ │ │ └── LICENSE.txt
│ │ ├── models/
│ │ │ ├── assimp/
│ │ │ │ ├── interior/
│ │ │ │ │ ├── interior.3ds
│ │ │ │ │ └── interior.assimp.json
│ │ │ │ └── jeep/
│ │ │ │ ├── jeep.assimp.json
│ │ │ │ ├── jeep1.ms3d
│ │ │ │ └── jeep1.readme.txt
│ │ │ ├── gltf/
│ │ │ │ ├── BotSkinned/
│ │ │ │ │ └── glTF-MaterialsUnlit/
│ │ │ │ │ └── Bot_Skinned.gltf
│ │ │ │ ├── CesiumMan/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── glTF/
│ │ │ │ │ │ └── CesiumMan.gltf
│ │ │ │ │ ├── glTF-Binary/
│ │ │ │ │ │ └── CesiumMan.glb
│ │ │ │ │ ├── glTF-Draco/
│ │ │ │ │ │ └── CesiumMan.gltf
│ │ │ │ │ └── glTF-Embedded/
│ │ │ │ │ └── CesiumMan.gltf
│ │ │ │ ├── ClearCoatTest.glb
│ │ │ │ ├── CornellBox.glb
│ │ │ │ ├── DamagedHelmet/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── DamagedHelmet.gltf
│ │ │ │ ├── DispersionTest.glb
│ │ │ │ ├── DragonAttenuation/
│ │ │ │ │ └── DragonAttenuation.gltf
│ │ │ │ ├── Duck/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── glTF/
│ │ │ │ │ │ └── Duck.gltf
│ │ │ │ │ ├── glTF-Binary/
│ │ │ │ │ │ └── Duck.glb
│ │ │ │ │ ├── glTF-Draco/
│ │ │ │ │ │ └── Duck.gltf
│ │ │ │ │ ├── glTF-Embedded/
│ │ │ │ │ │ └── Duck.gltf
│ │ │ │ │ └── glTF-pbrSpecularGlossiness/
│ │ │ │ │ └── Duck.gltf
│ │ │ │ ├── Flamingo.glb
│ │ │ │ ├── GlamVelvetSofa/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── glTF/
│ │ │ │ │ │ └── GlamVelvetSofa.gltf
│ │ │ │ │ └── glTF-Binary/
│ │ │ │ │ └── GlamVelvetSofa.glb
│ │ │ │ ├── IKTest.glb
│ │ │ │ ├── InterpolationTest.glb
│ │ │ │ ├── IridescentDishWithOlives.glb
│ │ │ │ ├── LeePerrySmith/
│ │ │ │ │ ├── LeePerrySmith.glb
│ │ │ │ │ └── LeePerrySmith_License.txt
│ │ │ │ ├── LittlestTokyo.glb
│ │ │ │ ├── Michelle.glb
│ │ │ │ ├── NormalTangentMirrorTest/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── NormalTangentMirrorTest.gltf
│ │ │ │ ├── NormalTangentTest/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── NormalTangentTest.gltf
│ │ │ │ ├── PointerTest.glb
│ │ │ │ ├── PrimaryIonDrive.glb
│ │ │ │ ├── Soldier.glb
│ │ │ │ ├── Spheres/
│ │ │ │ │ └── Spheres.gltf
│ │ │ │ ├── TextureTransformTest/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── TextureTransformTest.gltf
│ │ │ │ ├── UinoDog/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── robot.gltf
│ │ │ │ ├── UinoHelmet/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── UinoHelmet.gltf
│ │ │ │ ├── UinoMan/
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── glTF/
│ │ │ │ │ └── UinoMan.gltf
│ │ │ │ ├── UinoSpaceman/
│ │ │ │ │ ├── README.md
│ │ │ │ │ ├── glTF/
│ │ │ │ │ │ └── UinoSpaceman.gltf
│ │ │ │ │ └── glTF-Binary/
│ │ │ │ │ └── UinoSpaceman.glb
│ │ │ │ ├── Xbot.glb
│ │ │ │ ├── asteroid.glb
│ │ │ │ ├── bust_of_woman/
│ │ │ │ │ ├── glTF/
│ │ │ │ │ │ └── bust_of_woman.gltf
│ │ │ │ │ └── glTF-Binary/
│ │ │ │ │ └── bust_of_woman.glb
│ │ │ │ ├── coffeemat.glb
│ │ │ │ ├── ferrari/
│ │ │ │ │ └── ferrari.glb
│ │ │ │ ├── forest_house.glb
│ │ │ │ ├── grass/
│ │ │ │ │ └── grass.gltf
│ │ │ │ ├── lighthouse.glb
│ │ │ │ ├── pool.glb
│ │ │ │ ├── robot_arm/
│ │ │ │ │ └── glTF/
│ │ │ │ │ ├── license.txt
│ │ │ │ │ └── scene.gltf
│ │ │ │ ├── sea_shell.glb
│ │ │ │ ├── suzanne/
│ │ │ │ │ └── suzanne.gltf
│ │ │ │ ├── teapots_galore/
│ │ │ │ │ └── teapots_galore.gltf
│ │ │ │ └── tree.glb
│ │ │ └── vox/
│ │ │ ├── castle.vox
│ │ │ ├── largedata.vox
│ │ │ ├── menger.vox
│ │ │ ├── monu1.vox
│ │ │ ├── monu10.vox
│ │ │ ├── monu9.vox
│ │ │ ├── p1.vox
│ │ │ ├── p2.vox
│ │ │ ├── p3.vox
│ │ │ ├── p4.vox
│ │ │ ├── p5.vox
│ │ │ ├── p6.vox
│ │ │ ├── p7.vox
│ │ │ └── ship.vox
│ │ ├── navigation/
│ │ │ ├── level.glb
│ │ │ └── level.nav.glb
│ │ ├── sintel.ogv
│ │ └── skybox/
│ │ ├── Bridge2/
│ │ │ └── readme.txt
│ │ ├── Park2/
│ │ │ └── readme.txt
│ │ ├── mp_cloud9/
│ │ │ ├── Cloud 9.nfo
│ │ │ ├── cloud9_bk.tga
│ │ │ ├── cloud9_dn.tga
│ │ │ ├── cloud9_ft.tga
│ │ │ ├── cloud9_lf.tga
│ │ │ ├── cloud9_rt.tga
│ │ │ ├── cloud9_up.tga
│ │ │ ├── license.txt
│ │ │ └── mp_cloud9.shader
│ │ └── skyboxsun25deg/
│ │ └── skyboxsun25degtest.txt
│ ├── scene_anchor.html
│ ├── scene_clippingplanes.html
│ ├── scene_fog.html
│ ├── scene_gamma_correction.html
│ ├── sprite_sprites.html
│ ├── stereo_anaglyph.html
│ ├── stereo_webvr_car.html
│ ├── stereo_webxr_vr_car.html
│ ├── text_bitmap.html
│ ├── text_bitmap_dynamic.html
│ ├── text_sdf.html
│ ├── text_sdf_dynamic.html
│ ├── text_typeface.html
│ ├── texture_2darray.html
│ ├── texture_3d.html
│ ├── texture_anisotropic.html
│ ├── texture_depth.html
│ ├── texture_generator_heatmap.html
│ ├── texture_generator_idwmap.html
│ ├── texture_integer.html
│ ├── texture_loader_compressed_dds.html
│ ├── texture_loader_compressed_pvr.html
│ ├── texture_loader_env.html
│ ├── texture_loader_exr.html
│ ├── texture_loader_hdr.html
│ ├── texture_loader_hdr_cube.html
│ ├── texture_loader_hdr_panorama.html
│ ├── texture_loader_imagebitmap.html
│ ├── texture_loader_ktx2.html
│ ├── texture_loader_tga.html
│ ├── texture_mipmap.html
│ ├── texture_video.html
│ ├── webgl_canvas_transparent.html
│ ├── webgl_clipculldistance.html
│ ├── webgl_contextlost.html
│ ├── webgl_depthfunc.html
│ ├── webgl_external_buffer.html
│ ├── webgl_external_texture.html
│ ├── webgl_helpers.html
│ ├── webgl_instanced_draw.html
│ ├── webgl_logarithmicDepthBuffer.html
│ ├── webgl_mesh_batch.html
│ ├── webgl_multi_draw.html
│ ├── webgl_polygonoffset.html
│ ├── webgl_primitive_restart.html
│ ├── webgl_query_occlusion.html
│ ├── webgl_query_occlusion_proxy.html
│ ├── webgl_query_timer.html
│ ├── webgl_renderinfo.html
│ ├── webgl_shader_compile.html
│ ├── webgl_shader_precompile.html
│ └── webgl_stencil.html
├── package.json
├── rollup.config.js
├── src/
│ ├── EventDispatcher.js
│ ├── animation/
│ │ ├── AnimationAction.js
│ │ ├── AnimationMixer.js
│ │ ├── KeyframeClip.js
│ │ ├── KeyframeInterpolants.js
│ │ ├── KeyframeTrack.js
│ │ ├── PropertyBindingMixer.js
│ │ └── tracks/
│ │ ├── BooleanKeyframeTrack.js
│ │ ├── ColorKeyframeTrack.js
│ │ ├── NumberKeyframeTrack.js
│ │ ├── QuaternionKeyframeTrack.js
│ │ ├── StringKeyframeTrack.js
│ │ └── VectorKeyframeTrack.js
│ ├── base.js
│ ├── const.js
│ ├── legacy.js
│ ├── loaders/
│ │ ├── FileLoader.js
│ │ ├── ImageLoader.js
│ │ ├── Loader.js
│ │ └── LoadingManager.js
│ ├── main.js
│ ├── math/
│ │ ├── Box2.js
│ │ ├── Box3.js
│ │ ├── Color3.js
│ │ ├── Color4.js
│ │ ├── Euler.js
│ │ ├── Frustum.js
│ │ ├── MathUtils.js
│ │ ├── Matrix3.js
│ │ ├── Matrix4.js
│ │ ├── Plane.js
│ │ ├── Quaternion.js
│ │ ├── Ray.js
│ │ ├── Sphere.js
│ │ ├── Spherical.js
│ │ ├── SphericalHarmonics3.js
│ │ ├── Triangle.js
│ │ ├── Vector2.js
│ │ ├── Vector3.js
│ │ └── Vector4.js
│ ├── render/
│ │ ├── LightingData.js
│ │ ├── LightingGroup.js
│ │ ├── PropertyMap.js
│ │ ├── RenderCollector.js
│ │ ├── RenderInfo.js
│ │ ├── RenderQueue.js
│ │ ├── RenderQueueLayer.js
│ │ ├── RenderStates.js
│ │ ├── SceneData.js
│ │ ├── ThinRenderer.js
│ │ └── passes/
│ │ ├── ShaderPostPass.js
│ │ └── ShadowMapPass.js
│ ├── resources/
│ │ ├── QuerySet.js
│ │ ├── Raycaster.js
│ │ ├── RenderBuffer.js
│ │ ├── Skeleton.js
│ │ ├── TransformUV.js
│ │ ├── fogs/
│ │ │ ├── Fog.js
│ │ │ └── FogExp2.js
│ │ ├── geometries/
│ │ │ ├── Attribute.js
│ │ │ ├── BoxGeometry.js
│ │ │ ├── Buffer.js
│ │ │ ├── CylinderGeometry.js
│ │ │ ├── Geometry.js
│ │ │ ├── PlaneGeometry.js
│ │ │ ├── SphereGeometry.js
│ │ │ └── TorusKnotGeometry.js
│ │ ├── materials/
│ │ │ ├── BasicMaterial.js
│ │ │ ├── DepthMaterial.js
│ │ │ ├── DistanceMaterial.js
│ │ │ ├── LambertMaterial.js
│ │ │ ├── LineMaterial.js
│ │ │ ├── Material.js
│ │ │ ├── PBR2Material.js
│ │ │ ├── PBRMaterial.js
│ │ │ ├── PhongMaterial.js
│ │ │ ├── PointsMaterial.js
│ │ │ └── ShaderMaterial.js
│ │ ├── projections/
│ │ │ ├── CameraProjection.js
│ │ │ ├── OrthographicProjection.js
│ │ │ └── PerspectiveProjection.js
│ │ ├── targets/
│ │ │ ├── OffscreenRenderTarget.js
│ │ │ ├── RenderTargetBase.js
│ │ │ └── ScreenRenderTarget.js
│ │ └── textures/
│ │ ├── Texture2D.js
│ │ ├── Texture2DArray.js
│ │ ├── Texture3D.js
│ │ ├── TextureBase.js
│ │ └── TextureCube.js
│ ├── scenes/
│ │ ├── Bone.js
│ │ ├── Camera.js
│ │ ├── Light.js
│ │ ├── Mesh.js
│ │ ├── Object3D.js
│ │ ├── Scene.js
│ │ ├── SkinnedMesh.js
│ │ └── lights/
│ │ ├── AmbientLight.js
│ │ ├── DirectionalLight.js
│ │ ├── DirectionalLightShadow.js
│ │ ├── HemisphereLight.js
│ │ ├── LightShadow.js
│ │ ├── PointLight.js
│ │ ├── PointLightShadow.js
│ │ ├── RectAreaLight.js
│ │ ├── SphericalHarmonicsLight.js
│ │ ├── SpotLight.js
│ │ └── SpotLightShadow.js
│ ├── shaders/
│ │ ├── ShaderChunk.js
│ │ ├── ShaderLib.js
│ │ ├── shaderChunk/
│ │ │ ├── alphaTest_frag.glsl
│ │ │ ├── alphaTest_pars_frag.glsl
│ │ │ ├── alphamap_frag.glsl
│ │ │ ├── alphamap_pars_frag.glsl
│ │ │ ├── alphamap_pars_vert.glsl
│ │ │ ├── alphamap_vert.glsl
│ │ │ ├── aoMap_frag.glsl
│ │ │ ├── aoMap_pars_frag.glsl
│ │ │ ├── aoMap_pars_vert.glsl
│ │ │ ├── aoMap_vert.glsl
│ │ │ ├── begin_frag.glsl
│ │ │ ├── begin_vert.glsl
│ │ │ ├── bsdfs.glsl
│ │ │ ├── bumpMap_pars_frag.glsl
│ │ │ ├── clearcoat_pars_frag.glsl
│ │ │ ├── clippingPlanes_frag.glsl
│ │ │ ├── clippingPlanes_pars_frag.glsl
│ │ │ ├── color_frag.glsl
│ │ │ ├── color_pars_frag.glsl
│ │ │ ├── color_pars_vert.glsl
│ │ │ ├── color_vert.glsl
│ │ │ ├── common_frag.glsl
│ │ │ ├── common_vert.glsl
│ │ │ ├── diffuseMap_frag.glsl
│ │ │ ├── diffuseMap_pars_frag.glsl
│ │ │ ├── diffuseMap_pars_vert.glsl
│ │ │ ├── diffuseMap_vert.glsl
│ │ │ ├── dithering_frag.glsl
│ │ │ ├── dithering_pars_frag.glsl
│ │ │ ├── emissiveMap_frag.glsl
│ │ │ ├── emissiveMap_pars_frag.glsl
│ │ │ ├── emissiveMap_pars_vert.glsl
│ │ │ ├── emissiveMap_vert.glsl
│ │ │ ├── encodings_frag.glsl
│ │ │ ├── encodings_pars_frag.glsl
│ │ │ ├── end_frag.glsl
│ │ │ ├── envMap_frag.glsl
│ │ │ ├── envMap_pars_frag.glsl
│ │ │ ├── envMap_pars_vert.glsl
│ │ │ ├── envMap_vert.glsl
│ │ │ ├── fog_frag.glsl
│ │ │ ├── fog_pars_frag.glsl
│ │ │ ├── inverse.glsl
│ │ │ ├── light_frag.glsl
│ │ │ ├── light_pars_frag.glsl
│ │ │ ├── logdepthbuf_frag.glsl
│ │ │ ├── logdepthbuf_pars_frag.glsl
│ │ │ ├── logdepthbuf_pars_vert.glsl
│ │ │ ├── logdepthbuf_vert.glsl
│ │ │ ├── modelPos_pars_frag.glsl
│ │ │ ├── modelPos_pars_vert.glsl
│ │ │ ├── modelPos_vert.glsl
│ │ │ ├── morphnormal_vert.glsl
│ │ │ ├── morphtarget_pars_vert.glsl
│ │ │ ├── morphtarget_vert.glsl
│ │ │ ├── normalMap_pars_frag.glsl
│ │ │ ├── normal_frag.glsl
│ │ │ ├── normal_pars_frag.glsl
│ │ │ ├── normal_pars_vert.glsl
│ │ │ ├── normal_vert.glsl
│ │ │ ├── packing.glsl
│ │ │ ├── premultipliedAlpha_frag.glsl
│ │ │ ├── pvm_vert.glsl
│ │ │ ├── shadow.glsl
│ │ │ ├── shadowMap_frag.glsl
│ │ │ ├── shadowMap_pars_frag.glsl
│ │ │ ├── shadowMap_pars_vert.glsl
│ │ │ ├── shadowMap_vert.glsl
│ │ │ ├── skinning_pars_vert.glsl
│ │ │ ├── skinning_vert.glsl
│ │ │ ├── skinnormal_vert.glsl
│ │ │ ├── specularMap_frag.glsl
│ │ │ ├── specularMap_pars_frag.glsl
│ │ │ ├── transpose.glsl
│ │ │ ├── tsn.glsl
│ │ │ ├── uv_pars_frag.glsl
│ │ │ ├── uv_pars_vert.glsl
│ │ │ └── uv_vert.glsl
│ │ └── shaderLib/
│ │ ├── basic_frag.glsl
│ │ ├── basic_vert.glsl
│ │ ├── depth_frag.glsl
│ │ ├── depth_vert.glsl
│ │ ├── distance_frag.glsl
│ │ ├── distance_vert.glsl
│ │ ├── lambert_frag.glsl
│ │ ├── lambert_vert.glsl
│ │ ├── normaldepth_frag.glsl
│ │ ├── normaldepth_vert.glsl
│ │ ├── pbr2_frag.glsl
│ │ ├── pbr_frag.glsl
│ │ ├── pbr_vert.glsl
│ │ ├── phong_frag.glsl
│ │ ├── phong_vert.glsl
│ │ ├── point_frag.glsl
│ │ └── point_vert.glsl
│ └── webgl/
│ ├── WebGLAttribute.js
│ ├── WebGLBuffers.js
│ ├── WebGLCapabilities.js
│ ├── WebGLClusteredLighting.js
│ ├── WebGLConstants.js
│ ├── WebGLGeometries.js
│ ├── WebGLLights.js
│ ├── WebGLMaterials.js
│ ├── WebGLProgram.js
│ ├── WebGLPrograms.js
│ ├── WebGLQuerySets.js
│ ├── WebGLRenderBuffers.js
│ ├── WebGLRenderTargets.js
│ ├── WebGLRenderer.js
│ ├── WebGLState.js
│ ├── WebGLTextures.js
│ ├── WebGLUniforms.js
│ └── WebGLVertexArrayBindings.js
├── tests/
│ ├── index.html
│ └── unit/
│ ├── source.unit.js
│ ├── src/
│ │ ├── EventDispatcher.tests.js
│ │ └── math/
│ │ ├── Box2.tests.js
│ │ ├── Box3.tests.js
│ │ ├── Color3.tests.js
│ │ ├── Color4.tests.js
│ │ ├── MathUtils.tests.js
│ │ ├── Matrix3.tests.js
│ │ ├── Matrix4.tests.js
│ │ ├── Plane.tests.js
│ │ ├── Quaternion.tests.js
│ │ ├── Ray.tests.js
│ │ ├── Sphere.tests.js
│ │ ├── Vector2.tests.js
│ │ ├── Vector3.tests.js
│ │ └── Vector4.tests.js
│ └── utils/
│ └── math-constants.js
└── tools/
├── assimp2json
└── doc.config.json
Showing preview only (566K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (7174 symbols across 317 files)
FILE: build/t3d.js
class MathUtils (line 15) | class MathUtils {
method generateUUID (line 21) | static generateUUID() {
method lerp (line 39) | static lerp(x, y, t) {
method clamp (line 50) | static clamp(value, min, max) {
method euclideanModulo (line 61) | static euclideanModulo(n, m) {
method mapLinear (line 75) | static mapLinear(x, a1, a2, b1, b2) {
method isPowerOfTwo (line 84) | static isPowerOfTwo(value) {
method nearestPowerOfTwo (line 93) | static nearestPowerOfTwo(value) {
method nextPowerOfTwo (line 102) | static nextPowerOfTwo(value) {
method nextPowerOfTwoSquareSize (line 119) | static nextPowerOfTwoSquareSize(value) {
method denormalize (line 130) | static denormalize(value, array) {
method normalize (line 158) | static normalize(value, array) {
method toHalfFloat (line 184) | static toHalfFloat(val) {
method fromHalfFloat (line 200) | static fromHalfFloat(val) {
function _generateTables (line 214) | function _generateTables() {
class Vector3 (line 307) | class Vector3 {
method constructor (line 314) | constructor(x = 0, y = 0, z = 0) {
method set (line 341) | set(x = 0, y = 0, z = 0) {
method setScalar (line 353) | setScalar(scalar) {
method clone (line 364) | clone() {
method copy (line 373) | copy(v) {
method add (line 385) | add(v) {
method addScalar (line 397) | addScalar(s) {
method addVectors (line 410) | addVectors(a, b) {
method addScaledVector (line 423) | addScaledVector(v, s) {
method sub (line 435) | sub(v) {
method subVectors (line 448) | subVectors(a, b) {
method multiply (line 460) | multiply(v) {
method multiplyScalar (line 472) | multiplyScalar(scalar) {
method applyMatrix3 (line 484) | applyMatrix3(m) {
method applyMatrix4 (line 501) | applyMatrix4(m) {
method applyQuaternion (line 518) | applyQuaternion(q) {
method project (line 548) | project(camera) {
method unproject (line 558) | unproject(camera) {
method transformDirection (line 568) | transformDirection(m) {
method min (line 588) | min(v) {
method max (line 601) | max(v) {
method negate (line 612) | negate() {
method dot (line 624) | dot(v) {
method getLengthSquared (line 634) | getLengthSquared() {
method getLength (line 642) | getLength() {
method normalize (line 652) | normalize(thickness = 1) {
method lerp (line 669) | lerp(v, alpha) {
method lerpVectors (line 685) | lerpVectors(v1, v2, alpha) {
method cross (line 697) | cross(v) {
method crossVectors (line 708) | crossVectors(a, b) {
method reflect (line 726) | reflect(normal) {
method scaleAlong (line 736) | scaleAlong(direction, scale) {
method angleTo (line 746) | angleTo(v) {
method distanceTo (line 761) | distanceTo(v) {
method distanceToSquared (line 772) | distanceToSquared(v) {
method setFromSpherical (line 784) | setFromSpherical(s) {
method setFromMatrixPosition (line 798) | setFromMatrixPosition(m) {
method setFromMatrixScale (line 812) | setFromMatrixScale(m) {
method setFromMatrixColumn (line 825) | setFromMatrixColumn(m, index) {
method equals (line 834) | equals(v) {
method fromArray (line 846) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 869) | toArray(array = [], offset = 0, normalize = false) {
method [Symbol.iterator] (line 883) | *[Symbol.iterator]() {
class Matrix4 (line 902) | class Matrix4 {
method constructor (line 906) | constructor() {
method set (line 935) | set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n...
method identity (line 960) | identity() {
method isIdentity (line 968) | isIdentity() {
method clone (line 977) | clone() {
method copy (line 986) | copy(m) {
method setFromMatrix3 (line 1013) | setFromMatrix3(m) {
method extractBasis (line 1025) | extractBasis(xAxis, yAxis, zAxis) {
method makeBasis (line 1039) | makeBasis(xAxis, yAxis, zAxis) {
method extractRotation (line 1052) | extractRotation(m) {
method makeRotationFromEuler (line 1086) | makeRotationFromEuler(euler) {
method makeRotationFromQuaternion (line 1201) | makeRotationFromQuaternion(q) {
method lookAtRH (line 1212) | lookAtRH(eye, target, up) {
method multiply (line 1251) | multiply(m) {
method premultiply (line 1260) | premultiply(m) {
method multiplyMatrices (line 1271) | multiplyMatrices(a, b) {
method determinant (line 1331) | determinant() {
method transpose (line 1359) | transpose() {
method setPosition (line 1391) | setPosition(x, y, z) {
method invert (line 1411) | invert() {
method getMaxScaleOnAxis (line 1460) | getMaxScaleOnAxis() {
method makeTranslation (line 1475) | makeTranslation(x, y, z) {
method makeRotationAxis (line 1493) | makeRotationAxis(axis, angle) {
method makeScale (line 1514) | makeScale(x, y, z) {
method compose (line 1526) | compose(position, quaternion, scale) {
method decompose (line 1577) | decompose(position, quaternion, scale) {
method equals (line 1618) | equals(matrix) {
method fromArray (line 1633) | fromArray(array, offset = 0) {
method toArray (line 1647) | toArray(array = [], offset = 0) {
method lerpMatrices (line 1675) | lerpMatrices(m1, m2, ratio) {
class Quaternion (line 1706) | class Quaternion {
method constructor (line 1714) | constructor(x = 0, y = 0, z = 0, w = 1) {
method slerpFlat (line 1733) | static slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
method multiplyQuaternionsFlat (line 1809) | static multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1,...
method x (line 1830) | get x() {
method x (line 1833) | set x(value) {
method y (line 1843) | get y() {
method y (line 1846) | set y(value) {
method z (line 1856) | get z() {
method z (line 1859) | set z(value) {
method w (line 1869) | get w() {
method w (line 1872) | set w(value) {
method set (line 1885) | set(x, y, z, w) {
method clone (line 1898) | clone() {
method copy (line 1907) | copy(quaternion) {
method setFromEuler (line 1923) | setFromEuler(euler, update = true) {
method setFromAxisAngle (line 1972) | setFromAxisAngle(axis, angle) {
method setFromRotationMatrix (line 1990) | setFromRotationMatrix(m) {
method setFromUnitVectors (line 2043) | setFromUnitVectors(vFrom, vTo) {
method angleTo (line 2078) | angleTo(q) {
method identity (line 2087) | identity() {
method conjugate (line 2097) | conjugate() {
method dot (line 2110) | dot(v) {
method lengthSq (line 2121) | lengthSq() {
method length (line 2130) | length() {
method normalize (line 2139) | normalize() {
method multiply (line 2162) | multiply(q) {
method premultiply (line 2171) | premultiply(q) {
method multiplyQuaternions (line 2181) | multiplyQuaternions(a, b) {
method lerpQuaternions (line 2207) | lerpQuaternions(q1, q2, ratio) {
method slerp (line 2246) | slerp(qb, t) {
method slerpQuaternions (line 2295) | slerpQuaternions(qa, qb, t) {
method equals (line 2304) | equals(quaternion) {
method fromArray (line 2315) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 2342) | toArray(array = [], offset = 0, normalize = false) {
method toMatrix4 (line 2365) | toMatrix4(target = new Matrix4()) {
method onChange (line 2402) | onChange(callback) {
method onChangeCallback (line 2406) | onChangeCallback() {}
method [Symbol.iterator] (line 2407) | *[Symbol.iterator]() {
class KeyframeInterpolant (line 2428) | class KeyframeInterpolant {
method getValueSize (line 2433) | static getValueSize() {
method interpolate (line 2445) | static interpolate(index0, ratio, duration, outBuffer) {
method copyValue (line 2455) | static copyValue(index, outBuffer) {
class StepInterpolant (line 2470) | class StepInterpolant extends KeyframeInterpolant {
method interpolate (line 2471) | static interpolate(index0, ratio, duration, outBuffer) {
class LinearInterpolant (line 2486) | class LinearInterpolant extends KeyframeInterpolant {
method interpolate (line 2487) | static interpolate(index0, ratio, duration, outBuffer) {
class QuaternionLinearInterpolant (line 2510) | class QuaternionLinearInterpolant extends KeyframeInterpolant {
method interpolate (line 2511) | static interpolate(index0, ratio, duration, outBuffer) {
class CubicSplineInterpolant (line 2523) | class CubicSplineInterpolant extends KeyframeInterpolant {
method getValueSize (line 2524) | static getValueSize() {
method interpolate (line 2527) | static interpolate(index0, ratio, duration, outBuffer) {
method copyValue (line 2556) | static copyValue(index, outBuffer) {
class QuaternionCubicSplineInterpolant (line 2571) | class QuaternionCubicSplineInterpolant extends CubicSplineInterpolant {
method interpolate (line 2572) | static interpolate(index0, ratio, duration, outBuffer) {
class KeyframeTrack (line 2584) | class KeyframeTrack {
method constructor (line 2592) | constructor(target, propertyPath, times, values, interpolant = LinearI...
method setInterpolant (line 2615) | setInterpolant(interpolant) {
method getValue (line 2628) | getValue(t, outBuffer) {
class BooleanKeyframeTrack (line 2654) | class BooleanKeyframeTrack extends KeyframeTrack {
method constructor (line 2662) | constructor(target, propertyPath, times, values, interpolant = StepInt...
class ColorKeyframeTrack (line 2682) | class ColorKeyframeTrack extends KeyframeTrack {
method constructor (line 2690) | constructor(target, propertyPath, times, values, interpolant) {
class NumberKeyframeTrack (line 2706) | class NumberKeyframeTrack extends KeyframeTrack {
method constructor (line 2714) | constructor(target, propertyPath, times, values, interpolant) {
class QuaternionKeyframeTrack (line 2730) | class QuaternionKeyframeTrack extends KeyframeTrack {
method constructor (line 2738) | constructor(target, propertyPath, times, values, interpolant = Quatern...
class StringKeyframeTrack (line 2758) | class StringKeyframeTrack extends KeyframeTrack {
method constructor (line 2766) | constructor(target, propertyPath, times, values, interpolant = StepInt...
class VectorKeyframeTrack (line 2786) | class VectorKeyframeTrack extends KeyframeTrack {
method constructor (line 2794) | constructor(target, propertyPath, times, values, interpolant) {
class EventDispatcher (line 3161) | class EventDispatcher {
method addEventListener (line 3167) | addEventListener(type, listener) {
method removeEventListener (line 3183) | removeEventListener(type, listener) {
method dispatchEvent (line 3199) | dispatchEvent(event) {
class AnimationAction (line 3222) | class AnimationAction extends EventDispatcher {
method constructor (line 3226) | constructor(clip) {
method update (line 3261) | update(deltaTime) {
class PropertyBindingMixer (line 3281) | class PropertyBindingMixer {
method constructor (line 3288) | constructor(target, propertyPath, typeName, valueSize) {
method parseBinding (line 3328) | parseBinding(target, propertyPath) {
method saveOriginalState (line 3346) | saveOriginalState() {
method restoreOriginalState (line 3376) | restoreOriginalState() {
method accumulate (line 3392) | accumulate(weight) {
method accumulateAdditive (line 3414) | accumulateAdditive(weight) {
method apply (line 3428) | apply() {
function select (line 3463) | function select(buffer, dstOffset, srcOffset, t, stride) {
function slerp (line 3470) | function slerp(buffer, dstOffset, srcOffset, t) {
function slerpAdditive (line 3474) | function slerpAdditive(buffer, dstOffset, srcOffset, t) {
function lerp (line 3480) | function lerp(buffer, dstOffset, srcOffset, t, stride) {
function lerpAdditive (line 3487) | function lerpAdditive(buffer, dstOffset, srcOffset, t, stride) {
function setIdentityNumeric (line 3495) | function setIdentityNumeric(buffer, offset, stride) {
function setIdentityQuaternion (line 3500) | function setIdentityQuaternion(buffer, offset) {
function setIdentityOther (line 3504) | function setIdentityOther(buffer, offset, stride, copyOffset) {
function getArray (line 3511) | function getArray(target, source, stride, count) {
function setArray (line 3516) | function setArray(target, source, stride, count) {
class AnimationMixer (line 3526) | class AnimationMixer {
method constructor (line 3527) | constructor() {
method addAction (line 3536) | addAction(action) {
method removeAction (line 3563) | removeAction(action) {
method hasAction (line 3594) | hasAction(action) {
method getActions (line 3602) | getActions() {
method update (line 3610) | update(deltaTime) {
class KeyframeClip (line 3663) | class KeyframeClip {
method constructor (line 3669) | constructor(name = '', tracks = [], duration = -1) {
method resetDuration (line 3697) | resetDuration() {
class LoadingManager (line 3726) | class LoadingManager {
method constructor (line 3733) | constructor(onLoad, onProgress, onError) {
method itemStart (line 3773) | itemStart(url) {
method itemEnd (line 3788) | itemEnd(url) {
method itemError (line 3806) | itemError(url) {
method resolveURL (line 3818) | resolveURL(url) {
method setURLModifier (line 3852) | setURLModifier(transform) {
class Loader (line 3868) | class Loader {
method constructor (line 3873) | constructor(manager) {
method load (line 3920) | load(url, onLoad, onProgress, onError) {}
method loadAsync (line 3928) | loadAsync(url, onProgress) {
method setCrossOrigin (line 3941) | setCrossOrigin(crossOrigin) {
method setWithCredentials (line 3953) | setWithCredentials(value) {
method setPath (line 3963) | setPath(path) {
method setRequestHeader (line 3974) | setRequestHeader(requestHeader) {
class FileLoader (line 3990) | class FileLoader extends Loader {
method constructor (line 3995) | constructor(manager) {
method load (line 4020) | load(url, onLoad, onProgress, onError) {
method setResponseType (line 4133) | setResponseType(value) {
method setMimeType (line 4143) | setMimeType(value) {
class HttpError (line 4148) | class HttpError extends Error {
method constructor (line 4149) | constructor(message, response) {
class ImageLoader (line 4164) | class ImageLoader extends Loader {
method constructor (line 4169) | constructor(manager) {
method load (line 4184) | load(url, onLoad, onProgress, onError) {
class Vector2 (line 4219) | class Vector2 {
method constructor (line 4224) | constructor(x = 0, y = 0) {
method set (line 4235) | set(x = 0, y = 0) {
method lerpVectors (line 4250) | lerpVectors(v1, v2, ratio) {
method min (line 4259) | min(v) {
method max (line 4270) | max(v) {
method getLength (line 4280) | getLength() {
method getLengthSquared (line 4290) | getLengthSquared() {
method normalize (line 4299) | normalize(thickness = 1) {
method subtract (line 4313) | subtract(a, target = new Vector2()) {
method sub (line 4322) | sub(v) {
method copy (line 4333) | copy(v) {
method addVectors (line 4345) | addVectors(a, b) {
method subVectors (line 4357) | subVectors(a, b) {
method multiplyScalar (line 4368) | multiplyScalar(scalar) {
method distanceToSquared (line 4380) | distanceToSquared(v) {
method distanceTo (line 4391) | distanceTo(v) {
method fromArray (line 4402) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 4421) | toArray(array = [], offset = 0, normalize = false) {
method add (line 4438) | add(v) {
method angle (line 4448) | angle() {
method negate (line 4462) | negate() {
method dot (line 4473) | dot(a) {
method equals (line 4482) | equals(v) {
method clone (line 4490) | clone() {
method [Symbol.iterator] (line 4493) | *[Symbol.iterator]() {
class Box2 (line 4510) | class Box2 {
method constructor (line 4517) | constructor(min, max) {
method set (line 4528) | set(x1, y1, x2, y2) {
method clone (line 4537) | clone() {
method copy (line 4546) | copy(box) {
class Box3 (line 4564) | class Box3 {
method constructor (line 4571) | constructor(min, max) {
method set (line 4581) | set(min, max) {
method setFromPoints (line 4591) | setFromPoints(points) {
method makeEmpty (line 4603) | makeEmpty() {
method expandByPoint (line 4614) | expandByPoint(point) {
method expandByScalar (line 4625) | expandByScalar(scalar) {
method expandByBox3 (line 4636) | expandByBox3(box3) {
method setFromArray (line 4650) | setFromArray(array, gap = 3, offset = 0, denormalize = false) {
method clampPoint (line 4684) | clampPoint(point, target) {
method distanceToPoint (line 4694) | distanceToPoint(point) {
method getBoundingSphere (line 4703) | getBoundingSphere(target) {
method isEmpty (line 4717) | isEmpty() {
method equals (line 4727) | equals(box) {
method getCenter (line 4736) | getCenter(target = new Vector3()) {
method getSize (line 4745) | getSize(target = new Vector3()) {
method getPoints (line 4761) | getPoints(points) {
method union (line 4785) | union(box) {
method applyMatrix4 (line 4796) | applyMatrix4(matrix) {
method containsPoint (line 4819) | containsPoint(point) {
method intersectsTriangle (line 4828) | intersectsTriangle(triangle) {
method clone (line 4872) | clone() {
method copy (line 4881) | copy(box) {
function satForAxes (line 4913) | function satForAxes(axes, v0, v1, v2, extents) {
class Color3 (line 4935) | class Color3 {
method constructor (line 4942) | constructor(r, g, b) {
method setHex (line 4975) | setHex(hex) {
method setRGB (line 4990) | setRGB(r, g, b) {
method setHSL (line 5004) | setHSL(h, s, l) {
method clone (line 5025) | clone() {
method copy (line 5034) | copy(color) {
method convertSRGBToLinear (line 5045) | convertSRGBToLinear() {
method convertLinearToSRGB (line 5056) | convertLinearToSRGB() {
method getHex (line 5067) | getHex() {
method lerp (line 5079) | lerp(color, alpha) {
method lerpColors (line 5092) | lerpColors(color1, color2, alpha) {
method fromArray (line 5106) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 5129) | toArray(array = [], offset = 0, normalize = false) {
method [Symbol.iterator] (line 5143) | *[Symbol.iterator]() {
function hue2rgb (line 5157) | function hue2rgb(p, q, t) {
function SRGBToLinear (line 5165) | function SRGBToLinear(c) {
function LinearToSRGB (line 5168) | function LinearToSRGB(c) {
class Color4 (line 5175) | class Color4 {
method constructor (line 5183) | constructor(r = 0, g = 0, b = 0, a = 1) {
method setRGBA (line 5221) | setRGBA(r, g, b, a) {
method clone (line 5233) | clone() {
method copy (line 5242) | copy(color) {
method fromArray (line 5257) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 5283) | toArray(array = [], offset = 0, normalize = false) {
method [Symbol.iterator] (line 5300) | *[Symbol.iterator]() {
class Euler (line 5321) | class Euler {
method constructor (line 5328) | constructor(x = 0, y = 0, z = 0, order = Euler.DefaultOrder) {
method x (line 5338) | get x() {
method x (line 5345) | set x(value) {
method y (line 5353) | get y() {
method y (line 5360) | set y(value) {
method z (line 5368) | get z() {
method z (line 5375) | set z(value) {
method order (line 5383) | get order() {
method order (line 5390) | set order(value) {
method clone (line 5399) | clone() {
method copy (line 5408) | copy(euler) {
method set (line 5424) | set(x = 0, y = 0, z = 0, order = this._order) {
method setFromRotationMatrix (line 5440) | setFromRotationMatrix(m, order = this._order, update = true) {
method setFromQuaternion (line 5522) | setFromQuaternion(q, order, update) {
method onChange (line 5531) | onChange(callback) {
method onChangeCallback (line 5535) | onChangeCallback() {}
method [Symbol.iterator] (line 5536) | *[Symbol.iterator]() {
class Matrix3 (line 5567) | class Matrix3 {
method constructor (line 5571) | constructor() {
method set (line 5588) | set(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
method identity (line 5606) | identity() {
method isIdentity (line 5614) | isIdentity() {
method determinant (line 5623) | determinant() {
method invert (line 5643) | invert() {
method transpose (line 5676) | transpose() {
method equals (line 5696) | equals(matrix) {
method fromArray (line 5711) | fromArray(array, offset = 0) {
method toArray (line 5724) | toArray(array = [], offset = 0) {
method clone (line 5742) | clone() {
method copy (line 5751) | copy(m) {
method multiply (line 5771) | multiply(m) {
method premultiply (line 5780) | premultiply(m) {
method multiplyMatrices (line 5790) | multiplyMatrices(a, b) {
method transform (line 5835) | transform(x, y, scaleX, scaleY, rotation, anchorX, anchorY) {
method setUvTransform (line 5867) | setUvTransform(tx, ty, sx, sy, rotation, cx, cy) {
method setFromMatrix4 (line 5878) | setFromMatrix4(m) {
method extractBasis (line 5890) | extractBasis(xAxis, yAxis, zAxis) {
class Plane (line 5915) | class Plane {
method constructor (line 5921) | constructor(normal = new Vector3(1, 0, 0), constant = 0) {
method intersectPlanes (line 5934) | static intersectPlanes(p1, p2, p3, target) {
method set (line 5952) | set(normal, constant) {
method setComponents (line 5966) | setComponents(x, y, z, w) {
method setFromNormalAndCoplanarPoint (line 5978) | setFromNormalAndCoplanarPoint(normal, point) {
method setFromCoplanarPoints (line 5992) | setFromCoplanarPoints(a, b, c) {
method normalize (line 6003) | normalize() {
method distanceToPoint (line 6017) | distanceToPoint(point) {
method projectPoint (line 6027) | projectPoint(point, target = new Vector3()) {
method mirrorPoint (line 6037) | mirrorPoint(point, target = new Vector3()) {
method coplanarPoint (line 6047) | coplanarPoint(target = new Vector3()) {
method clone (line 6055) | clone() {
method copy (line 6064) | copy(plane) {
method applyMatrix4 (line 6076) | applyMatrix4(matrix, optionalNormalMatrix) {
class Frustum (line 6100) | class Frustum {
method constructor (line 6109) | constructor(p0 = new Plane(), p1 = new Plane(), p2 = new Plane(), p3 =...
method set (line 6123) | set(p0, p1, p2, p3, p4, p5) {
method setFromMatrix (line 6139) | setFromMatrix(m) {
method intersectsSphere (line 6172) | intersectsSphere(sphere) {
method intersectsBox (line 6190) | intersectsBox(box) {
method applyMatrix4 (line 6215) | applyMatrix4(matrix) {
method clone (line 6228) | clone() {
method copy (line 6237) | copy(frustum) {
class Ray (line 6266) | class Ray {
method constructor (line 6272) | constructor(origin = new Vector3(), direction = new Vector3(0, 0, -1)) {
method set (line 6292) | set(origin, direction) {
method copy (line 6303) | copy(ray) {
method at (line 6315) | at(t, target = new Vector3()) {
method recast (line 6324) | recast(t) {
method closestPointToPoint (line 6335) | closestPointToPoint(point, target) {
method distanceToPoint (line 6349) | distanceToPoint(point) {
method distanceSqToPoint (line 6358) | distanceSqToPoint(point) {
method intersectSphere (line 6374) | intersectSphere(sphere, target) {
method intersectsSphere (line 6411) | intersectsSphere(sphere) {
method distanceToPlane (line 6422) | distanceToPlane(plane) {
method intersectPlane (line 6446) | intersectPlane(plane, target) {
method intersectsPlane (line 6459) | intersectsPlane(plane) {
method intersectBox (line 6481) | intersectBox(box, target) {
method intersectsBox (line 6530) | intersectsBox(box) {
method intersectTriangle (line 6544) | intersectTriangle(a, b, c, backfaceCulling, target) {
method applyMatrix4 (line 6605) | applyMatrix4(matrix4) {
method equals (line 6616) | equals(ray) {
method clone (line 6624) | clone() {
class Sphere (line 6644) | class Sphere {
method constructor (line 6649) | constructor(center = new Vector3(), radius = -1) {
method set (line 6660) | set(center, radius) {
method setFromPoints (line 6674) | setFromPoints(points, optionalCenter) {
method setFromArray (line 6697) | setFromArray(array, gap = 3, offset = 0, denormalize = false) {
method applyMatrix4 (line 6714) | applyMatrix4(matrix) {
method getBoundingBox (line 6725) | getBoundingBox(target) {
method isEmpty (line 6741) | isEmpty() {
method makeEmpty (line 6749) | makeEmpty() {
method containsPoint (line 6760) | containsPoint(point) {
method distanceToPoint (line 6770) | distanceToPoint(point) {
method expandByPoint (line 6779) | expandByPoint(point) {
method union (line 6802) | union(sphere) {
method clone (line 6824) | clone() {
method copy (line 6833) | copy(sphere) {
class Spherical (line 6854) | class Spherical {
method constructor (line 6860) | constructor(radius = 1, phi = 0, theta = 0) {
method set (line 6873) | set(radius, phi, theta) {
method copy (line 6885) | copy(other) {
method clone (line 6896) | clone() {
method makeSafe (line 6904) | makeSafe() {
method setFromVector3 (line 6915) | setFromVector3(vec3) {
class SphericalHarmonics3 (line 6941) | class SphericalHarmonics3 {
method constructor (line 6945) | constructor() {
method set (line 6962) | set(coefficients) {
method zero (line 6973) | zero() {
method getAt (line 6986) | getAt(normal, target) {
method getIrradianceAt (line 7018) | getIrradianceAt(normal, target) {
method add (line 7049) | add(sh) {
method addScaledSH (line 7062) | addScaledSH(sh, s) {
method scale (line 7074) | scale(s) {
method lerp (line 7090) | lerp(sh, alpha) {
method equals (line 7102) | equals(sh) {
method copy (line 7116) | copy(sh) {
method clone (line 7124) | clone() {
method fromArray (line 7134) | fromArray(array, offset = 0) {
method toArray (line 7149) | toArray(array = [], offset = 0) {
method getBasisAt (line 7162) | static getBasisAt(normal, shBasis) {
class Triangle (line 7202) | class Triangle {
method constructor (line 7208) | constructor(a = new Vector3(), b = new Vector3(), c = new Vector3()) {
method normal (line 7222) | static normal(a, b, c, optionalTarget) {
method barycoordFromPoint (line 7244) | static barycoordFromPoint(point, a, b, c, target) {
method containsPoint (line 7278) | static containsPoint(point, a, b, c) {
method set (line 7290) | set(a, b, c) {
class Vector4 (line 7309) | class Vector4 {
method constructor (line 7316) | constructor(x = 0, y = 0, z = 0, w = 1) {
method lerpVectors (line 7332) | lerpVectors(v1, v2, ratio) {
method set (line 7344) | set(x = 0, y = 0, z = 0, w = 1) {
method normalize (line 7356) | normalize() {
method multiplyScalar (line 7365) | multiplyScalar(scalar) {
method dot (line 7378) | dot(v) {
method getLengthSquared (line 7388) | getLengthSquared() {
method getLength (line 7396) | getLength() {
method getManhattanLength (line 7404) | getManhattanLength() {
method applyMatrix4 (line 7413) | applyMatrix4(m) {
method setFromMatrixPosition (line 7431) | setFromMatrixPosition(m) {
method equals (line 7445) | equals(v) {
method add (line 7454) | add(v) {
method multiply (line 7467) | multiply(v) {
method subVectors (line 7481) | subVectors(a, b) {
method fromArray (line 7498) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 7523) | toArray(array = [], offset = 0, normalize = false) {
method round (line 7545) | round() {
method clone (line 7557) | clone() {
method copy (line 7566) | copy(v) {
method [Symbol.iterator] (line 7573) | *[Symbol.iterator]() {
function cloneUniforms (line 7596) | function cloneUniforms(uniforms_src) {
function cloneJson (line 7617) | function cloneJson(obj) {
class Object3D (line 7636) | class Object3D {
method constructor (line 7637) | constructor() {
method onBeforeRender (line 7818) | onBeforeRender() {}
method onAfterRender (line 7823) | onAfterRender() {}
method add (line 7829) | add(object) {
method remove (line 7846) | remove(object) {
method getObjectByName (line 7862) | getObjectByName(name) {
method getObjectByProperty (line 7872) | getObjectByProperty(name, value) {
method updateMatrix (line 7888) | updateMatrix(force) {
method getWorldDirection (line 7915) | getWorldDirection(optionalTarget = new Vector3()) {
method lookAt (line 7925) | lookAt(target, up) {
method raycast (line 7936) | raycast(ray, intersects) {}
method traverse (line 7942) | traverse(callback) {
method clone (line 7955) | clone(recursive) {
method copy (line 7965) | copy(source, recursive = true) {
class SceneData (line 8005) | class SceneData {
method constructor (line 8006) | constructor() {
method update (line 8026) | update(scene) {
method setClippingPlanesData (line 8043) | setClippingPlanesData(clippingPlanes, clippingPlanesData) {
class Light (line 8065) | class Light extends Object3D {
method constructor (line 8070) | constructor(color = 0xffffff, intensity = 1) {
method lookAt (line 8102) | lookAt(target, up) {
method copy (line 8112) | copy(source) {
class RectAreaLight (line 8139) | class RectAreaLight extends Light {
method constructor (line 8146) | constructor(color, intensity, width = 10, height = 10) {
method power (line 8170) | get power() {
method power (line 8174) | set power(power) {
method copy (line 8178) | copy(source) {
class LightingGroup (line 8208) | class LightingGroup extends EventDispatcher {
method constructor (line 8209) | constructor() {
method begin (line 8259) | begin() {
method push (line 8263) | push(light, shadow) {
method end (line 8269) | end(sceneData) {
method dispose (line 8274) | dispose() {
method _setupCache (line 8279) | _setupCache(sceneData) {
method _doAddAmbientLight (line 8359) | _doAddAmbientLight(object) {
method _doAddSphericalHarmonicsLight (line 8367) | _doAddSphericalHarmonicsLight(object) {
method _doAddHemisphereLight (line 8377) | _doAddHemisphereLight(object, sceneData) {
method _doAddDirectLight (line 8397) | _doAddDirectLight(object, sceneData) {
method _doAddPointLight (line 8431) | _doAddPointLight(object, sceneData) {
method _doAddSpotLight (line 8470) | _doAddSpotLight(object, sceneData) {
method _doAddRectAreaLight (line 8519) | _doAddRectAreaLight(object, sceneData) {
function getLightCache (line 8569) | function getLightCache(light) {
function getShadowCache (line 8617) | function getShadowCache(light) {
class LightingData (line 8653) | class LightingData {
method constructor (line 8654) | constructor() {
method getGroup (line 8662) | getGroup(id) {
method setMaxGroupCount (line 8665) | setMaxGroupCount(max) {
method begin (line 8681) | begin() {
method collect (line 8689) | collect(light) {
method end (line 8696) | end(sceneData) {
method _distribute (line 8713) | _distribute(light, shadow) {
function shadowCastingLightsFirst (line 8731) | function shadowCastingLightsFirst(lightA, lightB) {
function castShadow (line 8736) | function castShadow(light) {
function _isPerspectiveMatrix$1 (line 8740) | function _isPerspectiveMatrix$1(m) {
class RenderStates (line 8748) | class RenderStates {
method constructor (line 8749) | constructor(sceneData, lightingData) {
method updateCamera (line 8773) | updateCamera(camera) {
class RenderQueueLayer (line 8816) | class RenderQueueLayer {
method constructor (line 8820) | constructor(id) {
method begin (line 8832) | begin() {
method end (line 8837) | end() {
method addRenderable (line 8856) | addRenderable(object, geometry, material, z, group) {
method sort (line 8886) | sort() {
function defaultOpaqueSortCompare (line 8891) | function defaultOpaqueSortCompare(a, b) {
function defaultTransparentSortCompare (line 8900) | function defaultTransparentSortCompare(a, b) {
function quickSort (line 8919) | function quickSort(a, from, to, compareFunc) {
function insertionSort (line 8994) | function insertionSort(a, from, to, compareFunc) {
class RenderQueue (line 9015) | class RenderQueue {
method constructor (line 9016) | constructor() {
method begin (line 9024) | begin() {
method end (line 9030) | end() {
method push (line 9036) | push(object, camera) {
method setLayer (line 9071) | setLayer(id, layer) {
method createLayer (line 9082) | createLayer(id) {
method getLayer (line 9093) | getLayer(id) {
method removeLayer (line 9101) | removeLayer(id) {
function sortLayer (line 9116) | function sortLayer(a, b) {
class RenderCollector (line 9124) | class RenderCollector {
method constructor (line 9130) | constructor() {
method lightingNeedsUpdate (line 9180) | set lightingNeedsUpdate(value) {
method skeletonNeedsUpdate (line 9193) | set skeletonNeedsUpdate(value) {
method getRenderStates (line 9205) | getRenderStates(camera) {
method getRenderQueue (line 9222) | getRenderQueue(camera) {
method traverseAndCollect (line 9238) | traverseAndCollect(scene, camera) {
method _traverseAndCollect (line 9269) | _traverseAndCollect(object, camera, renderQueue) {
class Scene (line 9296) | class Scene extends Object3D {
method constructor (line 9300) | constructor() {
method maxLightingGroups (line 9380) | set maxLightingGroups(value) {
method maxLightingGroups (line 9383) | get maxLightingGroups() {
method getRenderStates (line 9394) | getRenderStates(camera) {
method getRenderQueue (line 9404) | getRenderQueue(camera) {
method updateRenderStates (line 9415) | updateRenderStates(camera, updateScene = true) {
method updateRenderQueue (line 9434) | updateRenderQueue(camera, collectLights = true, updateSkeletons = true) {
class CameraProjection (line 9455) | class CameraProjection {
method constructor (line 9459) | constructor() {
method matrix (line 9468) | get matrix() {
method copy (line 9480) | copy(source) {
method clone (line 9489) | clone() {
method _updateMatrix (line 9497) | _updateMatrix() {
class PerspectiveProjection (line 9508) | class PerspectiveProjection extends CameraProjection {
method constructor (line 9516) | constructor(fov = 50, aspect = 1, near = 0.1, far = 2000) {
method fov (line 9529) | set fov(value) {
method fov (line 9533) | get fov() {
method aspect (line 9542) | set aspect(value) {
method aspect (line 9546) | get aspect() {
method near (line 9555) | set near(value) {
method near (line 9559) | get near() {
method far (line 9568) | set far(value) {
method far (line 9572) | get far() {
method set (line 9584) | set(fov, aspect, near, far) {
method copy (line 9598) | copy(source) {
method _updateMatrix (line 9611) | _updateMatrix() {
class OrthographicProjection (line 9626) | class OrthographicProjection extends CameraProjection {
method constructor (line 9636) | constructor(left = -1, right = 1, top = 1, bottom = -1, near = 0.1, fa...
method left (line 9651) | set left(value) {
method left (line 9655) | get left() {
method right (line 9664) | set right(value) {
method right (line 9668) | get right() {
method top (line 9677) | set top(value) {
method top (line 9681) | get top() {
method bottom (line 9690) | set bottom(value) {
method bottom (line 9694) | get bottom() {
method near (line 9703) | set near(value) {
method near (line 9707) | get near() {
method far (line 9716) | set far(value) {
method far (line 9720) | get far() {
method set (line 9734) | set(left, right, top, bottom, near, far) {
method setSize (line 9751) | setSize(width, height) {
method copy (line 9765) | copy(source) {
method _updateMatrix (line 9780) | _updateMatrix() {
class Camera (line 9797) | class Camera extends Object3D {
method constructor (line 9801) | constructor() {
method lookAt (line 9872) | lookAt(target, up) {
method setOrtho (line 9887) | setOrtho(left, right, bottom, top, near, far) {
method setPerspective (line 9900) | setPerspective(fov, aspect, near, far) {
method setProjectionMatrix (line 9909) | setProjectionMatrix(matrix) {
method getWorldDirection (line 9913) | getWorldDirection(optionalTarget = new Vector3()) {
method updateMatrix (line 9916) | updateMatrix(force) {
method copy (line 9923) | copy(source, recursive) {
class Mesh (line 9968) | class Mesh extends Object3D {
method constructor (line 9973) | constructor(geometry, material) {
method getVertexPosition (line 10003) | getVertexPosition(index, target) {
method raycast (line 10022) | raycast(ray, intersects) {
method copy (line 10108) | copy(source) {
method clone (line 10115) | clone() {
function checkGeometryIntersection (line 10127) | function checkGeometryIntersection(object, material, ray, _ray, uv, a, b...
function uvIntersection (line 10156) | function uvIntersection(point, p1, p2, p3, uv1, uv2, uv3) {
function checkIntersection (line 10164) | function checkIntersection(object, material, ray, localRay, pA, pB, pC, ...
class Attribute (line 10187) | class Attribute {
method constructor (line 10194) | constructor(buffer, size = buffer.stride, offset = 0, normalized = fal...
method copy (line 10235) | copy(source) {
method clone (line 10249) | clone(buffers) {
class Buffer (line 10269) | class Buffer {
method constructor (line 10274) | constructor(array, stride) {
method onUploadCallback (line 10323) | onUploadCallback() {}
method copy (line 10330) | copy(source) {
method clone (line 10342) | clone() {
class Geometry (line 10363) | class Geometry extends EventDispatcher {
method constructor (line 10367) | constructor() {
method addAttribute (line 10452) | addAttribute(name, attribute) {
method getAttribute (line 10461) | getAttribute(name) {
method removeAttribute (line 10469) | removeAttribute(name) {
method setIndex (line 10477) | setIndex(index) {
method addGroup (line 10492) | addGroup(start, count, materialIndex = 0) {
method clearGroups (line 10503) | clearGroups() {
method computeBoundingBox (line 10511) | computeBoundingBox() {
method computeBoundingSphere (line 10533) | computeBoundingSphere() {
method dispose (line 10580) | dispose() {
method copy (line 10591) | copy(source) {
method clone (line 10651) | clone() {
function arrayMax (line 10655) | function arrayMax(array) {
class TransformUV (line 10668) | class TransformUV extends Matrix3 {
method constructor (line 10672) | constructor() {
method update (line 10686) | update() {
method updateMatrix (line 10698) | updateMatrix() {
method copy (line 10707) | copy(source) {
method clone (line 10724) | clone() {
class Material (line 10747) | class Material extends EventDispatcher {
method constructor (line 10748) | constructor() {
method copy (line 11351) | copy(source) {
method clone (line 11431) | clone() {
method dispose (line 11439) | dispose() {
class ShaderMaterial (line 11451) | class ShaderMaterial extends Material {
method constructor (line 11460) | constructor(shader) {
class ShaderPostPass (line 11477) | class ShaderPostPass {
method constructor (line 11486) | constructor(shader) {
method render (line 11517) | render(renderer, renderTarget) {
method dispose (line 11526) | dispose() {
class DepthMaterial (line 11537) | class DepthMaterial extends Material {
method constructor (line 11541) | constructor() {
class DistanceMaterial (line 11558) | class DistanceMaterial extends Material {
method constructor (line 11562) | constructor() {
class ShadowMapPass (line 11571) | class ShadowMapPass {
method constructor (line 11572) | constructor() {
method getGeometry (line 11622) | set getGeometry(func) {
method getGeometry (line 11629) | get getGeometry() {
method ifRender (line 11637) | set ifRender(func) {
method ifRender (line 11644) | get ifRender() {
method render (line 11653) | render(renderer, scene) {
function _getDepthMaterial (line 11707) | function _getDepthMaterial(renderable, light) {
function _getDistanceMaterial (line 11729) | function _getDistanceMaterial(renderable, light) {
class PropertyMap (line 11759) | class PropertyMap {
method constructor (line 11764) | constructor(prefix) {
method get (line 11775) | get(object) {
method delete (line 11790) | delete(object) {
method size (line 11803) | size() {
class RenderInfo (line 11813) | class RenderInfo {
method constructor (line 11814) | constructor() {
class ThinRenderer (line 11876) | class ThinRenderer {
method constructor (line 11877) | constructor() {
method init (line 11951) | init(context, options = {}) {}
method beginRender (line 11957) | beginRender(renderTarget) {
method endRender (line 11964) | endRender() {
method renderRenderableItem (line 11986) | renderRenderableItem(renderable, renderStates, options) {}
method renderRenderableList (line 11994) | renderRenderableList(renderables, renderStates, options = {}) {
method renderScene (line 12009) | renderScene(scene, camera, renderTarget, options = {}) {
method blitRenderTarget (line 12037) | blitRenderTarget(read, draw, color = true, depth = true, stencil = tru...
method generateMipmaps (line 12043) | generateMipmaps(texture) {}
method readTexturePixels (line 12058) | readTexturePixels(texture, x, y, width, height, buffer, zIndex = 0, mi...
method readTexturePixelsSync (line 12073) | readTexturePixelsSync(texture, x, y, width, height, buffer, zIndex = 0...
method resetVertexArrayBindings (line 12079) | resetVertexArrayBindings(force) {}
method resetState (line 12085) | resetState() {}
method beginOcclusionQuery (line 12091) | beginOcclusionQuery(index) {}
method endOcclusionQuery (line 12096) | endOcclusionQuery() {}
method readQuerySetResults (line 12107) | readQuerySetResults(querySet, dstBuffer, firstQuery = 0, queryCount = ...
method increaseId (line 12114) | increaseId() {
class Fog (line 12123) | class Fog {
method constructor (line 12129) | constructor(color = 0x000000, near = 1, far = 1000) {
class FogExp2 (line 12164) | class FogExp2 {
method constructor (line 12169) | constructor(color = 0x000000, density = 0.00025) {
class BoxGeometry (line 12199) | class BoxGeometry extends Geometry {
method constructor (line 12208) | constructor(width = 1, height = 1, depth = 1, widthSegments = 1, heigh...
class CylinderGeometry (line 12340) | class CylinderGeometry extends Geometry {
method constructor (line 12351) | constructor(radiusTop = 1, radiusBottom = 1, height = 1, radialSegment...
class PlaneGeometry (line 12564) | class PlaneGeometry extends Geometry {
method constructor (line 12571) | constructor(width = 1, height = 1, widthSegments = 1, heightSegments =...
class SphereGeometry (line 12636) | class SphereGeometry extends Geometry {
method constructor (line 12646) | constructor(radius = 1, widthSegments = 8, heightSegments = 6, phiStar...
class TorusKnotGeometry (line 12728) | class TorusKnotGeometry extends Geometry {
method constructor (line 12737) | constructor(radius = 1, tube = 0.4, tubularSegments = 64, radialSegmen...
class BasicMaterial (line 12858) | class BasicMaterial extends Material {
method constructor (line 12862) | constructor() {
class LambertMaterial (line 12874) | class LambertMaterial extends Material {
method constructor (line 12878) | constructor() {
class LineMaterial (line 12893) | class LineMaterial extends Material {
method constructor (line 12897) | constructor() {
method copy (line 12916) | copy(source) {
class PBR2Material (line 12930) | class PBR2Material extends Material {
method constructor (line 12934) | constructor() {
method copy (line 12971) | copy(source) {
class PBRMaterial (line 12988) | class PBRMaterial extends Material {
method constructor (line 12992) | constructor() {
method copy (line 13082) | copy(source) {
class PhongMaterial (line 13103) | class PhongMaterial extends Material {
method constructor (line 13107) | constructor() {
method copy (line 13138) | copy(source) {
class PointsMaterial (line 13151) | class PointsMaterial extends Material {
method constructor (line 13155) | constructor() {
method copy (line 13180) | copy(source) {
class RenderTargetBase (line 13195) | class RenderTargetBase extends EventDispatcher {
method constructor (line 13196) | constructor(width, height) {
method resize (line 13277) | resize() {
method dispose (line 13285) | dispose() {
method setClear (line 13296) | setClear(color, depth, stencil) {
method setColorClearValue (line 13311) | setColorClearValue(r, g, b, a) {
method setDepthClearValue (line 13321) | setDepthClearValue(depth) {
method setStencilClearValue (line 13331) | setStencilClearValue(stencil) {
method setOcclusionQuerySet (line 13341) | setOcclusionQuerySet(querySet) {
method setTimestampWrites (line 13353) | setTimestampWrites(querySet, beginIndex = 0, endIndex = 1) {
class RenderBuffer (line 13373) | class RenderBuffer extends EventDispatcher {
method constructor (line 13380) | constructor(width, height, format = PIXEL_FORMAT.RGBA8, multipleSampli...
method resize (line 13424) | resize(width, height) {
method clone (line 13438) | clone() {
method copy (line 13447) | copy(source) {
method dispose (line 13456) | dispose() {
class TextureBase (line 13478) | class TextureBase extends EventDispatcher {
method constructor (line 13479) | constructor() {
method clone (line 13631) | clone() {
method copy (line 13640) | copy(source) {
method dispose (line 13665) | dispose() {
method resizeAsAttachment (line 13680) | resizeAsAttachment(width, height, depth) {}
class Texture2D (line 13695) | class Texture2D extends TextureBase {
method constructor (line 13696) | constructor() {
method copy (line 13712) | copy(source) {
method resizeAsAttachment (line 13721) | resizeAsAttachment(width, height) {
class TextureCube (line 13752) | class TextureCube extends TextureBase {
method constructor (line 13753) | constructor() {
method copy (line 13774) | copy(source) {
method resizeAsAttachment (line 13783) | resizeAsAttachment(width, height) {
class Texture3D (line 13820) | class Texture3D extends TextureBase {
method constructor (line 13821) | constructor() {
method copy (line 13883) | copy(source) {
method resizeAsAttachment (line 13892) | resizeAsAttachment(width, height, depth) {
class Texture2DArray (line 13927) | class Texture2DArray extends TextureBase {
method constructor (line 13928) | constructor() {
method copy (line 13985) | copy(source) {
method resizeAsAttachment (line 13994) | resizeAsAttachment(width, height, depth) {
class OffscreenRenderTarget (line 14029) | class OffscreenRenderTarget extends RenderTargetBase {
method constructor (line 14035) | constructor(width, height) {
method resize (line 14064) | resize(width, height, depth) {
method dispose (line 14086) | dispose(disposeAttachments = true) {
method attach (line 14104) | attach(target, attachment = ATTACHMENT.COLOR_ATTACHMENT0) {
method detach (line 14119) | detach(attachment = ATTACHMENT.COLOR_ATTACHMENT0) {
method getAttachment (line 14129) | getAttachment(attachment = ATTACHMENT.COLOR_ATTACHMENT0) {
method texture (line 14137) | set texture(texture) {
method texture (line 14144) | get texture() {
method activeCubeFace (line 14154) | set activeCubeFace(value) {
method activeCubeFace (line 14157) | get activeCubeFace() {
method create2D (line 14168) | static create2D(width, height) {
method createCube (line 14182) | static createCube(width, height) {
method create3D (line 14197) | static create3D(width, height, depth) {
method create2DArray (line 14213) | static create2DArray(width, height, depth) {
class ScreenRenderTarget (line 14234) | class ScreenRenderTarget extends RenderTargetBase {
method constructor (line 14239) | constructor(view) {
method resize (line 14255) | resize(width, height) {
method dispose (line 14265) | dispose() {
class QuerySet (line 14286) | class QuerySet extends EventDispatcher {
method constructor (line 14292) | constructor(type, count) {
method dispose (line 14335) | dispose() {
class Raycaster (line 14347) | class Raycaster {
method constructor (line 14353) | constructor(origin, direction) {
method set (line 14366) | set(origin, direction) {
method setFromCamera (line 14377) | setFromCamera(coords, camera) {
method intersectObject (line 14401) | intersectObject(object, recursive = false, intersects = []) {
method intersectObjects (line 14417) | intersectObjects(objects, recursive = false, intersects = []) {
function ascSort (line 14425) | function ascSort(a, b) {
function intersect (line 14428) | function intersect(object, raycaster, intersects, recursive) {
class Skeleton (line 14445) | class Skeleton {
method constructor (line 14450) | constructor(bones, boneInverses) {
method pose (line 14482) | pose() {
method clone (line 14504) | clone() {
method updateBones (line 14513) | updateBones(sceneData) {
method generateBoneTexture (line 14529) | generateBoneTexture() {
class AmbientLight (line 14556) | class AmbientLight extends Light {
method constructor (line 14561) | constructor(color, intensity) {
class LightShadow (line 14578) | class LightShadow {
method constructor (line 14579) | constructor() {
method update (line 14662) | update(light, face) {}
method updateMatrix (line 14663) | updateMatrix() {
method copy (line 14672) | copy(source) {
method clone (line 14683) | clone() {
method prepareDepthMap (line 14686) | prepareDepthMap(_enable, _capabilities) {}
class DirectionalLightShadow (line 14693) | class DirectionalLightShadow extends LightShadow {
method constructor (line 14694) | constructor() {
method update (line 14731) | update(light) {
method _updateCamera (line 14737) | _updateCamera(light) {
method copy (line 14745) | copy(source) {
method prepareDepthMap (line 14751) | prepareDepthMap(enable, capabilities) {
class DirectionalLight (line 14777) | class DirectionalLight extends Light {
method constructor (line 14782) | constructor(color, intensity) {
method copy (line 14792) | copy(source) {
class HemisphereLight (line 14812) | class HemisphereLight extends Light {
method constructor (line 14818) | constructor(skyColor, groundColor, intensity) {
method copy (line 14828) | copy(source) {
class PointLightShadow (line 14846) | class PointLightShadow extends LightShadow {
method constructor (line 14847) | constructor() {
method update (line 14859) | update(light, face) {
method _updateCamera (line 14865) | _updateCamera(light, face) {
class PointLight (line 14890) | class PointLight extends Light {
method constructor (line 14897) | constructor(color, intensity, distance, decay) {
method copy (line 14921) | copy(source) {
class SphericalHarmonicsLight (line 14941) | class SphericalHarmonicsLight extends Light {
method constructor (line 14947) | constructor(sh = new SphericalHarmonics3(), intensity = 1) {
method copy (line 14956) | copy(source) {
class SpotLightShadow (line 14975) | class SpotLightShadow extends LightShadow {
method constructor (line 14976) | constructor() {
method update (line 15004) | update(light) {
method _updateCamera (line 15010) | _updateCamera(light) {
method copy (line 15017) | copy(source) {
method prepareDepthMap (line 15022) | prepareDepthMap(enable, capabilities) {
class SpotLight (line 15046) | class SpotLight extends Light {
method constructor (line 15055) | constructor(color, intensity, distance, angle, penumbra, decay) {
method copy (line 15095) | copy(source) {
class Bone (line 15119) | class Bone extends Object3D {
method constructor (line 15120) | constructor() {
class SkinnedMesh (line 15138) | class SkinnedMesh extends Mesh {
method constructor (line 15139) | constructor(geometry, material) {
method bind (line 15176) | bind(skeleton, bindMatrix) {
method updateMatrix (line 15185) | updateMatrix(force) {
method copy (line 15195) | copy(source) {
method getVertexPosition (line 15203) | getVertexPosition(index, target) {
method applyBoneTransform (line 15216) | applyBoneTransform(index, target) {
function getComponent (line 15249) | function getComponent(vec, index) {
class WebGLAttribute (line 15556) | class WebGLAttribute {
method constructor (line 15557) | constructor(gl, program, attributeData) {
function getAttributeCount (line 15571) | function getAttributeCount(gl, type) {
function getAttributeFormat (line 15596) | function getAttributeFormat(gl, type) {
class WebGLCapabilities (line 15618) | class WebGLCapabilities {
method constructor (line 15619) | constructor(gl) {
method getExtension (line 15671) | getExtension(name) {
function getMaxPrecision (line 15689) | function getMaxPrecision(gl, precision) {
class WebGLGeometries (line 15705) | class WebGLGeometries extends PropertyMap {
method constructor (line 15706) | constructor(prefix, gl, buffers, vertexArrayBindings) {
method setGeometry (line 15734) | setGeometry(geometry, passInfo) {
function arraysEqual (line 15955) | function arraysEqual(a, b) {
function copyArray (line 15962) | function copyArray(a, b) {
function allocTexUnits (line 15971) | function allocTexUnits(textures, n) {
function generateSetter (line 15985) | function generateSetter(uniform, pureArray) {
class SingleUniform (line 16295) | class SingleUniform {
method constructor (line 16296) | constructor(gl, id, activeInfo, location) {
class PureArrayUniform (line 16320) | class PureArrayUniform {
method constructor (line 16321) | constructor(gl, id, activeInfo, location) {
class UniformContainer (line 16333) | class UniformContainer {
method constructor (line 16334) | constructor() {
class StructuredUniform (line 16339) | class StructuredUniform extends UniformContainer {
method constructor (line 16340) | constructor(id) {
method set (line 16344) | set(value, textures) {
function addUniform (line 16368) | function addUniform(container, uniformObject) {
function parseUniform (line 16374) | function parseUniform(gl, activeInfo, location, container) {
class WebGLUniforms (line 16407) | class WebGLUniforms extends UniformContainer {
method constructor (line 16408) | constructor(gl, program) {
method set (line 16417) | set(name, value, textures) {
method has (line 16421) | has(name) {
class WebGLProgram (line 16427) | class WebGLProgram {
method constructor (line 16428) | constructor(gl, vshader, fshader) {
function handleSource (line 16532) | function handleSource(string, errorLine) {
function loadShader (line 16543) | function loadShader(gl, type, source) {
function getShaderErrors (line 16549) | function getShaderErrors(gl, shader, type) {
function extractAttributes (line 16566) | function extractAttributes(gl, program) {
class WebGLPrograms (line 16576) | class WebGLPrograms {
method constructor (line 16577) | constructor(gl, state, capabilities) {
method getProgram (line 16583) | getProgram(material, props, programCode, compileOptions) {
method releaseProgram (line 16606) | releaseProgram(program) {
method generateProps (line 16619) | generateProps(material, object, lightingState, renderStates) {
method generateProgramCode (line 16746) | generateProgramCode(props, material) {
function generateDefines (line 16767) | function generateDefines(defines) {
function getUVChannel (line 16778) | function getUVChannel(coord) {
function getTextureEncodingFromMap (line 16783) | function getTextureEncodingFromMap(map) {
function getEncodingComponents (line 16792) | function getEncodingComponents(encoding) {
function getTexelDecodingFunction (line 16804) | function getTexelDecodingFunction(functionName, encoding) {
function getTexelEncodingFunction (line 16808) | function getTexelEncodingFunction(functionName, encoding) {
function uvAttributes (line 16812) | function uvAttributes(activeMapCoords) {
function getShadowTypeDefines (line 16833) | function getShadowTypeDefines(shadowType) {
function createProgram (line 16841) | function createProgram(gl, defines, props, vertex, fragment) {
function replace (line 16918) | function replace(match, include) {
function filterEmptyLine (line 16927) | function filterEmptyLine(string) {
function replaceLightNums (line 16930) | function replaceLightNums(string, parameters) {
function replaceClippingPlaneNums (line 16933) | function replaceClippingPlaneNums(string, parameters) {
function loopReplacer (line 16937) | function loopReplacer(match, start, end, snippet) {
function unrollLoops (line 16944) | function unrollLoops(string) {
class WebGLQuerySets (line 16949) | class WebGLQuerySets extends PropertyMap {
method constructor (line 16950) | constructor(prefix, gl, capabilities) {
method setQuerySet (line 16979) | setQuerySet(querySet) {
method beginQuery (line 16999) | beginQuery(querySet, index) {
method endQuery (line 17013) | endQuery(querySet) {
method queryCounter (line 17026) | queryCounter(querySet, index) {
method readQuerySetResults (line 17037) | readQuerySetResults(querySet, dstBuffer, firstQuery, queryCount) {
method _getQueryGLByIndex (line 17083) | _getQueryGLByIndex(queriesGL, index) {
class WebGLConstants (line 17095) | class WebGLConstants {
method constructor (line 17096) | constructor(gl, capabilities) {
method getGLType (line 17100) | getGLType(type) {
method getGLFormat (line 17157) | getGLFormat(format) {
method getGLInternalFormat (line 17239) | getGLInternalFormat(internalFormat) {
function createTexture (line 17300) | function createTexture(gl, type, target, count) {
function ColorBuffer (line 17311) | function ColorBuffer(gl) {
function DepthBuffer (line 17348) | function DepthBuffer(gl, state) {
function StencilBuffer (line 17390) | function StencilBuffer(gl, state) {
class WebGLState (line 17480) | class WebGLState {
method constructor (line 17481) | constructor(gl, capabilities) {
method enable (line 17543) | enable(id) {
method disable (line 17549) | disable(id) {
method setBlending (line 17555) | setBlending(blend, blendEquation, blendSrc, blendDst, blendEquationAlp...
method setFlipSided (line 17619) | setFlipSided(flipSided) {
method setCullFace (line 17630) | setCullFace(cullFace) {
method viewport (line 17648) | viewport(viewport) {
method setLineWidth (line 17654) | setLineWidth(width) {
method setPolygonOffset (line 17665) | setPolygonOffset(polygonOffset, factor, units) {
method setProgram (line 17678) | setProgram(program) {
method bindBuffer (line 17684) | bindBuffer(type, buffer) {
method activeTexture (line 17692) | activeTexture(slot) {
method bindTexture (line 17702) | bindTexture(type, texture) {
method reset (line 17721) | reset() {
method setMaterial (line 17777) | setMaterial(material, frontFaceCW) {
class WebGLTextures (line 17806) | class WebGLTextures extends PropertyMap {
method constructor (line 17807) | constructor(prefix, gl, state, capabilities, constants) {
method allocTexUnit (line 17842) | allocTexUnit() {
method resetTextureUnits (line 17849) | resetTextureUnits() {
method setTexture (line 17852) | setTexture(texture, slot) {
method generateMipmaps (line 17919) | generateMipmaps(texture) {
method setTextureExternal (line 17928) | setTextureExternal(texture, webglTexture) {
method _setTextureParameters (line 17941) | _setTextureParameters(texture, textureType, needFallback) {
method _upload2DImage (line 17990) | _upload2DImage(texture, textureProperties, uploadMipmaps, image) {
method _uploadCubeImages (line 18023) | _uploadCubeImages(texture, textureProperties, uploadMipmaps) {
method _upload3DImage (line 18060) | _upload3DImage(texture, textureProperties) {
method _upload2DArrayImage (line 18069) | _upload2DArrayImage(texture, textureProperties) {
function textureNeedsPowerOfTwo (line 18088) | function textureNeedsPowerOfTwo(texture) {
function filterFallback (line 18091) | function filterFallback(filter) {
function _isPowerOfTwo (line 18097) | function _isPowerOfTwo(image) {
function makePowerOf2 (line 18101) | function makePowerOf2(image) {
function getGLInternalFormat (line 18110) | function getGLInternalFormat(gl, capabilities, glFormat, glType) {
function domCheck (line 18148) | function domCheck(image) {
function getByteLength (line 18151) | function getByteLength(width, height, format, type) {
function getTextureTypeByteLength (line 18208) | function getTextureTypeByteLength(type) {
function getTextureTarget (line 18235) | function getTextureTarget(gl, texture) {
class WebGLRenderBuffers (line 18249) | class WebGLRenderBuffers extends PropertyMap {
method constructor (line 18250) | constructor(prefix, gl, capabilities, constants) {
method setRenderBuffer (line 18267) | setRenderBuffer(renderBuffer) {
method setRenderBufferExternal (line 18290) | setRenderBufferExternal(renderBuffer, webglRenderbuffer) {
class WebGLRenderTargets (line 18305) | class WebGLRenderTargets extends PropertyMap {
method constructor (line 18306) | constructor(prefix, gl, state, capabilities, textures, renderBuffers, ...
method _setupRenderTarget (line 18329) | _setupRenderTarget(renderTarget) {
method setRenderTarget (line 18376) | setRenderTarget(renderTarget) {
method blitRenderTarget (line 18415) | blitRenderTarget(read, draw, color = true, depth = true, stencil = tru...
method setFramebufferExternal (line 18452) | setFramebufferExternal(renderTarget, webglFramebuffer) {
function drawBufferSort (line 18486) | function drawBufferSort(a, b) {
class WebGLBuffers (line 18490) | class WebGLBuffers extends PropertyMap {
method constructor (line 18491) | constructor(prefix, gl, capabilities) {
method setBuffer (line 18496) | setBuffer(buffer, bufferType, vertexArrayBindings) {
method removeBuffer (line 18514) | removeBuffer(buffer) {
method setBufferExternal (line 18522) | setBufferExternal(buffer, webglBuffer) {
method _createGLBuffer (line 18537) | _createGLBuffer(bufferProperties, buffer, bufferType) {
method _updateGLBuffer (line 18553) | _updateGLBuffer(glBuffer, buffer, bufferType) {
function getBufferType (line 18572) | function getBufferType(gl, array) {
class WebGLMaterials (line 18596) | class WebGLMaterials extends PropertyMap {
method constructor (line 18597) | constructor(prefix, programs, vertexArrayBindings) {
method setMaterial (line 18618) | setMaterial(material) {
method updateProgram (line 18629) | updateProgram(material, object, lightingState, renderStates, shaderCom...
function findProgram (line 18650) | function findProgram(list, code) {
class WebGLVertexArrayBindings (line 18672) | class WebGLVertexArrayBindings extends PropertyMap {
method constructor (line 18673) | constructor(prefix, gl, capabilities, buffers) {
method setup (line 18684) | setup(object, geometry, program) {
method releaseByGeometry (line 18716) | releaseByGeometry(geometry) {
method releaseByProgram (line 18729) | releaseByProgram(program) {
method reset (line 18740) | reset(force) {
method _createVAO (line 18753) | _createVAO() {
method _bindVAO (line 18761) | _bindVAO(vao) {
method _disposeVAO (line 18771) | _disposeVAO(vao) {
method _setupVertexAttributes (line 18778) | _setupVertexAttributes(program, geometry) {
method _vertexAttribPointer (line 18833) | _vertexAttribPointer(index, size, type, normalized, stride, offset, in...
class WebGLClusteredLighting (line 18843) | class WebGLClusteredLighting {
method constructor (line 18844) | constructor(options) {
method dispose (line 18859) | dispose() {
method setOptions (line 18864) | setOptions(options) {
method update (line 18869) | update(lightingGroup, cameraData, lightsNeedsUpdate = true) {
method _updateCellsTransform (line 18899) | _updateCellsTransform(cameraData) {
class CellsTexture (line 18919) | class CellsTexture extends Texture2D {
method constructor (line 18920) | constructor() {
method initCells (line 18937) | initCells(cellTable, maxLightsPerCell) {
method updateCells (line 18961) | updateCells(cellTable, maxLightsPerCell) {
method resetLightIndices (line 18970) | resetLightIndices() {
method setLightIndex (line 18974) | setLightIndex(cellsRange, index) {
class LightsTexture (line 19003) | class LightsTexture extends Texture2D {
method constructor (line 19004) | constructor() {
method initLights (line 19012) | initLights(maxLights, type) {
method updateLights (line 19024) | updateLights(maxLights, type) {
method setPointLight (line 19031) | setPointLight(index, lightInfo) {
method setSpotLight (line 19062) | setSpotLight(index, lightInfo) {
function getPointLightBoundingSphere (line 19107) | function getPointLightBoundingSphere(light, sphere) {
function getSpotLightBoundingSphere (line 19111) | function getSpotLightBoundingSphere(light, sphere) {
function lightsTextureSize (line 19123) | function lightsTextureSize(maxLights) {
function _isPerspectiveMatrix (line 19126) | function _isPerspectiveMatrix(m) {
function getCellsRange (line 19129) | function getCellsRange(lightSphere, cellsTable, cellsTransform, cellsRan...
class WebGLLights (line 19170) | class WebGLLights extends PropertyMap {
method constructor (line 19171) | constructor(prefix, capabilities, textures) {
method setLightingGroup (line 19187) | setLightingGroup(lightingGroup, passInfo, options, cameraData) {
method uploadUniforms (line 19245) | uploadUniforms(program, lightingGroup, disableShadowSampler) {
class LightingState (line 19332) | class LightingState {
method constructor (line 19333) | constructor() {
method update (line 19338) | update(lightingGroup, clusteredEnabled) {
method compare (line 19361) | compare(factor) {
method copyTo (line 19373) | copyTo(factor) {
method hasLight (line 19381) | hasLight() {
method hasShadow (line 19384) | hasShadow() {
method setProgramProps (line 19387) | setProgramProps(props, receiveShadow) {
function defaultGetGeometry (line 19415) | function defaultGetGeometry(renderable) {
function defaultGetMaterial (line 19418) | function defaultGetMaterial(renderable) {
function defaultIfRender (line 19421) | function defaultIfRender(renderable) {
function getLightingGroup (line 19425) | function getLightingGroup(lighting, material) {
function clientWaitAsync (line 19435) | function clientWaitAsync(gl) {
class WebGLRenderer (line 19461) | class WebGLRenderer extends ThinRenderer {
method constructor (line 19468) | constructor(context) {
method init (line 19499) | init(context, options = {}) {
method beginRender (line 19536) | beginRender(renderTarget) {
method endRender (line 19577) | endRender() {
method renderRenderableItem (line 19599) | renderRenderableItem(renderable, renderStates, options) {
method blitRenderTarget (line 19802) | blitRenderTarget(read, draw, color = true, depth = true, stencil = tru...
method generateMipmaps (line 19805) | generateMipmaps(texture) {
method readTexturePixels (line 19819) | readTexturePixels(texture, x, y, width, height, buffer, zIndex = 0, mi...
method readTexturePixelsSync (line 19851) | readTexturePixelsSync(texture, x, y, width, height, buffer, zIndex = 0...
method resetVertexArrayBindings (line 19869) | resetVertexArrayBindings(force) {
method resetState (line 19872) | resetState() {
method beginOcclusionQuery (line 19875) | beginOcclusionQuery(index) {
method endOcclusionQuery (line 19880) | endOcclusionQuery() {
method readQuerySetResults (line 19885) | async readQuerySetResults(querySet, dstBuffer, firstQuery = 0, queryCo...
method setTextureExternal (line 19894) | setTextureExternal(texture, webglTexture) {
method setRenderBufferExternal (line 19903) | setRenderBufferExternal(renderBuffer, webglRenderbuffer) {
method setBufferExternal (line 19912) | setBufferExternal(buffer, webglBuffer) {
method setFramebufferExternal (line 19921) | setFramebufferExternal(renderTarget, webglFramebuffer) {
method _uploadSkeleton (line 19924) | _uploadSkeleton(uniforms, object, sceneData) {
method _updateMorphtargets (line 19945) | _updateMorphtargets(object, geometry, program) {
method _draw (line 19988) | _draw(geometry, material, group, renderInfo) {
method _bindTextureToDummyFrameBuffer (line 20075) | _bindTextureToDummyFrameBuffer(texture, zIndex, mipLevel) {
class Query (line 20244) | class Query extends EventDispatcher {
method constructor (line 20245) | constructor() {
method dispose (line 20249) | dispose() {
class WebGLQueries (line 20284) | class WebGLQueries extends PropertyMap {
method constructor (line 20285) | constructor(prefix, gl, capabilities) {
method _get (line 20311) | _get(query) {
method begin (line 20322) | begin(query, target) {
method end (line 20334) | end(query) {
method counter (line 20344) | counter(query) {
method isResultAvailable (line 20351) | isResultAvailable(query) {
method isTimerDisjoint (line 20364) | isTimerDisjoint() {
method getResult (line 20367) | getResult(query) {
class RenderTarget2D (line 20446) | class RenderTarget2D extends OffscreenRenderTarget {
method constructor (line 20447) | constructor(width, height) {
class RenderTargetCube (line 20456) | class RenderTargetCube extends OffscreenRenderTarget {
method constructor (line 20457) | constructor(width, height) {
class RenderTarget3D (line 20466) | class RenderTarget3D extends OffscreenRenderTarget {
method constructor (line 20467) | constructor(width, height, depth) {
class RenderTarget2DArray (line 20477) | class RenderTarget2DArray extends OffscreenRenderTarget {
method constructor (line 20478) | constructor(width, height, depth) {
FILE: build/t3d.module.js
class MathUtils (line 9) | class MathUtils {
method generateUUID (line 16) | static generateUUID() {
method lerp (line 37) | static lerp(x, y, t) {
method clamp (line 48) | static clamp(value, min, max) {
method euclideanModulo (line 59) | static euclideanModulo(n, m) {
method mapLinear (line 73) | static mapLinear(x, a1, a2, b1, b2) {
method isPowerOfTwo (line 82) | static isPowerOfTwo(value) {
method nearestPowerOfTwo (line 91) | static nearestPowerOfTwo(value) {
method nextPowerOfTwo (line 100) | static nextPowerOfTwo(value) {
method nextPowerOfTwoSquareSize (line 118) | static nextPowerOfTwoSquareSize(value) {
method denormalize (line 129) | static denormalize(value, array) {
method normalize (line 157) | static normalize(value, array) {
method toHalfFloat (line 183) | static toHalfFloat(val) {
method fromHalfFloat (line 200) | static fromHalfFloat(val) {
function _generateTables (line 217) | function _generateTables() {
class Vector3 (line 317) | class Vector3 {
method constructor (line 325) | constructor(x = 0, y = 0, z = 0) {
method set (line 352) | set(x = 0, y = 0, z = 0) {
method setScalar (line 365) | setScalar(scalar) {
method clone (line 377) | clone() {
method copy (line 386) | copy(v) {
method add (line 399) | add(v) {
method addScalar (line 412) | addScalar(s) {
method addVectors (line 426) | addVectors(a, b) {
method addScaledVector (line 440) | addScaledVector(v, s) {
method sub (line 453) | sub(v) {
method subVectors (line 467) | subVectors(a, b) {
method multiply (line 480) | multiply(v) {
method multiplyScalar (line 493) | multiplyScalar(scalar) {
method applyMatrix3 (line 506) | applyMatrix3(m) {
method applyMatrix4 (line 523) | applyMatrix4(m) {
method applyQuaternion (line 541) | applyQuaternion(q) {
method project (line 567) | project(camera) {
method unproject (line 577) | unproject(camera) {
method transformDirection (line 587) | transformDirection(m) {
method min (line 607) | min(v) {
method max (line 621) | max(v) {
method negate (line 633) | negate() {
method dot (line 646) | dot(v) {
method getLengthSquared (line 656) | getLengthSquared() {
method getLength (line 664) | getLength() {
method normalize (line 674) | normalize(thickness = 1) {
method lerp (line 693) | lerp(v, alpha) {
method lerpVectors (line 710) | lerpVectors(v1, v2, alpha) {
method cross (line 723) | cross(v) {
method crossVectors (line 734) | crossVectors(a, b) {
method reflect (line 750) | reflect(normal) {
method scaleAlong (line 760) | scaleAlong(direction, scale) {
method angleTo (line 770) | angleTo(v) {
method distanceTo (line 787) | distanceTo(v) {
method distanceToSquared (line 798) | distanceToSquared(v) {
method setFromSpherical (line 808) | setFromSpherical(s) {
method setFromMatrixPosition (line 824) | setFromMatrixPosition(m) {
method setFromMatrixScale (line 840) | setFromMatrixScale(m) {
method setFromMatrixColumn (line 853) | setFromMatrixColumn(m, index) {
method equals (line 862) | equals(v) {
method fromArray (line 874) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 898) | toArray(array = [], offset = 0, normalize = false) {
method [Symbol.iterator] (line 914) | * [Symbol.iterator]() {
class Matrix4 (line 935) | class Matrix4 {
method constructor (line 940) | constructor() {
method set (line 974) | set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n...
method identity (line 989) | identity() {
method isIdentity (line 1002) | isIdentity() {
method clone (line 1014) | clone() {
method copy (line 1023) | copy(m) {
method setFromMatrix3 (line 1040) | setFromMatrix3(m) {
method extractBasis (line 1058) | extractBasis(xAxis, yAxis, zAxis) {
method makeBasis (line 1073) | makeBasis(xAxis, yAxis, zAxis) {
method extractRotation (line 1092) | extractRotation(m) {
method makeRotationFromEuler (line 1132) | makeRotationFromEuler(euler) {
method makeRotationFromQuaternion (line 1245) | makeRotationFromQuaternion(q) {
method lookAtRH (line 1256) | lookAtRH(eye, target, up) {
method multiply (line 1297) | multiply(m) {
method premultiply (line 1306) | premultiply(m) {
method multiplyMatrices (line 1317) | multiplyMatrices(a, b) {
method determinant (line 1360) | determinant() {
method transpose (line 1410) | transpose() {
method setPosition (line 1433) | setPosition(x, y, z) {
method invert (line 1455) | invert() {
method getMaxScaleOnAxis (line 1502) | getMaxScaleOnAxis() {
method makeTranslation (line 1519) | makeTranslation(x, y, z) {
method makeRotationAxis (line 1552) | makeRotationAxis(axis, angle) {
method makeScale (line 1576) | makeScale(x, y, z) {
method compose (line 1593) | compose(position, quaternion, scale) {
method decompose (line 1638) | decompose(position, quaternion, scale) {
method equals (line 1688) | equals(matrix) {
method fromArray (line 1705) | fromArray(array, offset = 0) {
method toArray (line 1720) | toArray(array = [], offset = 0) {
method lerpMatrices (line 1753) | lerpMatrices(m1, m2, ratio) {
class Quaternion (line 1789) | class Quaternion {
method constructor (line 1798) | constructor(x = 0, y = 0, z = 0, w = 1) {
method slerpFlat (line 1817) | static slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
method multiplyQuaternionsFlat (line 1908) | static multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1,...
method x (line 1932) | get x() {
method x (line 1936) | set x(value) {
method y (line 1946) | get y() {
method y (line 1950) | set y(value) {
method z (line 1960) | get z() {
method z (line 1964) | set z(value) {
method w (line 1974) | get w() {
method w (line 1978) | set w(value) {
method set (line 1991) | set(x, y, z, w) {
method clone (line 2006) | clone() {
method copy (line 2015) | copy(quaternion) {
method setFromEuler (line 2033) | setFromEuler(euler, update = true) {
method setFromAxisAngle (line 2086) | setFromAxisAngle(axis, angle) {
method setFromRotationMatrix (line 2106) | setFromRotationMatrix(m) {
method setFromUnitVectors (line 2163) | setFromUnitVectors(vFrom, vTo) {
method angleTo (line 2201) | angleTo(q) {
method identity (line 2210) | identity() {
method conjugate (line 2220) | conjugate() {
method dot (line 2235) | dot(v) {
method lengthSq (line 2246) | lengthSq() {
method length (line 2255) | length() {
method normalize (line 2264) | normalize() {
method multiply (line 2291) | multiply(q) {
method premultiply (line 2300) | premultiply(q) {
method multiplyQuaternions (line 2310) | multiplyQuaternions(a, b) {
method lerpQuaternions (line 2333) | lerpQuaternions(q1, q2, ratio) {
method slerp (line 2373) | slerp(qb, t) {
method slerpQuaternions (line 2430) | slerpQuaternions(qa, qb, t) {
method equals (line 2439) | equals(quaternion) {
method fromArray (line 2450) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 2479) | toArray(array = [], offset = 0, normalize = false) {
method toMatrix4 (line 2503) | toMatrix4(target = new Matrix4()) {
method onChange (line 2536) | onChange(callback) {
method onChangeCallback (line 2541) | onChangeCallback() {}
method [Symbol.iterator] (line 2543) | * [Symbol.iterator]() {
class KeyframeInterpolant (line 2565) | class KeyframeInterpolant {
method getValueSize (line 2571) | static getValueSize() {
method interpolate (line 2583) | static interpolate(index0, ratio, duration, outBuffer) {
method copyValue (line 2593) | static copyValue(index, outBuffer) {
class StepInterpolant (line 2611) | class StepInterpolant extends KeyframeInterpolant {
method interpolate (line 2613) | static interpolate(index0, ratio, duration, outBuffer) {
class LinearInterpolant (line 2631) | class LinearInterpolant extends KeyframeInterpolant {
method interpolate (line 2633) | static interpolate(index0, ratio, duration, outBuffer) {
class QuaternionLinearInterpolant (line 2662) | class QuaternionLinearInterpolant extends KeyframeInterpolant {
method interpolate (line 2664) | static interpolate(index0, ratio, duration, outBuffer) {
class CubicSplineInterpolant (line 2679) | class CubicSplineInterpolant extends KeyframeInterpolant {
method getValueSize (line 2681) | static getValueSize() {
method interpolate (line 2685) | static interpolate(index0, ratio, duration, outBuffer) {
method copyValue (line 2717) | static copyValue(index, outBuffer) {
class QuaternionCubicSplineInterpolant (line 2735) | class QuaternionCubicSplineInterpolant extends CubicSplineInterpolant {
method interpolate (line 2737) | static interpolate(index0, ratio, duration, outBuffer) {
class KeyframeTrack (line 2753) | class KeyframeTrack {
method constructor (line 2762) | constructor(target, propertyPath, times, values, interpolant = LinearI...
method setInterpolant (line 2789) | setInterpolant(interpolant) {
method getValue (line 2802) | getValue(t, outBuffer) {
class BooleanKeyframeTrack (line 2831) | class BooleanKeyframeTrack extends KeyframeTrack {
method constructor (line 2840) | constructor(target, propertyPath, times, values, interpolant = StepInt...
class ColorKeyframeTrack (line 2862) | class ColorKeyframeTrack extends KeyframeTrack {
method constructor (line 2871) | constructor(target, propertyPath, times, values, interpolant) {
class NumberKeyframeTrack (line 2888) | class NumberKeyframeTrack extends KeyframeTrack {
method constructor (line 2897) | constructor(target, propertyPath, times, values, interpolant) {
class QuaternionKeyframeTrack (line 2914) | class QuaternionKeyframeTrack extends KeyframeTrack {
method constructor (line 2923) | constructor(target, propertyPath, times, values, interpolant = Quatern...
class StringKeyframeTrack (line 2945) | class StringKeyframeTrack extends KeyframeTrack {
method constructor (line 2954) | constructor(target, propertyPath, times, values, interpolant = StepInt...
class VectorKeyframeTrack (line 2976) | class VectorKeyframeTrack extends KeyframeTrack {
method constructor (line 2985) | constructor(target, propertyPath, times, values, interpolant) {
constant MATERIAL_TYPE (line 3003) | const MATERIAL_TYPE = {
constant BLEND_TYPE (line 3021) | const BLEND_TYPE = {
constant BLEND_EQUATION (line 3035) | const BLEND_EQUATION = {
constant BLEND_FACTOR (line 3049) | const BLEND_FACTOR = {
constant CULL_FACE_TYPE (line 3068) | const CULL_FACE_TYPE = {
constant DRAW_SIDE (line 3080) | const DRAW_SIDE = {
constant SHADING_TYPE (line 3091) | const SHADING_TYPE = {
constant PIXEL_FORMAT (line 3101) | const PIXEL_FORMAT = {
constant PIXEL_TYPE (line 3159) | const PIXEL_TYPE = {
constant TEXTURE_FILTER (line 3180) | const TEXTURE_FILTER = {
constant TEXTURE_WRAP (line 3194) | const TEXTURE_WRAP = {
constant COMPARE_FUNC (line 3205) | const COMPARE_FUNC = {
constant OPERATION (line 3221) | const OPERATION = {
constant SHADOW_TYPE (line 3236) | const SHADOW_TYPE = {
constant TEXEL_ENCODING_TYPE (line 3253) | const TEXEL_ENCODING_TYPE = {
constant ENVMAP_COMBINE_TYPE (line 3264) | const ENVMAP_COMBINE_TYPE = {
constant DRAW_MODE (line 3275) | const DRAW_MODE = {
constant VERTEX_COLOR (line 3290) | const VERTEX_COLOR = {
constant ATTACHMENT (line 3301) | const ATTACHMENT = {
constant BUFFER_USAGE (line 3328) | const BUFFER_USAGE = {
constant QUERYSET_TYPE (line 3345) | const QUERYSET_TYPE = {
class EventDispatcher (line 3353) | class EventDispatcher {
method addEventListener (line 3360) | addEventListener(type, listener) {
method removeEventListener (line 3379) | removeEventListener(type, listener) {
method dispatchEvent (line 3399) | dispatchEvent(event) {
class AnimationAction (line 3428) | class AnimationAction extends EventDispatcher {
method constructor (line 3433) | constructor(clip) {
method update (line 3468) | update(deltaTime) {
class PropertyBindingMixer (line 3493) | class PropertyBindingMixer {
method constructor (line 3501) | constructor(target, propertyPath, typeName, valueSize) {
method parseBinding (line 3551) | parseBinding(target, propertyPath) {
method saveOriginalState (line 3572) | saveOriginalState() {
method restoreOriginalState (line 3603) | restoreOriginalState() {
method accumulate (line 3620) | accumulate(weight) {
method accumulateAdditive (line 3646) | accumulateAdditive(weight) {
method apply (line 3663) | apply() {
function select (line 3703) | function select(buffer, dstOffset, srcOffset, t, stride) {
function slerp (line 3711) | function slerp(buffer, dstOffset, srcOffset, t) {
function slerpAdditive (line 3716) | function slerpAdditive(buffer, dstOffset, srcOffset, t) {
function lerp (line 3723) | function lerp(buffer, dstOffset, srcOffset, t, stride) {
function lerpAdditive (line 3733) | function lerpAdditive(buffer, dstOffset, srcOffset, t, stride) {
function setIdentityNumeric (line 3742) | function setIdentityNumeric(buffer, offset, stride) {
function setIdentityQuaternion (line 3748) | function setIdentityQuaternion(buffer, offset) {
function setIdentityOther (line 3753) | function setIdentityOther(buffer, offset, stride, copyOffset) {
function getArray (line 3760) | function getArray(target, source, stride, count) {
function setArray (line 3766) | function setArray(target, source, stride, count) {
class AnimationMixer (line 3776) | class AnimationMixer {
method constructor (line 3778) | constructor() {
method addAction (line 3787) | addAction(action) {
method removeAction (line 3814) | removeAction(action) {
method hasAction (line 3851) | hasAction(action) {
method getActions (line 3859) | getActions() {
method update (line 3867) | update(deltaTime) {
class KeyframeClip (line 3927) | class KeyframeClip {
method constructor (line 3934) | constructor(name = '', tracks = [], duration = -1) {
method resetDuration (line 3963) | resetDuration() {
class LoadingManager (line 3996) | class LoadingManager {
method constructor (line 4004) | constructor(onLoad, onProgress, onError) {
method itemStart (line 4044) | itemStart(url) {
method itemEnd (line 4061) | itemEnd(url) {
method itemError (line 4082) | itemError(url) {
method resolveURL (line 4094) | resolveURL(url) {
method setURLModifier (line 4129) | setURLModifier(transform) {
class Loader (line 4146) | class Loader {
method constructor (line 4152) | constructor(manager) {
method load (line 4199) | load(url, onLoad, onProgress, onError) {}
method loadAsync (line 4207) | loadAsync(url, onProgress) {
method setCrossOrigin (line 4220) | setCrossOrigin(crossOrigin) {
method setWithCredentials (line 4232) | setWithCredentials(value) {
method setPath (line 4242) | setPath(path) {
method setRequestHeader (line 4253) | setRequestHeader(requestHeader) {
class FileLoader (line 4270) | class FileLoader extends Loader {
method constructor (line 4276) | constructor(manager) {
method load (line 4301) | load(url, onLoad, onProgress, onError) {
method setResponseType (line 4422) | setResponseType(value) {
method setMimeType (line 4432) | setMimeType(value) {
class HttpError (line 4439) | class HttpError extends Error {
method constructor (line 4441) | constructor(message, response) {
class ImageLoader (line 4457) | class ImageLoader extends Loader {
method constructor (line 4463) | constructor(manager) {
method load (line 4478) | load(url, onLoad, onProgress, onError) {
class Vector2 (line 4529) | class Vector2 {
method constructor (line 4535) | constructor(x = 0, y = 0) {
method set (line 4546) | set(x = 0, y = 0) {
method lerpVectors (line 4562) | lerpVectors(v1, v2, ratio) {
method min (line 4571) | min(v) {
method max (line 4583) | max(v) {
method getLength (line 4594) | getLength() {
method getLengthSquared (line 4604) | getLengthSquared() {
method normalize (line 4613) | normalize(thickness = 1) {
method subtract (line 4629) | subtract(a, target = new Vector2()) {
method sub (line 4638) | sub(v) {
method copy (line 4650) | copy(v) {
method addVectors (line 4663) | addVectors(a, b) {
method subVectors (line 4676) | subVectors(a, b) {
method multiplyScalar (line 4688) | multiplyScalar(scalar) {
method distanceToSquared (line 4701) | distanceToSquared(v) {
method distanceTo (line 4713) | distanceTo(v) {
method fromArray (line 4724) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 4745) | toArray(array = [], offset = 0, normalize = false) {
method add (line 4764) | add(v) {
method angle (line 4775) | angle() {
method negate (line 4789) | negate() {
method dot (line 4801) | dot(a) {
method equals (line 4810) | equals(v) {
method clone (line 4818) | clone() {
method [Symbol.iterator] (line 4822) | * [Symbol.iterator]() {
class Box2 (line 4840) | class Box2 {
method constructor (line 4848) | constructor(min, max) {
method set (line 4859) | set(x1, y1, x2, y2) {
method clone (line 4868) | clone() {
method copy (line 4877) | copy(box) {
class Box3 (line 4897) | class Box3 {
method constructor (line 4905) | constructor(min, max) {
method set (line 4915) | set(min, max) {
method setFromPoints (line 4925) | setFromPoints(points) {
method makeEmpty (line 4939) | makeEmpty() {
method expandByPoint (line 4951) | expandByPoint(point) {
method expandByScalar (line 4963) | expandByScalar(scalar) {
method expandByBox3 (line 4975) | expandByBox3(box3) {
method setFromArray (line 4990) | setFromArray(array, gap = 3, offset = 0, denormalize = false) {
method clampPoint (line 5031) | clampPoint(point, target) {
method distanceToPoint (line 5041) | distanceToPoint(point) {
method getBoundingSphere (line 5050) | getBoundingSphere(target) {
method isEmpty (line 5065) | isEmpty() {
method equals (line 5075) | equals(box) {
method getCenter (line 5084) | getCenter(target = new Vector3()) {
method getSize (line 5093) | getSize(target = new Vector3()) {
method getPoints (line 5109) | getPoints(points) {
method union (line 5131) | union(box) {
method applyMatrix4 (line 5142) | applyMatrix4(matrix) {
method containsPoint (line 5166) | containsPoint(point) {
method intersectsTriangle (line 5177) | intersectsTriangle(triangle) {
method clone (line 5226) | clone() {
method copy (line 5235) | copy(box) {
function satForAxes (line 5282) | function satForAxes(axes, v0, v1, v2, extents) {
class Color3 (line 5305) | class Color3 {
method constructor (line 5313) | constructor(r, g, b) {
method setHex (line 5347) | setHex(hex) {
method setRGB (line 5364) | setRGB(r, g, b) {
method setHSL (line 5379) | setHSL(h, s, l) {
method clone (line 5403) | clone() {
method copy (line 5412) | copy(color) {
method convertSRGBToLinear (line 5424) | convertSRGBToLinear() {
method convertLinearToSRGB (line 5435) | convertLinearToSRGB() {
method getHex (line 5446) | getHex() {
method lerp (line 5458) | lerp(color, alpha) {
method lerpColors (line 5471) | lerpColors(color1, color2, alpha) {
method fromArray (line 5485) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 5509) | toArray(array = [], offset = 0, normalize = false) {
method [Symbol.iterator] (line 5525) | * [Symbol.iterator]() {
function hue2rgb (line 5541) | function hue2rgb(p, q, t) {
function SRGBToLinear (line 5550) | function SRGBToLinear(c) {
function LinearToSRGB (line 5554) | function LinearToSRGB(c) {
class Color4 (line 5561) | class Color4 {
method constructor (line 5570) | constructor(r = 0, g = 0, b = 0, a = 1) {
method setRGBA (line 5608) | setRGBA(r, g, b, a) {
method clone (line 5621) | clone() {
method copy (line 5630) | copy(color) {
method fromArray (line 5646) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 5672) | toArray(array = [], offset = 0, normalize = false) {
method [Symbol.iterator] (line 5690) | * [Symbol.iterator]() {
class Euler (line 5712) | class Euler {
method constructor (line 5720) | constructor(x = 0, y = 0, z = 0, order = Euler.DefaultOrder) {
method x (line 5730) | get x() {
method x (line 5737) | set x(value) {
method y (line 5745) | get y() {
method y (line 5752) | set y(value) {
method z (line 5760) | get z() {
method z (line 5767) | set z(value) {
method order (line 5775) | get order() {
method order (line 5782) | set order(value) {
method clone (line 5791) | clone() {
method copy (line 5800) | copy(euler) {
method set (line 5818) | set(x = 0, y = 0, z = 0, order = this._order) {
method setFromRotationMatrix (line 5836) | setFromRotationMatrix(m, order = this._order, update = true) {
method setFromQuaternion (line 5922) | setFromQuaternion(q, order, update) {
method onChange (line 5931) | onChange(callback) {
method onChangeCallback (line 5936) | onChangeCallback() {}
method [Symbol.iterator] (line 5938) | * [Symbol.iterator]() {
class Matrix3 (line 5970) | class Matrix3 {
method constructor (line 5975) | constructor() {
method set (line 5996) | set(n11, n12, n13,
method identity (line 6020) | identity() {
method isIdentity (line 6032) | isIdentity() {
method determinant (line 6043) | determinant() {
method invert (line 6059) | invert() {
method transpose (line 6095) | transpose() {
method equals (line 6111) | equals(matrix) {
method fromArray (line 6128) | fromArray(array, offset = 0) {
method toArray (line 6142) | toArray(array = [], offset = 0) {
method clone (line 6164) | clone() {
method copy (line 6173) | copy(m) {
method multiply (line 6189) | multiply(m) {
method premultiply (line 6198) | premultiply(m) {
method multiplyMatrices (line 6208) | multiplyMatrices(a, b) {
method transform (line 6247) | transform(x, y, scaleX, scaleY, rotation, anchorX, anchorY) {
method setUvTransform (line 6285) | setUvTransform(tx, ty, sx, sy, rotation, cx, cy) {
method setFromMatrix4 (line 6301) | setFromMatrix4(m) {
method extractBasis (line 6318) | extractBasis(xAxis, yAxis, zAxis) {
class Plane (line 6346) | class Plane {
method constructor (line 6353) | constructor(normal = new Vector3(1, 0, 0), constant = 0) {
method intersectPlanes (line 6366) | static intersectPlanes(p1, p2, p3, target) {
method set (line 6389) | set(normal, constant) {
method setComponents (line 6404) | setComponents(x, y, z, w) {
method setFromNormalAndCoplanarPoint (line 6417) | setFromNormalAndCoplanarPoint(normal, point) {
method setFromCoplanarPoints (line 6432) | setFromCoplanarPoints(a, b, c) {
method normalize (line 6443) | normalize() {
method distanceToPoint (line 6458) | distanceToPoint(point) {
method projectPoint (line 6468) | projectPoint(point, target = new Vector3()) {
method mirrorPoint (line 6478) | mirrorPoint(point, target = new Vector3()) {
method coplanarPoint (line 6488) | coplanarPoint(target = new Vector3()) {
method clone (line 6496) | clone() {
method copy (line 6505) | copy(plane) {
method applyMatrix4 (line 6517) | applyMatrix4(matrix, optionalNormalMatrix) {
class Frustum (line 6546) | class Frustum {
method constructor (line 6556) | constructor(p0 = new Plane(), p1 = new Plane(), p2 = new Plane(), p3 =...
method set (line 6570) | set(p0, p1, p2, p3, p4, p5) {
method setFromMatrix (line 6588) | setFromMatrix(m) {
method intersectsSphere (line 6623) | intersectsSphere(sphere) {
method intersectsBox (line 6644) | intersectsBox(box) {
method applyMatrix4 (line 6671) | applyMatrix4(matrix) {
method clone (line 6687) | clone() {
method copy (line 6696) | copy(frustum) {
class Ray (line 6729) | class Ray {
method constructor (line 6736) | constructor(origin = new Vector3(), direction = new Vector3(0, 0, -1)) {
method set (line 6756) | set(origin, direction) {
method copy (line 6767) | copy(ray) {
method at (line 6780) | at(t, target = new Vector3()) {
method recast (line 6789) | recast(t) {
method closestPointToPoint (line 6801) | closestPointToPoint(point, target) {
method distanceToPoint (line 6818) | distanceToPoint(point) {
method distanceSqToPoint (line 6827) | distanceSqToPoint(point) {
method intersectSphere (line 6846) | intersectSphere(sphere, target) {
method intersectsSphere (line 6885) | intersectsSphere(sphere) {
method distanceToPlane (line 6896) | distanceToPlane(plane) {
method intersectPlane (line 6922) | intersectPlane(plane, target) {
method intersectsPlane (line 6937) | intersectsPlane(plane) {
method intersectBox (line 6962) | intersectBox(box, target) {
method intersectsBox (line 7022) | intersectsBox(box) {
method intersectTriangle (line 7036) | intersectTriangle(a, b, c, backfaceCulling, target) {
method applyMatrix4 (line 7100) | applyMatrix4(matrix4) {
method equals (line 7112) | equals(ray) {
method clone (line 7120) | clone() {
class Sphere (line 7141) | class Sphere {
method constructor (line 7147) | constructor(center = new Vector3(), radius = -1) {
method set (line 7158) | set(center, radius) {
method setFromPoints (line 7173) | setFromPoints(points, optionalCenter) {
method setFromArray (line 7201) | setFromArray(array, gap = 3, offset = 0, denormalize = false) {
method applyMatrix4 (line 7221) | applyMatrix4(matrix) {
method getBoundingBox (line 7233) | getBoundingBox(target) {
method isEmpty (line 7251) | isEmpty() {
method makeEmpty (line 7259) | makeEmpty() {
method containsPoint (line 7271) | containsPoint(point) {
method distanceToPoint (line 7281) | distanceToPoint(point) {
method expandByPoint (line 7290) | expandByPoint(point) {
method union (line 7317) | union(sphere) {
method clone (line 7345) | clone() {
method copy (line 7354) | copy(sphere) {
class Spherical (line 7377) | class Spherical {
method constructor (line 7384) | constructor(radius = 1, phi = 0, theta = 0) {
method set (line 7397) | set(radius, phi, theta) {
method copy (line 7410) | copy(other) {
method clone (line 7422) | clone() {
method makeSafe (line 7430) | makeSafe() {
method setFromVector3 (line 7442) | setFromVector3(vec3) {
class SphericalHarmonics3 (line 7471) | class SphericalHarmonics3 {
method constructor (line 7476) | constructor() {
method set (line 7494) | set(coefficients) {
method zero (line 7505) | zero() {
method getAt (line 7518) | getAt(normal, target) {
method getIrradianceAt (line 7550) | getIrradianceAt(normal, target) {
method add (line 7580) | add(sh) {
method addScaledSH (line 7593) | addScaledSH(sh, s) {
method scale (line 7605) | scale(s) {
method lerp (line 7621) | lerp(sh, alpha) {
method equals (line 7633) | equals(sh) {
method copy (line 7647) | copy(sh) {
method clone (line 7655) | clone() {
method fromArray (line 7665) | fromArray(array, offset = 0) {
method toArray (line 7682) | toArray(array = [], offset = 0) {
method getBasisAt (line 7697) | static getBasisAt(normal, shBasis) {
class Triangle (line 7736) | class Triangle {
method constructor (line 7743) | constructor(a = new Vector3(), b = new Vector3(), c = new Vector3()) {
method normal (line 7757) | static normal(a, b, c, optionalTarget) {
method barycoordFromPoint (line 7782) | static barycoordFromPoint(point, a, b, c, target) {
method containsPoint (line 7820) | static containsPoint(point, a, b, c) {
method set (line 7832) | set(a, b, c) {
class Vector4 (line 7853) | class Vector4 {
method constructor (line 7861) | constructor(x = 0, y = 0, z = 0, w = 1) {
method lerpVectors (line 7877) | lerpVectors(v1, v2, ratio) {
method set (line 7889) | set(x = 0, y = 0, z = 0, w = 1) {
method normalize (line 7902) | normalize() {
method multiplyScalar (line 7911) | multiplyScalar(scalar) {
method dot (line 7925) | dot(v) {
method getLengthSquared (line 7935) | getLengthSquared() {
method getLength (line 7943) | getLength() {
method getManhattanLength (line 7951) | getManhattanLength() {
method applyMatrix4 (line 7960) | applyMatrix4(m) {
method setFromMatrixPosition (line 7977) | setFromMatrixPosition(m) {
method equals (line 7993) | equals(v) {
method add (line 8002) | add(v) {
method multiply (line 8016) | multiply(v) {
method subVectors (line 8031) | subVectors(a, b) {
method fromArray (line 8049) | fromArray(array, offset = 0, denormalize = false) {
method toArray (line 8075) | toArray(array = [], offset = 0, normalize = false) {
method round (line 8098) | round() {
method clone (line 8111) | clone() {
method copy (line 8120) | copy(v) {
method [Symbol.iterator] (line 8129) | * [Symbol.iterator]() {
function cloneUniforms (line 8153) | function cloneUniforms(uniforms_src) {
function cloneJson (line 8176) | function cloneJson(obj) {
class Object3D (line 8198) | class Object3D {
method constructor (line 8200) | constructor() {
method onBeforeRender (line 8380) | onBeforeRender() {}
method onAfterRender (line 8385) | onAfterRender() {}
method add (line 8391) | add(object) {
method remove (line 8411) | remove(object) {
method getObjectByName (line 8428) | getObjectByName(name) {
method getObjectByProperty (line 8438) | getObjectByProperty(name, value) {
method updateMatrix (line 8457) | updateMatrix(force) {
method getWorldDirection (line 8489) | getWorldDirection(optionalTarget = new Vector3()) {
method lookAt (line 8499) | lookAt(target, up) {
method raycast (line 8510) | raycast(ray, intersects) {
method traverse (line 8518) | traverse(callback) {
method clone (line 8532) | clone(recursive) {
method copy (line 8542) | copy(source, recursive = true) {
class SceneData (line 8591) | class SceneData {
method constructor (line 8593) | constructor() {
method update (line 8617) | update(scene) {
method setClippingPlanesData (line 8641) | setClippingPlanesData(clippingPlanes, clippingPlanesData) {
class Light (line 8665) | class Light extends Object3D {
method constructor (line 8671) | constructor(color = 0xffffff, intensity = 1) {
method lookAt (line 8703) | lookAt(target, up) {
method copy (line 8713) | copy(source) {
class RectAreaLight (line 8744) | class RectAreaLight extends Light {
method constructor (line 8752) | constructor(color, intensity, width = 10, height = 10) {
method power (line 8776) | get power() {
method power (line 8781) | set power(power) {
method copy (line 8786) | copy(source) {
class LightingGroup (line 8819) | class LightingGroup extends EventDispatcher {
method constructor (line 8821) | constructor() {
method begin (line 8880) | begin() {
method push (line 8885) | push(light, shadow) {
method end (line 8893) | end(sceneData) {
method dispose (line 8901) | dispose() {
method _setupCache (line 8905) | _setupCache(sceneData) {
method _doAddAmbientLight (line 8991) | _doAddAmbientLight(object) {
method _doAddSphericalHarmonicsLight (line 9002) | _doAddSphericalHarmonicsLight(object) {
method _doAddHemisphereLight (line 9014) | _doAddHemisphereLight(object, sceneData) {
method _doAddDirectLight (line 9042) | _doAddDirectLight(object, sceneData) {
method _doAddPointLight (line 9088) | _doAddPointLight(object, sceneData) {
method _doAddSpotLight (line 9139) | _doAddSpotLight(object, sceneData) {
method _doAddRectAreaLight (line 9205) | _doAddRectAreaLight(object, sceneData) {
function getLightCache (line 9267) | function getLightCache(light) {
function getShadowCache (line 9321) | function getShadowCache(light) {
class LightingData (line 9354) | class LightingData {
method constructor (line 9356) | constructor() {
method getGroup (line 9366) | getGroup(id) {
method setMaxGroupCount (line 9370) | setMaxGroupCount(max) {
method begin (line 9388) | begin() {
method collect (line 9399) | collect(light) {
method end (line 9409) | end(sceneData) {
method _distribute (line 9433) | _distribute(light, shadow) {
function shadowCastingLightsFirst (line 9456) | function shadowCastingLightsFirst(lightA, lightB) {
function castShadow (line 9462) | function castShadow(light) {
function _isPerspectiveMatrix$1 (line 9466) | function _isPerspectiveMatrix$1(m) {
class RenderStates (line 9475) | class RenderStates {
method constructor (line 9477) | constructor(sceneData, lightingData) {
method updateCamera (line 9503) | updateCamera(camera) {
class RenderQueueLayer (line 9555) | class RenderQueueLayer {
method constructor (line 9560) | constructor(id) {
method begin (line 9577) | begin() {
method end (line 9584) | end() {
method addRenderable (line 9604) | addRenderable(object, geometry, material, z, group) {
method sort (line 9639) | sort() {
function defaultOpaqueSortCompare (line 9646) | function defaultOpaqueSortCompare(a, b) {
function defaultTransparentSortCompare (line 9656) | function defaultTransparentSortCompare(a, b) {
function quickSort (line 9675) | function quickSort(a, from, to, compareFunc) {
function insertionSort (line 9751) | function insertionSort(a, from, to, compareFunc) {
class RenderQueue (line 9772) | class RenderQueue {
method constructor (line 9774) | constructor() {
method begin (line 9784) | begin() {
method end (line 9792) | end() {
method push (line 9799) | push(object, camera) {
method setLayer (line 9841) | setLayer(id, layer) {
method createLayer (line 9852) | createLayer(id) {
method getLayer (line 9863) | getLayer(id) {
method removeLayer (line 9871) | removeLayer(id) {
function sortLayer (line 9892) | function sortLayer(a, b) {
class RenderCollector (line 9900) | class RenderCollector {
method constructor (line 9907) | constructor() {
method lightingNeedsUpdate (line 9961) | set lightingNeedsUpdate(value) {
method skeletonNeedsUpdate (line 9974) | set skeletonNeedsUpdate(value) {
method getRenderStates (line 9986) | getRenderStates(camera) {
method getRenderQueue (line 10003) | getRenderQueue(camera) {
method traverseAndCollect (line 10019) | traverseAndCollect(scene, camera) {
method _traverseAndCollect (line 10059) | _traverseAndCollect(object, camera, renderQueue) {
class Scene (line 10090) | class Scene extends Object3D {
method constructor (line 10095) | constructor() {
method maxLightingGroups (line 10175) | set maxLightingGroups(value) {
method maxLightingGroups (line 10178) | get maxLightingGroups() {
method getRenderStates (line 10189) | getRenderStates(camera) {
method getRenderQueue (line 10199) | getRenderQueue(camera) {
method updateRenderStates (line 10210) | updateRenderStates(camera, updateScene = true) {
method updateRenderQueue (line 10233) | updateRenderQueue(camera, collectLights = true, updateSkeletons = true) {
class CameraProjection (line 10257) | class CameraProjection {
method constructor (line 10262) | constructor() {
method matrix (line 10271) | get matrix() {
method copy (line 10284) | copy(source) {
method clone (line 10293) | clone() {
method _updateMatrix (line 10301) | _updateMatrix() {
class PerspectiveProjection (line 10313) | class PerspectiveProjection extends CameraProjection {
method constructor (line 10322) | constructor(fov = 50, aspect = 1, near = 0.1, far = 2000) {
method fov (line 10336) | set fov(value) {
method fov (line 10341) | get fov() {
method aspect (line 10350) | set aspect(value) {
method aspect (line 10355) | get aspect() {
method near (line 10364) | set near(value) {
method near (line 10369) | get near() {
method far (line 10378) | set far(value) {
method far (line 10383) | get far() {
method set (line 10395) | set(fov, aspect, near, far) {
method copy (line 10409) | copy(source) {
method _updateMatrix (line 10423) | _updateMatrix() {
class OrthographicProjection (line 10441) | class OrthographicProjection extends CameraProjection {
method constructor (line 10452) | constructor(left = -1, right = 1, top = 1, bottom = -1, near = 0.1, fa...
method left (line 10468) | set left(value) {
method left (line 10473) | get left() {
method right (line 10482) | set right(value) {
method right (line 10487) | get right() {
method top (line 10496) | set top(value) {
method top (line 10501) | get top() {
method bottom (line 10510) | set bottom(value) {
method bottom (line 10515) | get bottom() {
method near (line 10524) | set near(value) {
method near (line 10529) | get near() {
method far (line 10538) | set far(value) {
method far (line 10543) | get far() {
method set (line 10557) | set(left, right, top, bottom, near, far) {
method setSize (line 10574) | setSize(width, height) {
method copy (line 10588) | copy(source) {
method _updateMatrix (line 10604) | _updateMatrix() {
class Camera (line 10622) | class Camera extends Object3D {
method constructor (line 10627) | constructor() {
method lookAt (line 10698) | lookAt(target, up) {
method setOrtho (line 10713) | setOrtho(left, right, bottom, top, near, far) {
method setPerspective (line 10726) | setPerspective(fov, aspect, near, far) {
method setProjectionMatrix (line 10735) | setProjectionMatrix(matrix) {
method getWorldDirection (line 10740) | getWorldDirection(optionalTarget = new Vector3()) {
method updateMatrix (line 10744) | updateMatrix(force) {
method copy (line 10753) | copy(source, recursive) {
class Mesh (line 10808) | class Mesh extends Object3D {
method constructor (line 10814) | constructor(geometry, material) {
method getVertexPosition (line 10844) | getVertexPosition(index, target) {
method raycast (line 10873) | raycast(ray, intersects) {
method copy (line 10981) | copy(source) {
method clone (line 10989) | clone() {
function checkGeometryIntersection (line 11003) | function checkGeometryIntersection(object, material, ray, _ray, uv, a, b...
function uvIntersection (line 11041) | function uvIntersection(point, p1, p2, p3, uv1, uv2, uv3) {
function checkIntersection (line 11053) | function checkIntersection(object, material, ray, localRay, pA, pB, pC, ...
class Attribute (line 11081) | class Attribute {
method constructor (line 11089) | constructor(buffer, size = buffer.stride, offset = 0, normalized = fal...
method copy (line 11130) | copy(source) {
method clone (line 11144) | clone(buffers) {
class Buffer (line 11169) | class Buffer {
method constructor (line 11175) | constructor(array, stride) {
method onUploadCallback (line 11221) | onUploadCallback() {}
method copy (line 11228) | copy(source) {
method clone (line 11240) | clone() {
class Geometry (line 11263) | class Geometry extends EventDispatcher {
method constructor (line 11268) | constructor() {
method addAttribute (line 11353) | addAttribute(name, attribute) {
method getAttribute (line 11362) | getAttribute(name) {
method removeAttribute (line 11370) | removeAttribute(name) {
method setIndex (line 11378) | setIndex(index) {
method addGroup (line 11393) | addGroup(start, count, materialIndex = 0) {
method clearGroups (line 11404) | clearGroups() {
method computeBoundingBox (line 11412) | computeBoundingBox() {
method computeBoundingSphere (line 11440) | computeBoundingSphere() {
method dispose (line 11503) | dispose() {
method copy (line 11512) | copy(source) {
method clone (line 11578) | clone() {
function arrayMax (line 11584) | function arrayMax(array) {
class TransformUV (line 11600) | class TransformUV extends Matrix3 {
method constructor (line 11605) | constructor() {
method update (line 11621) | update() {
method updateMatrix (line 11636) | updateMatrix() {
method copy (line 11650) | copy(source) {
method clone (line 11670) | clone() {
class Material (line 11694) | class Material extends EventDispatcher {
method constructor (line 11696) | constructor() {
method copy (line 12299) | copy(source) {
method clone (line 12389) | clone() {
method dispose (line 12397) | dispose() {
class ShaderMaterial (line 12408) | class ShaderMaterial extends Material {
method constructor (line 12418) | constructor(shader) {
class ShaderPostPass (line 12436) | class ShaderPostPass {
method constructor (line 12446) | constructor(shader) {
method render (line 12484) | render(renderer, renderTarget) {
method dispose (line 12493) | dispose() {
class DepthMaterial (line 12505) | class DepthMaterial extends Material {
method constructor (line 12510) | constructor() {
class DistanceMaterial (line 12529) | class DistanceMaterial extends Material {
method constructor (line 12534) | constructor() {
class ShadowMapPass (line 12545) | class ShadowMapPass {
method constructor (line 12547) | constructor() {
method getGeometry (line 12596) | set getGeometry(func) {
method getGeometry (line 12603) | get getGeometry() {
method ifRender (line 12611) | set ifRender(func) {
method ifRender (line 12618) | get ifRender() {
method render (line 12627) | render(renderer, scene) {
function _getDepthMaterial (line 12700) | function _getDepthMaterial(renderable, light) {
function _getDistanceMaterial (line 12732) | function _getDistanceMaterial(renderable, light) {
class PropertyMap (line 12772) | class PropertyMap {
method constructor (line 12778) | constructor(prefix) {
method get (line 12789) | get(object) {
method delete (line 12804) | delete(object) {
method size (line 12817) | size() {
class RenderInfo (line 12828) | class RenderInfo {
method constructor (line 12830) | constructor() {
class ThinRenderer (line 12901) | class ThinRenderer {
method constructor (line 12903) | constructor() {
method init (line 12978) | init(context, options = {}) {}
method beginRender (line 12984) | beginRender(renderTarget) {
method endRender (line 12991) | endRender() {
method renderRenderableItem (line 13013) | renderRenderableItem(renderable, renderStates, options) {}
method renderRenderableList (line 13021) | renderRenderableList(renderables, renderStates, options = {}) {
method renderScene (line 13036) | renderScene(scene, camera, renderTarget, options = {}) {
method blitRenderTarget (line 13068) | blitRenderTarget(read, draw, color = true, depth = true, stencil = tru...
method generateMipmaps (line 13074) | generateMipmaps(texture) {}
method readTexturePixels (line 13089) | readTexturePixels(texture, x, y, width, height, buffer, zIndex = 0, mi...
method readTexturePixelsSync (line 13104) | readTexturePixelsSync(texture, x, y, width, height, buffer, zIndex = 0...
method resetVertexArrayBindings (line 13110) | resetVertexArrayBindings(force) {}
method resetState (line 13116) | resetState() {}
method beginOcclusionQuery (line 13122) | beginOcclusionQuery(index) {}
method endOcclusionQuery (line 13127) | endOcclusionQuery() {}
method readQuerySetResults (line 13138) | readQuerySetResults(querySet, dstBuffer, firstQuery = 0, queryCount = ...
method increaseId (line 13145) | increaseId() {
class Fog (line 13155) | class Fog {
method constructor (line 13162) | constructor(color = 0x000000, near = 1, far = 1000) {
class FogExp2 (line 13198) | class FogExp2 {
method constructor (line 13204) | constructor(color = 0x000000, density = 0.00025) {
class BoxGeometry (line 13235) | class BoxGeometry extends Geometry {
method constructor (line 13245) | constructor(width = 1, height = 1, depth = 1, widthSegments = 1, heigh...
class CylinderGeometry (line 13389) | class CylinderGeometry extends Geometry {
method constructor (line 13401) | constructor(radiusTop = 1, radiusBottom = 1, height = 1, radialSegment...
class PlaneGeometry (line 13636) | class PlaneGeometry extends Geometry {
method constructor (line 13644) | constructor(width = 1, height = 1, widthSegments = 1, heightSegments =...
class SphereGeometry (line 13723) | class SphereGeometry extends Geometry {
method constructor (line 13734) | constructor(radius = 1, widthSegments = 8, heightSegments = 6, phiStar...
class TorusKnotGeometry (line 13834) | class TorusKnotGeometry extends Geometry {
method constructor (line 13844) | constructor(radius = 1, tube = 0.4, tubularSegments = 64, radialSegmen...
class BasicMaterial (line 13978) | class BasicMaterial extends Material {
method constructor (line 13983) | constructor() {
class LambertMaterial (line 13997) | class LambertMaterial extends Material {
method constructor (line 14002) | constructor() {
class LineMaterial (line 14019) | class LineMaterial extends Material {
method constructor (line 14024) | constructor() {
method copy (line 14045) | copy(source) {
class PBR2Material (line 14062) | class PBR2Material extends Material {
method constructor (line 14067) | constructor() {
method copy (line 14106) | copy(source) {
class PBRMaterial (line 14126) | class PBRMaterial extends Material {
method constructor (line 14131) | constructor() {
method copy (line 14223) | copy(source) {
class PhongMaterial (line 14248) | class PhongMaterial extends Material {
method constructor (line 14253) | constructor() {
method copy (line 14286) | copy(source) {
class PointsMaterial (line 14302) | class PointsMaterial extends Material {
method constructor (line 14307) | constructor() {
method copy (line 14334) | copy(source) {
class RenderTargetBase (line 14352) | class RenderTargetBase extends EventDispatcher {
method constructor (line 14354) | constructor(width, height) {
method resize (line 14435) | resize() {
method dispose (line 14443) | dispose() {
method setClear (line 14454) | setClear(color, depth, stencil) {
method setColorClearValue (line 14469) | setColorClearValue(r, g, b, a) {
method setDepthClearValue (line 14479) | setDepthClearValue(depth) {
method setStencilClearValue (line 14489) | setStencilClearValue(stencil) {
method setOcclusionQuerySet (line 14499) | setOcclusionQuerySet(querySet) {
method setTimestampWrites (line 14511) | setTimestampWrites(querySet, beginIndex = 0, endIndex = 1) {
class RenderBuffer (line 14532) | class RenderBuffer extends EventDispatcher {
method constructor (line 14540) | constructor(width, height, format = PIXEL_FORMAT.RGBA8, multipleSampli...
method resize (line 14584) | resize(width, height) {
method clone (line 14600) | clone() {
method copy (line 14609) | copy(source) {
method dispose (line 14619) | dispose() {
class TextureBase (line 14640) | class TextureBase extends EventDispatcher {
method constructor (line 14642) | constructor() {
method clone (line 14794) | clone() {
method copy (line 14803) | copy(source) {
method dispose (line 14832) | dispose() {
method resizeAsAttachment (line 14846) | resizeAsAttachment(width, height, depth) {}
class Texture2D (line 14862) | class Texture2D extends TextureBase {
method constructor (line 14864) | constructor() {
method copy (line 14880) | copy(source) {
method resizeAsAttachment (line 14891) | resizeAsAttachment(width, height) {
class TextureCube (line 14918) | class TextureCube extends TextureBase {
method constructor (line 14920) | constructor() {
method copy (line 14941) | copy(source) {
method resizeAsAttachment (line 14952) | resizeAsAttachment(width, height) {
class Texture3D (line 14987) | class Texture3D extends TextureBase {
method constructor (line 14989) | constructor() {
method copy (line 15046) | copy(source) {
method resizeAsAttachment (line 15057) | resizeAsAttachment(width, height, depth) {
class Texture2DArray (line 15095) | class Texture2DArray extends TextureBase {
method constructor (line 15097) | constructor() {
method copy (line 15149) | copy(source) {
method resizeAsAttachment (line 15160) | resizeAsAttachment(width, height, depth) {
class OffscreenRenderTarget (line 15198) | class OffscreenRenderTarget extends RenderTargetBase {
method constructor (line 15205) | constructor(width, height) {
method resize (line 15235) | resize(width, height, depth) {
method dispose (line 15264) | dispose(disposeAttachments = true) {
method attach (line 15281) | attach(target, attachment = ATTACHMENT.COLOR_ATTACHMENT0) {
method detach (line 15298) | detach(attachment = ATTACHMENT.COLOR_ATTACHMENT0) {
method getAttachment (line 15308) | getAttachment(attachment = ATTACHMENT.COLOR_ATTACHMENT0) {
method texture (line 15316) | set texture(texture) {
method texture (line 15324) | get texture() {
method activeCubeFace (line 15334) | set activeCubeFace(value) {
method activeCubeFace (line 15338) | get activeCubeFace() {
method create2D (line 15349) | static create2D(width, height) {
method createCube (line 15363) | static createCube(width, height) {
method create3D (line 15378) | static create3D(width, height, depth) {
method create2DArray (line 15394) | static create2DArray(width, height, depth) {
class ScreenRenderTarget (line 15416) | class ScreenRenderTarget extends RenderTargetBase {
method constructor (line 15422) | constructor(view) {
method resize (line 15438) | resize(width, height) {
method dispose (line 15449) | dispose() {
class QuerySet (line 15469) | class QuerySet extends EventDispatcher {
method constructor (line 15476) | constructor(type, count) {
method dispose (line 15519) | dispose() {
class Raycaster (line 15530) | class Raycaster {
method constructor (line 15537) | constructor(origin, direction) {
method set (line 15550) | set(origin, direction) {
method setFromCamera (line 15561) | setFromCamera(coords, camera) {
method intersectObject (line 15584) | intersectObject(object, recursive = false, intersects = []) {
method intersectObjects (line 15602) | intersectObjects(objects, recursive = false, intersects = []) {
function ascSort (line 15614) | function ascSort(a, b) {
function intersect (line 15618) | function intersect(object, raycaster, intersects, recursive) {
class Skeleton (line 15639) | class Skeleton {
method constructor (line 15645) | constructor(bones, boneInverses) {
method pose (line 15678) | pose() {
method clone (line 15703) | clone() {
method updateBones (line 15712) | updateBones(sceneData) {
method generateBoneTexture (line 15731) | generateBoneTexture() {
class AmbientLight (line 15758) | class AmbientLight extends Light {
method constructor (line 15764) | constructor(color, intensity) {
class LightShadow (line 15782) | class LightShadow {
method constructor (line 15784) | constructor() {
method update (line 15869) | update(light, face) {}
method updateMatrix (line 15871) | updateMatrix() {
method copy (line 15887) | copy(source) {
method clone (line 15903) | clone() {
method prepareDepthMap (line 15907) | prepareDepthMap(_enable, _capabilities) {}
class DirectionalLightShadow (line 15915) | class DirectionalLightShadow extends LightShadow {
method constructor (line 15917) | constructor() {
method update (line 15962) | update(light) {
method _updateCamera (line 15970) | _updateCamera(light) {
method copy (line 15981) | copy(source) {
method prepareDepthMap (line 15990) | prepareDepthMap(enable, capabilities) {
class DirectionalLight (line 16020) | class DirectionalLight extends Light {
method constructor (line 16026) | constructor(color, intensity) {
method copy (line 16037) | copy(source) {
class HemisphereLight (line 16060) | class HemisphereLight extends Light {
method constructor (line 16067) | constructor(skyColor, groundColor, intensity) {
method copy (line 16078) | copy(source) {
class PointLightShadow (line 16098) | class PointLightShadow extends LightShadow {
method constructor (line 16100) | constructor() {
method update (line 16124) | update(light, face) {
method _updateCamera (line 16132) | _updateCamera(light, face) {
class PointLight (line 16158) | class PointLight extends Light {
method constructor (line 16166) | constructor(color, intensity, distance, decay) {
method copy (line 16191) | copy(source) {
class SphericalHarmonicsLight (line 16214) | class SphericalHarmonicsLight extends Light {
method constructor (line 16221) | constructor(sh = new SphericalHarmonics3(), intensity = 1) {
method copy (line 16231) | copy(source) {
class SpotLightShadow (line 16253) | class SpotLightShadow extends LightShadow {
method constructor (line 16255) | constructor() {
method update (line 16291) | update(light) {
method _updateCamera (line 16299) | _updateCamera(light) {
method copy (line 16309) | copy(source) {
method prepareDepthMap (line 16317) | prepareDepthMap(enable, capabilities) {
class SpotLight (line 16345) | class SpotLight extends Light {
method constructor (line 16355) | constructor(color, intensity, distance, angle, penumbra, decay) {
method copy (line 16396) | copy(source) {
class Bone (line 16423) | class Bone extends Object3D {
method constructor (line 16425) | constructor() {
class SkinnedMesh (line 16444) | class SkinnedMesh extends Mesh {
method constructor (line 16446) | constructor(geometry, material) {
method bind (line 16483) | bind(skeleton, bindMatrix) {
method updateMatrix (line 16496) | updateMatrix(force) {
method copy (line 16508) | copy(source) {
method getVertexPosition (line 16520) | getVertexPosition(index, target) {
method applyBoneTransform (line 16535) | applyBoneTransform(index, target) {
function getComponent (line 16582) | function getComponent(vec, index) {
class WebGLAttribute (line 16884) | class WebGLAttribute {
method constructor (line 16886) | constructor(gl, program, attributeData) {
function getAttributeCount (line 16909) | function getAttributeCount(gl, type) {
function getAttributeFormat (line 16935) | function getAttributeFormat(gl, type) {
class WebGLCapabilities (line 16957) | class WebGLCapabilities {
method constructor (line 16959) | constructor(gl) {
method getExtension (line 17011) | getExtension(name) {
function getMaxPrecision (line 17036) | function getMaxPrecision(gl, precision) {
class WebGLGeometries (line 17054) | class WebGLGeometries extends PropertyMap {
method constructor (line 17056) | constructor(prefix, gl, buffers, vertexArrayBindings) {
method setGeometry (line 17096) | setGeometry(geometry, passInfo) {
function arraysEqual (line 17210) | function arraysEqual(a, b) {
function copyArray (line 17220) | function copyArray(a, b) {
function allocTexUnits (line 17230) | function allocTexUnits(textures, n) {
function generateSetter (line 17247) | function generateSetter(uniform, pureArray) {
class SingleUniform (line 17564) | class SingleUniform {
method constructor (line 17566) | constructor(gl, id, activeInfo, location) {
class PureArrayUniform (line 17597) | class PureArrayUniform {
method constructor (line 17599) | constructor(gl, id, activeInfo, location) {
class UniformContainer (line 17619) | class UniformContainer {
method constructor (line 17621) | constructor() {
class StructuredUniform (line 17628) | class StructuredUniform extends UniformContainer {
method constructor (line 17630) | constructor(id) {
method set (line 17635) | set(value, textures) {
function addUniform (line 17661) | function addUniform(container, uniformObject) {
function parseUniform (line 17667) | function parseUniform(gl, activeInfo, location, container) {
class WebGLUniforms (line 17705) | class WebGLUniforms extends UniformContainer {
method constructor (line 17707) | constructor(gl, program) {
method set (line 17720) | set(name, value, textures) {
method has (line 17725) | has(name) {
class WebGLProgram (line 17733) | class WebGLProgram {
method constructor (line 17735) | constructor(gl, vshader, fshader) {
function handleSource (line 17863) | function handleSource(string, errorLine) {
function loadShader (line 17878) | function loadShader(gl, type, source) {
function getShaderErrors (line 17885) | function getShaderErrors(gl, shader, type) {
function extractAttributes (line 17905) | function extractAttributes(gl, program) {
class WebGLPrograms (line 17918) | class WebGLPrograms {
method constructor (line 17920) | constructor(gl, state, capabilities) {
method getProgram (line 17928) | getProgram(material, props, programCode, compileOptions) {
method releaseProgram (line 17959) | releaseProgram(program) {
method generateProps (line 17973) | generateProps(material, object, lightingState, renderStates) {
method generateProgramCode (line 18124) | generateProgramCode(props, material) {
function generateDefines (line 18149) | function generateDefines(defines) {
function getUVChannel (line 18163) | function getUVChannel(coord) {
function getTextureEncodingFromMap (line 18171) | function getTextureEncodingFromMap(map) {
function getEncodingComponents (line 18183) | function getEncodingComponents(encoding) {
function getTexelDecodingFunction (line 18196) | function getTexelDecodingFunction(functionName, encoding) {
function getTexelEncodingFunction (line 18201) | function getTexelEncodingFunction(functionName, encoding) {
function uvAttributes (line 18206) | function uvAttributes(activeMapCoords) {
function getShadowTypeDefines (line 18237) | function getShadowTypeDefines(shadowType) {
function createProgram (line 18246) | function createProgram(gl, defines, props, vertex, fragment) {
function replace (line 18486) | function replace(match, include) {
function filterEmptyLine (line 18499) | function filterEmptyLine(string) {
function replaceLightNums (line 18503) | function replaceLightNums(string, parameters) {
function replaceClippingPlaneNums (line 18515) | function replaceClippingPlaneNums(string, parameters) {
function loopReplacer (line 18522) | function loopReplacer(match, start, end, snippet) {
function unrollLoops (line 18534) | function unrollLoops(string) {
class WebGLQuerySets (line 18541) | class WebGLQuerySets extends PropertyMap {
method constructor (line 18543) | constructor(prefix, gl, capabilities) {
method setQuerySet (line 18587) | setQuerySet(querySet) {
method beginQuery (line 18615) | beginQuery(querySet, index) {
method endQuery (line 18635) | endQuery(querySet) {
method queryCounter (line 18652) | queryCounter(querySet, index) {
method readQuerySetResults (line 18668) | readQuerySetResults(querySet, dstBuffer, firstQuery, queryCount) {
method _getQueryGLByIndex (line 18722) | _getQueryGLByIndex(queriesGL, index) {
class WebGLConstants (line 18738) | class WebGLConstants {
method constructor (line 18740) | constructor(gl, capabilities) {
method getGLType (line 18745) | getGLType(type) {
method getGLFormat (line 18811) | getGLFormat(format) {
method getGLInternalFormat (line 18900) | getGLInternalFormat(internalFormat) {
function createTexture (line 18971) | function createTexture(gl, type, target, count) {
function ColorBuffer (line 18986) | function ColorBuffer(gl) {
function DepthBuffer (line 19033) | function DepthBuffer(gl, state) {
function StencilBuffer (line 19086) | function StencilBuffer(gl, state) {
class WebGLState (line 19200) | class WebGLState {
method constructor (line 19202) | constructor(gl, capabilities) {
method enable (line 19280) | enable(id) {
method disable (line 19287) | disable(id) {
method setBlending (line 19294) | setBlending(blend, blendEquation, blendSrc, blendDst, blendEquationAlp...
method setFlipSided (line 19370) | setFlipSided(flipSided) {
method setCullFace (line 19384) | setCullFace(cullFace) {
method viewport (line 19406) | viewport(viewport) {
method setLineWidth (line 19415) | setLineWidth(width) {
method setPolygonOffset (line 19427) | setPolygonOffset(polygonOffset, factor, units) {
method setProgram (line 19444) | setProgram(program) {
method bindBuffer (line 19451) | bindBuffer(type, buffer) {
method activeTexture (line 19462) | activeTexture(slot) {
method bindTexture (line 19475) | bindTexture(type, texture) {
method reset (line 19499) | reset() {
method setMaterial (line 19577) | setMaterial(material, frontFaceCW) {
class WebGLTextures (line 19619) | class WebGLTextures extends PropertyMap {
method constructor (line 19621) | constructor(prefix, gl, state, capabilities, constants) {
method allocTexUnit (line 19668) | allocTexUnit() {
method resetTextureUnits (line 19678) | resetTextureUnits() {
method setTexture (line 19682) | setTexture(texture, slot) {
method generateMipmaps (line 19777) | generateMipmaps(texture) {
method setTextureExternal (line 19789) | setTextureExternal(texture, webglTexture) {
method _setTextureParameters (line 19806) | _setTextureParameters(texture, textureType, needFallback) {
method _upload2DImage (line 19869) | _upload2DImage(texture, textureProperties, uploadMipmaps, image) {
method _uploadCubeImages (line 19905) | _uploadCubeImages(texture, textureProperties, uploadMipmaps) {
method _upload3DImage (line 19945) | _upload3DImage(texture, textureProperties) {
method _upload2DArrayImage (line 19958) | _upload2DArrayImage(texture, textureProperties) {
function textureNeedsPowerOfTwo (line 19985) | function textureNeedsPowerOfTwo(texture) {
function filterFallback (line 19990) | function filterFallback(filter) {
function _isPowerOfTwo (line 19998) | function _isPowerOfTwo(image) {
function makePowerOf2 (line 20003) | function makePowerOf2(image) {
function getGLInternalFormat (line 20017) | function getGLInternalFormat(gl, capabilities, glFormat, glType) {
function domCheck (line 20068) | function domCheck(image) {
function getByteLength (line 20075) | function getByteLength(width, height, format, type) {
function getTextureTypeByteLength (line 20134) | function getTextureTypeByteLength(type) {
function getTextureTarget (line 20162) | function getTextureTarget(gl, texture) {
class WebGLRenderBuffers (line 20176) | class WebGLRenderBuffers extends PropertyMap {
method constructor (line 20178) | constructor(prefix, gl, capabilities, constants) {
method setRenderBuffer (line 20204) | setRenderBuffer(renderBuffer) {
method setRenderBufferExternal (line 20235) | setRenderBufferExternal(renderBuffer, webglRenderbuffer) {
class WebGLRenderTargets (line 20254) | class WebGLRenderTargets extends PropertyMap {
method constructor (line 20256) | constructor(prefix, gl, state, capabilities, textures, renderBuffers, ...
method _setupRenderTarget (line 20289) | _setupRenderTarget(renderTarget) {
method setRenderTarget (line 20348) | setRenderTarget(renderTarget) {
method blitRenderTarget (line 20397) | blitRenderTarget(read, draw, color = true, depth = true, stencil = tru...
method setFramebufferExternal (line 20446) | setFramebufferExternal(renderTarget, webglFramebuffer) {
function drawBufferSort (line 20485) | function drawBufferSort(a, b) {
class WebGLBuffers (line 20489) | class WebGLBuffers extends PropertyMap {
method constructor (line 20491) | constructor(prefix, gl, capabilities) {
method setBuffer (line 20498) | setBuffer(buffer, bufferType, vertexArrayBindings) {
method removeBuffer (line 20520) | removeBuffer(buffer) {
method setBufferExternal (line 20532) | setBufferExternal(buffer, webglBuffer) {
method _createGLBuffer (line 20553) | _createGLBuffer(bufferProperties, buffer, bufferType) {
method _updateGLBuffer (line 20578) | _updateGLBuffer(glBuffer, buffer, bufferType) {
function getBufferType (line 20605) | function getBufferType(gl, array) {
class WebGLMaterials (line 20631) | class WebGLMaterials extends PropertyMap {
method constructor (line 20633) | constructor(prefix, programs, vertexArrayBindings) {
method setMaterial (line 20664) | setMaterial(material) {
method updateProgram (line 20678) | updateProgram(material, object, lightingState, renderStates, shaderCom...
function findProgram (line 20708) | function findProgram(list, code) {
class WebGLVertexArrayBindings (line 20733) | class WebGLVertexArrayBindings extends PropertyMap {
method constructor (line 20735) | constructor(prefix, gl, capabilities, buffers) {
method setup (line 20750) | setup(object, geometry, program) {
method releaseByGeometry (line 20783) | releaseByGeometry(geometry) {
method releaseByProgram (line 20799) | releaseByProgram(program) {
method reset (line 20811) | reset(force) {
method _createVAO (line 20827) | _createVAO() {
method _bindVAO (line 20836) | _bindVAO(vao) {
method _disposeVAO (line 20848) | _disposeVAO(vao) {
method _setupVertexAttributes (line 20856) | _setupVertexAttributes(program, geometry) {
method _vertexAttribPointer (line 20929) | _vertexAttribPointer(index, size, type, normalized, stride, offset, in...
class WebGLClusteredLighting (line 20940) | class WebGLClusteredLighting {
method constructor (line 20942) | constructor(options) {
method dispose (line 20960) | dispose() {
method setOptions (line 20966) | setOptions(options) {
method update (line 20972) | update(lightingGroup, cameraData, lightsNeedsUpdate = true) {
method _updateCellsTransform (line 21014) | _updateCellsTransform(cameraData) {
class CellsTexture (line 21038) | class CellsTexture extends Texture2D {
method constructor (line 21040) | constructor() {
method initCells (line 21062) | initCells(cellTable, maxLightsPerCell) {
method updateCells (line 21090) | updateCells(cellTable, maxLightsPerCell) {
method resetLightIndices (line 21101) | resetLightIndices() {
method setLightIndex (line 21106) | setLightIndex(cellsRange, index) {
class LightsTexture (line 21134) | class LightsTexture extends Texture2D {
method constructor (line 21136) | constructor() {
method initLights (line 21146) | initLights(maxLights, type) {
method updateLights (line 21155) | updateLights(maxLights, type) {
method setPointLight (line 21164) | setPointLight(index, lightInfo) {
method setSpotLight (line 21192) | setSpotLight(index, lightInfo) {
constant LIGHT_STRIDE (line 21228) | const LIGHT_STRIDE = 4;
function getPointLightBoundingSphere (line 21234) | function getPointLightBoundingSphere(light, sphere) {
function getSpotLightBoundingSphere (line 21239) | function getSpotLightBoundingSphere(light, sphere) {
function lightsTextureSize (line 21251) | function lightsTextureSize(maxLights) {
function _isPerspectiveMatrix (line 21255) | function _isPerspectiveMatrix(m) {
function getCellsRange (line 21259) | function getCellsRange(lightSphere, cellsTable, cellsTransform, cellsRan...
class WebGLLights (line 21305) | class WebGLLights extends PropertyMap {
method constructor (line 21307) | constructor(prefix, capabilities, textures) {
method setLightingGroup (line 21331) | setLightingGroup(lightingGroup, passInfo, options, cameraData) {
method uploadUniforms (line 21404) | uploadUniforms(program, lightingGroup, disableShadowSampler) {
class LightingState (line 21514) | class LightingState {
method constructor (line 21516) | constructor() {
method update (line 21523) | update(lightingGroup, clusteredEnabled) {
method compare (line 21552) | compare(factor) {
method copyTo (line 21567) | copyTo(factor) {
method hasLight (line 21576) | hasLight() {
method hasShadow (line 21580) | hasShadow() {
method setProgramProps (line 21584) | setProgramProps(props, receiveShadow) {
function defaultGetGeometry (line 21615) | function defaultGetGeometry(renderable) {
function defaultGetMaterial (line 21619) | function defaultGetMaterial(renderable) {
function defaultIfRender (line 21623) | function defaultIfRender(renderable) {
function getLightingGroup (line 21629) | function getLightingGroup(lighting, material) {
function clientWaitAsync (line 21642) | function clientWaitAsync(gl) {
class WebGLRenderer (line 21675) | class WebGLRenderer extends ThinRenderer {
method constructor (line 21683) | constructor(context) {
method init (line 21719) | init(context, options = {}) {
method beginRender (line 21764) | beginRender(renderTarget) {
method endRender (line 21826) | endRender() {
method renderRenderableItem (line 21853) | renderRenderableItem(renderable, renderStates, options) {
method blitRenderTarget (line 22094) | blitRenderTarget(read, draw, color = true, depth = true, stencil = tru...
method generateMipmaps (line 22098) | generateMipmaps(texture) {
method readTexturePixels (line 22123) | readTexturePixels(texture, x, y, width, height, buffer, zIndex = 0, mi...
method readTexturePixelsSync (line 22164) | readTexturePixelsSync(texture, x, y, width, height, buffer, zIndex = 0...
method resetVertexArrayBindings (line 22188) | resetVertexArrayBindings(force) {
method resetState (line 22192) | resetState() {
method beginOcclusionQuery (line 22196) | beginOcclusionQuery(index) {
method endOcclusionQuery (line 22202) | endOcclusionQuery() {
method readQuerySetResults (line 22208) | async readQuerySetResults(querySet, dstBuffer, firstQuery = 0, queryCo...
method setTextureExternal (line 22217) | setTextureExternal(texture, webglTexture) {
method setRenderBufferExternal (line 22226) | setRenderBufferExternal(renderBuffer, webglRenderbuffer) {
method setBufferExternal (line 22235) | setBufferExternal(buffer, webglBuffer) {
method setFramebufferExternal (line 22244) | setFramebufferExternal(renderTarget, webglFramebuffer) {
method _uploadSkeleton (line 22248) | _uploadSkeleton(uniforms, object, sceneData) {
method _updateMorphtargets (line 22274) | _updateMorphtargets(object, geometry, program) {
method _draw (line 22329) | _draw(geometry, material, group, renderInfo) {
method _bindTextureToDummyFrameBuffer (line 22435) | _bindTextureToDummyFrameBuffer(texture, zIndex, mipLevel) {
constant QUERY_TYPE (line 22609) | const QUERY_TYPE = {
class Query (line 22616) | class Query extends EventDispatcher {
method constructor (line 22618) | constructor() {
method dispose (line 22623) | dispose() {
class WebGLQueries (line 22665) | class WebGLQueries extends PropertyMap {
method constructor (line 22667) | constructor(prefix, gl, capabilities) {
method _get (line 22702) | _get(query) {
method begin (line 22718) | begin(query, target) {
method end (line 22734) | end(query) {
method counter (line 22747) | counter(query) {
method isResultAvailable (line 22758) | isResultAvailable(query) {
method isTimerDisjoint (line 22775) | isTimerDisjoint() {
method getResult (line 22779) | getResult(query) {
class RenderTarget2D (line 22865) | class RenderTarget2D extends OffscreenRenderTarget {
method constructor (line 22867) | constructor(width, height) {
class RenderTargetCube (line 22878) | class RenderTargetCube extends OffscreenRenderTarget {
method constructor (line 22880) | constructor(width, height) {
class RenderTarget3D (line 22891) | class RenderTarget3D extends OffscreenRenderTarget {
method constructor (line 22893) | constructor(width, height, depth) {
class RenderTarget2DArray (line 22905) | class RenderTarget2DArray extends OffscreenRenderTarget {
method constructor (line 22907) | constructor(width, height, depth) {
FILE: examples/jsm/Clock.js
class Clock (line 5) | class Clock {
method constructor (line 7) | constructor(autoStart = true) {
method start (line 17) | start() {
method stop (line 25) | stop() {
method getElapsedTime (line 31) | getElapsedTime() {
method getDelta (line 36) | getDelta() {
function now (line 58) | function now() {
FILE: examples/jsm/DynamicFont.js
class DynamicFont (line 8) | class DynamicFont {
method constructor (line 21) | constructor({
method fontData (line 54) | get fontData() {
method atlasBuffer (line 62) | get atlasBuffer() {
method addChars (line 71) | addChars(chars) {
method dispose (line 91) | dispose() {
method _addChar (line 96) | _addChar(char) {
class CharacterCanvas (line 132) | class CharacterCanvas {
method constructor (line 143) | constructor({
method draw (line 183) | draw(char) {
class FontAtlas (line 231) | class FontAtlas {
method constructor (line 240) | constructor(width, height, charSize, channel = 'R2R') {
method addChar (line 266) | addChar(char, originCharData) {
method removeChar (line 300) | removeChar(char) {
method clear (line 324) | clear() {
method getChar (line 341) | getChar(char) {
method hasChar (line 350) | hasChar(char) {
method buffer (line 359) | get buffer() {
class IndexManager (line 404) | class IndexManager {
method constructor (line 406) | constructor(max) {
method canAllocate (line 411) | canAllocate() {
method allocate (line 415) | allocate() {
method free (line 419) | free(index) {
method reset (line 423) | reset(max) {
FILE: examples/jsm/GBuffer.js
class GBuffer (line 14) | class GBuffer {
method constructor (line 16) | constructor(width, height) {
method resize (line 65) | resize(width, height) {
method update (line 71) | update(renderer, scene, camera) {
method renderDebug (line 201) | renderDebug(renderer, camera, type, renderTarget) {
method getNormalGlossinessTexture (line 221) | getNormalGlossinessTexture() {
method getDepthTexture (line 231) | getDepthTexture() {
method getAlbedoMetalnessTexture (line 244) | getAlbedoMetalnessTexture() {
method getMotionTexture (line 255) | getMotionTexture() {
method dispose (line 259) | dispose() {
function MaterialCache (line 285) | function MaterialCache() {
FILE: examples/jsm/PickBuffer.js
class PickBuffer (line 3) | class PickBuffer {
method constructor (line 5) | constructor(width, height) {
method setMeshPickId (line 24) | setMeshPickId(pickId, mesh) {
method getMeshByPickId (line 29) | getMeshByPickId(pickId) {
method render (line 33) | render(renderer, scene, camera) {
method output (line 51) | output() {
method resize (line 55) | resize(width, height) {
method dispose (line 59) | dispose() {
function createGetMaterialFunction (line 65) | function createGetMaterialFunction(func = defaultMaterialReplaceFunction) {
function defaultMaterialReplaceFunction (line 77) | function defaultMaterialReplaceFunction(renderable) {
FILE: examples/jsm/SHGenerator.js
class SHGenerator (line 13) | class SHGenerator {
method fromCubeTexture (line 15) | static fromCubeTexture(renderer, envMap, out = new SphericalHarmonics3...
method fromColors (line 130) | static fromColors(color1, color2, out = new SphericalHarmonics3()) {
method fromColor (line 144) | static fromColor(color, out = new SphericalHarmonics3()) {
function convertColorToLinear (line 152) | function convertColorToLinear(color, encoding) {
FILE: examples/jsm/SceneUtils.js
class SceneUtils (line 3) | class SceneUtils {
method getRelativeMatrixFromRoot (line 5) | static getRelativeMatrixFromRoot(node, root, target = new Matrix4()) {
method expandBox3ByObject (line 25) | static expandBox3ByObject(object, root, target, precise) {
method setBox3FromObject (line 51) | static setBox3FromObject(object, root, target = new Box3(), precise = ...
method computeMeshAccurateBoundings (line 56) | static computeMeshAccurateBoundings(mesh, target) {
FILE: examples/jsm/SkeletonUtils.js
function parallelTraverse (line 57) | function parallelTraverse(a, b, callback) {
FILE: examples/jsm/SuperSampling.js
class SuperSampling (line 13) | class SuperSampling {
method constructor (line 15) | constructor(width, height, samplingSize = 30) {
method resize (line 49) | resize(width, height) {
method start (line 54) | start() {
method finished (line 58) | finished() {
method frame (line 62) | frame() {
method jitterProjection (line 72) | jitterProjection(camera, width, height) {
method sample (line 93) | sample(renderer, texture, velocityTexture, depthTexture, still) {
method output (line 123) | output() {
function halton (line 132) | function halton(index, base) {
FILE: examples/jsm/VoxMeshBuilder.js
class VOXMeshBuilder (line 23) | class VOXMeshBuilder {
method constructor (line 33) | constructor(voxelData, param) {
method _build (line 56) | _build() {
method _createVoxGeometry (line 90) | _createVoxGeometry(voxel) {
method getTexture (line 175) | getTexture() {
method createMesh (line 182) | createMesh() {
method isOuterVoxel (line 191) | isOuterVoxel(voxel) {
function hash (line 241) | function hash(x, y, z) {
function createHashTable (line 245) | function createHashTable(voxels) {
class VOXFace3 (line 257) | class VOXFace3 {
method constructor (line 259) | constructor(a, b, c, normal = new Vector3(), color = new Color3(), mat...
method copy (line 268) | copy(source) {
method clone (line 280) | clone() {
class VOXGeometry (line 286) | class VOXGeometry {
method constructor (line 288) | constructor() {
method computeFaceNormals (line 294) | computeFaceNormals() {
method merge (line 314) | merge(geometry, matrix, materialIndexOffset) {
method mergeVertices (line 375) | mergeVertices() {
method createGeometry (line 440) | createGeometry() {
FILE: examples/jsm/WaterSimulation.js
class WaterSimulation (line 4) | class WaterSimulation {
method constructor (line 6) | constructor(width = 256, height = 256) {
method _swapRTT (line 27) | _swapRTT() {
method addDrop (line 33) | addDrop(renderer, x, y, radius, strength) {
method updateNormals (line 45) | updateNormals(renderer) {
method stepSimulation (line 54) | stepSimulation(renderer) {
FILE: examples/jsm/WorkerPool.js
class WorkerPool (line 5) | class WorkerPool {
method constructor (line 7) | constructor(pool = 4) {
method _initWorker (line 15) | _initWorker(workerId) {
method _getIdleWorker (line 23) | _getIdleWorker() {
method _onMessage (line 29) | _onMessage(workerId, msg) {
method setWorkerCreator (line 42) | setWorkerCreator(workerCreator) {
method setWorkerLimit (line 46) | setWorkerLimit(pool) {
method postMessage (line 50) | postMessage(msg, transfer) {
method dispose (line 65) | dispose() {
FILE: examples/jsm/animation/CCDIKSolver.js
class CCDIKSolver (line 23) | class CCDIKSolver {
method constructor (line 29) | constructor(bones, iks = []) {
method update (line 42) | update() {
method updateOne (line 57) | updateOne(ik) {
method _valid (line 158) | _valid() {
FILE: examples/jsm/animation/LockedTrack.js
class LockedTrack (line 7) | class LockedTrack {
method constructor (line 13) | constructor(object) {
method update (line 42) | update() {
FILE: examples/jsm/canvas2d/Canvas2D.js
class Canvas2D (line 13) | class Canvas2D extends Mesh {
method constructor (line 15) | constructor(width = 640, height = 800, isScreenCanvas = true, screenMa...
method setSize (line 70) | setSize(width, height) {
method setRenderViewport (line 80) | setRenderViewport(x, y, w, h) {
method setScaleFactor (line 91) | setScaleFactor(value) {
method setScreenMatchMode (line 99) | setScreenMatchMode(mode) {
method _updateCamera (line 107) | _updateCamera() {
method add (line 118) | add(object) {
method remove (line 126) | remove(object) {
method updateSprites (line 133) | updateSprites() {
method updateMatrix (line 253) | updateMatrix(force) {
method cacheSprites (line 272) | cacheSprites(object) {
function constant (line 317) | function constant() {
function shrink (line 336) | function shrink() {
function expand (line 363) | function expand() {
constant SCREEN_MATCH_MODE (line 390) | const SCREEN_MATCH_MODE = {
FILE: examples/jsm/canvas2d/Object2D.js
class Object2D (line 6) | class Object2D {
method constructor (line 8) | constructor() {
method add (line 38) | add(object) {
method remove (line 47) | remove(object) {
method getObjectByName (line 60) | getObjectByName(name) {
method getObjectByProperty (line 70) | getObjectByProperty(name, value) {
method updateMatrix (line 88) | updateMatrix() {
method computeBoundingBox (line 104) | computeBoundingBox() {
FILE: examples/jsm/canvas2d/Sprite2D.js
class Sprite2D (line 3) | class Sprite2D extends Object2D {
method constructor (line 5) | constructor() {
FILE: examples/jsm/controls/FlyControls.js
class FlyControls (line 9) | class FlyControls {
method constructor (line 11) | constructor(object, domElement = document) {
FILE: examples/jsm/controls/FreeControls.js
class FreeControls (line 11) | class FreeControls {
method constructor (line 13) | constructor(object, domElement = document) {
FILE: examples/jsm/controls/OrbitControls.js
class OrbitControls (line 19) | class OrbitControls {
method constructor (line 21) | constructor(object, domElement) {
FILE: examples/jsm/controls/TransformControls.js
class TransformControls (line 10) | class TransformControls extends Object3D {
method constructor (line 12) | constructor(camera, domElement) {
method group (line 57) | get group() {
method mode (line 62) | set mode(value) {
method mode (line 85) | get mode() {
method size (line 89) | set size(value) {
method size (line 93) | get size() {
method translateSnap (line 97) | set translateSnap(value) {
method translateSnap (line 101) | get translateSnap() {
method scaleSnap (line 105) | set scaleSnap(value) {
method scaleSnap (line 109) | get scaleSnap() {
method rotateSnap (line 113) | set rotateSnap(value) {
method rotateSnap (line 117) | get rotateSnap() {
method update (line 121) | update() {
method dispose (line 126) | dispose() {
method _addEventListeners (line 139) | _addEventListeners() {
method _removeEventListeners (line 146) | _removeEventListeners() {
method _onPointDown (line 153) | _onPointDown(e) {
method _onPointMove (line 163) | _onPointMove(e) {
method _onPointUp (line 186) | _onPointUp(e) {
method _setRaycaster (line 199) | _setRaycaster(clientX, clientY) {
method _selectGizmoMesh (line 214) | _selectGizmoMesh(clientX, clientY) {
method _onGizmoHoverEnd (line 237) | _onGizmoHoverEnd() {
method _onGizmoHoverStart (line 244) | _onGizmoHoverStart(currentType, axisName) {
method _triggerGizmoStart (line 251) | _triggerGizmoStart(currentType, axisName) {
method _triggerGizmoEnd (line 257) | _triggerGizmoEnd() {
class BaseControl (line 319) | class BaseControl extends Object3D {
method constructor (line 321) | constructor(name, camera, group) {
method onHoverStart (line 340) | onHoverStart(axisName) {}
method onHoverEnd (line 342) | onHoverEnd() {}
method onMoveStart (line 344) | onMoveStart(ray, axisName) {
method onMove (line 357) | onMove(ray) {}
method onMoveEnd (line 359) | onMoveEnd() {
method update (line 363) | update(isModify) {}
class TranslateControl (line 367) | class TranslateControl extends BaseControl {
method constructor (line 369) | constructor(camera, group) {
method _createAxis (line 388) | _createAxis() {
method onHoverStart (line 465) | onHoverStart(axisName) {
method onHoverEnd (line 471) | onHoverEnd() {
method onMoveStart (line 477) | onMoveStart(ray, axisName) {
method onMove (line 496) | onMove(ray) {
method onMoveEnd (line 529) | onMoveEnd() {
method _getHitPlane (line 545) | _getHitPlane() {
method _calRayIntersection (line 568) | _calRayIntersection(ray, out) {
method update (line 575) | update() {
method _resizeControl (line 580) | _resizeControl() {
method _adaptPlanes (line 604) | _adaptPlanes() {
method _applySnap (line 625) | _applySnap(target) {
class ScaleControl (line 661) | class ScaleControl extends BaseControl {
method constructor (line 663) | constructor(camera, group) {
method _createAxis (line 680) | _createAxis() {
method onHoverStart (line 716) | onHoverStart(axisName) {
method onHoverEnd (line 722) | onHoverEnd() {
method onMoveStart (line 728) | onMoveStart(ray, axisName) {
method onMove (line 752) | onMove(ray) {
method onMoveEnd (line 782) | onMoveEnd() {
method update (line 794) | update(isModify) {
method _getHitPlane (line 798) | _getHitPlane() {
method _calRayIntersection (line 808) | _calRayIntersection(ray, out) {
method _resizeControl (line 814) | _resizeControl(isModify) {
method _applySnap (line 852) | _applySnap(target) {
class RotateControl (line 882) | class RotateControl extends BaseControl {
method constructor (line 884) | constructor(camera, group) {
method _createAxis (line 913) | _createAxis() {
method onHoverStart (line 960) | onHoverStart(axisName) {
method onHoverEnd (line 966) | onHoverEnd() {
method onMoveStart (line 972) | onMoveStart(ray, axisName) {
method onMove (line 1008) | onMove(ray) {
method onMoveEnd (line 1060) | onMoveEnd() {
method _calRayIntersection (line 1082) | _calRayIntersection(ray, out) {
method _getFinalRad (line 1100) | _getFinalRad(rotateAxis, radius) {
method _getSnapRad (line 1121) | _getSnapRad(euler, rad, isY = false) {
method update (line 1146) | update() {
method _updateAxisTransform (line 1151) | _updateAxisTransform() {
method _resizeControl (line 1183) | _resizeControl() {
method _applySnap (line 1205) | _applySnap(target) {
class GizmoMesh (line 1237) | class GizmoMesh extends Mesh {
method constructor (line 1239) | constructor(type, name, color, position, rotation, size, arc, tube) {
method highlight (line 1300) | highlight() {
method unhighlight (line 1307) | unhighlight() {
method yellow (line 1312) | yellow() {
class GizmoMaterial (line 1320) | class GizmoMaterial extends BasicMaterial {
method constructor (line 1322) | constructor() {
class RotateTorusGeometry (line 1339) | class RotateTorusGeometry extends Geometry {
method constructor (line 1341) | constructor(radius = 1, arc = Math.PI, tube = 0.02) {
method updateTorus (line 1359) | updateTorus(radius = 1, arc = Math.PI) {
class RotateHelperGeometry (line 1377) | class RotateHelperGeometry extends Geometry {
method constructor (line 1379) | constructor() {
method updateCircle (line 1393) | updateCircle(startPoint, normal, thetaLength) {
method _generateData (line 1406) | _generateData(startPoint, normal, thetaLength, center, segmentFactor) {
class LineHelperGeometry (line 1432) | class LineHelperGeometry extends Geometry {
method constructor (line 1434) | constructor(startPoint, endPoint) {
method updateLine (line 1445) | updateLine(startPoint, endPoint) {
FILE: examples/jsm/controls/ViewControls.js
class ViewControls (line 3) | class ViewControls {
method constructor (line 5) | constructor(camera, options) {
method dispose (line 90) | dispose() {
method update (line 97) | update(delta) {
method _drawPoint (line 173) | _drawPoint(point, axisPoint) {
method _drawLine (line 186) | _drawLine(point, axisPoint) {
method _raycast (line 199) | _raycast(event) {
method _prepareAnimationData (line 215) | _prepareAnimationData(axisIndex) {
function depthSort (line 265) | function depthSort(a, b) {
function rotateTowards (line 271) | function rotateTowards(q, step, target) {
function angleTo (line 279) | function angleTo(q1, q2) {
FILE: examples/jsm/exporters/DRACOExporter.js
class DRACOExporter (line 13) | class DRACOExporter {
method parse (line 15) | parse(geometry, options = {}) {
constant ENCODER_METHOD (line 154) | const ENCODER_METHOD = {
constant ATTRIBUTE_NAME_TO_GLTF (line 159) | const ATTRIBUTE_NAME_TO_GLTF = {
FILE: examples/jsm/exporters/GLTFExporter.js
class GLTFExporter (line 17) | class GLTFExporter {
method constructor (line 19) | constructor() {
method register (line 29) | register(extension) {
method unregister (line 36) | unregister(extension) {
method setDRACOExporter (line 44) | setDRACOExporter(dracoExporter) {
method getDRACOExporter (line 49) | getDRACOExporter() {
method parse (line 60) | parse(input, onDone, onError, options) {
method parseAsync (line 73) | parseAsync(input, options) {
constant GLTF_FORMAT (line 85) | const GLTF_FORMAT = {
constant GLTF_CONSTANTS (line 91) | const GLTF_CONSTANTS = {
constant DRAW_MODE_TO_GLTF (line 115) | const DRAW_MODE_TO_GLTF = {
constant ATTRIBUTE_NAME_TO_GLTF (line 125) | const ATTRIBUTE_NAME_TO_GLTF = {
constant INTERPOLANT_TO_GLTF (line 142) | const INTERPOLANT_TO_GLTF = new WeakMap([
constant KHR_MESH_QUANTIZATION (line 152) | const KHR_MESH_QUANTIZATION = 'KHR_mesh_quantization';
constant PATH_PROPERTIES (line 185) | const PATH_PROPERTIES = {
constant T3D_TO_GLTF (line 192) | const T3D_TO_GLTF = {};
constant GLB_HEADER_BYTES (line 208) | const GLB_HEADER_BYTES = 12;
constant GLB_HEADER_MAGIC (line 209) | const GLB_HEADER_MAGIC = 0x46546C67;
constant GLB_VERSION (line 210) | const GLB_VERSION = 2;
constant GLB_CHUNK_PREFIX_BYTES (line 212) | const GLB_CHUNK_PREFIX_BYTES = 8;
constant GLB_CHUNK_TYPE_JSON (line 213) | const GLB_CHUNK_TYPE_JSON = 0x4E4F534A;
constant GLB_CHUNK_TYPE_BIN (line 214) | const GLB_CHUNK_TYPE_BIN = 0x004E4942;
function createAttributesKey (line 220) | function createAttributesKey(attributes) {
function decompose (line 232) | function decompose(matrix3) {
function equalArray (line 253) | function equalArray(array1, array2) {
function stringToArrayBuffer (line 264) | function stringToArrayBuffer(text) {
function isIdentityMatrix (line 273) | function isIdentityMatrix(matrix) {
function getMinMax (line 284) | function getMinMax(attribute, start, count) {
function getPaddedBufferSize (line 308) | function getPaddedBufferSize(bufferSize) {
function getPaddedArrayBuffer (line 318) | function getPaddedArrayBuffer(arrayBuffer, paddingByte = 0) {
function getCanvas (line 337) | function getCanvas() {
function getToBlobPromise (line 345) | function getToBlobPromise(canvas, mimeType) {
class GLTFWriter (line 369) | class GLTFWriter {
method constructor (line 371) | constructor() {
method setPlugins (line 414) | setPlugins(plugins) {
method setDRACOExporter (line 418) | setDRACOExporter(dracoExporter) {
method writeAsync (line 428) | async writeAsync(input, onDone, options) {
method processInputAsync (line 564) | async processInputAsync(input) {
method processSceneAsync (line 612) | async processSceneAsync(root) {
method processNodeAsync (line 648) | async processNodeAsync(object) {
method processMeshAsync (line 720) | async processMeshAsync(mesh) {
method processAccessor (line 907) | processAccessor(attribute, geometry, start, count, skipBufferView = fa...
method processBufferView (line 984) | processBufferView(attribute, componentType, start, count, target) {
method processDracoBufferView (line 1069) | processDracoBufferView(geometry) {
method processBuffer (line 1101) | processBuffer(buffer) {
method processMaterialAsync (line 1118) | async processMaterialAsync(material) {
method processTextureAsync (line 1238) | async processTextureAsync(map) {
method processImage (line 1276) | processImage(image, format, flipY, mimeType = 'image/png') {
method processSampler (line 1377) | processSampler(map) {
method processBufferViewImage (line 1397) | processBufferViewImage(blob) {
method processSkin (line 1425) | processSkin(object) {
method processAnimation (line 1470) | processAnimation(clip) {
method applyTextureTransform (line 1523) | applyTextureTransform(mapDef, matrix) {
method buildMetalRoughTextureAsync (line 1551) | async buildMetalRoughTextureAsync(metalnessMap, roughnessMap) {
method serializeUserData (line 1627) | serializeUserData(object, objectDef) {
method getUID (line 1655) | getUID(attribute) {
method getUniqueFileName (line 1669) | getUniqueFileName(originalName, ext) {
method setImageUri (line 1687) | setImageUri(imageDef, dataURL) {
method detectMeshQuantization (line 1713) | detectMeshQuantization(attributeName, attribute) {
method _invokeAllAsync (line 1745) | async _invokeAllAsync(func) {
class GLTFLightExtension (line 1758) | class GLTFLightExtension {
method constructor (line 1760) | constructor(writer) {
method writeNode (line 1765) | writeNode(light, nodeDef) {
class GLTFMaterialsUnlitExtension (line 1826) | class GLTFMaterialsUnlitExtension {
method constructor (line 1828) | constructor(writer) {
method writeMaterialAsync (line 1833) | async writeMaterialAsync(material, materialDef) {
class GLTFMeshGpuInstancingExtension (line 1856) | class GLTFMeshGpuInstancingExtension {
method constructor (line 1858) | constructor(writer) {
method writeNode (line 1863) | writeNode(object, nodeDef) {
FILE: examples/jsm/geometries/BitmapTextGeometry.js
class BitmapTextGeometry (line 7) | class BitmapTextGeometry extends Geometry {
method constructor (line 24) | constructor(options) {
method layout (line 40) | get layout() {
method visibleGlyphs (line 44) | get visibleGlyphs() {
method update (line 48) | update(options) {
method _validateOptions (line 115) | _validateOptions(options) {
function generateAttributes (line 130) | function generateAttributes(glyphs, texWidth, texHeight, flipY, fontSize) {
constant X_HEIGHTS (line 225) | const X_HEIGHTS = ['x', 'e', 'a', 'o', 'n', 's', 'r', 'c', 'u', 'm', 'v'...
constant M_WIDTHS (line 226) | const M_WIDTHS = ['m', 'w'];
constant CAP_HEIGHTS (line 227) | const CAP_HEIGHTS = ['H', 'I', 'N', 'E', 'F', 'K', 'L', 'T', 'U', 'V', '...
constant TAB_ID (line 229) | const TAB_ID = '\t'.charCodeAt(0);
constant SPACE_ID (line 230) | const SPACE_ID = ' '.charCodeAt(0);
constant ALIGN_LEFT (line 231) | const ALIGN_LEFT = 0;
constant ALIGN_CENTER (line 232) | const ALIGN_CENTER = 1;
constant ALIGN_RIGHT (line 233) | const ALIGN_RIGHT = 2;
class TextLayout (line 235) | class TextLayout {
method constructor (line 237) | constructor(options = {}) {
method width (line 243) | get width() {
method height (line 247) | get height() {
method descender (line 251) | get descender() {
method ascender (line 255) | get ascender() {
method xHeight (line 259) | get xHeight() {
method baseline (line 263) | get baseline() {
method capHeight (line 267) | get capHeight() {
method lineHeight (line 271) | get lineHeight() {
method linesTotal (line 275) | get linesTotal() {
method lettersTotal (line 279) | get lettersTotal() {
method wordsTotal (line 283) | get wordsTotal() {
method update (line 287) | update(options) {
method getGlyph (line 416) | getGlyph(font, id) {
method computeMetrics (line 430) | computeMetrics(text, start, end, width) {
method _setupSpaceGlyphs (line 483) | _setupSpaceGlyphs(font) {
function getGlyphById (line 514) | function getGlyphById(font, id) {
function getXHeight (line 527) | function getXHeight(font) {
function getMGlyph (line 536) | function getMGlyph(font) {
function getCapHeight (line 545) | function getCapHeight(font) {
function getKerning (line 554) | function getKerning(font, left, right) {
function getAlignType (line 565) | function getAlignType(align) {
function findChar (line 570) | function findChar(array, value, start) {
function number (line 580) | function number(num, def) {
function wordwrap (line 596) | function wordwrap(text, opt = {}) {
function idxOf (line 616) | function idxOf(text, chr, start, end) {
function isWhitespace (line 624) | function isWhitespace(chr) {
function pre (line 628) | function pre(measure, text, start, end, width) {
function greedy (line 648) | function greedy(measure, text, start, end, width, mode) {
function monospace (line 719) | function monospace(text, start, end, width) {
FILE: examples/jsm/geometries/CapsuleGeometry.js
class CapsuleGeometry (line 6) | class CapsuleGeometry extends Geometry {
method constructor (line 16) | constructor(radius = 1, height = 1, capSegments = 4, radialSegments = ...
FILE: examples/jsm/geometries/CircleGeometry.js
class CircleGeometry (line 3) | class CircleGeometry extends Geometry {
method constructor (line 5) | constructor(radius = 1, segments = 32, thetaStart = 0, thetaLength = M...
FILE: examples/jsm/geometries/GeometryUtils.js
class GeometryUtils (line 10) | class GeometryUtils {
method computeNormals (line 15) | static computeNormals(geometry) {
method normalizeNormals (line 91) | static normalizeNormals(geometry) {
method computeTangents (line 104) | static computeTangents(geometry) {
method mergeGeometries (line 252) | static mergeGeometries(geometries, useGroups = false) {
method mergeAttributes (line 386) | static mergeAttributes(attributes) {
method applyMatrix4 (line 438) | static applyMatrix4(geometry, matrix, updateBoundings) {
method getWireframeAttribute (line 496) | static getWireframeAttribute(geometry) {
FILE: examples/jsm/geometries/builders/Earcut.js
function linkedList (line 48) | function linkedList(data, start, end, dim, clockwise) {
function filterPoints (line 66) | function filterPoints(start, end) {
function earcutLinked (line 89) | function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
function isEar (line 142) | function isEar(ear) {
function isEarHashed (line 161) | function isEarHashed(ear, minX, minY, invSize) {
function cureLocalIntersections (line 214) | function cureLocalIntersections(start, triangles, dim) {
function splitEarcut (line 239) | function splitEarcut(start, triangles, dim, minX, minY, invSize) {
function eliminateHoles (line 267) | function eliminateHoles(data, holeIndices, outerNode, dim) {
function compareX (line 290) | function compareX(a, b) {
function eliminateHole (line 295) | function eliminateHole(hole, outerNode) {
function findHoleBridge (line 307) | function findHoleBridge(hole, outerNode) {
function sectorContainsSector (line 365) | function sectorContainsSector(m, p) {
function indexCurve (line 370) | function indexCurve(start, minX, minY, invSize) {
function sortLinked (line 387) | function sortLinked(list) {
function zOrder (line 438) | function zOrder(x, y, minX, minY, invSize) {
function getLeftmost (line 457) | function getLeftmost(start) {
function pointInTriangle (line 469) | function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
function isValidDiagonal (line 476) | function isValidDiagonal(a, b) {
function area (line 484) | function area(p, q, r) {
function equals (line 489) | function equals(p1, p2) {
function intersects (line 494) | function intersects(p1, q1, p2, q2) {
function onSegment (line 511) | function onSegment(p, q, r) {
function sign (line 515) | function sign(num) {
function intersectsPolygon (line 520) | function intersectsPolygon(a, b) {
function locallyInside (line 532) | function locallyInside(a, b) {
function middleInside (line 539) | function middleInside(a, b) {
function splitPolygon (line 555) | function splitPolygon(a, b) {
function insertNode (line 577) | function insertNode(i, x, y, last) {
function removeNode (line 593) | function removeNode(p) {
function Node (line 601) | function Node(i, x, y) {
function signedArea (line 624) | function signedArea(data, start, end, dim) {
FILE: examples/jsm/geometries/builders/EdgesBuilder.js
function dot (line 123) | function dot(v1, v2) {
function computeFaceNormal (line 127) | function computeFaceNormal(face, buffer) {
constant DEG2RAD (line 163) | const DEG2RAD = Math.PI / 180;
FILE: examples/jsm/geometries/builders/ExtrudeShapeBuilder.js
function getLength (line 168) | function getLength(x0, y0, x1, y1) {
function setPositionByPathFrames (line 178) | function setPositionByPathFrames(frames, index, x, y, positions) {
FILE: examples/jsm/geometries/builders/Font.js
class Font (line 7) | class Font {
method constructor (line 9) | constructor(data) {
method generateShapes (line 13) | generateShapes(text, size = 100) {
function createPaths (line 25) | function createPaths(text, size, data) {
function createPath (line 51) | function createPath(char, scale, offsetX, offsetY, data) {
function getShapes (line 140) | function getShapes(curvePaths, shapes = []) {
function vectorsToArray (line 206) | function vectorsToArray(vectors) {
function isClockWise (line 214) | function isClockWise(contour) {
FILE: examples/jsm/geometries/builders/GeometryBuilderUtils.js
function area (line 48) | function area(contour) {
function isClockWise (line 59) | function isClockWise(contour) {
function removeDupEndPts (line 63) | function removeDupEndPts(contour) {
function isArrayEquals (line 71) | function isArrayEquals(a1, a2) {
function addContour (line 85) | function addContour(vertices, contour) {
FILE: examples/jsm/geometries/builders/PolyhedronBuilder.js
class PolyhedronBuilder (line 3) | class PolyhedronBuilder {
method getGeometryData (line 5) | static getGeometryData(vertices, indices, radius = 1, detail = 0) {
method getTetrahedronGeometryData (line 220) | static getTetrahedronGeometryData(radius = 1, detail = 0) {
method getOctahedronGeometryData (line 232) | static getOctahedronGeometryData(radius = 1, detail = 0) {
method getIcosahedronGeometryData (line 247) | static getIcosahedronGeometryData(radius = 1, detail = 0) {
method getDodecahedronGeometryData (line 266) | static getDodecahedronGeometryData(radius = 1, detail = 0) {
FILE: examples/jsm/impostor/OctahedralImpostor.js
class OctahedralImpostor (line 9) | class OctahedralImpostor extends Mesh {
method constructor (line 11) | constructor() {
class OctahedralImpostorMaterial (line 18) | class OctahedralImpostorMaterial extends PBRMaterial {
method constructor (line 20) | constructor(sourceMaterial) {
class OctahedralImpostorDepthMaterial (line 325) | class OctahedralImpostorDepthMaterial extends DepthMaterial {
method constructor (line 327) | constructor(sourceMaterial) {
FILE: examples/jsm/impostor/OctahedralTextureGenerator.js
class OctahedralTextureGenerator (line 19) | class OctahedralTextureGenerator {
method constructor (line 28) | constructor(atlasSize = 2048, countPerSide = 16, cameraFactor = 1, use...
method render (line 52) | render(renderer, source) {
method _renderView (line 102) | _renderView(col, row, sphere, renderer, renderOption) {
function hemiOctaGridToDir (line 131) | function hemiOctaGridToDir(grid, target = new Vector3()) {
function octaGridToDir (line 138) | function octaGridToDir(grid, target = new Vector3()) {
class OctahedralBakeMaterial (line 151) | class OctahedralBakeMaterial extends PBRMaterial {
method constructor (line 153) | constructor(sourceMaterial) {
FILE: examples/jsm/lights/LightShadowAdapter.js
class LightShadowAdapter (line 9) | class LightShadowAdapter {
method constructor (line 15) | constructor(light) {
method update (line 71) | update() {
method _setUpdateType (line 91) | _setUpdateType() {
method _setShadowBoxRotation (line 122) | _setShadowBoxRotation() {
method _setShadowBoxByBoxCamera (line 141) | _setShadowBoxByBoxCamera() {
method _setShadowBoxByBox (line 210) | _setShadowBoxByBox() {
method _setShadowBoxByCamera (line 223) | _setShadowBoxByCamera() {
method _updateLight (line 242) | _updateLight() {
constant EPSILON (line 295) | const EPSILON = 1e-5;
constant UNIT_BOX3 (line 296) | const UNIT_BOX3 = new Box3(new Vector3(-0.5, -0.5, -0.5), new Vector3(0....
constant SHADOW_UPDATE_TYPE (line 298) | const SHADOW_UPDATE_TYPE = {
function isPerspectiveMatrix (line 305) | function isPerspectiveMatrix(m) {
function extractCameraNearFar (line 311) | function extractCameraNearFar(camera) {
class LightDirection (line 327) | class LightDirection extends Vector3 {
method setFromSphericalAngles (line 329) | setFromSphericalAngles(phi, theta) {
function getClipedViewVertices (line 359) | function getClipedViewVertices(camera, clipNear, clipFar, points) {
class Polygons (line 395) | class Polygons {
method constructor (line 397) | constructor(pool) {
method clear (line 404) | clear() {
method setFromBoxPoints (line 408) | setFromBoxPoints(points) {
method clipByPlane (line 419) | clipByPlane(plane) {
constant COPLANAR (line 430) | const COPLANAR = 0;
constant FRONT (line 431) | const FRONT = 1;
constant BACK (line 432) | const BACK = 2;
constant SPANNING (line 433) | const SPANNING = 3;
function splitPolygon (line 437) | function splitPolygon(plane, polygon, outPolygons, pool) {
class PolygonPool (line 494) | class PolygonPool {
method constructor (line 496) | constructor() {
method allocate (line 501) | allocate() {
method deallocate (line 514) | deallocate() {
method reset (line 518) | reset() {
class Polygon (line 524) | class Polygon {
method constructor (line 526) | constructor() {
method begin (line 532) | begin() {
method pushVertex (line 537) | pushVertex(vector3) {
method end (line 551) | end() {
FILE: examples/jsm/lights/RectAreaLightLTC.js
class RectAreaLightLTC (line 25) | class RectAreaLightLTC {
method getLTC1 (line 27) | static getLTC1() {
method getLTC2 (line 36) | static getLTC2() {
method _createTexture (line 45) | static _createTexture(data) {
FILE: examples/jsm/loaders/AssimpJsonLoader.js
class AssimpJsonLoader (line 32) | class AssimpJsonLoader {
method constructor (line 34) | constructor() {
method load (line 39) | load(url, onLoad, onProgress, onError) {
method parse (line 49) | parse(json) {
method parseNodeTree (line 75) | parseNodeTree(node) {
method parseList (line 92) | parseList(json, handler) {
method parseSkeleton (line 100) | parseSkeleton(meshName, bonesInfo, nodeTree, boneMap) {
method cloneNodeToBones (line 159) | cloneNodeToBones(node, boneMap) {
method parseAnimations (line 180) | parseAnimations(json, boneMap) {
method parseObject (line 250) | parseObject(json, node, meshes, materials, skeletons) {
method parseMaterial (line 281) | parseMaterial(json) {
method parseMesh (line 353) | parseMesh(json) {
method extractUrlBase (line 510) | extractUrlBase(url) {
FILE: examples/jsm/loaders/DDSLoader.js
class DDSLoader (line 10) | class DDSLoader extends Loader {
method load (line 12) | load(url, onLoad, onProgress, onError) {
method parse (line 23) | parse(buffer, loadMipmaps) {
class DDSTextureLoader (line 242) | class DDSTextureLoader extends DDSLoader {
method load (line 244) | load(url, onLoad, onProgress, onError) {
FILE: examples/jsm/loaders/DRACOLoader.js
class DRACOLoader (line 14) | class DRACOLoader extends Loader {
method constructor (line 16) | constructor(manager) {
method setDecoderPath (line 43) | setDecoderPath(path) {
method setDecoderConfig (line 48) | setDecoderConfig(config) {
method setWorkerLimit (line 53) | setWorkerLimit(workerLimit) {
method load (line 58) | load(url, onLoad, onProgress, onError) {
method parse (line 70) | parse(buffer, onLoad, onError) {
method decodeDracoFile (line 74) | decodeDracoFile(buffer, callback, attributeIDs, attributeTypes, vertex...
method decodeGeometry (line 85) | decodeGeometry(buffer, taskConfig) {
method _createGeometry (line 130) | _createGeometry(geometryData) {
method _loadLibrary (line 154) | _loadLibrary(url, responseType) {
method preload (line 165) | preload() {
method _initDecoder (line 170) | _initDecoder() {
method _getWorker (line 204) | _getWorker(taskID, taskCost) {
method _releaseTask (line 242) | _releaseTask(worker, taskID) {
method debug (line 248) | debug() {
method dispose (line 252) | dispose() {
function assignVertexColorSpace (line 287) | function assignVertexColorSpace(attribute, inputColorSpace) {
function DRACOWorker (line 308) | function DRACOWorker() {
FILE: examples/jsm/loaders/EXRLoader.js
class EXRLoader (line 87) | class EXRLoader extends Loader {
method constructor (line 89) | constructor(manager) {
method setfflate (line 95) | static setfflate(fflate) {
method load (line 99) | load(url, onLoad, onProgress, onError) {
method parse (line 110) | parse(buffer) {
class EXRTexture2DLoader (line 1859) | class EXRTexture2DLoader extends EXRLoader {
method load (line 1861) | load(url, onLoad, onProgress, onError) {
FILE: examples/jsm/loaders/EnvLoader.js
class EnvLoader (line 5) | class EnvLoader extends Loader {
method constructor (line 7) | constructor(manager) {
method load (line 28) | load(url, onLoad, onProgress, onError) {
method parse (line 43) | parse(buffer) {
class EnvTextureCubeLoader (line 82) | class EnvTextureCubeLoader extends EnvLoader {
method constructor (line 84) | constructor(manager) {
method setRenderer (line 91) | setRenderer(renderer) {
method load (line 96) | load(url, onLoad, onProgress, onError) {
FILE: examples/jsm/loaders/ImageBitmapLoader.js
class ImageBitmapLoader (line 3) | class ImageBitmapLoader extends Loader {
method constructor (line 5) | constructor(manager) {
method setOptions (line 19) | setOptions(options) {
method load (line 24) | load(url, onLoad, _onProgress, onError) {
FILE: examples/jsm/loaders/KTX2Loader.js
class KTX2Loader (line 21) | class KTX2Loader extends Loader {
method constructor (line 23) | constructor(manager) {
method setKTXParser (line 35) | static setKTXParser(ktxParser) {
method setZSTDDecoder (line 42) | static setZSTDDecoder(zstdDecoder) {
method setTranscoderPath (line 47) | setTranscoderPath(path) {
method setWorkerLimit (line 52) | setWorkerLimit(num) {
method detectSupport (line 57) | detectSupport(renderer) {
method init (line 73) | init() {
method load (line 131) | load(url, onLoad, onProgress, onError) {
method _createTextureData (line 160) | async _createTextureData(buffer, config = {}) {
method dispose (line 211) | dispose() {
function init (line 310) | function init(wasmBinary) {
function transcode (line 323) | function transcode(buffer) {
function getTranscoderFormat (line 525) | function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
function isPowerOfTwo (line 555) | function isPowerOfTwo(value) {
function concat (line 561) | function concat(arrays) {
constant UNCOMPRESSED_FORMATS (line 587) | const UNCOMPRESSED_FORMATS = new Set([PIXEL_FORMAT.RGBA, PIXEL_FORMAT.RG...
constant FORMAT_MAP (line 589) | let FORMAT_MAP = {};
function setFORMAT_MAP (line 590) | function setFORMAT_MAP() {
constant TYPE_MAP (line 613) | let TYPE_MAP = {};
function setTYPE_MAP (line 614) | function setTYPE_MAP() {
function createTextureData (line 634) | async function createTextureData(container) {
function parseTextureEncoding (line 715) | function parseTextureEncoding(container) {
class KTX2TextureLoader (line 733) | class KTX2TextureLoader extends KTX2Loader {
method constructor (line 735) | constructor(manager) {
method load (line 739) | load(url, onLoad, onProgress, onError) {
FILE: examples/jsm/loaders/PVRLoader.js
class PVRLoader (line 10) | class PVRLoader extends Loader {
method load (line 12) | load(url, onLoad, onProgress, onError) {
method parse (line 23) | parse(buffer, loadMipmaps) {
function _parseV3 (line 44) | function _parseV3(pvrDatas) {
function _parseV2 (line 89) | function _parseV2(pvrDatas) {
function _extract (line 140) | function _extract(pvrDatas) {
class PVRTextureLoader (line 210) | class PVRTextureLoader extends PVRLoader {
method load (line 212) | load(url, onLoad, onProgress, onError) {
FILE: examples/jsm/loaders/RGBELoader.js
class RGBELoader (line 3) | class RGBELoader extends Loader {
method constructor (line 5) | constructor(manager) {
method load (line 11) | load(url, onLoad, onProgress, onError) {
method parse (line 24) | parse(buffer) {
constant RGBE_VALID_PROGRAMTYPE (line 84) | const
constant RGBE_VALID_FORMAT (line 84) | const
constant RGBE_VALID_DIMENSIONS (line 84) | const
constant NEWLINE (line 84) | const
class RGBETexture2DLoader (line 336) | class RGBETexture2DLoader extends RGBELoader {
method load (line 338) | load(url, onLoad, onProgress, onError) {
class RGBETextureCubeLoader (line 368) | class RGBETextureCubeLoader extends RGBELoader {
method load (line 370) | load(urls, onLoad, _onProgress, onError) {
FILE: examples/jsm/loaders/TGALoader.js
class TGALoader (line 3) | class TGALoader extends Loader {
method load (line 5) | load(url, onLoad, onProgress, onError) {
method parse (line 16) | parse(buffer) {
class TGATexture2DLoader (line 402) | class TGATexture2DLoader extends TGALoader {
method load (line 404) | load(url, onLoad, onProgress, onError) {
class TGATextureCubeLoader (line 426) | class TGATextureCubeLoader extends TGALoader {
method load (line 428) | load(urls, onLoad, _onProgress, onError) {
FILE: examples/jsm/loaders/Texture2DLoader.js
class Texture2DLoader (line 3) | class Texture2DLoader extends Loader {
method constructor (line 5) | constructor(manager) {
method load (line 9) | load(url, onLoad, onProgress, onError) {
FILE: examples/jsm/loaders/TextureCubeLoader.js
class TextureCubeLoader (line 3) | class TextureCubeLoader extends Loader {
method constructor (line 5) | constructor(manager) {
method load (line 9) | load(urls, onLoad, _onProgress, onError) {
FILE: examples/jsm/loaders/glTF/Constants.js
constant ATTRIBUTES (line 6) | const ATTRIBUTES = {
constant ALPHA_MODES (line 30) | const ALPHA_MODES = {
constant ACCESSOR_TYPE_SIZES (line 36) | const ACCESSOR_TYPE_SIZES = {
constant ACCESSOR_COMPONENT_TYPES (line 46) | const ACCESSOR_COMPONENT_TYPES = {
constant WEBGL_FILTERS (line 55) | const WEBGL_FILTERS = {
constant WEBGL_WRAPPINGS (line 64) | const WEBGL_WRAPPINGS = {
constant WEBGL_DRAW_MODES (line 70) | const WEBGL_DRAW_MODES = {
FILE: examples/jsm/loaders/glTF/GLTFLoader.js
class GLTFLoader (line 62) | class GLTFLoader {
method constructor (line 64) | constructor(manager = DefaultLoadingManager, parsers = DefaultParsePip...
method load (line 105) | load(url, options = {}) {
method _parse (line 136) | _parse(context) {
method setDRACOLoader (line 155) | setDRACOLoader(dracoLoader) {
method getDRACOLoader (line 160) | getDRACOLoader() {
method setMeshoptDecoder (line 164) | setMeshoptDecoder(meshoptDecoder) {
method getMeshoptDecoder (line 168) | getMeshoptDecoder() {
method setKTX2Loader (line 172) | setKTX2Loader(ktx2Loader) {
method getKTX2Loader (line 176) | getKTX2Loader() {
method loadFile (line 180) | loadFile(url, type = 'json') {
method loadImage (line 189) | loadImage(url) {
method insertParser (line 196) | insertParser(parser, index) {
method replaceParser (line 200) | replaceParser(parser, index) {
FILE: examples/jsm/loaders/glTF/GLTFResource.js
class GLTFResource (line 3) | class GLTFResource {
method constructor (line 5) | constructor() {
FILE: examples/jsm/loaders/glTF/GLTFUtils.js
class GLTFUtils (line 5) | class GLTFUtils {
method constructor (line 7) | constructor() {}
method extractUrlBase (line 9) | static extractUrlBase(url) {
method resolveURL (line 16) | static resolveURL(url, path) {
method decodeText (line 33) | static decodeText(array) {
method parseGLB (line 57) | static parseGLB(glb) {
method getNormalizedComponentScale (line 112) | static getNormalizedComponentScale(constructor) {
method normalizeSkinWeights (line 126) | static normalizeSkinWeights(skinWeight) {
FILE: examples/jsm/loaders/glTF/extensions/EXT_mesh_gpu_instancing.js
class EXT_mesh_gpu_instancing (line 9) | class EXT_mesh_gpu_instancing {
method getInstancedMesh (line 11) | static getInstancedMesh(context, gltfNode) {
function setInstancedAttributes (line 67) | function setInstancedAttributes(geometry, instancingDef, accessors) {
FILE: examples/jsm/loaders/glTF/extensions/EXT_meshopt_compression.js
class EXT_meshopt_compression (line 6) | class EXT_meshopt_compression {
method loadBufferView (line 8) | static loadBufferView(extensionDef, buffers, meshoptDecoder) {
FILE: examples/jsm/loaders/glTF/extensions/KHR_animation_pointer.js
class KHR_animation_pointer (line 3) | class KHR_animation_pointer {
method getTrackInfos (line 5) | static getTrackInfos(context, extensionDef, input, output, interpolati...
FILE: examples/jsm/loaders/glTF/extensions/KHR_draco_mesh_compression.js
class KHR_draco_mesh_compression (line 7) | class KHR_draco_mesh_compression {
method getGeometry (line 9) | static getGeometry(params, bufferViews, attributes, accessors, dracoLo...
FILE: examples/jsm/loaders/glTF/extensions/KHR_lights_punctual.js
class KHR_lights_punctual (line 7) | class KHR_lights_punctual {
method getLight (line 9) | static getLight(params) {
FILE: examples/jsm/loaders/glTF/extensions/KHR_materials_clearcoat.js
class KHR_materials_clearcoat (line 6) | class KHR_materials_clearcoat {
method getMaterial (line 8) | static getMaterial() {
method parseParams (line 12) | static parseParams(material, extension, textures) {
FILE: examples/jsm/loaders/glTF/extensions/KHR_materials_dispersion.js
class KHR_materials_dispersion (line 7) | class KHR_materials_dispersion {
method getMaterial (line 9) | static getMaterial() {
method parseParams (line 13) | static parseParams(material, extension) {
FILE: examples/jsm/loaders/glTF/extensions/KHR_materials_ior.js
class KHR_materials_ior (line 7) | class KHR_materials_ior {
method getMaterial (line 9) | static getMaterial() {
method parseParams (line 13) | static parseParams(material, extension) {
FILE: examples/jsm/loaders/glTF/extensions/KHR_materials_pbrSpecularGlossiness.js
class KHR_materials_pbrSpecularGlossiness (line 7) | class KHR_materials_pbrSpecularGlossiness {
method getMaterial (line 9) | static getMaterial() {
method parseParams (line 13) | static parseParams(material, params, textures, transformExt) {
FILE: examples/jsm/loaders/glTF/extensions/KHR_materials_transmission.js
class KHR_materials_transmission (line 8) | class KHR_materials_transmission {
method getMaterial (line 10) | static getMaterial() {
method parseParams (line 14) | static parseParams(material, extension, textures) {
FILE: examples/jsm/loaders/glTF/extensions/KHR_materials_unlit.js
class KHR_materials_unlit (line 7) | class KHR_materials_unlit {
method getMaterial (line 9) | static getMaterial() {
FILE: examples/jsm/loaders/glTF/extensions/KHR_materials_volume.js
class KHR_materials_volume (line 7) | class KHR_materials_volume {
method parseParams (line 9) | static parseParams(material, extension, textures) {
FILE: examples/jsm/loaders/glTF/extensions/KHR_texture_basisu.js
class KHR_texture_basisu (line 6) | class KHR_texture_basisu {
method loadTextureData (line 8) | static loadTextureData(url, ktx2Loader) {
FILE: examples/jsm/loaders/glTF/extensions/KHR_texture_transform.js
class KHR_texture_transform (line 5) | class KHR_texture_transform {
method handleMaterialMap (line 7) | static handleMaterialMap(material, mapType, textureDef) {
FILE: examples/jsm/loaders/glTF/parsers/AccessorParser.js
class AccessorParser (line 4) | class AccessorParser {
method parse (line 6) | static parse(context) {
FILE: examples/jsm/loaders/glTF/parsers/AnimationParser.js
class AnimationParser (line 14) | class AnimationParser {
method parse (line 16) | static parse(context, loader) {
function getInterpolant (line 119) | function getInterpolant(type, quaternion) {
FILE: examples/jsm/loaders/glTF/parsers/BufferParser.js
class BufferParser (line 3) | class BufferParser {
method parse (line 5) | static parse(context, loader) {
FILE: examples/jsm/loaders/glTF/parsers/BufferViewParser.js
class BufferViewParser (line 1) | class BufferViewParser {
method parse (line 3) | static parse(context, loader) {
FILE: examples/jsm/loaders/glTF/parsers/ImageParser.js
class ImageParser (line 3) | class ImageParser {
method parse (line 5) | static parse(context, loader) {
function detectSupport (line 64) | function detectSupport(mimeType) {
function loadImage (line 81) | function loadImage(param) {
FILE: examples/jsm/loaders/glTF/parsers/IndexParser.js
class IndexParser (line 3) | class IndexParser {
method parse (line 5) | static parse(context, loader) {
FILE: examples/jsm/loaders/glTF/parsers/MaterialParser.js
class MaterialParser (line 8) | class MaterialParser {
method parse (line 10) | static parse(context, loader) {
FILE: examples/jsm/loaders/glTF/parsers/NodeParser.js
class NodeParser (line 4) | class NodeParser {
method parse (line 6) | static parse(context, loader) {
function createCamera (line 83) | function createCamera(cameraDef) {
function createMesh (line 100) | function createMesh(context, gltfNode) {
FILE: examples/jsm/loaders/glTF/parsers/PrimitiveParser.js
class PrimitiveParser (line 5) | class PrimitiveParser {
method parse (line 7) | static parse(context, loader) {
function parseGeometryFromGLTFPrimitive (line 78) | function parseGeometryFromGLTFPrimitive(geometry, gltfPrimitive, gltf, a...
function assignFinalMaterial (line 166) | function assignFinalMaterial(primitive, materialCache) {
function createGeometryKey (line 259) | function createGeometryKey(primitive) {
function createAttributesKey (line 280) | function createAttributesKey(attributes) {
FILE: examples/jsm/loaders/glTF/parsers/ReferenceParser.js
class ReferenceParser (line 4) | class ReferenceParser {
method parse (line 6) | static parse(context, loader) {
FILE: examples/jsm/loaders/glTF/parsers/SceneParser.js
class SceneParser (line 3) | class SceneParser {
method parse (line 5) | static parse(context) {
function buildNodeHierachy (line 27) | function buildNodeHierachy(nodeId, parentNode, gltfNodes, nodes) {
FILE: examples/jsm/loaders/glTF/parsers/SkinParser.js
class SkinParser (line 3) | class SkinParser {
method parse (line 5) | static parse(context) {
FILE: examples/jsm/loaders/glTF/parsers/TextureParser.js
class TextureParser (line 8) | class TextureParser {
method parse (line 10) | static parse(context) {
function parseSampler (line 82) | function parseSampler(texture, sampler = {}) {
function getImageURIMimeType (line 93) | function getImageURIMimeType(uri) {
FILE: examples/jsm/loaders/glTF/parsers/Validator.js
class Validator (line 1) | class Validator {
method parse (line 3) | static parse(context) {
FILE: examples/jsm/materials/AlphaHashedPBRMaterial.js
class AlphaHashedPBRMaterial (line 3) | class AlphaHashedPBRMaterial extends PBRMaterial {
method constructor (line 5) | constructor(sourceMaterial) {
FILE: examples/jsm/materials/AttenuationMaterial.js
class AttenuationPBRMaterial (line 36) | class AttenuationPBRMaterial extends PBRMaterial {
method constructor (line 38) | constructor(sourceMaterial) {
FILE: examples/jsm/materials/BatchedMaterial.js
class BatchedPBRMaterial (line 117) | class BatchedPBRMaterial extends PBRMaterial {
method constructor (line 119) | constructor(sourceMaterial) {
FILE: examples/jsm/materials/BitmapTextMaterial.js
class BitmapTextMaterial (line 3) | class BitmapTextMaterial extends ShaderMaterial {
method constructor (line 5) | constructor() {
FILE: examples/jsm/materials/InstancedMaterial.js
class InstancedPBRMaterial (line 52) | class InstancedPBRMaterial extends PBRMaterial {
method constructor (line 54) | constructor(sourceMaterial) {
class InstancedBasicMaterial (line 93) | class InstancedBasicMaterial extends BasicMaterial {
method constructor (line 95) | constructor(sourceMaterial) {
class InstancedDepthMaterial (line 134) | class InstancedDepthMaterial extends DepthMaterial {
method constructor (line 136) | constructor(sourceMaterial) {
FILE: examples/jsm/materials/PlanarReflectionMaterial.js
class PlanarReflectionMaterial (line 3) | class PlanarReflectionMaterial extends PBRMaterial {
method constructor (line 5) | constructor(sourceMaterial) {
FILE: examples/jsm/materials/TransmissionPBRMaterial.js
class TransmissionPBRMaterial (line 3) | class TransmissionPBRMaterial extends PBRMaterial {
method constructor (line 5) | constructor(sourceMaterial) {
FILE: examples/jsm/math/ColorGradient.js
class ColorGradient (line 3) | class ColorGradient {
method constructor (line 5) | constructor() {
method addColorStop (line 10) | addColorStop(position, color) {
method removeColorStop (line 16) | removeColorStop(position) {
method clear (line 27) | clear() {
method getColor (line 32) | getColor(position, target = new Color3()) {
method getUint8Array (line 59) | getUint8Array(steps, target = new Uint8Array(steps * 4)) {
method _sort (line 106) | _sort() {
FILE: examples/jsm/math/DistanceTransform.js
class DistanceTransform (line 6) | class DistanceTransform {
method constructor (line 13) | constructor(maxPixelCount = 64 * 64, maxGridSize = 64) {
method transform (line 38) | transform(imageData, options = {}) {
constant INF (line 97) | const INF = 1e20;
function edt (line 100) | function edt(data, x0, y0, width, height, gridSize, f, v, z) {
function edt1d (line 106) | function edt1d(grid, offset, stride, length, f, v, z) {
FILE: examples/jsm/math/OBB.js
class OBB (line 11) | class OBB {
method constructor (line 19) | constructor(center = new Vector3(), halfSize = new Vector3(), rotation...
method set (line 32) | set(center, halfSize, rotation) {
method copy (line 45) | copy(obb) {
method clone (line 57) | clone() {
method getSize (line 66) | getSize(result) {
method isEmpty (line 74) | isEmpty() {
method makeEmpty (line 82) | makeEmpty() {
method clampPoint (line 97) | clampPoint(point, result) {
method containsPoint (line 126) | containsPoint(point) {
method intersectsBox3 (line 142) | intersectsBox3(box3) {
method intersectsSphere (line 151) | intersectsSphere(sphere) {
method intersectsOBB (line 166) | intersectsOBB(obb, epsilon = Number.EPSILON) {
method intersectsPlane (line 293) | intersectsPlane(plane) {
method intersectRay (line 318) | intersectRay(ray, result) {
method intersectsRay (line 344) | intersectsRay(ray) {
method fromBox3 (line 353) | fromBox3(box3) {
method equals (line 367) | equals(obb) {
method applyMatrix4 (line 378) | applyMatrix4(matrix) {
method setFromCenterAndAxes (line 426) | setFromCenterAndAxes(center, axisX, axisY, axisZ) {
method toBoundingBoxAndTransform (line 472) | toBoundingBoxAndTransform(box3, matrix) {
method getPoints (line 487) | getPoints(points) {
method getPlanes (line 504) | getPlanes(planes) {
method
Copy disabled (too large)
Download .json
Condensed preview — 864 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (13,046K chars).
[
{
"path": ".editorconfig",
"chars": 203,
"preview": "# http://editorconfig.org\n\nroot = true\n\n[*]\nend_of_line = lf\ninsert_final_newline = false\n\n[*.{js,ts,html}]\ncharset = ut"
},
{
"path": ".gitattributes",
"chars": 84,
"preview": "# Set the default behavior, in case people don't have core.autocrlf set.\n* text=auto"
},
{
"path": ".github/contributing.md",
"chars": 3843,
"preview": "# t3d.js Contributing Guide\n\n## Issue Reporting Guidelines\n\nWelcome to use [Github](https://github.com/uinosoft/t3d.js/i"
},
{
"path": ".github/workflows/deploy-to-pages.yml",
"chars": 1050,
"preview": "name: Deploy examples and docs to Pages\n\non:\n push:\n branches: ['dev']\n paths-ignore:\n - 'build/**'\n\n workf"
},
{
"path": ".gitignore",
"chars": 209,
"preview": ".DS_Store\n*.swp\n\n# Editor directories and files\n.vscode/*\n!.vscode/extensions.json\n.idea\n.project\n*.suo\n*.ntvs*\n*.njspro"
},
{
"path": ".vscode/extensions.json",
"chars": 60,
"preview": "{\n \"recommendations\": [\n \"dbaeumer.vscode-eslint\"\n ]\n}\n"
},
{
"path": "LICENSE",
"chars": 1498,
"preview": "BSD 3-Clause License\n\nCopyright (c) 2021-present, uino\n\nRedistribution and use in source and binary forms, with or witho"
},
{
"path": "README.md",
"chars": 5410,
"preview": "# ThingJS 3D Engine\n\n[![NPM Package][npm]][npm-url]\n![npm-size][npm-size-url]\n[![Issues][issues-badge]][issues-badge-url"
},
{
"path": "build/t3d.js",
"chars": 728807,
"preview": "/**\n * @license\n * Copyright 2021-present uino\n * SPDX-License-Identifier: BSD-3-Clause\n */\n(function (global, factory) "
},
{
"path": "build/t3d.module.js",
"chars": 713038,
"preview": "/**\n * @license\n * Copyright 2021-present uino\n * SPDX-License-Identifier: BSD-3-Clause\n */\n/**\n * An utility class for "
},
{
"path": "eslint.config.mjs",
"chars": 5181,
"preview": "import js from '@eslint/js';\nimport importPlugin from 'eslint-plugin-import';\nimport jsdoc from 'eslint-plugin-jsdoc';\ni"
},
{
"path": "examples/animation_blending_additive.html",
"chars": 7726,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - animation blending additive</title>\n\t<meta name=\"vie"
},
{
"path": "examples/animation_bone_attach.html",
"chars": 8480,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - animation / bone attach</title>\n\t<meta name=\"viewpor"
},
{
"path": "examples/animation_crossfade.html",
"chars": 8409,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - animation crossfade</title>\n\t<meta name=\"viewport\" c"
},
{
"path": "examples/animation_interpolant.html",
"chars": 3638,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - animation interpolant</title>\n\t<meta name=\"viewport\""
},
{
"path": "examples/animation_keyframe_animation.html",
"chars": 5127,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - keyframe animation</title>\n\t<meta name=\"viewport\" co"
},
{
"path": "examples/animation_morphtargets.html",
"chars": 4470,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - morph targets</title>\n\t<meta name=\"viewport\" content"
},
{
"path": "examples/animation_multiple.html",
"chars": 5889,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - animation multiple</title>\n\t<meta name=\"viewport\" co"
},
{
"path": "examples/animation_skinned_instancing.html",
"chars": 8928,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - animation skinned instancing</title>\n\t<meta name=\"vi"
},
{
"path": "examples/animation_skinned_mesh.html",
"chars": 4838,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - skinned mesh</title>\n\t<meta name=\"viewport\" content="
},
{
"path": "examples/animation_snake.html",
"chars": 4975,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - snake</title>\n\t<meta name=\"viewport\" content=\"width="
},
{
"path": "examples/camera_multiple.html",
"chars": 4415,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - multiple cameras</title>\n\t<meta name=\"viewport\" cont"
},
{
"path": "examples/camera_projection.html",
"chars": 5324,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - camera projection</title>\n\t<meta name=\"viewport\" con"
},
{
"path": "examples/canvas2d_canvas2d.html",
"chars": 6386,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - canvas2d</title>\n\t<meta name=\"viewport\" content=\"wid"
},
{
"path": "examples/controls_camera_fly.html",
"chars": 2862,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - camera fly controls</title>\n\t<meta name=\"viewport\" c"
},
{
"path": "examples/controls_camera_free.html",
"chars": 2969,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - camera free controls</title>\n\t<meta name=\"viewport\" "
},
{
"path": "examples/controls_camera_orbit.html",
"chars": 2895,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - camera orbit controls</title>\n\t<meta name=\"viewport\""
},
{
"path": "examples/controls_camera_view.html",
"chars": 3587,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - camera view controls</title>\n\t<meta name=\"viewport\" "
},
{
"path": "examples/controls_transform.html",
"chars": 7641,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta charset=\"utf-8\">\n <title>t3d - transform controls</title>\n <meta name=\"vie"
},
{
"path": "examples/custompass_bloom.html",
"chars": 7181,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass bloom</title>\n\t<meta name=\"viewport\" con"
},
{
"path": "examples/custompass_blur.html",
"chars": 5073,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass blur</title>\n\t<meta name=\"viewport\" cont"
},
{
"path": "examples/custompass_car.html",
"chars": 5502,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass custom</title>\n\t<meta name=\"viewport\" co"
},
{
"path": "examples/custompass_deferred.html",
"chars": 23160,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass deferred</title>\n\t<meta name=\"viewport\" "
},
{
"path": "examples/custompass_depth_buffer_share.html",
"chars": 5501,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom depth buffer share</title>\n\t<meta name=\"viewp"
},
{
"path": "examples/custompass_depth_texture_share.html",
"chars": 5470,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom depth texture share</title>\n\t<meta name=\"view"
},
{
"path": "examples/custompass_dof.html",
"chars": 6379,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass dof</title>\n\t<meta name=\"viewport\" conte"
},
{
"path": "examples/custompass_gbuffer.html",
"chars": 3863,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass gbuffer</title>\n\t<meta name=\"viewport\" c"
},
{
"path": "examples/custompass_gpupick.html",
"chars": 8145,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta charset=\"utf-8\">\n <title>t3d - GPUPick</title>\n <meta name=\"viewport\" cont"
},
{
"path": "examples/custompass_lensflare.html",
"chars": 14204,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - lens flare</title>\n\t<meta name=\"viewport\" content=\"w"
},
{
"path": "examples/custompass_motion_blur.html",
"chars": 6524,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass motion blur</title>\n\t<meta name=\"viewpor"
},
{
"path": "examples/custompass_motion_blur2.html",
"chars": 5984,
"preview": "<!DOCTYPE html>\n<html>\n\t<head>\n\t\t<meta charset=\"utf-8\" />\n\t\t<title>t3d - custom pass motion blur</title>\n\t\t<meta name=\"v"
},
{
"path": "examples/custompass_msaa.html",
"chars": 5404,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass msaa</title>\n\t<meta name=\"viewport\" cont"
},
{
"path": "examples/custompass_oit.html",
"chars": 5061,
"preview": "<!DOCTYPE html>\n<html>\n\n<head>\n <meta charset=\"utf-8\" />\n <title>t3d - custom pass oit</title>\n <meta name=\"vie"
},
{
"path": "examples/custompass_rendertarget_2d.html",
"chars": 4126,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta charset=\"utf-8\">\n <title>t3d - rendertarget 2d</title>\n <meta name=\"viewpo"
},
{
"path": "examples/custompass_rendertarget_3d.html",
"chars": 4005,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta charset=\"utf-8\">\n <title>t3d - rendertarget 3d</title>\n <meta name=\"viewpo"
},
{
"path": "examples/custompass_shadow_planar.html",
"chars": 5903,
"preview": "<!DOCTYPE html>\n<html>\n\n<head>\n <meta charset=\"utf-8\">\n <title>t3d - planar shadow</title>\n <meta name=\"viewpor"
},
{
"path": "examples/custompass_sketch.html",
"chars": 5571,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass sketch</title>\n\t<meta name=\"viewport\" co"
},
{
"path": "examples/custompass_ssao.html",
"chars": 8028,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass ssao</title>\n\t<meta name=\"viewport\" cont"
},
{
"path": "examples/custompass_ssr.html",
"chars": 8416,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass ssr</title>\n\t<meta name=\"viewport\" conte"
},
{
"path": "examples/custompass_taa.html",
"chars": 8411,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custom pass taa</title>\n\t<meta name=\"viewport\" conte"
},
{
"path": "examples/custompass_transmission.html",
"chars": 9525,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta charset=\"utf-8\">\n <title>t3d - custompass transmission</title>\n <meta name"
},
{
"path": "examples/custompass_unrealbloom.html",
"chars": 4975,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta charset=\"utf-8\">\n <title>t3d - custom pass unreal bloom</title>\n <meta nam"
},
{
"path": "examples/custompass_xray.html",
"chars": 5807,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - custompass xray</title>\n\t<meta name=\"viewport\" conte"
},
{
"path": "examples/exporter_draco.html",
"chars": 4641,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - draco exporter</title>\n\t<meta name=\"viewport\" conten"
},
{
"path": "examples/exporter_gltf.html",
"chars": 9850,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf exporter</title>\n\t<meta name=\"viewport\" content"
},
{
"path": "examples/files/fonts/OFL-hind.txt",
"chars": 4373,
"preview": "Copyright (c) 2014, Indian Type Foundry (info@indiantypefoundry.com).\n\nThis Font Software is licensed under the SIL Open"
},
{
"path": "examples/files/fonts/OFL-montserrat.txt",
"chars": 4392,
"preview": "Copyright 2011 The Montserrat Project Authors (https://github.com/JulietaUla/Montserrat)\n\nThis Font Software is licensed"
},
{
"path": "examples/files/main.css",
"chars": 5074,
"preview": ":root {\n color-scheme: light dark;\n\n --background-color: #f7f7f7;\n\n --active-text-color: #FF7F02;\n --text-co"
},
{
"path": "examples/files.json",
"chars": 5993,
"preview": "{\n\t\"light\": [\n\t\t\"light_directlight\",\n\t\t\"light_pointlight\",\n\t\t\"light_spotlight\",\n\t\t\"light_rectarealight\",\n\t\t\"light_hemisp"
},
{
"path": "examples/geometry_boundings.html",
"chars": 5760,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta charset=\"utf-8\">\n <title>t3d - boundings</title>\n <meta name=\"viewport\" co"
},
{
"path": "examples/geometry_builder_edges.html",
"chars": 3985,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - geometry edges builder</title>\n\t<meta name=\"viewport"
},
{
"path": "examples/geometry_builder_lines.html",
"chars": 8547,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - geometry line builders</title>\n\t<meta name=\"viewport"
},
{
"path": "examples/geometry_builder_shapes.html",
"chars": 8339,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - geometry shape builders</title>\n\t<meta name=\"viewpor"
},
{
"path": "examples/geometry_geometries.html",
"chars": 5229,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - geometries</title>\n\t<meta name=\"viewport\" content=\"w"
},
{
"path": "examples/geometry_groups.html",
"chars": 3862,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - groups</title>\n\t<meta name=\"viewport\" content=\"width"
},
{
"path": "examples/geometry_loader_assimp2json.html",
"chars": 3496,
"preview": "<!DOCTYPE html>\n<html>\n\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - assimp2json</title>\n\t<meta name=\"viewport\" content="
},
{
"path": "examples/geometry_loader_gltf.html",
"chars": 4453,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf</title>\n\t<meta name=\"viewport\" content=\"width=d"
},
{
"path": "examples/geometry_loader_gltf2.html",
"chars": 6210,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf2</title>\n\t<meta name=\"viewport\" content=\"width="
},
{
"path": "examples/geometry_loader_gltf3.html",
"chars": 4385,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf3</title>\n\t<meta name=\"viewport\" content=\"width="
},
{
"path": "examples/geometry_loader_gltf_avif.html",
"chars": 3435,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf avif</title>\n\t<meta name=\"viewport\" content=\"wi"
},
{
"path": "examples/geometry_loader_gltf_camera.html",
"chars": 2835,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf camera</title>\n\t<meta name=\"viewport\" content=\""
},
{
"path": "examples/geometry_loader_gltf_draco.html",
"chars": 4750,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf draco</title>\n\t<meta name=\"viewport\" content=\"w"
},
{
"path": "examples/geometry_loader_gltf_helmat.html",
"chars": 3949,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf</title>\n\t<meta name=\"viewport\" content=\"width=d"
},
{
"path": "examples/geometry_loader_gltf_instancing.html",
"chars": 5765,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf</title>\n\t<meta name=\"viewport\" content=\"width=d"
},
{
"path": "examples/geometry_loader_gltf_lights.html",
"chars": 3571,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf lights</title>\n\t<meta name=\"viewport\" content=\""
},
{
"path": "examples/geometry_loader_gltf_materials_clearcoat.html",
"chars": 4312,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf materials clearcoat</title>\n\t<meta name=\"viewpo"
},
{
"path": "examples/geometry_loader_gltf_materials_dispersion.html",
"chars": 8369,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta charset=\"utf-8\">\n <title>t3d - gltf materials dispersion</title>\n <meta na"
},
{
"path": "examples/geometry_loader_gltf_materials_transmission.html",
"chars": 8520,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta charset=\"utf-8\">\n <title>t3d - gltf materials transmission</title>\n <meta "
},
{
"path": "examples/geometry_loader_gltf_materials_unlit.html",
"chars": 3249,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf materials unlit</title>\n\t<meta name=\"viewport\" "
},
{
"path": "examples/geometry_loader_gltf_meshopt.html",
"chars": 4604,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf meshopt</title>\n\t<meta name=\"viewport\" content="
},
{
"path": "examples/geometry_loader_gltf_morphtargets.html",
"chars": 5822,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf morphtargets</title>\n\t<meta name=\"viewport\" con"
},
{
"path": "examples/geometry_loader_gltf_pointer.html",
"chars": 3965,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf pointer</title>\n\t<meta name=\"viewport\" content="
},
{
"path": "examples/geometry_loader_gltf_skinning.html",
"chars": 6817,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf skinning</title>\n\t<meta name=\"viewport\" content"
},
{
"path": "examples/geometry_loader_gltf_tangent.html",
"chars": 3949,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf tangent</title>\n\t<meta name=\"viewport\" content="
},
{
"path": "examples/geometry_loader_gltf_uvtransform.html",
"chars": 3025,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - gltf uv transform</title>\n\t<meta name=\"viewport\" con"
},
{
"path": "examples/geometry_loader_vox.html",
"chars": 3362,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n\t<meta charset=\"utf-8\">\n\t<title>t3d - vox</title>\n\t<meta name=\"viewport\" content=\"width=de"
},
{
"path": "examples/index.html",
"chars": 5833,
"preview": "<!DOCTYPE html>\n<html>\n<head>\n <meta charset=\"UTF-8\">\n <title>t3d.js examples</title>\n <meta name=\"viewport\" co"
},
{
"path": "examples/jsm/Clock.js",
"chars": 859,
"preview": "/**\n * @author alteredq / http://alteredqualia.com/\n */\n\nclass Clock {\n\n\tconstructor(autoStart = true) {\n\t\tthis.autoStar"
},
{
"path": "examples/jsm/DynamicFont.js",
"chars": 12965,
"preview": "import { DistanceTransform } from './math/DistanceTransform.js';\n\n/**\n * DynamicFont uses the CharacterCanvas to obtain "
},
{
"path": "examples/jsm/GBuffer.js",
"chars": 27759,
"preview": "import {\n\tATTACHMENT,\n\tMatrix4,\n\tOffscreenRenderTarget,\n\tSHADING_TYPE,\n\tShaderMaterial,\n\tShaderPostPass,\n\tTexture2D,\n\tPI"
},
{
"path": "examples/jsm/PickBuffer.js",
"chars": 4858,
"preview": "import { OffscreenRenderTarget, PIXEL_TYPE, TEXTURE_FILTER, SHADING_TYPE, ShaderMaterial } from 't3d';\n\nexport default c"
},
{
"path": "examples/jsm/Raycaster.js",
"chars": 159,
"preview": "// deprecated since v0.4.3\nconsole.warn('Raycaster has been moved to core. Please import it from t3d instead of t3d/addo"
},
{
"path": "examples/jsm/SHGenerator.js",
"chars": 4371,
"preview": "import {\n\tVector3,\n\tColor3,\n\tOffscreenRenderTarget,\n\tScene,\n\tPIXEL_TYPE,\n\tPIXEL_FORMAT,\n\tSphericalHarmonics3\n} from 't3d"
},
{
"path": "examples/jsm/SceneUtils.js",
"chars": 1756,
"preview": "import { Box3, Matrix4, Vector3 } from 't3d';\n\nclass SceneUtils {\n\n\tstatic getRelativeMatrixFromRoot(node, root, target "
},
{
"path": "examples/jsm/SkeletonUtils.js",
"chars": 1575,
"preview": "import { KeyframeClip } from 't3d';\n\n/**\n * SkeletonUtils\n */\nconst SkeletonUtils = {\n\n\tclone: function(source, clips, o"
},
{
"path": "examples/jsm/SuperSampling.js",
"chars": 3642,
"preview": "/**\n * Super Sampling\n */\n\nimport {\n\tMatrix4,\n\tOffscreenRenderTarget,\n\tShaderPostPass,\n\tTEXTURE_FILTER\n} from 't3d';\nimp"
},
{
"path": "examples/jsm/VoxMeshBuilder.js",
"chars": 12761,
"preview": "/**\n * VOXMeshBuilder\n */\n\nimport {\n\tAttribute,\n\tBuffer,\n\tColor3,\n\tGeometry,\n\tMatrix3,\n\tMatrix4,\n\tMesh,\n\tPhongMaterial,\n"
},
{
"path": "examples/jsm/WaterSimulation.js",
"chars": 4123,
"preview": "import { OffscreenRenderTarget, ShaderPostPass, PIXEL_TYPE, TEXTURE_FILTER } from 't3d';\n\n// refer: madebyevan.com/webgl"
},
{
"path": "examples/jsm/WorkerPool.js",
"chars": 1614,
"preview": "/**\n * @author Deepkolos / https://github.com/deepkolos\n */\n\nexport class WorkerPool {\n\n\tconstructor(pool = 4) {\n\t\tthis."
},
{
"path": "examples/jsm/animation/CCDIKSolver.js",
"chars": 4561,
"preview": "import {\n\tQuaternion,\n\tVector3\n} from 't3d';\n\n// CCD Algorithm\n// - https://sites.google.com/site/auraliusproject/ccd-al"
},
{
"path": "examples/jsm/animation/LockedTrack.js",
"chars": 1974,
"preview": "import { Matrix4, Quaternion, Vector3 } from 't3d';\n\n/**\n * LockedTrack class allows an object to track a target positio"
},
{
"path": "examples/jsm/canvas2d/Canvas2D.js",
"chars": 10015,
"preview": "import {\n\tAttribute,\n\tBUFFER_USAGE,\n\tBuffer,\n\tCamera,\n\tGeometry,\n\tMesh,\n\tShaderMaterial,\n\tVector2,\n\tVector4\n} from 't3d'"
},
{
"path": "examples/jsm/canvas2d/Object2D.js",
"chars": 2066,
"preview": "import {\n\tBox2,\n\tMatrix3\n} from 't3d';\n\nclass Object2D {\n\n\tconstructor() {\n\t\tthis.width = 0;\n\t\tthis.height = 0;\n\n\t\t// bl"
},
{
"path": "examples/jsm/canvas2d/Sprite2D.js",
"chars": 167,
"preview": "import { Object2D } from '../canvas2d/Object2D.js';\n\nclass Sprite2D extends Object2D {\n\n\tconstructor() {\n\t\tsuper();\n\t\tth"
},
{
"path": "examples/jsm/controls/FlyControls.js",
"chars": 7556,
"preview": "import {\n\tQuaternion,\n\tVector3\n} from 't3d';\n\n/**\n * reference: https://github.com/mrdoob/three.js/blob/dev/examples/jsm"
},
{
"path": "examples/jsm/controls/FreeControls.js",
"chars": 4594,
"preview": "/**\n * @author shawn0326 / http://halflab.me\n */\n\nimport {\n\tQuaternion,\n\tVector2,\n\tVector3\n} from 't3d';\n\nclass FreeCont"
},
{
"path": "examples/jsm/controls/OrbitControls.js",
"chars": 19369,
"preview": "import {\n\tQuaternion,\n\tSpherical,\n\tVector2,\n\tVector3\n} from 't3d';\n\n// Modified from https://github.com/mrdoob/three.js/"
},
{
"path": "examples/jsm/controls/TransformControls.js",
"chars": 40973,
"preview": "import {\n\tObject3D, Vector2, Vector3, Euler, Plane, Matrix4, Quaternion,\n\tMesh, BasicMaterial, ShaderLib, Raycaster,\n\tCy"
},
{
"path": "examples/jsm/controls/ViewControls.js",
"chars": 8487,
"preview": "import { Vector3, Quaternion, Euler, MathUtils, Object3D } from 't3d';\n\nclass ViewControls {\n\n\tconstructor(camera, optio"
},
{
"path": "examples/jsm/exporters/DRACOExporter.js",
"chars": 6457,
"preview": "/**\n * Export draco compressed files from t3d geometry objects.\n *\n * Draco files are compressed and usually are smaller"
},
{
"path": "examples/jsm/exporters/GLTFExporter.js",
"chars": 54099,
"preview": "import { Attribute, Buffer, CubicSplineInterpolant, DRAW_MODE, DRAW_SIDE, MATERIAL_TYPE, Matrix4, Object3D, PIXEL_FORMAT"
},
{
"path": "examples/jsm/geometries/BitmapTextGeometry.js",
"chars": 18518,
"preview": "import { Geometry, Buffer, Attribute } from 't3d';\n\n/**\n * BitmapTextGeometry - generates a geometry for a bitmap text\n "
},
{
"path": "examples/jsm/geometries/CapsuleGeometry.js",
"chars": 4526,
"preview": "import { Geometry, Attribute, Buffer, Vector3 } from 't3d';\n\n/**\n * A geometry class for representing a capsule.\n */\ncla"
},
{
"path": "examples/jsm/geometries/CircleGeometry.js",
"chars": 1567,
"preview": "import { Geometry, Attribute, Buffer, Vector2, Vector3 } from 't3d';\n\nclass CircleGeometry extends Geometry {\n\n\tconstruc"
},
{
"path": "examples/jsm/geometries/GeometryUtils.js",
"chars": 14621,
"preview": "import {\n\tAttribute,\n\tBuffer,\n\tGeometry,\n\tMatrix3,\n\tVector2,\n\tVector3\n} from 't3d';\n\nclass GeometryUtils {\n\n\t/**\n\t * @pa"
},
{
"path": "examples/jsm/geometries/builders/Earcut.js",
"chars": 16421,
"preview": "/**\n * Port from https://github.com/mapbox/earcut (v2.2.2)\n */\n\nconst Earcut = {\n\n\ttriangulate: function(data, holeIndic"
},
{
"path": "examples/jsm/geometries/builders/EdgesBuilder.js",
"chars": 4749,
"preview": "/**\n * EdgesBuilder is a helper for building edges geometry from given triangles data.\n */\nconst EdgesBuilder = {\n\n\t/**\n"
},
{
"path": "examples/jsm/geometries/builders/ExtrudeShapeBuilder.js",
"chars": 5890,
"preview": "import { Vector3 } from 't3d';\nimport { Earcut } from './Earcut.js';\nimport { GeometryBuilderUtils } from './GeometryBui"
},
{
"path": "examples/jsm/geometries/builders/Font.js",
"chars": 5232,
"preview": "import { Vector2 } from 't3d';\nimport { CubicBezierCurve2 } from '../../math/curves/CubicBezierCurve2.js';\nimport { Curv"
},
{
"path": "examples/jsm/geometries/builders/GeometryBuilderUtils.js",
"chars": 1780,
"preview": "/**\n * Geometry Builder Utils\n */\nconst GeometryBuilderUtils = {\n\n\tconvertShapeDataToEarcut: function(shape, vertices, h"
},
{
"path": "examples/jsm/geometries/builders/LatheBuilder.js",
"chars": 3365,
"preview": "import { Vector2, Vector3, MathUtils } from 't3d';\n\n/**\n * LatheBuilder\n */\nconst LatheBuilder = {\n\t/**\n\t * @param {Arra"
},
{
"path": "examples/jsm/geometries/builders/PolygonBuilder.js",
"chars": 1217,
"preview": "import { Earcut } from './Earcut.js';\nimport { GeometryBuilderUtils } from './GeometryBuilderUtils.js';\n\n/**\n * PolygonB"
},
{
"path": "examples/jsm/geometries/builders/PolyhedronBuilder.js",
"chars": 7289,
"preview": "import { Vector3, Vector2 } from 't3d';\n\nclass PolyhedronBuilder {\n\n\tstatic getGeometryData(vertices, indices, radius = "
},
{
"path": "examples/jsm/geometries/builders/RouteBuilder.js",
"chars": 6746,
"preview": "import { Vector3 } from 't3d';\n\n/**\n * RouteBuilder\n */\nconst RouteBuilder = {\n\n\t/**\n\t * @param {object} frames\n\t * @par"
},
{
"path": "examples/jsm/geometries/builders/TorusBuilder.js",
"chars": 1680,
"preview": "import { Vector3 } from 't3d';\n\n/**\n * TorusBuilder\n */\nconst TorusBuilder = {\n\n\tgetGeometryData: function(radius = 1, t"
},
{
"path": "examples/jsm/geometries/builders/TubeBuilder.js",
"chars": 4710,
"preview": "import { Vector3, Quaternion } from 't3d';\n\n/**\n * TubeBuilder\n */\nconst TubeBuilder = {\n\n\t/**\n\t * @param {object} frame"
},
{
"path": "examples/jsm/impostor/OctahedralImpostor.js",
"chars": 12140,
"preview": "\nimport {\n\tMesh,\n\tPlaneGeometry\n} from 't3d';\nimport { ShaderLib, PBRMaterial, MATERIAL_TYPE, DepthMaterial }\tfrom 't3d'"
},
{
"path": "examples/jsm/impostor/OctahedralTextureGenerator.js",
"chars": 6937,
"preview": "import {\n\tScene,\n\tTexture2D,\n\tPBRMaterial,\n\tShaderLib,\n\tSphere,\n\tCamera,\n\tOffscreenRenderTarget,\n\tATTACHMENT,\n\tTEXTURE_F"
},
{
"path": "examples/jsm/lights/LightShadowAdapter.js",
"chars": 16851,
"preview": "import { Box3, Matrix3, Matrix4, Plane, Spherical, Vector3, Vector2 } from 't3d';\nimport { OBB } from '../math/OBB.js';\n"
},
{
"path": "examples/jsm/lights/RectAreaLightLTC.js",
"chars": 309157,
"preview": "import {\n\tTexture2D,\n\tTEXTURE_WRAP,\n\tTEXTURE_FILTER,\n\tPIXEL_FORMAT,\n\tPIXEL_TYPE\n} from 't3d';\n\n// Real-Time Polygonal-Li"
},
{
"path": "examples/jsm/loaders/AssimpJsonLoader.js",
"chars": 13264,
"preview": "import {\n\tAnimationAction,\n\tAnimationMixer,\n\tAttribute,\n\tBone,\n\tBuffer,\n\tFileLoader,\n\tGeometry,\n\tKeyframeClip,\n\tMatrix4,"
},
{
"path": "examples/jsm/loaders/DDSLoader.js",
"chars": 7707,
"preview": "import {\n\tLoader,\n\tFileLoader,\n\tPIXEL_FORMAT,\n\tTextureCube,\n\tTexture2D,\n\tTEXTURE_FILTER\n} from 't3d';\n\nclass DDSLoader e"
},
{
"path": "examples/jsm/loaders/DRACOLoader.js",
"chars": 12594,
"preview": "import {\n\tAttribute,\n\tGeometry,\n\tBuffer,\n\tFileLoader,\n\tLoader,\n\tColor3\n} from 't3d';\n\nconst _taskCache = new WeakMap();\n"
},
{
"path": "examples/jsm/loaders/EXRLoader.js",
"chars": 52913,
"preview": "import {\n\tLoader,\n\tFileLoader,\n\tPIXEL_TYPE,\n\tPIXEL_FORMAT,\n\tTEXTURE_FILTER,\n\tTEXEL_ENCODING_TYPE,\n\tTexture2D,\n\tMathUtils"
},
{
"path": "examples/jsm/loaders/EnvLoader.js",
"chars": 3897,
"preview": "import { Loader, FileLoader, TextureCube, ImageLoader, PIXEL_TYPE, PIXEL_FORMAT } from 't3d';\nimport { ImageBitmapLoader"
},
{
"path": "examples/jsm/loaders/ImageBitmapLoader.js",
"chars": 1321,
"preview": "import { Loader } from 't3d';\n\nclass ImageBitmapLoader extends Loader {\n\n\tconstructor(manager) {\n\t\tsuper(manager);\n\n\t\tif"
},
{
"path": "examples/jsm/loaders/KTX2Loader.js",
"chars": 23508,
"preview": "import {\n\tLoader,\n\tFileLoader,\n\tTEXTURE_FILTER,\n\tPIXEL_FORMAT,\n\tPIXEL_TYPE,\n\tTEXEL_ENCODING_TYPE,\n\tTexture2D\n} from 't3d"
},
{
"path": "examples/jsm/loaders/PVRLoader.js",
"chars": 6048,
"preview": "import {\n\tLoader,\n\tFileLoader,\n\tPIXEL_FORMAT,\n\tTexture2D,\n\tTEXTURE_FILTER,\n\tTextureCube\n} from 't3d';\n\nclass PVRLoader e"
},
{
"path": "examples/jsm/loaders/RGBELoader.js",
"chars": 12319,
"preview": "import { Loader, FileLoader, PIXEL_TYPE, PIXEL_FORMAT, TEXTURE_FILTER, Texture2D, TextureCube, MathUtils } from 't3d';\n\n"
},
{
"path": "examples/jsm/loaders/TGALoader.js",
"chars": 12226,
"preview": "import { Loader, FileLoader, TEXTURE_FILTER, Texture2D, TextureCube } from 't3d';\n\nclass TGALoader extends Loader {\n\n\tlo"
},
{
"path": "examples/jsm/loaders/Texture2DLoader.js",
"chars": 538,
"preview": "import { Loader, ImageLoader, Texture2D } from 't3d';\n\nclass Texture2DLoader extends Loader {\n\n\tconstructor(manager) {\n\t"
},
{
"path": "examples/jsm/loaders/TextureCubeLoader.js",
"chars": 710,
"preview": "import { Loader, ImageLoader, TextureCube } from 't3d';\n\nclass TextureCubeLoader extends Loader {\n\n\tconstructor(manager)"
},
{
"path": "examples/jsm/loaders/glTF/Constants.js",
"chars": 1536,
"preview": "import {\n\tTEXTURE_FILTER,\n\tTEXTURE_WRAP\n} from 't3d';\n\nexport const ATTRIBUTES = {\n\tPOSITION: 'a_Position',\n\tNORMAL: 'a_"
},
{
"path": "examples/jsm/loaders/glTF/GLTFLoader.js",
"chars": 6349,
"preview": "import { DefaultLoadingManager, FileLoader, ImageLoader } from 't3d';\n\nimport { ImageBitmapLoader } from '../ImageBitmap"
},
{
"path": "examples/jsm/loaders/glTF/GLTFResource.js",
"chars": 1167,
"preview": "let resourceId = 0;\n\nexport class GLTFResource {\n\n\tconstructor() {\n\t\tthis.id = ++resourceId;\n\t\tthis.url = ''; // url str"
},
{
"path": "examples/jsm/loaders/glTF/GLTFUtils.js",
"chars": 4074,
"preview": "import { Vector4 } from 't3d';\n\nconst _vec4_1 = new Vector4();\n\nexport class GLTFUtils {\n\n\tconstructor() {}\n\n\tstatic ext"
},
{
"path": "examples/jsm/loaders/glTF/extensions/EXT_mesh_gpu_instancing.js",
"chars": 3201,
"preview": "import { Object3D, Mesh, SkinnedMesh, Matrix4, Vector3, Quaternion, Attribute, Buffer, MATERIAL_TYPE } from 't3d';\nimpor"
},
{
"path": "examples/jsm/loaders/glTF/extensions/EXT_meshopt_compression.js",
"chars": 1255,
"preview": "/**\n * meshopt BufferView Compression Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/ex"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_animation_pointer.js",
"chars": 3066,
"preview": "import { QuaternionKeyframeTrack, NumberKeyframeTrack, VectorKeyframeTrack, ColorKeyframeTrack } from 't3d';\n\nexport cla"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_draco_mesh_compression.js",
"chars": 1846,
"preview": "import { ATTRIBUTES, ACCESSOR_COMPONENT_TYPES } from '../Constants.js';\n\n/**\n * KHR_draco_mesh_compression extension\n * "
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_lights_punctual.js",
"chars": 1375,
"preview": "import { DirectionalLight, PointLight, SpotLight } from 't3d';\n\n/**\n * KHR_lights_punctual extension\n * https://github.c"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_materials_clearcoat.js",
"chars": 1685,
"preview": "import { PBRMaterial, Vector2 } from 't3d';\n/**\n * KHR_materials_clearcoat extension\n * Specification: https://github.co"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_materials_dispersion.js",
"chars": 635,
"preview": "import { TransmissionPBRMaterial } from '../../../materials/TransmissionPBRMaterial.js';\n\n/**\n * KHR_materials_dispersio"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_materials_ior.js",
"chars": 545,
"preview": "import { TransmissionPBRMaterial } from '../../../materials/TransmissionPBRMaterial.js';\n\n/**\n * KHR_materials_ior exten"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_materials_pbrSpecularGlossiness.js",
"chars": 1462,
"preview": "import { TEXEL_ENCODING_TYPE, PBR2Material } from 't3d';\n\n/**\n * KHR_materials_pbrSpecularGlossiness extension\n * https:"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_materials_transmission.js",
"chars": 951,
"preview": "import { TransmissionPBRMaterial } from '../../../materials/TransmissionPBRMaterial.js';\n\n/**\n * KHR_materials_transmiss"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_materials_unlit.js",
"chars": 269,
"preview": "import { BasicMaterial } from 't3d';\n\n/**\n * KHR_materials_unlit extension\n * https://github.com/KhronosGroup/glTF/tree/"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_materials_volume.js",
"chars": 1035,
"preview": "import { TransmissionPBRMaterial } from '../../../materials/TransmissionPBRMaterial.js';\n\n/**\n * KHR_materials_volume ex"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_texture_basisu.js",
"chars": 334,
"preview": "/**\n * BasisU Texture Extension\n *\n * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khr"
},
{
"path": "examples/jsm/loaders/glTF/extensions/KHR_texture_transform.js",
"chars": 894,
"preview": "/**\n * KHR_texture_transform extension\n * https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_te"
},
{
"path": "examples/jsm/loaders/glTF/parsers/AccessorParser.js",
"chars": 4096,
"preview": "import { Attribute, Buffer } from 't3d';\nimport { ACCESSOR_COMPONENT_TYPES, ACCESSOR_TYPE_SIZES } from '../Constants.js'"
},
{
"path": "examples/jsm/loaders/glTF/parsers/AnimationParser.js",
"chars": 3908,
"preview": "import {\n\tQuaternionKeyframeTrack,\n\tNumberKeyframeTrack,\n\tVectorKeyframeTrack,\n\tKeyframeClip,\n\tStepInterpolant,\n\tLinearI"
},
{
"path": "examples/jsm/loaders/glTF/parsers/BufferParser.js",
"chars": 851,
"preview": "import { GLTFUtils } from '../GLTFUtils.js';\n\nexport class BufferParser {\n\n\tstatic parse(context, loader) {\n\t\tconst { gl"
},
{
"path": "examples/jsm/loaders/glTF/parsers/BufferViewParser.js",
"chars": 792,
"preview": "export class BufferViewParser {\n\n\tstatic parse(context, loader) {\n\t\tconst { buffers, gltf } = context;\n\n\t\tif (!gltf.buff"
},
{
"path": "examples/jsm/loaders/glTF/parsers/ImageParser.js",
"chars": 3254,
"preview": "import { GLTFUtils } from '../GLTFUtils.js';\n\nexport class ImageParser {\n\n\tstatic parse(context, loader) {\n\t\tconst { glt"
},
{
"path": "examples/jsm/loaders/glTF/parsers/IndexParser.js",
"chars": 546,
"preview": "import { GLTFUtils } from '../GLTFUtils.js';\n\nexport class IndexParser {\n\n\tstatic parse(context, loader) {\n\t\tconst { url"
},
{
"path": "examples/jsm/loaders/glTF/parsers/MaterialParser.js",
"chars": 4383,
"preview": "import {\n\tPBRMaterial,\n\tDRAW_SIDE,\n\tTEXEL_ENCODING_TYPE\n} from 't3d';\nimport { ALPHA_MODES } from '../Constants.js';\n\nex"
},
{
"path": "examples/jsm/loaders/glTF/parsers/NodeParser.js",
"chars": 3495,
"preview": "import { Bone, Camera, Object3D, Mesh, SkinnedMesh } from 't3d';\nimport { GLTFUtils } from '../GLTFUtils.js';\n\nexport cl"
},
{
"path": "examples/jsm/loaders/glTF/parsers/PrimitiveParser.js",
"chars": 9195,
"preview": "import { Geometry, PBRMaterial, VERTEX_COLOR, SHADING_TYPE, PointsMaterial, Material, BasicMaterial } from 't3d';\nimport"
},
{
"path": "examples/jsm/loaders/glTF/parsers/ReferenceParser.js",
"chars": 1670,
"preview": "import { GLTFUtils } from '../GLTFUtils.js';\n\n// Marks the special nodes/meshes in json for efficient parse.\nexport clas"
},
{
"path": "examples/jsm/loaders/glTF/parsers/SceneParser.js",
"chars": 874,
"preview": "import { Object3D } from 't3d';\n\nexport class SceneParser {\n\n\tstatic parse(context) {\n\t\tconst { gltf, nodes } = context;"
},
{
"path": "examples/jsm/loaders/glTF/parsers/SkinParser.js",
"chars": 1179,
"preview": "import { Matrix4, Skeleton } from 't3d';\n\nexport class SkinParser {\n\n\tstatic parse(context) {\n\t\tconst { gltf, accessors,"
},
{
"path": "examples/jsm/loaders/glTF/parsers/TextureParser.js",
"chars": 3051,
"preview": "import {\n\tTexture2D,\n\tTEXTURE_FILTER,\n\tTEXTURE_WRAP\n} from 't3d';\nimport { WEBGL_WRAPPINGS, WEBGL_FILTERS } from '../Con"
},
{
"path": "examples/jsm/loaders/glTF/parsers/Validator.js",
"chars": 247,
"preview": "export class Validator {\n\n\tstatic parse(context) {\n\t\tconst {\n\t\t\tgltf: {\n\t\t\t\tasset: { version }\n\t\t\t}\n\t\t} = context;\n\n\t\tco"
},
{
"path": "examples/jsm/materials/AlphaHashedPBRMaterial.js",
"chars": 3036,
"preview": "import { ShaderLib, PBRMaterial, MATERIAL_TYPE } from 't3d';\n\nexport class AlphaHashedPBRMaterial extends PBRMaterial {\n"
},
{
"path": "examples/jsm/materials/AttenuationMaterial.js",
"chars": 1358,
"preview": "import { MATERIAL_TYPE, PBRMaterial, ShaderLib } from 't3d';\n\nconst fresnel_pars_frag = `\n#include <inverse>\n#include <t"
},
{
"path": "examples/jsm/materials/BatchedMaterial.js",
"chars": 3674,
"preview": "import { ShaderLib, PBRMaterial, MATERIAL_TYPE } from 't3d';\n\nconst batching_pars_vert = `\n#ifdef USE_BATCHING\n\t#extensi"
},
{
"path": "examples/jsm/materials/BatchedPBRMaterial.js",
"chars": 178,
"preview": "// deprecated since v0.4.0\nconsole.warn('BatchedPBRMaterial has been moved to t3d/addons/material/BatchedMaterial.js');\n"
},
{
"path": "examples/jsm/materials/BitmapTextMaterial.js",
"chars": 3975,
"preview": "import { ShaderMaterial } from 't3d';\n\nclass BitmapTextMaterial extends ShaderMaterial {\n\n\tconstructor() {\n\t\tsuper(Bitma"
},
{
"path": "examples/jsm/materials/InstancedBasicMaterial.js",
"chars": 216,
"preview": "// deprecated since v0.3.1, add warning since v0.4.0\nconsole.warn('InstancedBasicMaterial has been moved to t3d/addons/m"
},
{
"path": "examples/jsm/materials/InstancedMaterial.js",
"chars": 3555,
"preview": "import { ShaderLib, PBRMaterial, BasicMaterial, DepthMaterial, MATERIAL_TYPE } from 't3d';\n\nconst instancing_pars_vert ="
},
{
"path": "examples/jsm/materials/InstancedPBRMaterial.js",
"chars": 212,
"preview": "// deprecated since v0.3.1, add warning since v0.4.0\nconsole.warn('InstancedPBRMaterial has been moved to t3d/addons/mat"
},
{
"path": "examples/jsm/materials/PlanarReflectionMaterial.js",
"chars": 2431,
"preview": "import { ShaderLib, PBRMaterial, MATERIAL_TYPE } from 't3d';\n\nexport class PlanarReflectionMaterial extends PBRMaterial "
},
{
"path": "examples/jsm/materials/TransmissionPBRMaterial.js",
"chars": 12193,
"preview": "import { ShaderLib, PBRMaterial, MATERIAL_TYPE } from 't3d';\n\nexport class TransmissionPBRMaterial extends PBRMaterial {"
},
{
"path": "examples/jsm/math/ColorGradient.js",
"chars": 2394,
"preview": "import { Color3 } from 't3d';\n\nclass ColorGradient {\n\n\tconstructor() {\n\t\tthis._colorStops = [];\n\t\tthis._sortDirty = fals"
},
{
"path": "examples/jsm/math/DistanceTransform.js",
"chars": 4071,
"preview": "\n/**\n * DistanceTransform is a class for creating distance fields from image data.\n * ref: https://github.com/mapbox/tin"
},
{
"path": "examples/jsm/math/OBB.js",
"chars": 15971,
"preview": "import { MathUtils, Ray, Box3, Matrix3, Matrix4, Vector3, Frustum } from 't3d';\n\n/**\n * An oriented bounding box (OBB) i"
},
{
"path": "examples/jsm/math/Octree.js",
"chars": 2705,
"preview": "import { Vector3, Box3 } from 't3d';\n\nclass Octree {\n\n\tconstructor(box = new Box3(), depth = 0) {\n\t\tthis.box = box;\n\t\tth"
},
{
"path": "examples/jsm/math/TriangleSoup.js",
"chars": 3494,
"preview": "import { Vector3, DRAW_MODE, MathUtils } from 't3d';\n\n/**\n * TriangleSoup - A data structure for storing and manipulatin"
},
{
"path": "examples/jsm/math/TrianglesOctree.js",
"chars": 3859,
"preview": "import { Vector3, Box3, Triangle } from 't3d';\nimport { Octree } from './Octree.js';\n\nclass TrianglesOctree extends Octr"
},
{
"path": "examples/jsm/math/VirtualGroup.js",
"chars": 4908,
"preview": "import { Matrix4, Box3, Vector3 } from 't3d';\n\n/**\n * This is a virtual group for objects.\n * With this, you can manipul"
},
{
"path": "examples/jsm/math/curves/CubicBezierCurve2.js",
"chars": 741,
"preview": "/**\n * CubicBezierCurve2\n */\n\nimport {\n\tVector2\n} from 't3d';\nimport { Curve } from './Curve.js';\nimport { CurveUtils } "
},
{
"path": "examples/jsm/math/curves/CubicBezierCurve3.js",
"chars": 795,
"preview": "/**\n * CubicBezierCurve3\n */\n\nimport {\n\tVector3\n} from 't3d';\nimport { Curve } from './Curve.js';\nimport { CurveUtils } "
},
{
"path": "examples/jsm/math/curves/Curve.js",
"chars": 2818,
"preview": "/**\n * Curve\n */\nclass Curve {\n\n\tconstructor() {\n\t\tthis.arcLengthDivisions = 200;\n\t\tthis.cacheArcLengths = null;\n\t\tthis."
},
{
"path": "examples/jsm/math/curves/CurvePath.js",
"chars": 10393,
"preview": "import { Vector2, Vector3 } from 't3d';\nimport { LineCurve2 } from './LineCurve2.js';\nimport { LineCurve3 } from './Line"
},
{
"path": "examples/jsm/math/curves/CurvePath2.js",
"chars": 149,
"preview": "import { CurvePath } from './CurvePath.js';\n\nclass CurvePath2 extends CurvePath {}\n\nCurvePath2.prototype.isCurvePath2 = "
},
{
"path": "examples/jsm/math/curves/CurvePath3.js",
"chars": 6565,
"preview": "import { Vector3, Matrix4, MathUtils } from 't3d';\nimport { CurvePath } from './CurvePath.js';\n\nclass CurvePath3 extends"
},
{
"path": "examples/jsm/math/curves/CurveUtils.js",
"chars": 5183,
"preview": "\nimport { Vector3 } from 't3d';\n\n/**\n * CurveUtils\n */\nclass CurveUtils {\n\n\t/**\n\t * Generates 2D-Coordinates in a very f"
},
{
"path": "examples/jsm/math/curves/Curves.js",
"chars": 476,
"preview": "export { Curve } from './Curve.js';\nexport { LineCurve2 } from './LineCurve2.js';\nexport { LineCurve3 } from './LineCurv"
},
{
"path": "examples/jsm/math/curves/LineCurve2.js",
"chars": 709,
"preview": "/**\n * LineCurve2\n */\n\nimport {\n\tVector2\n} from 't3d';\nimport { Curve } from './Curve.js';\n\nclass LineCurve2 extends Cur"
}
]
// ... and 664 more files (download for full content)
About this extraction
This page contains the full source code of the uinosoft/t3d.js GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 864 files (11.6 MB), approximately 3.1M tokens, and a symbol index with 7174 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.