t3d-3dtiles 0.1.0

package/src/libs/glTF/extensions/KHR_materials_pbrSpecularGlossiness.js

@@ -0,0 +1,53 @@
+import { TEXEL_ENCODING_TYPE, PBR2Material } from 't3d';
+import { KHR_texture_transform } from './KHR_texture_transform.js';
+
+/**
+ * KHR_materials_pbrSpecularGlossiness extension
+ * https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
+ */
+export class KHR_materials_pbrSpecularGlossiness {
+
+	static getMaterial() {
+		return new PBR2Material();
+	}
+
+	static parseParams(material, params, textures) {
+		const { diffuseFactor, diffuseTexture, specularFactor, glossinessFactor, specularGlossinessTexture } = params;
+
+		if (Array.isArray(diffuseFactor)) {
+			material.diffuse.fromArray(diffuseFactor);
+			material.opacity = diffuseFactor[3] || 1;
+		}
+
+		if (diffuseTexture) {
+			material.diffuseMap = textures[diffuseTexture.index];
+			material.diffuseMapCoord = diffuseTexture.texCoord || 0;
+			if (material.diffuseMap) {
+				material.diffuseMap.encoding = TEXEL_ENCODING_TYPE.SRGB;
+			}
+			parseTextureTransform(material, 'diffuseMap', diffuseTexture.extensions);
+		}
+
+		material.glossiness = glossinessFactor !== undefined ? glossinessFactor : 1.0;
+
+		if (Array.isArray(specularFactor)) {
+			material.specular.fromArray(specularFactor);
+		}
+
+		if (specularGlossinessTexture) {
+			material.glossinessMap = textures[specularGlossinessTexture.index];
+			material.specularMap = textures[specularGlossinessTexture.index];
+			// material does not yet support the transform of glossinessMap and specularMap.
+			// parseTextureTransform(material, 'glossinessMap', specularGlossinessTexture.extensions);
+			// parseTextureTransform(material, 'specularMap', specularGlossinessTexture.extensions);
+		}
+	}
+
+}
+
+function parseTextureTransform(material, key, extensions = {}) {
+	const extension = extensions.KHR_texture_transform;
+	if (extension) {
+		material[key] = KHR_texture_transform.transform(material[key + 'Transform'], extension);
+	}
+}

package/src/libs/glTF/extensions/KHR_materials_unlit.js

@@ -0,0 +1,13 @@
+import { BasicMaterial } from 't3d';
+
+/**
+ * KHR_materials_unlit extension
+ * https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
+ */
+export class KHR_materials_unlit {
+
+	static getMaterial() {
+		return new BasicMaterial();
+	}
+
+}

package/src/libs/glTF/extensions/KHR_texture_basisu.js

@@ -0,0 +1,14 @@
+/**
+ * BasisU Texture Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_basisu
+ */
+export class KHR_texture_basisu {
+
+	static loadTextureData(url, ktx2Loader) {
+		return new Promise((resolve, reject) => {
+			ktx2Loader.load(url, resolve, undefined, reject);
+		});
+	}
+
+}

package/src/libs/glTF/extensions/KHR_texture_transform.js

@@ -0,0 +1,31 @@
+/**
+ * KHR_texture_transform extension
+ * https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform
+ */
+export class KHR_texture_transform {
+
+	static transform(matrix, transform) {
+		let offsetX = 0, offsetY = 0, repeatX = 1, repeatY = 1, rotation = 0;
+
+		if (transform.offset !== undefined) {
+			offsetX = transform.offset[0];
+			offsetY = transform.offset[1];
+		}
+
+		if (transform.rotation !== undefined) {
+			rotation = transform.rotation;
+		}
+
+		if (transform.scale !== undefined) {
+			repeatX = transform.scale[0];
+			repeatY = transform.scale[1];
+		}
+
+		matrix.setUvTransform(offsetX, offsetY, repeatX, repeatY, rotation, 0, 0);
+
+		if (transform.texCoord !== undefined) {
+			console.warn('Custom UV sets in KHR_texture_transform extension not yet supported.');
+		}
+	}
+
+}

package/src/libs/glTF/parsers/AccessorParser.js

