@itwin/core-common 3.2.0-dev.8 → 3.3.0-dev.1

package/lib/esm/tile/TileMetadata.js

@@ -5,7 +5,7 @@
 /** @packageDocumentation
  * @module Tile
  */
-import { assert, compareBooleansOrUndefined, compareNumbers, compareStringsOrUndefined, Id64, } from "@itwin/core-bentley";
+import { assert, compareBooleans, compareBooleansOrUndefined, compareNumbers, compareStringsOrUndefined, Id64, } from "@itwin/core-bentley";
 import { Range3d, Vector3d } from "@itwin/core-geometry";
 import { BatchType } from "../FeatureTable";
 import { CurrentImdlVersion, FeatureTableHeader, ImdlFlags, ImdlHeader } from "./IModelTileIO";
@@ -28,6 +28,7 @@ export var TileOptions;
     function fromTreeIdAndContentId(treeId, contentId) {
         const tree = treeFlagsAndFormatVersionFromId(treeId);
         const contentFlags = contentFlagsFromId(contentId);
+        const edgeOptions = edgeOptionsFromTreeId(treeId);
         return {
             maximumMajorTileFormatVersion: tree.version,
             enableInstancing: 0 !== (contentFlags & ContentFlags.AllowInstancing),
@@ -39,137 +40,143 @@ export var TileOptions;
             useLargerTiles: 0 !== (tree.flags & TreeFlags.UseLargerTiles),
             disableMagnification: false,
             alwaysSubdivideIncompleteTiles: false,
-            enableIndexedEdges: true,
+            enableIndexedEdges: edgeOptions && edgeOptions.indexed,
+            generateAllPolyfaceEdges: edgeOptions && edgeOptions.smooth,
         };
     }
     TileOptions.fromTreeIdAndContentId = fromTreeIdAndContentId;
 })(TileOptions || (TileOptions = {}));
