@needle-tools/three 0.146.10 → 0.153.1

package/examples/js/misc/GPUComputationRenderer.js

@@ -1,393 +0,0 @@
-( function () {
-
-	/**
- * GPUComputationRenderer, based on SimulationRenderer by zz85
- *
- * The GPUComputationRenderer uses the concept of variables. These variables are RGBA float textures that hold 4 floats
- * for each compute element (texel)
- *
- * Each variable has a fragment shader that defines the computation made to obtain the variable in question.
- * You can use as many variables you need, and make dependencies so you can use textures of other variables in the shader
- * (the sampler uniforms are added automatically) Most of the variables will need themselves as dependency.
- *
- * The renderer has actually two render targets per variable, to make ping-pong. Textures from the current frame are used
- * as inputs to render the textures of the next frame.
- *
- * The render targets of the variables can be used as input textures for your visualization shaders.
- *
- * Variable names should be valid identifiers and should not collide with THREE GLSL used identifiers.
- * a common approach could be to use 'texture' prefixing the variable name; i.e texturePosition, textureVelocity...
- *
- * The size of the computation (sizeX * sizeY) is defined as 'resolution' automatically in the shader. For example:
- * #DEFINE resolution vec2( 1024.0, 1024.0 )
- *
- * -------------
- *
- * Basic use:
- *
- * // Initialization...
- *
- * // Create computation renderer
- * const gpuCompute = new GPUComputationRenderer( 1024, 1024, renderer );
- *
- * // Create initial state float textures
- * const pos0 = gpuCompute.createTexture();
- * const vel0 = gpuCompute.createTexture();
- * // and fill in here the texture data...
- *
- * // Add texture variables
- * const velVar = gpuCompute.addVariable( "textureVelocity", fragmentShaderVel, pos0 );
- * const posVar = gpuCompute.addVariable( "texturePosition", fragmentShaderPos, vel0 );
- *
- * // Add variable dependencies
- * gpuCompute.setVariableDependencies( velVar, [ velVar, posVar ] );
- * gpuCompute.setVariableDependencies( posVar, [ velVar, posVar ] );
- *
- * // Add custom uniforms
- * velVar.material.uniforms.time = { value: 0.0 };
- *
- * // Check for completeness
- * const error = gpuCompute.init();
- * if ( error !== null ) {
- *		console.error( error );
-  * }
- *
- *
- * // In each frame...
- *
- * // Compute!
- * gpuCompute.compute();
- *
- * // Update texture uniforms in your visualization materials with the gpu renderer output
- * myMaterial.uniforms.myTexture.value = gpuCompute.getCurrentRenderTarget( posVar ).texture;
- *
- * // Do your rendering
- * renderer.render( myScene, myCamera );
- *
- * -------------
- *
- * Also, you can use utility functions to create THREE.ShaderMaterial and perform computations (rendering between textures)
- * Note that the shaders can have multiple input textures.
- *
- * const myFilter1 = gpuCompute.createShaderMaterial( myFilterFragmentShader1, { theTexture: { value: null } } );
- * const myFilter2 = gpuCompute.createShaderMaterial( myFilterFragmentShader2, { theTexture: { value: null } } );
- *
- * const inputTexture = gpuCompute.createTexture();
- *
- * // Fill in here inputTexture...
- *
- * myFilter1.uniforms.theTexture.value = inputTexture;
- *
- * const myRenderTarget = gpuCompute.createRenderTarget();
- * myFilter2.uniforms.theTexture.value = myRenderTarget.texture;
- *
- * const outputRenderTarget = gpuCompute.createRenderTarget();
- *
- * // Now use the output texture where you want:
- * myMaterial.uniforms.map.value = outputRenderTarget.texture;
- *
- * // And compute each frame, before rendering to screen:
- * gpuCompute.doRenderTarget( myFilter1, myRenderTarget );
- * gpuCompute.doRenderTarget( myFilter2, outputRenderTarget );
- *
- *
- *
- * @param {int} sizeX Computation problem size is always 2d: sizeX * sizeY elements.
- * @param {int} sizeY Computation problem size is always 2d: sizeX * sizeY elements.
- * @param {WebGLRenderer} renderer The renderer
-  */
-
-	class GPUComputationRenderer {
-
-		constructor( sizeX, sizeY, renderer ) {
-
-			this.variables = [];
-			this.currentTextureIndex = 0;
-			let dataType = THREE.FloatType;
-			const scene = new THREE.Scene();
-			const camera = new THREE.Camera();
-			camera.position.z = 1;
-			const passThruUniforms = {
-				passThruTexture: {
-					value: null
-				}
-			};
-			const passThruShader = createShaderMaterial( getPassThroughFragmentShader(), passThruUniforms );
-			const mesh = new THREE.Mesh( new THREE.PlaneGeometry( 2, 2 ), passThruShader );
-			scene.add( mesh );
-			this.setDataType = function ( type ) {
-
-				dataType = type;
-				return this;
-
-			};
-
-			this.addVariable = function ( variableName, computeFragmentShader, initialValueTexture ) {
-
-				const material = this.createShaderMaterial( computeFragmentShader );
-				const variable = {
-					name: variableName,
-					initialValueTexture: initialValueTexture,
-					material: material,
-					dependencies: null,
-					renderTargets: [],
-					wrapS: null,
-					wrapT: null,
-					minFilter: THREE.NearestFilter,
-					magFilter: THREE.NearestFilter
-				};
-				this.variables.push( variable );
-				return variable;
-
-			};
-
-			this.setVariableDependencies = function ( variable, dependencies ) {
-
-				variable.dependencies = dependencies;
-
-			};
-
-			this.init = function () {
-
-				if ( renderer.capabilities.isWebGL2 === false && renderer.extensions.has( 'OES_texture_float' ) === false ) {
-
-					return 'No OES_texture_float support for float textures.';
-
-				}
-
-				if ( renderer.capabilities.maxVertexTextures === 0 ) {
-
-					return 'No support for vertex shader textures.';
-
-				}
-
-				for ( let i = 0; i < this.variables.length; i ++ ) {
-
-					const variable = this.variables[ i ];
-
-					// Creates rendertargets and initialize them with input texture
-					variable.renderTargets[ 0 ] = this.createRenderTarget( sizeX, sizeY, variable.wrapS, variable.wrapT, variable.minFilter, variable.magFilter );
-					variable.renderTargets[ 1 ] = this.createRenderTarget( sizeX, sizeY, variable.wrapS, variable.wrapT, variable.minFilter, variable.magFilter );
-					this.renderTexture( variable.initialValueTexture, variable.renderTargets[ 0 ] );
-					this.renderTexture( variable.initialValueTexture, variable.renderTargets[ 1 ] );
-
-					// Adds dependencies uniforms to the THREE.ShaderMaterial
-					const material = variable.material;
-					const uniforms = material.uniforms;
-					if ( variable.dependencies !== null ) {
-
-						for ( let d = 0; d < variable.dependencies.length; d ++ ) {
-
-							const depVar = variable.dependencies[ d ];
-							if ( depVar.name !== variable.name ) {
-
-								// Checks if variable exists
-								let found = false;
-								for ( let j = 0; j < this.variables.length; j ++ ) {
-
-									if ( depVar.name === this.variables[ j ].name ) {
-
-										found = true;
-										break;
-
-									}
-
-								}
-
-								if ( ! found ) {
-
-									return 'Variable dependency not found. Variable=' + variable.name + ', dependency=' + depVar.name;
-
-								}
-
-							}
-
-							uniforms[ depVar.name ] = {
-								value: null
-							};
-							material.fragmentShader = '\nuniform sampler2D ' + depVar.name + ';\n' + material.fragmentShader;
-
-						}
-
-					}
-
-				}
-
-				this.currentTextureIndex = 0;
-				return null;
-
-			};
-
-			this.compute = function () {
-
-				const currentTextureIndex = this.currentTextureIndex;
-				const nextTextureIndex = this.currentTextureIndex === 0 ? 1 : 0;
-				for ( let i = 0, il = this.variables.length; i < il; i ++ ) {
-
-					const variable = this.variables[ i ];
-
-					// Sets texture dependencies uniforms
-					if ( variable.dependencies !== null ) {
-
-						const uniforms = variable.material.uniforms;
-						for ( let d = 0, dl = variable.dependencies.length; d < dl; d ++ ) {
-
-							const depVar = variable.dependencies[ d ];
-							uniforms[ depVar.name ].value = depVar.renderTargets[ currentTextureIndex ].texture;
-
-						}
-
-					}
-
-					// Performs the computation for this variable
-					this.doRenderTarget( variable.material, variable.renderTargets[ nextTextureIndex ] );
-
-				}
-
-				this.currentTextureIndex = nextTextureIndex;
-
-			};
-
-			this.getCurrentRenderTarget = function ( variable ) {
-
-				return variable.renderTargets[ this.currentTextureIndex ];
-
-			};
-
-			this.getAlternateRenderTarget = function ( variable ) {
-
-				return variable.renderTargets[ this.currentTextureIndex === 0 ? 1 : 0 ];
-
-			};
-
-			this.dispose = function () {
-
-				mesh.geometry.dispose();
-				mesh.material.dispose();
-				const variables = this.variables;
-				for ( let i = 0; i < variables.length; i ++ ) {
-
-					const variable = variables[ i ];
-					variable.initialValueTexture?.dispose();
-					const renderTargets = variable.renderTargets;
-					for ( let j = 0; j < renderTargets.length; j ++ ) {
-
-						const renderTarget = renderTargets[ j ];
-						renderTarget.dispose();
-
-					}
-
-				}
-
-			};
-
-			function addResolutionDefine( materialShader ) {
-
-				materialShader.defines.resolution = 'vec2( ' + sizeX.toFixed( 1 ) + ', ' + sizeY.toFixed( 1 ) + ' )';
-
-			}
-
-			this.addResolutionDefine = addResolutionDefine;
-
-			// The following functions can be used to compute things manually
-
-			function createShaderMaterial( computeFragmentShader, uniforms ) {
-
-				uniforms = uniforms || {};
-				const material = new THREE.ShaderMaterial( {
-					uniforms: uniforms,
-					vertexShader: getPassThroughVertexShader(),
-					fragmentShader: computeFragmentShader
-				} );
-				addResolutionDefine( material );
-				return material;
-
-			}
-
-			this.createShaderMaterial = createShaderMaterial;
-			this.createRenderTarget = function ( sizeXTexture, sizeYTexture, wrapS, wrapT, minFilter, magFilter ) {
-
-				sizeXTexture = sizeXTexture || sizeX;
-				sizeYTexture = sizeYTexture || sizeY;
-				wrapS = wrapS || THREE.ClampToEdgeWrapping;
-				wrapT = wrapT || THREE.ClampToEdgeWrapping;
-				minFilter = minFilter || THREE.NearestFilter;
-				magFilter = magFilter || THREE.NearestFilter;
-				const renderTarget = new THREE.WebGLRenderTarget( sizeXTexture, sizeYTexture, {
-					wrapS: wrapS,
-					wrapT: wrapT,
-					minFilter: minFilter,
-					magFilter: magFilter,
-					format: THREE.RGBAFormat,
-					type: dataType,
-					depthBuffer: false
-				} );
-				return renderTarget;
-
-			};
-
-			this.createTexture = function () {
-
-				const data = new Float32Array( sizeX * sizeY * 4 );
-				const texture = new THREE.DataTexture( data, sizeX, sizeY, THREE.RGBAFormat, THREE.FloatType );
-				texture.needsUpdate = true;
-				return texture;
-
-			};
-
-			this.renderTexture = function ( input, output ) {
-
-				// Takes a texture, and render out in rendertarget
-				// input = Texture
-				// output = RenderTarget
-
-				passThruUniforms.passThruTexture.value = input;
-				this.doRenderTarget( passThruShader, output );
-				passThruUniforms.passThruTexture.value = null;
-
-			};
-
-			this.doRenderTarget = function ( material, output ) {
-
-				const currentRenderTarget = renderer.getRenderTarget();
-				const currentXrEnabled = renderer.xr.enabled;
-				const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-				const currentOutputEncoding = renderer.outputEncoding;
-				const currentToneMapping = renderer.toneMapping;
-				renderer.xr.enabled = false; // Avoid camera modification
-				renderer.shadowMap.autoUpdate = false; // Avoid re-computing shadows
-				renderer.outputEncoding = THREE.LinearEncoding;
-				renderer.toneMapping = THREE.NoToneMapping;
-				mesh.material = material;
-				renderer.setRenderTarget( output );
-				renderer.render( scene, camera );
-				mesh.material = passThruShader;
-				renderer.xr.enabled = currentXrEnabled;
-				renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-				renderer.outputEncoding = currentOutputEncoding;
-				renderer.toneMapping = currentToneMapping;
-				renderer.setRenderTarget( currentRenderTarget );
-
-			};
-
-			// Shaders
-
-			function getPassThroughVertexShader() {
-
-				return 'void main()	{\n' + '\n' + '	gl_Position = vec4( position, 1.0 );\n' + '\n' + '}\n';
-
-			}
-
-			function getPassThroughFragmentShader() {
-
-				return 'uniform sampler2D passThruTexture;\n' + '\n' + 'void main() {\n' + '\n' + '	vec2 uv = gl_FragCoord.xy / resolution.xy;\n' + '\n' + '	gl_FragColor = texture2D( passThruTexture, uv );\n' + '\n' + '}\n';
-
-			}
-
-		}
-
-	}
-
-	THREE.GPUComputationRenderer = GPUComputationRenderer;
-
-} )();

