@reearth/core 0.0.1

package/src/engines/Cesium/utils/utils.ts

@@ -0,0 +1,446 @@
+import {
+  Cartesian3,
+  Viewer as CesiumViewer,
+  Math as CesiumMath,
+  TranslationRotationScale,
+  Cartographic,
+  Entity,
+  Cesium3DTile,
+  Cesium3DTileset,
+  Cesium3DTileContent,
+  Cesium3DTileFeature,
+  JulianDate,
+  Model,
+  ImageryLayerFeatureInfo,
+  Scene,
+  Viewer,
+  Cesium3DTilePointFeature,
+  Primitive,
+  GroundPrimitive,
+  ImageryLayer,
+  DataSource,
+} from "cesium";
+
+import { ComputedFeature, DefaultInfobox } from "../../../Map";
+import { InfoboxProperty } from "../../../reearthTypes";
+import { getTag } from "../Feature";
+import { TilesetFeatureIndex } from "../Feature/Tileset/TilesetFeatureIndex";
+import type { InternalCesium3DTileFeature } from "../types";
+
+export const convertCartesian3ToPosition = (
+  cesium?: CesiumViewer,
+  pos?: Cartesian3,
+): { lat: number; lng: number; height: number } | undefined => {
+  if (!pos) return;
+  const cartographic = cesium?.scene.globe.ellipsoid.cartesianToCartographic(pos);
+  if (!cartographic) return;
+  return {
+    lat: CesiumMath.toDegrees(cartographic.latitude),
+    lng: CesiumMath.toDegrees(cartographic.longitude),
+    height: cartographic.height,
+  };
+};
+
+export const translationWithClamping = (
+  trs: TranslationRotationScale,
+  allowEnterGround: boolean,
+  terrainHeightEstimate: number,
+) => {
+  if (!allowEnterGround) {
+    const cartographic = Cartographic.fromCartesian(trs.translation, undefined, new Cartographic());
+    const boxBottomHeight = cartographic.height - trs.scale.z / 2;
+    const floorHeight = terrainHeightEstimate;
+    if (boxBottomHeight < floorHeight) {
+      cartographic.height += floorHeight - boxBottomHeight;
+      Cartographic.toCartesian(cartographic, undefined, trs.translation);
+    }
+  }
+};
+
+export const getModelFromTileContent = (c: Cesium3DTileContent) => {
+  if (!c.featuresLength && "_model" in c && c._model instanceof Model) {
+    return c._model;
+  }
+  return;
+};
+
+export function lookupFeatures(
+  c: Cesium3DTileContent,
+  cb: (
+    feature: InternalCesium3DTileFeature,
+    content: Cesium3DTileContent,
+    batchId?: number,
+  ) => void | Promise<void>,
+) {
+  if (!c) return;
+
+  // Use model, if featuresLength is 0.
+  const model = getModelFromTileContent(c);
+  if (model) {
+    return cb(model, c);
+  }
+
+  const length = c.featuresLength;
+  for (let i = 0; i < length; i++) {
+    const f = c.getFeature(i);
+    if (!f) {
+      continue;
+    }
+    cb(f, c, i);
+  }
+  c.innerContents?.forEach(c => lookupFeatures(c, cb));
+  return;
+}
+
+const findFeatureFrom3DTile = (
+  tile: Cesium3DTile,
+  featureId?: string,
+  featureIndex?: TilesetFeatureIndex,
+): Cesium3DTileFeature | void => {
+  let target: InternalCesium3DTileFeature | undefined = undefined;
+
+  if (featureId) {
+    target = featureIndex?.find(featureId)?.[0];
+    if (target && target instanceof Cesium3DTileFeature) {
+      return target;
+    }
+  }
+
+  lookupFeatures(tile.content, f => {
+    const tag = getTag(f);
+    if (tag?.featureId === featureId) {
+      target = f;
+    }
+  });
+
+  if (target && target instanceof Cesium3DTileFeature) {
+    return target;
+  }
+
+  for (const child of tile.children) {
+    const t = findFeatureFrom3DTile(child, featureId);
+    if (t) {
+      return t;
+    }
+  }
+};
+
+export function findEntity(
+  viewer: CesiumViewer,
+  layerId?: string,
+  featureId?: string,
+  withoutTileFeature?: boolean,
+):
+  | Entity
+  | Cesium3DTileset
+  | InternalCesium3DTileFeature
+  | Primitive
+  | GroundPrimitive
+  | ImageryLayer
+  | undefined {
+  const id = featureId ?? layerId;
+  const keyName = featureId ? "featureId" : "layerId";
+  if (!id) return;
+
+  let entity = viewer.entities.getById(id);
+  if (entity) return entity;
+
+  // we can store groundPrimitives as a state as aren't saved as unique entities in the viewer, i.e Workaround for making FlyTo for HeatMaps: @pyshx
+
+  entity = viewer.entities.values.find(e => getTag(e)?.[keyName] === id);
+  if (entity) return entity;
+
+  for (const ds of [viewer.dataSourceDisplay.dataSources, viewer.dataSources]) {
+    for (let i = 0; i < ds.length; i++) {
+      const entities = ds.get(i).entities.values;
+      const e = entities.find(e => getTag(e)?.[keyName] === id);
+      if (e) {
+        return e;
+      }
+    }
+  }
+
+  // Find Cesium3DTileset or Primitive or GroundPrimitive
+  for (let i = 0; i < viewer.scene.primitives.length; i++) {
+    const prim = viewer.scene.primitives.get(i);
+    if (
+      !(prim instanceof Cesium3DTileset) &&
+      !(prim instanceof Primitive) &&
+      !(prim instanceof GroundPrimitive)
+    ) {
+      continue;
+    }
+
+    if (layerId && !featureId) {
+      const tag = getTag(prim);
+      if (tag?.layerId && layerId && tag?.layerId === layerId) {
+        return prim;
+      }
+      continue;
+    }
+
+    if (prim.isDestroyed()) continue;
+
+    // Skip to search 3dtiles features if `withoutTileFeature` is `true`.
+    if (!withoutTileFeature && prim instanceof Cesium3DTileset) {
+      const target = findFeatureFrom3DTile(prim.root, featureId);
+      if (target) {
+        return target;
+      }
+    }
+  }
+
+  for (let i = 0; i < viewer.imageryLayers.length; i++) {
+    const imageryLayer = viewer.imageryLayers.get(i);
+    const tag = getTag(imageryLayer);
+    if (tag?.layerId === layerId) {
+      return imageryLayer;
+    }
+  }
+
+  return;
+}
+
+const findFeaturesFrom3DTile = <T = InternalCesium3DTileFeature>(
+  tile: Cesium3DTile,
+  featureId: string[],
+  convert?: (f: InternalCesium3DTileFeature) => T,
+  targets: Set<T> = new Set(),
+) => {
+  lookupFeatures(tile.content, f => {
+    const tag = getTag(f);
+    if (featureId.includes(tag?.featureId ?? "")) {
+      const r = convert?.(f);
+      if (r) {
+        targets.add(r);
+      } else {
+        targets.add(f as T);
+      }
+    }
+  });
+
+  for (const child of tile.children) {
+    findFeaturesFrom3DTile(child, featureId, convert, targets);
+  }
+};
+
+const filterEntity = <T = Entity | Cesium3DTileset | InternalCesium3DTileFeature>(
+  es: Entity[],
+  layerId: string,
+  featureId: string[],
+  convert?: (e: Entity | Cesium3DTileset | InternalCesium3DTileFeature) => T,
+) => {
+  const result: T[] = [];
+  for (const e of es) {
+    const tag = getTag(e);
+    if (tag?.layerId === layerId && featureId.includes(tag.featureId || "")) {
+      const f = convert?.(e);
+      if (f) {
+        result.push(f);
+      } else if (e) {
+        result.push(e as T);
+      }
+    }
+  }
+  return result;
+};
+
+const findEntityFromDatasource = <T = Entity | Cesium3DTileset | InternalCesium3DTileFeature>(
+  viewer: Viewer,
+  layerId: string,
+  featureId: string[],
+  convert?: (
+    e: Entity | Cesium3DTileset | InternalCesium3DTileFeature,
+    layer?: Cesium3DTileset | DataSource,
+  ) => T,
+) => {
+  let datasources: T[] = [];
+  for (const ds of [viewer.dataSourceDisplay.dataSources, viewer.dataSources]) {
+    for (let i = 0; i < ds.length; i++) {
+      const entities = ds.get(i).entities.values;
+      const e = filterEntity(entities, layerId, featureId, convert);
+      if (e.length) {
+        datasources = datasources.concat(e);
+      }
+    }
+  }
+  return datasources;
+};
+
+const findTile3DFeaturesFromScene = <T = Entity | Cesium3DTileset | InternalCesium3DTileFeature>(
+  viewer: Viewer,
+  layerId: string,
+  featureId: string[],
+  convert?: (
+    e: Entity | Cesium3DTileset | InternalCesium3DTileFeature,
+    layer?: Cesium3DTileset | DataSource,
+  ) => T,
+) => {
+  const targets: Set<T> = new Set();
+  // Find Cesium3DTileFeature
+  for (let i = 0; i < viewer.scene.primitives.length; i++) {
+    const prim = viewer.scene.primitives.get(i);
+    if (!(prim instanceof Cesium3DTileset) || prim.isDestroyed()) {
+      continue;
+    }
+
+    const tag = getTag(prim);
+    if (tag?.layerId !== layerId) continue;
+
+    const featureIndex = tag.featureIndex;
+    if (featureIndex) {
+      const featuresFromCache = featureId
+        .flatMap(id => featureIndex.find(id) as InternalCesium3DTileFeature[])
+        .filter((f): f is InternalCesium3DTileFeature => !!f)
+        .map(f => convert?.(f, prim))
+        .filter((f): f is NonNullable<T> => !!f);
+
+      return featuresFromCache;
+    }
+
+    findFeaturesFrom3DTile(prim.root, featureId, convert, targets);
+    if (targets.size) {
+      return Array.from(targets.values()) as NonNullable<T>[];
+    }
+  }
+
+  return [];
+};
+
+export function findFeaturesFromLayer<T = Entity | Cesium3DTileset | InternalCesium3DTileFeature>(
+  viewer: CesiumViewer,
+  layerId: string,
+  featureId: string[],
+  convert?: (
+    e: Entity | Cesium3DTileset | InternalCesium3DTileFeature,
+    layer?: Cesium3DTileset | DataSource,
+  ) => T,
+): NonNullable<T>[] {
+  const entity = filterEntity(viewer.entities.values, layerId, featureId, convert);
+  if (entity.length) return entity as NonNullable<T>[];
+
+  const datasources: T[] = findEntityFromDatasource(viewer, layerId, featureId, convert);
+  if (datasources.length) {
+    return datasources as NonNullable<T>[];
+  }
+
+  return findTile3DFeaturesFromScene(viewer, layerId, featureId, convert);
+}
+
+export const getEntityContent = (
+  entity: Entity | ImageryLayerFeatureInfo,
+  time: JulianDate,
+  defaultContent: InfoboxProperty["defaultContent"],
+): DefaultInfobox["content"] => {
+  const content: Record<
+    Exclude<InfoboxProperty["defaultContent"], undefined>,
+    DefaultInfobox["content"]
+  > = {
+    description: {
+      type: "html",
+      value:
+        entity instanceof ImageryLayerFeatureInfo
+          ? entity.description
+          : entity.description?.getValue(time),
+    },
+    attributes: {
+      type: "table",
+      value:
+        !(entity instanceof Entity) &&
+        "properties" in entity &&
+        entity.properties &&
+        typeof entity.properties === "object"
+          ? propertiesToTableContent(entity.properties)
+          : entity instanceof Entity && entity.properties
+            ? propertiesToTableContent(entity.properties.getValue(time))
+            : [],
+    },
+  };
+
+  return defaultContent ? content[defaultContent] : content.attributes ?? content.description;
+};
+
+function propertiesToTableContent(properties: Record<string, any>): { key: string; value: any }[] {
+  return Object.entries(properties).reduce<{ key: string; value: [string, string] }[]>(
+    (a, [key, value]) => [...a, { key, value }],
+    [],
+  );
+}
+
+// Just a shortcut to the private property.
+export function getPixelRatio(scene: Scene): number {
+  return (
+    scene as Scene & {
+      pixelRatio: number;
+    }
+  ).pixelRatio;
+}
+
+export const convertEntityProperties = (currentTime: JulianDate, entity: Entity) => {
+  const properties = entity.properties?.getValue(currentTime);
+  return entity.properties && properties
+    ? Object.fromEntries(entity.properties.propertyNames.map(key => [key, properties[key]]))
+    : {};
+};
+
+export const convertEntityDescription = (
+  currentTime: JulianDate,
+  entity: Entity,
+): string | undefined => {
+  const description = entity.description?.getValue(currentTime);
+  if (typeof description !== "string") return;
+  return description;
+};
+
+export const convertCesium3DTileFeatureProperties = (
+  feature: Cesium3DTileFeature | Cesium3DTilePointFeature,
+) => {
+  return Object.fromEntries(feature.getPropertyIds().map(id => [id, feature.getProperty(id)]));
+};
+
+export const convertObjToComputedFeature = (
+  currentTime: JulianDate,
+  obj: object,
+): [layerId: string | undefined, feature: ComputedFeature] | undefined => {
+  if (obj instanceof Cesium3DTileFeature || obj instanceof Cesium3DTilePointFeature) {
+    const tag = getTag(obj);
+    return [
+      tag?.layerId,
+      tag?.computedFeature ?? {
+        type: "computedFeature",
+        id: tag?.featureId ?? "",
+        properties: convertCesium3DTileFeatureProperties(obj),
+      },
+    ];
+  }
+
+  if (obj instanceof Model) {
+    const tag = getTag(obj);
+    return [
+      tag?.layerId,
+      {
+        type: "computedFeature",
+        id: tag?.featureId ?? "",
+        properties: {},
+      },
+    ];
+  }
+
+  if (obj instanceof Entity || ("id" in obj && obj.id instanceof Entity)) {
+    const entity = (obj instanceof Entity ? obj : obj.id) as Entity;
+    const tag = getTag(entity);
+    return [
+      tag?.layerId,
+      tag?.computedFeature ?? {
+        type: "computedFeature",
+        id: tag?.featureId ?? "",
+        properties: convertEntityProperties(currentTime, entity),
+        metaData: {
+          description: convertEntityDescription(currentTime, entity),
+        },
+      },
+    ];
+  }
+
+  return;
+};

