t3d-3dtiles 0.1.0

package/src/loaders/parsers/i3dm/I3DMParser.js

@@ -0,0 +1,28 @@
+import { GLTFUtils } from '../../../libs/glTF/GLTFUtils.js';
+
+export class I3DMParser {
+
+	static parse(context, loader) {
+		const bodyBytes = new Uint8Array(
+			context.options.buffer,
+			context.batchTableEnd,
+			context.header.byteLength - context.batchTableEnd
+		);
+
+		let promise = null;
+		if (context.header.gltfFormat === 1) {
+			promise = Promise.resolve(bodyBytes);
+		} else {
+			const externalUri = GLTFUtils.resolveURL(GLTFUtils.decodeText(bodyBytes), context.path);
+			promise = loader.loadFile(externalUri, 'arraybuffer').then(buffer => new Uint8Array(buffer));
+		}
+
+		return promise.then(glbBytes => {
+			const glbData = GLTFUtils.parseGLB(glbBytes.slice().buffer);
+
+			context.gltf = glbData.gltf;
+			context.buffers = glbData.buffers;
+		});
+	}
+
+}

package/src/loaders/parsers/i3dm/I3DMRootParser.js

@@ -0,0 +1,123 @@
+import { Vector3, Matrix4, Quaternion, Attribute, Buffer } from 't3d';
+
+export class I3DMRootParser {
+
+	static parse(context, loader) {
+		const { featureTable, root, options } = context;
+
+		const INSTANCES_LENGTH = featureTable.getData('INSTANCES_LENGTH');
+		const POSITION = featureTable.getData('POSITION', INSTANCES_LENGTH, 'FLOAT', 'VEC3');
+		const NORMAL_UP = featureTable.getData('NORMAL_UP', INSTANCES_LENGTH, 'FLOAT', 'VEC3');
+		const NORMAL_RIGHT = featureTable.getData('NORMAL_RIGHT', INSTANCES_LENGTH, 'FLOAT', 'VEC3');
+		const SCALE = featureTable.getData('SCALE', INSTANCES_LENGTH, 'FLOAT', 'SCALAR');
+		const SCALE_NON_UNIFORM = featureTable.getData('SCALE_NON_UNIFORM', INSTANCES_LENGTH, 'FLOAT', 'VEC3');
+
+		// check unsupported features
+
+		[
+			// Global Properties
+			'QUANTIZED_VOLUME_OFFSET',
+			'QUANTIZED_VOLUME_SCALE',
+			'EAST_NORTH_UP',
+
+			// Per-instance Properties
+			'POSITION_QUANTIZED',
+			'NORMAL_UP_OCT32P',
+			'NORMAL_RIGHT_OCT32P'
+		].forEach(feature => {
+			if (feature in featureTable.header) {
+				console.warn(`I3DMLoader: Unsupported FeatureTable feature "${feature}" detected.`);
+			}
+		});
+
+		// set instance matrix for all geometries
+
+		const averageVector = new Vector3();
+		for (let i = 0; i < INSTANCES_LENGTH; i++) {
+			averageVector.x += POSITION[i * 3 + 0] / INSTANCES_LENGTH;
+			averageVector.y += POSITION[i * 3 + 1] / INSTANCES_LENGTH;
+			averageVector.z += POSITION[i * 3 + 2] / INSTANCES_LENGTH;
+		}
+
+		const instances = [];
+
+		root.traverse(child => {
+			if (child.isMesh) {
+				const { geometry } = child;
+				geometry.instanceCount = INSTANCES_LENGTH;
+
+				const instanceMatrix = new Attribute(new Buffer(new Float32Array(INSTANCES_LENGTH * 16), 16), 16);
+				instanceMatrix.divisor = 1;
+				geometry.addAttribute('instanceMatrix', instanceMatrix);
+
+				// Center the instance around an average point to avoid jitter at large scales.
+				// Transform the average vector by matrix world so we can account for any existing
+				// transforms of the instanced mesh.
+				child.updateMatrix(true);
+				child.position.copy(averageVector).applyMatrix4(child.worldMatrix);
+
+				instances.push(child);
+			}
+		});
+
+		for (let i = 0; i < INSTANCES_LENGTH; i++) {
+			// position
+			tempPos.fromArray(POSITION, i * 3).sub(averageVector);
+
+			// rotation
+			if (NORMAL_UP) {
+				tempUp.fromArray(NORMAL_UP, i * 3);
+				tempRight.fromArray(NORMAL_RIGHT, i * 3);
+				tempFwd.crossVectors(tempRight, tempUp).normalize();
+
+				tempMat.set(
+					tempRight.x, tempUp.x, tempFwd.x, 0,
+					tempRight.y, tempUp.y, tempFwd.y, 0,
+					tempRight.z, tempUp.z, tempFwd.z, 0,
+					0, 0, 0, 1
+				);
+
+				tempQuat.setFromRotationMatrix(tempMat);
+			} else {
+				tempQuat.set(0, 0, 0, 1);
+			}
+
+			// scale
+			if (SCALE) {
+				tempSca.set(SCALE[i], SCALE[i], SCALE[i]);
+			} else if (SCALE_NON_UNIFORM) {
+				tempSca.fromArray(SCALE_NON_UNIFORM, i * 3);
+			} else {
+				tempSca.set(1, 1, 1);
+			}
+
+			// TODO instance matrix should be applied to model root
+			tempMat.transform(tempPos, tempSca, tempQuat).multiply(options.adjustmentTransform);
+
+			for (let j = 0, l = instances.length; j < l; j++) {
+				const { geometry } = instances[j];
+				const instanceArray = geometry.getAttribute('instanceMatrix').buffer.array;
+				tempMat.toArray(instanceArray, i * 16);
+				geometry.version++;
+			}
+		}
+
+		// fix rtc center
+
+		const rtcCenter = featureTable.getData('RTC_CENTER');
+		if (rtcCenter) {
+			root.position.x += rtcCenter[0];
+			root.position.y += rtcCenter[1];
+			root.position.z += rtcCenter[2];
+		}
+	}
+
+}
+
+const tempFwd = new Vector3();
+const tempUp = new Vector3();
+const tempRight = new Vector3();
+const tempPos = new Vector3();
+const tempQuat = new Quaternion();
+const tempSca = new Vector3();
+const tempMat = new Matrix4();

