@reearth/core 0.0.7-alpha.5 → 0.0.7-beta.1

package/src/engines/Cesium/index.tsx

@@ -36,7 +36,6 @@ const Cesium: React.ForwardRefRenderFunction<EngineRef, EngineProps> = (
     className,
     style,
     property,
-    time,
     camera,
     small,
     ready,
@@ -67,51 +66,48 @@ const Cesium: React.ForwardRefRenderFunction<EngineRef, EngineProps> = (
   ref,
 ) => {
   const {
+    backgroundColor,
     cesium,
+    cameraViewBoundaries,
+    cameraViewOuterBoundaries,
+    cameraViewBoundariesMaterial,
     mouseEventHandles,
     cesiumIonAccessToken,
     context,
+    light,
     layerSelectWithRectEventHandlers,
-    sceneLight,
-    sceneBackgroundColor,
-    sceneMsaaSamples,
-    sceneMode,
-    cameraViewBoundaries,
-    cameraViewOuterBoundaries,
-    cameraViewBoundariesMaterial,
-    handleCameraChange,
-    handleCameraMoveEnd,
-    handleUpdate,
-    handleClick,
     handleMount,
     handleUnmount,
+    handleUpdate,
+    handleClick,
+    handleCameraChange,
+    handleCameraMoveEnd,
   } = useHooks({
     ref,
     property,
-    time,
+    camera,
     selectedLayerId,
     selectionReason: layerSelectionReason,
+    isLayerDraggable,
+    isLayerDragging,
     meta,
     layersRef,
     featureFlags,
-    timelineManagerRef,
-    isLayerDraggable,
-    isLayerDragging,
-    shouldRender,
     requestingRenderMode,
-    camera,
+    shouldRender,
+    timelineManagerRef,
     cameraForceHorizontalRoll,
+    onLayerSelect,
+    onCameraChange,
     onLayerDrag,
     onLayerDrop,
-    onLayerSelect,
     onLayerEdit,
     onLayerSelectWithRectStart,
     onLayerSelectWithRectMove,
     onLayerSelectWithRectEnd,
+    onMount,
     onLayerVisibility,
     onLayerLoad,
-    onCameraChange,
-    onMount,
   });
 
   return (
@@ -141,20 +137,20 @@ const Cesium: React.ForwardRefRenderFunction<EngineRef, EngineProps> = (
         cursor: isLayerDragging ? "grab" : undefined,
         ...style,
       }}
-      shadows={!!property?.scene?.shadow?.enabled}
+      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}
+      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} />
@@ -200,18 +196,20 @@ const Cesium: React.ForwardRefRenderFunction<EngineRef, EngineProps> = (
       </ScreenSpaceEventHandler>
       <ScreenSpaceCameraController
         maximumZoomDistance={
-          property?.camera?.limiter?.enabled
-            ? property.camera?.limiter?.targetArea?.height ?? Number.POSITIVE_INFINITY
+          property?.cameraLimiter?.cameraLimitterEnabled
+            ? property.cameraLimiter?.cameraLimitterTargetArea?.height ?? Number.POSITIVE_INFINITY
             : Number.POSITIVE_INFINITY
         }
-        enableCollisionDetection={!property?.camera?.allowEnterGround}
+        enableCollisionDetection={
+          !(property?.default?.allowEnterGround ?? property?.camera?.allowEnterGround)
+        }
       />
       <Camera
-        percentageChanged={0.2}
         onChange={handleCameraChange}
+        percentageChanged={0.2}
         onMoveEnd={handleCameraMoveEnd}
       />
-      {cameraViewBoundaries && property?.camera?.limiter?.showHelper && (
+      {cameraViewBoundaries && property?.cameraLimiter?.cameraLimitterShowHelper && (
         <Entity>
           <PolylineGraphics
             positions={cameraViewBoundaries}
@@ -221,7 +219,7 @@ const Cesium: React.ForwardRefRenderFunction<EngineRef, EngineProps> = (
           />
         </Entity>
       )}
-      {cameraViewOuterBoundaries && property?.camera?.limiter?.showHelper && (
+      {cameraViewOuterBoundaries && property?.cameraLimiter?.cameraLimitterShowHelper && (
         <Entity>
           <PolylineGraphics
             positions={cameraViewOuterBoundaries}
@@ -231,35 +229,39 @@ const Cesium: React.ForwardRefRenderFunction<EngineRef, EngineProps> = (
           />
         </Entity>
       )}
+      {/* NOTE: useWebVR={false} will crash Cesium */}
       <Scene
-        backgroundColor={sceneBackgroundColor}
-        light={sceneLight}
-        mode={sceneMode}
-        msaaSamples={sceneMsaaSamples}
+        backgroundColor={backgroundColor}
+        useWebVR={!!property?.default?.vr || undefined}
+        light={light}
         useDepthPicking={false}
-        useWebVR={!!property?.scene?.vr || undefined} // NOTE: useWebVR={false} will crash Cesium
-        debugShowFramesPerSecond={!!property?.debug?.showFramesPerSecond}
-        verticalExaggerationRelativeHeight={property?.scene?.verticalExaggerationRelativeHeight}
-        verticalExaggeration={property?.scene?.verticalExaggeration}
+        debugShowFramesPerSecond={!!property?.render?.debugFramePerSecond}
+        verticalExaggerationRelativeHeight={property?.terrain?.terrainExaggerationRelativeHeight}
+        verticalExaggeration={property?.terrain?.terrainExaggeration}
       />
-      <SkyBox show={property?.sky?.skyBox?.show ?? true} />
-      <Fog enabled={property?.sky?.fog?.enabled ?? true} density={property?.sky?.fog?.density} />
-      <Sun show={property?.sky?.sun?.show ?? true} />
-      <Moon show={property?.sky?.moon?.show ?? true} />
+      <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?.sky?.skyAtmosphere?.show ?? true}
-        atmosphereLightIntensity={property?.sky?.skyAtmosphere?.lightIntensity}
-        saturationShift={property?.sky?.skyAtmosphere?.saturationShift}
-        brightnessShift={property?.sky?.skyAtmosphere?.brightnessShift}
+        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?.render?.ambientOcclusion?.quality || "low"]}
-        enabled={!!property?.render?.ambientOcclusion?.enabled}
-        intensity={property?.render?.ambientOcclusion?.intensity ?? 100}
+        {...AMBIENT_OCCLUSION_QUALITY[property?.ambientOcclusion?.quality || "low"]}
+        enabled={!!property?.ambientOcclusion?.enabled}
+        intensity={property?.ambientOcclusion?.intensity ?? 100}
         outputType={
-          property?.render?.ambientOcclusion?.ambientOcclusionOnly
+          property?.ambientOcclusion?.ambientOcclusionOnly
             ? AmbientOcclusionOutputType.Occlusion
             : null
         }

package/src/engines/Cesium/{hooks/useEngineRef.test.tsx → useEngineRef.test.tsx}

@@ -12,7 +12,7 @@ import { useRef } from "react";
 import type { CesiumComponentRef } from "resium";
 import { vi, expect, test, afterEach } from "vitest";
 
-import type { EngineRef, Clock } from "../../..";
+import type { EngineRef, Clock } from "..";
 
 import useEngineRef from "./useEngineRef";
 
@@ -57,86 +57,86 @@ test("bind mouse events", () => {
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onDoubleClick(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.doubleClick[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.doubleclick[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.doubleClick[0]?.(props);
+  result.current.current?.mouseEventCallbacks.doubleclick[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(2);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMouseDown(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.mouseDown[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.mousedown[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.mouseDown[0]?.(props);
+  result.current.current?.mouseEventCallbacks.mousedown[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(3);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMouseUp(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.mouseUp[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.mouseup[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.mouseUp[0]?.(props);
+  result.current.current?.mouseEventCallbacks.mouseup[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(4);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onRightClick(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.rightClick[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.rightclick[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.rightClick[0]?.(props);
+  result.current.current?.mouseEventCallbacks.rightclick[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(5);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onRightDown(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.rightDown[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.rightdown[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.rightDown[0]?.(props);
+  result.current.current?.mouseEventCallbacks.rightdown[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(6);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onRightUp(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.rightUp[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.rightup[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.rightUp[0]?.(props);
+  result.current.current?.mouseEventCallbacks.rightup[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(7);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMiddleClick(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.middleClick[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.middleclick[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.middleClick[0]?.(props);
+  result.current.current?.mouseEventCallbacks.middleclick[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(8);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMiddleDown(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.middleDown[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.middledown[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.middleDown[0]?.(props);
+  result.current.current?.mouseEventCallbacks.middledown[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(9);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMiddleUp(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.middleUp[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.middleup[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.middleUp[0]?.(props);
+  result.current.current?.mouseEventCallbacks.middleup[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(10);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMouseMove(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.mouseMove[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.mousemove[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.mouseMove[0]?.(props);
+  result.current.current?.mouseEventCallbacks.mousemove[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(11);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMouseEnter(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.mouseEnter[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.mouseenter[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.mouseEnter[0]?.(props);
+  result.current.current?.mouseEventCallbacks.mouseenter[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(12);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
   result.current.current?.onMouseLeave(mockMouseEventCallback);
-  expect(result.current.current?.mouseEventCallbacks.mouseLeave[0]).toBe(mockMouseEventCallback);
+  expect(result.current.current?.mouseEventCallbacks.mouseleave[0]).toBe(mockMouseEventCallback);
 
-  result.current.current?.mouseEventCallbacks.mouseLeave[0]?.(props);
+  result.current.current?.mouseEventCallbacks.mouseleave[0]?.(props);
   expect(mockMouseEventCallback).toHaveBeenCalledTimes(13);
   expect(mockMouseEventCallback).toHaveBeenCalledWith(props);
 
@@ -188,11 +188,10 @@ test("zoom", async () => {
     return engineRef;
   });
 
-  const commons = await import("../common");
-  const zoom = vi.spyOn(commons, "zoom");
+  const commons = await import("./common");
 
   result.current.current?.zoomIn(10);
-  expect(zoom).toHaveBeenCalledTimes(1);
+  expect(commons.zoom).toHaveBeenCalledTimes(1);
   expect(commons.zoom).toHaveBeenCalledWith(
     {
       viewer,
@@ -222,7 +221,6 @@ test("call orbit when camera focuses on center", async () => {
           rotateUp: vi.fn(),
           look: vi.fn(),
           move: vi.fn(),
-          getPickRay: vi.fn(),
           positionCartographic: new Cartesian3(),
         },
         mode: SceneMode.SCENE3D,
@@ -249,14 +247,15 @@ test("call orbit when camera focuses on center", async () => {
     return [engineRef, cesium] as const;
   });
 
-  const commons = await import("../common");
-  const getCenterCamera = vi.spyOn(commons, "getCenterCamera");
+  const commons = await import("./common");
 
   const [engineRef, cesium] = result.current;
 
   engineRef.current?.orbit(90);
-  expect(getCenterCamera).toHaveBeenCalled();
-  expect(cesium.current.cesiumElement?.scene.camera.lookAtTransform).toHaveBeenCalledTimes(1);
+  expect(commons.getCenterCamera).toHaveBeenCalled();
+  expect(cesium.current.cesiumElement?.scene.camera.rotateLeft).toHaveBeenCalled();
+  expect(cesium.current.cesiumElement?.scene.camera.rotateUp).toHaveBeenCalled();
+  expect(cesium.current.cesiumElement?.scene.camera.lookAtTransform).toHaveBeenCalledTimes(2);
 });
 
 test("call orbit when camera does not focus on center", async () => {
@@ -269,7 +268,6 @@ test("call orbit when camera does not focus on center", async () => {
           rotateUp: vi.fn(),
           look: vi.fn(),
           move: vi.fn(),
-          getPickRay: vi.fn(),
           positionWC: new Cartesian3(),
           positionCartographic: new Cartesian3(),
         },
@@ -296,13 +294,12 @@ test("call orbit when camera does not focus on center", async () => {
     return [engineRef, cesium] as const;
   });
 
-  const commons = await import("../common");
-  const getCenterCamera = vi.spyOn(commons, "getCenterCamera");
+  const commons = await import("./common");
 
   const [engineRef, cesium] = result.current;
 
   engineRef.current?.orbit(90);
-  expect(getCenterCamera).toHaveBeenCalled();
+  expect(commons.getCenterCamera).toHaveBeenCalled();
   expect(cesium.current.cesiumElement?.scene.camera.look).toHaveBeenCalledTimes(2);
   expect(cesium.current.cesiumElement?.scene.camera.lookAtTransform).toHaveBeenCalledTimes(2);
 });
@@ -317,7 +314,6 @@ test("orbit on 2D mode", async () => {
           rotateUp: vi.fn(),
           look: vi.fn(),
           move: vi.fn(),
-          getPickRay: vi.fn(),
           positionWC: new Cartesian3(),
           positionCartographic: new Cartesian3(),
         },

package/src/engines/Cesium/{hooks/useEngineRef.ts → useEngineRef.ts}

@@ -4,9 +4,11 @@ import { ClockStep, JulianDate, Math as CesiumMath } from "cesium";
 import { useImperativeHandle, Ref, RefObject, useMemo, useRef } from "react";
 import { CesiumComponentRef } from "resium";
 
-import type { EngineRef, MouseEventProps, Feature, ComputedFeature } from "../..";
-import { MouseEventCallbacks, TickEventCallback, SketchType } from "../../../Map";
-import { Position2d, Position3d } from "../../../types";
+import type { EngineRef, MouseEventProps, Feature, ComputedFeature } from "..";
+import { MouseEventCallbacks, TickEventCallback } from "../../Map";
+import { SketchType } from "../../Map/Sketch/types";
+import { Position2d, Position3d } from "../../types";
+
 import {
   getLocationFromScreen,
   flyTo,
@@ -32,11 +34,11 @@ import {
   cartesianToLatLngHeight,
   getExtrudedHeight,
   getOverriddenScreenSpaceCameraOptions,
-} from "../common";
-import { attachTag, getTag } from "../Feature";
-import { PickedFeature, pickManyFromViewportAsFeature } from "../pickMany";
-import { createGeometry } from "../Sketch/createGeometry";
-import { CursorType } from "../types";
+} from "./common";
+import { attachTag, getTag } from "./Feature";
+import { PickedFeature, pickManyFromViewportAsFeature } from "./pickMany";
+import { createGeometry } from "./Sketch/createGeometry";
+import { CursorType } from "./types";
 import {
   convertCesium3DTileFeatureProperties,
   convertEntityDescription,
@@ -44,7 +46,7 @@ import {
   convertObjToComputedFeature,
   findEntity,
   findFeaturesFromLayer,
-} from "../utils/utils";
+} from "./utils/utils";
 
 export default function useEngineRef(
   ref: Ref<EngineRef>,
@@ -53,18 +55,18 @@ export default function useEngineRef(
   const cancelCameraFlight = useRef<() => void>();
   const mouseEventCallbacks = useRef<MouseEventCallbacks>({
     click: [],
-    doubleClick: [],
-    mouseDown: [],
-    mouseUp: [],
-    rightClick: [],
-    rightDown: [],
-    rightUp: [],
-    middleClick: [],
-    middleDown: [],
-    middleUp: [],
-    mouseMove: [],
-    mouseEnter: [],
-    mouseLeave: [],
+    doubleclick: [],
+    mousedown: [],
+    mouseup: [],
+    rightclick: [],
+    rightdown: [],
+    rightup: [],
+    middleclick: [],
+    middledown: [],
+    middleup: [],
+    mousemove: [],
+    mouseenter: [],
+    mouseleave: [],
     wheel: [],
   });
   const tickEventCallback = useRef<TickEventCallback[]>([]);
@@ -237,8 +239,6 @@ export default function useEngineRef(
       setView: camera => {
         const viewer = cesium.current?.cesiumElement;
         if (!viewer || viewer.isDestroyed()) return false;
-        if (camera.lat === undefined || camera.lng === undefined || camera.height === undefined)
-          return false;
         const scene = viewer.scene;
         if (camera.lng || camera.lat || camera.height) {
           const xyz = Cesium.Cartesian3.fromDegrees(camera.lng, camera.lat, camera.height);
@@ -539,15 +539,13 @@ export default function useEngineRef(
         const oldTransform = Cesium.Matrix4.clone(camera.transform);
 
         const center = getCenterCamera({ camera, scene });
-        if (center || camera.positionWC) {
-          // Get fixed frame from center to globe ellipsoid.
-          const frame = Cesium.Transforms.eastNorthUpToFixedFrame(
-            center || camera.positionWC,
-            scene.globe.ellipsoid,
-          );
+        // Get fixed frame from center to globe ellipsoid.
+        const frame = Cesium.Transforms.eastNorthUpToFixedFrame(
+          center || camera.positionWC,
+          scene.globe.ellipsoid,
+        );
 
-          camera.lookAtTransform(frame);
-        }
+        camera.lookAtTransform(frame);
 
         if (viewer.scene.mode !== Cesium.SceneMode.SCENE3D) {
           camera.move(
@@ -677,40 +675,40 @@ export default function useEngineRef(
         mouseEventCallbacks.current.click.push(cb);
       },
       onDoubleClick: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.doubleClick.push(cb);
+        mouseEventCallbacks.current.doubleclick.push(cb);
       },
       onMouseDown: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.mouseDown.push(cb);
+        mouseEventCallbacks.current.mousedown.push(cb);
       },
       onMouseUp: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.mouseUp.push(cb);
+        mouseEventCallbacks.current.mouseup.push(cb);
       },
       onRightClick: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.rightClick.push(cb);
+        mouseEventCallbacks.current.rightclick.push(cb);
       },
       onRightDown: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.rightDown.push(cb);
+        mouseEventCallbacks.current.rightdown.push(cb);
       },
       onRightUp: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.rightUp.push(cb);
+        mouseEventCallbacks.current.rightup.push(cb);
       },
       onMiddleClick: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.middleClick.push(cb);
+        mouseEventCallbacks.current.middleclick.push(cb);
       },
       onMiddleDown: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.middleDown.push(cb);
+        mouseEventCallbacks.current.middledown.push(cb);
       },
       onMiddleUp: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.middleUp.push(cb);
+        mouseEventCallbacks.current.middleup.push(cb);
       },
       onMouseMove: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.mouseMove.push(cb);
+        mouseEventCallbacks.current.mousemove.push(cb);
       },
       onMouseEnter: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.mouseEnter.push(cb);
+        mouseEventCallbacks.current.mouseenter.push(cb);
       },
       onMouseLeave: (cb: (props: MouseEventProps) => void) => {
-        mouseEventCallbacks.current.mouseLeave.push(cb);
+        mouseEventCallbacks.current.mouseleave.push(cb);
       },
       onWheel: (cb: (props: MouseEventProps) => void) => {
         mouseEventCallbacks.current.wheel.push(cb);

package/src/engines/Cesium/{hooks/useOverrideGlobeShader/useOverrideGlobeShader.ts → useOverrideGlobeShader.ts}

@@ -8,15 +8,15 @@ import { Viewer, Globe, Material, Cartesian3 } from "cesium";
 import { RefObject, useCallback, useEffect, useMemo, useRef } from "react";
 import { CesiumComponentRef } from "resium";
 
-import { TerrainProperty } from "../../..";
-import { useImmutableFunction } from "../../../../hooks/useRefFunction";
-import { StringMatcher } from "../../../../utils/StringMatcher";
-import { createColorMapImage } from "../../Feature/HeatMap/colorMap";
-import GlobeFSDefinitions from "../../Shaders/OverriddenShaders/GlobeFS/Definitions.glsl?raw";
-import HeatmapForTerrainFS from "../../Shaders/OverriddenShaders/GlobeFS/HeatmapForTerrain.glsl?raw";
-import IBLFS from "../../Shaders/OverriddenShaders/GlobeFS/IBL.glsl?raw";
-import { PrivateCesiumGlobe } from "../../types";
-
+import { TerrainProperty } from "..";
+import { useImmutableFunction } from "../../hooks/useRefFunction";
+import { StringMatcher } from "../../utils/StringMatcher";
+
+import { createColorMapImage } from "./Feature/HeatMap/colorMap";
+import GlobeFSDefinitions from "./Shaders/OverriddenShaders/GlobeFS/Definitions.glsl?raw";
+import HeatmapForTerrainFS from "./Shaders/OverriddenShaders/GlobeFS/HeatmapForTerrain.glsl?raw";
+import IBLFS from "./Shaders/OverriddenShaders/GlobeFS/IBL.glsl?raw";
+import { PrivateCesiumGlobe } from "./types";
 import { VertexTerrainElevationMaterial } from "./VertexTerrainElevationMaterial";
 
 const defaultMatcher = new StringMatcher()
@@ -122,19 +122,17 @@ const useIBL = ({
 
 const useTerrainHeatmap = ({
   cesium,
-  terrain,
+  terrain: {
+    heatmapType,
+    heatmapMaxHeight,
+    heatmapMinHeight,
+    heatmapLogarithmic,
+    heatmapColorLUT,
+  } = {},
 }: {
   cesium: RefObject<CesiumComponentRef<Viewer>>;
   terrain: TerrainProperty | undefined;
 }) => {
-  const {
-    type: heatmapType,
-    maxHeight: heatmapMaxHeight,
-    minHeight: heatmapMinHeight,
-    logarithmic: heatmapLogarithmic,
-    colorLUT: heatmapColorLUT,
-  } = terrain?.elevationHeatMap ?? {};
-
   const isCustomHeatmapEnabled = useMemo(() => heatmapType === "custom", [heatmapType]);
 
   const shaderForTerrainHeatmap = useMemo(
@@ -143,7 +141,7 @@ const useTerrainHeatmap = ({
         [
           "#ifdef APPLY_COLOR_TO_ALPHA",
           "vec3 colorDiff = abs(color.rgb - colorToAlpha.rgb);",
-          "colorDiff.r = max(max(colorDiff.r, colorDiff.g), colorDiff.b);",
+          "colorDiff.r = czm_maximumComponent(colorDiff);",
           "alpha = czm_branchFreeTernary(colorDiff.r < colorToAlpha.a, 0.0, alpha);",
           "#endif",
         ],
@@ -208,7 +206,6 @@ export const useOverrideGlobeShader = ({
     enableLighting,
   });
 
-  // Terrain Heatmap is actually a built-in feature for globe, it renders as a heatmap using terrain height data.
   const { isCustomHeatmapEnabled, shaderForTerrainHeatmap } = useTerrainHeatmap({
     cesium,
     terrain,

package/src/engines/index.ts

@@ -5,7 +5,7 @@ export type {
   EngineRef,
   EngineProps,
   LayerSelectionReason,
-  ViewerProperty,
+  SceneProperty,
   MouseEventProps,
   MouseEvents,
   Geometry,

package/src/mantle/compat/types.ts

@@ -31,19 +31,19 @@ export type Rect = {
 /** Represents the camera position and state */
 export type CameraPosition = {
   /** degrees */
-  lat?: number;
+  lat: number;
   /** degrees */
-  lng?: number;
+  lng: number;
   /** meters */
-  height?: number;
+  height: number;
   /** radians */
-  heading?: number;
+  heading: number;
   /** radians */
-  pitch?: number;
+  pitch: number;
   /** radians */
-  roll?: number;
+  roll: number;
   /** Field of view expressed in radians */
-  fov?: number;
+  fov: number;
   /** Aspect ratio of frustum */
   aspectRatio?: number;
 };