@plastic-software/three 0.181.3 → 0.183.0

package/examples/jsm/tsl/display/radialBlur.js

@@ -0,0 +1,68 @@
+import { interleavedGradientNoise, Fn, vec2, vec4, mix, uv, Loop, premultiplyAlpha, unpremultiplyAlpha, int, float, nodeObject, convertToTexture, screenCoordinate } from 'three/tsl';
+
+/**
+ * This TSL function blurs an image in a circular pattern, radiating from a configurable center point in screen space.
+ *
+ * Radial blurs can be used for different kind of effects like producing simple faked lighting effects also known as
+ * "light shafts". The major limitation of this specific usage is the center point can only be defined in 2D so the
+ * effect does not honor the depth of 3D objects. Consequently, it is not intended for physically correct lit scenes.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec4>} textureNode - The texture node that should be blurred.
+ * @param {Object} [options={}] - Additional options for the radial blur effect.
+ * @param {Node<vec2>} [options.center=vec2(0.5, 0.5)] - The center of the light in screen uvs.
+ * @param {Node<int>} [options.weight=float(0.9)] - Base weight factor for each sample in the range `[0,1]`.
+ * @param {Node<int>} [options.decay=float(0.95)] - Decreases the weight factor so each iteration adds less to the sum. Must be in the range `[0,1]`.
+ * If you increase the sample count, you have to increase this option as well to avoid a darking effect.
+ * @param {Node<int>} [options.count=int(32)] - The number if iterations. Should be in the range `[16,64]`.
+ * @param {Node<int>} [options.exposure=float(5)] - Exposure control of the blur.
+ * @return {Node<vec4>} The blurred texture node.
+ */
+export const radialBlur = /*#__PURE__*/ Fn( ( [ textureNode, options = {} ] ) => {
+
+	textureNode = convertToTexture( textureNode );
+
+	const center = nodeObject( options.center ) || vec2( 0.5, 0.5 );
+	const weight = nodeObject( options.weight ) || float( 0.9 );
+	const decay = nodeObject( options.decay ) || float( 0.95 );
+	const count = nodeObject( options.count ) || int( 32 );
+	const exposure = nodeObject( options.exposure ) || float( 5 );
+	const premultipliedAlpha = options.premultipliedAlpha || false;
+
+	const tap = ( uv ) => {
+
+		const sample = textureNode.sample( uv );
+
+		return premultipliedAlpha ? premultiplyAlpha( sample ) : sample;
+
+	};
+
+	const sampleUv = vec2( textureNode.uvNode || uv() );
+
+	const base = tap( sampleUv ).toConst();
+	const blur = vec4().toVar();
+	const offset = center.sub( sampleUv ).div( count ).toConst();
+	const w = float( weight ).toVar();
+
+	const noise = interleavedGradientNoise( screenCoordinate );
+	sampleUv.addAssign( offset.mul( noise ) ); // mitigate banding
+
+	Loop( { start: int( 0 ), end: int( count ), type: 'int', condition: '<' }, () => {
+
+		sampleUv.addAssign( offset );
+		const sample = tap( sampleUv );
+
+		blur.addAssign( sample.mul( w ) );
+		w.mulAssign( decay );
+
+	} );
+
+	blur.divAssign( count );
+	blur.mulAssign( exposure );
+
+	const color = mix( blur, base.mul( 2 ), 0.5 );
+
+	return premultipliedAlpha ? unpremultiplyAlpha( color ) : color;
+
+} );

package/examples/jsm/tsl/math/Bayer.js

@@ -1,5 +1,5 @@
 import { TextureLoader } from 'three';