@@ -0,0 +1,99 @@
+import { Attribute, Buffer } from 't3d';
+import { ACCESSOR_COMPONENT_TYPES, ACCESSOR_TYPE_SIZES } from '../Constants.js';
+
+export class AccessorParser {
+
+	static parse(context) {
+		const { bufferViews, gltf } = context;
+
+		if (!gltf.accessors) return;
+
+		const interleavedBufferCache = new Map();
+
+		const accessors = gltf.accessors.map(accessor => {
+			const { bufferView: bufferViewIndex, type, componentType, count, byteOffset = 0, normalized = false, sparse } = accessor;
+
+			if (bufferViewIndex === undefined && sparse === undefined) {
+				// Ignore empty accessors, which may be used to declare runtime
+				// information about attributes coming from another source (e.g. Draco compression extension).
+				return null;
+			}
+
+			// Get buffer view infos
+			const bufferView = bufferViewIndex !== undefined ? bufferViews[bufferViewIndex] : null;
+			const byteStride = bufferViewIndex !== undefined ? gltf.bufferViews[bufferViewIndex].byteStride : undefined;
+
+			// Get accessor infos
+			const itemSize = ACCESSOR_TYPE_SIZES[type];
+			const TypedArray = ACCESSOR_COMPONENT_TYPES[componentType];
+			const elementBytes = TypedArray.BYTES_PER_ELEMENT;
+			const itemBytes = elementBytes * itemSize; // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
+
+			let array, attribute;
+
+			if (byteStride && byteStride !== itemBytes) { // The buffer is interleaved
+				// Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer
+				// This makes sure that IBA.count reflects accessor.count properly
+				const ibSlice = Math.floor(byteOffset / byteStride);
+				const ibCacheKey = 'Buffer:' + bufferViewIndex + ':' + componentType + ':' + ibSlice + ':' + count;
+				let ib = interleavedBufferCache.get(ibCacheKey);
+
+				if (!ib) {
+					// Use the full buffer if it's interleaved.
+					array = new TypedArray(bufferView, ibSlice * byteStride, count * byteStride / elementBytes);
+
+					// Integer parameters to IB/IBA are in array elements, not bytes.
+					ib = new Buffer(array, byteStride / elementBytes);
+
+					interleavedBufferCache.set(ibCacheKey, ib);
+				}
+
+				attribute = new Attribute(ib, itemSize, (byteOffset % byteStride) / elementBytes, normalized);
+			} else {
+				if (bufferView === null) {
+					array = new TypedArray(count * itemSize);
+				} else {
+					array = new TypedArray(bufferView, byteOffset, count * itemSize);
+				}
+
+				attribute = new Attribute(new Buffer(array, itemSize), itemSize, 0, normalized);
+			}
+
+			// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
+			if (sparse) {
+				const itemSizeIndices = ACCESSOR_TYPE_SIZES.SCALAR;
+				const TypedArrayIndices = ACCESSOR_COMPONENT_TYPES[sparse.indices.componentType];
+
+				const byteOffsetIndices = sparse.indices.byteOffset || 0;
+				const byteOffsetValues = sparse.values.byteOffset || 0;
+
+				const sparseIndices = new TypedArrayIndices(bufferViews[sparse.indices.bufferView], byteOffsetIndices, sparse.count * itemSizeIndices);
+				const sparseValues = new TypedArray(bufferViews[sparse.values.bufferView], byteOffsetValues, sparse.count * itemSize);
+
+				if (bufferView !== null) {
+					// Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.
+					attribute = new Attribute(attribute.buffer.clone(), attribute.size, attribute.offset, attribute.normalized);
+				}
+
+				const buffer = attribute.buffer;
+
+				for (let i = 0, il = sparseIndices.length; i < il; i++) {
+					const index = sparseIndices[i];
+
+					buffer.array[index * attribute.size] = sparseValues[i * itemSize];
+					if (itemSize >= 2) buffer.array[index * attribute.size + 1] = sparseValues[i * itemSize + 1];
+					if (itemSize >= 3) buffer.array[index * attribute.size + 2] = sparseValues[i * itemSize + 2];
+					if (itemSize >= 4) buffer.array[index * attribute.size + 3] = sparseValues[i * itemSize + 3];
+					if (itemSize >= 5) throw new Error('Unsupported itemSize in sparse Attribute.');
+				}
+			}
+
+			return attribute;
+		});
+
+		interleavedBufferCache.clear();
+
+		context.accessors = accessors;
+	}
+
+}

