@itwin/core-frontend 4.1.0-dev.7 → 4.1.0-dev.70

package/lib/cjs/{imdl/ImdlModel.js → common/render/primitives/MeshParams.js}

@@ -4,7 +4,7 @@
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
 /** @packageDocumentation
- * @module Tiles
+ * @module Rendering
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ImdlModel.js.map
+//# sourceMappingURL=MeshParams.js.map

package/lib/cjs/common/render/primitives/MeshParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeshParams.js","sourceRoot":"","sources":["../../../../../src/common/render/primitives/MeshParams.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Rendering\r\n */\r\n\r\nimport { AuxChannelTable } from \"./AuxChannelTable\";\r\nimport { VertexTable } from \"./VertexTable\";\r\nimport { SurfaceParams } from \"./SurfaceParams\";\r\nimport { EdgeParams } from \"./EdgeParams\";\r\n\r\n/** Describes mesh geometry to be submitted to the rendering system.\r\n * A mesh consists of a surface and its edges, which may include any combination of silhouettes, polylines, and single segments.\r\n * The surface and edges all refer to the same vertex table.\r\n * @internal\r\n */\r\nexport interface MeshParams {\r\n  vertices: VertexTable;\r\n  surface: SurfaceParams;\r\n  edges?: EdgeParams;\r\n  isPlanar: boolean;\r\n  auxChannels?: AuxChannelTable;\r\n}\r\n"]}

package/lib/cjs/common/render/primitives/MeshPrimitive.d.ts

@@ -0,0 +1,29 @@
+/** @packageDocumentation
+ * @module Rendering
+ */
+import { Point3d, Range3d } from "@itwin/core-geometry";
+import { QPoint3dList } from "@itwin/core-common";
+/** @internal */
+export declare enum MeshPrimitiveType {
+    Mesh = 0,
+    Polyline = 1,
+    Point = 2
+}
+/** A Point3d[] with an [[add]] method used to enable compatibility with the [[MeshPointList]] union type.
+ * It is provided a range to contain all of the points. Each point added to the list is transformed to be relative to
+ * the center of that range.
+ * In the finished graphic, a transform is applied to transform back from the range's center.
+ * @internal
+ */
+export interface Point3dList extends Array<Point3d> {
+    /** Identical to `push`, except it returns `void` instead of `number`; compatible with [QPoint3dList.add]($common). */
+    add(point: Point3d): void;
+    /** The range containing all of the points to be contained in the list, computed in advance. */
+    range: Range3d;
+}
+/** The list of points associated with a [[Mesh]].
+ * @see [[Mesh.Props.quantizePositions]] to specify whether points should be quantized or not.
+ * @internal
+ */
+export type MeshPointList = Point3dList | QPoint3dList;
+//# sourceMappingURL=MeshPrimitive.d.ts.map

package/lib/cjs/common/render/primitives/MeshPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeshPrimitive.d.ts","sourceRoot":"","sources":["../../../../../src/common/render/primitives/MeshPrimitive.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,gBAAgB;AAChB,oBAAY,iBAAiB;IAC3B,IAAI,IAAA;IACJ,QAAQ,IAAA;IACR,KAAK,IAAA;CACN;AAED;;;;;GAKG;AACH,MAAM,WAAW,WAAY,SAAQ,KAAK,CAAC,OAAO,CAAC;IACjD,sHAAsH;IACtH,GAAG,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,+FAA+F;IAC/F,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,YAAY,CAAC"}

package/lib/cjs/common/render/primitives/MeshPrimitive.js

@@ -0,0 +1,18 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Rendering
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshPrimitiveType = void 0;
+/** @internal */
+var MeshPrimitiveType;
+(function (MeshPrimitiveType) {
+    MeshPrimitiveType[MeshPrimitiveType["Mesh"] = 0] = "Mesh";
+    MeshPrimitiveType[MeshPrimitiveType["Polyline"] = 1] = "Polyline";
+    MeshPrimitiveType[MeshPrimitiveType["Point"] = 2] = "Point";
+})(MeshPrimitiveType = exports.MeshPrimitiveType || (exports.MeshPrimitiveType = {}));
+//# sourceMappingURL=MeshPrimitive.js.map

package/lib/cjs/common/render/primitives/MeshPrimitive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeshPrimitive.js","sourceRoot":"","sources":["../../../../../src/common/render/primitives/MeshPrimitive.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAKH,gBAAgB;AAChB,IAAY,iBAIX;AAJD,WAAY,iBAAiB;IAC3B,yDAAI,CAAA;IACJ,iEAAQ,CAAA;IACR,2DAAK,CAAA;AACP,CAAC,EAJW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAI5B","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Rendering\r\n */\r\n\r\nimport { Point3d, Range3d } from \"@itwin/core-geometry\";\r\nimport { QPoint3dList } from \"@itwin/core-common\";\r\n\r\n/** @internal */\r\nexport enum MeshPrimitiveType {\r\n  Mesh,\r\n  Polyline,\r\n  Point,\r\n}\r\n\r\n/** A Point3d[] with an [[add]] method used to enable compatibility with the [[MeshPointList]] union type.\r\n * It is provided a range to contain all of the points. Each point added to the list is transformed to be relative to\r\n * the center of that range.\r\n * In the finished graphic, a transform is applied to transform back from the range's center.\r\n * @internal\r\n */\r\nexport interface Point3dList extends Array<Point3d> {\r\n  /** Identical to `push`, except it returns `void` instead of `number`; compatible with [QPoint3dList.add]($common). */\r\n  add(point: Point3d): void;\r\n  /** The range containing all of the points to be contained in the list, computed in advance. */\r\n  range: Range3d;\r\n}\r\n\r\n/** The list of points associated with a [[Mesh]].\r\n * @see [[Mesh.Props.quantizePositions]] to specify whether points should be quantized or not.\r\n * @internal\r\n */\r\nexport type MeshPointList = Point3dList | QPoint3dList;\r\n"]}

