@reearth/core 0.0.1

package/src/engines/Cesium/index.stories.tsx

@@ -0,0 +1,42 @@
+import { Meta, StoryFn } from "@storybook/react";
+
+import { Map, Props } from "../../Map";
+
+import { engine } from ".";
+
+export default {
+  component: Map,
+  parameters: { actions: { argTypesRegex: "^on.*" } },
+} as Meta;
+
+const Template: StoryFn<Props> = args => <Map {...args} />;
+
+export const Default = Template.bind([]);
+Default.args = {
+  engine: "cesium",
+  engines: {
+    cesium: engine,
+  },
+  ready: true,
+  layers: [
+    {
+      id: "l",
+      type: "simple",
+      data: {
+        type: "geojson",
+        value: { type: "Feature", geometry: { type: "Point", coordinates: [0, 0] } },
+      },
+      marker: {
+        imageColor: "#fff",
+      },
+    },
+  ],
+  property: {
+    tiles: [
+      {
+        id: "default",
+        tile_type: "default",
+      },
+    ],
+  },
+};

package/src/engines/Cesium/index.tsx

@@ -0,0 +1,285 @@
+import { ArcType, Color, KeyboardEventModifier, ScreenSpaceEventType } from "cesium";
+import React, { forwardRef } from "react";
+import {
+  Viewer,
+  Fog,
+  Sun,
+  SkyAtmosphere,
+  Scene,
+  SkyBox,
+  Camera,
+  ScreenSpaceEventHandler,
+  ScreenSpaceEvent,
+  ScreenSpaceCameraController,
+  Entity,
+  PolylineGraphics,
+  Moon,
+} from "resium";
+
+import type { Engine, EngineProps, EngineRef } from "..";
+
+import Cluster from "./Cluster";
+import Clock from "./core/Clock";
+import Globe from "./core/Globe";
+import ImageryLayers from "./core/Imagery";
+import Indicator from "./core/Indicator/Indicator";
+import LabelImageryLayers from "./core/labels/LabelImageryLayers";
+import Event from "./Event";
+import Feature, { context as featureContext } from "./Feature";
+import useHooks from "./hooks";
+import { AmbientOcclusion, AmbientOcclusionOutputType } from "./PostProcesses/hbao";
+import { AMBIENT_OCCLUSION_QUALITY } from "./PostProcesses/hbao/config";
+import Sketch from "./Sketch";
+
+const Cesium: React.ForwardRefRenderFunction<EngineRef, EngineProps> = (
+  {
+    className,
+    style,
+    property,
+    camera,
+    small,
+    ready,
+    children,
+    selectedLayerId,
+    isLayerDraggable,
+    isLayerDragging,
+    shouldRender,
+    layerSelectionReason,
+    meta,
+    layersRef,
+    featureFlags,
+    requestingRenderMode,
+    timelineManagerRef,
+    cameraForceHorizontalRoll,
+    onLayerSelect,
+    onCameraChange,
+    onLayerDrag,
+    onLayerDrop,
+    onLayerEdit,
+    onLayerSelectWithRectStart,
+    onLayerSelectWithRectMove,
+    onLayerSelectWithRectEnd,
+    onMount,
+    onLayerVisibility,
+    onLayerLoad,
+  },
+  ref,
+) => {
+  const {
+    backgroundColor,
+    cesium,
+    cameraViewBoundaries,
+    cameraViewOuterBoundaries,
+    cameraViewBoundariesMaterial,
+    mouseEventHandles,
+    cesiumIonAccessToken,
+    context,
+    light,
+    layerSelectWithRectEventHandlers,
+    handleMount,
+    handleUnmount,
+    handleUpdate,
+    handleClick,
+    handleCameraChange,
+    handleCameraMoveEnd,
+  } = useHooks({
+    ref,
+    property,
+    camera,
+    selectedLayerId,
+    selectionReason: layerSelectionReason,
+    isLayerDraggable,
+    isLayerDragging,
+    meta,
+    layersRef,
+    featureFlags,
+    requestingRenderMode,
+    shouldRender,
+    timelineManagerRef,
+    cameraForceHorizontalRoll,
+    onLayerSelect,
+    onCameraChange,
+    onLayerDrag,
+    onLayerDrop,
+    onLayerEdit,
+    onLayerSelectWithRectStart,
+    onLayerSelectWithRectMove,
+    onLayerSelectWithRectEnd,
+    onMount,
+    onLayerVisibility,
+    onLayerLoad,
+  });
+
+  return (
+    <Viewer
+      ref={cesium}
+      onUpdate={handleUpdate}
+      className={className}
+      requestRenderMode={true}
+      animation={false}
+      timeline={false}
+      // NOTE: We need to update cesium ion token dynamically.
+      // To replace old imagery provider, we need to remove old imagery provider.
+      baseLayer={false}
+      fullscreenButton={false}
+      homeButton={false}
+      geocoder={false}
+      infoBox={false}
+      baseLayerPicker={false}
+      navigationHelpButton={false}
+      projectionPicker={false}
+      sceneModePicker={false}
+      creditContainer={creditContainer}
+      style={{
+        width: small ? "300px" : "auto",
+        height: small ? "300px" : "100%",
+        display: ready ? undefined : "none",
+        cursor: isLayerDragging ? "grab" : undefined,
+        ...style,
+      }}
+      shadows={!!(property?.atmosphere?.shadows ?? property?.globeShadow?.globeShadow)}
+      onClick={handleClick}
+      onDoubleClick={mouseEventHandles.doubleclick}
+      onMouseDown={mouseEventHandles.mousedown}
+      onMouseUp={mouseEventHandles.mouseup}
+      onRightClick={mouseEventHandles.rightclick}
+      onRightDown={mouseEventHandles.rightdown}
+      onRightUp={mouseEventHandles.rightup}
+      onMiddleClick={mouseEventHandles.middleclick}
+      onMiddleDown={mouseEventHandles.middledown}
+      onMiddleUp={mouseEventHandles.middleup}
+      onMouseMove={mouseEventHandles.mousemove}
+      onMouseEnter={mouseEventHandles.mouseenter}
+      onMouseLeave={mouseEventHandles.mouseleave}
+      onWheel={mouseEventHandles.wheel}>
+      <Event onMount={handleMount} onUnmount={handleUnmount} />
+      <Clock timelineManagerRef={timelineManagerRef} />
+      <ImageryLayers tiles={property?.tiles} cesiumIonAccessToken={cesiumIonAccessToken} />
+      <LabelImageryLayers tileLabels={property?.tileLabels} />
+      <Indicator property={property} timelineManagerRef={timelineManagerRef} />
+      <ScreenSpaceEventHandler useDefault>
+        {/* remove default click event */}
+        <ScreenSpaceEvent type={ScreenSpaceEventType.LEFT_CLICK} />
+        {/* remove default double click event */}
+        <ScreenSpaceEvent type={ScreenSpaceEventType.LEFT_DOUBLE_CLICK} />
+      </ScreenSpaceEventHandler>
+
+      {/* For LayerSelectWithRect event */}
+      <ScreenSpaceEventHandler>
+        <ScreenSpaceEvent
+          type={ScreenSpaceEventType.LEFT_DOWN}
+          action={layerSelectWithRectEventHandlers.start.handler}
+        />
+        <ScreenSpaceEvent
+          type={ScreenSpaceEventType.LEFT_DOWN}
+          modifier={KeyboardEventModifier.SHIFT}
+          action={layerSelectWithRectEventHandlers.start.shift}
+        />
+        <ScreenSpaceEvent
+          type={ScreenSpaceEventType.MOUSE_MOVE}
+          action={layerSelectWithRectEventHandlers.move.handler}
+        />
+        <ScreenSpaceEvent
+          type={ScreenSpaceEventType.MOUSE_MOVE}
+          modifier={KeyboardEventModifier.SHIFT}
+          action={layerSelectWithRectEventHandlers.move.shift}
+        />
+        <ScreenSpaceEvent
+          type={ScreenSpaceEventType.LEFT_UP}
+          action={layerSelectWithRectEventHandlers.end.handler}
+        />
+        <ScreenSpaceEvent
+          type={ScreenSpaceEventType.LEFT_UP}
+          modifier={KeyboardEventModifier.SHIFT}
+          action={layerSelectWithRectEventHandlers.end.shift}
+        />
+      </ScreenSpaceEventHandler>
+      <ScreenSpaceCameraController
+        maximumZoomDistance={
+          property?.cameraLimiter?.cameraLimitterEnabled
+            ? property.cameraLimiter?.cameraLimitterTargetArea?.height ?? Number.POSITIVE_INFINITY
+            : Number.POSITIVE_INFINITY
+        }
+        enableCollisionDetection={
+          !(property?.default?.allowEnterGround ?? property?.camera?.allowEnterGround)
+        }
+      />
+      <Camera
+        onChange={handleCameraChange}
+        percentageChanged={0.2}
+        onMoveEnd={handleCameraMoveEnd}
+      />
+      {cameraViewBoundaries && property?.cameraLimiter?.cameraLimitterShowHelper && (
+        <Entity>
+          <PolylineGraphics
+            positions={cameraViewBoundaries}
+            width={1}
+            material={Color.RED}
+            arcType={ArcType.RHUMB}
+          />
+        </Entity>
+      )}
+      {cameraViewOuterBoundaries && property?.cameraLimiter?.cameraLimitterShowHelper && (
+        <Entity>
+          <PolylineGraphics
+            positions={cameraViewOuterBoundaries}
+            width={1}
+            material={cameraViewBoundariesMaterial}
+            arcType={ArcType.RHUMB}
+          />
+        </Entity>
+      )}
+      {/* NOTE: useWebVR={false} will crash Cesium */}
+      <Scene
+        backgroundColor={backgroundColor}
+        useWebVR={!!property?.default?.vr || undefined}
+        light={light}
+        useDepthPicking={false}
+        debugShowFramesPerSecond={!!property?.render?.debugFramePerSecond}
+        verticalExaggerationRelativeHeight={property?.terrain?.terrainExaggerationRelativeHeight}
+        verticalExaggeration={property?.terrain?.terrainExaggeration}
+      />
+      <SkyBox show={property?.default?.skybox ?? property?.skyBox?.skyBox ?? true} />
+      <Fog
+        enabled={property?.atmosphere?.fog ?? true}
+        density={property?.atmosphere?.fog_density}
+      />
+      <Sun show={property?.atmosphere?.enable_sun ?? property?.sun?.sun ?? true} />
+      <Moon show={property?.atmosphere?.enableMoon ?? property?.moon?.moon ?? true} />
+      <SkyAtmosphere
+        show={
+          property?.atmosphere?.sky_atmosphere ?? property?.skyAtmosphere?.skyAtmosphere ?? true
+        }
+        saturationShift={property?.atmosphere?.skyboxSurturationShift}
+        atmosphereLightIntensity={property?.skyAtmosphere?.skyAtmosphereIntensity}
+        brightnessShift={property?.atmosphere?.skyboxBrightnessShift}
+      />
+      <Globe property={property} cesiumIonAccessToken={cesiumIonAccessToken} />
+      <featureContext.Provider value={context}>{ready ? children : null}</featureContext.Provider>
+      <AmbientOcclusion
+        {...AMBIENT_OCCLUSION_QUALITY[property?.ambientOcclusion?.quality || "low"]}
+        enabled={!!property?.ambientOcclusion?.enabled}
+        intensity={property?.ambientOcclusion?.intensity ?? 100}
+        outputType={
+          property?.ambientOcclusion?.ambientOcclusionOnly
+            ? AmbientOcclusionOutputType.Occlusion
+            : null
+        }
+      />
+    </Viewer>
+  );
+};
+
+const creditContainer = document.createElement("div");
+
+const Component = forwardRef(Cesium);
+
+export default Component;
+
+export const engine: Engine = {
+  component: Component,
+  featureComponent: Feature,
+  clusterComponent: Cluster,
+  sketchComponent: Sketch,
+  delegatedDataTypes: ["czml", "wms", "mvt", "3dtiles", "osm-buildings", "kml"],
+};

