@woosh/meep-engine 2.47.42 → 2.48.1

package/src/engine/graphics/render/frame_graph/TextureDescriptor.js

@@ -1,4 +1,4 @@
-import { DataType } from "../../../../core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 
 export const TextureInitialState = {
     /**
@@ -26,9 +26,9 @@ export class TextureDescriptor {
 
         /**
          * Render texture type
-         * @type {DataType}
+         * @type {BinaryDataType}
          */
-        this.format = DataType.Uint8;
+        this.format = BinaryDataType.Uint8;
 
         /**
          *
@@ -46,7 +46,7 @@ export class TextureDescriptor {
     static from({
                     height = 0,
                     width = 0,
-                    format = DataType.Uint8,
+                    format = BinaryDataType.Uint8,
                     channel_count = 1,
                     initial_state = TextureInitialState.Clear
                 }) {

package/src/engine/graphics/render/frame_graph/sample/meep-v1/ColorDepthPass.js

@@ -1,7 +1,7 @@
 import { RenderPass } from "../../RenderPass.js";
 import { TextureDescriptor } from "../../TextureDescriptor.js";
 import Vector2 from "../../../../../../core/geom/Vector2.js";
-import { DataType } from "../../../../../../core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../../../../core/binary/type/BinaryDataType.js";
 
 export class ColorDepthPass extends RenderPass {
     resolution = new Vector2(1024, 724);
@@ -10,7 +10,7 @@ export class ColorDepthPass extends RenderPass {
         const color = builder.create("Color", TextureDescriptor.from({
             width: this.resolution.x,
             height: this.resolution.y,
-            format: DataType.Uint8,
+            format: BinaryDataType.Uint8,
             channel_count: 4
         }));
 
@@ -19,7 +19,7 @@ export class ColorDepthPass extends RenderPass {
         const depth = builder.create("Depth", TextureDescriptor.from({
             width: this.resolution.x,
             height: this.resolution.y,
-            format: DataType.Float32,
+            format: BinaryDataType.Float32,
             channel_count: 4
         }));
 

package/src/engine/graphics/texture/atlas/TextureAtlas.js

@@ -7,10 +7,10 @@ import { AtlasPatch } from "./AtlasPatch.js";
 import { AtlasPatchFlag } from "./AtlasPatchFlag.js";
 import Signal from "../../../../core/events/signal/Signal.js";
 import { assert } from "../../../../core/assert.js";
-import { DataType } from "../../../../core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import {
     DataType2TypedArrayConstructorMapping
-} from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+} from "../../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
 import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
 import { invokeObjectClone } from "../../../../core/model/object/invokeObjectClone.js";
 import { ceilPowerOfTwo } from "../../../../core/binary/operations/ceilPowerOfTwo.js";
@@ -19,15 +19,15 @@ export class TextureAtlas extends AbstractTextureAtlas {
     /**
      *
      * @param {number} [size]
-     * @param {DataType} [data_type]
+     * @param {BinaryDataType} [data_type]
      * @param {number} [channel_count]
      * @constructor
      */
-    constructor(size = 16, data_type = DataType.Uint8, channel_count = 4) {
+    constructor(size = 16, data_type = BinaryDataType.Uint8, channel_count = 4) {
         super();
 
         assert.isNonNegativeInteger(size, 'size');
-        assert.enum(data_type, DataType, 'data_type');
+        assert.enum(data_type, BinaryDataType, 'data_type');
         assert.isNonNegativeInteger(channel_count, 'channel_count');
 
         /**

package/src/engine/graphics/texture/normalized_internal_format.js

@@ -1,10 +1,10 @@
-import { DataType } from "../../../core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
 import { assert } from "../../../core/assert.js";
 
 /**
  *
  * @returns {string}
- * @param {DataType} dt
+ * @param {BinaryDataType} dt
  * @param {number} channel_count
  */
 export function normalized_internal_format(dt, channel_count) {
@@ -12,13 +12,13 @@ export function normalized_internal_format(dt, channel_count) {
 
     let suffix = '';
     switch (dt) {
-        case DataType.Uint8:
+        case BinaryDataType.Uint8:
             suffix = '8';
             break;
-        case DataType.Int8:
+        case BinaryDataType.Int8:
             suffix = '8_SNORM';
             break;
-        case DataType.Uint16:
+        case BinaryDataType.Uint16:
             suffix = '16UI';
             break;
         default:

package/src/engine/graphics/texture/sampler/Sampler2D.js

@@ -13,31 +13,33 @@ import { typedArrayConstructorByInstance } from "./typedArrayConstructorByInstan
 import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
 import {
     compute_typed_array_constructor_from_data_type
-} from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+} from "../../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
 import { Base64 } from "../../../../core/binary/Base64.js";
 import { computeStridedIntegerArrayHash } from "../../../computeStridedIntegerArrayHash.js";
 import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
 
 /**
+ * Data Texture class, providing an abstraction around 2d numerical arrays, mostly for sampling purposes
+ * Inspired by OpenGL's glsl sampler2d API
  * @class
  */
 export class Sampler2D {
     /**
      *
      * @param {ArrayLike<number>|number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} data
-     * @param {number} itemSize
-     * @param {number} width
-     * @param {number} height
+     * @param {number} [itemSize]
+     * @param {number} [width]
+     * @param {number} [height]
      * @constructor
      */
     constructor(data = [], itemSize = 1, width = 0, height = 0) {
         if (!Number.isInteger(itemSize) || itemSize < 0) {
             throw new Error(`itemSize must be a non-negative integer, instead was ${itemSize}`);
         }
-        if (!Number.isInteger(width) || itemSize < 0) {
+        if (!Number.isInteger(width) || width < 0) {
             throw new Error(`width must be a non-negative integer, instead was ${width}`);
         }
-        if (!Number.isInteger(height) || itemSize < 0) {
+        if (!Number.isInteger(height) || width < 0) {
             throw new Error(`height must be a non-negative integer, instead was ${height}`);
         }
 
@@ -86,7 +88,7 @@ export class Sampler2D {
      * @returns {{x: number, index: number, y: number, value: number}}
      */
     computeMax(channel = 0) {
-       throw new Error("deprecated, use sampler2d_channel_compute_max");
+        throw new Error("deprecated, use sampler2d_channel_compute_max");
     }
 
     /**
@@ -205,7 +207,7 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelCatmullRom(x, y, channel) {
-        // We're going to sample a a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
+        // We're going to sample a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
         // down the sample location to get the exact center of our "starting" texel. The starting texel will be at
         // location [1, 1] in the grid, where [0, 0] is the top-left corner.
         const texPos1_x = Math.floor(x - 0.5) + 0.5;
@@ -583,31 +585,6 @@ export class Sampler2D {
         return temp[0];
     }
 
-    /**
-     *
-     * @param {number} index
-     * @param {number[]} result
-     */
-    computeNeighbors(index, result) {
-        const width = this.width;
-        const height = this.height;
-
-        const x = index % width;
-        const y = (index / width) | 0;
-        if (x > 0) {
-            result.push(index - 1);
-        }
-        if (x < width - 1) {
-            result.push(index + 1);
-        }
-        if (y > 0) {
-            result.push(index - width);
-        }
-        if (y < height - 1) {
-            result.push(index + width);
-        }
-    }
-
     /**
      *
      * @param {number} x
@@ -1351,8 +1328,7 @@ export class Sampler2D {
      */
     static uint8clamped(itemSize, width, height) {
         const data = new Uint8ClampedArray(width * height * itemSize);
-        const sampler = new Sampler2D(data, itemSize, width, height);
-        return sampler;
+        return new Sampler2D(data, itemSize, width, height);
     }
 
     /**
@@ -1364,8 +1340,7 @@ export class Sampler2D {
      */
     static uint8(itemSize, width, height) {
         const data = new Uint8Array(width * height * itemSize);
-        const sampler = new Sampler2D(data, itemSize, width, height);
-        return sampler;
+        return new Sampler2D(data, itemSize, width, height);
     }
 
     /**
@@ -1377,8 +1352,7 @@ export class Sampler2D {
      */
     static uint16(itemSize, width, height) {
         const data = new Uint16Array(width * height * itemSize);
-        const sampler = new Sampler2D(data, itemSize, width, height);
-        return sampler;
+        return new Sampler2D(data, itemSize, width, height);
     }
 
     /**
@@ -1390,8 +1364,7 @@ export class Sampler2D {
      */
     static uint32(itemSize, width, height) {
         const data = new Uint32Array(width * height * itemSize);
-        const sampler = new Sampler2D(data, itemSize, width, height);
-        return sampler;
+        return new Sampler2D(data, itemSize, width, height);
     }
 
     /**
@@ -1403,8 +1376,7 @@ export class Sampler2D {
      */
     static int8(itemSize, width, height) {
         const data = new Int8Array(width * height * itemSize);
-        const sampler = new Sampler2D(data, itemSize, width, height);
-        return sampler;
+        return new Sampler2D(data, itemSize, width, height);
     }
 
     /**
@@ -1416,8 +1388,7 @@ export class Sampler2D {
      */
     static int16(itemSize, width, height) {
         const data = new Int16Array(width * height * itemSize);
-        const sampler = new Sampler2D(data, itemSize, width, height);
-        return sampler;
+        return new Sampler2D(data, itemSize, width, height);
     }
 
     /**
@@ -1429,8 +1400,7 @@ export class Sampler2D {
      */
     static int32(itemSize, width, height) {
         const data = new Int32Array(width * height * itemSize);
-        const sampler = new Sampler2D(data, itemSize, width, height);
-        return sampler;
+        return new Sampler2D(data, itemSize, width, height);
     }
 
     /**
@@ -1442,8 +1412,7 @@ export class Sampler2D {
      */
     static float32(itemSize, width, height) {
         const data = new Float32Array(width * height * itemSize);
-        const sampler = new Sampler2D(data, itemSize, width, height);
-        return sampler;
+        return new Sampler2D(data, itemSize, width, height);
     }
 
     /**
@@ -1455,8 +1424,7 @@ export class Sampler2D {
      */
     static float64(itemSize, width, height) {
         const data = new Float64Array(width * height * itemSize);
-        const sampler = new Sampler2D(data, itemSize, width, height);
-        return sampler;
+        return new Sampler2D(data, itemSize, width, height);
     }
 
 }
@@ -1467,6 +1435,12 @@ export class Sampler2D {
  */
 Sampler2D.prototype.isSampler2D = true;
 
+/**
+ * @readonly
+ * @type {string}
+ */
+Sampler2D.typeName = "Sampler2D";
+
 /**
  * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
  * @param {number} t

package/src/engine/graphics/texture/sampler/sampler2DToFloat32Texture.js

@@ -4,7 +4,7 @@ import { channelCountToThreeTextureFormat } from "../channelCountToThreeTextureF
 import {
     computeThreeTextureInternalFormatFromDataType
 } from "../../render/forward_plus/data/computeThreeTextureInternalFormatFromDataType.js";
-import { DataType } from "../../../../core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 
 /**
  *
@@ -31,7 +31,7 @@ export function sampler2DtoFloat32Texture(sampler) {
 
     texture.type = FloatType;
     texture.format = channelCountToThreeTextureFormat(sampler.itemSize);
-    texture.internalFormat = computeThreeTextureInternalFormatFromDataType(DataType.Float32, sampler.itemSize);
+    texture.internalFormat = computeThreeTextureInternalFormatFromDataType(BinaryDataType.Float32, sampler.itemSize);
 
     texture.needsUpdate = true;
 

package/src/engine/graphics/texture/sampler/sampler2d_compute_texel_value_conversion_scale_to_uint8.js

@@ -1,4 +1,4 @@
-import { DataType } from "../../../../core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import { min2 } from "../../../../core/math/min2.js";
 import { max2 } from "../../../../core/math/max2.js";
 import { isTypedArray } from "../../../../core/collection/array/typed/isTypedArray.js";
@@ -19,12 +19,12 @@ export function sampler2d_compute_texel_value_conversion_scale_to_uint8(sampler)
         dataType = typedArrayToDataType(sampler.data);
     } else {
         // plain numeric array
-        dataType = DataType.Float32;
+        dataType = BinaryDataType.Float32;
     }
 
     let min = 0, max = 0;
 
-    if (dataType === DataType.Uint8) {
+    if (dataType === BinaryDataType.Uint8) {
         min = 0;
         max = 255;
     } else {

package/src/engine/graphics/texture/sampler/{TextureBinaryBufferSerializer.js → serialization/TextureBinaryBufferSerializer.js}

@@ -1,45 +1,16 @@
-import { DataTypeIndices } from "../../../../core/collection/table/DataTypeIndices.js";
-import { Sampler2D } from "./Sampler2D.js";
-import { EndianType } from "../../../../core/binary/BinaryBuffer.js";
-import { DataType } from "../../../../core/collection/table/DataType.js";
-import { assert } from "../../../../core/assert.js";
-import { DataTypeByteSizes } from "../../../../core/collection/table/DataTypeByteSizes.js";
+import { DataTypeIndices } from "../../../../../core/binary/type/DataTypeIndices.js";
+import { Sampler2D } from "../Sampler2D.js";
+import { EndianType } from "../../../../../core/binary/BinaryBuffer.js";
+import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
+import { assert } from "../../../../../core/assert.js";
+import { DataTypeByteSizes } from "../../../../../core/binary/type/DataTypeByteSizes.js";
+import { dataTypeFromTypedArray } from "../../../../../core/binary/type/dataTypeFromTypedArray.js";
 
 
-/**
- *
- * @param {TypedArray} arr
- * @returns {DataType}
- */
-function dataTypeFromTypedArray(arr) {
-    if (arr instanceof Float32Array) {
-        return DataType.Float32;
-    } else if (arr instanceof Float64Array) {
-        return DataType.Float64;
-    } else if (arr instanceof Uint8Array) {
-        return DataType.Uint8;
-    } else if (arr instanceof Uint16Array) {
-        return DataType.Uint16;
-    } else if (arr instanceof Uint32Array) {
-        return DataType.Uint32;
-    } else if (arr instanceof Int8Array) {
-        return DataType.Int8;
-    } else if (arr instanceof Int16Array) {
-        return DataType.Int16;
-    } else if (arr instanceof Int32Array) {
-        return DataType.Int32;
-    } else if (arr instanceof Array) {
-        //if array is untyped, use Float64 as numbers in JS are 64 bit
-        return DataType.Float64;
-    } else {
-        throw new TypeError(`Unknown array type`);
-    }
-}
-
 /**
  *
  * @param {number} index
- * @returns {DataType}
+ * @returns {BinaryDataType}
  */
 function dataTypeByTypeIndex(index) {
     for (let type in DataTypeIndices) {
@@ -55,7 +26,7 @@ function dataTypeByTypeIndex(index) {
 /**
  *
  * @param {BinaryBuffer} buffer
- * @param {DataType} type
+ * @param {BinaryDataType} type
  * @param {number} length
  */
 function readTypedArray(buffer, type, length) {
@@ -64,35 +35,35 @@ function readTypedArray(buffer, type, length) {
 
     let result = null;
     switch (type) {
-        case DataType.Uint8:
+        case BinaryDataType.Uint8:
             result = new Uint8Array(length);
             buffer.readUint8Array(result, 0, length);
             break;
-        case DataType.Uint16:
+        case BinaryDataType.Uint16:
             result = new Uint16Array(length);
             buffer.readUint16Array(result, 0, length);
             break;
-        case DataType.Uint32:
+        case BinaryDataType.Uint32:
             result = new Uint32Array(length);
             buffer.readUint32Array(result, 0, length);
             break;
-        case DataType.Int8:
+        case BinaryDataType.Int8:
             result = new Int8Array(length);
             buffer.readInt8Array(result, 0, length);
             break;
-        case DataType.Int16:
+        case BinaryDataType.Int16:
             result = new Int16Array(length);
             buffer.readInt16Array(result, 0, length);
             break;
-        case DataType.Int32:
+        case BinaryDataType.Int32:
             result = new Int32Array(length);
             buffer.readInt32Array(result, 0, length);
             break;
-        case DataType.Float32:
+        case BinaryDataType.Float32:
             result = new Float32Array(length);
             buffer.readFloat32Array(result, 0, length);
             break;
-        case DataType.Float64:
+        case BinaryDataType.Float64:
             result = new Float64Array(length);
             buffer.readFloat64Array(result, 0, length);
             break;

package/src/engine/graphics/texture/sampler/{TextureBinaryBufferSerializer.spec.js → serialization/TextureBinaryBufferSerializer.spec.js}

@@ -1,6 +1,6 @@
-import { Sampler2D } from "./Sampler2D.js";
+import { Sampler2D } from "../Sampler2D.js";
 import { deserializeTexture, serializeTexture } from "./TextureBinaryBufferSerializer.js";
-import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 
 function makeSample() {
     const width = 3;

package/src/engine/graphics/trail/TemporalPath.js

@@ -1,5 +1,5 @@
 import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
-import { DataType } from "../../../core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
 
 
 function TemporalPath() {
@@ -20,8 +20,8 @@ function TemporalPath() {
      * @type {RowFirstTable}
      */
     this.data = new RowFirstTable([
-        DataType.Float32,
-        DataType.Float32, DataType.Float32, DataType.Float32
+        BinaryDataType.Float32,
+        BinaryDataType.Float32, BinaryDataType.Float32, BinaryDataType.Float32
     ]);
 }
 

package/src/engine/graphics/trail/x/ribbon_attributes_spec.js

@@ -1,42 +1,42 @@
 import { RowFirstTableSpec } from "../../../../core/collection/table/RowFirstTableSpec.js";
-import { DataType } from "../../../../core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import { EndianType } from "../../../../core/binary/BinaryBuffer.js";
 
 export const ribbon_attributes_spec = new RowFirstTableSpec([
     // age
-    DataType.Float32,
+    BinaryDataType.Float32,
 
     // position
-    DataType.Float32,
-    DataType.Float32,
-    DataType.Float32,
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
 
     // UV (uv is recorded as a single coordinate)
-    DataType.Float32,
+    BinaryDataType.Float32,
 
     // alpha
-    DataType.Float32,
+    BinaryDataType.Float32,
 
     // color
-    DataType.Uint8,
-    DataType.Uint8,
-    DataType.Uint8,
+    BinaryDataType.Uint8,
+    BinaryDataType.Uint8,
+    BinaryDataType.Uint8,
 
     // Offset attribute
-    DataType.Uint8,
+    BinaryDataType.Uint8,
 
     // Previous point
-    DataType.Float32,
-    DataType.Float32,
-    DataType.Float32,
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
 
     // Next point
-    DataType.Float32,
-    DataType.Float32,
-    DataType.Float32,
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
+    BinaryDataType.Float32,
 
     // thickness
-    DataType.Float32,
+    BinaryDataType.Float32,
 
 ], EndianType.LittleEndian);
 

package/src/engine/intelligence/behavior/util/behavior_traverse_tree.js

@@ -1,6 +1,6 @@
 /**
  *
- * @param {Behavior} root
+ * @param {Behavior|CompositeBehavior|AbstractDecoratorBehavior} root
  * @param {function(Behavior):boolean?} visitor
  * @param {*} [thisArg]
  */
@@ -26,7 +26,7 @@ export function behavior_traverse_tree(root, visitor, thisArg) {
         }
     }
 
-    if (root.isCompositeBehavior === true) {
+    if (root.isDecoratorBehavior === true) {
 
         const source = root.getSource();
         behavior_traverse_tree(source, visitor, thisArg);

package/src/engine/navigation/ecs/components/Path.js

@@ -9,7 +9,7 @@ import { CatmullRomCurve3 } from "three";
 import { clamp } from "../../../../core/math/clamp.js";
 import { assert } from "../../../../core/assert.js";
 import { RowFirstTableSpec } from "../../../../core/collection/table/RowFirstTableSpec.js";
-import { DataType } from "../../../../core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import { RowFirstTable } from "../../../../core/collection/table/RowFirstTable.js";
 import { min2 } from "../../../../core/math/min2.js";
 import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
@@ -58,9 +58,9 @@ const scratch_array_4 = [];
  * @type {RowFirstTableSpec}
  */
 const DEFAULT_SPEC = Object.freeze(new RowFirstTableSpec([
-    DataType.Float32, // position X
-    DataType.Float32, // position Y
-    DataType.Float32  // position Z
+    BinaryDataType.Float32, // position X
+    BinaryDataType.Float32, // position Y
+    BinaryDataType.Float32  // position Z
 ]));
 
 class Path {
@@ -73,7 +73,7 @@ class Path {
         this.__spec = VertexDataSpec.from(
             AttributeSpec.fromJSON({
                 name: 'position',
-                type: DataType.Float32,
+                type: BinaryDataType.Float32,
                 itemSize: 3,
                 normalized: false
             })

package/src/generation/example/grid/configureMirGrid.js

@@ -1,6 +1,6 @@
 import { GridDataLayer } from "../../grid/layers/GridDataLayer.js";
 import { MirGridLayers } from "./MirGridLayers.js";
-import { DataType } from "../../../core/collection/table/DataType.js";
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
 
 /**
  *
@@ -8,12 +8,12 @@ import { DataType } from "../../../core/collection/table/DataType.js";
  */
 export function configureMirGrid(data) {
 
-    data.addLayer(GridDataLayer.from(MirGridLayers.Tags, DataType.Uint16, 1));
+    data.addLayer(GridDataLayer.from(MirGridLayers.Tags, BinaryDataType.Uint16, 1));
 
-    data.addLayer(GridDataLayer.from(MirGridLayers.DistanceFromStart, DataType.Uint16, 1));
-    data.addLayer(GridDataLayer.from(MirGridLayers.DistanceFromPlayArea, DataType.Uint16, 1));
+    data.addLayer(GridDataLayer.from(MirGridLayers.DistanceFromStart, BinaryDataType.Uint16, 1));
+    data.addLayer(GridDataLayer.from(MirGridLayers.DistanceFromPlayArea, BinaryDataType.Uint16, 1));
 
-    data.addLayer(GridDataLayer.from(MirGridLayers.Heights, DataType.Float32, 1));
+    data.addLayer(GridDataLayer.from(MirGridLayers.Heights, BinaryDataType.Float32, 1));
 
-    data.addLayer(GridDataLayer.from(MirGridLayers.Moisture, DataType.Float32, 1));
+    data.addLayer(GridDataLayer.from(MirGridLayers.Moisture, BinaryDataType.Float32, 1));
 }