package/src/libs/glTF/parsers/AnimationParser.js

@@ -0,0 +1,118 @@
+import {
+	QuaternionKeyframeTrack,
+	NumberKeyframeTrack,
+	VectorKeyframeTrack,
+	KeyframeClip,
+	StepInterpolant,
+	LinearInterpolant,
+	CubicSplineInterpolant,
+	QuaternionLinearInterpolant,
+	QuaternionCubicSplineInterpolant
+} from 't3d';
+import { GLTFUtils } from '../GLTFUtils.js';
+import { PATH_PROPERTIES } from '../Constants.js';
+
+export class AnimationParser {
+
+	static parse(context) {
+		const { gltf, nodes, accessors } = context;
+		const { animations } = gltf;
+
+		if (!animations) return;
+
+		const animationClips = animations.map((gltfAnimation, index) => {
+			const { channels, samplers, name = `animation_${index}` } = gltfAnimation;
+
+			const tracks = [];
+			let duration = 0;
+
+			for (let i = 0; i < channels.length; i++) {
+				const gltfChannel = channels[i];
+				const gltfSampler = samplers[gltfChannel.sampler];
+				if (gltfSampler) {
+					const target = gltfChannel.target;
+					const name = target.node !== undefined ? target.node : target.id; // Note: target.id is deprecated.
+					const inputAccessor = accessors[gltfSampler.input];
+					const outputAccessor = accessors[gltfSampler.output];
+
+					const node = nodes[name];
+
+					if (!node) continue;
+
+					node.updateMatrix();
+					node.matrixAutoUpdate = true;
+
+					let TypedKeyframeTrack;
+
+					switch (PATH_PROPERTIES[target.path]) {
+						case PATH_PROPERTIES.rotation:
+							TypedKeyframeTrack = QuaternionKeyframeTrack;
+							break;
+						case PATH_PROPERTIES.weights:
+							TypedKeyframeTrack = NumberKeyframeTrack;
+							break;
+						case PATH_PROPERTIES.position:
+						case PATH_PROPERTIES.scale:
+						default:
+							TypedKeyframeTrack = VectorKeyframeTrack;
+							break;
+					}
+
+					if (!TypedKeyframeTrack) {
+						continue;
+					}
+
+					const input = new inputAccessor.buffer.array.constructor(inputAccessor.buffer.array);
+					const output = new Float32Array(outputAccessor.buffer.array);
+
+					if (outputAccessor.normalized) {
+						const scale = GLTFUtils.getNormalizedComponentScale(outputAccessor.buffer.array.constructor);
+						for (let j = 0, jl = output.length; j < jl; j++) {
+							output[j] *= scale;
+						}
+					}
+
+					const targetNodes = [];
+					if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) {
+						// Node may be a Object3D (glTF mesh with several primitives) or a Mesh.
+						node.traverse(function(object) {
+							if (object.isMesh && object.morphTargetInfluences) {
+								targetNodes.push(object);
+							}
+						});
+					} else {
+						targetNodes.push(node);
+					}
+
+					for (let j = 0, jl = targetNodes.length; j < jl; j++) {
+						const interpolant = getInterpolant(gltfSampler.interpolation, TypedKeyframeTrack === QuaternionKeyframeTrack);
+						const track = new TypedKeyframeTrack(targetNodes[j], PATH_PROPERTIES[target.path], input, output, interpolant);
+						tracks.push(track);
+					}
+
+					const maxTime = input[input.length - 1];
+					if (duration < maxTime) {
+						duration = maxTime;
+					}
+				}
+			}
+
+			return new KeyframeClip(name, tracks, duration);
+		});
+
+		context.animations = animationClips;
+	}
+
+}
+
+function getInterpolant(type, quaternion) {
+	switch (type) {
+		case 'STEP':
+			return StepInterpolant;
+		case 'CUBICSPLINE':
+			return quaternion ? QuaternionCubicSplineInterpolant : CubicSplineInterpolant;
+		case 'LINEAR':
+		default:
+			return quaternion ? QuaternionLinearInterpolant : LinearInterpolant;
+	}
+}

