@gnsx/three 0.184.0

package/src/renderers/common/ClippingContext.js

@@ -0,0 +1,262 @@
+import { Matrix3 } from '../../math/Matrix3.js';
+import { Plane } from '../../math/Plane.js';
+import { Vector4 } from '../../math/Vector4.js';
+
+const _plane = /*@__PURE__*/ new Plane();
+
+/**
+ * Represents the state that is used to perform clipping via clipping planes.
+ * There is a default clipping context for each render context. When the
+ * scene holds instances of `ClippingGroup`, there will be a context for each
+ * group.
+ *
+ * @private
+ */
+class ClippingContext {
+
+	/**
+	 * Constructs a new clipping context.
+	 *
+	 * @param {?ClippingContext} [parentContext=null] - A reference to the parent clipping context.
+	 */
+	constructor( parentContext = null ) {
+
+		/**
+		 * The clipping context's version.
+		 *
+		 * @type {number}
+		 * @readonly
+		 */
+		this.version = 0;
+
+		/**
+		 * Whether the intersection of the clipping planes is used to clip objects, rather than their union.
+		 *
+		 * @type {?boolean}
+		 * @default null
+		 */
+		this.clipIntersection = null;
+
+		/**
+		 * The clipping context's cache key.
+		 *
+		 * @type {string}
+		 */
+		this.cacheKey = '';
+
+		/**
+		 * Whether the shadow pass is active or not.
+		 *
+		 * @type {boolean}
+		 * @default false
+		 */
+		this.shadowPass = false;
+
+		/**
+		 * The view normal matrix.
+		 *
+		 * @type {Matrix3}
+		 */
+		this.viewNormalMatrix = new Matrix3();
+
+		/**
+		 * Internal cache for maintaining clipping contexts.
+		 *
+		 * @type {WeakMap<ClippingGroup,ClippingContext>}
+		 */
+		this.clippingGroupContexts = new WeakMap();
+
+		/**
+		 * The intersection planes.
+		 *
+		 * @type {Array<Vector4>}
+		 */
+		this.intersectionPlanes = [];
+
+		/**
+		 * The intersection planes.
+		 *
+		 * @type {Array<Vector4>}
+		 */
+		this.unionPlanes = [];
+
+		/**
+		 * The version of the clipping context's parent context.
+		 *
+		 * @type {?number}
+		 * @readonly
+		 */
+		this.parentVersion = null;
+
+		if ( parentContext !== null ) {
+
+			this.viewNormalMatrix = parentContext.viewNormalMatrix;
+			this.clippingGroupContexts = parentContext.clippingGroupContexts;
+
+			this.shadowPass = parentContext.shadowPass;
+			this.viewMatrix = parentContext.viewMatrix;
+
+		}
+
+	}
+
+	/**
+	 * Projects the given source clipping planes and writes the result into the
+	 * destination array.
+	 *
+	 * @param {Array<Plane>} source - The source clipping planes.
+	 * @param {Array<Vector4>} destination - The destination.
+	 * @param {number} offset - The offset.
+	 */
+	projectPlanes( source, destination, offset ) {
+
+		const l = source.length;
+
+		for ( let i = 0; i < l; i ++ ) {
+
+			_plane.copy( source[ i ] ).applyMatrix4( this.viewMatrix, this.viewNormalMatrix );
+
+			const v = destination[ offset + i ];
+			const normal = _plane.normal;
+
+			v.x = - normal.x;
+			v.y = - normal.y;
+			v.z = - normal.z;
+			v.w = _plane.constant;
+
+		}
+
+	}
+
+	/**
+	 * Updates the root clipping context of a scene.
+	 *
+	 * @param {Scene} scene - The scene.
+	 * @param {Camera} camera - The camera that is used to render the scene.
+	 */
+	updateGlobal( scene, camera ) {
+
+		this.shadowPass = ( scene.overrideMaterial !== null && scene.overrideMaterial.isShadowPassMaterial );
+		this.viewMatrix = camera.matrixWorldInverse;
+
+		this.viewNormalMatrix.getNormalMatrix( this.viewMatrix );
+
+	}
+
+	/**
+	 * Updates the clipping context.
+	 *
+	 * @param {ClippingContext} parentContext - The parent context.
+	 * @param {ClippingGroup} clippingGroup - The clipping group this context belongs to.
+	 */
+	update( parentContext, clippingGroup ) {
+
+		let update = false;
+
+		if ( parentContext.version !== this.parentVersion ) {
+
+			this.intersectionPlanes = Array.from( parentContext.intersectionPlanes );
+			this.unionPlanes = Array.from( parentContext.unionPlanes );
+			this.parentVersion = parentContext.version;
+
+		}
+
+		if ( this.clipIntersection !== clippingGroup.clipIntersection ) {
+
+			this.clipIntersection = clippingGroup.clipIntersection;
+
+			if ( this.clipIntersection ) {
+
+				this.unionPlanes.length = parentContext.unionPlanes.length;
+
+			} else {
+
+				this.intersectionPlanes.length = parentContext.intersectionPlanes.length;
+
+			}
+
+		}
+
+		const srcClippingPlanes = clippingGroup.clippingPlanes;
+		const l = srcClippingPlanes.length;
+
+		let dstClippingPlanes;
+		let offset;
+
+		if ( this.clipIntersection ) {
+
+			dstClippingPlanes = this.intersectionPlanes;
+			offset = parentContext.intersectionPlanes.length;
+
+		} else {
+
+			dstClippingPlanes = this.unionPlanes;
+			offset = parentContext.unionPlanes.length;
+
+		}
+
+		if ( dstClippingPlanes.length !== offset + l ) {
+
+			dstClippingPlanes.length = offset + l;
+
+			for ( let i = 0; i < l; i ++ ) {
+
+				dstClippingPlanes[ offset + i ] = new Vector4();
+
+			}
+
+			update = true;
+
+		}
+
+		this.projectPlanes( srcClippingPlanes, dstClippingPlanes, offset );
+
+		if ( update ) {
+
+			this.version ++;
+			this.cacheKey = `${ this.intersectionPlanes.length }:${ this.unionPlanes.length }`;
+
+		}
+
+	}
+
+	/**
+	 * Returns a clipping context for the given clipping group.
+	 *
+	 * @param {ClippingGroup} clippingGroup - The clipping group.
+	 * @return {ClippingContext} The clipping context.
+	 */
+	getGroupContext( clippingGroup ) {
+
+		if ( this.shadowPass && ! clippingGroup.clipShadows ) return this;
+
+		let context = this.clippingGroupContexts.get( clippingGroup );
+
+		if ( context === undefined ) {
+
+			context = new ClippingContext( this );
+			this.clippingGroupContexts.set( clippingGroup, context );
+
+		}
+
+		context.update( this, clippingGroup );
+
+		return context;
+
+	}
+
+	/**
+	 * The count of union clipping planes.
+	 *
+	 * @type {number}
+	 * @readonly
+	 */
+	get unionClippingCount() {
+
+		return this.unionPlanes.length;
+
+	}
+
+}
+
+export default ClippingContext;