package/lib/cjs/common/render/primitives/PointStringParams.d.ts

@@ -0,0 +1,14 @@
+/** @packageDocumentation
+ * @module Rendering
+ */
+import { VertexIndices } from "./VertexIndices";
+import { VertexTable } from "./VertexTable";
+/** Describes point string geometry to be submitted to the rendering system.
+ * @internal
+ */
+export interface PointStringParams {
+    vertices: VertexTable;
+    indices: VertexIndices;
+    weight: number;
+}
+//# sourceMappingURL=PointStringParams.d.ts.map

package/lib/cjs/common/render/primitives/PointStringParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PointStringParams.d.ts","sourceRoot":"","sources":["../../../../../src/common/render/primitives/PointStringParams.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB"}

package/lib/cjs/common/render/primitives/PointStringParams.js

@@ -0,0 +1,10 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Rendering
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PointStringParams.js.map

package/lib/cjs/common/render/primitives/PointStringParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PointStringParams.js","sourceRoot":"","sources":["../../../../../src/common/render/primitives/PointStringParams.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Rendering\r\n */\r\n\r\nimport { VertexIndices } from \"./VertexIndices\";\r\nimport { VertexTable } from \"./VertexTable\";\r\n\r\n/** Describes point string geometry to be submitted to the rendering system.\r\n * @internal\r\n */\r\nexport interface PointStringParams {\r\n  vertices: VertexTable;\r\n  indices: VertexIndices;\r\n  weight: number;\r\n}\r\n"]}

package/lib/cjs/common/render/primitives/PolylineParams.d.ts

@@ -0,0 +1,29 @@
+/** @packageDocumentation
+ * @module Rendering
+ */
+import { LinePixels, PolylineTypeFlags } from "@itwin/core-common";
+import { VertexIndices } from "./VertexIndices";
+import { VertexTable } from "./VertexTable";
+/** Represents a tesselated polyline.
+ * Given a polyline as a line string, each segment of the line string is triangulated into a quad.
+ * Based on the angle between two segments, additional joint triangles may be inserted in between to enable smoothly-rounded corners.
+ * @internal
+ */
+export interface TesselatedPolyline {
+    /** 24-bit index of each vertex. */
+    indices: VertexIndices;
+    /** 24-bit index of the previous vertex in the polyline. */
+    prevIndices: VertexIndices;
+    /** 24-bit index of the next vertex in the polyline, plus 8-bit parameter describing the semantics of this vertex. */
+    nextIndicesAndParams: Uint8Array;
+}
+/** @internal */
+export interface PolylineParams {
+    vertices: VertexTable;
+    polyline: TesselatedPolyline;
+    isPlanar: boolean;
+    type: PolylineTypeFlags;
+    weight: number;
+    linePixels: LinePixels;
+}
+//# sourceMappingURL=PolylineParams.d.ts.map

package/lib/cjs/common/render/primitives/PolylineParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PolylineParams.d.ts","sourceRoot":"","sources":["../../../../../src/common/render/primitives/PolylineParams.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,mCAAmC;IACnC,OAAO,EAAE,aAAa,CAAC;IACvB,2DAA2D;IAC3D,WAAW,EAAE,aAAa,CAAC;IAC3B,qHAAqH;IACrH,oBAAoB,EAAE,UAAU,CAAC;CAClC;AAED,gBAAgB;AAChB,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,WAAW,CAAC;IACtB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,iBAAiB,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,UAAU,CAAC;CACxB"}

package/lib/cjs/common/render/primitives/PolylineParams.js

@@ -0,0 +1,10 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Rendering
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PolylineParams.js.map

package/lib/cjs/common/render/primitives/PolylineParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PolylineParams.js","sourceRoot":"","sources":["../../../../../src/common/render/primitives/PolylineParams.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Rendering\r\n */\r\n\r\nimport { LinePixels, PolylineTypeFlags } from \"@itwin/core-common\";\r\nimport { VertexIndices } from \"./VertexIndices\";\r\nimport { VertexTable } from \"./VertexTable\";\r\n\r\n/** Represents a tesselated polyline.\r\n * Given a polyline as a line string, each segment of the line string is triangulated into a quad.\r\n * Based on the angle between two segments, additional joint triangles may be inserted in between to enable smoothly-rounded corners.\r\n * @internal\r\n */\r\nexport interface TesselatedPolyline {\r\n  /** 24-bit index of each vertex. */\r\n  indices: VertexIndices;\r\n  /** 24-bit index of the previous vertex in the polyline. */\r\n  prevIndices: VertexIndices;\r\n  /** 24-bit index of the next vertex in the polyline, plus 8-bit parameter describing the semantics of this vertex. */\r\n  nextIndicesAndParams: Uint8Array;\r\n}\r\n\r\n/** @internal */\r\nexport interface PolylineParams {\r\n  vertices: VertexTable;\r\n  polyline: TesselatedPolyline;\r\n  isPlanar: boolean;\r\n  type: PolylineTypeFlags;\r\n  weight: number;\r\n  linePixels: LinePixels;\r\n}\r\n"]}

package/lib/{esm → cjs/common}/render/primitives/SurfaceParams.d.ts

@@ -2,7 +2,7 @@
  * @module Rendering
  */
 import { FillFlags, RenderMaterial, RenderTexture } from "@itwin/core-common";
