easy-three-utils 0.0.1

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

@@ -0,0 +1,149 @@
+import {
+	initializeFromProperty,
+	adjustValueScaleOffset,
+	getField,
+	isNumericType,
+	resolveDefaultElement,
+	resolveNoData,
+	resolveDefault,
+} from '../utilities/ClassPropertyHelpers.js';
+
+export class ClassProperty {
+
+	constructor( enums, property, accessorProperty = null ) {
+
+		// initialize defaults for class property info
+		this.name = property.name || null;
+		this.description = property.description || null;
+		this.type = property.type;
+		this.componentType = property.componentType || null;
+		this.enumType = property.enumType || null;
+		this.array = property.array || false;
+		this.count = property.count || 0;
+		this.normalized = property.normalized || false;
+		this.offset = property.offset || 0;
+		this.scale = getField( property, 'scale', 1 );
+		this.max = getField( property, 'max', Infinity );
+		this.min = getField( property, 'min', - Infinity );
+		this.required = property.required || false;
+		this.noData = getField( property, 'noData', null );
+		this.default = getField( property, 'default', null );
+		this.semantic = getField( property, 'semantic', null );
+		this.enumSet = null;
+		this.accessorProperty = accessorProperty;
+
+		// accessor properties can override min, max, offset, and scale values
+		if ( accessorProperty ) {
+
+			this.offset = getField( accessorProperty, 'offset', this.offset );
+			this.scale = getField( accessorProperty, 'scale', this.scale );
+			this.max = getField( accessorProperty, 'max', this.max );
+			this.min = getField( accessorProperty, 'min', this.min );
+
+		}
+
+		// get the component type for the provided enum
+		if ( property.type === 'ENUM' ) {
+
+			this.enumSet = enums[ this.enumType ];
+			if ( this.componentType === null ) {
+
+				this.componentType = getField( this.enumSet, 'valueType', 'UINT16' );
+
+			}
+
+		}
+
+	}
+
+	// shape the given target to match the data type of the property
+	// enums are set to their integer value
+	shapeToProperty( target, countOverride = null ) {
+
+		return initializeFromProperty( this, target, countOverride );
+
+	}
+
+	// resolve the given object to the default value for the property for a single element
+	// enums are set to a default string
+	resolveDefaultElement( target ) {
+
+		return resolveDefaultElement( this, target );
+
+	}
+
+	// resolve the target to the default value for the property for every element if it's an array
+	// enums are set to a default string
+	resolveDefault( target ) {
+
+		return resolveDefault( this, target );
+
+	}
+
+	// converts any instances of no data to the default value
+	resolveNoData( target ) {
+
+		return resolveNoData( this, target );
+
+	}
+
+	// converts enums integers in the given target to strings
+	resolveEnumsToStrings( target ) {
+
+		const enumSet = this.enumSet;
+		if ( this.type === 'ENUM' ) {
+
+			if ( Array.isArray( target ) ) {
+
+				for ( let i = 0, l = target.length; i < l; i ++ ) {
+
+					target[ i ] = getEnumName( target[ i ] );
+
+				}
+
+			} else {
+
+				target = getEnumName( target );
+
+			}
+
+
+		}
+
+		return target;
+
+		function getEnumName( index ) {
+
+			const match = enumSet.values.find( e => e.value === index );
+			if ( match === null ) {
+
+				// the default "default enum" value is an empty string when we can't find a match
+				// in a case where enums are defined correctly we should never get here.
+				return '';
+
+			} else {
+
+				return match.name;
+
+			}
+
+		}
+
+	}
+
+	// apply scales
+	adjustValueScaleOffset( target ) {
+
+		if ( isNumericType( this.type ) ) {
+
+			return adjustValueScaleOffset( this, target );
+
+		} else {
+
+			return target;
+
+		}
+
+	}
+
+}

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

