@itwin/core-frontend 4.10.0-dev.2 → 4.10.0-dev.22

package/lib/esm/tile/GltfReader.js

@@ -9,7 +9,6 @@ import { assert, ByteStream, compareBooleans, compareNumbers, compareStrings, Di
 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, PackedFeatureTable, QParams2d, QParams3d, QPoint2dList, QPoint3dList, Quantization, RenderMode, RenderTexture, TextureMapping, TextureTransparency, TileFormat, TileReadStatus, } from "@itwin/core-common";
 import { IModelApp } from "../IModelApp";
-import { GraphicBranch } from "../render/GraphicBranch";
 import { RealityMeshParams } from "../render/RealityMeshParams";
 import { Mesh } from "../common/internal/render/MeshPrimitives";
 import { Triangle } from "../common/internal/render/Primitives";
@@ -19,6 +18,7 @@ import { FrontendLoggerCategory } from "../common/FrontendLoggerCategory";
 import { getImageSourceFormatForMimeType, imageBitmapFromImageSource, imageElementFromImageSource, tryImageElementFromUrl } from "../common/ImageUtil";
 import { MeshPrimitiveType } from "../common/internal/render/MeshPrimitive";
 import { getGltfNodeMeshIds, GltfDataType, gltfDictionaryIterator, GltfMeshMode, GltfTechniqueState, GltfWrapMode, isGltf1Material, traverseGltfNodes, } from "../common/gltf/GltfSchema";
+import { createGraphicTemplate } from "../render/GraphicTemplate";
 /**
  * A chunk of binary data exposed as a typed array.
  * The count member indicates how many elements exist. This may be less than this.buffer.length due to padding added to the
@@ -94,6 +94,14 @@ class GltfBufferView {
         return GltfBufferData.create(this.data, this.type, desiredType, this.count);
     }
 }
+function templateToGraphicResult(result, system) {
+    const template = result.template;
+    delete result.template;
+    return {
+        ...result,
+        graphic: template ? system.createGraphicFromTemplate({ template }) : undefined,
+    };
+}
 /** Data required for creating a [[GltfReader]] capable of deserializing [glTF](https://www.khronos.org/gltf/).
  * @internal
  */
