@itwin/core-frontend 5.2.0-dev.1 → 5.2.0-dev.11

package/lib/esm/tile/GltfReader.js

@@ -5,7 +5,7 @@
 /** @packageDocumentation
  * @module Tiles
  */
-import { assert, ByteStream, compareBooleans, compareNumbers, compareStrings, Dictionary, JsonUtils, Logger, utf8ToString, } from "@itwin/core-bentley";
+import { assert, ByteStream, compareBooleans, compareNumbers, compareStrings, Dictionary, expectDefined, JsonUtils, Logger, utf8ToString, } from "@itwin/core-bentley";
 import { Angle, IndexedPolyface, Matrix3d, Point2d, Point3d, Point4d, Range2d, Range3d, Transform, Vector3d, } from "@itwin/core-geometry";
 import { BatchType, ColorDef, Feature, FeatureIndex, FeatureIndexType, FeatureTable, FillFlags, GlbHeader, ImageSource, LinePixels, MeshEdge, MeshEdges, MeshPolyline, OctEncodedNormal, OctEncodedNormalPair, PackedFeatureTable, QParams2d, QParams3d, QPoint2dList, QPoint3dList, Quantization, RenderMode, RenderTexture, TextureMapping, TextureTransparency, TileFormat, TileReadStatus, } from "@itwin/core-common";
 import { IModelApp } from "../IModelApp";