-import { Fn, int, ivec2, textureLoad } from 'three/tsl';
+import { Fn, int, ivec2, textureLoad, screenUV, screenSize, mod, floor, float, vec3 } from 'three/tsl';
 
 /**
  * @module Bayer
@@ -32,3 +32,42 @@ export const bayer16 = Fn( ( [ uv ] ) => {
 	return textureLoad( bayer16Texture, ivec2( uv ).mod( int( 16 ) ) );
 
 } );
+
+/**
+ * This TSL function applies Bayer dithering to a color input. It uses a 4x4 Bayer matrix
+ * pattern to add structured noise before color quantization, which helps reduce visible
+ * color banding when limiting color depth.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} color - The input color to apply dithering to.
+ * @param {Node<float>} [steps=32] - The number of color steps per channel.
+ * @return {Node<vec3>} The dithered color ready for quantization.
+ *
+ * @example
+ * // Apply dithering with posterize
+ * const ditheredColor = bayerDither( inputColor, 32 );
+ * const finalColor = posterize( ditheredColor, 32 );
+ */
+export const bayerDither = Fn( ( [ color, steps = float( 32.0 ) ] ) => {
+
+	const screenPos = screenUV.mul( screenSize );
+	const x = mod( floor( screenPos.x ), float( 4.0 ) );
+	const y = mod( floor( screenPos.y ), float( 4.0 ) );
+
+	// Simplified Bayer matrix approximation
+	const bayer = mod(
+		floor( x.add( 1.0 ) ).mul( floor( y.add( 1.0 ) ) ).mul( 17.0 ),
+		16.0
+	).div( 16.0 ).sub( 0.5 );
+
+	// Apply dither offset before quantization
+	const ditherOffset = bayer.div( steps );
+
+	return vec3(
+		color.r.add( ditherOffset ),
+		color.g.add( ditherOffset ),
+		color.b.add( ditherOffset )
+	);
+
+} );

package/examples/jsm/utils/LDrawUtils.js