package/src/loaders/parsers/i3dm/MaterialParser.js

@@ -0,0 +1,152 @@
+import {
+	Color3,
+	// PBRMaterial,
+	DRAW_SIDE,
+	TEXEL_ENCODING_TYPE
+} from 't3d';
+// import { KHR_materials_unlit as _KHR_materials_unlit } from '../../../libs/glTF/extensions/KHR_materials_unlit.js';
+import { KHR_materials_pbrSpecularGlossiness as _KHR_materials_pbrSpecularGlossiness } from '../../../libs/glTF/extensions/KHR_materials_pbrSpecularGlossiness.js';
+import { KHR_materials_clearcoat as _KHR_materials_clearcoat } from '../../../libs/glTF/extensions/KHR_materials_clearcoat.js';
+import { KHR_texture_transform } from '../../../libs/glTF/extensions/KHR_texture_transform.js';
+import { ALPHA_MODES } from '../../../libs/glTF/Constants.js';
+
+import { InstancedPBRMaterial } from '../../../materials/InstancedPBRMaterial.js'; // @parser-modification - instanced materials
+import { InstancedBasicMaterial } from '../../../materials/InstancedBasicMaterial.js'; // @parser-modification - instanced materials
+
+export class MaterialParser {
+
+	static parse(context) {
+		const { gltf, textures } = context;
+
+		if (!gltf.materials) return;
+
+		const materials = [];
+		for (let i = 0; i < gltf.materials.length; i++) {
+			const {
+				extensions = {},
+				pbrMetallicRoughness,
+				normalTexture,
+				occlusionTexture,
+				emissiveTexture,
+				emissiveFactor,
+				alphaMode,
+				alphaCutoff,
+				doubleSided,
+				name = ''
+			} = gltf.materials[i];
+
+			const { KHR_materials_unlit, KHR_materials_pbrSpecularGlossiness, KHR_materials_clearcoat } = extensions;
+
+			let material = null;
+			if (KHR_materials_unlit) {
+				material = new InstancedBasicMaterial(); // @parser-modification - instanced materials
+			} else if (KHR_materials_pbrSpecularGlossiness) {
+				// TODO - InstancedPBR2Material
+				material = new InstancedPBRMaterial(); // @parser-modification - instanced materials
+				material.specular = new Color3(0x111111);
+				_KHR_materials_pbrSpecularGlossiness.parseParams(material, KHR_materials_pbrSpecularGlossiness, textures);
+			} else if (KHR_materials_clearcoat) {
+				material = new InstancedPBRMaterial(); // @parser-modification - instanced materials
+				_KHR_materials_clearcoat.parseParams(material, KHR_materials_clearcoat, textures);
+			} else {
+				material = new InstancedPBRMaterial(); // @parser-modification - instanced materials
+			}
+
+			material.name = name;
+
+			if (pbrMetallicRoughness) {
+				const { baseColorFactor, baseColorTexture, metallicFactor, roughnessFactor, metallicRoughnessTexture } = pbrMetallicRoughness;
+
+				if (Array.isArray(baseColorFactor)) {
+					material.diffuse.fromArray(baseColorFactor);
+					material.opacity = (baseColorFactor[3] !== undefined) ? baseColorFactor[3] : 1;
+				}
+
+				if (baseColorTexture) {
+					material.diffuseMap = textures[baseColorTexture.index];
+					material.diffuseMapCoord = baseColorTexture.texCoord || 0;
+					if (material.diffuseMap) {
+						material.diffuseMap.encoding = TEXEL_ENCODING_TYPE.SRGB;
+						parseTextureTransform(material, 'diffuseMap', baseColorTexture.extensions);
+					}
+				}
+
+				if (!KHR_materials_unlit && !KHR_materials_pbrSpecularGlossiness) {
+					material.metalness = metallicFactor !== undefined ? metallicFactor : 1;
+					material.roughness = roughnessFactor !== undefined ? roughnessFactor : 1;
+					if (metallicRoughnessTexture) {
+						material.metalnessMap = textures[metallicRoughnessTexture.index];
+						material.roughnessMap = textures[metallicRoughnessTexture.index];
+						// parseTextureTransform(material, 'metalnessMap', metallicRoughnessTexture.extensions);
+						// parseTextureTransform(material, 'roughnessMap', metallicRoughnessTexture.extensions);
+					}
+				}
+			}
+
+			if (emissiveFactor) {
+				material.emissive.fromArray(emissiveFactor);
+			}
+
+			if (emissiveTexture) {
+				material.emissiveMap = textures[emissiveTexture.index];
+				material.emissiveMapCoord = emissiveTexture.texCoord || 0;
+				if (material.emissiveMap) {
+					material.emissiveMap.encoding = TEXEL_ENCODING_TYPE.SRGB;
+					parseTextureTransform(material, 'emissiveMap', emissiveTexture.extensions);
+				}
+			}
+
+			if (occlusionTexture) {
+				material.aoMap = textures[occlusionTexture.index];
+				material.aoMapCoord = occlusionTexture.texCoord || 0;
+				if (occlusionTexture.strength !== undefined) {
+					material.aoMapIntensity = occlusionTexture.strength;
+				}
+				if (material.aoMap) {
+					parseTextureTransform(material, 'aoMap', occlusionTexture.extensions);
+				}
+			}
+
+			if (!KHR_materials_unlit) {
+				if (normalTexture) {
+					material.normalMap = textures[normalTexture.index];
+
+					material.normalScale.set(1, -1);
+					if (normalTexture.scale !== undefined) {
+						// fix flip y for normal map
+						// https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
+						material.normalScale.set(normalTexture.scale, -normalTexture.scale);
+					}
+
+					if (material.normalMap) {
+						// parseTextureTransform(material, 'normalMap', normalTexture.extensions);
+					}
+				}
+			}
+
+			material.side = doubleSided === true ? DRAW_SIDE.DOUBLE : DRAW_SIDE.FRONT;
+
+			if (alphaMode === ALPHA_MODES.BLEND) {
+				material.transparent = true;
+			} else {
+				material.transparent = false;
+
+				if (alphaMode === ALPHA_MODES.MASK) {
+					material.alphaTest = alphaCutoff !== undefined ? alphaCutoff : 0.5;
+				}
+			}
+
+			materials[i] = material;
+		}
+
+		context.materials = materials;
+	}
+
+}
+
+function parseTextureTransform(material, key, extensions = {}) {
+	const extension = extensions.KHR_texture_transform;
+	if (extension) {
+		KHR_texture_transform.transform(material[key + 'Transform'], extension);
+	}
+}

