@itwin/core-common 5.0.0-dev.9 → 5.0.0-dev.92

package/lib/cjs/RenderSchedule.js

@@ -61,6 +61,10 @@ var RenderSchedule;
      * @see [[RenderSchedule.CuttingPlaneEntry]]
      */
     class TimelineEntry {
+        /** The time point in seconds in the [Unix Epoch](https://en.wikipedia.org/wiki/Unix_time). */
+        time;
+        /** How to interpolate from this entry to the next entry in the timeline. */
+        interpolation;
         constructor(props) {
             this.time = props.time;
             this.interpolation = props.interpolation === Interpolation.Linear ? props.interpolation : Interpolation.Step;
@@ -83,6 +87,10 @@ var RenderSchedule;
     RenderSchedule.TimelineEntry = TimelineEntry;
     /** A timeline entry that controls the visibility of the associated geometry. */
     class VisibilityEntry extends TimelineEntry {
+        /** The visibility of the geometry at this point on the timeline, in the range [0, 100] where 0 is completely invisible, 100 is completely visible,
+         * and values in between indicate increasing opacity.
+         */
+        value;
         constructor(props) {
             super(props);
             if (typeof props.value !== "number")
@@ -104,6 +112,8 @@ var RenderSchedule;
     RenderSchedule.VisibilityEntry = VisibilityEntry;
     /** A timeline entry controlling the color of the affected geometry. */
     class ColorEntry extends TimelineEntry {
+        /** If defined, the color in which to draw the geometry. If undefined, the geometry is drawn in its actual color. */
+        value;
         constructor(props) {
             super(props);
             if (props.value)
@@ -128,6 +138,12 @@ var RenderSchedule;
     RenderSchedule.ColorEntry = ColorEntry;
     /** Describes the components of a [[RenderSchedule.TransformEntry]] as a rotation around a pivot point followed by a translation. */
     class TransformComponents {
+        /** Pivot point - applied before rotation. */
+        pivot;
+        /** Quaternion rotation. */
+        orientation;
+        /** Translation - applied after rotation. */
+        position;
         constructor(position, pivot, orientation) {
             this.position = position;
             this.pivot = pivot;
@@ -156,6 +172,10 @@ var RenderSchedule;
     RenderSchedule.TransformComponents = TransformComponents;
     /** A timeline entry that applies rotation, scaling, and/or translation to the affected geometry. */
     class TransformEntry extends TimelineEntry {
+        /** The transform matrix to be applied to the geometry, used only if [[components]] is not defined. */
+        value;
+        /** The transform represented as a rotation about a pivot point followed by a translation. If undefined, [[value]] is used instead. */
+        components;
         constructor(props) {
             super(props);
             this.value = props.value ? core_geometry_1.Transform.fromJSON(props.value.transform) : core_geometry_1.Transform.identity;
@@ -189,6 +209,14 @@ var RenderSchedule;
     RenderSchedule.TransformEntry = TransformEntry;
     /** Defines a [ClipPlane]($core-geometry) associated with a [[RenderSchedule.CuttingPlaneEntry]]. */
     class CuttingPlane {
+        /** A point on the plane. */
+        position;
+        /** The direction perpendicular to the plane pointing toward the clip. */
+        direction;
+        /** If true, the clip plane is ignored and the geometry is never clipped. */
+        visible;
+        /** If true, the clip plane is ignored and the geometry is always clipped. */
+        hidden;
         constructor(props) {
             this.position = core_geometry_1.Point3d.fromJSON(props.position);
             this.direction = core_geometry_1.Point3d.fromJSON(props.direction);
@@ -216,6 +244,8 @@ var RenderSchedule;
     RenderSchedule.CuttingPlane = CuttingPlane;
     /** A timeline entry that applies a [ClipPlane]($core-geometry) to the affected geometry. */
     class CuttingPlaneEntry extends TimelineEntry {
+        /** The definition of the [ClipPlane]($core-geometry), or undefined if this entry applies no clipping. */
+        value;
         constructor(props) {
             super(props);
             if (props.value)
@@ -237,6 +267,12 @@ var RenderSchedule;
      * @internal
      */
     class Interval {
+        /** The index of the first timeline entry within the list. */
+        lowerIndex;
+        /** The index of the second timeline entry within the list. */
+        upperIndex;
+        /** The normalized distance between the two timeline entries. */
+        fraction;
         constructor(lower = 0, upper = 0, fraction = 0) {
             this.init(lower, upper, fraction);
         }
@@ -253,6 +289,9 @@ var RenderSchedule;
      *  - V, the type of `T.value`.
      */
     class TimelineEntryList {
+        _entries;
+        /** The total time period represented by the entries in this list. */
+        duration;
         constructor(props, ctor) {
             this.duration = core_geometry_1.Range1d.createNull();
             this._entries = props.map((x) => {
@@ -345,6 +384,16 @@ var RenderSchedule;
      * @see [[RenderSchedule.ElementTimeline]] and [[RenderSchedule.ModelTimeline]].
      */
     class Timeline {
+        /** Sequence controlling the visibility of the geometry. */
+        visibility;
+        /** Sequence controlling the color of the geometry. */
+        color;
+        /** Sequence controlling the position, orientation, and/or scale of the geometry. */
+        transform;
+        /** Sequence controlling how the geometry is clipped. */
+        cuttingPlane;
+        /** The total time period represented by this timeline. */
+        duration;
         constructor(props) {
             this.duration = core_geometry_1.Range1d.createNull();
             if (props.visibilityTimeline) {
@@ -490,6 +539,9 @@ var RenderSchedule;
     RenderSchedule.Timeline = Timeline;
     /** Specifies how to animate the geometry belonging to a set of [GeometricElement]($backend)s as part of a [[RenderSchedule.Script]]. */
     class ElementTimeline extends Timeline {
+        /** A positive integer that uniquely identififes this timeline among all ElementTimelines in the [[RenderSchedule.Script]]. */
+        batchId;
+        _elementIds;
         constructor(props) {
             super(props);
             this.batchId = props.batchId;
@@ -584,10 +636,36 @@ var RenderSchedule;
     RenderSchedule.ElementTimeline = ElementTimeline;
     /** Specifies how to animate the geometry within a [GeometricModel]($backend) as part of a [[RenderSchedule.Script]]. */
     class ModelTimeline extends Timeline {
+        /** The Id of the [GeometricModel]($backend) to be animated. */
+        modelId;
+        /** @internal */
+        realityModelUrl;
+        /** Timelines specifying how to animate groups of [GeometricElement]($backend)s within the model. */
+        elementTimelines;
+        /** @internal */
+        transformBatchIds;
+        /** True if this timeline affects the color or transparency of the geometry. */
+        containsFeatureOverrides;
+        /** True if this timeline applies clipping to the model. */
+        containsModelClipping;
+        /** If true, applying this timeline requires special tiles to be generated in which groups of elements are batched into nodes.
+         * @internal
+         */
+        requiresBatching;
+        /** True if this timeline affects the position, orientation, or scale of the geometry. */
+        containsTransform;
+        /** True if any [[RenderSchedule.ElementTimeline]]s exist and none of them contain any element Ids. This generally indicates that
+         * the backend was instructed to omit the Ids to save space when supplying the script.
+         */
+        omitsElementIds;
+        _maxBatchId;
+        /** Tile tree suppliers perform **very** frequent ordered comparisons of ModelTimelines. They need to be fast. */
+        _cachedComparisons = new WeakMap();
+        /** When loading tiles we need to quickly map element Ids to batch Ids. This map is initialized on first call to [[getTimelineForElement]] to facilitate that lookup. */
+        _idPairToElementTimeline;
+        _discreteBatchIds;
         constructor(props) {
             super(props);
-            /** Tile tree suppliers perform **very** frequent ordered comparisons of ModelTimelines. They need to be fast. */
-            this._cachedComparisons = new WeakMap();
             this.modelId = props.modelId;
             this.realityModelUrl = props.realityModelUrl;
             this.containsModelClipping = undefined !== this.cuttingPlane;
@@ -717,6 +795,29 @@ var RenderSchedule;
      * @see [[RenderSchedule.ScriptBuilder]] to define a new script.
      */
     class Script {
+        /** Timelines specifying how to animate individual models within the view. */
+        modelTimelines;
+        /** True if this script applies clipping to any models. */
+        containsModelClipping;
+        /** If true, applying this timeline requires special tiles to be generated in which groups of elements are batched into nodes.
+         * @internal
+         */
+        requiresBatching;
+        /** True if this script affects the position, orientation, or scale of the geometry. */
+        containsTransform;
+        /** True if this script affects the color or transparency of the geometry. */
+        containsFeatureOverrides;
+        /** The total time period over which this script animates. */
+        duration;
+        /** The batchIds of all nodes in all timelines that apply a transform.
+         * @internal
+         */
+        transformBatchIds;
+        /** Tile tree references perform **very** frequent ordered comparisons of Scripts. They need to be fast. */
+        _cachedComparisons = new WeakMap();
+        _discreteBatchIds;
+        _lastFeatureModelTimeline;
+        _maxBatchId;
         compareTo(other) {
             if (this === other)
                 return 0;
@@ -739,8 +840,6 @@ var RenderSchedule;
             return 0 === this.compareTo(other);
         }
         constructor(props) {
-            /** Tile tree references perform **very** frequent ordered comparisons of Scripts. They need to be fast. */
-            this._cachedComparisons = new WeakMap();
             this.duration = core_geometry_1.Range1d.createNull();
             const transformBatchIds = new Set();
             const modelTimelines = [];
@@ -840,11 +939,22 @@ var RenderSchedule;
     }
     RenderSchedule.Script = Script;
     /** A reference to a [[RenderSchedule.Script]], optionally identifying the source of the script.
-     * @see [DisplayStyle.loadScheduleScript]($backend) and [DisplayStyleState.scheduleScript]($frontend) to obtain the script reference for a display style on the frontend
-     * and backend respectively.
+     * @see [DisplayStyle.loadScheduleScript]($backend) to obtain the script reference for a display style.
      * @see [DisplayStyleState.scheduleScript]($frontend) or [DisplayStyleState.changeRenderTimeline]($frontend) to change a display style's script on the frontend.
      */
     class ScriptReference {
+        /** The Id of the element - if any - from which the script originated.
+         * A schedule script may originate from one of the following sources:
+         *  - A [RenderTimeline]($backend) element stored in the iModel; or
+         *  - The `scheduleScript` JSON property of a [DisplayStyle]($backend) element stored in the iModel; or
+         *  - Any other source outside of the iModel, such as code that generates the script on the frontend, a script obtained from some server, etc.
+         *
+         * The [[sourceId]] property identifies the Id of the element from which the script originated; an empty or invalid [Id64String]($bentley) indicates the script did not
+         * originate from any persistent element. If the Id is valid, the contents of [[script]] are assumed to match those stored on the source element.
+         */
+        sourceId;
+        /** The script defining the rendering timelines to be applied. */
+        script;
         /** @internal Use one of the public constructor overloads which forward to this one. */
         constructor(sourceIdOrScript, scriptIfSourceId) {
             if (typeof sourceIdOrScript === "string") {
@@ -866,6 +976,14 @@ var RenderSchedule;
      * @see [[RenderSchedule.ElementTimelineBuilder]] and [[RenderSchedule.ModelTimelineBuilder]].
      */
     class TimelineBuilder {
+        /** Timeline controlling visibility. */
+        visibility;
+        /** Timeline controlling color. */
+        color;
+        /** Timeline controlling position and orientation. */
+        transform;
+        /** Timeline controlling clipping. */
+        cuttingPlane;
         /** Append a new [[RenderSchedule.VisibilityEntry]] to the timeline. `time` must be more recent than any previously-appended visibility entries. */
         addVisibility(time, visibility, interpolation = Interpolation.Linear) {
             if (!this.visibility)
@@ -929,6 +1047,12 @@ var RenderSchedule;
      * @see [[RenderSchedule.ModelTimelineBuilder.addElementTimeline]].
      */
     class ElementTimelineBuilder extends TimelineBuilder {
+        /** A positive integer that uniquely identifies this timeline among all element timelines in the [[RenderSchedule.Script]].
+         * [[RenderSchedule.ScriptBuilder]] ensures each ElementTimelineBuilder receives a unique batch Id.
+         */
+        batchId;
+        /** The compressed set of Ids of the elements affected by this timeline. */
+        elementIds;
         /** Constructor - typically not used directly.
          * @see [[RenderSchedule.ModelTimelineBuilder.addElementTimeline]] to create an ElementTimelineBuilder.
          */
@@ -952,12 +1076,17 @@ var RenderSchedule;
      * @see [[RenderSchedule.ScriptBuilder.addModelTimeline]].
      */
     class ModelTimelineBuilder extends TimelineBuilder {
+        /** The Id of the model affected by this timeline. */
+        modelId;
+        /** @internal */
+        realityModelUrl;
+        _obtainNextBatchId;
+        _elements = [];
         /** Constructor - typically not used directly.
          * @see [[RenderSchedule.ScriptBuilder.addModelTimeline]] to create a ModelTimelineBuilder.
          */
         constructor(modelId, obtainNextBatchId) {
             super();
-            this._elements = [];
             this.modelId = modelId;
             this._obtainNextBatchId = obtainNextBatchId;
         }
@@ -1007,10 +1136,8 @@ var RenderSchedule;
      * ```
      */
     class ScriptBuilder {
-        constructor() {
-            this._nextBatchId = 1;
-            this._models = [];
-        }
+        _nextBatchId = 1;
+        _models = [];
         /** Add a new [[RenderSchedule.ModelTimeline]] to be applied to the specified model. */
         addModelTimeline(modelId) {
             const builder = new ModelTimelineBuilder(modelId, () => this._nextBatchId++);