-/** @internal */
-export function parseTileTreeIdAndContentId(treeId, contentId) {
-    let idx = 0;
-    let type, expansion, animationId, edges, sectionCut;
-    // Skip version and flags, they're handled by TileOptions.fromTreeIdAndContentId
-    while (idx < treeId.length && treeId[idx] !== "-")
-        idx++;
-    idx++; // -
-    if (idx >= treeId.length)
-        throw new Error("Invalid tree Id");
-    if (treeId[idx] === "C") {
-        // PlanarClassifier or VolumeClassifier
-        ({ idx, type, expansion } = parseClassifier(idx, treeId, expansion));
-    }
-    else {
-        type = BatchType.Primary;
-    }
-    // Animation
-    // eslint-disable-next-line prefer-const
-    ({ idx, animationId } = parseAnimation(idx, treeId, animationId));
-    if (type === BatchType.Primary) {
-        ({ idx, edges, sectionCut } = parsePrimary(idx, treeId, edges, sectionCut));
-    }
-    const modelId = treeId.substr(idx);
-    if (!Id64.isId64(modelId))
-        throw new Error("Invalid tree Id");
-    const { flags: treeFlags } = treeFlagsAndFormatVersionFromId(treeId);
-    const parsedTreeId = getTreeId(type, edges, sectionCut, animationId, expansion, (treeFlags & TreeFlags.EnforceDisplayPriority) !== 0 ? true : undefined);
-    const options = TileOptions.fromTreeIdAndContentId(treeId, contentId);
-    let parsedContentId;
-    try {
-        parsedContentId = ContentIdProvider.create(true, options).specFromId(contentId);
-    }
-    catch (e) {
-        throw new Error("Invalid content Id");
-    }
-    if (Object.keys(parsedContentId).some((key) => parsedContentId.hasOwnProperty(key) && typeof parsedContentId[key] === "number" && !Number.isFinite(parsedContentId[key])))
-        throw new Error("Invalid content Id");
-    return {
-        contentId: parsedContentId,
-        modelId,
-        options,
-        treeId: parsedTreeId,
-    };
-}
-function getTreeId(type, edges, sectionCut, animationId, expansion, enforceDisplayPriority) {
-    if (type === BatchType.Primary)
-        return {
-            type,
-            edges,
-            sectionCut,
-            animationId,
-            enforceDisplayPriority,
-        };
-    else
+class Parser {
+    constructor(input) {
+        this.curPos = 0;
+        this.input = input;
+    }
+    parse(contentId) {
+        this.require(this.input.length > 0);
+        // Skip version and flags, they're handled by TileOptions.fromTreeIdAndContentId
+        while (this.curPos < this.input.length && this.cur() !== "-")
+            this.advance();
+        this.eat("-");
+        this.require(this.curPos < this.input.length);
+        const classifier = this.cur() === "C" ? this.parseClassifier() : undefined;
+        const animationId = this.parseAnimation();
+        const primary = classifier ? undefined : this.parsePrimary();
+        this.require((undefined === classifier) !== (undefined === primary));
+        const modelId = this.input.substr(this.curPos);
+        this.require(Id64.isId64(modelId));
+        const { flags: treeFlags } = treeFlagsAndFormatVersionFromId(this.input);
+        const options = TileOptions.fromTreeIdAndContentId(this.input, contentId);
+        let parsedContentId;
+        try {
+            parsedContentId = ContentIdProvider.create(true, options).specFromId(contentId);
+        }
+        catch (e) {
+            this.reject("Invalid content Id");
+        }
+        if (Object.keys(parsedContentId).some((key) => parsedContentId.hasOwnProperty(key) && typeof parsedContentId[key] === "number" && !Number.isFinite(parsedContentId[key])))
+            throw new Error("Invalid content Id");
+        let treeId;
+        if (classifier) {
+            treeId = { ...classifier, animationId };
+        }
+        else {
+            assert(undefined !== primary);
+            const enforceDisplayPriority = (treeFlags & TreeFlags.EnforceDisplayPriority) !== 0 ? true : undefined;
+            treeId = { ...primary, animationId, type: BatchType.Primary, enforceDisplayPriority };
+        }
         return {
-            type,
-            expansion,
-            animationId,
+            contentId: parsedContentId,
+            modelId,
+            options,
+            treeId,
         };
-}
-function parsePrimary(idx, treeId, edges = EdgeType.None, sectionCut) {
-    // Edges
-    edges = EdgeType.NonIndexed;
-    if (idx < treeId.length) {
-        const noEdgesStr = "E:0_";
-        if (treeId.startsWith(noEdgesStr, idx))
-            edges = EdgeType.None;
-        else if (treeId.startsWith("E:2_", idx))
-            edges = EdgeType.Indexed;
-        if (EdgeType.NonIndexed !== edges)
-            idx += noEdgesStr.length;
-    }
-    // Section cut
-    if (idx + 1 < treeId.length && treeId[idx] === "S") {
-        idx++; // S
-        sectionCut = "";
-        while (idx < treeId.length && treeId[idx] !== "s") {
-            sectionCut += treeId[idx++];
-        }
-        if (idx === treeId.length)
-            throw new Error("Invalid tree Id");
-        idx++; // s
     }
-    return { idx, edges, sectionCut };
-}
-function parseClassifier(idx, treeId, expansion) {
-    let type;
-    idx++; // C
-    if (idx + 1 < treeId.length && treeId[idx] === "P" && treeId[idx + 1] === ":") {
-        type = BatchType.PlanarClassifier;
-        idx += 2; // P:
+    cur() {
+        this.require(this.curPos < this.input.length);
+        return this.input[this.curPos];
     }
-    else if (idx < treeId.length && treeId[idx] === ":") {
-        type = BatchType.VolumeClassifier;
-        idx++; // :
+    advance() {
+        this.require(this.curPos < this.input.length);
+        ++this.curPos;
     }
-    else {
-        throw new Error("Invalid tree Id");
+    eat(expectedChar) {
+        this.require(this.cur() === expectedChar);
+        this.advance();
     }
-    // C: or CP: is always followed by {expansion}_
-    let expansionStr = "";
-    while (idx < treeId.length && (treeId[idx] >= "0" && treeId[idx] <= "9" || treeId[idx] === ".")) {
-        expansionStr += treeId[idx++];
+    reject(message = "Invalid tree Id") {
+        throw new Error(message);
     }
-    if (idx === treeId.length || treeId[idx] !== "_")
-        throw new Error("Invalid tree Id");
-    idx++; // _
-    expansion = Number.parseFloat(expansionStr);
-    return { idx, type, expansion };
-}
-function parseAnimation(idx, treeId, animationId) {
-    if (idx < treeId.length && treeId[idx] === "A") {
-        if (idx + 1 < treeId.length && treeId[idx + 1] !== ":")
-            throw new Error("Invalid tree Id");
-        idx += 2;
-        // Parse animation id
-        animationId = "";
-        while (idx < treeId.length && treeId[idx] !== "_") {
-            animationId += treeId[idx++];
+    require(condition, message = "Invalid tree Id") {
+        if (!condition)
+            this.reject(message);
+    }
+    parseClassifier() {
+        this.eat("C");
+        let type = BatchType.VolumeClassifier;
+        if (this.cur() === "P") {
+            type = BatchType.PlanarClassifier;
+            this.advance();
         }
-        if (!Id64.isId64(animationId) || idx === treeId.length)
-            throw new Error("Invalid tree Id");
-        idx++; // _
+        this.eat(":");
+        // C: or CP: is always folowed by expansion then an underscore.
+        let expansionStr = "";
+        while (this.curPos < this.input.length && (this.cur() >= "0" && this.cur() <= "9" || this.cur() === ".")) {
+            expansionStr += this.cur();
+            this.advance();
+        }
+        this.eat("_");
+        const expansion = Number.parseFloat(expansionStr);
+        this.require(!Number.isNaN(expansion));
+        return { type, expansion };
+    }
+    parseAnimation() {
+        if (this.cur() !== "A")
+            return undefined;
+        this.eat("A");
+        this.eat(":");
+        const termPos = this.input.indexOf("_", this.curPos);
+        this.require(termPos > this.curPos);
+        const animationId = this.input.substring(this.curPos, termPos);
+        this.require(Id64.isId64(animationId));
+        this.curPos = termPos + 1; // Skip "_"
+        return animationId;
+    }
+    parsePrimary() {
+        const edges = this.parseEdges();
+        const sectionCut = this.parseSectionCut();
+        return { edges, sectionCut };
+    }
+    parseEdges() {
+        if ("E" !== this.cur())
+            return { indexed: false, smooth: false };
+        this.eat("E");
+        this.eat(":");
+        const typeStr = this.cur();
+        this.eat(typeStr);
+        this.eat("_");
+        switch (typeStr) {
+            case "0": return false;
+            case "2": return { indexed: true, smooth: false };
+            case "3": return { indexed: false, smooth: true };
+            case "4": return { indexed: true, smooth: true };
+            default: this.reject();
+        }
+    }
+    parseSectionCut() {
+        if ("S" !== this.cur())
+            return undefined;
+        this.eat("S");
+        const termPos = this.input.indexOf("s", this.curPos);
+        this.require(termPos > this.curPos);
+        const sectionCut = this.input.substring(this.curPos, termPos);
+        this.curPos = termPos + 1; // Skip "_";
+        return sectionCut;
     }
-    return { idx, animationId };
+}
+/** @internal */
+export function parseTileTreeIdAndContentId(treeId, contentId) {
+    const parser = new Parser(treeId);
+    return parser.parse(contentId);
 }
 /** @internal */
 export const defaultTileOptions = Object.freeze({
@@ -184,6 +191,7 @@ export const defaultTileOptions = Object.freeze({
     disableMagnification: false,
     alwaysSubdivideIncompleteTiles: false,
     enableIndexedEdges: true,
+    generateAllPolyfaceEdges: true,
 });
 function contentFlagsFromId(id) {
     if (0 === id.length || "-" !== id[0])
@@ -212,6 +220,18 @@ function treeFlagsAndFormatVersionFromId(id) {
     }
     throw new Error("Invalid tree Id");
 }
+function edgeOptionsFromTreeId(id) {
+    const pos = id.indexOf("E:");
+    if (pos <= 0)
+        return { indexed: false, smooth: false };
+    switch (id[pos + 2]) {
+        case "0": return { indexed: defaultTileOptions.enableIndexedEdges, smooth: defaultTileOptions.generateAllPolyfaceEdges };
+        case "2": return { indexed: true, smooth: false };
+        case "3": return { indexed: false, smooth: true };
+        case "4": return { indexed: true, smooth: true };
+    }
+    throw new Error("Invalid tree Id");
+}
 /** @internal */
 export function getMaximumMajorTileFormatVersion(maxMajorVersion, formatVersion) {
     // The `formatVersion` input is from the backend, telling us precisely the maximum major+minor version it can produce.
@@ -238,18 +258,19 @@ export var TreeFlags;
     TreeFlags[TreeFlags["OptimizeBRepProcessing"] = 4] = "OptimizeBRepProcessing";
     TreeFlags[TreeFlags["UseLargerTiles"] = 8] = "UseLargerTiles";
 })(TreeFlags || (TreeFlags = {}));
-/** Describes the type of edges to include in the graphics for a tile tree.
- * @alpha
- */
-export var EdgeType;
-(function (EdgeType) {
-    /** Omit all edges. */
-    EdgeType[EdgeType["None"] = 0] = "None";
-    /** Include non-indexed edges, which consume more memory and are less efficient to draw than [[Indexed]] edges, but are compatible with WebGL 1. */
-    EdgeType[EdgeType["NonIndexed"] = 1] = "NonIndexed";
-    /** Include indexed edges, which use less memory and draw more efficiently than [[NonIndexed]] edges, but require WebGL 2. */
-    EdgeType[EdgeType["Indexed"] = 2] = "Indexed";
-})(EdgeType || (EdgeType = {}));
+function compareEdgeOptions(a, b) {
+    if (typeof a !== typeof b)
+        return a ? 1 : -1;
+    if (typeof a === "boolean") {
+        assert(typeof b === "boolean");
+        return compareBooleans(a, b);
+    }
+    assert(typeof b === "object");
+    let cmp = compareBooleans(a.indexed, b.indexed);
+    if (0 === cmp)
+        cmp = compareBooleans(a.smooth, b.smooth);
+    return cmp;
+}
 function animationIdToString(animationId) {
     return `A:${animationId}_`;
 }
@@ -268,7 +289,16 @@ export function iModelTileTreeIdToString(modelId, treeId, options) {
             idStr = `${idStr}${animationIdToString(treeId.animationId)}`;
         else if (treeId.enforceDisplayPriority) // animation and priority are currently mutually exclusive
             flags |= TreeFlags.EnforceDisplayPriority;
-        const edges = treeId.edges !== EdgeType.NonIndexed ? `E:${treeId.edges}_` : "";
+        let edges;
+        if (!treeId.edges) {
+            edges = "E:0_";
+        }
+        else {
+            if (!treeId.edges.smooth)
+                edges = treeId.edges.indexed ? "E:2_" : "";
+            else
+                edges = treeId.edges.indexed ? "E:4_" : "E:3_";
+        }
         const sectionCut = treeId.sectionCut ? `S${treeId.sectionCut}s` : "";
         idStr = `${idStr}${edges}${sectionCut}`;
     }
@@ -299,7 +329,7 @@ export function compareIModelTileTreeIds(lhs, rhs) {
     // NB: The redundant checks on BatchType below are to satisfy compiler.
     assert(lhs.type === rhs.type);
     if (BatchType.Primary === lhs.type && BatchType.Primary === rhs.type) {
-        cmp = compareNumbers(lhs.edges, rhs.edges);
+        cmp = compareEdgeOptions(lhs.edges, rhs.edges);
         if (0 === cmp) {
             cmp = compareBooleansOrUndefined(lhs.enforceDisplayPriority, rhs.enforceDisplayPriority);
             if (0 === cmp)