@@ -119,7 +119,7 @@ class LDrawUtils {
 
 		object.traverse( c => {
 
-			if ( c.isMesh | c.isLineSegments ) {
+			if ( c.isMesh || c.isLineSegments ) {
 
 				const elemSize = c.isMesh ? 3 : 2;
 

package/examples/jsm/utils/ShadowMapViewer.js

@@ -6,10 +6,8 @@ import {
 	OrthographicCamera,
 	PlaneGeometry,
 	Scene,
-	ShaderMaterial,
-	UniformsUtils
+	ShaderMaterial
 } from 'three';
-import { UnpackDepthRGBAShader } from '../shaders/UnpackDepthRGBAShader.js';
 
 /**
  * This is a helper for visualising a given light's shadow map.
@@ -57,13 +55,29 @@ class ShadowMapViewer {
 		const scene = new Scene();
 
 		//HUD for shadow map
-		const shader = UnpackDepthRGBAShader;
-
-		const uniforms = UniformsUtils.clone( shader.uniforms );
 		const material = new ShaderMaterial( {
-			uniforms: uniforms,
-			vertexShader: shader.vertexShader,
-			fragmentShader: shader.fragmentShader
+			uniforms: {
+				tDiffuse: { value: null },
+				opacity: { value: 1.0 }
+			},
+			vertexShader: /* glsl */`
+				varying vec2 vUv;
+				void main() {
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+				}`,
+			fragmentShader: /* glsl */`
+				uniform float opacity;
+				uniform sampler2D tDiffuse;
+				varying vec2 vUv;
+				void main() {
+					float depth = texture2D( tDiffuse, vUv ).r;
+					#ifdef USE_REVERSED_DEPTH_BUFFER
+						gl_FragColor = vec4( vec3( depth ), opacity );
+					#else
+						gl_FragColor = vec4( vec3( 1.0 - depth ), opacity );
+					#endif
+				}`
 		} );
 		const plane = new PlaneGeometry( frame.width, frame.height );
 		const mesh = new Mesh( plane, material );
@@ -177,7 +191,7 @@ class ShadowMapViewer {
 				//always end up with the scene's first added shadow casting light's shadowMap
 				//in the shader
 				//See: https://github.com/mrdoob/three.js/issues/5932
-				uniforms.tDiffuse.value = light.shadow.map.texture;
+				material.uniforms.tDiffuse.value = light.shadow.map.texture;
 
 				userAutoClearSetting = renderer.autoClear;
 				renderer.autoClear = false; // To allow render overlay

package/examples/jsm/utils/ShadowMapViewerGPU.js

@@ -9,7 +9,7 @@ import {
 	Scene,
 	DepthTexture,
 	Vector2
-} from 'three';
+} from 'three/webgpu';
 import { uv, uniform, textureLoad } from 'three/tsl';
 
 /**

package/examples/jsm/utils/WebGPUTextureUtils.js

@@ -3,7 +3,7 @@ import {
 	NodeMaterial,
 	WebGPURenderer,
 	CanvasTexture
-} from 'three';
+} from 'three/webgpu';
 import { texture, uv } from 'three/tsl';
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plastic-software/three",
-  "version": "0.181.3",
+  "version": "0.183.0",
   "description": "JavaScript 3D library",
   "type": "module",
   "main": "./build/three.cjs",
@@ -46,23 +46,20 @@
     "start": "npm run dev",
     "test": "npm run lint && npm run test-unit && npm run test-unit-addons",
     "build": "rollup -c utils/build/rollup.config.js",
+    "build-docs": "jsdoc -c utils/docs/jsdoc.config.json && npm run build-llms",
+    "build-llms": "node utils/llms/build.js",
     "build-module": "rollup -c utils/build/rollup.config.js --configOnlyModule",
-    "build-docs": "jsdoc -c utils/docs/jsdoc.config.json",
-    "dev": "node utils/build/dev.js && servez -p 8080",
-    "dev-ssl": "node utils/build/dev.js && servez -p 8080 --ssl",
-    "preview": "concurrently --names \"ROLLUP,HTTP\" -c \"bgBlue.bold,bgGreen.bold\" \"rollup -c utils/build/rollup.config.js -w -m inline\" \"servez -p 8080\"",
-    "preview-ssl": "concurrently --names \"ROLLUP,HTTPS\" -c \"bgBlue.bold,bgGreen.bold\" \"rollup -c utils/build/rollup.config.js -w -m inline\" \"servez -p 8080 --ssl\"",
+    "dev": "node utils/build/dev.js && node utils/server.js -p 8080",
+    "preview": "node utils/build/preview.js",
     "lint-core": "eslint src",
-    "lint-addons": "eslint examples/jsm --ext .js --ignore-pattern libs --ignore-pattern ifc",
-    "lint-examples": "eslint examples --ext .html",
-    "lint-docs": "eslint docs --ignore-pattern prettify.js",
-    "lint-editor": "eslint editor --ignore-pattern libs",
-    "lint-playground": "eslint playground --ignore-pattern libs",
-    "lint-manual": "eslint manual --ignore-pattern 3rdparty --ignore-pattern prettify.js --ignore-pattern shapefile.js",
-    "lint-test": "eslint test --ignore-pattern vendor",
-    "lint-utils": "eslint utils --ignore-pattern prettify --ignore-pattern fuse",
+    "lint-addons": "eslint examples/jsm",
+    "lint-examples": "eslint examples",
+    "lint-editor": "eslint editor",
+    "lint-manual": "eslint manual",
+    "lint-test": "eslint test",
+    "lint-utils": "eslint utils",
     "lint": "npm run lint-core",
-    "lint-fix": "npm run lint-core -- --fix && npm run lint-addons -- --fix && npm run lint-examples -- --fix && npm run lint-docs -- --fix && npm run lint-editor -- --fix && npm run lint-playground -- --fix && npm run lint-manual -- --fix && npm run lint-test -- --fix && npm run lint-utils -- --fix",
+    "lint-fix": "npm run lint-core -- --fix && npm run lint-addons -- --fix && npm run lint-examples -- --fix && npm run lint-editor -- --fix && npm run lint-manual -- --fix && npm run lint-test -- --fix && npm run lint-utils -- --fix",
     "test-unit": "qunit test/unit/three.source.unit.js",
     "test-unit-addons": "qunit test/unit/three.addons.unit.js",
     "test-e2e": "node test/e2e/puppeteer.js",
@@ -94,26 +91,23 @@
   },
   "homepage": "https://threejs.org/",
   "devDependencies": {
+    "@eslint/js": "^9.0.0",
     "@rollup/plugin-node-resolve": "^16.0.0",
     "@rollup/plugin-terser": "^0.4.0",
-    "concurrently": "^9.0.0",
-    "eslint": "^8.37.0",
+    "eslint": "^9.0.0",
     "eslint-config-mdcs": "^5.0.0",
     "eslint-plugin-compat": "^6.0.0",
-    "eslint-plugin-html": "^8.0.0",
-    "eslint-plugin-import": "^2.27.5",
-    "jimp": "^1.6.0",
+    "eslint-plugin-html": "^8.1.3",
+    "eslint-plugin-jsdoc": "^62.0.0",
+    "globals": "^17.0.0",
+    "jpeg-js": "^0.4.4",
     "jsdoc": "^4.0.5",
     "magic-string": "^0.30.0",
-    "pixelmatch": "^7.0.0",
+    "pngjs": "^7.0.0",
     "puppeteer": "^24.25.0",
     "qunit": "^2.19.4",
     "rollup": "^4.6.0",
-    "rollup-plugin-filesize": "^10.0.0",
-    "servez": "^2.2.4"
-  },
-  "overrides": {
-    "jpeg-js": "^0.4.4"
+    "turndown": "^7.2.2"
   },
   "jspm": {
     "files": [

package/src/Three.Core.js

@@ -3,7 +3,6 @@ import { warn } from './utils.js';
 
 export { WebGLArrayRenderTarget } from './renderers/WebGLArrayRenderTarget.js';
 export { WebGL3DRenderTarget } from './renderers/WebGL3DRenderTarget.js';
-export { WebGLCubeRenderTarget } from './renderers/WebGLCubeRenderTarget.js';
 export { WebGLRenderTarget } from './renderers/WebGLRenderTarget.js';
 export { WebXRController } from './renderers/webxr/WebXRController.js';
 export { FogExp2 } from './scenes/FogExp2.js';
@@ -35,6 +34,7 @@ export { CompressedCubeTexture } from './textures/CompressedCubeTexture.js';
 export { CubeTexture } from './textures/CubeTexture.js';
 export { CanvasTexture } from './textures/CanvasTexture.js';
 export { DepthTexture } from './textures/DepthTexture.js';
+export { CubeDepthTexture } from './textures/CubeDepthTexture.js';
 export { ExternalTexture } from './textures/ExternalTexture.js';
 export { Texture } from './textures/Texture.js';
 export * from './geometries/Geometries.js';
@@ -110,6 +110,7 @@ export { QuaternionLinearInterpolant } from './math/interpolants/QuaternionLinea
 export { LinearInterpolant } from './math/interpolants/LinearInterpolant.js';
 export { DiscreteInterpolant } from './math/interpolants/DiscreteInterpolant.js';
 export { CubicInterpolant } from './math/interpolants/CubicInterpolant.js';
+export { BezierInterpolant } from './math/interpolants/BezierInterpolant.js';
 export { Interpolant } from './math/Interpolant.js';
 export { Triangle } from './math/Triangle.js';
 export { MathUtils } from './math/MathUtils.js';

package/src/Three.TSL.js

@@ -7,7 +7,7 @@ export const BasicShadowFilter = TSL.BasicShadowFilter;
 export const Break = TSL.Break;
 export const Const = TSL.Const;
 export const Continue = TSL.Continue;
-export const DFGApprox = TSL.DFGApprox;
+export const DFGLUT = TSL.DFGLUT;
 export const D_GGX = TSL.D_GGX;
 export const Discard = TSL.Discard;
 export const EPSILON = TSL.EPSILON;
@@ -29,7 +29,6 @@ export const HALF_PI = TSL.HALF_PI;
 export const PointShadowFilter = TSL.PointShadowFilter;
 export const Return = TSL.Return;
 export const Schlick_to_F0 = TSL.Schlick_to_F0;
-export const ScriptableNodeResources = TSL.ScriptableNodeResources;
 export const ShaderNode = TSL.ShaderNode;
 export const Stack = TSL.Stack;
 export const Switch = TSL.Switch;
@@ -58,7 +57,6 @@ export const arrayBuffer = TSL.arrayBuffer;
 export const asin = TSL.asin;
 export const assign = TSL.assign;
 export const atan = TSL.atan;
-export const atan2 = TSL.atan2;
 export const atomicAdd = TSL.atomicAdd;
 export const atomicAnd = TSL.atomicAnd;
 export const atomicFunc = TSL.atomicFunc;
@@ -98,8 +96,9 @@ export const bool = TSL.bool;
 export const buffer = TSL.buffer;
 export const bufferAttribute = TSL.bufferAttribute;
 export const bumpMap = TSL.bumpMap;
-export const burn = TSL.burn;
 export const builtin = TSL.builtin;
+export const builtinAOContext = TSL.builtinAOContext;
+export const builtinShadowContext = TSL.builtinShadowContext;
 export const bvec2 = TSL.bvec2;
 export const bvec3 = TSL.bvec3;
 export const bvec4 = TSL.bvec4;
@@ -125,6 +124,7 @@ export const clamp = TSL.clamp;
 export const clearcoat = TSL.clearcoat;
 export const clearcoatNormalView = TSL.clearcoatNormalView;
 export const clearcoatRoughness = TSL.clearcoatRoughness;
+export const clipSpace = TSL.clipSpace;
 export const code = TSL.code;
 export const color = TSL.color;
 export const colorSpaceToWorking = TSL.colorSpaceToWorking;
@@ -136,11 +136,13 @@ export const context = TSL.context;
 export const convert = TSL.convert;
 export const convertColorSpace = TSL.convertColorSpace;
 export const convertToTexture = TSL.convertToTexture;
+export const countLeadingZeros = TSL.countLeadingZeros;
+export const countOneBits = TSL.countOneBits;
+export const countTrailingZeros = TSL.countTrailingZeros;
 export const cos = TSL.cos;
 export const cross = TSL.cross;
 export const cubeTexture = TSL.cubeTexture;
 export const cubeTextureBase = TSL.cubeTextureBase;
-export const cubeToUV = TSL.cubeToUV;
 export const dFdx = TSL.dFdx;
 export const dFdy = TSL.dFdy;
 export const dashSize = TSL.dashSize;
@@ -165,17 +167,16 @@ export const directionToFaceDirection = TSL.directionToFaceDirection;
 export const dispersion = TSL.dispersion;
 export const distance = TSL.distance;
 export const div = TSL.div;
-export const dodge = TSL.dodge;
 export const dot = TSL.dot;
 export const drawIndex = TSL.drawIndex;
 export const dynamicBufferAttribute = TSL.dynamicBufferAttribute;
 export const element = TSL.element;
 export const emissive = TSL.emissive;
 export const equal = TSL.equal;
-export const equals = TSL.equals;
 export const equirectUV = TSL.equirectUV;
 export const exp = TSL.exp;
 export const exp2 = TSL.exp2;
+export const exponentialHeightFogFactor = TSL.exponentialHeightFogFactor;
 export const expression = TSL.expression;
 export const faceDirection = TSL.faceDirection;
 export const faceForward = TSL.faceForward;
@@ -199,6 +200,7 @@ export const getDistanceAttenuation = TSL.getDistanceAttenuation;
 export const getGeometryRoughness = TSL.getGeometryRoughness;
 export const getNormalFromDepth = TSL.getNormalFromDepth;
 export const interleavedGradientNoise = TSL.interleavedGradientNoise;
+export const vogelDiskSample = TSL.vogelDiskSample;
 export const getParallaxCorrectNormal = TSL.getParallaxCorrectNormal;
 export const getRoughness = TSL.getRoughness;
 export const getScreenPosition = TSL.getScreenPosition;
@@ -412,8 +414,10 @@ export const oscSquare = TSL.oscSquare;
 export const oscTriangle = TSL.oscTriangle;
 export const output = TSL.output;
 export const outputStruct = TSL.outputStruct;
-export const overlay = TSL.overlay;
 export const overloadingFn = TSL.overloadingFn;
+export const packHalf2x16 = TSL.packHalf2x16;
+export const packSnorm2x16 = TSL.packSnorm2x16;
+export const packUnorm2x16 = TSL.packUnorm2x16;
 export const parabola = TSL.parabola;
 export const parallaxDirection = TSL.parallaxDirection;
 export const parallaxUV = TSL.parallaxUV;
@@ -461,6 +465,7 @@ export const remapClamp = TSL.remapClamp;
 export const renderGroup = TSL.renderGroup;
 export const renderOutput = TSL.renderOutput;
 export const rendererReference = TSL.rendererReference;
+export const replaceDefaultUV = TSL.replaceDefaultUV;
 export const rotate = TSL.rotate;
 export const rotateUV = TSL.rotateUV;
 export const roughness = TSL.roughness;
@@ -478,8 +483,6 @@ export const screenCoordinate = TSL.screenCoordinate;
 export const screenDPR = TSL.screenDPR;
 export const screenSize = TSL.screenSize;
 export const screenUV = TSL.screenUV;
-export const scriptable = TSL.scriptable;
-export const scriptableValue = TSL.scriptableValue;
 export const select = TSL.select;
 export const setCurrentStack = TSL.setCurrentStack;
 export const setName = TSL.setName;
@@ -510,7 +513,6 @@ export const step = TSL.step;
 export const stepElement = TSL.stepElement;
 export const storage = TSL.storage;
 export const storageBarrier = TSL.storageBarrier;
-export const storageObject = TSL.storageObject;
 export const storageTexture = TSL.storageTexture;
 export const string = TSL.string;
 export const struct = TSL.struct;
@@ -579,6 +581,9 @@ export const uniformCubeTexture = TSL.uniformCubeTexture;
 export const uniformGroup = TSL.uniformGroup;
 export const uniformFlow = TSL.uniformFlow;
 export const uniformTexture = TSL.uniformTexture;
+export const unpackHalf2x16 = TSL.unpackHalf2x16;
+export const unpackSnorm2x16 = TSL.unpackSnorm2x16;
+export const unpackUnorm2x16 = TSL.unpackUnorm2x16;
 export const unpremultiplyAlpha = TSL.unpremultiplyAlpha;
 export const userData = TSL.userData;
 export const uv = TSL.uv;
@@ -599,11 +604,14 @@ export const vibrance = TSL.vibrance;
 export const viewZToLogarithmicDepth = TSL.viewZToLogarithmicDepth;
 export const viewZToOrthographicDepth = TSL.viewZToOrthographicDepth;
 export const viewZToPerspectiveDepth = TSL.viewZToPerspectiveDepth;
+export const viewZToReversedOrthographicDepth = TSL.viewZToReversedOrthographicDepth;
+export const viewZToReversedPerspectiveDepth = TSL.viewZToReversedPerspectiveDepth;
 export const viewport = TSL.viewport;
 export const viewportCoordinate = TSL.viewportCoordinate;
 export const viewportDepthTexture = TSL.viewportDepthTexture;
 export const viewportLinearDepth = TSL.viewportLinearDepth;
 export const viewportMipTexture = TSL.viewportMipTexture;
+export const viewportOpaqueMipTexture = TSL.viewportOpaqueMipTexture;
 export const viewportResolution = TSL.viewportResolution;
 export const viewportSafeUV = TSL.viewportSafeUV;
 export const viewportSharedTexture = TSL.viewportSharedTexture;

package/src/Three.WebGPU.Nodes.js

@@ -6,6 +6,7 @@ export { default as Lighting } from './renderers/common/Lighting.js';
 export { default as BundleGroup } from './renderers/common/BundleGroup.js';
 export { default as QuadMesh } from './renderers/common/QuadMesh.js';
 export { default as PMREMGenerator } from './renderers/common/extras/PMREMGenerator.js';
+export { default as RenderPipeline } from './renderers/common/RenderPipeline.js';
 export { default as PostProcessing } from './renderers/common/PostProcessing.js';
 import * as RendererUtils from './renderers/common/RendererUtils.js';
 export { RendererUtils };
@@ -20,6 +21,7 @@ export { default as NodeObjectLoader } from './loaders/nodes/NodeObjectLoader.js
 export { default as NodeMaterialLoader } from './loaders/nodes/NodeMaterialLoader.js';
 export { default as InspectorBase } from './renderers/common/InspectorBase.js';
 export { default as CanvasTarget } from './renderers/common/CanvasTarget.js';
+export { default as BlendMode } from './renderers/common/BlendMode.js';
 export { ClippingGroup } from './objects/ClippingGroup.js';
 export * from './nodes/Nodes.js';
 import * as TSL from './nodes/TSL.js';

package/src/Three.WebGPU.js

@@ -6,9 +6,11 @@ export { default as Lighting } from './renderers/common/Lighting.js';
 export { default as BundleGroup } from './renderers/common/BundleGroup.js';
 export { default as QuadMesh } from './renderers/common/QuadMesh.js';
 export { default as PMREMGenerator } from './renderers/common/extras/PMREMGenerator.js';
+export { default as RenderPipeline } from './renderers/common/RenderPipeline.js';
 export { default as PostProcessing } from './renderers/common/PostProcessing.js';
 import * as RendererUtils from './renderers/common/RendererUtils.js';
 export { RendererUtils };
+export { default as CubeRenderTarget } from './renderers/common/CubeRenderTarget.js';
 export { default as StorageTexture } from './renderers/common/StorageTexture.js';
 export { default as Storage3DTexture } from './renderers/common/Storage3DTexture.js';
 export { default as StorageArrayTexture } from './renderers/common/StorageArrayTexture.js';
@@ -22,6 +24,7 @@ export { default as NodeObjectLoader } from './loaders/nodes/NodeObjectLoader.js
 export { default as NodeMaterialLoader } from './loaders/nodes/NodeMaterialLoader.js';
 export { default as InspectorBase } from './renderers/common/InspectorBase.js';
 export { default as CanvasTarget } from './renderers/common/CanvasTarget.js';
+export { default as BlendMode } from './renderers/common/BlendMode.js';
 export { ClippingGroup } from './objects/ClippingGroup.js';
 export * from './nodes/Nodes.js';
 import * as TSL from './nodes/TSL.js';

package/src/Three.js

@@ -1,6 +1,7 @@
 export * from './Three.Core.js';
 
 export { WebGLRenderer } from './renderers/WebGLRenderer.js';
+export { WebGLCubeRenderTarget } from './renderers/WebGLCubeRenderTarget.js';
 export { ShaderLib } from './renderers/shaders/ShaderLib.js';
 export { UniformsLib } from './renderers/shaders/UniformsLib.js';
 export { UniformsUtils } from './renderers/shaders/UniformsUtils.js';

package/src/animation/AnimationAction.js

@@ -548,7 +548,7 @@ class AnimationAction {
 
 	}
 
-	// Interna
+	// Internal
 
 	_update( time, deltaTime, timeDirection, accuIndex ) {
 

package/src/animation/AnimationClip.js

@@ -301,7 +301,7 @@ class AnimationClip {
 	 * @static
 	 * @deprecated since r175.
 	 * @param {Object} animation - A serialized animation clip as JSON.
-	 * @param {Array<Bones>} bones - An array of bones.
+	 * @param {Array<Bone>} bones - An array of bones.
 	 * @return {?AnimationClip} The new animation clip.
 	 */
 	static parseAnimation( animation, bones ) {

package/src/animation/AnimationMixer.js

@@ -48,6 +48,12 @@ class AnimationMixer extends EventDispatcher {
 		 */
 		this.timeScale = 1.0;
 
+		if ( typeof __THREE_DEVTOOLS__ !== 'undefined' ) {
+
+			__THREE_DEVTOOLS__.dispatchEvent( new CustomEvent( 'observe', { detail: this } ) );
+
+		}
+
 	}
 
 	_bindAction( action, prototypeAction ) {

package/src/animation/AnimationUtils.js

@@ -1,5 +1,6 @@
 import { Quaternion } from '../math/Quaternion.js';
 import { AdditiveAnimationBlendMode } from '../constants.js';
+import { isTypedArray } from '../utils.js';
 
 /**
  * Converts an array to a specific type.
@@ -22,18 +23,6 @@ function convertArray( array, type ) {
 
 }
 
-/**
- * Returns `true` if the given object is a typed array.
- *
- * @param {any} object - The object to check.
- * @return {boolean} Whether the given object is a typed array.
- */
-function isTypedArray( object ) {
-
-	return ArrayBuffer.isView( object ) && ! ( object instanceof DataView );
-
-}
-
 /**
  * Returns an array by which times and values can be sorted.
  *