-import { VertexIndices } from "./VertexTable";
+import { VertexIndices } from "./VertexIndices";
 /** @internal */
 export declare enum SurfaceType {
     Unlit = 0,

package/lib/cjs/common/render/primitives/SurfaceParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SurfaceParams.d.ts","sourceRoot":"","sources":["../../../../../src/common/render/primitives/SurfaceParams.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,gBAAgB;AAChB,oBAAY,WAAW;IACrB,KAAK,IAAA;IACL,GAAG,IAAA;IACH,QAAQ,IAAA;IACR,WAAW,IAAA;IACX,gBAAgB,IAAA;CACjB;AAED,gBAAgB;AAChB,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAWzD;AAED,gBAAgB;AAChB,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;CACnC;AAED,gBAAgB;AAChB,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IAEvB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAElC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IAEjC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,gBAAgB;AAChB,MAAM,MAAM,eAAe,GAAG,qBAAqB,GAAG,oBAAoB,CAAC;AAE3E,gBAAgB;AAChB,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,GAAG,eAAe,GAAG,SAAS,CAKrG;AAED,gBAAgB;AAChB,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,cAAc,CAAC,EAAE;QACxB,OAAO,EAAE,aAAa,CAAC;QACvB,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;IACF,QAAQ,CAAC,QAAQ,CAAC,EAAE,eAAe,CAAC;CACrC"}

package/lib/cjs/common/render/primitives/SurfaceParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SurfaceParams.js","sourceRoot":"","sources":["../../../../../src/common/render/primitives/SurfaceParams.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAKH,gBAAgB;AAChB,IAAY,WAMX;AAND,WAAY,WAAW;IACrB,+CAAK,CAAA;IACL,2CAAG,CAAA;IACH,qDAAQ,CAAA;IACR,2DAAW,CAAA;IACX,qEAAgB,CAAA;AAClB,CAAC,EANW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAMtB;AAED,gBAAgB;AAChB,SAAgB,kBAAkB,CAAC,KAAa;IAC9C,QAAQ,KAAK,EAAE;QACb,KAAK,WAAW,CAAC,KAAK,CAAC;QACvB,KAAK,WAAW,CAAC,GAAG,CAAC;QACrB,KAAK,WAAW,CAAC,QAAQ,CAAC;QAC1B,KAAK,WAAW,CAAC,WAAW,CAAC;QAC7B,KAAK,WAAW,CAAC,gBAAgB;YAC/B,OAAO,IAAI,CAAC;QACd;YACE,OAAO,KAAK,CAAC;KAChB;AACH,CAAC;AAXD,gDAWC;AAuBD,gBAAgB;AAChB,SAAgB,qBAAqB,CAAC,MAAkC;IACtE,IAAI,SAAS,KAAK,MAAM;QACtB,OAAO,SAAS,CAAC;;QAEjB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;AAChD,CAAC;AALD,sDAKC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Rendering\r\n */\r\n\r\nimport { FillFlags, RenderMaterial, RenderTexture } from \"@itwin/core-common\";\r\nimport { VertexIndices } from \"./VertexIndices\";\r\n\r\n/** @internal */\r\nexport enum SurfaceType {\r\n  Unlit,\r\n  Lit,\r\n  Textured,\r\n  TexturedLit,\r\n  VolumeClassifier,\r\n}\r\n\r\n/** @internal */\r\nexport function isValidSurfaceType(value: number): boolean {\r\n  switch (value) {\r\n    case SurfaceType.Unlit:\r\n    case SurfaceType.Lit:\r\n    case SurfaceType.Textured:\r\n    case SurfaceType.TexturedLit:\r\n    case SurfaceType.VolumeClassifier:\r\n      return true;\r\n    default:\r\n      return false;\r\n  }\r\n}\r\n\r\n/** @internal */\r\nexport interface SurfaceRenderMaterial {\r\n  readonly isAtlas: false;\r\n  readonly material: RenderMaterial;\r\n}\r\n\r\n/** @internal */\r\nexport interface SurfaceMaterialAtlas {\r\n  readonly isAtlas: true;\r\n  // Overrides surface alpha to be translucent. Implies `overridesAlpha`.\r\n  readonly hasTranslucency: boolean;\r\n  // Overrides surface alpha to be opaque or translucent.\r\n  readonly overridesAlpha: boolean;\r\n  // offset past the END of the vertex data; equivalently, number of 32-bit colors in color table preceding material atlas.\r\n  readonly vertexTableOffset: number;\r\n  readonly numMaterials: number;\r\n}\r\n\r\n/** @internal */\r\nexport type SurfaceMaterial = SurfaceRenderMaterial | SurfaceMaterialAtlas;\r\n\r\n/** @internal */\r\nexport function createSurfaceMaterial(source: RenderMaterial | undefined): SurfaceMaterial | undefined {\r\n  if (undefined === source)\r\n    return undefined;\r\n  else\r\n    return { isAtlas: false, material: source };\r\n}\r\n\r\n/** @internal */\r\nexport interface SurfaceParams {\r\n  readonly type: SurfaceType;\r\n  readonly indices: VertexIndices;\r\n  readonly fillFlags: FillFlags;\r\n  readonly hasBakedLighting: boolean;\r\n  readonly textureMapping?: {\r\n    texture: RenderTexture;\r\n    alwaysDisplayed: boolean;\r\n  };\r\n  readonly material?: SurfaceMaterial;\r\n}\r\n"]}

package/lib/cjs/common/render/primitives/VertexIndices.d.ts