package/src/renderers/common/Color4.js

@@ -0,0 +1,77 @@
+import { Color } from '../../math/Color.js';
+
+/**
+ * A four-component version of {@link Color} which is internally
+ * used by the renderer to represents clear color with alpha as
+ * one object.
+ *
+ * @private
+ * @augments Color
+ */
+class Color4 extends Color {
+
+	/**
+	 * Constructs a new four-component color.
+	 * You can also pass a single THREE.Color, hex or
+	 * string argument to this constructor.
+	 *
+	 * @param {number|string} [r=1] - The red value.
+	 * @param {number} [g=1] - The green value.
+	 * @param {number} [b=1] - The blue value.
+	 * @param {number} [a=1] - The alpha value.
+	 */
+	constructor( r, g, b, a = 1 ) {
+
+		super( r, g, b );
+
+		this.a = a;
+
+	}
+
+	/**
+	 * Overwrites the default to honor alpha.
+	 * You can also pass a single THREE.Color, hex or
+	 * string argument to this method.
+	 *
+	 * @param {number|string|Color} r - The red value.
+	 * @param {number} [g] - The green value.
+	 * @param {number} [b] - The blue value.
+	 * @param {number} [a=1] - The alpha value.
+	 * @return {Color4} A reference to this object.
+	 */
+	set( r, g, b, a = 1 ) {
+
+		this.a = a;
+
+		return super.set( r, g, b );
+
+	}
+
+	/**
+	 * Overwrites the default to honor alpha.
+	 *
+	 * @param {Color4} color - The color to copy.
+	 * @return {Color4} A reference to this object.
+	 */
+	copy( color ) {
+
+		if ( color.a !== undefined ) this.a = color.a;
+
+		return super.copy( color );
+
+	}
+
+	/**
+	 * Overwrites the default to honor alpha.
+	 *
+	 * @return {Color4} The cloned color.
+	 */
+	clone() {
+
+		return new this.constructor( this.r, this.g, this.b, this.a );
+
+	}
+
+}
+
+export default Color4;