package/examples/js/misc/Gyroscope.js

@@ -1,56 +0,0 @@
-( function () {
-
-	const _translationObject = new THREE.Vector3();
-	const _quaternionObject = new THREE.Quaternion();
-	const _scaleObject = new THREE.Vector3();
-	const _translationWorld = new THREE.Vector3();
-	const _quaternionWorld = new THREE.Quaternion();
-	const _scaleWorld = new THREE.Vector3();
-	class Gyroscope extends THREE.Object3D {
-
-		constructor() {
-
-			super();
-
-		}
-		updateMatrixWorld( force ) {
-
-			this.matrixAutoUpdate && this.updateMatrix();
-
-			// update matrixWorld
-
-			if ( this.matrixWorldNeedsUpdate || force ) {
-
-				if ( this.parent !== null ) {
-
-					this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );
-					this.matrixWorld.decompose( _translationWorld, _quaternionWorld, _scaleWorld );
-					this.matrix.decompose( _translationObject, _quaternionObject, _scaleObject );
-					this.matrixWorld.compose( _translationWorld, _quaternionObject, _scaleWorld );
-
-				} else {
-
-					this.matrixWorld.copy( this.matrix );
-
-				}
-
-				this.matrixWorldNeedsUpdate = false;
-				force = true;
-
-			}
-
-			// update children
-
-			for ( let i = 0, l = this.children.length; i < l; i ++ ) {
-
-				this.children[ i ].updateMatrixWorld( force );
-
-			}
-
-		}
-
-	}
-
-	THREE.Gyroscope = Gyroscope;
-
-} )();

