@woosh/meep-engine 3.52.0 → 3.53.0

package/src/generation/foliage/asset/place_tree.js

@@ -0,0 +1,194 @@
+import { assert } from "../../../core/assert.js";
+import { PI2 } from "../../../core/math/PI2.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { FoliageWindRigs } from "../../../engine/graphics3/animation/FoliageWindRigs.js";
+import { prefab_place, prefab_unplace } from "../../../engine/graphics3/prefab/prefab_place.js";
+import { FoliageWindJoint } from "../../../shade/renderer/animation/foliage/FoliageWindJoint.js";
+import { FoliageWindRig } from "../../../shade/renderer/animation/foliage/FoliageWindRig.js";
+import { generate_tree } from "./generate_tree.js";
+
+/**
+ * Turn-key helper to place a procedural tree (`TreeAsset`, `Prefab`, or on-the-fly generation options)
+ * into a bare `GPUSceneContext` + `EntityComponentDataset` (one without ECS graphics systems),
+ * automatically registering its GPU fluid-driven `FoliageWindRig` with `GPUAnimationManager` so its
+ * bones sample `GPUSceneWind` (3D fluid dynamics cascades + global far-field wind) every frame.
+ *
+ * When using a full ECS world with `ShadedGeometrySystem`, `MeshSkinSystem`, and `FoliageWindSystem`,
+ * prefer `prefab_instantiate(tree.prefab, dataset, root)` directly so the ECS systems manage rows,
+ * skins, and wind rigs automatically.
+ *
+ * @param {import("../../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext} scene_context
+ * @param {import("../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset} dataset
+ * @param {Object} [options={}]
+ * @param {import("./TreeAsset.js").TreeAsset} [options.tree] pre-generated `TreeAsset`
+ * @param {import("../../../engine/graphics3/prefab/Prefab.js").Prefab} [options.prefab] pre-compiled `Prefab`
+ * @param {number} [options.lod=0] LOD index when placing from `TreeAsset`
+ * @param {Transform64} [options.placement] explicit `Transform64` placement
+ * @param {number[]|{x:number,y:number,z:number}} [options.position] world position `[x, y, z]`
+ * @param {number[]|{x:number,y:number,z:number,w:number}} [options.rotation] world quaternion `[x, y, z, w]`
+ * @param {number} [options.rotation_y] yaw rotation around `+Y` in radians
+ * @param {number|number[]|{x:number,y:number,z:number}} [options.scale] uniform or 3-axis scale
+ * @param {boolean} [options.wind=true] whether to register GPU fluid-driven foliage wind rigs
+ * @param {number} [options.wind_weight=1.0] foliage wind rig blend weight in `pose_accumulator`
+ * @param {number} [options.wind_phase_offset] explicit phase offset in radians for flutter desynchronization
+ * @returns {{
+ *   root: number,
+ *   instance: import("../../../engine/graphics3/prefab/PrefabInstance.js").PrefabInstance,
+ *   skins: {entity: number, skin_id: number}[]|null,
+ *   foliage_rig_ids: number[],
+ *   drawn: number,
+ *   tree: import("./TreeAsset.js").TreeAsset|null,
+ *   prefab: import("../../../engine/graphics3/prefab/Prefab.js").Prefab
+ * }}
+ */
+export function place_tree(scene_context, dataset, options = {}) {
+    assert.defined(scene_context, 'scene_context');
+    assert.defined(dataset, 'dataset');
+
+    const opts = options || {};
+    let tree = null;
+    let prefab = null;
+
+    if (opts.prefab && opts.prefab.isPrefab) {
+        prefab = opts.prefab;
+    } else if (opts.tree && opts.tree.isTreeAsset) {
+        tree = opts.tree;
+        const lod_idx = Math.max(0, Math.min(tree.lods.length - 1, opts.lod ?? 0));
+        prefab = tree.lods[lod_idx].prefab;
+    } else if (opts.isTreeAsset) {
+        tree = opts;
+        prefab = tree.prefab;
+    } else if (opts.isPrefab) {
+        prefab = opts;
+    } else {
+        tree = generate_tree(opts);
+        const lod_idx = Math.max(0, Math.min(tree.lods.length - 1, opts.lod ?? 0));
+        prefab = tree.lods[lod_idx].prefab;
+    }
+
+    const placement = new Transform64();
+    if (opts.placement && opts.placement.isTransform64) {
+        placement.copy(opts.placement);
+    } else {
+        if (opts.position !== undefined) {
+            if (Array.isArray(opts.position) || ArrayBuffer.isView(opts.position)) {
+                placement.setTranslation(opts.position[0] ?? 0, opts.position[1] ?? 0, opts.position[2] ?? 0);
+            } else {
+                placement.setTranslation(opts.position.x ?? 0, opts.position.y ?? 0, opts.position.z ?? 0);
+            }
+        }
+        if (opts.rotation !== undefined) {
+            if (Array.isArray(opts.rotation) || ArrayBuffer.isView(opts.rotation)) {
+                placement.setRotation(
+                    opts.rotation[0] ?? 0,
+                    opts.rotation[1] ?? 0,
+                    opts.rotation[2] ?? 0,
+                    opts.rotation[3] ?? 1
+                );
+            } else {
+                placement.setRotation(
+                    opts.rotation.x ?? 0,
+                    opts.rotation.y ?? 0,
+                    opts.rotation.z ?? 0,
+                    opts.rotation.w ?? 1
+                );
+            }
+        } else if (typeof opts.rotation_y === "number") {
+            const half = opts.rotation_y * 0.5;
+            placement.setRotation(0, Math.sin(half), 0, Math.cos(half));
+        }
+
+        if (opts.scale !== undefined) {
+            if (typeof opts.scale === "number") {
+                placement.setScale(opts.scale, opts.scale, opts.scale);
+            } else if (Array.isArray(opts.scale) || ArrayBuffer.isView(opts.scale)) {
+                placement.setScale(opts.scale[0] ?? 1, opts.scale[1] ?? 1, opts.scale[2] ?? 1);
+            } else {
+                placement.setScale(opts.scale.x ?? 1, opts.scale.y ?? 1, opts.scale.z ?? 1);
+            }
+        }
+    }
+    placement.updateMatrix();
+
+    const enable_wind = opts.wind !== false;
+    const has_skins = Array.isArray(prefab.skins) && prefab.skins.length > 0;
+    const placed = prefab_place(scene_context, dataset, prefab, placement, {
+        register_animation: enable_wind || has_skins,
+        skinned: has_skins
+    });
+
+    const foliage_rig_ids = [];
+    const manager = scene_context.animation_manager;
+    const rigs_component = dataset.getComponent(placed.root, FoliageWindRigs);
+
+    if (!enable_wind && rigs_component !== undefined) {
+        dataset.removeComponentFromEntity(placed.root, FoliageWindRigs);
+    } else if (enable_wind && rigs_component !== undefined && manager !== undefined && manager !== null) {
+        if (typeof opts.wind_phase_offset === "number" && Array.isArray(prefab.foliage_rigs)) {
+            const entities = placed.instance.entities;
+            const phase_offset = opts.wind_phase_offset;
+            rigs_component.rigs = prefab.foliage_rigs.map(rig_template => FoliageWindRig.from({
+                name: rig_template.name,
+                root: entities[rig_template.root],
+                weight: rig_template.weight,
+                joints: rig_template.joints.map(j => FoliageWindJoint.from({
+                    target: entities[j.target],
+                    branch_axis: j.branch_axis,
+                    compliance: j.compliance,
+                    natural_frequency: j.natural_frequency,
+                    damping_ratio: j.damping_ratio,
+                    max_angle: j.max_angle,
+                    turbulence: j.turbulence,
+                    phase_offset: (j.phase_offset + phase_offset) % PI2,
+                })),
+            }));
+        }
+
+        if (typeof opts.wind_weight === "number") {
+            rigs_component.weight = opts.wind_weight;
+        }
+
+        for (let i = 0; i < rigs_component.rigs.length; i++) {
+            const rig_id = manager.register_foliage_rig(rigs_component.rigs[i]);
+            if (typeof opts.wind_weight === "number") {
+                manager.set_foliage_rig_weight(rig_id, opts.wind_weight);
+            }
+            foliage_rig_ids.push(rig_id);
+        }
+    }
+
+    return {
+        root: placed.root,
+        instance: placed.instance,
+        skins: placed.skins,
+        foliage_rig_ids,
+        drawn: placed.drawn,
+        tree,
+        prefab
+    };
+}
+
+/**
+ * Unplaces a tree previously placed via `place_tree`, unregistering its GPU fluid-driven foliage
+ * wind rigs BEFORE destroying the prefab instance so target entities still exist in `dataset` during cleanup.
+ *
+ * @param {import("../../../shade/renderer/scene/GPUSceneContext.js").GPUSceneContext} scene_context
+ * @param {import("../../../engine/ecs/EntityComponentDataset.js").EntityComponentDataset} dataset
+ * @param {ReturnType<typeof place_tree>} placed
+ */
+export function unplace_tree(scene_context, dataset, placed) {
+    assert.defined(scene_context, 'scene_context');
+    assert.defined(dataset, 'dataset');
+    assert.defined(placed, 'placed');
+
+    // CRITICAL: unregister_foliage_rig must run BEFORE prefab_unplace removes the target entities from dataset!
+    if (Array.isArray(placed.foliage_rig_ids) && placed.foliage_rig_ids.length > 0 && scene_context.animation_manager) {
+        const manager = scene_context.animation_manager;
+        for (let i = 0; i < placed.foliage_rig_ids.length; i++) {
+            manager.unregister_foliage_rig(placed.foliage_rig_ids[i]);
+        }
+        placed.foliage_rig_ids.length = 0;
+    }
+
+    prefab_unplace(scene_context, dataset, placed);
+}

