easy-three-utils 0.0.1

package/src/tileRenderer/plugins/three/gltf/metadata/classes/PropertyTableAccessor.js

@@ -0,0 +1,209 @@
+import { ClassProperty } from './ClassProperty.js';
+import { PropertySetAccessor } from './PropertySetAccessor.js';
+import {
+	initializeFromClass,
+	getArrayConstructorFromComponentType,
+	readDataFromBufferToType,
+	getField,
+	isNumericType,
+	typeToComponentCount,
+} from '../utilities/ClassPropertyHelpers.js';
+
+class PropertyTableClassProperty extends ClassProperty {
+
+	constructor( enums, classProperty, tableProperty = null ) {
+
+		super( enums, classProperty, tableProperty );
+
+		this.values = tableProperty.values;
+		this.valueLength = typeToComponentCount( this.type );
+		this.arrayOffsets = getField( tableProperty, 'arrayOffsets', null );
+		this.stringOffsets = getField( tableProperty, 'stringOffsets', null );
+		this.arrayOffsetType = getField( tableProperty, 'arrayOffsetType', 'UINT32' );
+		this.stringOffsetType = getField( tableProperty, 'stringOffsetType', 'UINT32' );
+
+	}
+
+	// returns the necessary array length based on the array offsets if present
+	getArrayLengthFromId( buffers, id ) {
+
+		let count = this.count;
+		if ( this.arrayOffsets !== null ) {
+
+			const { arrayOffsets, arrayOffsetType } = this;
+			const bufferCons = getArrayConstructorFromComponentType( arrayOffsetType );
+			const arr = new bufferCons( buffers[ arrayOffsets ] );
+			count = arr[ id + 1 ] - arr[ id ];
+
+		}
+
+		return count;
+
+	}
+
+	// returns the index offset into the data buffer for the given id based on the
+	// the array offsets if present
+	getIndexOffsetFromId( buffers, id ) {
+
+		let indexOffset = id;
+		if ( this.arrayOffsets ) {
+
+			const { arrayOffsets, arrayOffsetType } = this;
+			const bufferCons = getArrayConstructorFromComponentType( arrayOffsetType );
+			const arr = new bufferCons( buffers[ arrayOffsets ] );
+			indexOffset = arr[ indexOffset ];
+
+		} else if ( this.array ) {
+
+			// TODO: why do this? Revisit
+			indexOffset *= this.count;
+
+		}
+
+		return indexOffset;
+
+	}
+
+}
+
+export class PropertyTableAccessor extends PropertySetAccessor {
+
+	constructor( ...args ) {
+
+		super( ...args );
+
+		this.isPropertyTableAccessor = true;
+		this.count = this.definition.count;
+
+		this._initProperties( PropertyTableClassProperty );
+
+	}
+
+	getData( id, target = {} ) {
+
+		const properties = this.properties;
+		initializeFromClass( properties, target );
+
+		for ( const name in properties ) {
+
+			target[ name ] = this.getPropertyValue( name, id, target[ name ] );
+
+		}
+
+		return target;
+
+	}
+
+	// reads an individual element
+	_readValueAtIndex( name, id, index, target = null ) {
+
+		const property = this.properties[ name ];
+		const { componentType, type } = property;
+
+		const buffers = this.data;
+		const bufferView = buffers[ property.values ];
+		const bufferCons = getArrayConstructorFromComponentType( componentType, type );
+		const dataArray = new bufferCons( bufferView );
+
+		// array offsets contain element offsets, not byte offsets
+		const indexOffset = property.getIndexOffsetFromId( buffers, id );
+
+		if ( isNumericType( type ) || type === 'ENUM' ) {
+
+			// "readDataFromBufferToType" takes the start offset to read from so we multiply the
+			// index by the final value length
+			return readDataFromBufferToType( dataArray, ( indexOffset + index ) * property.valueLength, type, target );
+
+		} else if ( type === 'STRING' ) {
+
+			// https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata/#variable-length-arrays
+
+			let stringIndex = indexOffset + index;
+			let stringLength = 0;
+			if ( property.stringOffsets !== null ) {
+
+				// get the string lengths and beginning offsets if variable
+				const { stringOffsets, stringOffsetType } = property;
+				const bufferCons = getArrayConstructorFromComponentType( stringOffsetType );
+				const stringOffsetBuffer = new bufferCons( buffers[ stringOffsets ] );
+				stringLength = stringOffsetBuffer[ stringIndex + 1 ] - stringOffsetBuffer[ stringIndex ];
+				stringIndex = stringOffsetBuffer[ stringIndex ];
+
+			}
+
+			const byteArray = new Uint8Array( dataArray.buffer, stringIndex, stringLength );
+			target = new TextDecoder().decode( byteArray );
+
+		} else if ( type === 'BOOLEAN' ) {
+
+			const offset = indexOffset + index;
+			const byteIndex = Math.floor( offset / 8 );
+			const bitIndex = offset % 8;
+			const bitValue = ( dataArray[ byteIndex ] >> bitIndex ) & 1;
+			target = bitValue === 1;
+
+		}
+
+		return target;
+
+	}
+
+	// Reads the data for the given table index
+	getPropertyValue( name, id, target = null ) {
+
+		// check if the requested id is outside of the size of the table
+		if ( id >= this.count ) {
+
+			throw new Error( 'PropertyTableAccessor: Requested index is outside the range of the table.' );
+
+		}
+
+		// check to see if we skip this field since its not in the table
+		const property = this.properties[ name ];
+		if ( ! property ) {
+
+			throw new Error( 'PropertyTableAccessor: Requested property does not exist.' );
+
+		} else if ( ! this.definition.properties[ name ] ) {
+
+			return property.resolveDefault( target );
+
+		}
+
+		// get the dynamic array count from the property buffer
+		const array = property.array;
+		const buffers = this.data;
+		const count = property.getArrayLengthFromId( buffers, id );
+
+		// initialize the array
+		target = property.shapeToProperty( target, count );
+
+		// read all data
+		if ( array ) {
+
+			for ( let i = 0, l = target.length; i < l; i ++ ) {
+
+				target[ i ] = this._readValueAtIndex( name, id, i, target[ i ] );
+
+			}
+
+		} else {
+
+			target = this._readValueAtIndex( name, id, 0, target );
+
+		}
+
+		// scale the numeric values
+		target = property.adjustValueScaleOffset( target );
+
+		// convert to enum strings - no data enum values are stored as strings
+		target = property.resolveEnumsToStrings( target );
+
+		// resolve to default values
+		target = property.resolveNoData( target );
+
+		return target;
+
+	}
+
+}