package/examples/js/misc/MD2Character.js

@@ -1,235 +0,0 @@
-( function () {
-
-	class MD2Character {
-
-		constructor() {
-
-			this.scale = 1;
-			this.animationFPS = 6;
-			this.root = new THREE.Object3D();
-			this.meshBody = null;
-			this.meshWeapon = null;
-			this.skinsBody = [];
-			this.skinsWeapon = [];
-			this.weapons = [];
-			this.activeAnimation = null;
-			this.mixer = null;
-			this.onLoadComplete = function () {};
-
-			this.loadCounter = 0;
-
-		}
-		loadParts( config ) {
-
-			const scope = this;
-			function createPart( geometry, skinMap ) {
-
-				const materialWireframe = new THREE.MeshLambertMaterial( {
-					color: 0xffaa00,
-					wireframe: true
-				} );
-				const materialTexture = new THREE.MeshLambertMaterial( {
-					color: 0xffffff,
-					wireframe: false,
-					map: skinMap
-				} );
-
-				//
-
-				const mesh = new THREE.Mesh( geometry, materialTexture );
-				mesh.rotation.y = - Math.PI / 2;
-				mesh.castShadow = true;
-				mesh.receiveShadow = true;
-
-				//
-
-				mesh.materialTexture = materialTexture;
-				mesh.materialWireframe = materialWireframe;
-				return mesh;
-
-			}
-
-			function loadTextures( baseUrl, textureUrls ) {
-
-				const textureLoader = new THREE.TextureLoader();
-				const textures = [];
-				for ( let i = 0; i < textureUrls.length; i ++ ) {
-
-					textures[ i ] = textureLoader.load( baseUrl + textureUrls[ i ], checkLoadingComplete );
-					textures[ i ].mapping = THREE.UVMapping;
-					textures[ i ].name = textureUrls[ i ];
-					textures[ i ].encoding = THREE.sRGBEncoding;
-
-				}
-
-				return textures;
-
-			}
-
-			function checkLoadingComplete() {
-
-				scope.loadCounter -= 1;
-				if ( scope.loadCounter === 0 ) scope.onLoadComplete();
-
-			}
-
-			this.loadCounter = config.weapons.length * 2 + config.skins.length + 1;
-			const weaponsTextures = [];
-			for ( let i = 0; i < config.weapons.length; i ++ ) weaponsTextures[ i ] = config.weapons[ i ][ 1 ];
-			// SKINS
-
-			this.skinsBody = loadTextures( config.baseUrl + 'skins/', config.skins );
-			this.skinsWeapon = loadTextures( config.baseUrl + 'skins/', weaponsTextures );
-
-			// BODY
-
-			const loader = new THREE.MD2Loader();
-			loader.load( config.baseUrl + config.body, function ( geo ) {
-
-				const boundingBox = new THREE.Box3();
-				boundingBox.setFromBufferAttribute( geo.attributes.position );
-				scope.root.position.y = - scope.scale * boundingBox.min.y;
-				const mesh = createPart( geo, scope.skinsBody[ 0 ] );
-				mesh.scale.set( scope.scale, scope.scale, scope.scale );
-				scope.root.add( mesh );
-				scope.meshBody = mesh;
-				scope.meshBody.clipOffset = 0;
-				scope.activeAnimationClipName = mesh.geometry.animations[ 0 ].name;
-				scope.mixer = new THREE.AnimationMixer( mesh );
-				checkLoadingComplete();
-
-			} );
-
-			// WEAPONS
-
-			const generateCallback = function ( index, name ) {
-
-				return function ( geo ) {
-
-					const mesh = createPart( geo, scope.skinsWeapon[ index ] );
-					mesh.scale.set( scope.scale, scope.scale, scope.scale );
-					mesh.visible = false;
-					mesh.name = name;
-					scope.root.add( mesh );
-					scope.weapons[ index ] = mesh;
-					scope.meshWeapon = mesh;
-					checkLoadingComplete();
-
-				};
-
-			};
-
-			for ( let i = 0; i < config.weapons.length; i ++ ) {
-
-				loader.load( config.baseUrl + config.weapons[ i ][ 0 ], generateCallback( i, config.weapons[ i ][ 0 ] ) );
-
-			}
-
-		}
-		setPlaybackRate( rate ) {
-
-			if ( rate !== 0 ) {
-
-				this.mixer.timeScale = 1 / rate;
-
-			} else {
-
-				this.mixer.timeScale = 0;
-
-			}
-
-		}
-		setWireframe( wireframeEnabled ) {
-
-			if ( wireframeEnabled ) {
-
-				if ( this.meshBody ) this.meshBody.material = this.meshBody.materialWireframe;
-				if ( this.meshWeapon ) this.meshWeapon.material = this.meshWeapon.materialWireframe;
-
-			} else {
-
-				if ( this.meshBody ) this.meshBody.material = this.meshBody.materialTexture;
-				if ( this.meshWeapon ) this.meshWeapon.material = this.meshWeapon.materialTexture;
-
-			}
-
-		}
-		setSkin( index ) {
-
-			if ( this.meshBody && this.meshBody.material.wireframe === false ) {
-
-				this.meshBody.material.map = this.skinsBody[ index ];
-
-			}
-
-		}
-		setWeapon( index ) {
-
-			for ( let i = 0; i < this.weapons.length; i ++ ) this.weapons[ i ].visible = false;
-			const activeWeapon = this.weapons[ index ];
-			if ( activeWeapon ) {
-
-				activeWeapon.visible = true;
-				this.meshWeapon = activeWeapon;
-				this.syncWeaponAnimation();
-
-			}
-
-		}
-		setAnimation( clipName ) {
-
-			if ( this.meshBody ) {
-
-				if ( this.meshBody.activeAction ) {
-
-					this.meshBody.activeAction.stop();
-					this.meshBody.activeAction = null;
-
-				}
-
-				const action = this.mixer.clipAction( clipName, this.meshBody );
-				if ( action ) {
-
-					this.meshBody.activeAction = action.play();
-
-				}
-
-			}
-
-			this.activeClipName = clipName;
-			this.syncWeaponAnimation();
-
-		}
-		syncWeaponAnimation() {
-
-			const clipName = this.activeClipName;
-			if ( this.meshWeapon ) {
-
-				if ( this.meshWeapon.activeAction ) {
-
-					this.meshWeapon.activeAction.stop();
-					this.meshWeapon.activeAction = null;
-
-				}
-
-				const action = this.mixer.clipAction( clipName, this.meshWeapon );
-				if ( action ) {
-
-					this.meshWeapon.activeAction = action.syncWith( this.meshBody.activeAction ).play();
-
-				}
-
-			}
-
-		}
-		update( delta ) {
-
-			if ( this.mixer ) this.mixer.update( delta );
-
-		}
-
-	}
-
-	THREE.MD2Character = MD2Character;
-
-} )();