Misc sector loading optimizations

viewer/packages/cad-geometry-loaders/src/CadManager.ts

@@ -4,7 +4,7 @@
 
 import * as THREE from 'three';
 
-import { Subscription, Observable } from 'rxjs';
+import { Subscription, Observable, auditTime, buffer } from 'rxjs';
 
 import { LevelOfDetail, ConsumedSector, CadModelMetadata } from '@reveal/cad-parsers';
 import { CadModelUpdateHandler } from './CadModelUpdateHandler';
@@ -35,6 +35,8 @@ export class CadManager {
   private readonly _markNeedsRedrawBound = this.markNeedsRedraw.bind(this);
   private readonly _materialsChangedListener = this.handleMaterialsChanged.bind(this);
 
+  private readonly _sectorBufferTime = 350;
+
   get materialManager(): CadMaterialManager {
     return this._materialManager;
   }
@@ -107,9 +109,18 @@ export class CadManager {
       this.updateTreeIndexToSectorsMap(cadModel, sector);
     };
 
+    const consumeNextSectors = (sectors: ConsumedSector[]) => {
+      for (const sector of sectors) {
+        consumeNextSector(sector);
+      }
+      this._cadModelUpdateHandler.reportNewSectorsLoaded(sectors.length);
+    };
+
+    const consumedSectorsObservable = this._cadModelUpdateHandler.consumedSectorObservable();
+    const flushAt = consumedSectorsObservable.pipe(auditTime(this._sectorBufferTime));
     this._subscription.add(
-      this._cadModelUpdateHandler.consumedSectorObservable().subscribe({
-        next: consumeNextSector,
+      consumedSectorsObservable.pipe(buffer(flushAt)).subscribe({
+        next: consumeNextSectors,
         error: error => {
           MetricsLogger.trackError(error, {
             moduleName: 'CadManager',

viewer/packages/cad-geometry-loaders/src/CadModelUpdateHandler.ts

@@ -38,6 +38,7 @@ export class CadModelUpdateHandler {
   private readonly _modelStateHandler: ModelStateHandler;
   private _budget: CadModelBudget;
   private _lastSpent: SectorLoadingSpent;
+  private readonly _determineSectorsHandler: SectorLoader;
 
   private readonly _cameraSubject: Subject<CameraInput> = new Subject();
   private readonly _clippingPlaneSubject: Subject<THREE.Plane[]> = new Subject();
@@ -106,15 +107,15 @@ export class CadModelUpdateHandler {
       };
       this._progressSubject.next(state);
     };
-    const determineSectorsHandler = new SectorLoader(
+    this._determineSectorsHandler = new SectorLoader(
       sectorCuller,
       this._modelStateHandler,
       collectStatisticsCallback,
       reportProgressCallback,
       continuousModelStreaming
     );
 
-    async function* loadSectors(input: DetermineSectorsPayload) {
+    async function* loadSectors(input: DetermineSectorsPayload, determineSectorsHandler: SectorLoader) {
       for await (const sector of determineSectorsHandler.loadSectors(input)) {
         yield sector;
       }
@@ -124,7 +125,7 @@ export class CadModelUpdateHandler {
       observeOn(asyncScheduler), // Schedule tasks on macro task queue (setInterval)
       map(createDetermineSectorsInput), // Map from array to interface (enables destructuring)
       filter(loadingEnabled), // should we load?
-      mergeMap(async x => loadSectors(x)),
+      mergeMap(async x => loadSectors(x, this._determineSectorsHandler)),
       mergeMap(x => x)
     );
   }
@@ -182,6 +183,10 @@ export class CadModelUpdateHandler {
     return this._progressSubject;
   }
 
+  reportNewSectorsLoaded(loadedCountChange: number): void {
+    this._determineSectorsHandler.reportNewSectorsLoaded(loadedCountChange);
+  }
+
   /**
    * When loading hints of a CAD model changes, propagate the event down to the stream and either add or remove
    * the {@link CadModelMetadata} from the array and push the new array down stream

viewer/packages/cad-geometry-loaders/src/sector/SectorLoader.ts

@@ -31,7 +31,7 @@ const SectorLoadingBatchSize = 20;
  */
 export class SectorLoader {
   private readonly _modelStateHandler: ModelStateHandler;
-  private readonly _progressCallback: (sectorsLoaded: number, sectorsScheduled: number, sectorsCulled: number) => void;
+  private readonly _progressHelper: ProgressReportHelper;
   private readonly _collectStatisticsCallback: (spent: SectorLoadingSpent) => void;
   private readonly _sectorCuller: SectorCuller;
   private readonly _continuousModelStreaming: boolean;
@@ -52,7 +52,7 @@ export class SectorLoader {
 
     this._modelStateHandler = modelStateHandler;
     this._collectStatisticsCallback = collectStatisticsCallback;
-    this._progressCallback = progressCallback;
+    this._progressHelper = new ProgressReportHelper(progressCallback);
     this._continuousModelStreaming = continuousModelStreaming;
   }
 
@@ -86,15 +86,18 @@ export class SectorLoader {
       hasSectorChanged(sector.modelIdentifier, sector.metadata.id, sector.levelOfDetail)
     );
 
-    const progressHelper = new ProgressReportHelper(this._progressCallback);
-    progressHelper.start(changedSectors.length);
+    this._progressHelper.reset(changedSectors.length);
 
     this._batchId++;
     const currentBatchId = this._batchId;
 
     for (const batch of chunk(changedSectors, SectorLoadingBatchSize)) {
-      if (currentBatchId !== this._batchId) break; // Stop processing this batch as a new batch has started, and will discard results from old batches.
-      const filteredSectors = await this.filterSectors(sectorCullerInput, batch, sectorCuller, progressHelper);
+      if (currentBatchId !== this._batchId) {
+        // Stop processing this batch as a new batch has started, and will discard results from old batches.
+        this._progressHelper.reportNewSectorsLoaded(batch.length);
+        continue;
+      }
+      const filteredSectors = await this.filterSectors(sectorCullerInput, batch, sectorCuller, this._progressHelper);
       const consumedPromises = this.startLoadingBatch(filteredSectors, cadModels);
       for await (const consumed of PromiseUtils.raceUntilAllCompleted(consumedPromises)) {
         const resolvedSector = consumed.result;
@@ -104,13 +107,18 @@ export class SectorLoader {
             resolvedSector.metadata.id,
             resolvedSector.levelOfDetail
           );
-          yield resolvedSector;
+          yield resolvedSector; // progress will be reported when sector is loaded by CadManager
+        } else {
+          this._progressHelper.reportNewSectorsLoaded(1);
         }
-        progressHelper.reportNewSectorsLoaded(1);
       }
     }
   }
 
+  reportNewSectorsLoaded(loadedCountChange: number): void {
+    this._progressHelper.reportNewSectorsLoaded(loadedCountChange);
+  }
+
   private shouldLoad(input: DetermineSectorsPayload) {
     if (input.models.length == 0) {
       return false;
@@ -157,8 +165,8 @@ class ProgressReportHelper {
     this._progressCallback = reportCb;
   }
 
-  start(sectorsScheduled: number) {
-    this._sectorsScheduled = sectorsScheduled;
+  reset(sectorsScheduledChange: number) {
+    this._sectorsScheduled += sectorsScheduledChange - this._sectorsLoaded;
     this._sectorsLoaded = 0;
     this._sectorsCulled = 0;
     this.triggerCallback();

viewer/packages/cad-model/src/utilities/GeometryBufferUtils.ts

@@ -4,7 +4,13 @@
 
 import { TypedArray, TypedArrayConstructor } from '@reveal/utilities';
 import assert from 'assert';
-import { BufferAttribute, InterleavedBufferAttribute, BufferGeometry, InstancedInterleavedBuffer } from 'three';
+import {
+  BufferAttribute,
+  InterleavedBufferAttribute,
+  BufferGeometry,
+  InstancedInterleavedBuffer,
+  DynamicDrawUsage
+} from 'three';
 
 export class GeometryBufferUtils {
   private static readonly TypedArrayViews = new Map<number, TypedArrayConstructor>([
@@ -51,6 +57,7 @@ export class GeometryBufferUtils {
 
       const ComponentType = GeometryBufferUtils.TypedArrayViews.get(componentSize)!;
       const interleavedAttributesBuffer = new InstancedInterleavedBuffer(new ComponentType(backingBuffer), stride);
+      interleavedAttributesBuffer.setUsage(DynamicDrawUsage);
 
       bufferGeometry.setAttribute(
         name,

viewer/packages/rendering/src/utilities/renderUtilities.ts

@@ -265,14 +265,14 @@ export function setModelRenderLayers(rootNode: THREE.Object3D, stylingSets: Styl
       return;
     }
 
-    if (visible.hasIntersectionWith(objectTreeIndices)) {
-      if (back.hasIntersectionWith(objectTreeIndices)) {
+    if (visible.hasIntersectionWithMap(objectTreeIndices)) {
+      if (back.hasIntersectionWithMap(objectTreeIndices)) {
         node.layers.enable(RenderLayer.Back);
       }
-      if (ghost.hasIntersectionWith(objectTreeIndices)) {
+      if (ghost.hasIntersectionWithMap(objectTreeIndices)) {
         node.layers.enable(RenderLayer.Ghost);
       }
-      if (inFront.hasIntersectionWith(objectTreeIndices)) {
+      if (inFront.hasIntersectionWithMap(objectTreeIndices)) {
         node.layers.enable(RenderLayer.InFront);
       }
     }

viewer/packages/utilities/src/indexset/IndexSet.test.ts

@@ -141,6 +141,22 @@ describe('IndexSet', () => {
     expect(set1.hasIntersectionWith(set2)).toBeFalse();
   });
 
+  test('hasIntersectionWithMap returns true if there is any overlap', () => {
+    const set = new IndexSet();
+    set.addRange(new NumericRange(1, 5));
+    const map = new Map<number, number>();
+    map.set(3, 0);
+    expect(set.hasIntersectionWithMap(map)).toBeTrue();
+  });
+
+  test('hasIntersectionWithMap returns false if there is no overlap', () => {
+    const set = new IndexSet();
+    set.addRange(new NumericRange(1, 5));
+    const map = new Map<number, number>();
+    map.set(6, 0);
+    expect(set.hasIntersectionWithMap(map)).toBeFalse();
+  });
+
   test('differenceWith removes overlapping elements', () => {
     const set1 = new IndexSet();
     set1.addRange(new NumericRange(1, 5));

viewer/packages/utilities/src/indexset/IndexSet.ts

@@ -142,21 +142,13 @@ export class IndexSet {
     return this;
   }
 
-  hasIntersectionWith(otherSet: IndexSet | Map<number, number> | Set<number>): boolean {
+  hasIntersectionWith(otherSet: IndexSet | Set<number>): boolean {
     if (otherSet instanceof IndexSet) {
       if (this.rootNode === undefined || otherSet.rootNode === undefined) {
         return false;
       }
 
       return this.rootNode.hasIntersectionWith(otherSet.rootNode);
-    } else if (otherSet instanceof Map) {
-      for (const index of otherSet.keys()) {
-        if (this.contains(index)) {
-          return true;
-        }
-      }
-
-      return false;
     } else {
       for (const index of otherSet) {
         if (this.contains(index)) {
@@ -168,6 +160,20 @@ export class IndexSet {
     }
   }
 
+  hasIntersectionWithMap(otherMap: Map<number, number>): boolean {
+    if (!this.rootNode) {
+      return false;
+    }
+
+    for (const index of otherMap.keys()) {
+      if (this.rootNode.contains(index)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
   intersectWith(otherSet: IndexSet): IndexSet {
     if (this.rootNode && otherSet.rootNode) {
       // Tackle endpoints

viewer/reveal.api.md

@@ -900,7 +900,9 @@ export class IndexSet {
     // (undocumented)
     forEachRange(visitor: (range: NumericRange) => void): void;
     // (undocumented)
-    hasIntersectionWith(otherSet: IndexSet | Map<number, number> | Set<number>): boolean;
+    hasIntersectionWith(otherSet: IndexSet | Set<number>): boolean;
+    // (undocumented)
+    hasIntersectionWithMap(otherMap: Map<number, number>): boolean;
     // (undocumented)
     intersectWith(otherSet: IndexSet): IndexSet;
     // (undocumented)