@@ -0,0 +1,215 @@
+import { Vector2 } from 'three';
+import { TextureReadUtility } from '../utilities/TextureReadUtility.js';
+import { getTexCoord, getTexelIndices, getTriangleVertexIndices } from '../utilities/TexCoordUtilities.js';
+
+const _uv = /* @__PURE__ */ new Vector2();
+const _pixel = /* @__PURE__ */ new Vector2();
+const _dstPixel = /* @__PURE__ */ new Vector2();
+
+// retrieve the appropriate UV attribute based on the tex coord index
+function getMaxBarycoordIndex( barycoord ) {
+
+	if ( barycoord.x > barycoord.y && barycoord.x > barycoord.z ) {
+
+		return 0;
+
+	} else if ( barycoord.y > barycoord.z ) {
+
+		return 1;
+
+	} else {
+
+		return 2;
+
+	}
+
+}
+
+export class MeshFeatures {
+
+	constructor( geometry, textures, data ) {
+
+		this.geometry = geometry;
+		this.textures = textures;
+		this.data = data;
+		this._asyncRead = false;
+
+		// fill out feature id default values
+		this.featureIds = data.featureIds.map( info => {
+
+			const { texture, ...rest } = info;
+			const result = {
+				label: null,
+				propertyTable: null,
+				nullFeatureId: null,
+				...rest,
+			};
+
+			if ( texture ) {
+
+				result.texture = {
+					texCoord: 0,
+					channels: [ 0 ],
+					...texture,
+				};
+
+			}
+
+			return result;
+
+		} );
+
+	}
+
+	// returns list of textures
+	getTextures() {
+
+		return this.textures;
+
+	}
+
+	// returns a set of info for each feature
+	getFeatureInfo() {
+
+		return this.featureIds;
+
+	}
+
+	// performs texture data read back asynchronously
+	getFeaturesAsync( ...args ) {
+
+		this._asyncRead = true;
+		const result = this.getFeatures( ...args );
+		this._asyncRead = false;
+		return result;
+
+	}
+
+	// returns all features for the given point on the given triangle
+	getFeatures( triangle, barycoord ) {
+
+		const { geometry, textures, featureIds } = this;
+		const result = new Array( featureIds.length ).fill( null );
+
+		// prep the canvas width
+		const width = featureIds.length;
+		TextureReadUtility.increaseSizeTo( width );
+
+		// get the attribute indices
+		const indices = getTriangleVertexIndices( geometry, triangle );
+		const closestIndex = indices[ getMaxBarycoordIndex( barycoord ) ];
+		for ( let i = 0, l = featureIds.length; i < l; i ++ ) {
+
+			// the feature id from the closest point is returned
+			const featureId = featureIds[ i ];
+			const nullFeatureId = 'nullFeatureId' in featureId ? featureId.nullFeatureId : null;
+			if ( 'texture' in featureId ) {
+
+				const texture = textures[ featureId.texture.index ];
+
+				// get the attribute of the target tex coord and pixel
+				getTexCoord( geometry, featureId.texture.texCoord, barycoord, indices, _uv );
+				getTexelIndices( _uv, texture.image.width, texture.image.height, _pixel );
+				_dstPixel.set( i, 0 );
+
+				// draw the image
+				TextureReadUtility.renderPixelToTarget( textures[ featureId.texture.index ], _pixel, _dstPixel );
+
+			} else if ( 'attribute' in featureId ) {
+
+				const attr = geometry.getAttribute( `_feature_id_${ featureId.attribute }` );
+				const value = attr.getX( closestIndex );
+				if ( value !== nullFeatureId ) {
+
+					result[ i ] = value;
+
+				}
+
+			} else {
+
+				// implicit id is based on vertex attributes, see 3d-tiles#763
+				const value = closestIndex;
+				if ( value !== nullFeatureId ) {
+
+					result[ i ] = value;
+
+				}
+
+			}
+
+		}
+
+		// read the buffer data
+		const buffer = new Uint8Array( width * 4 );
+		if ( this._asyncRead ) {
+
+			return TextureReadUtility
+				.readDataAsync( buffer )
+				.then( () => {
+
+					readTextureSampleResults();
+					return result;
+
+				} );
+
+		} else {
+
+			TextureReadUtility.readData( buffer );
+			readTextureSampleResults();
+
+			return result;
+
+		}
+
+		function readTextureSampleResults() {
+
+			// get data based on the texture information
+			const readBuffer = new Uint32Array( 1 );
+			for ( let i = 0, l = featureIds.length; i < l; i ++ ) {
+
+				const featureId = featureIds[ i ];
+				const nullFeatureId = 'nullFeatureId' in featureId ? featureId.nullFeatureId : null;
+				if ( 'texture' in featureId ) {
+
+					// TODO: do we need to handle big-endian here?
+					const { channels } = featureId.texture;
+					const data = channels.map( c => buffer[ 4 * i + c ] );
+					new Uint8Array( readBuffer.buffer ).set( data );
+
+					const value = readBuffer[ 0 ];
+					if ( value !== nullFeatureId ) {
+
+						result[ i ] = value;
+
+					}
+
+				}
+
+			}
+
+		}
+
+	}
+
+	// dispose all of the texture data used
+	dispose() {
+
+		this.textures.forEach( texture => {
+
+			if ( texture ) {
+
+				texture.dispose();
+
+				if ( texture.image instanceof ImageBitmap ) {
+
+					texture.image.close();
+
+				}
+
+			}
+
+		} );
+
+	}
+
+}

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

