@hztxi/cesium-engine 25.0.6 → 26.2.1

package/Source/DataSources/PathGraphics.js

@@ -14,10 +14,11 @@ import createPropertyDescriptor from "./createPropertyDescriptor.js";
  * @property {Property | number} [leadTime] A Property specifying the number of seconds in front the object to show.
  * @property {Property | number} [trailTime] A Property specifying the number of seconds behind of the object to show.
  * @property {Property | number} [width=1.0] A numeric Property specifying the width in pixels.
- * @property {Property | number} [resolution=60] A numeric Property specifying the maximum number of seconds to step when sampling the position.
+ * @property {Property | number} [resolution=60] A numeric Property specifying the maximum number of seconds to step when sampling the position. Fractional positive values are allowed; in PORTIONS materialMode, non-positive values fall back to the default resolution of 60 seconds.
  * @property {MaterialProperty | Color} [material=Color.WHITE] A Property specifying the material used to draw the path.
  * @property {Property | DistanceDisplayCondition} [distanceDisplayCondition] A Property specifying at what distance from the camera that this path will be displayed.
  * @property {Property | string} [relativeTo] A Property specifying the frame in which to visualize the path. Use another entity's id to visualize the path relative to that entity, or use the string values "FIXED" or "INERTIAL" to visualize the path in those reference frames.
+ * @property {Property | PathMode} [materialMode] A Property specifying how material properties are applied along the path.
  */
 
 /**
@@ -46,6 +47,8 @@ function PathGraphics(options) {
   this._distanceDisplayConditionSubscription = undefined;
   this._relativeTo = undefined;
   this._relativeToSubscription = undefined;
+  this._materialMode = undefined;
+  this._materialModeSubscription = undefined;
 
   this.merge(options ?? Frozen.EMPTY_OBJECT);
 }
@@ -95,6 +98,7 @@ Object.defineProperties(PathGraphics.prototype, {
 
   /**
    * Gets or sets the Property specifying the maximum number of seconds to step when sampling the position.
+   * Fractional positive values are allowed; in PORTIONS materialMode, non-positive values fall back to the default resolution of 60 seconds.
    * @memberof PathGraphics.prototype
    * @type {Property|undefined}
    * @default 60
@@ -125,6 +129,7 @@ Object.defineProperties(PathGraphics.prototype, {
    * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
    */
   relativeTo: createPropertyDescriptor("relativeTo"),
+  materialMode: createPropertyDescriptor("materialMode"),
 });
 
 /**
@@ -145,6 +150,7 @@ PathGraphics.prototype.clone = function (result) {
   result.material = this.material;
   result.distanceDisplayCondition = this.distanceDisplayCondition;
   result.relativeTo = this.relativeTo;
+  result.materialMode = this.materialMode;
   return result;
 };
 
@@ -170,5 +176,6 @@ PathGraphics.prototype.merge = function (source) {
   this.distanceDisplayCondition =
     this.distanceDisplayCondition ?? source.distanceDisplayCondition;
   this.relativeTo = this.relativeTo ?? source.relativeTo;
+  this.materialMode = this.materialMode ?? source.materialMode;
 };
 export default PathGraphics;

package/Source/DataSources/PathMode.js

@@ -0,0 +1,27 @@
+// @ts-check
+
+/**
+ * Defines how material properties are applied along a path.
+ *
+ * @enum {number}
+ */
+const PathMode = {
+  /**
+   * The material is applied to the entire path as a whole.
+   * @type {number}
+   * @constant
+   */
+  WHOLE: 0,
+
+  /**
+   * The material is applied in portions based on temporal position information,
+   * using interval-based material properties.
+   * @type {number}
+   * @constant
+   */
+  PORTIONS: 1,
+};
+
+Object.freeze(PathMode);
+
+export default PathMode;

package/Source/DataSources/PathVisualizer.js

@@ -17,12 +17,14 @@ import CallbackPositionProperty from "./CallbackPositionProperty.js";
 import CompositePositionProperty from "./CompositePositionProperty.js";
 import ConstantPositionProperty from "./ConstantPositionProperty.js";
 import MaterialProperty from "./MaterialProperty.js";