package/src/engines/Cesium/vertexTerrainElevationMaterial.glsl

@@ -0,0 +1,25 @@
+uniform sampler2D colorMap;
+uniform float minHeight;
+uniform float maxHeight;
+uniform bool logarithmic;
+uniform float heightDatum;
+
+#define LOG_10 (2.302585092994046)
+
+float pseudoLog(float value) {
+    return value > 10.0 ? log(value) / LOG_10 : value < -10.0 ? -log(-value) / LOG_10 : value / 10.0;
+}
+
+czm_material czm_getMaterial(czm_materialInput materialInput) {
+    czm_material material = czm_getDefaultMaterial(materialInput);
+    float height = materialInput.height + heightDatum;
+    float minHeight = czm_branchFreeTernary(logarithmic, pseudoLog(minHeight), minHeight);
+    float maxHeight = czm_branchFreeTernary(logarithmic, pseudoLog(maxHeight), maxHeight);
+    float value = czm_branchFreeTernary(logarithmic, pseudoLog(height), height);
+    float normalizedHeight = clamp((value - minHeight) / (maxHeight - minHeight), 0.0, 1.0);
+    vec4 mappedColor = texture(colorMap, vec2(normalizedHeight, 0.5));
+    mappedColor = czm_gammaCorrect(mappedColor);
+    material.diffuse = mappedColor.rgb;
+    material.alpha = mappedColor.a;
+    return material;
+}

