@zephyr3d/scene 0.9.24 → 0.9.26

package/dist/utility/serialization/scene/hair.js

@@ -0,0 +1,1141 @@
+import { mimeTypeOf, Vector4, Vector3 } from '@zephyr3d/base';
+import '../../../scene/scene.js';
+import '../../../values.js';
+import '../../../render/render_queue.js';
+import '../../../render/primitive.js';
+import '@zephyr3d/device';
+import '../../../material/shader/helper.js';
+import '../../../material/lambert.js';
+import '../../../material/blinn.js';
+import '../../../material/unlit.js';
+import '../../../material/particle.js';
+import '../../../material/subsurfaceprofile.js';
+import '../../../material/skin.js';
+import '../../../material/eye.js';
+import '../../../material/meshmaterial.js';
+import '../../../material/hair.js';
+import '../../../material/hairstrand.js';
+import '../../../material/grassmaterial.js';
+import '../../../material/terrain-cm.js';
+import '../../../material/pbrmr.js';
+import '../../../material/pbrsg.js';
+import '../../../material/mtoon.js';
+import '../../../material/pbrblueprint.js';
+import '../../../material/sprite.js';
+import '../../../material/sprite_std.js';
+import { defineProps } from '../types.js';
+import '../../blueprint/material/texture.js';
+import '../../../render/rendergraph/forward_plus_builder.js';
+import '../../../render/lightpass.js';
+import '../../../render/sky.js';
+import '../../../render/clipmap.js';
+import '../../../render/envlight.js';
+import '../../../render/dualdepthpeeling_oit.js';
+import '../../../shaders/atmosphere.js';
+import '../../../render/rendergraph/scene_render_context.js';
+import { GraphNode } from '../../../scene/graph_node.js';
+import '../../../shadow/shadowmapper.js';
+import '../../../scene/mesh.js';
+import '../../../scene/meshdrawable.js';
+import '../../../scene/basesprite.js';
+import '../../../material/msdf_text.js';
+import '../../../scene/water.js';
+import { HairNode } from '../../../scene/hair.js';
+import '../../../scene/scene_node.js';
+import '../../../scene/particlesys.js';
+import '../../../scene/batchgroup.js';
+import '../../../scene/terrain-cm/terrain-cm.js';
+import '../../../scene/terrain-cm/grass.js';
+import '../../../scene/raycast_visitor.js';
+
+/**
+ * Serialization for {@link HairNode}.
+ *
+ * @remarks
+ * Ordinary in every respect: the node holds all of its own state, so these are
+ * plain accessors onto it and the node saves and loads like any other.
+ *
+ * Two things are deliberately absent. The strand geometry is not here - it lives
+ * in the `.zhair` asset the node references by path, and that file holds nothing
+ * but strands, so the same groom can be shared by characters that style it
+ * differently. Nor is the material: it is an implementation detail of the node
+ * (see the {@link HairNode} class remarks), and its controls appear below as
+ * properties of the node itself.
+ * @internal
+ */ function getHairNodeClass() {
+    return {
+        ctor: HairNode,
+        name: 'HairNode',
+        parent: GraphNode,
+        createFunc (ctx) {
+            const node = new HairNode(ctx.scene);
+            node.parent = ctx;
+            return {
+                obj: node
+            };
+        },
+        getProps () {
+            return defineProps([
+                {
+                    name: 'HairAsset',
+                    description: 'Strand geometry asset drawn by this node',
+                    type: 'string',
+                    default: '',
+                    options: {
+                        group: 'Geometry',
+                        label: 'Hair Asset',
+                        mimeTypes: [
+                            mimeTypeOf('.zhair')
+                        ]
+                    },
+                    get (value) {
+                        value.str[0] = this.hairAsset;
+                    },
+                    async set (value) {
+                        await this.setHairAsset(value?.str?.[0] ?? '');
+                    }
+                },
+                {
+                    name: 'StrandStride',
+                    description: 'Draw one strand in every N. Thins the groom evenly across the scalp rather than cropping it',
+                    type: 'int',
+                    default: 1,
+                    options: {
+                        group: 'Geometry',
+                        minValue: 1,
+                        maxValue: 64
+                    },
+                    get (value) {
+                        value.num[0] = this.strandStride;
+                    },
+                    set (value) {
+                        this.strandStride = value.num[0];
+                    }
+                },
+                {
+                    name: 'MaxStrands',
+                    description: 'Upper bound on drawn strands, widening the stride further when needed. 0 disables',
+                    type: 'int',
+                    default: 0,
+                    options: {
+                        group: 'Geometry',
+                        minValue: 0,
+                        maxValue: 1000000
+                    },
+                    get (value) {
+                        value.num[0] = this.maxStrands;
+                    },
+                    set (value) {
+                        this.maxStrands = value.num[0];
+                    }
+                },
+                {
+                    name: 'SegmentsPerStrand',
+                    description: 'Ribbon segments generated per strand. Independent of the control point count, so the same strands can be drawn coarser at a distance',
+                    type: 'int',
+                    default: 8,
+                    options: {
+                        group: 'Geometry',
+                        minValue: 1,
+                        maxValue: 64
+                    },
+                    get (value) {
+                        value.num[0] = this.segmentsPerStrand;
+                    },
+                    set (value) {
+                        this.segmentsPerStrand = value.num[0];
+                    }
+                },
+                {
+                    name: 'StrandWidthScale',
+                    description: 'Multiplier on the width stored in the strand data',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        group: 'Geometry',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 100
+                    },
+                    get (value) {
+                        value.num[0] = this.strandWidthScale;
+                    },
+                    set (value) {
+                        this.strandWidthScale = value.num[0];
+                    }
+                },
+                {
+                    name: 'MinStrandWidth',
+                    description: 'Lower bound on ribbon width, in world units',
+                    type: 'float',
+                    default: 0,
+                    options: {
+                        group: 'Geometry',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.minStrandWidth;
+                    },
+                    set (value) {
+                        this.minStrandWidth = value.num[0];
+                    }
+                },
+                {
+                    name: 'MinPixelWidth',
+                    description: 'Lower bound on ribbon width in pixels. Real hair is thinner than a pixel; widening it and paying the coverage back in alpha keeps distant hair from breaking into a flickering dotted line',
+                    type: 'float',
+                    default: 1.4,
+                    options: {
+                        group: 'Geometry',
+                        minValue: 0,
+                        maxValue: 8
+                    },
+                    get (value) {
+                        value.num[0] = this.minPixelWidth;
+                    },
+                    set (value) {
+                        this.minPixelWidth = value.num[0];
+                    }
+                },
+                {
+                    name: 'RootOcclusion',
+                    description: 'Darkens ambient light on strands near the root, standing in for the occlusion of being buried in the groom. Environment light is not shadowed, so without this a dense hairstyle is as bright inside as out. Direct light is left to the shadow map',
+                    type: 'float',
+                    default: 0.5,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.rootOcclusion;
+                    },
+                    set (value) {
+                        this.rootOcclusion = value.num[0];
+                    }
+                },
+                {
+                    name: 'RootOcclusionRange',
+                    description: 'Fraction of a strand length over which the root occlusion fades out',
+                    type: 'float',
+                    default: 0.6,
+                    options: {
+                        group: 'Shading',
+                        minValue: 0.001,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.rootOcclusion <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.rootOcclusionRange;
+                    },
+                    set (value) {
+                        this.rootOcclusionRange = value.num[0];
+                    }
+                },
+                {
+                    name: 'StrandLOD',
+                    description: 'Drop strands with distance, redistributing their coverage to the survivors',
+                    type: 'bool',
+                    default: false,
+                    options: {
+                        group: 'Geometry'
+                    },
+                    get (value) {
+                        value.bool[0] = this.strandLOD;
+                    },
+                    set (value) {
+                        this.strandLOD = value.bool[0];
+                    }
+                },
+                {
+                    name: 'MinStrandLODRatio',
+                    description: 'Floor on the fraction of strands distance decimation keeps',
+                    type: 'float',
+                    default: 0.05,
+                    options: {
+                        group: 'Geometry',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return !this.strandLOD;
+                    },
+                    get (value) {
+                        value.num[0] = this.minStrandLODRatio;
+                    },
+                    set (value) {
+                        this.minStrandLODRatio = value.num[0];
+                    }
+                },
+                {
+                    name: 'AlbedoColor',
+                    description: 'Base color of the strands',
+                    type: 'rgba',
+                    default: [
+                        1,
+                        1,
+                        1,
+                        1
+                    ],
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.albedoColor.x;
+                        value.num[1] = this.albedoColor.y;
+                        value.num[2] = this.albedoColor.z;
+                        value.num[3] = this.albedoColor.w;
+                    },
+                    set (value) {
+                        this.albedoColor = new Vector4(value.num[0], value.num[1], value.num[2], value.num[3]);
+                    }
+                },
+                {
+                    name: 'ShadingModel',
+                    description: 'Which scattering model shades the hair. Marschner derives the lobes from the fibre; Kajiya-Kay is the art-directed double lobe',
+                    type: 'string',
+                    default: 'kajiya-kay',
+                    options: {
+                        group: 'Shading',
+                        enum: {
+                            labels: [
+                                'Kajiya-Kay (double lobe)',
+                                'Marschner (fibre)'
+                            ],
+                            values: [
+                                'kajiya-kay',
+                                'marschner'
+                            ]
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.shadingModel;
+                    },
+                    set (value) {
+                        this.shadingModel = value.str[0];
+                    }
+                },
+                {
+                    name: 'Specular1Color',
+                    description: 'Color of the primary (sharp, near-white) specular lobe',
+                    type: 'rgb',
+                    default: [
+                        0.35,
+                        0.35,
+                        0.35
+                    ],
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'kajiya-kay';
+                    },
+                    get (value) {
+                        value.num[0] = this.specular1Color.x;
+                        value.num[1] = this.specular1Color.y;
+                        value.num[2] = this.specular1Color.z;
+                    },
+                    set (value) {
+                        this.specular1Color = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'Specular1Power',
+                    description: 'Exponent of the primary specular lobe',
+                    type: 'float',
+                    default: 160,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 1,
+                        maxValue: 1024
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'kajiya-kay';
+                    },
+                    get (value) {
+                        value.num[0] = this.specular1Power;
+                    },
+                    set (value) {
+                        this.specular1Power = value.num[0];
+                    }
+                },
+                {
+                    name: 'Specular1Shift',
+                    description: 'Shift of the primary specular lobe along the strand',
+                    type: 'float',
+                    default: 0.05,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: -1,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'kajiya-kay';
+                    },
+                    get (value) {
+                        value.num[0] = this.specular1Shift;
+                    },
+                    set (value) {
+                        this.specular1Shift = value.num[0];
+                    }
+                },
+                {
+                    name: 'Specular2Color',
+                    description: 'Color of the secondary (broad, tinted) specular lobe',
+                    type: 'rgb',
+                    default: [
+                        0.5,
+                        0.35,
+                        0.25
+                    ],
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'kajiya-kay';
+                    },
+                    get (value) {
+                        value.num[0] = this.specular2Color.x;
+                        value.num[1] = this.specular2Color.y;
+                        value.num[2] = this.specular2Color.z;
+                    },
+                    set (value) {
+                        this.specular2Color = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'Specular2Power',
+                    description: 'Exponent of the secondary specular lobe',
+                    type: 'float',
+                    default: 20,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 1,
+                        maxValue: 1024
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'kajiya-kay';
+                    },
+                    get (value) {
+                        value.num[0] = this.specular2Power;
+                    },
+                    set (value) {
+                        this.specular2Power = value.num[0];
+                    }
+                },
+                {
+                    name: 'Specular2Shift',
+                    description: 'Shift of the secondary specular lobe along the strand',
+                    type: 'float',
+                    default: -0.08,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: -1,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'kajiya-kay';
+                    },
+                    get (value) {
+                        value.num[0] = this.specular2Shift;
+                    },
+                    set (value) {
+                        this.specular2Shift = value.num[0];
+                    }
+                },
+                {
+                    name: 'MarschnerShift',
+                    description: 'Longitudinal shift of the Marschner lobes',
+                    type: 'float',
+                    default: 0.035,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 0.5
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'marschner';
+                    },
+                    get (value) {
+                        value.num[0] = this.marschnerShift;
+                    },
+                    set (value) {
+                        this.marschnerShift = value.num[0];
+                    }
+                },
+                {
+                    name: 'MarschnerRoughness',
+                    description: 'Longitudinal roughness of the Marschner lobes',
+                    type: 'float',
+                    default: 0.25,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0.01,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'marschner';
+                    },
+                    get (value) {
+                        value.num[0] = this.marschnerRoughness;
+                    },
+                    set (value) {
+                        this.marschnerRoughness = value.num[0];
+                    }
+                },
+                {
+                    name: 'MarschnerIOR',
+                    description: 'Index of refraction of the fibre',
+                    type: 'float',
+                    default: 1.55,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 1,
+                        maxValue: 3
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'marschner';
+                    },
+                    get (value) {
+                        value.num[0] = this.marschnerIOR;
+                    },
+                    set (value) {
+                        this.marschnerIOR = value.num[0];
+                    }
+                },
+                {
+                    name: 'MarschnerAbsorption',
+                    description: 'How strongly pigmented the fibre is. Deepens the transmitted paths without touching the white surface reflection',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 8
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'marschner';
+                    },
+                    get (value) {
+                        value.num[0] = this.marschnerAbsorption;
+                    },
+                    set (value) {
+                        this.marschnerAbsorption = value.num[0];
+                    }
+                },
+                {
+                    name: 'MarschnerLobes',
+                    description: 'Relative weight of the R, TT and TRT lobes',
+                    type: 'vec3',
+                    default: [
+                        1,
+                        1,
+                        1
+                    ],
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    isHidden () {
+                        return this.shadingModel !== 'marschner';
+                    },
+                    get (value) {
+                        value.num[0] = this.marschnerLobes.x;
+                        value.num[1] = this.marschnerLobes.y;
+                        value.num[2] = this.marschnerLobes.z;
+                    },
+                    set (value) {
+                        this.marschnerLobes = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'StrandRoundness',
+                    description: 'How far the shading normal bends across the ribbon. At 0 a strand shades as a flat tape, at 1 as a cylinder',
+                    type: 'float',
+                    default: 1,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.strandRoundness;
+                    },
+                    set (value) {
+                        this.strandRoundness = value.num[0];
+                    }
+                },
+                {
+                    name: 'DiffuseWrap',
+                    description: 'How far diffuse lighting wraps around the fibre',
+                    type: 'float',
+                    default: 0.5,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.diffuseWrap;
+                    },
+                    set (value) {
+                        this.diffuseWrap = value.num[0];
+                    }
+                },
+                {
+                    name: 'TransmissionColor',
+                    description: 'Color of light transmitted through the fibre',
+                    type: 'rgb',
+                    default: [
+                        0.6,
+                        0.35,
+                        0.2
+                    ],
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.transmissionColor.x;
+                        value.num[1] = this.transmissionColor.y;
+                        value.num[2] = this.transmissionColor.z;
+                    },
+                    set (value) {
+                        this.transmissionColor = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'TransmissionIntensity',
+                    description: 'Strength of back-lit transmission',
+                    type: 'float',
+                    default: 0.35,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.transmissionIntensity;
+                    },
+                    set (value) {
+                        this.transmissionIntensity = value.num[0];
+                    }
+                },
+                {
+                    name: 'TransmissionPower',
+                    description: 'Falloff exponent of back-lit transmission',
+                    type: 'float',
+                    default: 4,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 1,
+                        maxValue: 64
+                    },
+                    get (value) {
+                        value.num[0] = this.transmissionPower;
+                    },
+                    set (value) {
+                        this.transmissionPower = value.num[0];
+                    }
+                },
+                {
+                    name: 'ScatterColor',
+                    description: 'Color of multiple scattering within the groom',
+                    type: 'rgb',
+                    default: [
+                        0.55,
+                        0.32,
+                        0.18
+                    ],
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.scatterColor.x;
+                        value.num[1] = this.scatterColor.y;
+                        value.num[2] = this.scatterColor.z;
+                    },
+                    set (value) {
+                        this.scatterColor = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'ScatterIntensity',
+                    description: 'Strength of multiple scattering',
+                    type: 'float',
+                    default: 0,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 4
+                    },
+                    get (value) {
+                        value.num[0] = this.scatterIntensity;
+                    },
+                    set (value) {
+                        this.scatterIntensity = value.num[0];
+                    }
+                },
+                {
+                    name: 'ScatterLocal',
+                    description: 'Share of scattering taken as local rather than global',
+                    type: 'float',
+                    default: 0.5,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.scatterIntensity <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.scatterLocal;
+                    },
+                    set (value) {
+                        this.scatterLocal = value.num[0];
+                    }
+                },
+                {
+                    name: 'ScatterWrap',
+                    description: 'How far scattered light wraps around the fibre',
+                    type: 'float',
+                    default: 0.8,
+                    options: {
+                        group: 'Shading',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return this.scatterIntensity <= 0;
+                    },
+                    get (value) {
+                        value.num[0] = this.scatterWrap;
+                    },
+                    set (value) {
+                        this.scatterWrap = value.num[0];
+                    }
+                },
+                {
+                    name: 'BlendMode',
+                    description: 'How the strands blend with what is behind them. The pixel-width floor pays its widening back in alpha, which only means anything once blending is on',
+                    type: 'string',
+                    default: 'none',
+                    options: {
+                        group: 'Transparency',
+                        enum: {
+                            labels: [
+                                'None',
+                                'Blend',
+                                'Additive',
+                                'Max',
+                                'Min'
+                            ],
+                            values: [
+                                'none',
+                                'blend',
+                                'additive',
+                                'max',
+                                'min'
+                            ]
+                        }
+                    },
+                    get (value) {
+                        value.str[0] = this.blendMode;
+                    },
+                    set (value) {
+                        this.blendMode = value.str[0];
+                    }
+                },
+                {
+                    name: 'AlphaCutoff',
+                    description: 'Alpha below which a fragment is discarded',
+                    type: 'float',
+                    default: 0,
+                    options: {
+                        group: 'Transparency',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    get (value) {
+                        value.num[0] = this.alphaCutoff;
+                    },
+                    set (value) {
+                        this.alphaCutoff = value.num[0];
+                    }
+                },
+                {
+                    name: 'AlphaDither',
+                    description: 'Dither the alpha test, so a temporal filter resolves the soft edge',
+                    type: 'bool',
+                    default: false,
+                    options: {
+                        group: 'Transparency'
+                    },
+                    get (value) {
+                        value.bool[0] = this.alphaDither;
+                    },
+                    set (value) {
+                        this.alphaDither = value.bool[0];
+                    }
+                },
+                {
+                    name: 'CastShadow',
+                    description: 'If true, the groom is drawn into shadow maps',
+                    type: 'bool',
+                    default: true,
+                    options: {
+                        group: 'Shadow'
+                    },
+                    get (value) {
+                        value.bool[0] = this.castShadow;
+                    },
+                    set (value) {
+                        this.castShadow = value.bool[0];
+                    }
+                },
+                {
+                    name: 'TransparentShadowCaster',
+                    description: 'Let the shadow caster pass respect strand alpha, for softer self-shadowing',
+                    type: 'bool',
+                    default: false,
+                    options: {
+                        group: 'Shadow'
+                    },
+                    isHidden () {
+                        return !this.castShadow;
+                    },
+                    get (value) {
+                        value.bool[0] = this.transparentShadowCaster;
+                    },
+                    set (value) {
+                        this.transparentShadowCaster = value.bool[0];
+                    }
+                },
+                {
+                    name: 'ShadowAlphaCutoff',
+                    description: 'Alpha below which a fragment casts no shadow',
+                    type: 'float',
+                    default: 0,
+                    options: {
+                        group: 'Shadow',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return !this.castShadow || !this.transparentShadowCaster;
+                    },
+                    get (value) {
+                        value.num[0] = this.shadowAlphaCutoff;
+                    },
+                    set (value) {
+                        this.shadowAlphaCutoff = value.num[0];
+                    }
+                },
+                {
+                    name: 'Simulation',
+                    description: 'Run strand dynamics on this groom. WebGPU only; the strands stay in their authored pose elsewhere',
+                    type: 'bool',
+                    default: false,
+                    options: {
+                        group: 'Simulation'
+                    },
+                    get (value) {
+                        value.bool[0] = this.simulationEnabled;
+                    },
+                    set (value) {
+                        this.simulationEnabled = value.bool[0];
+                    }
+                },
+                {
+                    name: 'Gravity',
+                    description: 'World-space gravity acting on the strands',
+                    type: 'vec3',
+                    default: [
+                        0,
+                        -9.8,
+                        0
+                    ],
+                    options: {
+                        group: 'Simulation',
+                        animatable: true
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.gravity.x;
+                        value.num[1] = this.gravity.y;
+                        value.num[2] = this.gravity.z;
+                    },
+                    set (value) {
+                        this.gravity = new Vector3(value.num[0], value.num[1], value.num[2]);
+                    }
+                },
+                {
+                    name: 'Local Stiffness',
+                    description: 'How strongly a strand keeps its authored shape. Holds the curl, and damps the groom',
+                    type: 'float',
+                    default: 0.9,
+                    options: {
+                        group: 'Simulation',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.localStiffness;
+                    },
+                    set (value) {
+                        this.localStiffness = value.num[0];
+                    }
+                },
+                {
+                    name: 'Local Iterations',
+                    description: 'Local shape constraint passes per substep. More converges closer',
+                    type: 'int',
+                    default: 2,
+                    options: {
+                        group: 'Simulation',
+                        minValue: 1,
+                        maxValue: 8
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.localIterations;
+                    },
+                    set (value) {
+                        this.localIterations = value.num[0];
+                    }
+                },
+                {
+                    name: 'Global Stiffness',
+                    description: 'Pull back to the authored pose. Off by default: it anchors points in place, which reads as a spring',
+                    type: 'float',
+                    default: 0,
+                    options: {
+                        group: 'Simulation',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.globalStiffness;
+                    },
+                    set (value) {
+                        this.globalStiffness = value.num[0];
+                    }
+                },
+                {
+                    name: 'Global Range',
+                    description: 'Fraction of a strand, from the root, the pose pull acts on',
+                    type: 'float',
+                    default: 0,
+                    options: {
+                        group: 'Simulation',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.globalRange;
+                    },
+                    set (value) {
+                        this.globalRange = value.num[0];
+                    }
+                },
+                {
+                    name: 'FTL Damping',
+                    description: 'Length correction handed back to the parent point as reverse momentum. Lower whips more',
+                    type: 'float',
+                    default: 0.7,
+                    options: {
+                        group: 'Simulation',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.ftlDamping;
+                    },
+                    set (value) {
+                        this.ftlDamping = value.num[0];
+                    }
+                },
+                {
+                    name: 'Shock Propagation',
+                    description: 'How much of the node motion strands are carried along by. 0 lags fully, 1 follows rigidly',
+                    type: 'float',
+                    default: 0.8,
+                    options: {
+                        group: 'Simulation',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.vspCoeff;
+                    },
+                    set (value) {
+                        this.vspCoeff = value.num[0];
+                    }
+                },
+                {
+                    name: 'Shock Threshold',
+                    description: 'Node acceleration above which strands stop lagging, in units per second squared',
+                    type: 'float',
+                    default: 50,
+                    options: {
+                        group: 'Simulation',
+                        minValue: 0,
+                        maxValue: 500
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.vspAccelThreshold;
+                    },
+                    set (value) {
+                        this.vspAccelThreshold = value.num[0];
+                    }
+                },
+                {
+                    name: 'Damping',
+                    description: 'Velocity lost each step. 0 keeps full inertia',
+                    type: 'float',
+                    default: 0.08,
+                    options: {
+                        group: 'Simulation',
+                        animatable: true,
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.damping;
+                    },
+                    set (value) {
+                        this.damping = value.num[0];
+                    }
+                },
+                {
+                    name: 'Friction',
+                    description: 'Tangential motion removed at a contact',
+                    type: 'float',
+                    default: 0.2,
+                    options: {
+                        group: 'Simulation',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.friction;
+                    },
+                    set (value) {
+                        this.friction = value.num[0];
+                    }
+                },
+                {
+                    name: 'Substeps',
+                    description: 'Integration substeps per fixed step. More is stabler and slower',
+                    type: 'int',
+                    default: 1,
+                    options: {
+                        group: 'Simulation',
+                        minValue: 1,
+                        maxValue: 8
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.substeps;
+                    },
+                    set (value) {
+                        this.substeps = value.num[0];
+                    }
+                },
+                {
+                    name: 'Max Speed Factor',
+                    description: 'Per-substep ceiling on point travel, in segment lengths',
+                    type: 'float',
+                    default: 4,
+                    options: {
+                        group: 'Simulation',
+                        minValue: 0,
+                        maxValue: 32
+                    },
+                    isHidden () {
+                        return !this.simulationEnabled;
+                    },
+                    get (value) {
+                        value.num[0] = this.maxSpeedFactor;
+                    },
+                    set (value) {
+                        this.maxSpeedFactor = value.num[0];
+                    }
+                }
+            ]);
+        }
+    };
+}
+
+export { getHairNodeClass };
+//# sourceMappingURL=hair.js.map