@reearth/core 0.0.7-alpha.6 → 0.0.7-alpha.60

package/src/engines/Cesium/Feature/Polygon/index.tsx

@@ -54,6 +54,7 @@ export default function Polygon({
     fillColor,
     strokeColor,
     strokeWidth = 1,
+    height,
     heightReference: hr,
     shadows,
     extrudedHeight,
@@ -83,7 +84,7 @@ export default function Polygon({
       coordiantes && stroke && !disableWorkaround
         ? coordiantes.flatMap(hole => [
             // bottom
-            hole.map(c => Cartesian3.fromDegrees(c[0], c[1], c[2] ?? 0)),
+            hole.map(c => Cartesian3.fromDegrees(c[0], c[1], c[2] ?? height)),
             ...(extrudedHeight
               ? [
                   // top
@@ -92,14 +93,14 @@ export default function Polygon({
                   ...hole
                     .slice(0, -1)
                     .map(c => [
-                      Cartesian3.fromDegrees(c[0], c[1], 0),
+                      Cartesian3.fromDegrees(c[0], c[1], height ?? 0),
                       Cartesian3.fromDegrees(c[0], c[1], extrudedHeight),
                     ]),
                 ]
               : []),
           ])
         : [],
-    [coordiantes, stroke, disableWorkaround],
+    [coordiantes, stroke, disableWorkaround, height, extrudedHeight],
   );
 
   const memoStrokeColor = useMemo(
@@ -127,7 +128,7 @@ export default function Polygon({
   );
 
   const extrudedHeightProperty: { extrudedHeight: number } | undefined = useMemo(
-    () => (extrudedHeight ? { extrudedHeight } : undefined),
+    () => (extrudedHeight !== undefined ? { extrudedHeight } : undefined),
     [extrudedHeight],
   );
 
@@ -152,6 +153,7 @@ export default function Polygon({
           outline={!!memoStrokeColor}
           outlineColor={memoStrokeColor}
           outlineWidth={strokeWidth}
+          height={height}
           heightReference={heightReference(hr)}
           shadows={shadowMode(shadows)}
           distanceDisplayCondition={distanceDisplayCondition}

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

@@ -5,7 +5,6 @@ import { Map, Props } from "../../../../Map";
 
 export default {
   component: Map,
-  parameters: { actions: { argTypesRegex: "^on.*" } },
 } as Meta;
 
 const Template: StoryFn<Props> = args => <Map {...args} />;

package/src/engines/Cesium/Feature/Raster/mvt.ts

@@ -1,6 +1,7 @@
-import { MVTImageryProvider } from "@reearth/cesium-mvt-imagery-provider";
 import { useMemo } from "react";
 
+import { MVTImageryProvider } from "@reearth/cesium-mvt-imagery-provider";
+
 import { extractSimpleLayer } from "../utils";
 
 import { useData, useImageryProvider } from "./hooks";

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

@@ -5,7 +5,6 @@ import { Map, Props } from "../../../../Map";
 
 export default {
   component: Map,
-  parameters: { actions: { argTypesRegex: "^on.*" } },
 } as Meta;
 
 const Template: StoryFn<Props> = args => <Map {...args} />;

package/src/engines/Cesium/Feature/Resource/index.tsx

@@ -111,11 +111,6 @@ export default function Resource({
     [layer, viewer, onComputedFeatureFetch, type, requestRender],
   );
 
-  const initialClock = useRef({
-    start: timelineManagerRef?.current?.timeline?.start,
-    stop: timelineManagerRef?.current?.timeline?.stop,
-    current: timelineManagerRef?.current?.timeline?.current,
-  });
   const handleLoad = useCallback(
     (ds: DataSource) => {
       ds.entities.values.forEach(e =>
@@ -128,28 +123,7 @@ export default function Resource({
           });
         }),
       );
-      if (!updateClock) {
-        if (
-          initialClock.current.current &&
-          initialClock.current.start &&
-          initialClock.current.stop
-        ) {
-          timelineManagerRef?.current?.commit({
-            cmd: "SET_TIME",
-            payload: {
-              start: initialClock.current.start,
-              stop: initialClock.current.stop,
-              current: initialClock.current.current,
-            },
-            committer: {
-              source: "featureResource",
-              id: layer?.id,
-            },
-          });
-        }
-        return;
-      }
-      if (ds.clock) {
+      if (updateClock && ds.clock) {
         timelineManagerRef?.current?.commit({
           cmd: "SET_TIME",
           payload: {

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

@@ -1,15 +1,9 @@
-import {
-  Entity,
-  Cartesian3,
-  PolygonHierarchy,
-  PointGraphics,
-  BillboardGraphics,
-  JulianDate,
-} from "cesium";
+import { Entity, PointGraphics, BillboardGraphics, JulianDate } from "cesium";
 
 import { EvalFeature } from "../../..";
 import { AppearanceTypes, ComputedFeature, ComputedLayer, Feature } from "../../../../mantle";
-import { heightReference, shadowMode, toColor } from "../../common";
+import { heightReference, shadowMode, toColor, classificationType } from "../../common";
+import { getMarkerCoordinates, getGeometryFromEntity } from "../../helpers/getGeometryFromEntity";
 import { convertEntityDescription, convertEntityProperties } from "../../utils/utils";
 import { attachTag, extractSimpleLayer, getTag, Tag } from "../utils";
 
@@ -39,7 +33,7 @@ type EntityAppearanceKey<AName extends SupportedAppearanceKey> = AName extends "
   ? keyof Pick<Entity, "point" | "billboard" | "label">
   : keyof Pick<Entity, CesiumEntityAppearanceKey>;
 
-type AppearancePropertyKeyType = "color" | "heightReference" | "shadows";
+type AppearancePropertyKeyType = "color" | "heightReference" | "shadows" | "classificationType";
 
 export function attachProperties<
   AName extends SupportedAppearanceKey,
@@ -93,6 +87,9 @@ export function attachProperties<
         break;
       case "heightReference":
         value = heightReference(value);
+        break;
+      case "classificationType":
+        value = classificationType(value);
     }
 
     if (value === (entity[propertyName] as any)[entityPropertyKey]) {
@@ -132,16 +129,14 @@ export const attachStyle = (
   const point = hasAppearance(layer, entity, ["marker", "point"]);
   const billboard = hasAppearance(layer, entity, ["marker", "billboard"]);
   const label = hasAppearance(layer, entity, ["marker", "label"]);
-  if (point || billboard || label) {
-    const position = entity.position?.getValue(currentTime);
-    const coordinates = [position?.x ?? 0, position?.y ?? 0, position?.z ?? 0];
+  if (entity.point || entity.billboard || entity.label) {
+    const coordinates = getMarkerCoordinates(entity, currentTime);
+    const geometry = getGeometryFromEntity(currentTime, entity);
+
     const feature: Feature = {
       type: "feature",
       id: makeFeatureId(entity),
-      geometry: {
-        type: "Point",
-        coordinates,
-      },
+      geometry,
       properties: convertEntityProperties(currentTime, entity),
       metaData: {
         description: convertEntityDescription(currentTime, entity),
@@ -261,21 +256,14 @@ export const attachStyle = (
     return [feature, computedFeature];
   }
 
-  if (hasAppearance(layer, entity, ["polyline", "polyline"])) {
+  if (entity.polyline) {
     const entityPosition = entity.position?.getValue(currentTime);
-    const positions = entity.polyline?.positions?.getValue(currentTime) as Cartesian3[];
-    const coordinates = positions?.map(position => [
-      position?.x ?? 0,
-      position?.y ?? 0,
-      position?.z ?? 0,
-    ]);
+    const geometry = getGeometryFromEntity(currentTime, entity);
+
     const feature: Feature = {
       type: "feature",
       id: makeFeatureId(entity),
-      geometry: {
-        type: "LineString",
-        coordinates,
-      },
+      geometry,
       properties: convertEntityProperties(currentTime, entity),
       metaData: {
         description: convertEntityDescription(currentTime, entity),
@@ -290,42 +278,43 @@ export const attachStyle = (
     if (!computedFeature) {
       return;
     }
-    attachProperties(entity, computedFeature, ["polyline", "polyline"], {
-      show: {
-        name: "show",
-        default: true,
-      },
-      width: {
-        name: "strokeWidth",
-      },
-      material: {
-        name: "strokeColor",
-        type: "color",
-      },
-      shadows: {
-        name: "shadows",
-        type: "shadows",
-      },
-      clampToGround: {
-        name: "clampToGround",
-      },
-    });
+    if (hasAppearance(layer, entity, ["polyline", "polyline"])) {
+      attachProperties(entity, computedFeature, ["polyline", "polyline"], {
+        show: {
+          name: "show",
+          default: true,
+        },
+        width: {
+          name: "strokeWidth",
+        },
+        material: {
+          name: "strokeColor",
+          type: "color",
+        },
+        shadows: {
+          name: "shadows",
+          type: "shadows",
+        },
+        clampToGround: {
+          name: "clampToGround",
+        },
+        classificationType: {
+          name: "classificationType",
+          type: "classificationType",
+        },
+      });
+    }
     return [feature, computedFeature];
   }
 
-  if (hasAppearance(layer, entity, ["polygon", "polygon"])) {
+  if (entity.polygon) {
     const entityPosition = entity.position?.getValue(currentTime);
-    const hierarchy = entity.polygon?.hierarchy?.getValue(currentTime) as PolygonHierarchy;
-    const coordinates = hierarchy?.holes?.map(hole =>
-      hole.positions.map(position => [position?.x ?? 0, position?.y ?? 0, position?.z ?? 0]),
-    );
+    const geometry = getGeometryFromEntity(currentTime, entity);
+
     const feature: Feature = {
       type: "feature",
       id: makeFeatureId(entity),
-      geometry: {
-        type: "Polygon",
-        coordinates,
-      },
+      geometry,
       properties: convertEntityProperties(currentTime, entity),
       metaData: {
         description: convertEntityDescription(currentTime, entity),
@@ -340,40 +329,46 @@ export const attachStyle = (
     if (!computedFeature) {
       return;
     }
-    attachProperties(entity, computedFeature, ["polygon", "polygon"], {
-      show: {
-        name: "show",
-        default: true,
-      },
-      fill: {
-        name: "fill",
-      },
-      material: {
-        name: "fillColor",
-        type: "color",
-      },
-      outline: {
-        name: "stroke",
-      },
-      outlineColor: {
-        name: "strokeColor",
-        type: "color",
-      },
-      outlineWidth: {
-        name: "strokeWidth",
-      },
-      shadows: {
-        name: "shadows",
-        type: "shadows",
-      },
-      heightReference: {
-        name: "heightReference",
-        type: "heightReference",
-      },
-      extrudedHeight: {
-        name: "extrudedHeight",
-      },
-    });
+    if (hasAppearance(layer, entity, ["polygon", "polygon"])) {
+      attachProperties(entity, computedFeature, ["polygon", "polygon"], {
+        show: {
+          name: "show",
+          default: true,
+        },
+        fill: {
+          name: "fill",
+        },
+        material: {
+          name: "fillColor",
+          type: "color",
+        },
+        outline: {
+          name: "stroke",
+        },
+        outlineColor: {
+          name: "strokeColor",
+          type: "color",
+        },
+        outlineWidth: {
+          name: "strokeWidth",
+        },
+        shadows: {
+          name: "shadows",
+          type: "shadows",
+        },
+        heightReference: {
+          name: "heightReference",
+          type: "heightReference",
+        },
+        extrudedHeight: {
+          name: "extrudedHeight",
+        },
+        classificationType: {
+          name: "classificationType",
+          type: "classificationType",
+        },
+      });
+    }
     return [feature, computedFeature];
   }
 };