package/src/engines/index.ts

@@ -0,0 +1,37 @@
+export type {
+  FeatureComponentProps,
+  Engine,
+  EngineComponent,
+  EngineRef,
+  EngineProps,
+  LayerSelectionReason,
+  SceneProperty,
+  MouseEventProps,
+  MouseEvents,
+  Geometry,
+  AppearanceTypes,
+  Camera,
+  LatLng,
+  ClusterProperty,
+  ClusterComponentProps,
+  Clock,
+  TerrainProperty,
+  LayerEditEvent,
+  EvalFeature,
+  LayerVisibilityEvent,
+} from "../Map";
+export type {
+  Cesium3DTilesAppearance,
+  EllipsoidAppearance,
+  EllipseAppearance,
+  PolygonAppearance,
+  PolylineAppearance,
+  MarkerAppearance,
+  ModelAppearance,
+  LegacyPhotooverlayAppearance,
+  ResourceAppearance,
+  RasterAppearance,
+  ComputedFeature,
+  ComputedLayer,
+  Feature,
+} from "../mantle";

package/src/env.d.ts

@@ -0,0 +1,3 @@
+declare module "jsep" {
+  function addLiteral(literalName: string, literalValue: string): void;
+}

package/src/hooks/index.ts

@@ -0,0 +1,2 @@
+export * from "./useRefValue";
+export * from "./useRefFunction";