package/src/generation/foliage/config/BarkMaterialConfig.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Procedural bark PBR material & UV tiling configuration.
+ */
+export class BarkMaterialConfig {
+    /**
+     * @param {Partial<BarkMaterialConfig>} [options]
+     * @returns {BarkMaterialConfig}
+     */
+    static from(options?: Partial<BarkMaterialConfig>): BarkMaterialConfig;
+    /**
+     * Procedural texture resolution (pixels, power of two).
+     * @type {number}
+     */
+    resolution: number;
+    /**
+     * Botanical bark pattern archetype (`"fissured"` | `"birch"` | `"plated"` | `"ringed"`).
+     * @type {string}
+     */
+    bark_type: string;
+    /**
+     * Outer bark ridge / periderm color (sRGB).
+     * @type {Color}
+     */
+    primary_color: Color;
+    /**
+     * Deep fissure / crevice bark color (sRGB).
+     * @type {Color}
+     */
+    secondary_color: Color;
+    /**
+     * Exposed inner phloem / peeled cambium accent color (sRGB).
+     * @type {Color}
+     */
+    inner_bark_color: Color;
+    /**
+     * Basal moss / lichen tint color (sRGB).
+     * @type {Color}
+     */
+    moss_color: Color;
+    /**
+     * Amount [0, 1] of lichen/moss flecking.
+     * @type {number}
+     */
+    moss_amount: number;
+    /**
+     * Circumferential fissure ridge or plate count across unit UV tile.
+     * @type {number}
+     */
+    fissure_frequency: number;
+    /**
+     * Normal map relief and occlusion depth of bark fissures [0, 1].
+     * @type {number}
+     */
+    fissure_depth: number;
+    /**
+     * Horizontal lenticel stripe intensity [0, 1] (characteristic of birch/cherry bark).
+     * @type {number}
+     */
+    lenticel_amount: number;
+    /**
+     * Papery bark peeling & curling strip intensity [0, 1] (characteristic of birch).
+     * @type {number}
+     */
+    peel_amount: number;
+    /**
+     * Stepped terrace quantization of bark plates/ridges [0, 1].
+     * @type {number}
+     */
+    plate_terrace: number;
+    /**
+     * Intensity [0, 1] of embedded callus knots / chevron branch-eye scars and grain flow warping.
+     * @type {number}
+     */
+    knot_amount: number;
+    /**
+     * Base PBR roughness [0, 1].
+     * @type {number}
+     */
+    roughness: number;
+    /**
+     * World-space UV tile density (tiles per meter of circumference/length).
+     * @type {number}
+     */
+    texel_density: number;
+    /**
+     * Helical UV twist rate along branch length (tiles per meter).
+     * @type {number}
+     */
+    twist_uv: number;
+    /**
+     * @param {Partial<BarkMaterialConfig>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: Partial<BarkMaterialConfig>): this;
+    /**
+     * @param {BarkMaterialConfig} other
+     * @returns {this}
+     */
+    copy(other: BarkMaterialConfig): this;
+    /**
+     * @returns {BarkMaterialConfig}
+     */
+    clone(): BarkMaterialConfig;
+    /**
+     * @param {BarkMaterialConfig} other
+     * @returns {boolean}
+     */
+    equals(other: BarkMaterialConfig): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isBarkMaterialConfig: boolean;
+}
+import { Color } from "../../../core/color/Color.js";
+//# sourceMappingURL=BarkMaterialConfig.d.ts.map