@@ -313,6 +321,10 @@ export class GltfReader {
         return transform;
     }
     readGltfAndCreateGraphics(isLeaf, featureTable, contentRange, transformToRoot, pseudoRtcBias, instances) {
+        const result = this.readGltfAndCreateTemplate(isLeaf, featureTable, contentRange, true, transformToRoot, pseudoRtcBias, instances);
+        return templateToGraphicResult(result, this._system);
+    }
+    readGltfAndCreateTemplate(isLeaf, featureTable, contentRange, noDispose, transformToRoot, pseudoRtcBias, instances) {
         if (this._isCanceled)
             return { readStatus: TileReadStatus.Canceled, isLeaf };
         // If contentRange was not supplied, we will compute it as we read the meshes.
@@ -330,12 +342,12 @@ export class GltfReader {
         if (this._returnToCenter || this._nodes[0]?.matrix || (pseudoRtcBias && pseudoRtcBias.magnitude() < 1.0E5))
             pseudoRtcBias = undefined;
         const transformStack = new TransformStack();
-        const renderGraphicList = [];
+        const templateNodes = [];
         let readStatus = TileReadStatus.InvalidTileData;
         for (const nodeKey of this._sceneNodes) {
             assert(transformStack.isEmpty);
             const node = this._nodes[nodeKey];
-            if (node && TileReadStatus.Success !== (readStatus = this.readNodeAndCreateGraphics(renderGraphicList, node, featureTable, transformStack, instances, pseudoRtcBias)))
+            if (node && TileReadStatus.Success !== (readStatus = this.readTemplateNodes(templateNodes, node, featureTable, transformStack, instances, pseudoRtcBias)))
                 return { readStatus, isLeaf };
         }
         // Creates a feature table based on instance features
@@ -346,39 +358,35 @@ export class GltfReader {
                 featureTable.insertWithIndex(this._instanceFeatures[instanceFeatureId], instanceFeatureId);
             }
         }
-        if (0 === renderGraphicList.length)
+        if (0 === templateNodes.length)
             return { readStatus: TileReadStatus.InvalidTileData, isLeaf };
-        let renderGraphic;
-        if (1 === renderGraphicList.length)
-            renderGraphic = renderGraphicList[0];
-        else
-            renderGraphic = this._system.createGraphicList(renderGraphicList);
-        const transform = this.getTileTransform(transformToRoot, pseudoRtcBias);
         // Compute range in tileset/world space.
         let range = contentRange;
+        const transform = this.getTileTransform(transformToRoot, pseudoRtcBias);
         const invTransform = transform?.inverse();
         if (invTransform)
             range = invTransform.multiplyRange(contentRange);
         // The batch range needs to be in tile coordinate space.
         // If we computed the content range ourselves, it's already in tile space.
         // If the content range was supplied by the caller, it's in tileset space and needs to be transformed to tile space.
-        if (featureTable)
-            renderGraphic = this._system.createBatch(renderGraphic, PackedFeatureTable.pack(featureTable), this._computedContentRange ? contentRange : range);
+        const batch = !featureTable ? undefined : {
+            featureTable: PackedFeatureTable.pack(featureTable),
+            range: this._computedContentRange ? contentRange : range,
+        };
         const viewFlagOverrides = this.viewFlagOverrides;
-        if (transform || viewFlagOverrides) {
-            const branch = new GraphicBranch(true);
-            if (viewFlagOverrides)
-                branch.setViewFlagOverrides(viewFlagOverrides);
-            branch.add(renderGraphic);
-            renderGraphic = this._system.createBranch(branch, transform ?? Transform.createIdentity());
-        }
+        const branch = transform || viewFlagOverrides ? { transform, viewFlagOverrides } : undefined;
         return {
             readStatus,
             isLeaf,
             contentRange,
             range,
-            graphic: renderGraphic,
             containsPointCloud: this._containsPointCloud,
+            template: createGraphicTemplate({
+                nodes: templateNodes,
+                batch,
+                branch,
+                noDispose,
+            }),
         };
     }
     readGltfAndCreateGeometry(transformToRoot, needNormals = false, needParams = false) {
@@ -391,14 +399,14 @@ export class GltfReader {
         }
         return { polyfaces };
     }