@@ -0,0 +1,26 @@
+/** @packageDocumentation
+ * @module Rendering
+ */
+/**
+ * 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.
+ * @internal
+ */
+export declare class VertexIndices implements Iterable<number> {
+    readonly data: Uint8Array;
+    /**
+     * Directly construct from an array of bytes in which each index occupies 3 contiguous bytes.
+     * The length of the array must be a multiple of 3. This object takes ownership of the array.
+     */
+    constructor(data: Uint8Array);
+    /** Get the number of 24-bit indices. */
+    get length(): number;
+    /** Convert an array of 24-bit unsigned integer values into a VertexIndices object. */
+    static fromArray(indices: number[]): VertexIndices;
+    static encodeIndex(index: number, bytes: Uint8Array, byteIndex: number): void;
+    setNthIndex(n: number, value: number): void;
+    decodeIndex(index: number): number;
+    decodeIndices(): number[];
+    [Symbol.iterator](): Generator<number, void, unknown>;
+}
+//# sourceMappingURL=VertexIndices.d.ts.map

package/lib/cjs/common/render/primitives/VertexIndices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VertexIndices.d.ts","sourceRoot":"","sources":["../../../../../src/common/render/primitives/VertexIndices.ts"],"names":[],"mappings":"AAIA;;GAEG;AAIH;;;;GAIG;AACH,qBAAa,aAAc,YAAW,QAAQ,CAAC,MAAM,CAAC;IACpD,SAAgB,IAAI,EAAE,UAAU,CAAC;IAEjC;;;OAGG;gBACgB,IAAI,EAAE,UAAU;IAKnC,wCAAwC;IACxC,IAAW,MAAM,IAAI,MAAM,CAAiC;IAE5D,sFAAsF;WACxE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,aAAa;WAQ3C,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAO7E,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAI3C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAMlC,aAAa,IAAI,MAAM,EAAE;IAQzB,CAAC,MAAM,CAAC,QAAQ,CAAC;CAQzB"}

package/lib/cjs/common/render/primitives/VertexIndices.js

@@ -0,0 +1,64 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Rendering
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VertexIndices = void 0;
+const core_bentley_1 = require("@itwin/core-bentley");
+/**
+ * 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.
+ * @internal
+ */
+class VertexIndices {
+    /**
+     * Directly construct from an array of bytes in which each index occupies 3 contiguous bytes.
+     * The length of the array must be a multiple of 3. This object takes ownership of the array.
+     */
+    constructor(data) {
+        this.data = data;
+        (0, core_bentley_1.assert)(0 === this.data.length % 3);
+    }
+    /** Get the number of 24-bit indices. */
+    get length() { return this.data.length / 3; }
+    /** Convert an array of 24-bit unsigned integer values into a VertexIndices object. */
+    static fromArray(indices) {
+        const bytes = new Uint8Array(indices.length * 3);
+        for (let i = 0; i < indices.length; i++)
+            this.encodeIndex(indices[i], bytes, i * 3);
+        return new VertexIndices(bytes);
+    }
+    static encodeIndex(index, bytes, byteIndex) {
+        (0, core_bentley_1.assert)(byteIndex + 2 < bytes.length);
+        bytes[byteIndex + 0] = index & 0x000000ff;
+        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;
+        return this.data[byteIndex] | (this.data[byteIndex + 1] << 8) | (this.data[byteIndex + 2] << 16);
+    }
+    decodeIndices() {
+        const indices = [];
+        for (let i = 0; i < this.length; i++)
+            indices.push(this.decodeIndex(i));
+        return indices;
+    }
+    [Symbol.iterator]() {
+        function* iterator(indices) {
+            for (let i = 0; i < indices.length; i++)
+                yield indices.decodeIndex(i);
+        }
+        return iterator(this);
+    }
+}
+exports.VertexIndices = VertexIndices;
+//# sourceMappingURL=VertexIndices.js.map