package/src/generation/foliage/config/BarkMaterialConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BarkMaterialConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/BarkMaterialConfig.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IAiGI;;;OAGG;IACH,sBAHW,QAAQ,kBAAkB,CAAC,GACzB,kBAAkB,CAM9B;IAxGD;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,WAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,eAFU,KAAK,CAEkC;IAEjD;;;OAGG;IACH,iBAFU,KAAK,CAEoC;IAEnD;;;OAGG;IACH,kBAFU,KAAK,CAEqC;IAEpD;;;OAGG;IACH,YAFU,KAAK,CAE+B;IAE9C;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,eAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,eAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,MAAM,CAEA;IAYhB;;;OAGG;IACH,2BAHW,QAAQ,kBAAkB,CAAC,GACzB,IAAI,CA+ChB;IAED;;;OAGG;IACH,YAHW,kBAAkB,GAChB,IAAI,CAqBhB;IAED;;OAEG;IACH,SAFa,kBAAkB,CAM9B;IAED;;;OAGG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAqBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAelB;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;CANhD;sBAlPqB,8BAA8B"}

package/src/generation/foliage/config/BarkMaterialConfig.js

@@ -0,0 +1,250 @@
+import { assert } from "../../../core/assert.js";
+import { Color } from "../../../core/color/Color.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+
+/**
+ * Procedural bark PBR material & UV tiling configuration.
+ */
+export class BarkMaterialConfig {
+    /**
+     * Procedural texture resolution (pixels, power of two).
+     * @type {number}
+     */
+    resolution = 256;
+
+    /**
+     * Botanical bark pattern archetype (`"fissured"` | `"birch"` | `"plated"` | `"ringed"`).
+     * @type {string}
+     */
+    bark_type = "fissured";
+
+    /**
+     * Outer bark ridge / periderm color (sRGB).
+     * @type {Color}
+     */
+    primary_color = new Color(0.29, 0.27, 0.24, 1.0);
+
+    /**
+     * Deep fissure / crevice bark color (sRGB).
+     * @type {Color}
+     */
+    secondary_color = new Color(0.11, 0.10, 0.09, 1.0);
+
+    /**
+     * Exposed inner phloem / peeled cambium accent color (sRGB).
+     * @type {Color}
+     */
+    inner_bark_color = new Color(0.32, 0.26, 0.21, 1.0);
+
+    /**
+     * Basal moss / lichen tint color (sRGB).
+     * @type {Color}
+     */
+    moss_color = new Color(0.24, 0.29, 0.18, 1.0);
+
+    /**
+     * Amount [0, 1] of lichen/moss flecking.
+     * @type {number}
+     */
+    moss_amount = 0.10;
+
+    /**
+     * Circumferential fissure ridge or plate count across unit UV tile.
+     * @type {number}
+     */
+    fissure_frequency = 7;
+
+    /**
+     * Normal map relief and occlusion depth of bark fissures [0, 1].
+     * @type {number}
+     */
+    fissure_depth = 0.72;
+
+    /**
+     * Horizontal lenticel stripe intensity [0, 1] (characteristic of birch/cherry bark).
+     * @type {number}
+     */
+    lenticel_amount = 0.0;
+
+    /**
+     * Papery bark peeling & curling strip intensity [0, 1] (characteristic of birch).
+     * @type {number}
+     */
+    peel_amount = 0.35;
+
+    /**
+     * Stepped terrace quantization of bark plates/ridges [0, 1].
+     * @type {number}
+     */
+    plate_terrace = 0.42;
+
+    /**
+     * Intensity [0, 1] of embedded callus knots / chevron branch-eye scars and grain flow warping.
+     * @type {number}
+     */
+    knot_amount = 0.55;
+
+    /**
+     * Base PBR roughness [0, 1].
+     * @type {number}
+     */
+    roughness = 0.90;
+
+    /**
+     * World-space UV tile density (tiles per meter of circumference/length).
+     * @type {number}
+     */
+    texel_density = 1.2;
+
+    /**
+     * Helical UV twist rate along branch length (tiles per meter).
+     * @type {number}
+     */
+    twist_uv = 0.04;
+
+    /**
+     * @param {Partial<BarkMaterialConfig>} [options]
+     * @returns {BarkMaterialConfig}
+     */
+    static from(options = {}) {
+        const r = new BarkMaterialConfig();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<BarkMaterialConfig>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.resolution !== undefined) this.resolution = Math.max(16, overrides.resolution | 0);
+        if (overrides.bark_type !== undefined) this.bark_type = String(overrides.bark_type);
+        if (overrides.primary_color !== undefined) {
+            if (Array.isArray(overrides.primary_color)) {
+                this.primary_color.setRGB(overrides.primary_color[0], overrides.primary_color[1], overrides.primary_color[2]);
+            } else {
+                this.primary_color.copy(overrides.primary_color);
+            }
+        }
+        if (overrides.secondary_color !== undefined) {
+            if (Array.isArray(overrides.secondary_color)) {
+                this.secondary_color.setRGB(overrides.secondary_color[0], overrides.secondary_color[1], overrides.secondary_color[2]);
+            } else {
+                this.secondary_color.copy(overrides.secondary_color);
+            }
+        }
+        if (overrides.inner_bark_color !== undefined) {
+            if (Array.isArray(overrides.inner_bark_color)) {
+                this.inner_bark_color.setRGB(overrides.inner_bark_color[0], overrides.inner_bark_color[1], overrides.inner_bark_color[2]);
+            } else {
+                this.inner_bark_color.copy(overrides.inner_bark_color);
+            }
+        }
+        if (overrides.moss_color !== undefined) {
+            if (Array.isArray(overrides.moss_color)) {
+                this.moss_color.setRGB(overrides.moss_color[0], overrides.moss_color[1], overrides.moss_color[2]);
+            } else {
+                this.moss_color.copy(overrides.moss_color);
+            }
+        }
+        if (overrides.moss_amount !== undefined) this.moss_amount = overrides.moss_amount;
+        if (overrides.fissure_frequency !== undefined) this.fissure_frequency = Math.max(1, overrides.fissure_frequency | 0);
+        if (overrides.fissure_depth !== undefined) this.fissure_depth = overrides.fissure_depth;
+        if (overrides.lenticel_amount !== undefined) this.lenticel_amount = overrides.lenticel_amount;
+        if (overrides.peel_amount !== undefined) this.peel_amount = overrides.peel_amount;
+        if (overrides.plate_terrace !== undefined) this.plate_terrace = overrides.plate_terrace;
+        if (overrides.knot_amount !== undefined) this.knot_amount = overrides.knot_amount;
+        if (overrides.roughness !== undefined) this.roughness = overrides.roughness;
+        if (overrides.texel_density !== undefined) this.texel_density = overrides.texel_density;
+        if (overrides.twist_uv !== undefined) this.twist_uv = overrides.twist_uv;
+        return this;
+    }
+
+    /**
+     * @param {BarkMaterialConfig} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.resolution = other.resolution;
+        this.bark_type = other.bark_type;
+        this.primary_color.copy(other.primary_color);
+        this.secondary_color.copy(other.secondary_color);
+        this.inner_bark_color.copy(other.inner_bark_color);
+        this.moss_color.copy(other.moss_color);
+        this.moss_amount = other.moss_amount;
+        this.fissure_frequency = other.fissure_frequency;
+        this.fissure_depth = other.fissure_depth;
+        this.lenticel_amount = other.lenticel_amount;
+        this.peel_amount = other.peel_amount;
+        this.plate_terrace = other.plate_terrace;
+        this.knot_amount = other.knot_amount;
+        this.roughness = other.roughness;
+        this.texel_density = other.texel_density;
+        this.twist_uv = other.twist_uv;
+        return this;
+    }
+
+    /**
+     * @returns {BarkMaterialConfig}
+     */
+    clone() {
+        const r = new BarkMaterialConfig();
+        r.copy(this);
+        return r;
+    }
+
+    /**
+     * @param {BarkMaterialConfig} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isBarkMaterialConfig) return false;
+        return this.resolution === other.resolution
+            && this.bark_type === other.bark_type
+            && this.primary_color.equals(other.primary_color)
+            && this.secondary_color.equals(other.secondary_color)
+            && this.inner_bark_color.equals(other.inner_bark_color)
+            && this.moss_color.equals(other.moss_color)
+            && this.moss_amount === other.moss_amount
+            && this.fissure_frequency === other.fissure_frequency
+            && this.fissure_depth === other.fissure_depth
+            && this.lenticel_amount === other.lenticel_amount
+            && this.peel_amount === other.peel_amount
+            && this.plate_terrace === other.plate_terrace
+            && this.knot_amount === other.knot_amount
+            && this.roughness === other.roughness
+            && this.texel_density === other.texel_density
+            && this.twist_uv === other.twist_uv;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(this.resolution, computeStringHash(this.bark_type));
+        h = hash_mix2(h, this.primary_color.hash());
+        h = hash_mix2(h, this.secondary_color.hash());
+        h = hash_mix2(h, this.inner_bark_color.hash());
+        h = hash_mix2(h, this.moss_color.hash());
+        h = hash_mix2(h, computeHashFloat(this.fissure_depth));
+        h = hash_mix2(h, computeHashFloat(this.lenticel_amount));
+        h = hash_mix2(h, computeHashFloat(this.peel_amount));
+        h = hash_mix2(h, computeHashFloat(this.plate_terrace));
+        h = hash_mix2(h, computeHashFloat(this.knot_amount));
+        h = hash_mix2(h, computeHashFloat(this.roughness));
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+BarkMaterialConfig.prototype.isBarkMaterialConfig = true;