package/src/hooks/useRefFunction.ts

@@ -0,0 +1,10 @@
+import { useCallback, useEffect, useRef } from "react";
+
+export const useImmutableFunction = <T>(v: T) => {
+  const valueRef = useRef(v);
+  const immutableFunc = useCallback(() => valueRef.current, []);
+  useEffect(() => {
+    valueRef.current = v;
+  }, [v]);
+  return immutableFunc;
+};

package/src/hooks/useRefValue.ts

@@ -0,0 +1,7 @@
+import { useRef } from "react";
+
+export const useRefValue = <V>(v: V) => {
+  const vRef = useRef(v);
+  vRef.current = v;
+  return vRef;
+};

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./Map";
+export * from "./mantle";
+export * from "./Visualizer";
+export * from "./types";

package/src/mantle/README.md

@@ -0,0 +1,7 @@
+# @reearth/core/mantle
+
+This library provides React hooks and components for following functionality:
+
+- Fetching various data and convert them to features
+- Evaluating Re:Earth Style Language expressions
+- Compatibility with conventional layer system

package/src/mantle/atoms/cache.test.ts

@@ -0,0 +1,61 @@
+import { renderHook, act } from "@testing-library/react";
+import { useAtomValue, useSetAtom } from "jotai";
+import { useMemo } from "react";
+import { test, expect } from "vitest";
+
+import { cacheAtom, doubleKeyCacheAtom } from "./cache";
+
+test("cacheAtom", () => {
+  const { result } = renderHook(() => {
+    const atoms = useMemo(() => cacheAtom<string, string>(), []);
+    const get = useAtomValue(atoms.get);
+    const set = useSetAtom(atoms.set);
+    return { get, set };
+  });
+
+  expect(result.current.get("test")).toBeUndefined();
+
+  act(() => {
+    result.current.set({ key: "test", value: "aaaa" });
+  });
+
+  expect(result.current.get("test")).toBe("aaaa");
+
+  act(() => {
+    result.current.set({ key: "test" });
+  });
+
+  expect(result.current.get("test")).toBeUndefined();
+});
+
+test("doubleKeyCacheAtom", () => {
+  const { result } = renderHook(() => {
+    const atoms = useMemo(() => doubleKeyCacheAtom<string, string, string>(), []);
+    const get = useAtomValue(atoms.get);
+    const getAll = useAtomValue(atoms.getAll);
+    const set = useSetAtom(atoms.set);
+    return { get, set, getAll };
+  });
+
+  expect(result.current.get("test", "a")).toBeUndefined();
+  expect(result.current.get("test", "b")).toBeUndefined();
+  expect(result.current.get("test", "c")).toBeUndefined();
+
+  act(() => {
+    result.current.set({ key: "test", key2: "a", value: "aaaa" });
+    result.current.set({ key: "test", key2: "c", value: "ccc" });
+  });
+
+  expect(result.current.get("test", "a")).toBe("aaaa");
+  expect(result.current.get("test", "b")).toBeUndefined();
+  expect(result.current.get("test", "c")).toBe("ccc");
+  expect(result.current.getAll("test")).toEqual(["aaaa", "ccc"]);
+
+  act(() => {
+    result.current.set({ key: "test", key2: "a" });
+  });
+
+  expect(result.current.get("test", "a")).toBeUndefined();
+  expect(result.current.get("test", "b")).toBeUndefined();
+  expect(result.current.get("test", "c")).toBe("ccc");
+});