package/lib/cjs/common/render/primitives/VertexIndices.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VertexIndices.js","sourceRoot":"","sources":["../../../../../src/common/render/primitives/VertexIndices.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,sDAA6C;AAE7C;;;;GAIG;AACH,MAAa,aAAa;IAGxB;;;OAGG;IACH,YAAmB,IAAgB;QACjC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAA,qBAAM,EAAC,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACrC,CAAC;IAED,wCAAwC;IACxC,IAAW,MAAM,KAAa,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;IAE5D,sFAAsF;IAC/E,MAAM,CAAC,SAAS,CAAC,OAAiB;QACvC,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE;YACrC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QAE7C,OAAO,IAAI,aAAa,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAEM,MAAM,CAAC,WAAW,CAAC,KAAa,EAAE,KAAiB,EAAE,SAAiB;QAC3E,IAAA,qBAAM,EAAC,SAAS,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;QACrC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,UAAU,CAAC;QAC1C,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;QACjD,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC;IACpD,CAAC;IAEM,WAAW,CAAC,CAAS,EAAE,KAAa;QACzC,aAAa,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACrD,CAAC;IAEM,WAAW,CAAC,KAAa;QAC9B,IAAA,qBAAM,EAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QAC5B,MAAM,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;QAC5B,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IACnG,CAAC;IAEM,aAAa;QAClB,MAAM,OAAO,GAAG,EAAE,CAAC;QACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE;YAClC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QAEpC,OAAO,OAAO,CAAC;IACjB,CAAC;IAEM,CAAC,MAAM,CAAC,QAAQ,CAAC;QACtB,QAAS,CAAC,CAAC,QAAQ,CAAC,OAAsB;YACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE;gBACrC,MAAM,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACjC,CAAC;QAED,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;CACF;AAzDD,sCAyDC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Rendering\r\n */\r\n\r\nimport { assert } from \"@itwin/core-bentley\";\r\n\r\n/**\r\n * Holds an array of indices into a VertexTable. Each index is a 24-bit unsigned integer.\r\n * The order of the indices specifies the order in which vertices are drawn.\r\n * @internal\r\n */\r\nexport class VertexIndices implements Iterable<number> {\r\n  public readonly data: Uint8Array;\r\n\r\n  /**\r\n   * Directly construct from an array of bytes in which each index occupies 3 contiguous bytes.\r\n   * The length of the array must be a multiple of 3. This object takes ownership of the array.\r\n   */\r\n  public constructor(data: Uint8Array) {\r\n    this.data = data;\r\n    assert(0 === this.data.length % 3);\r\n  }\r\n\r\n  /** Get the number of 24-bit indices. */\r\n  public get length(): number { return this.data.length / 3; }\r\n\r\n  /** Convert an array of 24-bit unsigned integer values into a VertexIndices object. */\r\n  public static fromArray(indices: number[]): VertexIndices {\r\n    const bytes = new Uint8Array(indices.length * 3);\r\n    for (let i = 0; i < indices.length; i++)\r\n      this.encodeIndex(indices[i], bytes, i * 3);\r\n\r\n    return new VertexIndices(bytes);\r\n  }\r\n\r\n  public static encodeIndex(index: number, bytes: Uint8Array, byteIndex: number): void {\r\n    assert(byteIndex + 2 < bytes.length);\r\n    bytes[byteIndex + 0] = index & 0x000000ff;\r\n    bytes[byteIndex + 1] = (index & 0x0000ff00) >> 8;\r\n    bytes[byteIndex + 2] = (index & 0x00ff0000) >> 16;\r\n  }\r\n\r\n  public setNthIndex(n: number, value: number): void {\r\n    VertexIndices.encodeIndex(value, this.data, n * 3);\r\n  }\r\n\r\n  public decodeIndex(index: number): number {\r\n    assert(index < this.length);\r\n    const byteIndex = index * 3;\r\n    return this.data[byteIndex] | (this.data[byteIndex + 1] << 8) | (this.data[byteIndex + 2] << 16);\r\n  }\r\n\r\n  public decodeIndices(): number[] {\r\n    const indices = [];\r\n    for (let i = 0; i < this.length; i++)\r\n      indices.push(this.decodeIndex(i));\r\n\r\n    return indices;\r\n  }\r\n\r\n  public [Symbol.iterator]() {\r\n    function * iterator(indices: VertexIndices) {\r\n      for (let i = 0; i < indices.length; i++)\r\n        yield indices.decodeIndex(i);\r\n    }\r\n\r\n    return iterator(this);\r\n  }\r\n}\r\n"]}

package/lib/cjs/common/render/primitives/VertexTable.d.ts

@@ -0,0 +1,45 @@
+/** @packageDocumentation
+ * @module Rendering
+ */
+import { ColorDef, FeatureIndexType, QParams2d, QParams3d } from "@itwin/core-common";
+/** Describes a VertexTable.
+ * @internal
+ */
+export interface VertexTable {
+    /** The rectangular array of vertex data, of size width*height*numRgbaPerVertex bytes. */
+    readonly data: Uint8Array;
+    /** If true, positions are not quantized but instead stored as 32-bit floats.
+     * [[qparams]] will still be defined; it can be used to derive the range of positions in the table.
+     */
+    readonly usesUnquantizedPositions?: boolean;
+    /** Quantization parameters for the vertex positions encoded into the array, if the positions are quantized;
+     * and for deriving the range of positions in the table, whether quantized or not.
+     */
+    readonly qparams: QParams3d;
+    /** The number of 4-byte 'RGBA' values in each row of the array. Must be divisible by numRgbaPerVertex. */
+    readonly width: number;
+    /** The number of rows in the array. */
+    readonly height: number;
+    /** Whether or not the vertex colors contain translucent colors. */
+    readonly hasTranslucency: boolean;
+    /** If no color table exists, the color to use for all vertices. */
+    readonly uniformColor?: ColorDef;
+    /** Describes the number of features (none, one, or multiple) contained. */
+    readonly featureIndexType: FeatureIndexType;
+    /** If featureIndexType is 'Uniform', the feature ID associated with all vertices. */
+    readonly uniformFeatureID?: number;
+    /** The number of vertices in the table. Must be less than (width*height)/numRgbaPerVertex. */
+    readonly numVertices: number;
+    /** The number of 4-byte 'RGBA' values associated with each vertex. */
+    readonly numRgbaPerVertex: number;
+    /** If vertex data include texture UV coordinates, the quantization params for those coordinates. */
+    readonly uvParams?: QParams2d;
+}
+/** @internal */
+export interface Dimensions {
+    width: number;
+    height: number;
+}
+/** @internal */
+export declare function computeDimensions(nEntries: number, nRgbaPerEntry: number, nExtraRgba: number, maxSize: number): Dimensions;
+//# sourceMappingURL=VertexTable.d.ts.map

package/lib/cjs/common/render/primitives/VertexTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VertexTable.d.ts","sourceRoot":"","sources":["../../../../../src/common/render/primitives/VertexTable.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEtF;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,yFAAyF;IACzF,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B;;OAEG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B,0GAA0G;IAC1G,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uCAAuC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,mEAAmE;IACnE,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,mEAAmE;IACnE,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC;IACjC,2EAA2E;IAC3E,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC5C,qFAAqF;IACrF,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,8FAA8F;IAC9F,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,oGAAoG;IACpG,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;CAC/B;AAED,gBAAgB;AAChB,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,gBAAgB;AAChB,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,CA8B1H"}

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

