@itwin/core-backend 5.7.0-dev.6 → 5.7.0-dev.7

package/lib/esm/test/standalone/ExportGraphics.test.js

@@ -379,6 +379,27 @@ describe("exportGraphics", () => {
         // Sorting since output order is arbitrary
         assert.deepStrictEqual([infos[0].elementId, infos[1].elementId].sort(), [id0, id1].sort());
     });
+    it("process multiple elements simultaneously using separate async calls", async () => {
+        const builder0 = new GeometryStreamBuilder();
+        builder0.appendGeometry(Loop.createPolygon([Point3d.createZero(), Point3d.create(1, 0, 0), Point3d.create(1, 1, 0), Point3d.create(0, 1, 0)]));
+        const id0 = insertPhysicalElement(builder0.geometryStream);
+        const builder1 = new GeometryStreamBuilder();
+        builder1.appendGeometry(Loop.createPolygon([Point3d.createZero(), Point3d.create(-1, 0, 0), Point3d.create(-1, -1, 0), Point3d.create(0, -1, 0)]));
+        const id1 = insertPhysicalElement(builder1.geometryStream);
+        const infos = [];
+        const onGraphics = (info) => infos.push(info);
+        const promises = [id0, id1].map(async (id) => iModel.exportGraphicsAsync({
+            elementIdArray: [id],
+            onGraphics,
+        }));
+        // onGraphics should not be called yet
+        assert.strictEqual(infos.length, 0);
+        await Promise.all(promises);
+        // once both promises are resolved, the results are available.
+        assert.strictEqual(infos.length, 2);
+        // Sorting since output order is arbitrary
+        assert.deepStrictEqual([infos[0].elementId, infos[1].elementId].sort(), [id0, id1].sort());
+    });
     it("produces expected indices, points, normals, params in smoketest", () => {
         const builder = new GeometryStreamBuilder();
         builder.appendGeometry(Loop.createPolygon([Point3d.createZero(), Point3d.create(1, 0, 0), Point3d.create(1, 1, 0), Point3d.create(0, 1, 0)]));
@@ -692,6 +713,74 @@ describe("exportGraphics", () => {
         assert.deepStrictEqual(Array.from(partInfos[0].mesh.normals), [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1]);
         assert.deepStrictEqual(Array.from(partInfos[0].mesh.params), [1, 0, 0, 1, 0, 0, 1, 1]);
     });
+    it("exports multiple parts simultaneously with exportPartGraphicsAsync", async () => {
+        const partBuilder = new GeometryStreamBuilder();
+        partBuilder.appendGeometry(Loop.createPolygon([Point3d.createZero(), Point3d.create(1, 0, 0), Point3d.create(1, 1, 0), Point3d.create(0, 1, 0)]));
+        const partProps = {
+            classFullName: GeometryPart.classFullName,
+            model: IModel.dictionaryId,
+            code: Code.createEmpty(),
+            geom: partBuilder.geometryStream,
+        };
+        // Add two parts
+        const partId1 = iModel.elements.insertElement(partProps);
+        const partId2 = iModel.elements.insertElement(partProps);
+        const partInstanceBuilder = new GeometryStreamBuilder();
+        partInstanceBuilder.appendGeometryPart3d(partId1, Point3d.create(7, 8, 9));
+        partInstanceBuilder.appendGeometryPart3d(partId2, Point3d.create(10, 11, 12));
+        const partInstanceId = insertPhysicalElement(partInstanceBuilder.geometryStream);
+        const infos = [];
+        const partInstanceArray = [];
+        const exportGraphicsOptions = {
+            elementIdArray: [partInstanceId],
+            onGraphics: (info) => infos.push(info),
+            partInstanceArray,
+        };
+        await iModel.exportGraphicsAsync(exportGraphicsOptions);
+        assert.strictEqual(infos.length, 0);
+        assert.strictEqual(partInstanceArray.length, 2);
+        assert.isTrue(partInstanceArray[0].partId === partId1 || partInstanceArray[1].partId === partId1);
+        assert.isTrue(partInstanceArray[0].partId === partId2 || partInstanceArray[1].partId === partId2);
+        assert.isTrue(partInstanceArray[0].partId !== partInstanceArray[1].partId);
+        assert.strictEqual(partInstanceArray[0].partInstanceId, partInstanceId);
+        assert.strictEqual(partInstanceArray[1].partInstanceId, partInstanceId);
+        assert.isDefined(partInstanceArray[0].transform);
+        assert.deepStrictEqual(Array.from(partInstanceArray[0].transform), [1, 0, 0, 7, 0, 1, 0, 8, 0, 0, 1, 9]);
+        assert.isDefined(partInstanceArray[1].transform);
+        assert.deepStrictEqual(Array.from(partInstanceArray[1].transform), [1, 0, 0, 10, 0, 1, 0, 11, 0, 0, 1, 12]);
+        const partInfos = [];
+        const onPartGraphics = (partInfo) => partInfos.push(partInfo);
+        const promises = partInstanceArray.map(async (partInstance) => iModel.exportPartGraphicsAsync({
+            elementId: partInstance.partId,
+            displayProps: partInstance.displayProps,
+            onPartGraphics,
+        }));
+        // onPartGraphics should not be called yet
+        assert.strictEqual(partInfos.length, 0);
+        await Promise.all(promises);
+        // once both promises are resolved, the results are available.
+        assert.strictEqual(partInfos.length, 2);
+        // The ordering of these values is arbitrary, but should be consistent between runs.
+        // Baselines may need to be updated if native GeomLibs is refactored, but:
+        //   * Lengths of all fields should remain the same
+        //   * Actual point, normal and param values should remain the same
+        assert.strictEqual(partInfos[0].mesh.indices.length, 6);
+        assert.strictEqual(partInfos[0].mesh.points.length, 12);
+        assert.strictEqual(partInfos[0].mesh.normals.length, 12);
+        assert.strictEqual(partInfos[0].mesh.params.length, 8);
+        assert.strictEqual(partInfos[1].mesh.indices.length, 6);
+        assert.strictEqual(partInfos[1].mesh.points.length, 12);
+        assert.strictEqual(partInfos[1].mesh.normals.length, 12);
+        assert.strictEqual(partInfos[1].mesh.params.length, 8);
+        assert.deepStrictEqual(Array.from(partInfos[0].mesh.indices), [0, 1, 2, 1, 0, 3]);
+        assert.deepStrictEqual(Array.from(partInfos[0].mesh.points), [1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0]);
+        assert.deepStrictEqual(Array.from(partInfos[0].mesh.normals), [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1]);
+        assert.deepStrictEqual(Array.from(partInfos[0].mesh.params), [1, 0, 0, 1, 0, 0, 1, 1]);
+        assert.deepStrictEqual(Array.from(partInfos[1].mesh.indices), [0, 1, 2, 1, 0, 3]);
+        assert.deepStrictEqual(Array.from(partInfos[1].mesh.points), [1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0]);
+        assert.deepStrictEqual(Array.from(partInfos[1].mesh.normals), [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1]);
+        assert.deepStrictEqual(Array.from(partInfos[1].mesh.params), [1, 0, 0, 1, 0, 0, 1, 1]);
+    });
     it("handles single geometryClass in GeometryStream", () => {
         const builder = new GeometryStreamBuilder();
         const geometryParams = new GeometryParams(seedCategory);