@itwin/core-frontend 5.2.0-dev.5 → 5.2.0-dev.7

package/lib/cjs/tile/GltfReader.js

@@ -74,6 +74,7 @@ class GltfBufferData {
             switch (expectedType) {
                 case GltfSchema_1.GltfDataType.Float:
                 case GltfSchema_1.GltfDataType.UnsignedByte:
+                case GltfSchema_1.GltfDataType.SignedByte:
                     return undefined;
                 case GltfSchema_1.GltfDataType.UnsignedShort:
                     if (GltfSchema_1.GltfDataType.UnsignedByte !== actualType)
@@ -94,6 +95,8 @@ class GltfBufferData {
         switch (actualType) {
             case GltfSchema_1.GltfDataType.UnsignedByte:
                 return bytes;
+            case GltfSchema_1.GltfDataType.SignedByte:
+                return new Int8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
             case GltfSchema_1.GltfDataType.UnsignedShort:
                 return new Uint16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);
             case GltfSchema_1.GltfDataType.UInt32:
@@ -673,6 +676,8 @@ class GltfReader {
                     this._instanceElementIdToFeatureId.set(instanceElementId, this._instanceFeatures.length);
                     this._instanceFeatures.push(new core_common_1.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;
@@ -804,6 +809,7 @@ class GltfReader {
             let dataSize = 0;
             switch (type) {
                 case GltfSchema_1.GltfDataType.UnsignedByte:
+                case GltfSchema_1.GltfDataType.SignedByte:
                     dataSize = 1;
                     break;
                 case GltfSchema_1.GltfDataType.UnsignedShort:
@@ -1081,7 +1087,7 @@ class GltfReader {
             case MeshPrimitive_1.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;
@@ -1123,8 +1129,8 @@ class GltfReader {
                 const indices = mesh.indices;
                 (0, core_bentley_1.assert)(indices !== undefined);
                 (0, core_bentley_1.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 core_common_1.MeshEdges();
                 for (const edge of (0, CompactEdges_1.compactEdgeIterator)(visibility.buffer, normalPairs, indices.length, (idx) => indices[idx])) {
                     if (undefined === edge.normals) {
@@ -1345,9 +1351,14 @@ 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];
             }
         }
@@ -1468,7 +1479,7 @@ class GltfReader {
                 if (featureIdDesc.attribute === undefined) {
                     continue;
                 }
-                const { buffer, stride } = featureIdBuffers.get(featureIdDesc.attribute);
+                const { buffer, stride } = (0, core_bentley_1.expectDefined)(featureIdBuffers.get(featureIdDesc.attribute));
                 const featureId = buffer[vertexId * stride];
                 const propertyTableId = featureIdDesc.propertyTable ?? 0;
                 vertexUniqueId = `${vertexUniqueId}-${featureId}-${propertyTableId}`;
@@ -1480,7 +1491,7 @@ class GltfReader {
                     if (featureIdDesc.attribute === undefined) {
                         continue;
                     }
-                    const { buffer, stride } = featureIdBuffers.get(featureIdDesc.attribute);
+                    const { buffer, stride } = (0, core_bentley_1.expectDefined)(featureIdBuffers.get(featureIdDesc.attribute));
                     const featureId = buffer[vertexId * stride];
                     const table = this._structuralMetadata.tables[featureIdDesc.propertyTable ?? 0];
                     vertexProps[table.name] = {};
@@ -1522,40 +1533,67 @@ 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 GltfSchema_1.GltfDataType.Float: {
                 const data = view.toBufferData(GltfSchema_1.GltfDataType.Float);
                 if (undefined === data)
-                    return false;
-                mesh.normals = new Uint16Array(data.count);
+                    return undefined;
+                const normals = new Uint16Array(data.count);
                 const scratchNormal = new core_geometry_1.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] = core_common_1.OctEncodedNormal.encode(scratchNormal);
+                    normals[i] = core_common_1.OctEncodedNormal.encode(scratchNormal);
                 }
-                return true;
+                return normals;
             }
+            case GltfSchema_1.GltfDataType.SignedByte: {
+                const data = view.toBufferData(GltfSchema_1.GltfDataType.SignedByte);
+                if (!data) {
+                    return undefined;
+                }
+                const normalize = (val) => 2 * ((val + 128) / 255) - 1;
+                const normals = new Uint16Array(data.count);
+                const scratchNormal = new core_geometry_1.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] = core_common_1.OctEncodedNormal.encode(scratchNormal);
+                }
+                return normals;
+            }
+            // This is weird, why does it assume 8-bit normal vectors are actually 16-bit oct-encoded normals?
             case GltfSchema_1.GltfDataType.UnsignedByte: {
                 const data = view.toBufferData(GltfSchema_1.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) {