package/src/libs/glTF/parsers/BufferParser.js

@@ -0,0 +1,35 @@
+import { GLTFUtils } from '../GLTFUtils.js';
+
+export class BufferParser {
+
+	static parse(context, loader) {
+		const { gltf, loadItems } = context;
+
+		if (context.buffers !== null) {
+			// buffers have been parsed
+			return null;
+		} else {
+			return Promise.all(
+				gltf.buffers.map(buffer => {
+					const bufferUrl = GLTFUtils.resolveURL(buffer.uri, context.path);
+					if (loader.detailLoadProgress) {
+						loadItems.delete(bufferUrl);
+					}
+					const promise = loader.loadFile(bufferUrl, 'arraybuffer').then(buffer => {
+						if (loader.detailLoadProgress) {
+							loader.manager.itemEnd(bufferUrl);
+						}
+						return buffer;
+					});
+					if (loader.detailLoadProgress) {
+						promise.catch(() => loader.manager.itemEnd(bufferUrl));
+					}
+					return promise;
+				})
+			).then(buffers => {
+				context.buffers = buffers;
+			});
+		}
+	}
+
+}

package/src/libs/glTF/parsers/BufferViewParser.js

@@ -0,0 +1,27 @@
+import { EXT_meshopt_compression as _EXT_meshopt_compression } from '../extensions/EXT_meshopt_compression.js';
+export class BufferViewParser {
+
+	static parse(context, loader) {
+		const { buffers, gltf } = context;
+
+		if (!gltf.bufferViews) return;
+
+		return Promise.all(
+			gltf.bufferViews.map(bufferView => {
+				const { buffer, byteOffset = 0, byteLength = 0 } = bufferView;
+
+				if (bufferView.extensions) {
+					const { EXT_meshopt_compression } = bufferView.extensions;
+					if (EXT_meshopt_compression) {
+						return _EXT_meshopt_compression.loadBufferView(EXT_meshopt_compression, buffers, loader.getMeshoptDecoder());
+					}
+				}
+				const arrayBuffer = buffers[buffer];
+				return arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+			})
+		).then(bufferViews => {
+			context.bufferViews = bufferViews;
+		});
+	}
+
+}

package/src/libs/glTF/parsers/ImageParser.js

