@loaders.gl/tile-converter 5.0.0-alpha.10 → 5.0.0-alpha.12

package/src/v5/index.ts

@@ -30,8 +30,14 @@ export type {
   FeatureArrowBatchOptions,
   TileFeatureAttributes
 } from '@loaders.gl/tile-converter/v5/adapters';
-export {encodePointCloudTile} from '@loaders.gl/tile-converter/v5/adapters';
-export type {EncodePointCloudTileOptions} from '@loaders.gl/tile-converter/v5/adapters';
+export {
+  encodePointCloudTile,
+  encodePointCloudTileWithMetadata
+} from '@loaders.gl/tile-converter/v5/adapters';
+export type {
+  EncodePointCloudTileOptions,
+  EncodedPointCloudTile
+} from '@loaders.gl/tile-converter/v5/adapters';
 export {traversePointCloudSource} from '@loaders.gl/tile-converter/v5/core';
 export type {
   PointCloudSourceTile,
@@ -97,3 +103,55 @@ export type {
   I3SMeshConversionCodecOptions,
   SingleMeshI3SSink
 } from '@loaders.gl/tile-converter/v5/adapters';
+
+export {
+  createI3SMeshSink,
+  createTileConversionResourceFetcher
+} from '@loaders.gl/tile-converter/v5/adapters';
+export type {
+  I3SMeshSink,
+  I3SMeshSinkOptions,
+  TileConversionResourceFetcherOptions,
+  MeshTileFeatures
+} from '@loaders.gl/tile-converter/v5/adapters';
+
+export {createPointCloudTilesetSink} from '@loaders.gl/tile-converter/v5/adapters';
+export type {
+  PointCloudTilesetSink,
+  PointCloudTilesetSinkOptions
+} from '@loaders.gl/tile-converter/v5/adapters';
+
+export {transformPointCloudSourceTile} from '@loaders.gl/tile-converter/v5/adapters';
+export type {PointCloudSpatialOptions} from '@loaders.gl/tile-converter/v5/adapters';
+
+export {createI3SMeshTilesetConversionSource} from '@loaders.gl/tile-converter/v5/adapters';
+export type {
+  I3SMeshTilesetSourceOptions,
+  I3SMeshSourceFeatureOptions
+} from '@loaders.gl/tile-converter/v5/adapters';
+
+export {convertPointCloudToTileset} from '@loaders.gl/tile-converter/v5/adapters';
+export type {
+  ConvertPointCloudToTilesetOptions,
+  ConvertedPointCloudTileset
+} from '@loaders.gl/tile-converter/v5/adapters';
+
+export {
+  encodePotreeArchive,
+  openPointCloudFile,
+  extractMeshVertices
+} from '@loaders.gl/tile-converter/v5/adapters';
+export type {
+  EncodePotreeArchiveOptions,
+  OpenPointCloudFileOptions,
+  OpenedPointCloudFile,
+  ExtractMeshVerticesOptions
+} from '@loaders.gl/tile-converter/v5/adapters';
+
+export {createMeshSourceFeatureOptions} from '@loaders.gl/tile-converter/v5/adapters';
+export type {MeshSourceSchemaOptions} from '@loaders.gl/tile-converter/v5/adapters';
+export {convertPointCloudToPotree} from '@loaders.gl/tile-converter/v5/adapters';
+export type {
+  ConvertPointCloudToPotreeOptions,
+  ConvertedPointCloudPotree
+} from '@loaders.gl/tile-converter/v5/adapters';

package/src/v5/mesh-conversion.ts

@@ -8,8 +8,12 @@ import type {MeshGeometry} from '@loaders.gl/schema';
 import type {LoadLibraryOptions} from '@loaders.gl/worker-utils';
 import {TileConversionError} from '@loaders.gl/tile-converter/v5/core';
 import type {TileConversionCodec} from '@loaders.gl/tile-converter/v5/core';
-import type {Tiles3DConversionSpatialContext} from '@loaders.gl/tile-converter/v5/core';
+import type {
+  Tiles3DConversionSpatialContext,
+  I3SConversionSpatialContext
+} from '@loaders.gl/tile-converter/v5/core';
 import {encodeMeshTile, validateMeshGeometry} from './mesh.js';
+import type {MeshTileFeatures} from './mesh-features.js';
 import type {MeshTileMaterial} from './mesh.js';
 import {encodeDracoMeshTile} from './mesh-draco.js';
 
@@ -17,10 +21,23 @@ import {encodeDracoMeshTile} from './mesh-draco.js';
 export interface MeshConversionInput {
   /** Caller-owned resource identifier, forwarded to the output sink. */
   readonly id: string;
+  /** Inspected content placement, used by the hierarchy sink independently of primitive IDs. */
+  readonly contentResourceId?: string;
+  /** Ordered primitive within a content; last marks complete extraction for hierarchy authoring. */
+  readonly contentPrimitive?: {
+    /** Zero-based primitive placement index in scene traversal order. */
+    readonly index: number;
+    /** Whether this is the final primitive placement in the content. */
+    readonly last: boolean;
+  };
   /** Triangle geometry with absolute packed Float32 or Float64 source positions. */
   readonly mesh: MeshGeometry;
+  /** Original I3S vector basis; overrides the codec default when supplied by a source. */
+  readonly normalReferenceFrame?: 'earth-centered' | 'vertex-reference-frame';
   /** Optional single material with an embedded base-color image, mapped explicitly by the source adapter. */
   readonly material?: MeshTileMaterial;
+  /** Explicit feature table and triangle associations, written as structural metadata. */
+  readonly features?: MeshTileFeatures;
   /** Finite xyz origin in the target frame, subtracted before float32 encoding. */
   readonly origin: readonly [number, number, number];
 }
@@ -29,6 +46,15 @@ export interface MeshConversionInput {
 export interface EncodedMeshConversionResource {
   /** Caller-owned resource identifier. */
   readonly id: string;
+  /** Inspected content placement, retained by the codec for hierarchy authoring. */
+  readonly contentResourceId?: string;
+  /** Ordered primitive within a content; last marks complete extraction for hierarchy authoring. */
+  readonly contentPrimitive?: {
+    /** Zero-based primitive placement index in scene traversal order. */
+    readonly index: number;
+    /** Whether this is the final primitive placement in the content. */
+    readonly last: boolean;
+  };
   /** Self-contained GLB with local positions and transformed normals. */
   readonly glb: ArrayBuffer;
   /** Target-frame translation to add to the encoded positions. */
@@ -46,7 +72,11 @@ export interface EncodedMeshConversionResource {
 /** Spatial policy used by the concrete mesh conversion codec. */
 export interface MeshConversionCodecOptions {
   /** Shared context that accepts absolute source positions and returns absolute target positions. */
-  readonly spatialContext: Tiles3DConversionSpatialContext;
+  readonly spatialContext: Tiles3DConversionSpatialContext | I3SConversionSpatialContext;
+  /** I3S vector frame when using an I3S context; defaults to earth-centered. */
+  readonly normalReferenceFrame?: 'earth-centered' | 'vertex-reference-frame';
+  /** Rebase around the transformed bounds center instead of the resource's explicit origin. */
+  readonly autoOrigin?: boolean;
   /** Maximum Euclidean reconstruction error per vertex, in target coordinate units. */
   readonly maxPositionError: number;
   /** Lossless Draco Edge Breaker is enabled by default; false emits uncompressed GLB geometry. */
@@ -105,12 +135,6 @@ export function createMeshConversionCodec<TInspection = unknown>(
     /** Prepares and encodes one geometry while honoring cancellation. */
     async *convert(resource, _inspection, signal) {
       signal?.throwIfAborted();
-      if ('features' in resource && resource.features) {
-        throw new TileConversionError(
-          'MESH_FEATURE_OUTPUT_UNSUPPORTED',
-          'The GLB codec requires an explicit feature metadata writer; use the I3S codec for supported feature-bearing meshes'
-        );
-      }
       const geometry = validateMeshGeometry(resource.mesh, true);
       const sourcePositions = geometry.attributes.POSITION.value;
       const origin: [number, number, number] = [...resource.origin];
@@ -120,7 +144,21 @@ export function createMeshConversionCodec<TInspection = unknown>(
           'Target origin must contain three finite coordinates'
         );
       }
-      const targetPositions = spatialContext.transformPositions(sourcePositions);
+      const transformed =
+        'transformGeometryAsync' in spatialContext
+          ? await spatialContext.transformGeometryAsync(
+              sourcePositions,
+              geometry.attributes.NORMAL?.value,
+              resource.normalReferenceFrame ?? options.normalReferenceFrame
+            )
+          : {
+              positions: spatialContext.transformPositions(sourcePositions),
+              normals: geometry.attributes.NORMAL
+                ? spatialContext.transformNormals(geometry.attributes.NORMAL.value, sourcePositions)
+                : undefined
+            };
+      signal?.throwIfAborted();
+      const targetPositions = transformed.positions;
       if (
         targetPositions.length !== sourcePositions.length ||
         targetPositions.some(value => !Number.isFinite(value))
@@ -130,6 +168,16 @@ export function createMeshConversionCodec<TInspection = unknown>(
           'Spatial transformation must return one finite xyz position per vertex'
         );
       }
+      if (options.autoOrigin) {
+        const minimum = [Infinity, Infinity, Infinity];
+        const maximum = [-Infinity, -Infinity, -Infinity];
+        for (let index = 0; index < targetPositions.length; index++) {
+          const axis = index % 3;
+          minimum[axis] = Math.min(minimum[axis], targetPositions[index]);
+          maximum[axis] = Math.max(maximum[axis], targetPositions[index]);
+        }
+        for (let axis = 0; axis < 3; axis++) origin[axis] = minimum[axis] / 2 + maximum[axis] / 2;
+      }
       const localPositions = new Float32Array(targetPositions.length);
       const minimum = [Infinity, Infinity, Infinity];
       const maximum = [-Infinity, -Infinity, -Infinity];
@@ -156,11 +204,11 @@ export function createMeshConversionCodec<TInspection = unknown>(
       geometry.attributes.POSITION = {value: localPositions, size: 3};
       if (geometry.attributes.NORMAL) {
         geometry.attributes.NORMAL = {
-          value: spatialContext.transformNormals(geometry.attributes.NORMAL.value, sourcePositions),
+          value: transformed.normals!,
           size: 3
         };
       }
-      const appearance = {material: resource.material};
+      const appearance = {material: resource.material, features: resource.features};
       const encoded = draco
         ? await encodeDracoMeshTile(geometry, appearance, dracoLibraryOptions)
         : {glb: encodeMeshTile(geometry, appearance), positions: localPositions};
@@ -175,6 +223,8 @@ export function createMeshConversionCodec<TInspection = unknown>(
       }
       yield {
         id: resource.id,
+        contentResourceId: resource.contentResourceId,
+        contentPrimitive: resource.contentPrimitive,
         glb: encoded.glb,
         origin,
         boundingBox: [minimum, maximum],

package/src/v5/mesh-draco.ts

@@ -14,6 +14,8 @@ import {
   validateMeshGeometry
 } from './mesh.js';
 
+import {prepareMeshFeatureGeometry, encodeMeshFeatures} from './mesh-features.js';
+
 const DRACO_EXTENSION = 'KHR_draco_mesh_compression';
 
 /** Encodes the validated single-mesh profile with lossless Edge Breaker and no raw fallback. */
@@ -22,7 +24,7 @@ export async function encodeDracoMeshTile(
   options: MeshTileOptions,
   libraryOptions: LoadLibraryOptions = {}
 ): Promise<{glb: ArrayBuffer; positions: Float32Array}> {
-  geometry = validateMeshGeometry(geometry);
+  geometry = prepareMeshFeatureGeometry(validateMeshGeometry(geometry), options.features);
   // Draco requires explicit faces even when the input triangle list is non-indexed.
   if (!geometry.indices) {
     geometry.indices = {
@@ -72,6 +74,12 @@ export async function encodeDracoMeshTile(
       );
     }
   }
+  if (JSON.stringify(getMeshTriangles(geometry)) !== JSON.stringify(getMeshTriangles(decoded))) {
+    throw new TileConversionError(
+      'MESH_DRACO_ATTRIBUTE_CHANGED',
+      'Lossless Draco must preserve oriented triangles and every attribute, including feature ownership'
+    );
+  }
   const bufferView = scenegraph.addBufferView(encoded.data);
   const attributes: Record<string, number> = {};
   const attributeIdentifiers: Record<string, number> = {};
@@ -90,9 +98,18 @@ export async function encodeDracoMeshTile(
           ? 5121
           : attribute.value instanceof Uint16Array
             ? 5123
-            : 5126,
+            : attribute.value instanceof Uint32Array
+              ? 5125
+              : 5126,
       count: encoded.report.pointCount,
-      type: attribute.size === 2 ? 'VEC2' : attribute.size === 3 ? 'VEC3' : 'VEC4',
+      type:
+        attribute.size === 1
+          ? 'SCALAR'
+          : attribute.size === 2
+            ? 'VEC2'
+            : attribute.size === 3
+              ? 'VEC3'
+              : 'VEC4',
       ...(attribute.normalized ? {normalized: true} : {})
     };
     if (name === 'POSITION') {
@@ -128,6 +145,7 @@ export async function encodeDracoMeshTile(
       ]
     }
   ];
+  encodeMeshFeatures(scenegraph, 0, options.features);
   scenegraph.registerRequiredExtension(DRACO_EXTENSION);
   return {glb: finalizeMeshTileScenegraph(scenegraph, 0), positions};
 }
@@ -136,3 +154,29 @@ export async function encodeDracoMeshTile(
 function getPositionKey(positions: ArrayLike<number>, index: number): string {
   return `${positions[index]},${positions[index + 1]},${positions[index + 2]}`;
 }
+
+/** Compares oriented triangles independently of vertex/face order, retaining every attribute. */
+function getMeshTriangles(mesh: Pick<MeshGeometry, 'attributes' | 'indices'>): string[] {
+  const names = Object.keys(mesh.attributes).sort();
+  const indices = mesh.indices!.value;
+  const triangles: string[] = [];
+  for (let index = 0; index < indices.length; index += 3) {
+    const vertices = [0, 1, 2].map(corner =>
+      names
+        .map(name => {
+          const attribute = mesh.attributes[name];
+          return Array.from(
+            {length: attribute.size},
+            (_, component) => attribute.value[indices[index + corner] * attribute.size + component]
+          ).join(',');
+        })
+        .join('|')
+    );
+    triangles.push(
+      [0, 1, 2]
+        .map(corner => [...vertices.slice(corner), ...vertices.slice(0, corner)].join(';'))
+        .sort()[0]
+    );
+  }
+  return triangles.sort();
+}

package/src/v5/mesh-features.ts

@@ -0,0 +1,319 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {convertArrowToSchema} from '@loaders.gl/schema-utils';
+import type {MeshGeometry, Field} from '@loaders.gl/schema';
+import type {GLTFScenegraph} from '@loaders.gl/gltf';
+import type {I3SMeshFeatures} from '@loaders.gl/i3s';
+import {TileConversionError} from '@loaders.gl/tile-converter/v5/core';
+
+/** Explicit-schema Arrow features; stable identifiers are distinct from geometry row indices. */
+export type MeshTileFeatures = Pick<
+  I3SMeshFeatures,
+  'batches' | 'triangleFeatureIndices' | 'featureIdField'
+>;
+
+/** Expands shared vertices so each complete triangle retains its own feature row through Draco. */
+export function prepareMeshFeatureGeometry(
+  mesh: MeshGeometry,
+  features?: MeshTileFeatures
+): MeshGeometry {
+  if (!features) return mesh;
+  const count = features.batches.reduce((total, batch) => total + batch.data.numRows, 0);
+  const indices = mesh.indices?.value;
+  const vertexCount = indices?.length ?? mesh.attributes.POSITION.value.length / 3;
+  const associations = features.triangleFeatureIndices;
+  if (
+    !(associations instanceof Uint32Array) ||
+    associations.length !== vertexCount / 3 ||
+    associations.some(row => row >= count) ||
+    new Set(associations).size !== count
+  ) {
+    throw new TileConversionError(
+      'MESH_FEATURE_ASSOCIATION_INVALID',
+      'Every feature row must own a triangle and every triangle must reference a valid row'
+    );
+  }
+  if (count > 2 ** 24)
+    throw new TileConversionError(
+      'MESH_FEATURE_COUNT_UNSUPPORTED',
+      'Feature row indices must be exactly representable in a glTF vertex attribute'
+    );
+  const attributes: MeshGeometry['attributes'] = Object.fromEntries(
+    Object.entries(mesh.attributes).map(([name, attribute]) => {
+      const values = attribute.value;
+      const Constructor = values.constructor as {new (length: number): typeof values};
+      const output = new Constructor(vertexCount * attribute.size);
+      for (let vertex = 0; vertex < vertexCount; vertex++) {
+        const sourceVertex = indices?.[vertex] ?? vertex;
+        for (let component = 0; component < attribute.size; component++)
+          output[vertex * attribute.size + component] = Number(
+            values[sourceVertex * attribute.size + component]
+          );
+      }
+      return [name, {...attribute, value: output}];
+    })
+  );
+  const featureIndices =
+    count <= 65536 ? new Uint16Array(vertexCount) : new Float32Array(vertexCount);
+  for (let vertex = 0; vertex < vertexCount; vertex++)
+    featureIndices[vertex] = associations[Math.floor(vertex / 3)];
+  attributes._FEATURE_ID_0 = {value: featureIndices, size: 1};
+  return {...mesh, indices: undefined, attributes};
+}
+
+/** Writes one inline structural metadata table without number coercion or nullable sentinel collisions. */
+export function encodeMeshFeatures(
+  scenegraph: GLTFScenegraph,
+  meshIndex: number,
+  features?: MeshTileFeatures
+): void {
+  if (!features) return;
+  const {batches, featureIdField} = features;
+  const schema = batches[0]?.schema;
+  const count = batches.reduce((total, batch) => total + batch.data.numRows, 0);
+  const metadataClass = schema?.metadata?.['loaders.gl:feature-class'] || 'features';
+  if (
+    !schema ||
+    !count ||
+    !/^[A-Za-z_][A-Za-z0-9_]*$/.test(metadataClass) ||
+    !schema.fields.some(field => field.name === featureIdField && field.nullable !== true) ||
+    new Set(schema.fields.map(field => field.name)).size !== schema.fields.length
+  ) {
+    throw new TileConversionError(
+      'MESH_FEATURE_SCHEMA_INVALID',
+      'Features require a single named class, unique fields, and a non-null stable identifier'
+    );
+  }
+  for (const batch of batches) {
+    const actual = convertArrowToSchema(batch.data.schema).fields;
+    if (
+      JSON.stringify(batch.schema) !== JSON.stringify(schema) ||
+      batch.length !== batch.data.numRows ||
+      JSON.stringify(actual.map(field => [field.name, field.type])) !==
+        JSON.stringify(schema.fields.map(field => [field.name, field.type]))
+    ) {
+      throw new TileConversionError(
+        'MESH_FEATURE_SCHEMA_INVALID',
+        'Declared feature schemas and Arrow column types must agree across batches'
+      );
+    }
+  }
+  const properties: Record<string, object> = Object.create(null);
+  const columns: Record<string, object> = Object.create(null);
+  for (const field of schema.fields) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(field.name))
+      throw new TileConversionError(
+        'MESH_FEATURE_SCHEMA_INVALID',
+        'Property names must be metadata identifiers'
+      );
+    const values = batches.flatMap(batch => {
+      const column = batch.data.getChild(field.name);
+      if (!column)
+        throw new TileConversionError(
+          'MESH_FEATURE_SCHEMA_INVALID',
+          `Missing Arrow column ${field.name}`
+        );
+      return Array.from({length: column.length}, (_, index) => column.get(index));
+    });
+    if (
+      field.name === featureIdField &&
+      (values.some(
+        value =>
+          !(typeof value === 'string' || typeof value === 'bigint' || Number.isSafeInteger(value))
+      ) ||
+        new Set(values).size !== count)
+    )
+      throw new TileConversionError(
+        'MESH_FEATURE_IDS_INVALID',
+        'Stable identifiers must be unique strings or exact integers'
+      );
+    const encoded = encodeFeatureColumn(field, values);
+    properties[field.name] = encoded.property;
+    columns[field.name] = {
+      values: addMetadataBuffer(scenegraph, encoded.data),
+      ...(encoded.offsets
+        ? {
+            stringOffsets: addMetadataBuffer(scenegraph, encoded.offsets),
+            stringOffsetType: 'UINT32'
+          }
+        : {})
+    };
+  }
+  scenegraph.json.extensions ||= {};
+  scenegraph.json.extensions.EXT_structural_metadata = {
+    schema: {id: 'loaders_gl_features', classes: {[metadataClass]: {properties}}},
+    propertyTables: [{class: metadataClass, count, properties: columns}]
+  };
+  const primitive = scenegraph.json.meshes![meshIndex].primitives[0];
+  primitive.extensions ||= {};
+  primitive.extensions.EXT_mesh_features = {
+    featureIds: [{featureCount: count, attribute: 0, propertyTable: 0}]
+  };
+  scenegraph.registerUsedExtension('EXT_structural_metadata');
+  scenegraph.registerUsedExtension('EXT_mesh_features');
+}
+
+/** Aligns every metadata buffer to eight bytes, including INT64, UINT64 and FLOAT64 columns. */
+function addMetadataBuffer(scenegraph: GLTFScenegraph, data: ArrayBufferView): number {
+  if (scenegraph.byteLength % 8) scenegraph.addBufferView(new Uint8Array(4));
+  return scenegraph.addBufferView(data);
+}
+
+/** Encodes supported scalar values and chooses an unused noData value for nullable columns. */
+function encodeFeatureColumn(
+  field: Field,
+  values: unknown[]
+): {property: object; data: Uint8Array; offsets?: Uint32Array} {
+  const type = field.type;
+  const hasNull = values.includes(null);
+  if (hasNull && field.nullable !== true)
+    throw new TileConversionError(
+      'MESH_FEATURE_VALUE_INVALID',
+      `Required field ${field.name} contains null`
+    );
+  const present = values.filter(value => value !== null);
+  let noData: string | number | undefined;
+  if (type === 'utf8') {
+    if (
+      present.some(
+        value =>
+          typeof value !== 'string' ||
+          new TextDecoder().decode(new TextEncoder().encode(value)) !== value
+      )
+    )
+      throw new TileConversionError('MESH_FEATURE_VALUE_INVALID', 'Strings require valid Unicode');
+    if (hasNull) {
+      noData = '';
+      const strings = new Set(present);
+      while (strings.has(noData)) noData += '_';
+    }
+    const encoded = values.map(value =>
+      new TextEncoder().encode(value === null ? (noData as string) : (value as string))
+    );
+    const offsets = new Uint32Array(values.length + 1);
+    for (let index = 0; index < values.length; index++)
+      offsets[index + 1] = offsets[index] + encoded[index].length;
+    const data = new Uint8Array(offsets[values.length]);
+    encoded.forEach((bytes, index) => data.set(bytes, offsets[index]));
+    return {
+      property: {type: 'STRING', required: field.nullable !== true, ...(hasNull ? {noData} : {})},
+      data,
+      offsets
+    };
+  }
+  const widths: Record<string, number> = {
+    int8: 1,
+    uint8: 1,
+    int16: 2,
+    uint16: 2,
+    int32: 4,
+    uint32: 4,
+    int64: 8,
+    uint64: 8,
+    float32: 4,
+    float64: 8
+  };
+  const width = widths[String(type)];
+  if (!width)
+    throw new TileConversionError(
+      'MESH_FEATURE_TYPE_UNSUPPORTED',
+      `No qualified GLB property mapping for ${String(type)}`
+    );
+  const isInteger64 = type === 'int64' || type === 'uint64';
+  const isFloat = type === 'float32' || type === 'float64';
+  const minimum = isFloat
+    ? -Infinity
+    : String(type).startsWith('uint')
+      ? 0n
+      : -(1n << BigInt(width * 8 - 1));
+  const maximum = isFloat
+    ? Infinity
+    : (1n << BigInt(width * 8 - (String(type).startsWith('uint') ? 0 : 1))) - 1n;
+  if (
+    present.some(value =>
+      isInteger64
+        ? typeof value !== 'bigint' || value < minimum || value > maximum
+        : typeof value !== 'number' ||
+          !Number.isFinite(value) ||
+          (!isFloat &&
+            (!Number.isSafeInteger(value) || BigInt(value) < minimum || BigInt(value) > maximum))
+    )
+  )
+    throw new TileConversionError(
+      'MESH_FEATURE_VALUE_INVALID',
+      `Values do not fit ${String(type)}`
+    );
+  if (hasNull) {
+    const used = new Set(present.map(String));
+    noData = 0;
+    while (used.has(String(noData))) noData++;
+    if (noData > maximum && minimum < 0) {
+      noData = -1;
+      while (used.has(String(noData))) noData--;
+    }
+    if (noData > maximum || noData < minimum)
+      throw new TileConversionError(
+        'MESH_FEATURE_NULL_UNREPRESENTABLE',
+        'No unused value remains for null without losing a real value'
+      );
+  }
+  const data = new Uint8Array(values.length * width);
+  const view = new DataView(data.buffer);
+  values.forEach((value, index) => {
+    const selected = value === null ? (isInteger64 ? BigInt(noData!) : noData) : value;
+    const offset = index * width;
+    switch (type) {
+      case 'int8':
+        view.setInt8(offset, selected as number);
+        break;
+      case 'uint8':
+        view.setUint8(offset, selected as number);
+        break;
+      case 'int16':
+        view.setInt16(offset, selected as number, true);
+        break;
+      case 'uint16':
+        view.setUint16(offset, selected as number, true);
+        break;
+      case 'int32':
+        view.setInt32(offset, selected as number, true);
+        break;
+      case 'uint32':
+        view.setUint32(offset, selected as number, true);
+        break;
+      case 'int64':
+        view.setBigInt64(offset, selected as bigint, true);
+        break;
+      case 'uint64':
+        view.setBigUint64(offset, selected as bigint, true);
+        break;
+      case 'float32':
+        view.setFloat32(offset, selected as number, true);
+        break;
+      case 'float64':
+        view.setFloat64(offset, selected as number, true);
+        break;
+    }
+    if (
+      isFloat &&
+      !Number.isFinite(
+        type === 'float32' ? view.getFloat32(offset, true) : view.getFloat64(offset, true)
+      )
+    )
+      throw new TileConversionError(
+        'MESH_FEATURE_VALUE_INVALID',
+        'Floating point property overflow'
+      );
+  });
+  return {
+    property: {
+      type: 'SCALAR',
+      componentType: String(type).toUpperCase(),
+      required: field.nullable !== true,
+      ...(hasNull ? {noData} : {})
+    },
+    data
+  };
+}