package/src/mantle/atoms/cache.ts

@@ -0,0 +1,55 @@
+import { atom } from "jotai";
+
+export function cacheAtom<K, T>() {
+  const map = atom<Map<K, T> | undefined>(undefined);
+
+  const get = atom(get => (key: K) => get(map)?.get(key));
+
+  const set = atom(null, (get, set, value: { key: K; value?: T }) => {
+    const m = get(map) ?? new Map();
+    if (typeof value.value === "undefined") {
+      m.delete(value.key);
+    } else {
+      m.set(value.key, value.value);
+    }
+    set(map, m);
+  });
+
+  return { get, set };
+}
+
+export function doubleKeyCacheAtom<K, L, T>() {
+  const map = atom<Map<K, Map<L, T>> | undefined>(undefined);
+
+  const get = atom(get => (key: K, key2: L) => get(map)?.get(key)?.get(key2));
+
+  const getAll = atom(get => (key: K) => {
+    const m = get(map)?.get(key);
+    if (!m) return undefined;
+
+    const res: T[] = [];
+    for (const k of m.keys()) {
+      const v = m.get(k);
+      if (typeof v === "undefined") continue;
+      res.push(v);
+    }
+    return res;
+  });
+
+  const set = atom(null, (get, set, value: { key: K; key2: L; value?: T }) => {
+    const m: Map<K, Map<L, T>> = get(map) ?? new Map();
+    const n = m.get(value.key) ?? new Map();
+    if (typeof value.value === "undefined") {
+      n?.delete(value.key2);
+      if (n?.size === 0) {
+        m.delete(value.key);
+      }
+    } else {
+      n.set(value.key2, value.value);
+      m.set(value.key, n);
+    }
+    set(map, m);
+  });
+
+  return { get, set, getAll };
+}