@loaders.gl/scene 5.0.0-alpha.9 → 5.0.0-beta.2

package/src/gltf/lib/extensions/deprecated/EXT_feature_metadata.ts

@@ -0,0 +1,479 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* eslint-disable camelcase */
+import type {GLTFMeshPrimitive, GLTFTextureInfoMetadata} from '../../types/gltf-json-schema';
+import type {GLTFWithBuffers} from '../../types/gltf-types';
+import type {
+  GLTF_EXT_feature_metadata_Class,
+  GLTF_EXT_feature_metadata_ClassProperty,
+  GLTF_EXT_feature_metadata_FeatureTable,
+  GLTF_EXT_feature_metadata_FeatureTableProperty,
+  GLTF_EXT_feature_metadata_FeatureTexture,
+  GLTF_EXT_feature_metadata_GLTF,
+  GLTF_EXT_feature_metadata_TextureAccessor,
+  GLTF_EXT_feature_metadata_Schema
+} from '../../types/gltf-ext-feature-metadata-schema';
+import type {BigTypedArray, TypedArray} from '@loaders.gl/core/schema';
+import {GLTFIterator} from '../../api/gltf-iterator';
+import {GLTFLoaderOptions} from '../../../gltf-loader-types';
+import {
+  convertRawBufferToMetadataArray,
+  getPrimitiveTextureData,
+  primitivePropertyDataToAttributes,
+  getArrayElementByteSize,
+  NumericComponentType,
+  getOffsetsForProperty,
+  parseVariableLengthArrayNumeric,
+  parseFixedLengthArrayNumeric,
+  getPropertyDataString
+} from '../utils/3d-tiles-utils';
+
+/** Extension name */
+const EXT_FEATURE_METADATA_NAME = 'EXT_feature_metadata';
+export const name = EXT_FEATURE_METADATA_NAME;
+
+export async function decode(gltfData: GLTFWithBuffers, options: GLTFLoaderOptions): Promise<void> {
+  const iterator = new GLTFIterator(gltfData);
+  decodeExtFeatureMetadata(iterator, options);
+}
+
+/**
+ * Decodes feature metadata from extension.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param options - GLTFLoader options.
+ */
+function decodeExtFeatureMetadata(iterator: GLTFIterator, options: GLTFLoaderOptions): void {
+  // Decoding metadata involves buffers processing.
+  // So, if buffers have not been loaded, there is no reason to process metadata.
+  if (!options.gltf?.loadBuffers) {
+    return;
+  }
+  const extension =
+    iterator.getExtension<GLTF_EXT_feature_metadata_GLTF>(EXT_FEATURE_METADATA_NAME);
+  if (!extension) {
+    return;
+  }
+
+  if (options.gltf?.loadImages) {
+    decodePropertyTextures(iterator, extension);
+  }
+
+  decodePropertyTables(iterator, extension);
+}
+
+/**
+ * Processes the data stored in the textures
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param extension - Top-level extension.
+ */
+function decodePropertyTextures(
+  iterator: GLTFIterator,
+  extension: GLTF_EXT_feature_metadata_GLTF
+): void {
+  const schema = extension.schema;
+  if (!schema) {
+    return;
+  }
+  const schemaClasses = schema.classes;
+
+  const {featureTextures} = extension;
+  if (schemaClasses && featureTextures) {
+    for (const schemaName in schemaClasses) {
+      const schemaClass = schemaClasses[schemaName];
+      const featureTexture = findFeatureTextureByClass(featureTextures, schemaName);
+
+      if (featureTexture) {
+        handleFeatureTextureProperties(iterator, featureTexture, schemaClass);
+      }
+    }
+  }
+}
+
+/**
+ * Processes the data stored in the property tables.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param extension - Top-level extension.
+ */
+function decodePropertyTables(
+  iterator: GLTFIterator,
+  extension: GLTF_EXT_feature_metadata_GLTF
+): void {
+  const schema = extension.schema;
+  if (!schema) {
+    return;
+  }
+  const schemaClasses = schema.classes;
+  const propertyTables = extension.featureTables;
+  if (schemaClasses && propertyTables) {
+    for (const schemaName in schemaClasses) {
+      const propertyTable = findPropertyTableByClass(propertyTables, schemaName);
+      if (propertyTable) {
+        processPropertyTable(iterator, schema, propertyTable);
+      }
+    }
+  }
+}
+
+/**
+ * Finds the property table by class name.
+ * @param propertyTables - propertyTable definition taken from the top-level extension.
+ * @param schemaClassName - class name in the extension schema.
+ */
+function findPropertyTableByClass(
+  propertyTables: {[key: string]: GLTF_EXT_feature_metadata_FeatureTable},
+  schemaClassName: string
+): GLTF_EXT_feature_metadata_FeatureTable | null {
+  for (const propertyTableName in propertyTables) {
+    const propertyTable = propertyTables[propertyTableName];
+    if (propertyTable.class === schemaClassName) {
+      return propertyTable;
+    }
+  }
+
+  return null;
+}
+
+function findFeatureTextureByClass(
+  featureTextures: {[key: string]: GLTF_EXT_feature_metadata_FeatureTexture},
+  schemaClassName: string
+): GLTF_EXT_feature_metadata_FeatureTexture | null {
+  for (const featureTexturesName in featureTextures) {
+    const featureTable = featureTextures[featureTexturesName];
+
+    if (featureTable.class === schemaClassName) {
+      return featureTable;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Navigates through all properies in the property table, gets properties data,
+ * and put the data to `propertyTable.data` as an array.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param schema - schema object.
+ * @param propertyTable - propertyTable definition taken from the top-level extension.
+ */
+function processPropertyTable(
+  iterator: GLTFIterator,
+  schema: GLTF_EXT_feature_metadata_Schema,
+  propertyTable: GLTF_EXT_feature_metadata_FeatureTable
+): void {
+  // Though 'class' is not required by spec, it doesn't make any scence when it's not provided.
+  // So, bale out here.
+  if (!propertyTable.class) {
+    return;
+  }
+
+  const schemaClass = schema.classes?.[propertyTable.class];
+  if (!schemaClass) {
+    throw new Error(
+      `Incorrect data in the EXT_structural_metadata extension: no schema class with name ${propertyTable.class}`
+    );
+  }
+
+  const numberOfElements = propertyTable.count; // `propertyTable.count` is a number of elements in each property array.
+
+  for (const propertyName in schemaClass.properties) {
+    const classProperty = schemaClass.properties[propertyName];
+    const propertyTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty | undefined =
+      propertyTable.properties?.[propertyName];
+
+    if (propertyTableProperty) {
+      // Getting all elements (`numberOfElements`) of the array in the `propertyTableProperty`
+      const data = getPropertyDataFromBinarySource(
+        iterator,
+        schema,
+        classProperty,
+        numberOfElements,
+        propertyTableProperty
+      );
+      propertyTableProperty.data = data;
+    }
+  }
+}
+
+/**
+ * Navigates through all properies in feature texture and gets properties data.
+ * Data will be stored in featureTexture.properties[propertyName].data.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param featureTexture
+ * @param schemaClass
+ */
+function handleFeatureTextureProperties(
+  iterator: GLTFIterator,
+  featureTexture: GLTF_EXT_feature_metadata_FeatureTexture,
+  schemaClass: GLTF_EXT_feature_metadata_Class
+): void {
+  const attributeName = featureTexture.class;
+
+  for (const propertyName in schemaClass.properties) {
+    const featureTextureProperty = featureTexture?.properties?.[propertyName];
+
+    if (featureTextureProperty) {
+      const data = getPropertyDataFromTexture(iterator, featureTextureProperty, attributeName);
+      featureTextureProperty.data = data;
+    }
+  }
+}
+
+/**
+ * Decodes properties from binary sourse based on property type.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param schemaProperty
+ * @param numberOfFeatures
+ * @param featureTableProperty
+ */
+function getPropertyDataFromBinarySource(
+  iterator: GLTFIterator,
+  schema: GLTF_EXT_feature_metadata_Schema,
+  classProperty: GLTF_EXT_feature_metadata_ClassProperty,
+  numberOfFeatures: number,
+  featureTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty
+): string[] | BigTypedArray | string[][] | BigTypedArray[] {
+  let data: string[] | BigTypedArray | string[][] | BigTypedArray[] = [];
+  const bufferView = featureTableProperty.bufferView;
+  const dataArray: Uint8Array = iterator.getTypedArrayForBufferView(bufferView);
+
+  const arrayOffsets = getArrayOffsetsForProperty(
+    iterator,
+    classProperty,
+    featureTableProperty,
+    numberOfFeatures
+  );
+  const stringOffsets = getStringOffsetsForProperty(
+    iterator,
+    classProperty,
+    featureTableProperty,
+    numberOfFeatures,
+    arrayOffsets
+  );
+
+  if (classProperty.type === 'STRING' || classProperty.componentType === 'STRING') {
+    data = getPropertyDataString(
+      numberOfFeatures,
+      dataArray,
+      arrayOffsets,
+      stringOffsets,
+      classProperty.type === 'ARRAY' ? classProperty.componentCount : undefined
+    );
+  } else if (isNumericProperty(classProperty)) {
+    data = getPropertyDataNumeric(classProperty, numberOfFeatures, dataArray, arrayOffsets);
+  }
+
+  return data;
+}
+
+/**
+ * Parses propertyTable.property.arrayOffsets that are offsets of sub-arrays in a flatten array of values.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param classProperty - class property object.
+ * @param propertyTableProperty - propertyTable's property metadata.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @returns Typed array with offset values.
+ * @see https://github.com/CesiumGS/glTF/blob/2976f1183343a47a29e4059a70961371cd2fcee8/extensions/2.0/Vendor/EXT_structural_metadata/schema/propertyTable.property.schema.json#L21
+ */
+function getArrayOffsetsForProperty(
+  iterator: GLTFIterator,
+  classProperty: GLTF_EXT_feature_metadata_ClassProperty,
+  propertyTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty,
+  numberOfElements: number
+): TypedArray | null {
+  /*
+   If ARRAY is used, then componentType must also be specified.
+   ARRAY is a fixed-length array when componentCount is defined, and variable-length otherwise.
+*/
+  if (
+    classProperty.type === 'ARRAY' &&
+    // `componentCount` is a number of fixed-length array elements.
+    // If `componentCount` is NOT defined, it's a VARIABLE-length array
+    typeof classProperty.componentCount === 'undefined' &&
+    // `arrayOffsetBufferView` is an index of the buffer view containing offsets for variable-length arrays.
+    typeof propertyTableProperty.arrayOffsetBufferView !== 'undefined'
+  ) {
+    // Data are in a VARIABLE-length array
+    return getOffsetsForProperty(
+      iterator,
+      propertyTableProperty.arrayOffsetBufferView,
+      propertyTableProperty.offsetType || 'UINT32', // offsetType is used both for stringOffsetBufferView and arrayOffsetBufferView
+      numberOfElements
+    );
+  }
+  return null;
+}
+
+/**
+ * Parses featureTable.property.stringOffsetBufferView.
+ * String offsets is an array of offsets of strings in the united array of characters.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param propertyTableProperty - propertyTable's property metadata.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param arrayOffsets - Offsets for a variable-length array, when present.
+ * @returns Typed array of offset values. The number of offsets in the array is equal to `numberOfElements` plus one.
+ * @see https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/featureTable.property.schema.json#L50C10-L50C32
+ */
+function getStringOffsetsForProperty(
+  iterator: GLTFIterator,
+  classProperty: GLTF_EXT_feature_metadata_ClassProperty,
+  propertyTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty,
+  numberOfElements: number,
+  arrayOffsets: TypedArray | null
+): TypedArray | null {
+  if (
+    typeof propertyTableProperty.stringOffsetBufferView !== 'undefined' // `stringOffsetBufferView` is an index of the buffer view containing offsets for strings.
+  ) {
+    const numberOfStrings = arrayOffsets
+      ? Number(arrayOffsets[numberOfElements])
+      : numberOfElements * (classProperty.type === 'ARRAY' ? classProperty.componentCount || 1 : 1);
+    return getOffsetsForProperty(
+      iterator,
+      propertyTableProperty.stringOffsetBufferView,
+      propertyTableProperty.offsetType || 'UINT32', // offsetType is used both for stringOffsetBufferView and arrayOffsetBufferView
+      numberOfStrings
+    );
+  }
+  return null;
+}
+
+/**
+ * Checks if the feature table property is of numeric type.
+ * @param schemaPropertyType - feature table property
+ * @returns true if property is numeric, else - false
+ */
+function isNumericProperty(schemaProperty: GLTF_EXT_feature_metadata_ClassProperty): boolean {
+  const types = [
+    'UINT8',
+    'INT16',
+    'UINT16',
+    'INT32',
+    'UINT32',
+    'INT64',
+    'UINT64',
+    'FLOAT32',
+    'FLOAT64'
+  ];
+  return (
+    types.includes(schemaProperty.type) ||
+    (typeof schemaProperty.componentType !== 'undefined' &&
+      types.includes(schemaProperty.componentType))
+  );
+}
+
+/**
+ * Decodes properties of numeric types from binary sourse.
+ * @param classProperty - class property object.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param valuesDataBytes - Data taken from values property of the property table property.
+ * @param arrayOffsets - Offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
+ * @returns Property values in a typed array or in an array of typed arrays.
+ */
+function getPropertyDataNumeric(
+  classProperty: GLTF_EXT_feature_metadata_ClassProperty,
+  numberOfElements: number,
+  valuesDataBytes: Uint8Array,
+  arrayOffsets: TypedArray | null
+): BigTypedArray | BigTypedArray[] {
+  const isArray = classProperty.type === 'ARRAY';
+  const arrayCount = classProperty.componentCount;
+
+  /*
+  We are getting Numeric data. So,
+    the component type can be one of NumericComponentType,
+    the attribute type should be 'SCALAR'
+  */
+  const attributeType = 'SCALAR';
+  const componentType = classProperty.componentType || classProperty.type;
+  const elementSize = getArrayElementByteSize(attributeType, componentType);
+  const elementCount = valuesDataBytes.byteLength / elementSize;
+
+  const valuesData: BigTypedArray = convertRawBufferToMetadataArray(
+    valuesDataBytes,
+    attributeType,
+    componentType as NumericComponentType,
+    elementCount
+  );
+
+  if (isArray) {
+    if (arrayOffsets) {
+      // VARIABLE-length array
+      return parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets);
+    }
+    if (arrayCount) {
+      // FIXED-length array
+      return parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount);
+    }
+    return [];
+  }
+
+  return valuesData;
+}
+
+/**
+ * Gets properties from texture associated with all mesh primitives.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param featureTextureProperty
+ * @param attributeName
+ * @returns Feature texture data
+ */
+function getPropertyDataFromTexture(
+  iterator: GLTFIterator,
+  featureTextureProperty: GLTF_EXT_feature_metadata_TextureAccessor,
+  attributeName: string
+): number[] {
+  const json = iterator.data;
+  if (!json.meshes) {
+    return [];
+  }
+  const featureTextureTable: number[] = [];
+  for (const mesh of json.meshes) {
+    for (const primitive of mesh.primitives) {
+      processPrimitiveTextures(
+        iterator,
+        attributeName,
+        featureTextureProperty,
+        featureTextureTable,
+        primitive
+      );
+    }
+  }
+  return featureTextureTable;
+}
+
+/**
+ * Processes data encoded in the texture associated with the primitive. This data will be accessible through the attributes.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param attributeName
+ * @param featureTextureProperty
+ * @param featureTextureTable
+ * @param primitive
+ */
+function processPrimitiveTextures(
+  iterator: GLTFIterator,
+  attributeName: string,
+  featureTextureProperty: GLTF_EXT_feature_metadata_TextureAccessor,
+  featureTextureTable: number[],
+  primitive: GLTFMeshPrimitive
+): void {
+  const textureInfoTopLevel: GLTFTextureInfoMetadata = {
+    channels: featureTextureProperty.channels,
+    ...featureTextureProperty.texture
+  };
+  const propertyData: number[] | null = getPrimitiveTextureData(
+    iterator,
+    textureInfoTopLevel,
+    primitive
+  );
+  if (!propertyData) {
+    return;
+  }
+  primitivePropertyDataToAttributes(
+    iterator,
+    attributeName,
+    propertyData,
+    featureTextureTable,
+    primitive
+  );
+}

package/src/gltf/lib/extensions/deprecated/KHR_lights_punctual.ts

@@ -0,0 +1,67 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// GLTF EXTENSION: KHR_lights_punctual
+// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
+
+import type {GLTFWithBuffers} from '../../types/gltf-types';
+
+import {assert} from '../../utils/assert';
+import {GLTFIterator} from '../../api/gltf-iterator';
+import {GLTFScenegraph} from '../../api/gltf-scenegraph';
+
+const KHR_LIGHTS_PUNCTUAL = 'KHR_lights_punctual';
+
+export const name = KHR_LIGHTS_PUNCTUAL;
+
+export async function decode(gltfData: GLTFWithBuffers): Promise<void> {
+  const iterator = new GLTFIterator(gltfData);
+
+  // Move the light array out of the extension and remove the extension
+  const extension = iterator.getExtension<{lights: unknown[]}>(KHR_LIGHTS_PUNCTUAL);
+  if (extension) {
+    (iterator.data as typeof iterator.data & {lights?: unknown[]}).lights = extension.lights;
+    iterator.removeExtension(KHR_LIGHTS_PUNCTUAL);
+  }
+
+  // Any nodes that have the extension, add lights field pointing to light object
+  // and remove the extension
+  for (const node of iterator.nodes) {
+    const nodeExtension = iterator.getExtension<{light: number}>(node, KHR_LIGHTS_PUNCTUAL);
+    if (nodeExtension) {
+      (node as typeof node & {light?: number}).light = nodeExtension.light;
+    }
+    iterator.removeExtension(node, KHR_LIGHTS_PUNCTUAL);
+  }
+}
+
+// Move the light ar ray out of the extension and remove the extension
+export async function encode(gltfData): Promise<void> {
+  const gltfScenegraph = new GLTFScenegraph(gltfData);
+  const {json} = gltfScenegraph;
+
+  // @ts-ignore
+  if (json.lights) {
+    const extension = gltfScenegraph.addExtension(KHR_LIGHTS_PUNCTUAL);
+    // @ts-ignore
+    assert(!extension.lights);
+    // @ts-ignore
+    extension.lights = json.lights;
+    // @ts-ignore
+    delete json.lights;
+  }
+
+  // Any nodes that have lights field pointing to light object
+  // add the extension
+  // @ts-ignore
+  if (gltfScenegraph.json.lights) {
+    // @ts-ignore
+    for (const light of gltfScenegraph.json.lights) {
+      const node = light.node;
+      gltfScenegraph.addObjectExtension(node, KHR_LIGHTS_PUNCTUAL, light);
+    }
+    // @ts-ignore
+    delete gltfScenegraph.json.lights;
+  }
+}

package/src/gltf/lib/extensions/deprecated/KHR_materials_unlit.ts

@@ -0,0 +1,52 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// GLTF EXTENSION: KHR_materials_unlit
+// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
+
+import type {GLTFWithBuffers} from '../../types/gltf-types';
+import type {GLTF, GLTFMaterial} from '../../types/gltf-json-schema';
+
+import {GLTFIterator} from '../../api/gltf-iterator';
+import {GLTFScenegraph} from '../../api/gltf-scenegraph';
+
+const KHR_MATERIALS_UNLIT = 'KHR_materials_unlit';
+
+export const name = KHR_MATERIALS_UNLIT;
+
+export async function decode(gltfData: GLTFWithBuffers): Promise<void> {
+  const iterator = new GLTFIterator(gltfData);
+
+  // Any nodes that have the extension, add lights field pointing to light object
+  // and remove the extension
+  for (const material of iterator.materials) {
+    const extension = iterator.getExtension(material, KHR_MATERIALS_UNLIT);
+    if (extension) {
+      // @ts-ignore TODO
+      (material as typeof material & {unlit?: boolean}).unlit = true;
+    }
+    iterator.removeExtension(material, KHR_MATERIALS_UNLIT);
+  }
+
+  // Remove the top-level extension
+  iterator.removeExtension(KHR_MATERIALS_UNLIT);
+}
+
+/** Restore decoded unlit annotations for export, requiring consumers to preserve their shading. */
+export function encode(gltfData: {json: GLTF}): void {
+  const scenegraph = new GLTFScenegraph(gltfData);
+  for (const material of gltfData.json.materials || []) {
+    const decodedMaterial = material as GLTFMaterial & {
+      /** Deprecated loader annotation indicating lighting-independent shading. */
+      unlit?: boolean;
+    };
+    if (decodedMaterial.unlit) {
+      delete decodedMaterial.unlit;
+      scenegraph.addObjectExtension(material, KHR_MATERIALS_UNLIT, {});
+      scenegraph.registerRequiredExtension(KHR_MATERIALS_UNLIT);
+    }
+  }
+  for (const field of ['extensionsUsed', 'extensionsRequired'] as const)
+    if (gltfData.json[field]?.length === 0) delete gltfData.json[field];
+}

package/src/gltf/lib/extensions/deprecated/KHR_techniques_webgl.ts

@@ -0,0 +1,105 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// GLTF EXTENSION: KHR_techniques_webgl
+// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_techniques_webgl
+
+import type {GLTFWithBuffers} from '../../types/gltf-types';
+
+import {GLTFIterator} from '../../api/gltf-iterator';
+import {getTypedArrayForBufferView} from '../../gltf-utils/get-typed-array';
+
+const KHR_TECHNIQUES_WEBGL = 'KHR_techniques_webgl';
+
+export const name = KHR_TECHNIQUES_WEBGL;
+
+export async function decode(gltfData: GLTFWithBuffers): Promise<void> {
+  const iterator = new GLTFIterator(gltfData);
+
+  const extension = iterator.getExtension(KHR_TECHNIQUES_WEBGL);
+  if (extension) {
+    const techniques = resolveTechniques(extension, iterator);
+
+    for (const material of iterator.materials) {
+      const materialExtension = iterator.getExtension<any>(material, KHR_TECHNIQUES_WEBGL);
+      if (materialExtension) {
+        // @ts-ignore TODO
+        (material as any).technique = Object.assign(
+          {},
+          materialExtension,
+          // @ts-ignore
+          techniques[materialExtension.technique]
+        );
+        // @ts-ignore TODO
+        (material as any).technique.values = resolveValues((material as any).technique, iterator);
+      }
+      iterator.removeExtension(material, KHR_TECHNIQUES_WEBGL);
+    }
+
+    // Remove the top-level extension
+    iterator.removeExtension(KHR_TECHNIQUES_WEBGL);
+  }
+}
+// eslint-disable-next-line
+export async function encode(gltfData, options): Promise<void> {
+  // TODO
+}
+
+function resolveTechniques(
+  techniquesExtension: {[key: string]: any},
+  // programs: {[key: string]: any}[],
+  // shaders: {[key: string]: any}[],
+  // techniques: {[key: string]: any}[]
+  iterator: GLTFIterator
+) {
+  const {programs = [], shaders = [], techniques = []} = techniquesExtension;
+  const textDecoder = new TextDecoder();
+
+  shaders.forEach(shader => {
+    if (Number.isFinite(shader.bufferView)) {
+      shader.code = textDecoder.decode(
+        getTypedArrayForBufferView(iterator.data, iterator.gltf.buffers, shader.bufferView)
+      );
+    } else {
+      // TODO: handle URI shader
+      throw new Error('KHR_techniques_webgl: no shader code');
+    }
+  });
+
+  programs.forEach(program => {
+    program.fragmentShader = shaders[program.fragmentShader];
+    program.vertexShader = shaders[program.vertexShader];
+  });
+
+  techniques.forEach(technique => {
+    technique.program = programs[technique.program];
+  });
+
+  return techniques;
+}
+
+function resolveValues(technique, iterator: GLTFIterator) {
+  const values = Object.assign({}, technique.values);
+
+  // merge values from uniforms
+  Object.keys(technique.uniforms || {}).forEach(uniform => {
+    if (technique.uniforms[uniform].value && !(uniform in values)) {
+      values[uniform] = technique.uniforms[uniform].value;
+    }
+  });
+
+  // resolve textures
+  Object.keys(values).forEach(uniform => {
+    if (typeof values[uniform] === 'object' && values[uniform].index !== undefined) {
+      // Assume this is a texture
+      // TODO: find if there are any other types that can be referenced
+      values[uniform].texture = iterator.resolveTexture(
+        values[uniform].index,
+        `technique.values.${uniform}.index`
+      );
+    }
+  });
+
+  return values;
+}