package/src/renderers/common/ComputePipeline.js

@@ -0,0 +1,41 @@
+import Pipeline from './Pipeline.js';
+
+/**
+ * Class for representing compute pipelines.
+ *
+ * @private
+ * @augments Pipeline
+ */
+class ComputePipeline extends Pipeline {
+
+	/**
+	 * Constructs a new compute pipeline.
+	 *
+	 * @param {string} cacheKey - The pipeline's cache key.
+	 * @param {ProgrammableStage} computeProgram - The pipeline's compute shader.
+	 */
+	constructor( cacheKey, computeProgram ) {
+
+		super( cacheKey );
+
+		/**
+		 * The pipeline's compute shader.
+		 *
+		 * @type {ProgrammableStage}
+		 */
+		this.computeProgram = computeProgram;
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isComputePipeline = true;
+
+	}
+
+}
+
+export default ComputePipeline;

package/src/renderers/common/Constants.js

@@ -0,0 +1,15 @@
+export const AttributeType = {
+	VERTEX: 1,
+	INDEX: 2,
+	STORAGE: 3,
+	INDIRECT: 4
+};
+
+// size of a chunk in bytes (STD140 layout)
+
+export const GPU_CHUNK_BYTES = 16;
+
+// @TODO: Move to src/constants.js
+
+export const BlendColorFactor = 211;
+export const OneMinusBlendColorFactor = 212;

package/src/renderers/common/CubeRenderTarget.js

