@ztgkzhaohao/geo-effect-kit 0.3.1 → 0.4.0

package/dist/index.js

@@ -1,5 +1,6 @@
-import { BoundingSphere, BillboardGraphics, CallbackPositionProperty, CallbackProperty, Cartesian2, Cartesian3, Cartesian4, CircleGeometry, Color, ColorMaterialProperty, ConstantPositionProperty, ConstantProperty, CustomDataSource, EllipsoidSurfaceAppearance, Event, GeometryInstance, GroundPrimitive, HeadingPitchRoll, HeadingPitchRange, HeightReference, HorizontalOrigin, Material, Math as CesiumMath, PointGraphics, PolylineArrowMaterialProperty, PolylineDashMaterialProperty, PolylineGlowMaterialProperty, PolylineOutlineMaterialProperty, PolygonGeometry, PolygonHierarchy, PostProcessStage, Primitive, Rectangle, Transforms, VerticalOrigin, } from 'cesium';
+import { BoundingSphere, BillboardGraphics, CallbackPositionProperty, CallbackProperty, Cartesian2, Cartesian3, Cartesian4, CircleGeometry, Color, ColorMaterialProperty, ConstantPositionProperty, ConstantProperty, CustomDataSource, CylinderGeometry, EllipsoidSurfaceAppearance, Event, GeometryInstance, GroundPrimitive, HeadingPitchRoll, HeadingPitchRange, HeightReference, HorizontalOrigin, Intersect, Material, MaterialAppearance, Math as CesiumMath, Matrix4, PointGraphics, PolylineArrowMaterialProperty, PolylineDashMaterialProperty, PolylineGlowMaterialProperty, PolylineOutlineMaterialProperty, PolygonGeometry, PolygonHierarchy, PostProcessStage, Primitive, Rectangle, Transforms, VerticalOrigin, } from 'cesium';
 import { decompressFrames, parseGIF } from 'gifuct-js';
+import { normalizeScanConeExpansionOptions, sampleScanConeExpansionFrame } from './scan-cone-expansion.js';
 export const GEO_RADAR_SCAN_MATERIAL_TYPE = 'GeoRadarScanMaterial';
 export const GEO_RIPPLE_SPREAD_MATERIAL_TYPE = 'GeoRippleSpreadMaterial';
 export const GEO_LIGHT_WALL_MATERIAL_TYPE = 'GeoLightWallMaterial';