+import PathMode from "./PathMode.js";
 import Property from "./Property.js";
 import ReferenceProperty from "./ReferenceProperty.js";
 import SampledPositionProperty from "./SampledPositionProperty.js";
 import ScaledPositionProperty from "./ScaledPositionProperty.js";
 import TimeIntervalCollectionPositionProperty from "./TimeIntervalCollectionPositionProperty.js";
 import Quaternion from "../Core/Quaternion.js";
+import arrayRemoveDuplicates from "../Core/arrayRemoveDuplicates.js";
 
 const update3DMatrix3Scratch1 = new Matrix3();
 const update3DMatrix3Scratch2 = new Matrix3();
@@ -210,6 +212,7 @@ const subSampleIntervalPropertyScratch = new TimeInterval();
 function EntityData(entity) {
   this.entity = entity;
   this.polyline = undefined;
+  this.segmentPolylines = [];
   this.index = undefined;
   this.updater = undefined;
 }
@@ -734,6 +737,111 @@ function subSample(
 const toFixedScratch = new Matrix3();
 const updateOrientationScratch = new Quaternion();
 const updateRotationScratch = new Matrix3();
+const portionsVisibleIntervalScratch = new TimeInterval();
+const portionsSegmentIntervalScratch = new TimeInterval();
+const portionsDynamicIntervalScratch = new TimeInterval();
+
+function getDynamicMaterialProperties(materialData) {
+  const dynamic = [];
+  if (!defined(materialData)) {
+    return dynamic;
+  }
+
+  for (const key in materialData) {
+    // Material properties store uniforms as underscored backing fields.
+    // Ignore event and subscription bookkeeping fields.
+    if (
+      key[0] !== "_" ||
+      key === "_definitionChanged" ||
+      key.endsWith("Subscription")
+    ) {
+      continue;
+    }
+
+    const prop = materialData[key];
+    if (
+      defined(prop) &&
+      typeof prop.getValue === "function" &&
+      !Property.isConstant(prop)
+    ) {
+      dynamic.push(prop);
+    }
+  }
+
+  return dynamic;
+}
+
+function emitSegmentsForSplitTimes(
+  splitTimes,
+  positionProperty,
+  time,
+  pathGraphics,
+  entity,
+  item,
+  polylineCollection,
+  resolution,
+  referenceFrame,
+  materialProp,
+  startingSegIndex,
+) {
+  // Sort and dedupe
+  splitTimes.sort(JulianDate.compare);
+  splitTimes = arrayRemoveDuplicates(splitTimes, JulianDate.equalsEpsilon);
+
+  let segIndex = startingSegIndex;
+  for (let j = 0; j < splitTimes.length - 1; j++) {
+    const splitStart = splitTimes[j];
+    const splitStop = splitTimes[j + 1];
+    if (!JulianDate.lessThan(splitStart, splitStop)) {
+      continue;
+    }
+
+    // Get segment midpoint
+    const splitMidTime = JulianDate.addSeconds(
+      splitStart,
+      JulianDate.secondsDifference(splitStop, splitStart) / 2,
+      new JulianDate(),
+    );
+
+    // Subsample positions
+    const subPositions = subSample(
+      positionProperty,
+      splitStart,
+      splitStop,
+      time,
+      referenceFrame,
+      resolution,
+      [],
+    );
+    if (subPositions.length < 2) {
+      continue;
+    }
+
+    // Get or create a polyline for this segment
+    let segPolyline = item.segmentPolylines[segIndex];
+    if (!defined(segPolyline)) {
+      segPolyline = polylineCollection.add();
+      segPolyline.id = entity;
+      item.segmentPolylines[segIndex] = segPolyline;
+    }
+    segPolyline.show = true;
+    segPolyline.positions = subPositions;
+    segPolyline.material = MaterialProperty.getValue(
+      splitMidTime,
+      materialProp,
+      segPolyline.material,
+    );
+    segPolyline.width = Property.getValueOrDefault(
+      pathGraphics._width,
+      time,
+      defaultWidth,
+    );
+
+    segIndex++;
+  }
+  return segIndex;
+}
+
 function PolylineUpdater(scene, referenceFrame) {
   this._unusedIndexes = [];
   this._polylineCollection = new PolylineCollection();
@@ -845,6 +953,9 @@ PolylineUpdater.prototype.updateObject = function (time, item) {
       polyline.show = false;
       item.index = undefined;
     }
+    for (let j = 0; j < item.segmentPolylines.length; j++) {
+      item.segmentPolylines[j].show = false;
+    }
     return;
   }
 
@@ -883,16 +994,198 @@ PolylineUpdater.prototype.updateObject = function (time, item) {
   // This can happen if the position is sampled at a time when it is only defined at a single point
   if (positions.length < 2) {
     polyline.show = false;
+    for (let j = 0; j < item.segmentPolylines.length; j++) {
+      item.segmentPolylines[j].show = false;
+    }
     return;
   }
 
   polyline.show = true;
   polyline.positions = positions;
+
   polyline.material = MaterialProperty.getValue(
     time,
-    pathGraphics._material,
+    pathGraphics.material,
     polyline.material,
   );
+
+  const materialMode = Property.getValueOrUndefined(
+    pathGraphics.materialMode,
+    time,
+  );
+  const materialProp = pathGraphics.material;
+  if (materialMode === PathMode.PORTIONS && !materialProp.isConstant) {
+    // Hide the single polyline if it exists
+    if (defined(polyline)) {
+      polyline.show = false;
+    }
+
+    // Prevent non-positive split steps from creating non-terminating loops.
+    // Positive fractional resolutions are valid; only values <= 0 fall back to the default.
+    const splitResolution = resolution > 0 ? resolution : defaultResolution;
+
+    const intervals = materialProp.intervals;
+    let nextSegIndex = 0;
+
+    if (!defined(intervals)) {
+      // Sampled/interpolated root material - generate synthetic times at resolution intervals
+      const splitTimes = [
+        JulianDate.clone(sampleStart),
+        JulianDate.clone(sampleStop),
+      ];
+      let splitTime = JulianDate.addSeconds(
+        sampleStart,
+        splitResolution,
+        new JulianDate(),
+      );
+      while (JulianDate.lessThan(splitTime, sampleStop)) {
+        splitTimes.push(JulianDate.clone(splitTime));
+        splitTime = JulianDate.addSeconds(
+          splitTime,
+          splitResolution,
+          new JulianDate(),
+        );
+      }
+      nextSegIndex = emitSegmentsForSplitTimes(
+        splitTimes,
+        positionProperty,
+        time,
+        pathGraphics,
+        entity,
+        item,
+        this._polylineCollection,
+        splitResolution,
+        this._referenceFrame,
+        pathGraphics.material,
+        nextSegIndex,
+      );
+    } else {
+      portionsVisibleIntervalScratch.start = sampleStart;
+      portionsVisibleIntervalScratch.stop = sampleStop;
+      portionsVisibleIntervalScratch.isStartIncluded = true;
+      portionsVisibleIntervalScratch.isStopIncluded = true;
+
+      // Interval-based material - process each interval separately
+      for (let i = 0; i < intervals.length; i++) {
+        const interval = intervals.get(i);
+
+        if (
+          !TimeInterval.intersect(
+            interval,
+            portionsVisibleIntervalScratch,
+            portionsSegmentIntervalScratch,
+          )
+        ) {
+          continue;
+        }
+
+        const segStart = portionsSegmentIntervalScratch.start;
+        const segStop = portionsSegmentIntervalScratch.stop;
+
+        if (JulianDate.greaterThanOrEquals(segStart, segStop)) {
+          continue;
+        }
+
+        // Detect dynamic properties and collect their split times
+        const dynamic = getDynamicMaterialProperties(interval.data);
+        const splitTimes = [
+          JulianDate.clone(segStart),
+          JulianDate.clone(segStop),
+        ];
+
+        for (let j = 0; j < dynamic.length; j++) {
+          const prop = dynamic[j];
+          const timeDynamicIntervals = prop.intervals;
+
+          if (defined(timeDynamicIntervals)) {
+            // Interval-based property: collect interval boundaries
+            for (let k = 0; k < timeDynamicIntervals.length; k++) {
+              const timeDynamicInterval = timeDynamicIntervals.get(k);
+
+              if (
+                !TimeInterval.intersect(
+                  timeDynamicInterval,
+                  portionsSegmentIntervalScratch,
+                  portionsDynamicIntervalScratch,
+                )
+              ) {
+                continue;
+              }
+
+              if (
+                JulianDate.greaterThan(
+                  portionsDynamicIntervalScratch.start,
+                  segStart,
+                ) &&
+                JulianDate.lessThan(
+                  portionsDynamicIntervalScratch.start,
+                  segStop,
+                )
+              ) {
+                splitTimes.push(
+                  JulianDate.clone(portionsDynamicIntervalScratch.start),
+                );
+              }
+
+              if (
+                JulianDate.greaterThan(
+                  portionsDynamicIntervalScratch.stop,
+                  segStart,
+                ) &&
+                JulianDate.lessThan(
+                  portionsDynamicIntervalScratch.stop,
+                  segStop,
+                )
+              ) {
+                splitTimes.push(
+                  JulianDate.clone(portionsDynamicIntervalScratch.stop),
+                );
+              }
+            }
+          } else if (!Property.isConstant(prop)) {
+            // Sampled/interpolated property: add resolution-based split times
+            let sampledTime = JulianDate.clone(segStart);
+            while (JulianDate.lessThan(sampledTime, segStop)) {
+              splitTimes.push(JulianDate.clone(sampledTime));
+              sampledTime = JulianDate.addSeconds(
+                sampledTime,
+                splitResolution,
+                new JulianDate(),
+              );
+            }
+          }
+        }
+
+        // Emit segments for this interval's split times
+        nextSegIndex = emitSegmentsForSplitTimes(
+          splitTimes,
+          positionProperty,
+          time,
+          pathGraphics,
+          entity,
+          item,
+          this._polylineCollection,
+          splitResolution,
+          this._referenceFrame,
+          interval.data,
+          nextSegIndex,
+        );
+      }
+    }
+
+    // Hide any excess segment polylines from previous frames.
+    for (let j = nextSegIndex; j < item.segmentPolylines.length; j++) {
+      if (defined(item.segmentPolylines[j])) {
+        item.segmentPolylines[j].show = false;
+      }
+    }
+  } else {
+    // Not in PORTIONS mode, hide all segment polylines from previous frames
+    for (let j = 0; j < item.segmentPolylines.length; j++) {
+      item.segmentPolylines[j].show = false;
+    }
+  }
+
   polyline.width = Property.getValueOrDefault(
     pathGraphics._width,
     time,
@@ -914,6 +1207,10 @@ PolylineUpdater.prototype.removeObject = function (item) {
     polyline.id = undefined;
     item.index = undefined;
   }
+  for (let i = 0; i < item.segmentPolylines.length; i++) {
+    item.segmentPolylines[i].show = false;
+  }
+  item.segmentPolylines.length = 0;
 };
 
 PolylineUpdater.prototype.destroy = function () {

package/Source/DataSources/PolylineGeometryUpdater.js

@@ -649,6 +649,8 @@ function DynamicGeometryUpdater(primitives, groundPrimitives, geometryUpdater) {
   this._primitives = primitives;
   this._groundPrimitives = groundPrimitives;
   this._groundPolylinePrimitive = undefined;
+  this._groundGeometrySignature = undefined;
+  this._colorAppearance = undefined;
   this._material = undefined;
   this._geometryUpdater = geometryUpdater;
   this._positions = [];
@@ -692,6 +694,81 @@ function invalidateGroundPolylinePrimitiveGeometry(groundPolylinePrimitive) {
   groundPolylinePrimitive._spMorph = undefined;
 }
 
+/**
+ * Compares the evaluated ground polyline geometry attributes with the ones the
+ * current primitive was built from and refreshes the stored signature.
+ * Returns true when the primitive has to be rebuilt.
+ *
+ * Entity polylines driven by a dynamic property (e.g. a CallbackProperty used
+ * by the editors) are evaluated every frame. Editors usually return the same
+ * positions frame after frame - the camera moves, not the line - so rebuilding
+ * the ground polyline primitive unconditionally would destroy its vertex
+ * arrays and shader programs on every rendered frame, which is very expensive
+ * and makes the line flicker while the view changes.
+ *
+ * @private
+ */
+function updateGroundPolylineSignature(
+  dynamicUpdater,
+  positions,
+  width,
+  arcType,
+  granularity,
+  color,
+) {
+  const length = positions.length;
+  const previous = dynamicUpdater._groundGeometrySignature;
+  const sameLength = defined(previous) && previous.xyz.length === length * 3;
+  const xyz = sameLength ? previous.xyz : new Float64Array(length * 3);
+  const colorChanged =
+    !sameLength ||
+    !defined(previous.color) !== !defined(color) ||
+    (defined(color) &&
+      (previous.color.red !== color.red ||
+        previous.color.green !== color.green ||
+        previous.color.blue !== color.blue ||
+        previous.color.alpha !== color.alpha));
+  let changed =
+    !sameLength ||
+    colorChanged ||
+    previous.width !== width ||
+    previous.arcType !== arcType ||
+    previous.granularity !== granularity;
+
+  // Compare the positions by value: the editors move the nodes of the line
+  // while the property keeps returning an array of the same length, so only
+  // the coordinates tell an edit from a plain re-evaluation.
+  for (let i = 0, j = 0; i < length; ++i) {
+    const position = positions[i];
+    const x = position.x;
+    const y = position.y;
+    const z = position.z;
+    if (!sameLength || xyz[j] !== x || xyz[j + 1] !== y || xyz[j + 2] !== z) {
+      changed = true;
+    }
+    xyz[j++] = x;
+    xyz[j++] = y;
+    xyz[j++] = z;
+  }
+
+  dynamicUpdater._groundGeometrySignature = {
+    xyz,
+    width,
+    arcType,
+    granularity,
+    // Copy the components: colors are evaluated into shared scratch objects.
+    color: defined(color)
+      ? {
+          red: color.red,
+          green: color.green,
+          blue: color.blue,
+          alpha: color.alpha,
+        }
+      : undefined,
+  };
+  return changed;
+}
+
 DynamicGeometryUpdater.prototype.update = function (time) {
   const geometryUpdater = this._geometryUpdater;
   const entity = geometryUpdater._entity;
@@ -754,9 +831,45 @@ DynamicGeometryUpdater.prototype.update = function (time) {
     }
 
     const fillMaterialProperty = geometryUpdater.fillMaterialProperty;
+    const isColorMaterial =
+      fillMaterialProperty instanceof ColorMaterialProperty;
+
+    // Per-instance attributes (show, distance display condition and the
+    // material color) are baked into the geometry instance, so any animated
+    // one of them requires a rebuild every frame.
+    const attributesAnimated =
+      !Property.isConstant(polyline._show) ||
+      !Property.isConstant(geometryUpdater._distanceDisplayConditionProperty) ||
+      (isColorMaterial &&
+        defined(fillMaterialProperty.color) &&
+        !Property.isConstant(fillMaterialProperty.color));
+
+    // The per-instance color is part of the geometry instance as well.
+    const colorAttribute =
+      isColorMaterial && defined(fillMaterialProperty.color)
+        ? fillMaterialProperty.color.getValue(time, scratchColor)
+        : undefined;
+
+    // Only rebuild the ground polyline primitive when the evaluated geometry
+    // actually changed. See updateGroundPolylineSignature.
+    const geometryChanged =
+      attributesAnimated ||
+      updateGroundPolylineSignature(
+        this,
+        positions,
+        geometryUpdater._groundGeometryOptions.width,
+        geometryUpdater._groundGeometryOptions.arcType,
+        geometryUpdater._groundGeometryOptions.granularity,
+        colorAttribute,
+      );
+
     let appearance;
-    if (fillMaterialProperty instanceof ColorMaterialProperty) {
-      appearance = new PolylineColorAppearance();
+    if (isColorMaterial) {
+      // Reuse one appearance instance: assigning a new appearance makes the
+      // primitive rebuild its render states and shader programs.
+      appearance =
+        this._colorAppearance ??
+        (this._colorAppearance = new PolylineColorAppearance());
     } else {
       const material = MaterialProperty.getValue(
         time,
@@ -770,7 +883,6 @@ DynamicGeometryUpdater.prototype.update = function (time) {
       this._material = material;
     }
 
-    const geometryInstance = geometryUpdater.createFillGeometryInstance(time);
     const classificationType =
       geometryUpdater.classificationTypeProperty.getValue(time);
     const zIndex = Property.getValueOrUndefined(geometryUpdater.zIndex, time);
@@ -779,7 +891,7 @@ DynamicGeometryUpdater.prototype.update = function (time) {
     if (!defined(this._groundPolylinePrimitive)) {
       this._groundPolylinePrimitive = groundPrimitives.add(
         new GroundPolylinePrimitive({
-          geometryInstances: geometryInstance,
+          geometryInstances: geometryUpdater.createFillGeometryInstance(time),
           appearance: appearance,
           classificationType: classificationType,
           asynchronous: false,
@@ -791,9 +903,15 @@ DynamicGeometryUpdater.prototype.update = function (time) {
       if (groundPolylinePrimitive._zIndex !== zIndexKey) {
         groundPrimitives.set(groundPolylinePrimitive, zIndexKey);
       }
-      groundPolylinePrimitive.geometryInstances = geometryInstance;
-      invalidateGroundPolylinePrimitiveGeometry(groundPolylinePrimitive);
-      groundPolylinePrimitive.appearance = appearance;
+      if (geometryChanged) {
+        groundPolylinePrimitive.geometryInstances =
+          geometryUpdater.createFillGeometryInstance(time);
+        invalidateGroundPolylinePrimitiveGeometry(groundPolylinePrimitive);
+      }
+      // Animated materials still need their uniforms refreshed per frame.
+      if (geometryChanged || !isColorMaterial) {
+        groundPolylinePrimitive.appearance = appearance;
+      }
       groundPolylinePrimitive.classificationType = classificationType;
     }
 

package/Source/DataSources/PolylineVisualizer.js

@@ -298,7 +298,7 @@ PolylineVisualizer.prototype.getBoundingSphere = function (entity, result) {
   const tmp = getBoundingSphereBoundingSphereScratch;
 
   let count = 0;
-  let state = BoundingSphereState.DONE;
+  let state;
   const batches = this._batches;
   const batchesLength = batches.length;
   const updater = this._updaters.get(entity.id);

package/Source/DataSources/StaticOutlineGeometryBatch.js

@@ -375,7 +375,7 @@ StaticOutlineGeometryBatch.prototype.update = function (time) {
   const translucentBatchesLength = translucentBatches.length;
   let itemsToRemove;
   let isUpdated = true;
-  let needUpdate = false;
+  let needUpdate;
 
   do {
     needUpdate = false;

package/Source/Renderer/AutomaticUniforms.js

@@ -222,6 +222,29 @@ const AutomaticUniforms = {
     },
   }),
 
+  /**
+   * An automatic GLSL uniform containing the feature-ID texture produced by
+   * the planar fill pre-pass (BENTLEY_materials_planar_fill). Non-behind
+   * planar fill geometry writes its per-fragment feature ID here so that
+   * behind fills can test whether the existing pixel belongs to the same
+   * logical object.
+   *
+   * @example
+   * // GLSL declaration
+   * uniform sampler2D czm_planarFillIdTexture;
+   *
+   * // Sample
+   * vec2 coords = gl_FragCoord.xy / czm_viewport.zw;
+   * float existingFeatureId = texture(czm_planarFillIdTexture, coords).r;
+   */
+  czm_planarFillIdTexture: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.SAMPLER_2D,
+    getValue: function (uniformState) {
+      return uniformState.planarFillIdTexture;
+    },
+  }),
+
   /**
    * An automatic GLSL uniform representing a 4x4 model transformation matrix that
    * transforms model coordinates to world coordinates.

package/Source/Renderer/Context.js

@@ -1011,20 +1011,26 @@ Object.defineProperties(Context.prototype, {
   },
 
   /**
-   * A 1x1 RGBA texture initialized to [255, 255, 255, 255].  This can
-   * be used as a placeholder texture while other textures are downloaded.
+   * A 1x1 RGBA texture initialized to the color defined by {@link Texture.defaultColor}.
+   * This can be used as a placeholder texture while other textures are downloaded.
    * @memberof Context.prototype
    * @type {Texture}
    */
   defaultTexture: {
     get: function () {
       if (this._defaultTexture === undefined) {
+        const color = Texture.defaultColor;
         this._defaultTexture = new Texture({
           context: this,
           source: {
             width: 1,
             height: 1,
-            arrayBufferView: new Uint8Array([255, 255, 255, 255]),
+            arrayBufferView: new Uint8Array([
+              color.red * 255,
+              color.green * 255,
+              color.blue * 255,
+              color.alpha * 255,
+            ]),
           },
           flipY: false,
         });