@@ -0,0 +1,147 @@
+import { equirectUV } from '../../nodes/utils/EquirectUV.js';
+import { texture as TSL_Texture } from '../../nodes/accessors/TextureNode.js';
+import { positionWorldDirection } from '../../nodes/accessors/Position.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
+
+import { RenderTarget } from '../../core/RenderTarget.js';
+import { Scene } from '../../scenes/Scene.js';
+import { CubeCamera } from '../../cameras/CubeCamera.js';
+import { BoxGeometry } from '../../geometries/BoxGeometry.js';
+import { Mesh } from '../../objects/Mesh.js';
+import { CubeTexture } from '../../textures/CubeTexture.js';
+import { BackSide, NoBlending, LinearFilter, LinearMipmapLinearFilter } from '../../constants.js';
+
+/**
+ * This class represents a cube render target. It is a special version
+ * of `WebGLCubeRenderTarget` which is compatible with `WebGPURenderer`.
+ *
+ * @augments RenderTarget
+ */
+class CubeRenderTarget extends RenderTarget {
+
+	/**
+	 * Constructs a new cube render target.
+	 *
+	 * @param {number} [size=1] - The size of the render target.
+	 * @param {RenderTarget~Options} [options] - The configuration object.
+	 */
+	constructor( size = 1, options = {} ) {
+
+		super( size, size, options );
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isCubeRenderTarget = true;
+
+		const image = { width: size, height: size, depth: 1 };
+		const images = [ image, image, image, image, image, image ];
+
+		/**
+		 * Overwritten with a different texture type.
+		 *
+		 * @type {DataArrayTexture}
+		 */
+		this.texture = new CubeTexture( images );
+		this._setTextureOptions( options );
+
+		// By convention -- likely based on the RenderMan spec from the 1990's -- cube maps are specified by WebGL (and three.js)
+		// in a coordinate system in which positive-x is to the right when looking up the positive-z axis -- in other words,
+		// in a left-handed coordinate system. By continuing this convention, preexisting cube maps continued to render correctly.
+
+		// three.js uses a right-handed coordinate system. So environment maps used in three.js appear to have px and nx swapped
+		// and the flag isRenderTargetTexture controls this conversion. The flip is not required when using WebGLCubeRenderTarget.texture
+		// as a cube texture (this is detected when isRenderTargetTexture is set to true for cube textures).
+
+		this.texture.isRenderTargetTexture = true;
+
+	}
+
+	/**
+	 * Converts the given equirectangular texture to a cube map.
+	 *
+	 * @param {Renderer} renderer - The renderer.
+	 * @param {Texture} texture - The equirectangular texture.
+	 * @return {CubeRenderTarget} A reference to this cube render target.
+	 */
+	fromEquirectangularTexture( renderer, texture ) {
+
+		const currentMinFilter = texture.minFilter;
+		const currentGenerateMipmaps = texture.generateMipmaps;
+
+		texture.generateMipmaps = true;
+
+		this.texture.type = texture.type;
+		this.texture.colorSpace = texture.colorSpace;
+
+		this.texture.generateMipmaps = texture.generateMipmaps;
+		this.texture.minFilter = texture.minFilter;
+		this.texture.magFilter = texture.magFilter;
+
+		const geometry = new BoxGeometry( 5, 5, 5 );
+
+		const uvNode = equirectUV( positionWorldDirection );
+
+		const material = new NodeMaterial();
+		material.colorNode = TSL_Texture( texture, uvNode, 0 );
+		material.side = BackSide;
+		material.blending = NoBlending;
+
+		const mesh = new Mesh( geometry, material );
+
+		const scene = new Scene();
+		scene.add( mesh );
+
+		// Avoid blurred poles
+		if ( texture.minFilter === LinearMipmapLinearFilter ) texture.minFilter = LinearFilter;
+
+		const camera = new CubeCamera( 1, 10, this );
+
+		const currentMRT = renderer.getMRT();
+		renderer.setMRT( null );
+
+		camera.update( renderer, scene );
+
+		renderer.setMRT( currentMRT );
+
+		texture.minFilter = currentMinFilter;
+		texture.generateMipmaps = currentGenerateMipmaps;
+
+		mesh.geometry.dispose();
+		mesh.material.dispose();
+
+		return this;
+
+	}
+
+	/**
+	 * Clears this cube render target.
+	 *
+	 * @param {Renderer} renderer - The renderer.
+	 * @param {boolean} [color=true] - Whether the color buffer should be cleared or not.
+	 * @param {boolean} [depth=true] - Whether the depth buffer should be cleared or not.
+	 * @param {boolean} [stencil=true] - Whether the stencil buffer should be cleared or not.
+	 */
+	clear( renderer, color = true, depth = true, stencil = true ) {
+
+		const currentRenderTarget = renderer.getRenderTarget();
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			renderer.setRenderTarget( this, i );
+
+			renderer.clear( color, depth, stencil );
+
+		}
+
+		renderer.setRenderTarget( currentRenderTarget );
+
+	}
+
+}
+
+export default CubeRenderTarget;

package/src/renderers/common/DataMap.js

@@ -0,0 +1,90 @@
+/**
+ * Data structure for the renderer. It is intended to manage
+ * data of objects in dictionaries.
+ *
+ * @private
+ */
+class DataMap {
+
+	/**
+	 * Constructs a new data map.
+	 */
+	constructor() {
+
+		/**
+		 * `DataMap` internally uses a weak map
+		 * to manage its data.
+		 *
+		 * @type {WeakMap<Object, Object>}
+		 */
+		this.data = new WeakMap();
+
+	}
+
+	/**
+	 * Returns the dictionary for the given object.
+	 *
+	 * @param {Object} object - The object.
+	 * @return {Object} The dictionary.
+	 */
+	get( object ) {
+
+		let map = this.data.get( object );
+
+		if ( map === undefined ) {
+
+			map = {};
+			this.data.set( object, map );
+
+		}
+
+		return map;
+
+	}
+
+	/**
+	 * Deletes the dictionary for the given object.
+	 *
+	 * @param {Object} object - The object.
+	 * @return {?Object} The deleted dictionary.
+	 */
+	delete( object ) {
+
+		let map = null;
+
+		if ( this.data.has( object ) ) {
+
+			map = this.data.get( object );
+
+			this.data.delete( object );
+
+		}
+
+		return map;
+
+	}
+
+	/**
+	 * Returns `true` if the given object has a dictionary defined.
+	 *
+	 * @param {Object} object - The object to test.
+	 * @return {boolean} Whether a dictionary is defined or not.
+	 */
+	has( object ) {
+
+		return this.data.has( object );
+
+	}
+
+	/**
+	 * Frees internal resources.
+	 */
+	dispose() {
+
+		this.data = new WeakMap();
+
+	}
+
+}
+
+export default DataMap;