package/src/engines/Cesium/pickMany.ts

@@ -0,0 +1,310 @@
+import { SceneTransforms, type Scene } from "@cesium/engine";
+import Cesium3DTilePass from "@cesium/engine/Source/Scene/Cesium3DTilePass";
+import Cesium3DTilePassState from "@cesium/engine/Source/Scene/Cesium3DTilePassState";
+import {
+  BoundingRectangle,
+  Cartesian2,
+  Color,
+  PerspectiveFrustum,
+  PerspectiveOffCenterFrustum,
+  type CullingVolume,
+  Viewer,
+} from "cesium";
+import invariant from "tiny-invariant";
+
+import { ComputedFeature } from "../../Map";
+import { assertType } from "../../utils";
+
+import { convertObjToComputedFeature, getPixelRatio } from "./utils/utils";
+
+declare module "@cesium/engine" {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace SceneTransforms {
+    function transformWindowToDrawingBuffer(
+      scene: Scene,
+      windowPosition: Cartesian2,
+      result?: Cartesian2,
+    ): Cartesian2;
+  }
+}
+
+interface ReadState {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  framebuffer: unknown;
+}
+
+interface PickFramebuffer {
+  _fb: {
+    framebuffer: unknown;
+  };
+  _context: {
+    readPixels: (readState: ReadState) => Uint8Array;
+    getObjectByPickColor: (color: Color) => unknown | undefined;
+  };
+  begin: (screenSpaceRectangle: BoundingRectangle, viewport: BoundingRectangle) => PassState;
+  end: (screenSpaceRectangle: BoundingRectangle) => unknown | undefined;
+}
+
+interface PassState {
+  viewport: BoundingRectangle;
+}
+
+interface FrameState {
+  passes: {
+    pick: boolean;
+  };
+  cullingVolume?: CullingVolume;
+  invertClassification: boolean;
+  tilesetPassState?: PassState;
+}
+
+interface UniformState {
+  update: (frameState: FrameState) => void;
+}
+
+interface Context {
+  uniformState: UniformState;
+  drawingBufferWidth: number;
+  drawingBufferHeight: number;
+  endFrame: () => void;
+}
+
+interface JobScheduler {
+  disableThisFrame: () => void;
+}
+
+interface View {
+  viewport: BoundingRectangle;
+  passState: PassState;
+  pickFramebuffer: PickFramebuffer;
+}
+
+interface PrivateScene extends Scene {
+  view: View;
+  defaultView: View;
+  jobScheduler: JobScheduler;
+  frameState: FrameState;
+  context: Context;
+  updateFrameState: () => void;
+  updateEnvironment: () => void;
+  updateAndExecuteCommands: (passState: PassState, backgroundColor: Color) => void;
+  resolveFramebuffers: (passState: PassState) => void;
+}
+
+const colorScratch = new Color();
+
+// Derived from: https://github.com/CesiumGS/cesium/blob/1.105/packages/engine/Source/Scene/PickFramebuffer.js#L54
+// Picks multiple objects in the given rectangle.
+function pickFramebufferEnd(
+  this: PickFramebuffer,
+  screenSpaceRectangle: BoundingRectangle,
+): object[] {
+  const width = screenSpaceRectangle.width ?? 1;
+  const height = screenSpaceRectangle.height ?? 1;
+  const context = this._context;
+  const pixels = context.readPixels({
+    x: screenSpaceRectangle.x,
+    y: screenSpaceRectangle.y,
+    width,
+    height,
+    framebuffer: this._fb.framebuffer,
+  });
+
+  // TODO: Why this assertion fails, even if the format is RGBA and data type
+  // is unsigned bytes?
+  // invariant(pixels.length % 4 === 0)
+
+  // I don't know why Cesium doesn't provide this functionality but reads pixels
+  // in spiral to find only a single object. Precision issue maybe?
+  const objects = new Set<object>();
+  for (let index = 0; index < pixels.length; index += 4) {
+    try {
+      colorScratch.red = Color.byteToFloat(pixels[index]);
+      colorScratch.green = Color.byteToFloat(pixels[index + 1]);
+      colorScratch.blue = Color.byteToFloat(pixels[index + 2]);
+      colorScratch.alpha = Color.byteToFloat(pixels[index + 3]);
+      const object = context.getObjectByPickColor(colorScratch);
+      if (object != null) {
+        objects.add(object);
+      }
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  return Array.from(objects.values());
+}
+
+const pickingFrustumScratch = new PerspectiveOffCenterFrustum();
+const pixelSizeScratch = new Cartesian2();
+
+// Derived from: https://github.com/CesiumGS/cesium/blob/1.105/packages/engine/Source/Scene/Picking.js#L197
+// Changes are in the comments below.
+function getPickCullingVolume(
+  scene: Scene,
+  drawingBufferPosition: Cartesian2,
+  width: number,
+  height: number,
+  viewport: BoundingRectangle,
+): CullingVolume {
+  const camera = scene.camera;
+  const frustum = camera.frustum;
+  invariant(frustum instanceof PerspectiveFrustum);
+
+  const near = frustum.near;
+  const tanPhi = Math.tan(frustum.fovy / 2);
+  const tanTheta = frustum.aspectRatio * tanPhi;
+
+  const bx = drawingBufferPosition.x;
+  const by = drawingBufferPosition.y;
+  const x = (2 * (bx - viewport.x)) / viewport.width - 1;
+  const y = (2 * (viewport.height - by - viewport.y)) / viewport.height - 1;
+  const xDir = x * near * tanTheta;
+  const yDir = y * near * tanPhi;
+
+  const pixelSize = frustum.getPixelDimensions(
+    viewport.width,
+    viewport.height,
+    near, // Changed from 1
+    getPixelRatio(scene), // Changed from 1
+    pixelSizeScratch,
+  );
+  const pickWidth = (pixelSize.x * width) / 2;
+  const pickHeight = (pixelSize.y * height) / 2;
+
+  const offCenter = pickingFrustumScratch;
+  offCenter.top = yDir + pickHeight;
+  offCenter.bottom = yDir - pickHeight;
+  offCenter.right = xDir + pickWidth;
+  offCenter.left = xDir - pickWidth;
+  offCenter.near = near;
+  offCenter.far = frustum.far;
+
+  return offCenter.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
+}
+
+function getIntersection(
+  a: BoundingRectangle,
+  b: BoundingRectangle,
+  result = new BoundingRectangle(),
+): BoundingRectangle | undefined {
+  invariant(a.width >= 0 && a.height >= 0);
+  invariant(b.width >= 0 && b.height >= 0);
+  const x1 = Math.max(a.x, b.x);
+  const x2 = Math.min(a.x + a.width, b.x + b.width);
+  const y1 = Math.max(a.y, b.y);
+  const y2 = Math.min(a.y + a.height, b.y + b.height);
+  if (x1 >= x2 || y1 >= y2) {
+    return undefined;
+  }
+  result.x = x1;
+  result.y = y1;
+  result.width = x2 - x1;
+  result.height = y2 - y1;
+  return result.clone(new BoundingRectangle());
+}
+
+const pickTilesetPassState = new Cesium3DTilePassState({
+  pass: Cesium3DTilePass.PICK,
+});
+const zeroColor = new Color(0, 0, 0, 0);
+const positionScratch = new Cartesian2();
+const rectangleScratch = new BoundingRectangle();
+
+// Derived from: https://github.com/CesiumGS/cesium/blob/1.105/packages/engine/Source/Scene/Picking.js#L239
+// Changes are in the comments below.
+function pickManyFromViewport(
+  scene: Scene,
+  windowPosition: Cartesian2,
+  windowWidth: number,
+  windowHeight: number,
+): object[] {
+  const showGroundPrimitives = scene.groundPrimitives.show;
+  scene.groundPrimitives.show = false;
+  invariant(windowWidth > 0 && windowHeight > 0);
+  assertType<PrivateScene>(scene);
+  const context = scene.context;
+  const view = scene.defaultView;
+  scene.view = view;
+
+  const viewport = view.viewport;
+  viewport.x = 0;
+  viewport.y = 0;
+  viewport.width = context.drawingBufferWidth;
+  viewport.height = context.drawingBufferHeight;
+  view.passState.viewport = BoundingRectangle.clone(viewport, view.passState.viewport);
+
+  scene.jobScheduler.disableThisFrame();
+  scene.updateFrameState();
+
+  // Drawing buffer coordinates are scaled by pixel ratio, so do we scale width
+  // and height which are supposed to be window coordinates.
+  const position = SceneTransforms.transformWindowToDrawingBuffer(
+    scene,
+    windowPosition,
+    positionScratch,
+  );
+  const pixelRatio = getPixelRatio(scene);
+  const width = windowWidth * pixelRatio;
+  const height = windowHeight * pixelRatio;
+  const frameState = scene.frameState;
+  frameState.cullingVolume = getPickCullingVolume(scene, position, width, height, viewport);
+  frameState.invertClassification = false;
+  frameState.passes.pick = true;
+  frameState.tilesetPassState = pickTilesetPassState;
+  context.uniformState.update(frameState);
+  scene.updateEnvironment();
+
+  // In the original code, width and height are offset by one. I don't know why
+  // because they are not normalized coordinates.
+  rectangleScratch.x = position.x - width / 2;
+  rectangleScratch.y = scene.drawingBufferHeight - position.y - height / 2;
+  rectangleScratch.height = height;
+  rectangleScratch.width = width;
+  const intersection = getIntersection(rectangleScratch, view.viewport, rectangleScratch);
+  invariant(intersection != null);
+  const passState = view.pickFramebuffer.begin(intersection, view.viewport);
+
+  scene.updateAndExecuteCommands(passState, zeroColor);
+  scene.resolveFramebuffers(passState);
+
+  // Use our pickFramebufferEnd instead of PickFramebuffer.pick().
+  const objects = pickFramebufferEnd.apply(view.pickFramebuffer, [rectangleScratch]);
+  context.endFrame();
+
+  scene.groundPrimitives.show = showGroundPrimitives;
+
+  return objects;
+}
+
+export type PickedFeature = ComputedFeature & { layerId?: string };
+
+export const pickManyFromViewportAsFeature = (
+  viewer: Viewer,
+  windowPosition: Cartesian2,
+  windowWidth: number,
+  windowHeight: number,
+  // TODO: Get condition as expression for plugin
+  condition?: (f: PickedFeature) => boolean,
+): PickedFeature[] => {
+  const objs = pickManyFromViewport(
+    viewer.scene as Scene,
+    windowPosition,
+    windowWidth,
+    windowHeight,
+  );
+
+  const result = [];
+  for (const obj of objs) {
+    const [layerId, f] = convertObjToComputedFeature(viewer.clock.currentTime, obj) ?? [];
+    const pickedFeature = f ? { ...f, layerId } : undefined;
+    if (!pickedFeature || (condition && !condition(pickedFeature))) {
+      continue;
+    }
+    result.push(pickedFeature);
+  }
+
+  return result;
+};

package/src/engines/Cesium/type.d.ts

@@ -0,0 +1,47 @@
+// ref: https://github.com/takram-design-engineering/plateau-view/blob/6c8225d626cd8085e5d10ffe8980837814c333b0/types.d.ts
+declare module "@cesium/engine" {
+  export class ShaderSource {
+    sources: string[];
+    defines: string[];
+    constructor(options: { sources: string[]; defines: string[] });
+  }
+
+  // Cesium's type definition is wrong. The parameter type of raiseEvent()
+  // should be (...args: Parameter<Listener>) instead of
+  // (...args: Parameter<Listener>[]).
+  // This cannot be fixed by augmentation but by overloading.
+  export interface Event<Listener extends (...args: any[]) => void = (...args: any[]) => void> {
+    // eslint-disable-next-line @typescript-eslint/method-signature-style
+    raiseEvent(...arguments: Parameters<Listener>): void;
+  }
+
+  // https://github.com/CesiumGS/cesium/blob/1.105/packages/engine/Source/Core/EllipsoidalOccluder.js
+  export class EllipsoidalOccluder {
+    constructor(ellipsoid: Ellipsoid, cameraPosition: Cartesian3);
+
+    readonly ellipsoid: Ellipsoid;
+    cameraPosition: Cartesian3;
+    position: Cartesian3;
+
+    isPointVisible: (occludee: Cartesian3) => boolean;
+  }
+}
+
+declare module "@cesium/engine/Source/Scene/Cesium3DTilePass" {
+  enum Cesium3DTilePass {
+    PICK,
+  }
+  export default Cesium3DTilePass;
+}
+
+declare module "@cesium/engine/Source/Scene/Cesium3DTilePassState" {
+  export default class Cesium3DTilePassState {
+    viewport: BoundingRectangle;
+    constructor(arg: { pass: Cesium3DTilePass });
+  }
+}
+
+declare module "@cesium/engine/Source/Renderer/DrawCommand" {
+  const DrawCommand: () => void;
+  export default DrawCommand;
+}

package/src/engines/Cesium/types.ts

@@ -0,0 +1,24 @@
+import type { ShaderSource } from "@cesium/engine";
+import type {
+  Cesium3DTileContent,
+  Cesium3DTileFeature,
+  Cesium3DTilePointFeature,
+  Globe,
+  Model,
+} from "cesium";
+
+export type InternalCesium3DTileFeature = Cesium3DTileFeature | Cesium3DTilePointFeature | Model;
+export type InternalCesium3DTileContent = Cesium3DTileContent | Model;
+
+export type PrivateCesiumGlobe = Globe & {
+  _surface?: {
+    _tileProvider?: {
+      materialUniformMap?: Record<string, () => unknown>;
+    };
+  };
+  _surfaceShaderSet?: {
+    baseFragmentShaderSource?: ShaderSource;
+  };
+};
+
+export type CursorType = "default" | "auto" | "help" | "pointer" | "grab" | "crosshair";