package/src/tileRenderer/plugins/three/gltf/metadata/classes/PropertyTextureAccessor.js

@@ -0,0 +1,244 @@
+import { Vector2 } from 'three';
+import { PropertySetAccessor } from './PropertySetAccessor.js';
+import { ClassProperty } from './ClassProperty.js';
+import { TextureReadUtility } from '../utilities/TextureReadUtility.js';
+import { getTexCoord, getTexelIndices, getTriangleVertexIndices } from '../utilities/TexCoordUtilities.js';
+import {
+	initializeFromClass,
+	initializeFromProperty,
+	getArrayConstructorFromComponentType,
+	readDataFromBufferToType,
+	getField
+} from '../utilities/ClassPropertyHelpers.js';
+
+const _uv = /* @__PURE__ */ new Vector2();
+const _srcPixel = /* @__PURE__ */ new Vector2();
+const _dstPixel = /* @__PURE__ */ new Vector2();
+
+class PropertyTextureClassProperty extends ClassProperty {
+
+	constructor( enums, classProperty, textureProperty = null ) {
+
+		super( enums, classProperty, textureProperty );
+
+		this.channels = getField( textureProperty, 'channels', [ 0 ] );
+		this.index = getField( textureProperty, 'index', null );
+		this.texCoord = getField( textureProperty, 'texCoord', null );
+		this.valueLength = parseInt( this.type.replace( /[^0-9]/g, '' ) ) || 1;
+
+	}
+
+	// takes the buffer to read from and the value index to read
+	readDataFromBuffer( buffer, index, target = null ) {
+
+		const type = this.type;
+		if ( type === 'BOOLEAN' || type === 'STRING' ) {
+
+			throw new Error( 'PropertyTextureAccessor: BOOLEAN and STRING types not supported.' );
+
+		}
+
+		// "readDataFromBufferToType" takes the start offset to read from so we multiply the index by the
+		// final value length
+		return readDataFromBufferToType( buffer, index * this.valueLength, type, target );
+
+	}
+
+}
+
+// Reads and accesses data encoded to textures
+export class PropertyTextureAccessor extends PropertySetAccessor {
+
+	constructor( ...args ) {
+
+		super( ...args );
+
+		this.isPropertyTextureAccessor = true;
+		this._asyncRead = false;
+
+		this._initProperties( PropertyTextureClassProperty );
+
+	}
+
+	// Reads the full set of property data
+	getData( faceIndex, barycoord, geometry, target = {} ) {
+
+		const properties = this.properties;
+		initializeFromClass( properties, target );
+
+		const names = Object.keys( properties );
+		const results = names.map( n => target[ n ] );
+		this.getPropertyValuesAtTexel( names, faceIndex, barycoord, geometry, results );
+
+		names.forEach( ( n, i ) => target[ n ] = results[ i ] );
+		return target;
+
+	}
+
+	// Reads the full set of property data asynchronously
+	async getDataAsync( faceIndex, barycoord, geometry, target = {} ) {
+
+		const properties = this.properties;
+		initializeFromClass( properties, target );
+
+		const names = Object.keys( properties );
+		const results = names.map( n => target[ n ] );
+		await this.getPropertyValuesAtTexelAsync( names, faceIndex, barycoord, geometry, results );
+
+		names.forEach( ( n, i ) => target[ n ] = results[ i ] );
+		return target;
+
+	}
+
+	// Reads values asynchronously
+	getPropertyValuesAtTexelAsync( ...args ) {
+
+		this._asyncRead = true;
+		const result = this.getPropertyValuesAtTexel( ...args );
+		this._asyncRead = false;
+		return result;
+
+	}
+
+	// Reads values from the textures synchronously
+	getPropertyValuesAtTexel( names, faceIndex, barycoord, geometry, target = [] ) {
+
+		// resize our targets appropriately
+		while ( target.length < names.length ) target.push( null );
+		target.length = names.length;
+		TextureReadUtility.increaseSizeTo( target.length );
+
+		// get the attribute indices
+		const textures = this.data;
+		const accessorProperties = this.definition.properties;
+		const properties = this.properties;
+		const indices = getTriangleVertexIndices( geometry, faceIndex );
+		for ( let i = 0, l = names.length; i < l; i ++ ) {
+
+			// skip any requested class schema properties that are not provided via the accessor
+			const name = names[ i ];
+			if ( ! accessorProperties[ name ] ) {
+
+				continue;
+
+			}
+
+			// get the attribute of the target tex coord
+			const property = properties[ name ];
+			const texture = textures[ property.index ];
+			getTexCoord( geometry, property.texCoord, barycoord, indices, _uv );
+			getTexelIndices( _uv, texture.image.width, texture.image.height, _srcPixel );
+			_dstPixel.set( i, 0 );
+
+			TextureReadUtility.renderPixelToTarget( texture, _srcPixel, _dstPixel );
+
+		}
+
+		// read the data
+		const buffer = new Uint8Array( names.length * 4 );
+		if ( this._asyncRead ) {
+
+			return TextureReadUtility
+				.readDataAsync( buffer )
+				.then( () => {
+
+					readTextureSampleResults.call( this );
+					return target;
+
+				} );
+
+		} else {
+
+			TextureReadUtility.readData( buffer );
+			readTextureSampleResults.call( this );
+
+			return target;
+
+		}
+
+		function readTextureSampleResults() {
+
+			for ( let i = 0, l = names.length; i < l; i ++ ) {
+
+				const name = names[ i ];
+				const property = properties[ name ];
+				const type = property.type;
+
+				// initialize the output value
+				target[ i ] = initializeFromProperty( property, target[ i ] );
+
+				// use a default of the texture accessor definition does not include the value
+				if ( ! property ) {
+
+					throw new Error( 'PropertyTextureAccessor: Requested property does not exist.' );
+
+				} else if ( ! accessorProperties[ name ] ) {
+
+					target[ i ] = property.resolveDefault( target );
+					continue;
+
+				}
+
+				// get the final array length to read all data based on used buffer data
+				const length = property.valueLength * ( property.count || 1 );
+
+				// set the data read back from the texture to the target type
+				const data = property.channels.map( c => buffer[ 4 * i + c ] );
+				const componentType = property.componentType;
+				const BufferCons = getArrayConstructorFromComponentType( componentType, type );
+				const readBuffer = new BufferCons( length );
+				new Uint8Array( readBuffer.buffer ).set( data );
+
+				// read all the data
+				if ( property.array ) {
+
+					const arr = target[ i ];
+					for ( let j = 0, lj = arr.length; j < lj; j ++ ) {
+
+						arr[ j ] = property.readDataFromBuffer( readBuffer, j, arr[ j ] );
+
+					}
+
+				} else {
+
+					target[ i ] = property.readDataFromBuffer( readBuffer, 0, target[ i ] );
+
+				}
+
+				// scale the numeric values
+				target[ i ] = property.adjustValueScaleOffset( target[ i ] );
+
+				// convert to enum strings - no data enum values are stored as strings
+				target[ i ] = property.resolveEnumsToStrings( target[ i ] );
+
+				// resolve to default values
+				target[ i ] = property.resolveNoData( target[ i ] );
+
+			}
+
+		}
+
+	}
+
+	// dispose all of the texture data used
+	dispose() {
+
+		this.data.forEach( texture => {
+
+			if ( texture ) {
+
+				texture.dispose();
+
+				if ( texture.image instanceof ImageBitmap ) {
+
+					texture.image.close();
+
+				}
+
+			}
+
+		} );
+
+	}
+
+}