@@ -44,6 +44,7 @@ export class GltfBufferData {
             switch (expectedType) {
                 case GltfDataType.Float:
                 case GltfDataType.UnsignedByte:
+                case GltfDataType.SignedByte:
                     return undefined;
                 case GltfDataType.UnsignedShort:
                     if (GltfDataType.UnsignedByte !== actualType)
@@ -64,6 +65,8 @@ export class GltfBufferData {
         switch (actualType) {
             case GltfDataType.UnsignedByte:
                 return bytes;
+            case GltfDataType.SignedByte:
+                return new Int8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
             case GltfDataType.UnsignedShort:
                 return new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
             case GltfDataType.UInt32:
@@ -640,6 +643,8 @@ export class GltfReader {
                     this._instanceElementIdToFeatureId.set(instanceElementId, this._instanceFeatures.length);
                     this._instanceFeatures.push(new Feature(instanceElementId));
                 }
+                // If the map didn't contain instanceElementId, it was inserted above
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 const instanceFeatureId = this._instanceElementIdToFeatureId.get(instanceElementId);
                 featureIds[localInstanceId * 3 + 0] = instanceFeatureId & 0xFF;
                 featureIds[localInstanceId * 3 + 1] = (instanceFeatureId >> 8) & 0xFF;
@@ -771,6 +776,7 @@ export class GltfReader {
             let dataSize = 0;
             switch (type) {
                 case GltfDataType.UnsignedByte:
+                case GltfDataType.SignedByte:
                     dataSize = 1;
                     break;
                 case GltfDataType.UnsignedShort:
@@ -1048,7 +1054,7 @@ export class GltfReader {
             case MeshPrimitiveType.Mesh: {
                 if (!this.readMeshIndices(mesh, primitive))
                     return undefined;
-                if (!displayParams.ignoreLighting && !this.readNormals(mesh, primitive.attributes, "NORMAL"))
+                if (!displayParams.ignoreLighting && !this.readMeshNormals(mesh, primitive.attributes, "NORMAL"))
                     return undefined;
                 if (!mesh.uvs) {
                     let texCoordIndex = 0;
@@ -1090,8 +1096,8 @@ export class GltfReader {
                 const indices = mesh.indices;
                 assert(indices !== undefined);
                 assert(visibility.buffer instanceof Uint8Array);
-                const silhouetteNormals = this.readBufferData16(ext, "silhouetteNormals");
-                const normalPairs = silhouetteNormals ? new Uint32Array(silhouetteNormals.buffer.buffer, silhouetteNormals.buffer.byteOffset, silhouetteNormals.buffer.byteLength / 4) : undefined;
+                const silhouetteNormals = this.readAndOctEncodeNormals(ext, "silhouetteNormals");
+                const normalPairs = silhouetteNormals ? new Uint32Array(silhouetteNormals.buffer, silhouetteNormals.byteOffset, silhouetteNormals.byteLength / 4) : undefined;
                 mesh.primitive.edges = new MeshEdges();
                 for (const edge of compactEdgeIterator(visibility.buffer, normalPairs, indices.length, (idx) => indices[idx])) {
                     if (undefined === edge.normals) {
@@ -1312,9 +1318,14 @@ export class GltfReader {
             points[i * 3 + 1] = mesh.points[index * 3 + 1];
             points[i * 3 + 2] = mesh.points[index * 3 + 2];
             if (normals)
+                // normals is only defined if mesh.normals is defined.
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 normals[i] = mesh.normals[index];
             if (uvs) {
+                // uvs is only defined if mesh.uvs is defined.
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 uvs[i * 2 + 0] = mesh.uvs[index * 2 + 0];
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 uvs[i * 2 + 1] = mesh.uvs[index * 2 + 1];
             }
         }
@@ -1435,7 +1446,7 @@ export class GltfReader {
                 if (featureIdDesc.attribute === undefined) {
                     continue;
                 }
-                const { buffer, stride } = featureIdBuffers.get(featureIdDesc.attribute);
+                const { buffer, stride } = expectDefined(featureIdBuffers.get(featureIdDesc.attribute));
                 const featureId = buffer[vertexId * stride];
                 const propertyTableId = featureIdDesc.propertyTable ?? 0;
                 vertexUniqueId = `${vertexUniqueId}-${featureId}-${propertyTableId}`;
@@ -1447,7 +1458,7 @@ export class GltfReader {
                     if (featureIdDesc.attribute === undefined) {
                         continue;
                     }
-                    const { buffer, stride } = featureIdBuffers.get(featureIdDesc.attribute);
+                    const { buffer, stride } = expectDefined(featureIdBuffers.get(featureIdDesc.attribute));
                     const featureId = buffer[vertexId * stride];
                     const table = this._structuralMetadata.tables[featureIdDesc.propertyTable ?? 0];
                     vertexProps[table.name] = {};
@@ -1489,40 +1500,67 @@ export class GltfReader {
             mesh.indices[i] = i;
         return true;
     }
-    readNormals(mesh, json, accessorName) {
+    readMeshNormals(mesh, json, accessorName) {
+        const normals = this.readAndOctEncodeNormals(json, accessorName);
+        if (normals) {
+            mesh.normals = normals;
+            return true;
+        }
+        return false;
+    }
+    readAndOctEncodeNormals(json, accessorName) {
         const view = this.getBufferView(json, accessorName);
         if (undefined === view)
-            return false;
+            return undefined;
         switch (view.type) {
             case GltfDataType.Float: {
                 const data = view.toBufferData(GltfDataType.Float);
                 if (undefined === data)
-                    return false;
-                mesh.normals = new Uint16Array(data.count);
+                    return undefined;
+                const normals = new Uint16Array(data.count);
                 const scratchNormal = new Vector3d();
                 const strideSkip = view.stride - 3;
                 for (let i = 0, j = 0; i < data.count; i++, j += strideSkip) {
                     scratchNormal.set(data.buffer[j++], data.buffer[j++], data.buffer[j++]);
-                    mesh.normals[i] = OctEncodedNormal.encode(scratchNormal);
+                    normals[i] = OctEncodedNormal.encode(scratchNormal);
                 }
-                return true;
+                return normals;
             }
+            case GltfDataType.SignedByte: {
+                const data = view.toBufferData(GltfDataType.SignedByte);
+                if (!data) {
+                    return undefined;
+                }
+                const normalize = (val) => 2 * ((val + 128) / 255) - 1;
+                const normals = new Uint16Array(data.count);
+                const scratchNormal = new Vector3d();
+                const strideSkip = view.stride - 3;
+                for (let i = 0, j = 0; i < data.count; i++, j += strideSkip) {
+                    const x = normalize(data.buffer[j++]);
+                    const y = normalize(data.buffer[j++]);
+                    const z = normalize(data.buffer[j++]);
+                    scratchNormal.set(x, y, z);
+                    normals[i] = OctEncodedNormal.encode(scratchNormal);
+                }
+                return normals;
+            }
+            // This is weird, why does it assume 8-bit normal vectors are actually 16-bit oct-encoded normals?
             case GltfDataType.UnsignedByte: {
                 const data = view.toBufferData(GltfDataType.UnsignedByte);
                 if (undefined === data)
-                    return false;
+                    return undefined;
                 // ###TODO: we shouldn't have to allocate OctEncodedNormal objects...just use uint16s / numbers...
-                mesh.normals = new Uint16Array(data.count);
+                const normals = new Uint16Array(data.count);
                 for (let i = 0; i < data.count; i++) {
                     // ###TODO? not clear why ray writes these as pairs of uint8...
                     const index = i * view.stride;
                     const normal = data.buffer[index] | (data.buffer[index + 1] << 8);
-                    mesh.normals[i] = normal;
+                    normals[i] = normal;
                 }
-                return true;
+                return normals;
             }
             default:
-                return false;
+                return undefined;
         }
     }
     readColors(mesh, attribute, accessorName) {