package/src/loaders/parsers/i3dm/PrimitiveParser.js

@@ -0,0 +1,291 @@
+import { Geometry, /* PBRMaterial, */ VERTEX_COLOR, SHADING_TYPE, PointsMaterial, Material, BasicMaterial } from 't3d';
+import { GLTFUtils } from '../../../libs/glTF/GLTFUtils.js';
+import { ATTRIBUTES, ACCESSOR_COMPONENT_TYPES, WEBGL_DRAW_MODES } from '../../../libs/glTF/Constants.js';
+import { KHR_draco_mesh_compression as _KHR_draco_mesh_compression } from '../../../libs/glTF/extensions/KHR_draco_mesh_compression.js';
+
+import { InstancedPBRMaterial } from '../../../materials/InstancedPBRMaterial.js'; // @parser-modification - instanced materials
+
+export class PrimitiveParser {
+
+	static parse(context, loader) {
+		const { gltf, accessors, materials, bufferViews } = context;
+
+		if (!gltf.meshes) return;
+
+		const materialCache = new Map();
+		const geometryPromiseCache = new Map();
+
+		const meshPromises = [];
+		for (let i = 0; i < gltf.meshes.length; i++) {
+			const gltfMesh = gltf.meshes[i];
+
+			const primitivePromises = [];
+			for (let j = 0; j < gltfMesh.primitives.length; j++) {
+				const gltfPrimitive = gltfMesh.primitives[j];
+				const {
+					extensions = {},
+					mode,
+					material
+				} = gltfPrimitive;
+				const { KHR_draco_mesh_compression } = extensions;
+
+				let geometryPromise;
+
+				const geometryKey = createGeometryKey(gltfPrimitive);
+				if (geometryPromiseCache.has(geometryKey)) {
+					geometryPromise = geometryPromiseCache.get(geometryKey);
+				} else {
+					if (KHR_draco_mesh_compression) {
+						geometryPromise = _KHR_draco_mesh_compression.getGeometry(KHR_draco_mesh_compression, bufferViews, gltfPrimitive.attributes, gltf.accessors, loader.getDRACOLoader());
+					} else {
+						geometryPromise = Promise.resolve(new Geometry());
+					}
+
+					geometryPromise = geometryPromise.then(geometry => {
+						parseGeometryFromGLTFPrimitive(geometry, gltfPrimitive, gltf, accessors);
+						return geometry;
+					});
+
+					geometryPromiseCache.set(geometryKey, geometryPromise);
+				}
+
+				const primitivePromise = geometryPromise.then(geometry => {
+					const primitive = {
+						mode,
+						geometry,
+						material: material === undefined ? new InstancedPBRMaterial() : materials[material], // @parser-modification - instanced materials
+						weights: (Object.keys(geometry.morphAttributes).length > 0 && gltfMesh.weights) ? gltfMesh.weights.slice(0) : undefined,
+						skinned: gltfMesh.isSkinned
+					};
+					assignFinalMaterial(primitive, materialCache);
+					return primitive;
+				});
+
+				primitivePromises.push(primitivePromise);
+			}
+			meshPromises.push(Promise.all(primitivePromises));
+		}
+
+		materialCache.clear();
+		geometryPromiseCache.clear();
+
+		return Promise.all(meshPromises).then(primitives => {
+			context.primitives = primitives;
+		});
+	}
+
+}
+
+function parseGeometryFromGLTFPrimitive(geometry, gltfPrimitive, gltf, accessors) {
+	const { attributes, indices, targets } = gltfPrimitive;
+
+	// set attributes
+
+	for (const attributeSemantic in attributes) {
+		const accessorIdx = attributes[attributeSemantic];
+
+		const attributeName = ATTRIBUTES[attributeSemantic] === undefined ? attributeSemantic : ATTRIBUTES[attributeSemantic];
+		// Skip attributes already provided by e.g. Draco extension.
+		if (attributeName in geometry.attributes) continue;
+
+		geometry.addAttribute(attributeName, accessors[accessorIdx]);
+	}
+
+	// set index
+
+	if (indices !== undefined && !geometry.index) {
+		geometry.setIndex(accessors[indices]);
+	}
+
+	// compute bounds
+
+	const { boundingBox, boundingSphere } = geometry;
+	if (attributes.POSITION !== undefined) {
+		const accessorIdx = attributes.POSITION;
+		const accessor = gltf.accessors[accessorIdx];
+
+		if (accessor.min && accessor.max) {
+			boundingBox.min.fromArray(accessor.min);
+			boundingBox.max.fromArray(accessor.max);
+
+			if (accessor.normalized) {
+				const boxScale = GLTFUtils.getNormalizedComponentScale(ACCESSOR_COMPONENT_TYPES[accessor.componentType]);
+				boundingBox.min.multiplyScalar(boxScale);
+				boundingBox.max.multiplyScalar(boxScale);
+			}
+		} else {
+			geometry.computeBoundingBox();
+		}
+	} else {
+		geometry.computeBoundingBox();
+	}
+	boundingBox.getCenter(boundingSphere.center);
+	boundingSphere.radius = boundingBox.min.distanceTo(boundingBox.max) / 2;
+
+	// set morph targets
+
+	if (targets) {
+		let hasMorphPosition = false;
+		let hasMorphNormal = false;
+
+		for (let i = 0, il = targets.length; i < il; i++) {
+			const target = targets[i];
+
+			if (target.POSITION !== undefined) hasMorphPosition = true;
+			if (target.NORMAL !== undefined) hasMorphNormal = true;
+
+			if (hasMorphPosition && hasMorphNormal) break;
+		}
+
+		if (hasMorphPosition || hasMorphNormal) {
+			const morphPositions = [];
+			const morphNormals = [];
+
+			for (let i = 0, il = targets.length; i < il; i++) {
+				const target = targets[i];
+
+				if (hasMorphPosition) {
+					morphPositions.push(target.POSITION !== undefined ? accessors[target.POSITION] : geometry.attributes[ATTRIBUTES.POSITION]);
+				}
+				if (hasMorphNormal) {
+					morphNormals.push(target.NORMAL !== undefined ? accessors[target.NORMAL] : geometry.attributes[ATTRIBUTES.NORMAL]);
+				}
+			}
+
+			if (hasMorphPosition) {
+				geometry.morphAttributes.position = morphPositions;
+			}
+			if (hasMorphNormal) {
+				geometry.morphAttributes.normal = morphNormals;
+			}
+		}
+	}
+
+	return geometry;
+}
+
+function assignFinalMaterial(primitive, materialCache) {
+	let { geometry, material, skinned, mode } = primitive;
+
+	// If the material will be modified later on, clone it now.
+	const useVertexTangents = geometry.attributes[ATTRIBUTES.TANGENT] !== undefined;
+	const useVertexColors = geometry.attributes[ATTRIBUTES.COLOR_0] !== undefined;
+	const useFlatShading = geometry.attributes[ATTRIBUTES.NORMAL] === undefined;
+	const useSkinning = skinned;
+
+	if (mode === WEBGL_DRAW_MODES.POINTS) {
+		const cacheKey = 'PointsMaterial:' + material.id;
+		let pointsMaterial = materialCache.get(cacheKey);
+		if (!pointsMaterial) {
+			pointsMaterial = new PointsMaterial();
+			Material.prototype.copy.call(pointsMaterial, material);
+			pointsMaterial.diffuse.copy(material.diffuse);
+			pointsMaterial.diffuseMap = material.map;
+			pointsMaterial.drawMode = mode;
+			pointsMaterial.acceptLight = false; // PointsMaterial doesn't support lights yet
+			materialCache.set(cacheKey, pointsMaterial);
+		}
+		material = pointsMaterial;
+	} else if (mode === WEBGL_DRAW_MODES.LINES || mode === WEBGL_DRAW_MODES.LINE_STRIP || mode === WEBGL_DRAW_MODES.LINE_LOOP) {
+		const cacheKey = 'BasicMaterial:' + material.id;
+		let basicMaterial = materialCache.get(cacheKey);
+		if (!basicMaterial) {
+			basicMaterial = new BasicMaterial();
+			basicMaterial.envMap = undefined; // force close env map
+			basicMaterial.diffuse.copy(material.diffuse);
+			basicMaterial.diffuseMap = material.diffuseMap;
+			basicMaterial.drawMode = mode;
+			materialCache.set(cacheKey, basicMaterial);
+		}
+		material = basicMaterial;
+	} else if (mode === WEBGL_DRAW_MODES.TRIANGLE_STRIP) {
+		// TODO
+		console.warn('TRIANGLE_STRIP will be removed later.');
+		material.drawMode = WEBGL_DRAW_MODES.TRIANGLE_STRIP;
+	} else if (mode === WEBGL_DRAW_MODES.TRIANGLE_FAN) {
+		// TODO
+		console.warn('TRIANGLE_FAN will be removed later.');
+		material.drawMode = WEBGL_DRAW_MODES.TRIANGLE_FAN;
+	}
+
+	if (useVertexTangents || useVertexColors || useFlatShading || useSkinning) {
+		let cacheKey = 'ClonedMaterial:' + material.id + ':';
+
+		if (useVertexTangents) cacheKey += 'vertex-tangents:';
+		if (useVertexColors) {
+			if (geometry.attributes[ATTRIBUTES.COLOR_0].size === 3) {
+				cacheKey += 'vertex-colors-rgb:';
+			} else if (geometry.attributes[ATTRIBUTES.COLOR_0].size === 4) {
+				cacheKey += 'vertex-colors-rgba:';
+			}
+		}
+		if (useFlatShading) cacheKey += 'flat-shading:';
+
+		let cachedMaterial = materialCache.get(cacheKey);
+
+		if (!cachedMaterial) {
+			cachedMaterial = material.clone();
+
+			if (useVertexTangents) {
+				cachedMaterial.vertexTangents = true;
+
+				// revert flip y fix for tangents
+				// https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
+				if (cachedMaterial.normalMap) {
+					cachedMaterial.normalScale.y *= -1;
+				}
+			}
+
+			if (useVertexColors) {
+				if (geometry.attributes[ATTRIBUTES.COLOR_0].size === 3) {
+					cachedMaterial.vertexColors = VERTEX_COLOR.RGB;
+				} else if (geometry.attributes[ATTRIBUTES.COLOR_0].size === 4) {
+					cachedMaterial.vertexColors = VERTEX_COLOR.RGBA;
+				} else {
+					console.warn('Illegal vertex color size: ' + geometry.attributes[ATTRIBUTES.COLOR_0].size);
+				}
+			}
+
+			if (useFlatShading) {
+				cachedMaterial.shading = SHADING_TYPE.FLAT_SHADING;
+			}
+		}
+
+		material = cachedMaterial;
+	}
+
+	primitive.material = material;
+}
+
+function createGeometryKey(primitive) {
+	const dracoExtension = primitive.extensions && primitive.extensions.KHR_draco_mesh_compression;
+	let geometryKey;
+
+	if (dracoExtension) {
+		geometryKey = 'draco:' + dracoExtension.bufferView
+				+ ':' + dracoExtension.indices
+				+ ':' + createAttributesKey(dracoExtension.attributes);
+	} else {
+		geometryKey = primitive.indices + ':' + createAttributesKey(primitive.attributes) + ':' + primitive.mode;
+	}
+
+	if (primitive.targets) {
+		for (let i = 0, il = primitive.targets.length; i < il; i++) {
+			geometryKey += ':' + createAttributesKey(primitive.targets[i]);
+		}
+	}
+
+	return geometryKey;
+}
+
+function createAttributesKey(attributes) {
+	let attributesKey = '';
+
+	const keys = Object.keys(attributes).sort();
+
+	for (let i = 0, il = keys.length; i < il; i++) {
+		attributesKey += keys[i] + ':' + attributes[keys[i]] + ';';
+	}
+
+	return attributesKey;
+}