-    graphicFromMeshData(gltfMesh, instances) {
+    geometryFromMeshData(gltfMesh, isInstanced) {
         if ("pointcloud" === gltfMesh.type)
-            return this._system.createPointCloud(gltfMesh, this._iModel);
+            return this._system.createPointCloudGeometry(gltfMesh);
         if (!gltfMesh.points || !gltfMesh.pointRange)
-            return this._system.createMeshGraphics(gltfMesh.primitive, instances);
-        const realityMeshPrimitive = (this._vertexTableRequired || instances) ? undefined : RealityMeshParams.fromGltfMesh(gltfMesh);
+            return this._system.createGeometryFromMesh(gltfMesh.primitive, undefined);
+        const realityMeshPrimitive = (this._vertexTableRequired || isInstanced) ? undefined : RealityMeshParams.fromGltfMesh(gltfMesh);
         if (realityMeshPrimitive) {
-            const realityMesh = this._system.createRealityMesh(realityMeshPrimitive);
+            const realityMesh = this._system.createRealityMeshGeometry(realityMeshPrimitive);
             if (realityMesh)
                 return realityMesh;
         }
@@ -416,7 +424,7 @@ export class GltfReader {
         if (gltfMesh.normals)
             for (const normal of gltfMesh.normals)
                 mesh.normals.push(new OctEncodedNormal(normal));
-        return this._system.createMeshGraphics(mesh, instances);
+        return this._system.createGeometryFromMesh(mesh, undefined);
     }
     readInstanceAttributes(node, featureTable) {
         const ext = node.extensions?.EXT_mesh_gpu_instancing;
@@ -539,7 +547,7 @@ export class GltfReader {
         }
         return { count, transforms, transformCenter, featureIds };
     }
-    readNodeAndCreateGraphics(renderGraphicList, node, featureTable, transformStack, batchInstances, pseudoRtcBias) {
+    readTemplateNodes(templateNodes, node, featureTable, transformStack, batchInstances, pseudoRtcBias) {
         if (undefined === node)
             return TileReadStatus.InvalidTileData;
         // IMPORTANT: Do not return without popping this node from the stack.
@@ -561,28 +569,19 @@ export class GltfReader {
             const nodeMesh = this._meshes[meshKey];
             if (nodeMesh?.primitives) {
                 const meshes = this.readMeshPrimitives(node, featureTable, thisTransform, thisBias, nodeInstances);
-                let renderGraphic;
                 if (0 !== meshes.length) {
-                    if (1 === meshes.length) {
-                        renderGraphic = this.graphicFromMeshData(meshes[0], batchInstances ?? nodeInstances);
-                    }
-                    else {
-                        const thisList = [];
-                        for (const mesh of meshes) {
-                            renderGraphic = this.graphicFromMeshData(mesh, batchInstances ?? nodeInstances);
-                            if (undefined !== renderGraphic)
-                                thisList.push(renderGraphic);
-                        }
-                        if (0 !== thisList.length)
-                            renderGraphic = this._system.createGraphicList(thisList);
+                    const thisList = [];
+                    for (const mesh of meshes) {
+                        const geometry = this.geometryFromMeshData(mesh, !!batchInstances || !!nodeInstances);
+                        if (undefined !== geometry)
+                            thisList.push(geometry);
                     }
-                    if (renderGraphic) {
-                        if (thisTransform && !thisTransform.isIdentity) {
-                            const branch = new GraphicBranch(true);
-                            branch.add(renderGraphic);
-                            renderGraphic = this._system.createBranch(branch, thisTransform);
-                        }
-                        renderGraphicList.push(renderGraphic);
+                    if (0 !== thisList.length) {
+                        templateNodes.push({
+                            geometry: thisList,
+                            transform: thisTransform && !thisTransform.isIdentity ? thisTransform : undefined,
+                            instances: batchInstances ?? nodeInstances,
+                        });
                     }
                 }
             }
@@ -591,7 +590,7 @@ export class GltfReader {
             for (const childId of node.children) {
                 const child = this._nodes[childId];
                 if (child)
-                    this.readNodeAndCreateGraphics(renderGraphicList, child, featureTable, transformStack, batchInstances ?? nodeInstances);
+                    this.readTemplateNodes(templateNodes, child, featureTable, transformStack, batchInstances ?? nodeInstances);
             }
         }
         transformStack.pop();
@@ -1606,11 +1605,7 @@ export class GltfReader {
 }
 /** Produce a [[RenderGraphic]] from a [glTF](https://www.khronos.org/gltf/) asset suitable for use in [view decorations]($docs/learning/frontend/ViewDecorations).
  * @returns a graphic produced from the glTF asset's default scene, or `undefined` if a graphic could not be produced from the asset.
- * @note Support for the full [glTF 2.0 specification](https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html) is currently a work in progress.
- * If a particular glTF asset fails to load and/or display properly, please
- * [submit an issue](https://github.com/iTwin/itwinjs-core/issues).
- * @see [Example decorator]($docs/learning/frontend/ViewDecorations#gltf-decorations) for an example of a decorator that reads and displays a glTF asset.
- * @see [[readGltf]] to obtain more information about the glTF model.
+ * @see [[readGltf]] for more details.
  * @public
  * @extensions
  */
@@ -1618,6 +1613,26 @@ export async function readGltfGraphics(args) {
     const result = await readGltf(args);
     return result?.graphic;
 }
+/** Produce a [[GraphicTemplate]] from a [glTF](https://www.khronos.org/gltf/) asset suitable for use in [view decorations]($docs/learning/frontend/ViewDecorations).
+ * @returns a template produced from the glTF asset's default scene, or `undefined` if a template could not be produced from the asset.
+ * @see [[readGltf]] for more details.
+ * @beta
+ */
+export async function readGltfTemplate(args) {
+    const baseUrl = typeof args.baseUrl === "string" ? new URL(args.baseUrl) : args.baseUrl;
+    const props = GltfReaderProps.create(args.gltf, true, baseUrl); // glTF supports exactly one coordinate system with y axis up.
+    const reader = props ? new GltfGraphicsReader(props, args) : undefined;
+    if (!reader)
+        return undefined;
+    const result = await reader.readTemplate();
+    if (!result.template)
+        return undefined;
+    return {
+        template: result.template,
+        localBoundingBox: result.contentRange ?? Range3d.createNull(),
+        boundingBox: result.range ?? Range3d.createNull(),
+    };
+}
 /** Produce a [[RenderGraphic]] from a [glTF](https://www.khronos.org/gltf/) asset suitable for use in [view decorations]($docs/learning/frontend/ViewDecorations).
  * @returns a graphic produced from the glTF asset's default scene, or `undefined` if a graphic could not be produced from the asset.
  * The returned graphic also includes the bounding boxes of the glTF model in world and local coordiantes.
@@ -1625,23 +1640,19 @@ export async function readGltfGraphics(args) {
  * If a particular glTF asset fails to load and/or display properly, please
  * [submit an issue](https://github.com/iTwin/itwinjs-core/issues).
  * @see [Example decorator]($docs/learning/frontend/ViewDecorations#gltf-decorations) for an example of a decorator that reads and displays a glTF asset.
+ * @see [[readGltfTemplate]] to produce a [[GraphicTemplate]] instead of a [[RenderGraphic]].
  * @public
  */
 export async function readGltf(args) {
-    const baseUrl = typeof args.baseUrl === "string" ? new URL(args.baseUrl) : args.baseUrl;
-    const props = GltfReaderProps.create(args.gltf, true, baseUrl); // glTF supports exactly one coordinate system with y axis up.
-    const reader = props ? new GltfGraphicsReader(props, args) : undefined;
-    if (!reader)
-        return undefined;
-    const result = await reader.read();
-    if (!result.graphic)
+    const result = await readGltfTemplate(args);
+    if (!result) {
         return undefined;
-    assert(result.contentRange !== undefined, "readGltf always computes content range");
-    assert(result.range !== undefined, "readGltf always computes world range");
+    }
+    const template = result.template;
+    delete result.template;
     return {
-        graphic: result.graphic,
-        localBoundingBox: result.contentRange ?? Range3d.createNull(),
-        boundingBox: result.range ?? Range3d.createNull(),
+        ...result,
+        graphic: IModelApp.renderSystem.createGraphicFromTemplate({ template }),
     };
 }
 /** Implements [[readGltfGraphics]]. Exported strictly for tests.
@@ -1827,10 +1838,14 @@ export class GltfGraphicsReader extends GltfReader {
             }
         }
     }
-    async read() {
+    async readTemplate() {
         await this.resolveResources();
         this.readGltfStructuralMetadata();
-        return this.readGltfAndCreateGraphics(this._isLeaf, this._featureTable, this._contentRange, this._transform);
+        return this.readGltfAndCreateTemplate(this._isLeaf, this._featureTable, this._contentRange, true, this._transform);
+    }
+    async read() {
+        const result = await this.readTemplate();
+        return templateToGraphicResult(result, this._system);
     }
     get structuralMetadata() { return this._structuralMetadata; }
     get nodes() { return this._nodes; }