super-three 0.136.0 → 0.136.1

package/examples/jsm/shaders/DigitalGlitch.js

@@ -62,7 +62,7 @@ const DigitalGlitch = {
 				float xs = floor(gl_FragCoord.x / 0.5);
 				float ys = floor(gl_FragCoord.y / 0.5);
 				//based on staffantans glitch shader for unity https://github.com/staffantan/unityglitch
-				vec4 normal = texture2D (tDisp, p*seed*seed);
+				float disp = texture2D(tDisp, p*seed*seed).r;
 				if(p.y<distortion_x+col_s && p.y>distortion_x-col_s*seed) {
 					if(seed_x>0.){
 						p.y = 1. - (p.y + distortion_y);
@@ -79,8 +79,8 @@ const DigitalGlitch = {
 						p.x = 1. - (p.x + distortion_x);
 					}
 				}
-				p.x+=normal.x*seed_x*(seed/5.);
-				p.y+=normal.y*seed_y*(seed/5.);
+				p.x+=disp*seed_x*(seed/5.);
+				p.y+=disp*seed_y*(seed/5.);
 				//base from RGB shift shader
 				vec2 offset = amount * vec2( cos(angle), sin(angle));
 				vec4 cr = texture2D(tDiffuse, p + offset);

package/examples/jsm/shaders/MMDToonShader.js

@@ -57,7 +57,6 @@ const mmd_toon_matcap_fragment = `
 	vec3 y = cross( viewDir, x );
 	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5; // 0.495 to remove artifacts caused by undersized matcap disks
 	vec4 matcapColor = texture2D( matcap, uv );
-	matcapColor = matcapTexelToLinear( matcapColor );
 
 	#ifdef MATCAP_BLENDING_MULTIPLY
 

package/examples/jsm/shaders/SSAOShader.js

@@ -134,7 +134,7 @@ const SSAOShader = {
 			vec3 viewNormal = getViewNormal( vUv );
 
 			vec2 noiseScale = vec2( resolution.x / 4.0, resolution.y / 4.0 );
-			vec3 random = texture2D( tNoise, vUv * noiseScale ).xyz;
+			vec3 random = vec3( texture2D( tNoise, vUv * noiseScale ).r );
 
 			// compute matrix used to reorient a kernel vector
 

package/examples/jsm/utils/LDrawUtils.js

@@ -0,0 +1,195 @@
+import {
+	BufferAttribute,
+	BufferGeometry,
+	Group,
+	LineSegments,
+	Matrix3,
+	Mesh
+} from 'three';
+
+import { mergeBufferGeometries } from './BufferGeometryUtils.js';
+
+class LDrawUtils {
+
+	static mergeObject( object ) {
+
+		// Merges geometries in object by materials and returns new object. Use on not indexed geometries.
+		// The object buffers reference the old object ones.
+		// Special treatment is done to the conditional lines generated by LDrawLoader.
+
+		function extractGroup( geometry, group, elementSize, isConditionalLine ) {
+
+			// Extracts a group from a geometry as a new geometry (with attribute buffers referencing original buffers)
+
+			const newGeometry = new BufferGeometry();
+
+			const originalPositions = geometry.getAttribute( 'position' ).array;
+			const originalNormals = elementSize === 3 ? geometry.getAttribute( 'normal' ).array : null;
+
+			const numVertsGroup = Math.min( group.count, Math.floor( originalPositions.length / 3 ) - group.start );
+			const vertStart = group.start * 3;
+			const vertEnd = ( group.start + numVertsGroup ) * 3;
+
+			const positions = originalPositions.subarray( vertStart, vertEnd );
+			const normals = originalNormals !== null ? originalNormals.subarray( vertStart, vertEnd ) : null;
+
+			newGeometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
+			if ( normals !== null ) newGeometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
+
+			if ( isConditionalLine ) {
+
+				const controlArray0 = geometry.getAttribute( 'control0' ).array.subarray( vertStart, vertEnd );
+				const controlArray1 = geometry.getAttribute( 'control1' ).array.subarray( vertStart, vertEnd );
+				const directionArray = geometry.getAttribute( 'direction' ).array.subarray( vertStart, vertEnd );
+
+				newGeometry.setAttribute( 'control0', new BufferAttribute( controlArray0, 3, false ) );
+				newGeometry.setAttribute( 'control1', new BufferAttribute( controlArray1, 3, false ) );
+				newGeometry.setAttribute( 'direction', new BufferAttribute( directionArray, 3, false ) );
+
+			}
+
+			return newGeometry;
+
+		}
+
+		function addGeometry( mat, geometry, geometries ) {
+
+			const geoms = geometries[ mat.uuid ];
+			if ( ! geoms ) {
+
+				geometries[ mat.uuid ] = {
+					mat: mat,
+					arr: [ geometry ]
+				};
+
+			}
+			else geoms.arr.push( geometry );
+
+		}
+
+		function permuteAttribute( attribute, elemSize ) {
+
+			// Permutes first two vertices of each attribute element
+
+			if ( ! attribute ) return;
+
+			const verts = attribute.array;
+			const numVerts = Math.floor( verts.length / 3 );
+			let offset = 0;
+			for ( let i = 0; i < numVerts; i ++ ) {
+
+				const x = verts[ offset ];
+				const y = verts[ offset + 1 ];
+				const z = verts[ offset + 2 ];
+
+				verts[ offset ] = verts[ offset + 3 ];
+				verts[ offset + 1 ] = verts[ offset + 4 ];
+				verts[ offset + 2 ] = verts[ offset + 5 ];
+
+				verts[ offset + 3 ] = x;
+				verts[ offset + 4 ] = y;
+				verts[ offset + 5 ] = z;
+
+				offset += elemSize * 3;
+
+			}
+
+		}
+
+		// Traverse the object hierarchy collecting geometries and transforming them to world space
+
+		const meshGeometries = {};
+		const linesGeometries = {};
+		const condLinesGeometries = {};
+
+		object.updateMatrixWorld( true );
+		const normalMatrix = new Matrix3();
+
+		object.traverse( c => {
+
+			if ( c.isMesh | c.isLineSegments ) {
+
+				const elemSize = c.isMesh ? 3 : 2;
+
+				const matrixIsInverted = c.matrixWorld.determinant() < 0;
+				if ( matrixIsInverted ) {
+
+					permuteAttribute( c.geometry.attributes.position, elemSize );
+					permuteAttribute( c.geometry.attributes.normal, elemSize );
+
+				}
+
+				c.geometry.applyMatrix4( c.matrixWorld );
+
+				if ( c.isConditionalLine ) {
+
+					c.geometry.attributes.control0.applyMatrix4( c.matrixWorld );
+					c.geometry.attributes.control1.applyMatrix4( c.matrixWorld );
+					normalMatrix.getNormalMatrix( c.matrixWorld );
+					c.geometry.attributes.direction.applyNormalMatrix( normalMatrix );
+
+				}
+
+				const geometries = c.isMesh ? meshGeometries : ( c.isConditionalLine ? condLinesGeometries : linesGeometries );
+
+				if ( Array.isArray( c.material ) ) {
+
+					for ( const groupIndex in c.geometry.groups ) {
+
+						const group = c.geometry.groups[ groupIndex ];
+						const mat = c.material[ group.materialIndex ];
+						const newGeometry = extractGroup( c.geometry, group, elemSize, c.isConditionalLine );
+						addGeometry( mat, newGeometry, geometries );
+
+					}
+
+				}
+				else addGeometry( c.material, c.geometry, geometries );
+
+			}
+
+		} );
+
+		// Create object with merged geometries
+
+		const mergedObject = new Group();
+
+		const meshMaterialsIds = Object.keys( meshGeometries );
+		for ( const i in meshMaterialsIds ) {
+
+			const meshGeometry = meshGeometries[ meshMaterialsIds[ i ] ];
+			const mergedGeometry = mergeBufferGeometries( meshGeometry.arr );
+			mergedObject.add( new Mesh( mergedGeometry, meshGeometry.mat ) );
+
+		}
+
+		const linesMaterialsIds = Object.keys( linesGeometries );
+		for ( const i in linesMaterialsIds ) {
+
+			const lineGeometry = linesGeometries[ linesMaterialsIds[ i ] ];
+			const mergedGeometry = mergeBufferGeometries( lineGeometry.arr );
+			mergedObject.add( new LineSegments( mergedGeometry, lineGeometry.mat ) );
+
+		}
+
+		const condLinesMaterialsIds = Object.keys( condLinesGeometries );
+		for ( const i in condLinesMaterialsIds ) {
+
+			const condLineGeometry = condLinesGeometries[ condLinesMaterialsIds[ i ] ];
+			const mergedGeometry = mergeBufferGeometries( condLineGeometry.arr );
+			const condLines = new LineSegments( mergedGeometry, condLineGeometry.mat );
+			condLines.isConditionalLine = true;
+			mergedObject.add( condLines );
+
+		}
+
+		mergedObject.userData.constructionStep = 0;
+		mergedObject.userData.numConstructionSteps = 1;
+
+		return mergedObject;
+
+	}
+
+}
+
+export { LDrawUtils };

package/examples/jsm/webxr/VRButton.js

@@ -132,6 +132,12 @@ class VRButton {
 
 				supported ? showEnterVR() : showWebXRNotFound();
 
+				if ( supported && VRButton.xrSessionIsGranted ) {
+
+					button.click();
+
+				}
+
 			} );
 
 			return button;
@@ -164,6 +170,24 @@ class VRButton {
 
 	}
 
+	static xrSessionIsGranted = false;
+
+	static registerSessionGrantedListener() {
+
+		if ( 'xr' in navigator ) {
+
+			navigator.xr.addEventListener( 'sessiongranted', () => {
+
+				VRButton.xrSessionIsGranted = true;
+
+			} );
+
+		}
+
+	}
+
 }
 
+VRButton.registerSessionGrantedListener();
+
 export { VRButton };

package/examples/jsm/webxr/XREstimatedLight.js

@@ -69,6 +69,8 @@ class SessionLightProbe {
 
 				textureProperties.__webglTexture = cubeMap;
 
+				this.xrLight.environment.needsPMREMUpdate = true;
+
 			}
 
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "super-three",
-  "version": "0.136.0",
+  "version": "0.136.1",
   "description": "JavaScript 3D library",
   "main": "build/three.js",
   "module": "build/three.module.js",
@@ -55,6 +55,9 @@
       "GPUTextureUsage": "readonly"
     },
     "rules": {
+      "no-throw-literal": [
+        "error"
+      ],
       "quotes": [
         "error",
         "single"

package/src/animation/AnimationMixer.js

@@ -48,6 +48,7 @@ class AnimationMixer extends EventDispatcher {
 
 			if ( binding !== undefined ) {
 
+				++ binding.referenceCount;
 				bindings[ i ] = binding;
 
 			} else {

package/src/cameras/CubeCamera.js

@@ -100,6 +100,8 @@ class CubeCamera extends Object3D {
 
 		renderer.xr.enabled = currentXrEnabled;
 
+		renderTarget.texture.needsPMREMUpdate = true;
+
 	}
 
 }

package/src/constants.js

@@ -1,4 +1,4 @@
-export const REVISION = '136';
+export const REVISION = '137dev';
 export const MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 };
 export const TOUCH = { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 };
 export const CullFaceNone = 0;
@@ -87,7 +87,6 @@ export const UnsignedShort5551Type = 1018;
 export const UnsignedShort565Type = 1019;
 export const UnsignedInt248Type = 1020;
 export const AlphaFormat = 1021;
-export const RGBFormat = 1022;
 export const RGBAFormat = 1023;
 export const LuminanceFormat = 1024;
 export const LuminanceAlphaFormat = 1025;
@@ -126,20 +125,6 @@ export const RGBA_ASTC_10x10_Format = 37819;
 export const RGBA_ASTC_12x10_Format = 37820;
 export const RGBA_ASTC_12x12_Format = 37821;
 export const RGBA_BPTC_Format = 36492;
-export const SRGB8_ALPHA8_ASTC_4x4_Format = 37840;
-export const SRGB8_ALPHA8_ASTC_5x4_Format = 37841;
-export const SRGB8_ALPHA8_ASTC_5x5_Format = 37842;
-export const SRGB8_ALPHA8_ASTC_6x5_Format = 37843;
-export const SRGB8_ALPHA8_ASTC_6x6_Format = 37844;
-export const SRGB8_ALPHA8_ASTC_8x5_Format = 37845;
-export const SRGB8_ALPHA8_ASTC_8x6_Format = 37846;
-export const SRGB8_ALPHA8_ASTC_8x8_Format = 37847;
-export const SRGB8_ALPHA8_ASTC_10x5_Format = 37848;
-export const SRGB8_ALPHA8_ASTC_10x6_Format = 37849;
-export const SRGB8_ALPHA8_ASTC_10x8_Format = 37850;
-export const SRGB8_ALPHA8_ASTC_10x10_Format = 37851;
-export const SRGB8_ALPHA8_ASTC_12x10_Format = 37852;
-export const SRGB8_ALPHA8_ASTC_12x12_Format = 37853;
 export const LoopOnce = 2200;
 export const LoopRepeat = 2201;
 export const LoopPingPong = 2202;
@@ -191,3 +176,5 @@ export const StreamCopyUsage = 35042;
 
 export const GLSL1 = '100';
 export const GLSL3 = '300 es';
+
+export const _SRGBAFormat = 1035; // fallback for WebGL 1

package/src/extras/ImageUtils.js

@@ -1,4 +1,5 @@
 import { createElementNS } from '../utils.js';
+import { SRGBToLinear } from '../math/Color.js';
 
 let _canvas;
 
@@ -61,6 +62,68 @@ class ImageUtils {
 
 	}
 
+	static sRGBToLinear( image ) {
+
+		if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
+			( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
+			( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
+
+			const canvas = createElementNS( 'canvas' );
+
+			canvas.width = image.width;
+			canvas.height = image.height;
+
+			const context = canvas.getContext( '2d' );
+			context.drawImage( image, 0, 0, image.width, image.height );
+
+			const imageData = context.getImageData( 0, 0, image.width, image.height );
+			const data = imageData.data;
+
+			for ( let i = 0; i < data.length; i ++ ) {
+
+				data[ i ] = SRGBToLinear( data[ i ] / 255 ) * 255;
+
+			}
+
+			context.putImageData( imageData, 0, 0 );
+
+			return canvas;
+
+		} else if ( image.data ) {
+
+			const data = image.data.slice( 0 );
+
+			for ( let i = 0; i < data.length; i ++ ) {
+
+				if ( data instanceof Uint8Array || data instanceof Uint8ClampedArray ) {
+
+					data[ i ] = Math.floor( SRGBToLinear( data[ i ] / 255 ) * 255 );
+
+				} else {
+
+					// assuming float
+
+					data[ i ] = SRGBToLinear( data[ i ] );
+
+				}
+
+			}
+
+			return {
+				data: data,
+				width: image.width,
+				height: image.height
+			};
+
+		} else {
+
+			console.warn( 'THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied.' );
+			return image;
+
+		}
+
+	}
+
 }
 
 export { ImageUtils };