@@ -0,0 +1,107 @@
+import { initializeFromClass, isMatrixType, isVectorType } from '../utilities/ClassPropertyHelpers.js';
+import { ClassProperty } from './ClassProperty.js';
+import { PropertySetAccessor } from './PropertySetAccessor.js';
+
+class PropertyAttributeClassProperty extends ClassProperty {
+
+	constructor( enums, classProperty, attributeProperty = null ) {
+
+		super( enums, classProperty, attributeProperty );
+
+		this.attribute = attributeProperty.attribute;
+
+	}
+
+}
+
+export class PropertyAttributeAccessor extends PropertySetAccessor {
+
+	constructor( ...args ) {
+
+		super( ...args );
+
+		this.isPropertyAttributeAccessor = true;
+		this._initProperties( PropertyAttributeClassProperty );
+
+	}
+
+	getData( id, geometry, target = {} ) {
+
+		const properties = this.properties;
+		initializeFromClass( properties, target );
+
+		for ( const name in properties ) {
+
+			target[ name ] = this.getPropertyValue( name, id, geometry, target[ name ] );
+
+		}
+
+		return target;
+
+	}
+
+	getPropertyValue( name, id, geometry, target = null ) {
+
+		// NOTE: arrays are not supported via attribute accessors
+		if ( id >= this.count ) {
+
+			throw new Error( 'PropertyAttributeAccessor: Requested index is outside the range of the buffer.' );
+
+		}
+
+		// use a default of the texture accessor definition does not include the value
+		const property = this.properties[ name ];
+		const type = property.type;
+		if ( ! property ) {
+
+			throw new Error( 'PropertyAttributeAccessor: Requested class property does not exist.' );
+
+		} else if ( ! this.definition.properties[ name ] ) {
+
+			return property.resolveDefault( target );
+
+		}
+
+		// initialize the array
+		target = property.shapeToProperty( target );
+
+		// Read the data values from the attribute
+		const attribute = geometry.getAttribute( property.attribute.toLowerCase() );
+		if ( isMatrixType( type ) ) {
+
+			const elements = target.elements;
+			for ( let i = 0, l = elements.length; i < l; i < l ) {
+
+				elements[ i ] = attribute.getComponent( id, i );
+
+			}
+
+		} else if ( isVectorType( type ) ) {
+
+			target.fromBufferAttribute( attribute, id );
+
+		} else if ( type === 'SCALAR' || type === 'ENUM' ) {
+
+			target = attribute.getX( id );
+
+		} else {
+
+			// BOOLEAN, STRING not supported
+			throw new Error( 'StructuredMetadata.PropertyAttributeAccessor: BOOLEAN and STRING types are not supported by property attributes.' );
+
+		}
+
+		// 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/PropertySetAccessor.js

@@ -0,0 +1,45 @@
+import { ClassProperty } from './ClassProperty.js';
+
+export class PropertySetAccessor {
+
+	constructor( definition, classes = {}, enums = {}, data = null ) {
+
+		this.definition = definition;
+		this.class = classes[ definition.class ];
+		this.className = definition.class;
+		this.enums = enums;
+		this.data = data;
+		this.name = 'name' in definition ? definition.name : null;
+
+		this.properties = null;
+
+	}
+
+	getPropertyNames() {
+
+		return Object.keys( this.class.properties );
+
+	}
+
+	includesData( name ) {
+
+		return Boolean( this.definition.properties[ name ] );
+
+	}
+
+	dispose() {}
+
+	_initProperties( propertyClass = ClassProperty ) {
+
+		const properties = {};
+		for ( const key in this.class.properties ) {
+
+			properties[ key ] = new propertyClass( this.enums, this.class.properties[ key ], this.definition.properties[ key ] );
+
+		}
+
+		this.properties = properties;
+
+	}
+
+}