@@ -0,0 +1,38 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Rendering
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeDimensions = void 0;
+const core_bentley_1 = require("@itwin/core-bentley");
+/** @internal */
+function computeDimensions(nEntries, nRgbaPerEntry, nExtraRgba, maxSize) {
+    const nRgba = nEntries * nRgbaPerEntry + nExtraRgba;
+    if (nRgba < maxSize)
+        return { width: nRgba, height: 1 };
+    // Make roughly square to reduce unused space in last row
+    let width = Math.ceil(Math.sqrt(nRgba));
+    // Ensure a given entry's RGBA values all fit on the same row.
+    const remainder = width % nRgbaPerEntry;
+    if (0 !== remainder) {
+        width += nRgbaPerEntry - remainder;
+    }
+    // Compute height
+    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);
+    (0, core_bentley_1.assert)(Math.floor(height) === height);
+    (0, core_bentley_1.assert)(Math.floor(width) === width);
+    // Row padding should never be necessary...
+    (0, core_bentley_1.assert)(0 === width % nRgbaPerEntry);
+    return { width, height };
+}
+exports.computeDimensions = computeDimensions;
+//# sourceMappingURL=VertexTable.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VertexTable.js","sourceRoot":"","sources":["../../../../../src/common/render/primitives/VertexTable.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAEH,sDAA6C;AA2C7C,gBAAgB;AAChB,SAAgB,iBAAiB,CAAC,QAAgB,EAAE,aAAqB,EAAE,UAAkB,EAAE,OAAe;IAC5G,MAAM,KAAK,GAAG,QAAQ,GAAG,aAAa,GAAG,UAAU,CAAC;IAEpD,IAAI,KAAK,GAAG,OAAO;QACjB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;IAErC,yDAAyD;IACzD,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAExC,8DAA8D;IAC9D,MAAM,SAAS,GAAG,KAAK,GAAG,aAAa,CAAC;IACxC,IAAI,CAAC,KAAK,SAAS,EAAE;QACnB,KAAK,IAAI,aAAa,GAAG,SAAS,CAAC;KACpC;IAED,iBAAiB;IACjB,IAAI,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;IACtC,IAAI,KAAK,GAAG,MAAM,GAAG,KAAK;QACxB,EAAE,MAAM,CAAC;IAEX,IAAA,qBAAM,EAAC,MAAM,IAAI,OAAO,CAAC,CAAC;IAC1B,IAAA,qBAAM,EAAC,KAAK,IAAI,OAAO,CAAC,CAAC;IACzB,IAAA,qBAAM,EAAC,KAAK,GAAG,MAAM,IAAI,KAAK,CAAC,CAAC;IAChC,IAAA,qBAAM,EAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,CAAC;IACtC,IAAA,qBAAM,EAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC,CAAC;IAEpC,2CAA2C;IAC3C,IAAA,qBAAM,EAAC,CAAC,KAAK,KAAK,GAAG,aAAa,CAAC,CAAC;IAEpC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAC3B,CAAC;AA9BD,8CA8BC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Rendering\r\n */\r\n\r\nimport { assert } from \"@itwin/core-bentley\";\r\nimport { ColorDef, FeatureIndexType, QParams2d, QParams3d } from \"@itwin/core-common\";\r\n\r\n/** Describes a VertexTable.\r\n * @internal\r\n */\r\nexport interface VertexTable {\r\n  /** The rectangular array of vertex data, of size width*height*numRgbaPerVertex bytes. */\r\n  readonly data: Uint8Array;\r\n  /** If true, positions are not quantized but instead stored as 32-bit floats.\r\n   * [[qparams]] will still be defined; it can be used to derive the range of positions in the table.\r\n   */\r\n  readonly usesUnquantizedPositions?: boolean;\r\n  /** Quantization parameters for the vertex positions encoded into the array, if the positions are quantized;\r\n   * and for deriving the range of positions in the table, whether quantized or not.\r\n   */\r\n  readonly qparams: QParams3d;\r\n  /** The number of 4-byte 'RGBA' values in each row of the array. Must be divisible by numRgbaPerVertex. */\r\n  readonly width: number;\r\n  /** The number of rows in the array. */\r\n  readonly height: number;\r\n  /** Whether or not the vertex colors contain translucent colors. */\r\n  readonly hasTranslucency: boolean;\r\n  /** If no color table exists, the color to use for all vertices. */\r\n  readonly uniformColor?: ColorDef;\r\n  /** Describes the number of features (none, one, or multiple) contained. */\r\n  readonly featureIndexType: FeatureIndexType;\r\n  /** If featureIndexType is 'Uniform', the feature ID associated with all vertices. */\r\n  readonly uniformFeatureID?: number;\r\n  /** The number of vertices in the table. Must be less than (width*height)/numRgbaPerVertex. */\r\n  readonly numVertices: number;\r\n  /** The number of 4-byte 'RGBA' values associated with each vertex. */\r\n  readonly numRgbaPerVertex: number;\r\n  /** If vertex data include texture UV coordinates, the quantization params for those coordinates. */\r\n  readonly uvParams?: QParams2d;\r\n}\r\n\r\n/** @internal */\r\nexport interface Dimensions {\r\n  width: number;\r\n  height: number;\r\n}\r\n\r\n/** @internal */\r\nexport function computeDimensions(nEntries: number, nRgbaPerEntry: number, nExtraRgba: number, maxSize: number): Dimensions {\r\n  const nRgba = nEntries * nRgbaPerEntry + nExtraRgba;\r\n\r\n  if (nRgba < maxSize)\r\n    return { width: nRgba, height: 1 };\r\n\r\n  // Make roughly square to reduce unused space in last row\r\n  let width = Math.ceil(Math.sqrt(nRgba));\r\n\r\n  // Ensure a given entry's RGBA values all fit on the same row.\r\n  const remainder = width % nRgbaPerEntry;\r\n  if (0 !== remainder) {\r\n    width += nRgbaPerEntry - remainder;\r\n  }\r\n\r\n  // Compute height\r\n  let height = Math.ceil(nRgba / width);\r\n  if (width * height < nRgba)\r\n    ++height;\r\n\r\n  assert(height <= maxSize);\r\n  assert(width <= maxSize);\r\n  assert(width * height >= nRgba);\r\n  assert(Math.floor(height) === height);\r\n  assert(Math.floor(width) === width);\r\n\r\n  // Row padding should never be necessary...\r\n  assert(0 === width % nRgbaPerEntry);\r\n\r\n  return { width, height };\r\n}\r\n"]}