@@ -233,6 +234,7 @@ export function normalizeScanConeOptions(options) {
         pitch: finiteOr(options.pitch ?? 0, 0),
         showOrigin: options.showOrigin ?? true,
         visible: options.visible ?? true,
+        ...(options.expansion ? { expansion: normalizeScanConeExpansionOptions(options.expansion) } : {}),
     };
 }
 export function normalizeShieldDomeOptions(options) {
@@ -3120,17 +3122,42 @@ export class ScanConeEffect {
     dataSource;
     options;
     coneEntity = null;
+    conePrimitive = null;
     originEntity = null;
     material = null;
+    primitiveMaterial = null;
+    primitiveOriginScratch = new Cartesian3();
+    primitiveHeadingPitchRollScratch = new HeadingPitchRoll();
+    primitiveModelMatrixScratch = new Matrix4();
+    primitiveScaleScratch = new Cartesian3();
+    primitiveTranslationScratch = new Cartesian3();
+    expansionState = createInitialScanConeExpansionState('idle');
+    expansionPreviousTimestamp = null;
+    pausedByVisibility = false;
+    completionNotified = false;
+    cameraFollowPlanned = false;
+    cameraFollowCancelledByUser = false;
+    cameraFollowListenersAttached = false;
+    cameraFollowGeneration = 0;
+    activeCameraFollowGeneration = null;
+    internallyCancellingCameraFollowGeneration = null;
     renderFrame = 0;
     destroyed = false;
+    handleCameraFollowUserInput = () => {
+        if (this.activeCameraFollowGeneration === null)
+            return;
+        this.cameraFollowCancelledByUser = true;
+        this.stopExpansionCameraFollow(true);
+    };
     constructor(viewer, options) {
         this.viewer = viewer;
         this.options = normalizeScanConeOptions(options);
         this.dataSource = new CustomDataSource('geo-effect-kit-scan-cone');
         this.dataSource.show = this.options.visible;
         this.viewer.dataSources.add(this.dataSource);
-        this.renderEntities();
+        this.resetExpansionState();
+        this.renderCurrentPath();
+        this.startExpansionCameraFollow(this.getExpansionRemainingDurationMs());
         this.startRenderLoop();
         this.viewer.scene.requestRender();
     }
@@ -3144,27 +3171,107 @@ export class ScanConeEffect {
             showOrigin: options.showOrigin ?? this.options.showOrigin,
             visible: options.visible ?? this.options.visible,
         });
-        const rebuildEntities = shouldRebuildScanCone(this.options, next);
+        const previous = this.options;
+        const modeChanged = Boolean(previous.expansion) !== Boolean(next.expansion);
+        const restartExpansion = Boolean(previous.expansion && next.expansion) && (previous.lengthMeters !== next.lengthMeters ||
+            previous.expansion?.maxRadiusMeters !== next.expansion?.maxRadiusMeters ||
+            previous.expansion?.durationMs !== next.expansion?.durationMs);
+        const cameraFollowChanged = previous.expansion?.cameraFollow !== next.expansion?.cameraFollow;
+        const cameraTargetChanged = Boolean(previous.expansion && next.expansion) && (!positionEqual(previous.center, next.center) ||
+            previous.heading !== next.heading ||
+            previous.pitch !== next.pitch ||
+            previous.speed !== next.speed);
+        const rebuildEntities = !next.expansion && shouldRebuildScanCone(previous, next);
+        if (modeChanged)
+            this.stopExpansionCameraFollow(true);
         this.options = next;
-        if (rebuildEntities) {
+        if (modeChanged) {
+            this.cameraFollowPlanned = false;
+            this.cameraFollowCancelledByUser = false;
+            this.resetExpansionState();
+            this.renderCurrentPath();
+            this.startExpansionCameraFollow(this.getExpansionRemainingDurationMs());
+        }
+        else if (rebuildEntities) {
             this.renderEntities();
         }
         else {
             this.applyMaterialOptions();
             this.syncOriginEntity();
+            if (restartExpansion)
+                this.restartExpansion();
+            else if (this.options.expansion)
+                this.updatePrimitiveModelMatrix(getAnimationSeconds());
+        }
+        if (!modeChanged && !restartExpansion && cameraFollowChanged) {
+            this.stopExpansionCameraFollow(true);
+            this.cameraFollowPlanned = false;
+            this.startExpansionCameraFollow(this.getExpansionRemainingDurationMs());
+        }
+        if (!modeChanged &&
+            !restartExpansion &&
+            !cameraFollowChanged &&
+            cameraTargetChanged &&
+            !this.cameraFollowCancelledByUser) {
+            this.stopExpansionCameraFollow(true);
+            this.cameraFollowPlanned = false;
+            this.startExpansionCameraFollow(this.getExpansionRemainingDurationMs());
         }
         this.dataSource.show = this.options.visible;
+        if (this.conePrimitive)
+            this.conePrimitive.show = this.options.visible;
+        if (!modeChanged && !restartExpansion && previous.visible !== this.options.visible) {
+            if (this.options.visible)
+                this.resumeExpansionAfterVisibilityPause();
+            else
+                this.pauseExpansionForVisibility();
+        }
         if (this.options.visible)
             this.startRenderLoop();
         else
             this.stopRenderLoop();
         this.viewer.scene.requestRender();
     }
+    restartExpansion() {
+        if (this.destroyed || !this.options.expansion)
+            return;
+        this.stopExpansionCameraFollow(true);
+        this.cameraFollowPlanned = false;
+        this.cameraFollowCancelledByUser = false;
+        this.expansionState = createInitialScanConeExpansionState(this.options.visible ? 'running' : 'paused');
+        this.expansionPreviousTimestamp = null;
+        this.pausedByVisibility = !this.options.visible;
+        this.completionNotified = false;
+        this.updatePrimitiveModelMatrix(getAnimationSeconds());
+        this.startExpansionCameraFollow(this.getExpansionRemainingDurationMs());
+        if (this.options.visible)
+            this.startRenderLoop();
+        this.viewer.scene.requestRender();
+    }
+    cancelExpansion() {
+        if (this.destroyed || !this.options.expansion)
+            return;
+        if (this.expansionState.status === 'completed' || this.expansionState.status === 'cancelled')
+            return;
+        this.expansionState = { ...this.expansionState, status: 'cancelled' };
+        this.expansionPreviousTimestamp = null;
+        this.pausedByVisibility = false;
+        this.stopExpansionCameraFollow(true);
+    }
+    isExpanding() {
+        return !this.destroyed && this.expansionState.status === 'running';
+    }
+    getExpansionState() {
+        return { ...this.expansionState };
+    }
     show() {
         if (this.destroyed)
             return;
         this.options = { ...this.options, visible: true };
         this.dataSource.show = true;
+        if (this.conePrimitive)
+            this.conePrimitive.show = true;
+        this.resumeExpansionAfterVisibilityPause();
         this.startRenderLoop();
         this.viewer.scene.requestRender();
     }
@@ -3173,12 +3280,19 @@ export class ScanConeEffect {
             return;
         this.options = { ...this.options, visible: false };
         this.dataSource.show = false;
+        if (this.conePrimitive)
+            this.conePrimitive.show = false;
+        this.pauseExpansionForVisibility();
         this.stopRenderLoop();
         this.viewer.scene.requestRender();
     }
     flyTo(options = {}) {
         if (this.destroyed)
             return;
+        if (this.activeCameraFollowGeneration !== null) {
+            this.cameraFollowCancelledByUser = true;
+            this.stopExpansionCameraFollow(true);
+        }
         const center = this.getOriginCartesian();
         const radius = Math.max(this.options.radiusMeters, this.options.lengthMeters);
         this.viewer.camera.flyToBoundingSphere(new BoundingSphere(center, radius), {
@@ -3189,12 +3303,15 @@ export class ScanConeEffect {
     destroy() {
         if (this.destroyed)
             return;
+        this.stopExpansionCameraFollow(true);
         this.destroyed = true;
         this.stopRenderLoop();
+        this.removeConePrimitive();
         this.dataSource.entities.removeAll();
         this.coneEntity = null;
         this.originEntity = null;
         this.material = null;
+        this.primitiveMaterial = null;
         this.viewer.dataSources.remove(this.dataSource, true);
         this.viewer.scene.requestRender();
     }
@@ -3208,9 +3325,11 @@ export class ScanConeEffect {
         return {
             ...this.options,
             center: { ...this.options.center },
+            ...(this.options.expansion ? { expansion: { ...this.options.expansion } } : {}),
         };
     }
     renderEntities() {
+        this.removeConePrimitive();
         clearEntities(this.dataSource);
         this.originEntity = null;
         this.material = createScanConeMaterialProperty(this.options);
@@ -3230,14 +3349,48 @@ export class ScanConeEffect {
         });
         this.syncOriginEntity();
     }
+    renderCurrentPath() {
+        if (this.options.expansion)
+            this.renderPrimitive();
+        else
+            this.renderEntities();
+    }
+    renderPrimitive() {
+        clearEntities(this.dataSource);
+        this.coneEntity = null;
+        this.originEntity = null;
+        this.material = null;
+        this.removeConePrimitive();
+        registerScanConeMaterial();
+        this.primitiveMaterial = Material.fromType(GEO_SCAN_CONE_MATERIAL_TYPE, createScanConeMaterialUniforms(this.options));
+        this.conePrimitive = this.viewer.scene.primitives.add(new Primitive({
+            geometryInstances: new GeometryInstance({
+                id: 'geo-effect-kit-scan-cone-volume',
+                geometry: new CylinderGeometry({
+                    length: 1,
+                    topRadius: 0,
+                    bottomRadius: 1,
+                    slices: 128,
+                    vertexFormat: MaterialAppearance.MaterialSupport.TEXTURED.vertexFormat,
+                }),
+            }),
+            appearance: new MaterialAppearance({
+                material: this.primitiveMaterial,
+                translucent: true,
+                closed: false,
+                faceForward: true,
+            }),
+            asynchronous: false,
+            modelMatrix: this.createPrimitiveModelMatrix(getAnimationSeconds()),
+            show: this.options.visible,
+        }));
+        this.syncOriginEntity();
+    }
     applyMaterialOptions() {
-        if (!this.material)
-            return;
-        this.material.uniforms.color = Color.fromCssColorString(this.options.color).withAlpha(1);
-        this.material.uniforms.opacity = this.options.opacity;
-        this.material.uniforms.speed = this.options.speed;
-        this.material.uniforms.coneType = getScanConeTypeUniform(this.options.type);
-        this.material.uniforms.aperture = this.options.aperture;
+        if (this.material)
+            applyScanConeMaterialUniforms(this.material.uniforms, this.options);
+        if (this.primitiveMaterial)
+            applyScanConeMaterialUniforms(this.primitiveMaterial.uniforms, this.options);
     }
     syncOriginEntity() {
         if (!this.options.showOrigin) {
@@ -3267,8 +3420,8 @@ export class ScanConeEffect {
         if (this.originEntity.point)
             this.originEntity.point.color = new ConstantProperty(color);
     }
-    getOriginCartesian() {
-        return Cartesian3.fromDegrees(this.options.center.longitude, this.options.center.latitude, this.options.center.height ?? 0);
+    getOriginCartesian(result) {
+        return Cartesian3.fromDegrees(this.options.center.longitude, this.options.center.latitude, this.options.center.height ?? 0, undefined, result);
     }
     getConeCenterCartesian() {
         return Cartesian3.fromDegrees(this.options.center.longitude, this.options.center.latitude, (this.options.center.height ?? 0) + this.options.lengthMeters / 2);
@@ -3281,13 +3434,32 @@ export class ScanConeEffect {
     startRenderLoop() {
         if (this.renderFrame || !this.options.visible || typeof window === 'undefined')
             return;
-        const tick = () => {
+        const tick = (timestamp) => {
+            this.renderFrame = 0;
             if (this.destroyed || !this.options.visible) {
-                this.renderFrame = 0;
                 return;
             }
-            this.viewer.scene.requestRender();
-            this.renderFrame = window.requestAnimationFrame(tick);
+            try {
+                const animationSeconds = Number.isFinite(timestamp) ? timestamp / 1000 : 0;
+                if (this.primitiveMaterial)
+                    this.primitiveMaterial.uniforms.timeSeconds = animationSeconds;
+                const modelMatrixUpdated = this.advanceExpansion(timestamp);
+                if (this.destroyed || !this.options.visible)
+                    return;
+                if (this.conePrimitive && !modelMatrixUpdated)
+                    this.updatePrimitiveModelMatrix(animationSeconds);
+            }
+            finally {
+                if (!this.destroyed && this.options.visible) {
+                    try {
+                        this.viewer.scene.requestRender();
+                    }
+                    finally {
+                        if (!this.renderFrame)
+                            this.renderFrame = window.requestAnimationFrame(tick);
+                    }
+                }
+            }
         };
         this.renderFrame = window.requestAnimationFrame(tick);
     }
@@ -3299,6 +3471,210 @@ export class ScanConeEffect {
         window.cancelAnimationFrame(this.renderFrame);
         this.renderFrame = 0;
     }
+    resetExpansionState() {
+        if (!this.options.expansion) {
+            this.expansionState = createInitialScanConeExpansionState('idle');
+            this.expansionPreviousTimestamp = null;
+            this.pausedByVisibility = false;
+            this.completionNotified = false;
+            return;
+        }
+        const shouldRun = this.options.expansion.autoStart;
+        this.expansionState = createInitialScanConeExpansionState(shouldRun ? (this.options.visible ? 'running' : 'paused') : 'idle');
+        this.expansionPreviousTimestamp = null;
+        this.pausedByVisibility = shouldRun && !this.options.visible;
+        this.completionNotified = false;
+    }
+    advanceExpansion(timestamp) {
+        const expansion = this.options.expansion;
+        if (!expansion || this.expansionState.status !== 'running')
+            return false;
+        const safeTimestamp = Number.isFinite(timestamp) ? timestamp : 0;
+        const previousTimestamp = this.expansionPreviousTimestamp;
+        const elapsedDelta = previousTimestamp === null ? 0 : Math.max(0, safeTimestamp - previousTimestamp);
+        this.expansionPreviousTimestamp = previousTimestamp === null
+            ? safeTimestamp
+            : Math.max(previousTimestamp, safeTimestamp);
+        const frame = sampleScanConeExpansionFrame(expansion, this.options.lengthMeters, this.expansionState.elapsedMs + elapsedDelta);
+        const completed = frame.elapsedMs >= expansion.durationMs;
+        this.expansionState = {
+            ...frame,
+            status: completed ? 'completed' : 'running',
+        };
+        this.updatePrimitiveModelMatrix(safeTimestamp / 1000);
+        const callbackState = { ...this.expansionState };
+        const notifyCompletion = completed && !this.completionNotified;
+        if (notifyCompletion)
+            this.completionNotified = true;
+        if (completed)
+            this.detachCameraFollowListeners();
+        try {
+            expansion.onFrame?.(callbackState);
+        }
+        finally {
+            if (!this.destroyed && notifyCompletion)
+                expansion.onComplete?.({ ...callbackState });
+        }
+        return true;
+    }
+    pauseExpansionForVisibility() {
+        if (!this.options.expansion || this.expansionState.status !== 'running')
+            return;
+        this.expansionState = { ...this.expansionState, status: 'paused' };
+        this.expansionPreviousTimestamp = null;
+        this.pausedByVisibility = true;
+        this.stopExpansionCameraFollow(true);
+        this.cameraFollowPlanned = false;
+    }
+    resumeExpansionAfterVisibilityPause() {
+        if (!this.options.expansion || this.expansionState.status !== 'paused' || !this.pausedByVisibility)
+            return;
+        this.expansionState = { ...this.expansionState, status: 'running' };
+        this.expansionPreviousTimestamp = null;
+        this.pausedByVisibility = false;
+        this.startExpansionCameraFollow(this.getExpansionRemainingDurationMs());
+    }
+    getExpansionRemainingDurationMs() {
+        if (!this.options.expansion)
+            return 0;
+        return Math.max(0, this.options.expansion.durationMs - this.expansionState.elapsedMs);
+    }
+    startExpansionCameraFollow(durationMs) {
+        const expansion = this.options.expansion;
+        if (!expansion?.cameraFollow ||
+            !this.options.visible ||
+            this.expansionState.status !== 'running' ||
+            this.cameraFollowPlanned ||
+            this.cameraFollowCancelledByUser ||
+            durationMs <= 0)
+            return;
+        this.cameraFollowPlanned = true;
+        const camera = this.viewer.camera;
+        let sphere;
+        let visibility;
+        try {
+            sphere = this.createFinalExpansionBoundingSphere(durationMs);
+            const position = camera.positionWC ?? camera.position;
+            const direction = camera.directionWC ?? camera.direction;
+            const up = camera.upWC ?? camera.up;
+            visibility = camera.frustum
+                .computeCullingVolume(position, direction, up)
+                .computeVisibility(sphere);
+        }
+        catch {
+            return;
+        }
+        if (visibility === Intersect.INSIDE)
+            return;
+        const heading = Number.isFinite(camera.heading) ? camera.heading : 0;
+        const pitch = Number.isFinite(camera.pitch)
+            ? clamp(camera.pitch, -CesiumMath.PI_OVER_TWO + 0.01, CesiumMath.PI_OVER_TWO - 0.01)
+            : -CesiumMath.PI_OVER_FOUR;
+        const framedSphere = new BoundingSphere(sphere.center, sphere.radius * 1.18);
+        const generation = ++this.cameraFollowGeneration;
+        this.activeCameraFollowGeneration = generation;
+        this.attachCameraFollowListeners();
+        try {
+            camera.flyToBoundingSphere(framedSphere, {
+                duration: durationMs / 1000,
+                offset: new HeadingPitchRange(heading, pitch, 0),
+                complete: () => this.releaseExpansionCameraFollow(generation),
+                cancel: () => this.handleExpansionCameraFollowCancelled(generation),
+            });
+        }
+        catch {
+            this.releaseExpansionCameraFollow(generation);
+        }
+    }
+    createFinalExpansionBoundingSphere(durationMs) {
+        const expansion = this.options.expansion;
+        const radius = expansion?.maxRadiusMeters ?? this.options.radiusMeters;
+        const length = this.options.lengthMeters;
+        const finalHeading = this.options.heading +
+            (getAnimationSeconds() + durationMs / 1000) * this.options.speed * 36;
+        const headingPitchRoll = HeadingPitchRoll.fromDegrees(finalHeading, this.options.pitch, 0);
+        const transform = Transforms.headingPitchRollToFixedFrame(this.getOriginCartesian(), headingPitchRoll);
+        const localCenter = new Cartesian3(0, 0, length / 2);
+        const center = Matrix4.multiplyByPoint(transform, localCenter, new Cartesian3());
+        return new BoundingSphere(center, Math.hypot(radius, length / 2));
+    }
+    attachCameraFollowListeners() {
+        if (this.cameraFollowListenersAttached)
+            return;
+        this.cameraFollowListenersAttached = true;
+        this.viewer.canvas.addEventListener('pointerdown', this.handleCameraFollowUserInput);
+        this.viewer.canvas.addEventListener('wheel', this.handleCameraFollowUserInput);
+        this.viewer.canvas.addEventListener('touchstart', this.handleCameraFollowUserInput);
+    }
+    stopExpansionCameraFollow(cancelFlight) {
+        const generation = this.activeCameraFollowGeneration;
+        if (generation === null) {
+            this.detachCameraFollowListeners();
+            return;
+        }
+        if (!cancelFlight) {
+            this.releaseExpansionCameraFollow(generation);
+            return;
+        }
+        this.internallyCancellingCameraFollowGeneration = generation;
+        try {
+            this.viewer.camera.cancelFlight();
+        }
+        catch {
+            // Camera follow is optional; camera failures must not stop the effect lifecycle.
+        }
+        finally {
+            this.releaseExpansionCameraFollow(generation);
+            if (this.internallyCancellingCameraFollowGeneration === generation) {
+                this.internallyCancellingCameraFollowGeneration = null;
+            }
+        }
+    }
+    handleExpansionCameraFollowCancelled(generation) {
+        if (this.activeCameraFollowGeneration !== generation)
+            return;
+        if (this.internallyCancellingCameraFollowGeneration !== generation) {
+            this.cameraFollowCancelledByUser = true;
+        }
+        this.releaseExpansionCameraFollow(generation);
+    }
+    releaseExpansionCameraFollow(generation) {
+        if (this.activeCameraFollowGeneration !== generation)
+            return;
+        this.activeCameraFollowGeneration = null;
+        this.detachCameraFollowListeners();
+    }
+    detachCameraFollowListeners() {
+        if (!this.cameraFollowListenersAttached)
+            return;
+        this.viewer.canvas.removeEventListener('pointerdown', this.handleCameraFollowUserInput);
+        this.viewer.canvas.removeEventListener('wheel', this.handleCameraFollowUserInput);
+        this.viewer.canvas.removeEventListener('touchstart', this.handleCameraFollowUserInput);
+        this.cameraFollowListenersAttached = false;
+    }
+    createPrimitiveModelMatrix(animationSeconds, result = this.primitiveModelMatrixScratch) {
+        const heading = this.options.heading + animationSeconds * this.options.speed * 36;
+        HeadingPitchRoll.fromDegrees(heading, this.options.pitch, 0, this.primitiveHeadingPitchRollScratch);
+        Transforms.headingPitchRollToFixedFrame(this.getOriginCartesian(this.primitiveOriginScratch), this.primitiveHeadingPitchRollScratch, undefined, undefined, result);
+        const radius = Math.max(0.000001, this.expansionState.radiusMeters);
+        const length = Math.max(0.000001, this.expansionState.lengthMeters);
+        Cartesian3.fromElements(0, 0, length / 2, this.primitiveTranslationScratch);
+        Cartesian3.fromElements(radius, radius, length, this.primitiveScaleScratch);
+        Matrix4.multiplyByTranslation(result, this.primitiveTranslationScratch, result);
+        return Matrix4.multiplyByScale(result, this.primitiveScaleScratch, result);
+    }
+    updatePrimitiveModelMatrix(animationSeconds) {
+        if (!this.conePrimitive)
+            return;
+        this.createPrimitiveModelMatrix(animationSeconds, this.conePrimitive.modelMatrix);
+    }
+    removeConePrimitive() {
+        if (!this.conePrimitive)
+            return;
+        this.viewer.scene.primitives.remove(this.conePrimitive);
+        this.conePrimitive = null;
+        this.primitiveMaterial = null;
+    }
 }
 export class ShieldDomeEffect {
     viewer;
@@ -3635,14 +4011,21 @@ function createLightWallMaterialProperty(options) {
 export function createScanConeMaterialProperty(options) {
     const normalized = normalizeScanConeOptions(options);
     registerScanConeMaterial();
-    return new DynamicCesiumMaterialProperty(GEO_SCAN_CONE_MATERIAL_TYPE, {
-        color: Color.fromCssColorString(normalized.color).withAlpha(1),
-        opacity: normalized.opacity,
-        speed: normalized.speed,
-        timeSeconds: -1,
-        coneType: getScanConeTypeUniform(normalized.type),
-        aperture: normalized.aperture,
-    });
+    return new DynamicCesiumMaterialProperty(GEO_SCAN_CONE_MATERIAL_TYPE, createScanConeMaterialUniforms(normalized));
+}
+function createScanConeMaterialUniforms(options, timeSeconds = -1) {
+    return {
+        color: Color.fromCssColorString(options.color).withAlpha(1),
+        opacity: options.opacity,
+        speed: options.speed,
+        timeSeconds,
+        coneType: getScanConeTypeUniform(options.type),
+        aperture: options.aperture,
+    };
+}
+function applyScanConeMaterialUniforms(uniforms, options) {
+    const timeSeconds = typeof uniforms.timeSeconds === 'number' ? uniforms.timeSeconds : -1;
+    Object.assign(uniforms, createScanConeMaterialUniforms(options, timeSeconds));
 }
 function createShieldDomeMaterialProperty(options) {
     registerShieldDomeMaterial();
@@ -3997,6 +4380,15 @@ function getConeBottomRadius(options) {
     const apertureRadius = Math.tan(CesiumMath.toRadians(options.aperture) / 2) * options.lengthMeters;
     return Math.max(options.radiusMeters, apertureRadius);
 }
+function createInitialScanConeExpansionState(status) {
+    return {
+        status,
+        progress: 0,
+        radiusMeters: 0,
+        lengthMeters: 0,
+        elapsedMs: 0,
+    };
+}
 function normalizePositions(positions, close) {
     const normalized = (positions.length ? positions : [{ longitude: 0, latitude: 0 }]).map(normalizePosition);
     const onlyPosition = normalized[0];