package/src/loaders/parsers/pnts/PNTSRootParser.js

@@ -0,0 +1,69 @@
+import { Mesh, Geometry, PointsMaterial, Attribute, Buffer, VERTEX_COLOR } from 't3d';
+
+export class PNTSRootParser {
+
+	static parse(context, loader) {
+		const { featureTable } = context;
+
+		const POINTS_LENGTH = featureTable.getData('POINTS_LENGTH');
+		const POSITION = featureTable.getData('POSITION', POINTS_LENGTH, 'FLOAT', 'VEC3');
+		const RGB = featureTable.getData('RGB', POINTS_LENGTH, 'UNSIGNED_BYTE', 'VEC3');
+		const RGBA = featureTable.getData('RGBA', POINTS_LENGTH, 'UNSIGNED_BYTE', 'VEC4');
+
+		// check unsupported features
+
+		[
+			// Global Properties
+			'QUANTIZED_VOLUME_OFFSET',
+			'QUANTIZED_VOLUME_SCALE',
+			'CONSTANT_RGBA',
+			'BATCH_LENGTH',
+
+			// Per-point Properties
+			'POSITION_QUANTIZED',
+			'RGB565',
+			'NORMAL',
+			'NORMAL_OCT16P',
+			'BATCH_ID'
+		].forEach(feature => {
+			if (feature in featureTable.header) {
+				console.warn(`PNTSLoader: Unsupported FeatureTable feature "${feature}" detected.`);
+			}
+		});
+
+		// generate root
+
+		const geometry = new Geometry();
+		geometry.addAttribute('a_Position', new Attribute(new Buffer(POSITION, 3), 3, 0, true));
+		geometry.computeBoundingBox();
+		geometry.computeBoundingSphere();
+
+		const material = new PointsMaterial();
+		material.size = 2;
+		material.sizeAttenuation = false;
+
+		if (RGB !== null) {
+			geometry.addAttribute('a_Color', new Attribute(new Buffer(RGB, 3), 3, 0, true));
+			material.vertexColors = VERTEX_COLOR.RGB;
+		} else if (RGBA !== null) {
+			geometry.addAttribute('a_Color', new Attribute(new Buffer(RGBA, 4), 4, 0, true));
+			material.vertexColors = VERTEX_COLOR.RGBA;
+		}
+
+		const root = new Mesh(geometry, material);
+
+		// output mesh to root
+
+		context.root = root;
+
+		// fix rtc center
+
+		const rtcCenter = featureTable.getData('RTC_CENTER');
+		if (rtcCenter) {
+			root.position.x += rtcCenter[0];
+			root.position.y += rtcCenter[1];
+			root.position.z += rtcCenter[2];
+		}
+	}
+
+}

package/src/main.js

@@ -0,0 +1,14 @@
+export * from './Tiles3D.js';
+
+export * from './math/OBB.js';
+
+export * from './materials/InstancedBasicMaterial.js';
+export * from './materials/InstancedPBRMaterial.js';
+
+export * from './loaders/B3DMLoader.js';
+export * from './loaders/CMPTLoader.js';
+export * from './loaders/TileGLTFLoader.js';
+export * from './loaders/I3DMLoader.js';
+export * from './loaders/PNTSLoader.js';
+
+export { LoadParser as DebugLoadParser } from './loaders/parsers/LoadParser.js';