package/lib/{esm → cjs/common}/render/primitives/VertexTableSplitter.d.ts

@@ -2,12 +2,22 @@
  * @module Rendering
  */
 import { RenderFeatureTable, RenderMaterial } from "@itwin/core-common";
-import { MeshParams, VertexIndices } from "./VertexTable";
+import { VertexTable } from "./VertexTable";
+import { VertexIndices } from "./VertexIndices";
+import { SurfaceMaterial } from "./SurfaceParams";
+import { MaterialParams } from "../MaterialParams";
+import { MeshParams } from "./MeshParams";
 import { PointStringParams } from "./PointStringParams";
 import { PolylineParams } from "./PolylineParams";
-import { CreateRenderMaterialArgs } from "../RenderMaterial";
+/** @internal */
+export interface VertexTableWithIndices {
+    vertices: VertexTable;
+    indices: VertexIndices;
+    material?: SurfaceMaterial;
+}
 /** Builds up a [[VertexIndices]].
  * Exported strictly for tests.
+ * @internal
  */
 export declare class IndexBuffer {
     private readonly _builder;
@@ -18,13 +28,16 @@ export declare class IndexBuffer {
     push(index: number): void;
     toVertexIndices(): VertexIndices;
 }
-type CreateRenderMaterial = (args: CreateRenderMaterialArgs) => RenderMaterial | undefined;
+type CreateRenderMaterial = (args: MaterialParams) => RenderMaterial | undefined;
+/** @internal */
 export type ComputeAnimationNodeId = (featureIndex: number) => number;
+/** @internal */
 export interface SplitVertexTableArgs {
     featureTable: RenderFeatureTable;
     maxDimension: number;
     computeNodeId: ComputeAnimationNodeId;
 }
+/** @internal */
 export interface SplitPointStringArgs extends SplitVertexTableArgs {
     params: PointStringParams;
 }
@@ -33,14 +46,18 @@ export interface SplitPointStringArgs extends SplitVertexTableArgs {
  * @internal
  */
 export declare function splitPointStringParams(args: SplitPointStringArgs): Map<number, PointStringParams>;
+/** @internal */
 export interface SplitMeshArgs extends SplitVertexTableArgs {
     params: MeshParams;
     createMaterial: CreateRenderMaterial;
 }
+/** @internal */
 export declare function splitMeshParams(args: SplitMeshArgs): Map<number, MeshParams>;
+/** @internal */
 export interface SplitPolylineArgs extends SplitVertexTableArgs {
     params: PolylineParams;
 }
+/** @internal */
 export declare function splitPolylineParams(args: SplitPolylineArgs): Map<number, PolylineParams>;
 export {};
 //# sourceMappingURL=VertexTableSplitter.d.ts.map

package/lib/cjs/common/render/primitives/VertexTableSplitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VertexTableSplitter.d.ts","sourceRoot":"","sources":["../../../../../src/common/render/primitives/VertexTableSplitter.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAY,kBAAkB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAElF,OAAO,EAAqB,WAAW,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAyB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAsB,MAAM,kBAAkB,CAAC;AAEtE,gBAAgB;AAChB,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,EAAE,aAAa,CAAC;IACvB,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAED;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsB;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8C;gBAEnD,eAAe,SAAI;IAItC,IAAW,UAAU,IAAI,MAAM,CAG9B;IAEM,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKzB,eAAe,IAAI,aAAa;CAGxC;AAkHD,KAAK,oBAAoB,GAAG,CAAC,IAAI,EAAE,cAAc,KAAK,cAAc,GAAG,SAAS,CAAC;AAsIjF,gBAAgB;AAChB,MAAM,MAAM,sBAAsB,GAAG,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC;AAuDtE,gBAAgB;AAChB,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,kBAAkB,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,sBAAsB,CAAC;CACvC;AAED,gBAAgB;AAChB,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB;IAChE,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAcjG;AAqRD,gBAAgB;AAChB,MAAM,WAAW,aAAc,SAAQ,oBAAoB;IACzD,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,EAAE,oBAAoB,CAAC;CACtC;AAED,gBAAgB;AAChB,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAsC5E;AAED,gBAAgB;AAChB,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D,MAAM,EAAE,cAAc,CAAC;CACxB;AAOD,gBAAgB;AAChB,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAqDxF"}

package/lib/cjs/{render → common/render}/primitives/VertexTableSplitter.js

@@ -10,13 +10,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitPolylineParams = exports.splitMeshParams = exports.splitPointStringParams = exports.IndexBuffer = void 0;
 const core_bentley_1 = require("@itwin/core-bentley");
 const core_common_1 = require("@itwin/core-common");
-const VertexTable_1 = require("./VertexTable");
-const PointStringParams_1 = require("./PointStringParams");
-const PolylineParams_1 = require("./PolylineParams");
 const EdgeParams_1 = require("./EdgeParams");
+const VertexTable_1 = require("./VertexTable");
+const VertexIndices_1 = require("./VertexIndices");
 const SurfaceParams_1 = require("./SurfaceParams");
 /** Builds up a [[VertexIndices]].
  * Exported strictly for tests.
+ * @internal
  */
 class IndexBuffer {
     constructor(initialCapacity = 3) {
@@ -33,7 +33,7 @@ class IndexBuffer {
         this._builder.append(this._index8);
     }
     toVertexIndices() {
-        return new VertexTable_1.VertexIndices(this._builder.toTypedArray());
+        return new VertexIndices_1.VertexIndices(this._builder.toTypedArray());
     }
 }
 exports.IndexBuffer = IndexBuffer;
@@ -79,7 +79,7 @@ class VertexBuffer {
         }
         if (materialAtlasTable instanceof Uint32Array)
             rgbaData.set(materialAtlasTable, tableSize);
-        const tableProps = {
+        return {
             data: new Uint8Array(rgbaData.buffer, rgbaData.byteOffset, rgbaData.byteLength),
             usesUnquantizedPositions: source.usesUnquantizedPositions,
             qparams: source.qparams,
@@ -93,7 +93,6 @@ class VertexBuffer {
             numRgbaPerVertex: source.numRgbaPerVertex,
             uvParams: source.uvParams,
         };
-        return new VertexTable_1.VertexTable(tableProps);
     }
 }
 /** Remaps portions of a source color table into a filtered target color table. */
@@ -282,7 +281,7 @@ function splitPointStringParams(args) {
     const result = new Map();
     for (const [id, node] of nodes) {
         const { vertices, indices } = node.buildOutput(args.maxDimension);
-        result.set(id, new PointStringParams_1.PointStringParams(vertices, indices, args.params.weight));
+        result.set(id, { vertices, indices, weight: args.params.weight });
     }
     return result;
 }
@@ -466,7 +465,7 @@ function splitEdges(source, nodes, maxDimension) {
             if (numSilhouettes > 0)
                 data.set(remappedEdges.indexed.silhouettes.toTypedArray(), silhouetteStartByteIndex + silhouettePadding);
             const numTotalEdges = numSegmentEdges + numSilhouettes;
-            edgeIndices = new VertexTable_1.VertexIndices(new Uint8Array(numTotalEdges * 6 * 3));
+            edgeIndices = new VertexIndices_1.VertexIndices(new Uint8Array(numTotalEdges * 6 * 3));
             for (let i = 0; i < numTotalEdges; i++)
                 for (let j = 0; j < 6; j++)
                     edgeIndices.setNthIndex(i * 6 + j, i);
@@ -503,6 +502,7 @@ function splitEdges(source, nodes, maxDimension) {
     }
     return result;
 }
+/** @internal */
 function splitMeshParams(args) {
     const result = new Map();
     const mat = args.params.surface.material;
@@ -517,21 +517,27 @@ function splitMeshParams(args) {
     const edges = args.params.edges ? splitEdges(args.params.edges, nodes, args.maxDimension) : undefined;
     for (const [id, node] of nodes) {
         const { vertices, indices, material } = node.buildOutput(args.maxDimension);
-        const params = new VertexTable_1.MeshParams(vertices, {
-            type: args.params.surface.type,
-            indices,
-            fillFlags: args.params.surface.fillFlags,
-            hasBakedLighting: args.params.surface.hasBakedLighting,
-            textureMapping: args.params.surface.textureMapping,
-            material: material !== undefined ? material : args.params.surface.material,
-        }, edges?.get(id), args.params.isPlanar, 
-        // ###TODO handle aux channels.......
-        args.params.auxChannels);
+        const params = {
+            vertices,
+            surface: {
+                type: args.params.surface.type,
+                indices,
+                fillFlags: args.params.surface.fillFlags,
+                hasBakedLighting: args.params.surface.hasBakedLighting,
+                textureMapping: args.params.surface.textureMapping,
+                material: material !== undefined ? material : args.params.surface.material,
+            },
+            edges: edges?.get(id),
+            isPlanar: args.params.isPlanar,
+            // ###TODO handle aux channels.......
+            auxChannels: args.params.auxChannels,
+        };
         result.set(id, params);
     }
     return result;
 }
 exports.splitMeshParams = splitMeshParams;
+/** @internal */
 function splitPolylineParams(args) {
     const nodes = VertexTableSplitter.split({
         indices: args.params.polyline.indices,
@@ -567,11 +573,15 @@ function splitPolylineParams(args) {
     for (const [id, node] of nodes) {
         (0, core_bentley_1.assert)(undefined !== node.prevIndices && undefined !== node.nextIndicesAndParams);
         const { vertices, indices } = node.buildOutput(args.maxDimension);
-        const params = new PolylineParams_1.PolylineParams(vertices, {
-            indices,
-            prevIndices: node.prevIndices.toVertexIndices(),
-            nextIndicesAndParams: node.nextIndicesAndParams.toUint8Array(),
-        }, args.params.weight, args.params.linePixels, args.params.isPlanar, args.params.type);
+        const params = {
+            ...args.params,
+            vertices,
+            polyline: {
+                indices,
+                prevIndices: node.prevIndices.toVertexIndices(),
+                nextIndicesAndParams: node.nextIndicesAndParams.toUint8Array(),
+            },
+        };
         result.set(id, params);
     }
     return result;