@itwin/core-frontend 3.0.0-dev.98 → 3.0.0

package/lib/cjs/render/primitives/VertexTable.js

@@ -7,12 +7,14 @@
  * @module Rendering
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VertexTableBuilder = exports.PolylineParams = exports.MeshParams = exports.createSurfaceMaterial = exports.isValidSurfaceType = exports.SurfaceType = exports.tesselatePolyline = exports.PointStringParams = exports.VertexTable = exports.computeDimensions = exports.VertexIndices = void 0;
+exports.VertexTableBuilder = exports.MeshParams = exports.VertexTable = exports.computeDimensions = exports.VertexIndices = void 0;
 const core_bentley_1 = require("@itwin/core-bentley");
 const core_geometry_1 = require("@itwin/core-geometry");
 const core_common_1 = require("@itwin/core-common");
 const IModelApp_1 = require("../../IModelApp");
 const AuxChannelTable_1 = require("./AuxChannelTable");
+const SurfaceParams_1 = require("./SurfaceParams");
+const EdgeParams_1 = require("./EdgeParams");
 /**
  * Holds an array of indices into a VertexTable. Each index is a 24-bit unsigned integer.
  * The order of the indices specifies the order in which vertices are drawn.
@@ -42,6 +44,9 @@ class VertexIndices {
         bytes[byteIndex + 1] = (index & 0x0000ff00) >> 8;
         bytes[byteIndex + 2] = (index & 0x00ff0000) >> 16;
     }
+    setNthIndex(n, value) {
+        VertexIndices.encodeIndex(value, this.data, n * 3);
+    }
     decodeIndex(index) {
         (0, core_bentley_1.assert)(index < this.length);
         const byteIndex = index * 3;
@@ -69,7 +74,9 @@ function computeDimensions(nEntries, nRgbaPerEntry, nExtraRgba) {
         width += nRgbaPerEntry - remainder;
     }
     // Compute height
-    const height = Math.ceil(nRgba / width);
+    let height = Math.ceil(nRgba / width);
+    if (width * height < nRgba)
+        ++height;
     (0, core_bentley_1.assert)(height <= maxSize);
     (0, core_bentley_1.assert)(width <= maxSize);
     (0, core_bentley_1.assert)(width * height >= nRgba);
@@ -137,321 +144,6 @@ class VertexTable {
     }
 }
 exports.VertexTable = VertexTable;
-/** Describes point string geometry to be submitted to the rendering system.
- * @internal
- */
-class PointStringParams {
-    constructor(vertices, indices, weight) {
-        this.vertices = vertices;
-        this.indices = indices;
-        this.weight = weight;
-    }
-    static create(args) {
-        if (!args.flags.isDisjoint)
-            return undefined;
-        const vertices = VertexTable.createForPolylines(args);
-        if (undefined === vertices)
-            return undefined;
-        const polylines = args.polylines;
-        let vertIndices = polylines[0].vertIndices;
-        if (1 < polylines.length) {
-            // We used to assert this wouldn't happen - apparently it does...
-            vertIndices = [];
-            for (const polyline of polylines)
-                for (const vertIndex of polyline.vertIndices)
-                    vertIndices.push(vertIndex);
-        }
-        const vertexIndices = VertexIndices.fromArray(vertIndices);
-        (0, core_bentley_1.assert)(vertexIndices.length === vertIndices.length);
-        return new PointStringParams(vertices, vertexIndices, args.width);
-    }
-}
-exports.PointStringParams = PointStringParams;
-class PolylineVertex {
-    constructor() {
-        this.isSegmentStart = false;
-        this.isPolylineStartOrEnd = false;
-        this.vertexIndex = 0;
-        this.prevIndex = 0;
-        this.nextIndex = 0;
-    }
-    init(isSegmentStart, isPolylineStartOrEnd, vertexIndex, prevIndex, nextIndex) {
-        this.isSegmentStart = isSegmentStart;
-        this.isPolylineStartOrEnd = isPolylineStartOrEnd;
-        this.vertexIndex = vertexIndex;
-        this.prevIndex = prevIndex;
-        this.nextIndex = nextIndex;
-    }
-    computeParam(negatePerp, adjacentToJoint = false, joint = false, noDisplacement = false) {
-        if (joint)
-            return 12 /* kJointBase */;
-        let param;
-        if (noDisplacement)
-            param = 96 /* kNoneAdjustWeight */; // prevent getting tossed before width adjustment
-        else if (adjacentToJoint)
-            param = 9 /* kMiterInsideOnly */;
-        else
-            param = this.isPolylineStartOrEnd ? 3 /* kSquare */ : 6 /* kMiter */;
-        let adjust = 0;
-        if (negatePerp)
-            adjust = 24 /* kNegatePerp */;
-        if (!this.isSegmentStart)
-            adjust += 48 /* kNegateAlong */;
-        return param + adjust;
-    }
-}
-class PolylineTesselator {
-    constructor(polylines, points, doJointTriangles) {
-        this._numIndices = 0;
-        this._vertIndex = [];
-        this._prevIndex = [];
-        this._nextIndex = [];
-        this._nextParam = [];
-        this._position = [];
-        this._polylines = polylines;
-        this._points = points;
-        this._doJoints = doJointTriangles;
-    }
-    static fromPolyline(args) {
-        return new PolylineTesselator(args.polylines, args.points, wantJointTriangles(args.width, args.flags.is2d));
-    }
-    static fromMesh(args) {
-        if (undefined !== args.edges.polylines.lines && undefined !== args.points)
-            return new PolylineTesselator(args.edges.polylines.lines, args.points, wantJointTriangles(args.edges.width, args.is2d));
-        return undefined;
-    }
-    tesselate() {
-        for (const p of this._points.list)
-            this._position.push(p.unquantize(this._points.params));
-        this._tesselate();
-        const vertIndex = VertexIndices.fromArray(this._vertIndex);
-        const prevIndex = VertexIndices.fromArray(this._prevIndex);
-        const nextIndexAndParam = new Uint8Array(this._numIndices * 4);
-        for (let i = 0; i < this._numIndices; i++) {
-            const index = this._nextIndex[i];
-            const j = i * 4;
-            VertexIndices.encodeIndex(index, nextIndexAndParam, j);
-            nextIndexAndParam[j + 3] = this._nextParam[i] & 0x000000ff;
-        }
-        return {
-            indices: vertIndex,
-            prevIndices: prevIndex,
-            nextIndicesAndParams: nextIndexAndParam,
-        };
-    }
-    _tesselate() {
-        const v0 = new PolylineVertex(), v1 = new PolylineVertex();
-        const maxJointDot = -0.7;
-        for (const line of this._polylines) {
-            if (line.numIndices < 2)
-                continue;
-            const last = line.numIndices - 1;
-            const isClosed = line.vertIndices[0] === line.vertIndices[last];
-            for (let i = 0; i < last; ++i) {
-                const idx0 = line.vertIndices[i];
-                const idx1 = line.vertIndices[i + 1];
-                const isStart = (0 === i);
-                const isEnd = (last - 1 === i);
-                const prevIdx0 = isStart ? (isClosed ? line.vertIndices[last - 1] : idx0) : line.vertIndices[i - 1];
-                const nextIdx1 = isEnd ? (isClosed ? line.vertIndices[1] : idx1) : line.vertIndices[i + 2];
-                v0.init(true, isStart && !isClosed, idx0, prevIdx0, idx1);
-                v1.init(false, isEnd && !isClosed, idx1, nextIdx1, idx0);
-                const jointAt0 = this._doJoints && (isClosed || !isStart) && this._dotProduct(v0) > maxJointDot;
-                const jointAt1 = this._doJoints && (isClosed || !isEnd) && this._dotProduct(v1) > maxJointDot;
-                if (jointAt0 || jointAt1) {
-                    this._addVertex(v0, v0.computeParam(true, jointAt0, false, false));
-                    this._addVertex(v1, v1.computeParam(false, jointAt1, false, false));
-                    this._addVertex(v0, v0.computeParam(false, jointAt0, false, true));
-                    this._addVertex(v0, v0.computeParam(false, jointAt0, false, true));
-                    this._addVertex(v1, v1.computeParam(false, jointAt1, false, false));
-                    this._addVertex(v1, v1.computeParam(false, jointAt1, false, true));
-                    this._addVertex(v0, v0.computeParam(false, jointAt0, false, true));
-                    this._addVertex(v1, v1.computeParam(false, jointAt1, false, true));
-                    this._addVertex(v0, v0.computeParam(false, jointAt0, false, false));
-                    this._addVertex(v0, v0.computeParam(false, jointAt0, false, false));
-                    this._addVertex(v1, v1.computeParam(false, jointAt1, false, true));
-                    this._addVertex(v1, v1.computeParam(true, jointAt1, false, false));
-                    if (jointAt0)
-                        this.addJointTriangles(v0, v0.computeParam(false, true, false, true), v0);
-                    if (jointAt1)
-                        this.addJointTriangles(v1, v1.computeParam(false, true, false, true), v1);
-                }
-                else {
-                    this._addVertex(v0, v0.computeParam(true));
-                    this._addVertex(v1, v1.computeParam(false));
-                    this._addVertex(v0, v0.computeParam(false));
-                    this._addVertex(v0, v0.computeParam(false));
-                    this._addVertex(v1, v1.computeParam(false));
-                    this._addVertex(v1, v1.computeParam(true));
-                }
-            }
-        }
-    }
-    addJointTriangles(v0, p0, v1) {
-        const param = v1.computeParam(false, false, true);
-        for (let i = 0; i < 3; i++) {
-            this._addVertex(v0, p0);
-            this._addVertex(v1, param + i + 1);
-            this._addVertex(v1, param + i);
-        }
-    }
-    _dotProduct(v) {
-        const pos = this._position[v.vertexIndex];
-        const prevDir = core_geometry_1.Vector3d.createStartEnd(this._position[v.prevIndex], pos);
-        const nextDir = core_geometry_1.Vector3d.createStartEnd(this._position[v.nextIndex], pos);
-        return prevDir.dotProduct(nextDir);
-    }
-    _addVertex(vertex, param) {
-        this._vertIndex[this._numIndices] = vertex.vertexIndex;
-        this._prevIndex[this._numIndices] = vertex.prevIndex;
-        this._nextIndex[this._numIndices] = vertex.nextIndex;
-        this._nextParam[this._numIndices] = param;
-        this._numIndices++;
-    }
-}
-/** Strictly for tests. @internal */
-function tesselatePolyline(polylines, points, doJointTriangles) {
-    const tesselator = new PolylineTesselator(polylines, points, doJointTriangles);
-    return tesselator.tesselate();
-}
-exports.tesselatePolyline = tesselatePolyline;
-/** @internal */
-var SurfaceType;
-(function (SurfaceType) {
-    SurfaceType[SurfaceType["Unlit"] = 0] = "Unlit";
-    SurfaceType[SurfaceType["Lit"] = 1] = "Lit";
-    SurfaceType[SurfaceType["Textured"] = 2] = "Textured";
-    SurfaceType[SurfaceType["TexturedLit"] = 3] = "TexturedLit";
-    SurfaceType[SurfaceType["VolumeClassifier"] = 4] = "VolumeClassifier";
-})(SurfaceType = exports.SurfaceType || (exports.SurfaceType = {}));
-/** @internal */
-function isValidSurfaceType(value) {
-    switch (value) {
-        case SurfaceType.Unlit:
-        case SurfaceType.Lit:
-        case SurfaceType.Textured:
-        case SurfaceType.TexturedLit:
-        case SurfaceType.VolumeClassifier:
-            return true;
-        default:
-            return false;
-    }
-}
-exports.isValidSurfaceType = isValidSurfaceType;
-/** @internal */
-function createSurfaceMaterial(source) {
-    if (undefined === source)
-        return undefined;
-    else
-        return { isAtlas: false, material: source };
-}
-exports.createSurfaceMaterial = createSurfaceMaterial;
-function convertPolylinesAndEdges(polylines, edges) {
-    let numIndices = undefined !== edges ? edges.length : 0;
-    if (undefined !== polylines)
-        for (const pd of polylines)
-            numIndices += (pd.vertIndices.length - 1);
-    if (0 === numIndices)
-        return undefined;
-    numIndices *= 6;
-    const indexBytes = new Uint8Array(numIndices * 3);
-    const endPointAndQuadIndexBytes = new Uint8Array(numIndices * 4);
-    let ndx = 0;
-    let ndx2 = 0;
-    const addPoint = (p0, p1, quadIndex) => {
-        VertexIndices.encodeIndex(p0, indexBytes, ndx);
-        ndx += 3;
-        VertexIndices.encodeIndex(p1, endPointAndQuadIndexBytes, ndx2);
-        endPointAndQuadIndexBytes[ndx2 + 3] = quadIndex;
-        ndx2 += 4;
-    };
-    if (undefined !== polylines) {
-        for (const pd of polylines) {
-            const num = pd.vertIndices.length - 1;
-            for (let i = 0; i < num; ++i) {
-                let p0 = pd.vertIndices[i];
-                let p1 = pd.vertIndices[i + 1];
-                if (p1 < p0) { // swap so that lower index is first.
-                    p0 = p1;
-                    p1 = pd.vertIndices[i];
-                }
-                addPoint(p0, p1, 0);
-                addPoint(p1, p0, 2);
-                addPoint(p0, p1, 1);
-                addPoint(p0, p1, 1);
-                addPoint(p1, p0, 2);
-                addPoint(p1, p0, 3);
-            }
-        }
-    }
-    if (undefined !== edges) {
-        for (const meshEdge of edges) {
-            const p0 = meshEdge.indices[0];
-            const p1 = meshEdge.indices[1];
-            addPoint(p0, p1, 0);
-            addPoint(p1, p0, 2);
-            addPoint(p0, p1, 1);
-            addPoint(p0, p1, 1);
-            addPoint(p1, p0, 2);
-            addPoint(p1, p0, 3);
-        }
-    }
-    return {
-        indices: new VertexIndices(indexBytes),
-        endPointAndQuadIndices: endPointAndQuadIndexBytes,
-    };
-}
-function convertSilhouettes(edges, normalPairs) {
-    const base = convertPolylinesAndEdges(undefined, edges);
-    if (undefined === base)
-        return undefined;
-    const normalPairBytes = new Uint8Array(normalPairs.length * 6 * 4);
-    const normalPair16 = new Uint16Array(normalPairBytes.buffer);
-    let ndx = 0;
-    for (const pair of normalPairs) {
-        for (let i = 0; i < 6; i++) {
-            normalPair16[ndx++] = pair.first.value;
-            normalPair16[ndx++] = pair.second.value;
-        }
-    }
-    return {
-        indices: base.indices,
-        endPointAndQuadIndices: base.endPointAndQuadIndices,
-        normalPairs: normalPairBytes,
-    };
-}
-function wantJointTriangles(weight, is2d) {
-    // Joints are incredibly expensive. In 3d, only generate them if the line is sufficiently wide for them to be noticeable.
-    const jointWidthThreshold = 3;
-    return is2d || weight >= jointWidthThreshold;
-}
-function convertEdges(meshArgs) {
-    const args = meshArgs.edges;
-    if (undefined === args)
-        return undefined;
-    let polylines;
-    let segments;
-    if (wantJointTriangles(args.width, meshArgs.is2d)) {
-        segments = convertPolylinesAndEdges(args.polylines.lines, args.edges.edges);
-    }
-    else {
-        segments = convertPolylinesAndEdges(undefined, args.edges.edges);
-        const tesselator = PolylineTesselator.fromMesh(meshArgs);
-        if (undefined !== tesselator)
-            polylines = tesselator.tesselate();
-    }
-    // ###TODO: why the heck are the edges and normals of SilhouetteEdgeArgs potentially undefined???
-    const silhouettes = undefined !== args.silhouettes.edges && undefined !== args.silhouettes.normals ? convertSilhouettes(args.silhouettes.edges, args.silhouettes.normals) : undefined;
-    if (undefined === segments && undefined === silhouettes && undefined === polylines)
-        return undefined;
-    return {
-        weight: args.width,
-        linePixels: args.linePixels,
-        segments,
-        silhouettes,
-        polylines,
-    };
-}
 /**
  * Describes mesh geometry to be submitted to the rendering system.
  * A mesh consists of a surface and its edges, which may include any combination of silhouettes, polylines, and single segments.
@@ -478,42 +170,14 @@ class MeshParams {
             hasBakedLighting: args.hasBakedLighting,
             hasFixedNormals: args.hasFixedNormals,
             textureMapping: undefined !== args.texture ? { texture: args.texture, alwaysDisplayed: false } : undefined,
-            material: createSurfaceMaterial(args.material),
+            material: (0, SurfaceParams_1.createSurfaceMaterial)(args.material),
         };
         const channels = undefined !== args.auxChannels ? AuxChannelTable_1.AuxChannelTable.fromChannels(args.auxChannels, vertices.numVertices) : undefined;
-        const edges = convertEdges(args);
+        const edges = EdgeParams_1.EdgeParams.fromMeshArgs(args);
         return new MeshParams(vertices, surface, edges, args.isPlanar, channels);
     }
 }
 exports.MeshParams = MeshParams;
-/**
- * Describes a set of tesselated polylines.
- * Each segment of each polyline is triangulated into a quad. Additional triangles may be inserted
- * between segments to enable rounded corners.
- */
-class PolylineParams {
-    /** Directly construct a PolylineParams. The PolylineParams takes ownership of all input data. */
-    constructor(vertices, polyline, weight, linePixels, isPlanar, type = core_common_1.PolylineTypeFlags.Normal) {
-        this.vertices = vertices;
-        this.polyline = polyline;
-        this.isPlanar = isPlanar;
-        this.weight = weight;
-        this.linePixels = linePixels;
-        this.type = type;
-    }
-    /** Construct from an PolylineArgs. */
-    static create(args) {
-        (0, core_bentley_1.assert)(!args.flags.isDisjoint);
-        const vertices = VertexTable.createForPolylines(args);
-        if (undefined === vertices)
-            return undefined;
-        const tesselator = PolylineTesselator.fromPolyline(args);
-        if (undefined === tesselator)
-            return undefined;
-        return new PolylineParams(vertices, tesselator.tesselate(), args.width, args.linePixels, args.flags.isPlanar, args.flags.type);
-    }
-}
-exports.PolylineParams = PolylineParams;
 /** Builds a VertexTable from some data type supplying the vertex data. */
 class VertexTableBuilder {
     constructor() {
@@ -626,7 +290,7 @@ class MeshBuilder extends SimpleBuilder {
     }
     static create(args) {
         if (args.isVolumeClassifier)
-            return new MeshBuilder(args, SurfaceType.VolumeClassifier);
+            return new MeshBuilder(args, SurfaceParams_1.SurfaceType.VolumeClassifier);
         const isLit = undefined !== args.normals && 0 < args.normals.length;
         const isTextured = undefined !== args.texture;
         let uvParams;
@@ -642,7 +306,7 @@ class MeshBuilder extends SimpleBuilder {
         if (isLit)
             return isTextured ? new TexturedLitMeshBuilder(args, uvParams) : new LitMeshBuilder(args);
         else
-            return isTextured ? new TexturedMeshBuilder(args, uvParams) : new MeshBuilder(args, SurfaceType.Unlit);
+            return isTextured ? new TexturedMeshBuilder(args, uvParams) : new MeshBuilder(args, SurfaceParams_1.SurfaceType.Unlit);
     }
 }
 /** Supplies vertex data from a MeshArgs where each vertex consists of 16 bytes.
@@ -650,7 +314,7 @@ class MeshBuilder extends SimpleBuilder {
  * The color index is left uninitialized as it is unused.
  */
 class TexturedMeshBuilder extends MeshBuilder {
-    constructor(args, qparams, type = SurfaceType.Textured) {
+    constructor(args, qparams, type = SurfaceParams_1.SurfaceType.Textured) {
         super(args, type);
         this._qpoint = new core_common_1.QPoint2d();
         this._qparams = qparams;
@@ -674,7 +338,7 @@ class TexturedMeshBuilder extends MeshBuilder {
 /** As with TexturedMeshBuilder, but the color index is replaced with the oct-encoded normal value. */
 class TexturedLitMeshBuilder extends TexturedMeshBuilder {
     constructor(args, qparams) {
-        super(args, qparams, SurfaceType.TexturedLit);
+        super(args, qparams, SurfaceParams_1.SurfaceType.TexturedLit);
         (0, core_bentley_1.assert)(undefined !== args.normals);
     }
     appendNormal(vertIndex) { this.append16(this.args.normals[vertIndex].value); }
@@ -682,7 +346,7 @@ class TexturedLitMeshBuilder extends TexturedMeshBuilder {
 /** 16 bytes. The last 2 bytes are unused; the 2 immediately preceding it hold the oct-encoded normal value. */
 class LitMeshBuilder extends MeshBuilder {
     constructor(args) {
-        super(args, SurfaceType.Lit);
+        super(args, SurfaceParams_1.SurfaceType.Lit);
         (0, core_bentley_1.assert)(undefined !== args.normals);
     }
     get numRgbaPerVertex() { return 4; }