package/src/tileRenderer/plugins/three/gltf/metadata/classes/StructuralMetadata.js

@@ -0,0 +1,202 @@
+import { PropertyAttributeAccessor } from './PropertyAttributeAccessor.js';
+import { PropertyTableAccessor } from './PropertyTableAccessor.js';
+import { PropertyTextureAccessor } from './PropertyTextureAccessor.js';
+
+export class StructuralMetadata {
+
+	constructor( definition, textures, buffers, nodeMetadata = null, object = null ) {
+
+		const {
+			schema,
+			propertyTables = [],
+			propertyTextures = [],
+			propertyAttributes = [],
+		} = definition;
+
+		const { enums, classes } = schema;
+		const tableAccessors = propertyTables.map( t => new PropertyTableAccessor( t, classes, enums, buffers ) );
+		let textureAccessors = [];
+		let attributeAccessors = [];
+
+		if ( nodeMetadata ) {
+
+			if ( nodeMetadata.propertyTextures ) {
+
+				textureAccessors = nodeMetadata.propertyTextures.map( i => new PropertyTextureAccessor( propertyTextures[ i ], classes, enums, textures ) );
+
+			}
+
+			if ( nodeMetadata.propertyAttributes ) {
+
+				attributeAccessors = nodeMetadata.propertyAttributes.map( i => new PropertyAttributeAccessor( propertyAttributes[ i ], classes, enums ) );
+
+			}
+
+		}
+
+		this.schema = schema;
+		this.tableAccessors = tableAccessors;
+		this.textureAccessors = textureAccessors;
+		this.attributeAccessors = attributeAccessors;
+		this.object = object;
+		this.textures = textures;
+		this.nodeMetadata = nodeMetadata;
+
+	}
+
+	// Property Tables
+	getPropertyTableData( tableIndices, ids, target = null ) {
+
+		if ( ! Array.isArray( tableIndices ) || ! Array.isArray( ids ) ) {
+
+			// only return a single tables data
+			target = target || {};
+
+			const table = this.tableAccessors[ tableIndices ];
+			target = table.getData( ids, target );
+
+		} else {
+
+			// return data from an array of tables and ids
+			target = target || [];
+
+			const length = Math.min( tableIndices.length, ids.length );
+			target.length = length;
+
+			for ( let i = 0; i < length; i ++ ) {
+
+				const table = this.tableAccessors[ tableIndices[ i ] ];
+				target[ i ] = table.getData( ids[ i ], target[ i ] );
+
+			}
+
+		}
+
+		return target;
+
+	}
+
+	getPropertyTableInfo( tableIndices = null ) {
+
+		// default to all table information
+		if ( tableIndices === null ) {
+
+			tableIndices = this.tableAccessors.map( ( t, i ) => i );
+
+		}
+
+		if ( Array.isArray( tableIndices ) ) {
+
+			// return all table information from the requested list
+			return tableIndices.map( i => {
+
+				const table = this.tableAccessors[ i ];
+				return {
+					name: table.name,
+					className: table.definition.class,
+				};
+
+			} );
+
+		} else {
+
+			// return the one piece of table information
+			const table = this.tableAccessors[ tableIndices ];
+			return {
+				name: table.name,
+				className: table.definition.class,
+			};
+
+		}
+
+	}
+
+	// Property Textures
+	getPropertyTextureData( triangle, barycoord, target = [] ) {
+
+		const textureAccessors = this.textureAccessors;
+		target.length = textureAccessors.length;
+
+		for ( let i = 0; i < textureAccessors.length; i ++ ) {
+
+			const accessor = textureAccessors[ i ];
+			target[ i ] = accessor.getData( triangle, barycoord, this.object.geometry, target[ i ] );
+
+		}
+
+		return target;
+
+	}
+
+	async getPropertyTextureDataAsync( triangle, barycoord, target = [] ) {
+
+		const textureAccessors = this.textureAccessors;
+		target.length = textureAccessors.length;
+
+		const promises = [];
+		for ( let i = 0; i < textureAccessors.length; i ++ ) {
+
+			const accessor = textureAccessors[ i ];
+			const promise = accessor
+				.getDataAsync( triangle, barycoord, this.object.geometry, target[ i ] )
+				.then( result => {
+
+					target[ i ] = result;
+
+				} );
+
+			promises.push( promise );
+
+		}
+
+		await Promise.all( promises );
+
+		return target;
+
+	}
+
+	getPropertyTextureInfo() {
+
+		return this.textureAccessors;
+
+	}
+
+	// Property Attributes
+	getPropertyAttributeData( attributeIndex, target = [] ) {
+
+		const attributeAccessors = this.attributeAccessors;
+		target.length = attributeAccessors.length;
+
+		for ( let i = 0; i < attributeAccessors.length; i ++ ) {
+
+			const accessor = attributeAccessors[ i ];
+			target[ i ] = accessor.getData( attributeIndex, this.object.geometry, target[ i ] );
+
+		}
+
+		return target;
+
+	}
+
+	getPropertyAttributeInfo() {
+
+		return this.attributeAccessors.map( acc => {
+
+			return {
+				name: acc.name,
+				className: acc.definition.class,
+			};
+
+		} );
+
+	}
+
+	dispose() {
+
+		this.textureAccessors.forEach( acc => acc.dispose() );
+		this.tableAccessors.forEach( acc => acc.dispose() );
+		this.attributeAccessors.forEach( acc => acc.dispose() );
+
+	}
+
+}

package/src/tileRenderer/plugins/three/gltf/metadata/math/Matrix2.js

@@ -0,0 +1,55 @@
+// Matrix2 definition since it doesn't exist in three.js
+export class Matrix2 {
+
+	constructor( n11, n12, n21, n22 ) {
+
+		Matrix2.prototype.isMatrix2 = true;
+
+		this.elements = [
+			1, 0,
+			0, 1,
+		];
+
+		if ( n11 !== undefined ) {
+
+			this.set( n11, n12, n21, n22 );
+
+		}
+
+	}
+
+	identity() {
+
+		this.set(
+			1, 0,
+			0, 1,
+		);
+
+		return this;
+
+	}
+
+	fromArray( array, offset = 0 ) {
+
+		for ( let i = 0; i < 4; i ++ ) {
+
+			this.elements[ i ] = array[ i + offset ];
+
+		}
+
+		return this;
+
+	}
+
+	set( n11, n12, n21, n22 ) {
+
+		const te = this.elements;
+
+		te[ 0 ] = n11; te[ 1 ] = n21;
+		te[ 2 ] = n12; te[ 3 ] = n22;
+
+		return this;
+
+	}
+
+}