@@ -0,0 +1,97 @@
+import { GLTFUtils } from '../GLTFUtils.js';
+import { KHR_texture_basisu as _KHR_texture_basisu } from '../extensions/KHR_texture_basisu.js';
+
+export class ImageParser {
+
+	static parse(context, loader) {
+		const { gltf, bufferViews, path, loadItems } = context;
+
+		if (!gltf.images) return;
+
+		return Promise.all(
+			gltf.images.map((params, index) => {
+				const { uri, bufferView: bufferViewIndex, mimeType, name: imageName } = params;
+				let isObjectURL = false;
+				let sourceUrl = uri || '';
+
+				if (bufferViewIndex !== undefined) {
+					const bufferViewData = bufferViews[bufferViewIndex];
+					const blob = new Blob([bufferViewData], { type: mimeType });
+					sourceUrl = URL.createObjectURL(blob);
+					isObjectURL = true;
+				}
+				const imageUrl = GLTFUtils.resolveURL(sourceUrl, path);
+
+				if (loader.detailLoadProgress) {
+					loadItems.delete(imageUrl);
+				}
+				let promise;
+				if (mimeType && mimeType.includes('ktx2')) {
+					promise = _KHR_texture_basisu.loadTextureData(imageUrl, loader.getKTX2Loader()).then(transcodeResult => {
+						if (loader.detailLoadProgress) {
+							if (isObjectURL) {
+								loader.manager.itemEnd(GLTFUtils.resolveURL('blob<' + index + '>', path));
+							} else {
+								loader.manager.itemEnd(imageUrl);
+							}
+						}
+						return transcodeResult;
+					});
+				} else {
+					const param = { loader, imageUrl, imageName, isObjectURL, sourceUrl, index, path };
+					if (mimeType && (mimeType.includes('avif') || mimeType.includes('webp'))) {
+						promise = detectSupport(mimeType).then(isSupported => {
+							if (isSupported) return loadImage(param);
+							throw new Error('GLTFLoader: WebP or AVIF required by asset but unsupported.');
+						});
+					} else {
+						return loadImage(param);
+					}
+				}
+				if (loader.detailLoadProgress) {
+					promise.catch(() => loader.manager.itemEnd(imageUrl));
+				}
+				return promise;
+			})
+		).then(images => {
+			context.images = images;
+		});
+	}
+
+}
+
+function detectSupport(mimeType) {
+	const isSupported = new Promise(resolve => {
+		// Lossy test image.
+		const image = new Image();
+		if (mimeType.includes('avif')) {
+			image.src = 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAEAAAABAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAACAAIABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgABogQEDQgMgkQAAAAB8dSLfI=';
+		} else {
+			image.src = 'data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA';
+		}
+		image.onload = () => {
+			resolve(image.height === 1);
+		};
+	});
+
+	return isSupported;
+}
+
+function loadImage(param) {
+	const { loader, imageUrl, imageName, isObjectURL, sourceUrl, index, path } = param;
+	const promise = loader.loadImage(imageUrl).then(image => {
+		image.__name = imageName;
+		if (isObjectURL === true) {
+			URL.revokeObjectURL(sourceUrl);
+		}
+		if (loader.detailLoadProgress) {
+			if (isObjectURL) {
+				loader.manager.itemEnd(GLTFUtils.resolveURL('blob<' + index + '>', path));
+			} else {
+				loader.manager.itemEnd(imageUrl);
+			}
+		}
+		return image;
+	});
+	return promise;
+}

package/src/libs/glTF/parsers/IndexParser.js

@@ -0,0 +1,22 @@
+import { GLTFUtils } from '../GLTFUtils.js';
+
+export class IndexParser {
+
+	static parse(context, loader) {
+		const { url } = context;
+
+		return loader.loadFile(url, 'arraybuffer').then(data => {
+			const magic = GLTFUtils.decodeText(new Uint8Array(data, 0, 4));
+
+			if (magic === 'glTF') {
+				const glbData = GLTFUtils.parseGLB(data);
+				context.gltf = glbData.gltf;
+				context.buffers = glbData.buffers;
+			} else {
+				const gltfString = GLTFUtils.decodeText(new Uint8Array(data));
+				context.gltf = JSON.parse(gltfString);
+			}
+		});
+	}
+
+}

package/src/libs/glTF/parsers/MaterialParser.js

@@ -0,0 +1,146 @@
+import {
+	PBRMaterial,
+	DRAW_SIDE,
+	TEXEL_ENCODING_TYPE
+} from 't3d';
+import { KHR_materials_unlit as _KHR_materials_unlit } from '../extensions/KHR_materials_unlit.js';
+import { KHR_materials_pbrSpecularGlossiness as _KHR_materials_pbrSpecularGlossiness } from '../extensions/KHR_materials_pbrSpecularGlossiness.js';
+import { KHR_materials_clearcoat as _KHR_materials_clearcoat } from '../extensions/KHR_materials_clearcoat.js';
+import { KHR_texture_transform } from '../extensions/KHR_texture_transform.js';
+import { ALPHA_MODES } from '../Constants.js';
+
+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 = _KHR_materials_unlit.getMaterial();
+			} else if (KHR_materials_pbrSpecularGlossiness) {
+				material = _KHR_materials_pbrSpecularGlossiness.getMaterial();
+				_KHR_materials_pbrSpecularGlossiness.parseParams(material, KHR_materials_pbrSpecularGlossiness, textures);
+			} else if (KHR_materials_clearcoat) {
+				material = _KHR_materials_clearcoat.getMaterial();
+				_KHR_materials_clearcoat.parseParams(material, KHR_materials_clearcoat, textures);
+			} else {
+				material = new PBRMaterial();
+			}
+
+			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);
+	}
+}