@awesome-flow/noise 0.7.0 → 0.8.0

package/dist/chunk-BG6U3TYO.js

@@ -0,0 +1,1376 @@
+import {
+  noise_displace_node_default,
+  noise_rotate_point_node_default,
+  noise_scale_point_node_default,
+  noise_translate_point_node_default,
+  noise_turbulence_node_default
+} from "./chunk-PS5VUND5.js";
+import {
+  noise_billow_node_default,
+  noise_checkerboard_node_default,
+  noise_const_node_default,
+  noise_cylinders_node_default,
+  noise_perlin_node_default,
+  noise_ridgedmulti_node_default,
+  noise_spheres_node_default,
+  noise_voronoi_node_default,
+  position_const_node_default,
+  position_grid_node_default
+} from "./chunk-DWSACR65.js";
+import {
+  module_group_node_default
+} from "./chunk-KHIIB5TH.js";
+import {
+  noise_abs_node_default,
+  noise_clamp_node_default,
+  noise_combine_node_default,
+  noise_curve_node_default,
+  noise_exponent_node_default,
+  noise_invert_node_default,
+  noise_normalize_node_default,
+  noise_scale_bias_node_default,
+  noise_terrace_node_default
+} from "./chunk-RDQ4BOOV.js";
+
+// src/nodes/output/noise-logger-node.tsx
+import { useIncomingComputedData } from "@awesome-flow/core/hooks";
+import { NodeContainer, NodeTrackConnections } from "@awesome-flow/core/layout";
+import { Divider, Stack, Text } from "@mantine/core";
+import { useMemo } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function NoiseLoggerNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData(id);
+  const noise = useMemo(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+  return /* @__PURE__ */ jsxs(NodeContainer, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Size: ",
+      noise?.length || 0
+    ] }),
+    /* @__PURE__ */ jsx(Divider, { h: 5 }),
+    /* @__PURE__ */ jsx(Stack, { children: noise?.map((v, i) => /* @__PURE__ */ jsxs(Text, { children: [
+      v.position?.x,
+      ":",
+      v.position?.y,
+      ":",
+      v.position?.z,
+      ": ",
+      v.value
+    ] }, i)) }),
+    /* @__PURE__ */ jsx(NodeTrackConnections, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_logger_node_default = NoiseLoggerNode;
+
+// src/nodes/output/noise-output-node.tsx
+import { HandlesIncomingDataStatus as HandlesIncomingDataStatus3 } from "@awesome-flow/core/components";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData4 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer6, NodeTrackConnections as NodeTrackConnections6 } from "@awesome-flow/core/layout";
+import { Text as Text3 } from "@mantine/core";
+import { useCallback as useCallback3, useState as useState3 } from "react";
+
+// src/nodes/selectors/noise-blend-node.tsx
+import { HandlesIncomingDataStatus } from "@awesome-flow/core/components";
+import { useUpdateNodeComputedData } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer2, NodeTrackConnections as NodeTrackConnections2 } from "@awesome-flow/core/layout";
+import { Blend } from "libnoise-simplex-ts";
+import { useCallback } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function NoiseBlendNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData();
+  const onDataUpdated = useCallback(
+    (incomingData) => {
+      const incomingSources = incomingData["source" /* source */];
+      const incomingControl = incomingData["control" /* control */];
+      if (incomingSources?.length >= 2 && incomingControl?.length) {
+        const module = new Blend(
+          incomingSources[0].module,
+          incomingSources[1].module,
+          incomingControl[0].module
+        );
+        updateComputedData(id, { module });
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs2(NodeContainer2, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx2(
+      HandlesIncomingDataStatus,
+      {
+        nodeId: id,
+        handles: data.handles,
+        handleKey: "dataId",
+        onDataUpdated,
+        type: "target",
+        resetComputedData: true
+      }
+    ),
+    /* @__PURE__ */ jsx2(NodeTrackConnections2, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_blend_node_default = NoiseBlendNode;
+
+// src/nodes/selectors/noise-select-node.tsx
+import { HandlesIncomingDataStatus as HandlesIncomingDataStatus2 } from "@awesome-flow/core/components";
+import { useUpdateNodeComputedData as useUpdateNodeComputedData2, useUpdateNodeData } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer3, NodeTrackConnections as NodeTrackConnections3 } from "@awesome-flow/core/layout";
+import { Group, NumberInput, Stack as Stack2 } from "@mantine/core";
+import { Select } from "libnoise-simplex-ts";
+import { useCallback as useCallback2, useEffect, useState } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function NoiseSelectNode({ id, selected, data, type }) {
+  const [edgeFalloff, setEdgeFalloff] = useState(data.edgeFalloff);
+  const [lowerBound, setLowerBound] = useState(data.lowerBound);
+  const [upperBound, setUpperBound] = useState(data.upperBound);
+  const updateNodeData = useUpdateNodeData();
+  const updateComputedData = useUpdateNodeComputedData2();
+  useEffect(() => {
+    updateNodeData(id, { edgeFalloff, lowerBound, upperBound });
+  }, [edgeFalloff, lowerBound, upperBound]);
+  const onDataUpdated = useCallback2(
+    (incomingData) => {
+      const incomingSources = incomingData["source" /* source */];
+      const incomingControl = incomingData["control" /* control */];
+      if (incomingSources?.length >= 2 && incomingControl?.length) {
+        const module = new Select(
+          incomingSources[0].module,
+          incomingSources[1].module,
+          incomingControl[0].module,
+          edgeFalloff,
+          lowerBound,
+          upperBound
+        );
+        updateComputedData(id, { module });
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs3(NodeContainer3, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs3(Stack2, { children: [
+      /* @__PURE__ */ jsxs3(Group, { children: [
+        "Edge Falloff:",
+        /* @__PURE__ */ jsx3(
+          NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: edgeFalloff,
+            onChange: (e) => setEdgeFalloff(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs3(Group, { children: [
+        "Lower Bound:",
+        /* @__PURE__ */ jsx3(
+          NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: lowerBound,
+            onChange: (e) => setLowerBound(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs3(Group, { children: [
+        "Upper Bound:",
+        /* @__PURE__ */ jsx3(
+          NumberInput,
+          {
+            size: "xs",
+            w: 100,
+            value: upperBound,
+            onChange: (e) => setUpperBound(Number(e)),
+            step: 0.1
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx3(
+        HandlesIncomingDataStatus2,
+        {
+          nodeId: id,
+          handles: data.handles,
+          handleKey: "dataId",
+          onDataUpdated,
+          type: "target",
+          resetComputedData: true
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx3(NodeTrackConnections3, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_select_node_default = NoiseSelectNode;
+
+// src/nodes/output/noise-raw-texture-node.tsx
+import { useIncomingComputedData as useIncomingComputedData2, useUpdateNodeComputedData as useUpdateNodeComputedData3 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer4, NodeTrackConnections as NodeTrackConnections4 } from "@awesome-flow/core/layout";
+import { Group as Group2, Stack as Stack3 } from "@mantine/core";
+import { useEffect as useEffect2, useMemo as useMemo2, useState as useState2 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function NoiseRawTextureNode({ id, selected, data, type }) {
+  const updateComputedData = useUpdateNodeComputedData3();
+  const [dataLength, setDataLength] = useState2(0);
+  const [resolution, setResolution] = useState2(0);
+  const incoming = useIncomingComputedData2(id);
+  const noise = useMemo2(() => incoming?.map((p) => p.noise).flat(), [incoming]);
+  useEffect2(() => {
+    if (noise?.length) {
+      const size = Math.ceil(Math.sqrt(noise.length));
+      const colors = noise.map((n) => [n.value * 255, n.value * 255, n.value * 255, 255]).flat();
+      const dataArray = new Uint8Array(size * size * 4);
+      dataArray.set(colors);
+      setResolution(size);
+      setDataLength(dataArray.length);
+      updateComputedData(id, {
+        textureData: dataArray,
+        textureResolutionX: size,
+        textureResolutionY: size
+      });
+    }
+  }, [noise]);
+  return /* @__PURE__ */ jsxs4(NodeContainer4, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs4(Stack3, { children: [
+      /* @__PURE__ */ jsxs4(Group2, { children: [
+        "Resolution: ",
+        resolution,
+        "x",
+        resolution
+      ] }),
+      /* @__PURE__ */ jsxs4(Group2, { children: [
+        "Input Length: ",
+        noise?.length || 0
+      ] }),
+      /* @__PURE__ */ jsxs4(Group2, { children: [
+        "Output Length (",
+        resolution,
+        "*",
+        resolution,
+        "*4): ",
+        dataLength
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4(NodeTrackConnections4, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_raw_texture_node_default = NoiseRawTextureNode;
+
+// src/nodes/output/positions-logger-node.tsx
+import { useIncomingComputedData as useIncomingComputedData3 } from "@awesome-flow/core/hooks";
+import { NodeContainer as NodeContainer5, NodeTrackConnections as NodeTrackConnections5 } from "@awesome-flow/core/layout";
+import { Divider as Divider2, Stack as Stack4, Text as Text2 } from "@mantine/core";
+import { useMemo as useMemo3 } from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function PositionsLoggerNode({ id, selected, data, type }) {
+  const incoming = useIncomingComputedData3(id);
+  const positions = useMemo3(() => {
+    return incoming?.map((p) => p.positions).flat();
+  }, [incoming]);
+  return /* @__PURE__ */ jsxs5(NodeContainer5, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsxs5(Text2, { children: [
+      "Size: ",
+      positions?.length || 0
+    ] }),
+    /* @__PURE__ */ jsx5(Divider2, { h: 5 }),
+    /* @__PURE__ */ jsx5(Stack4, { children: positions?.map((v, i) => /* @__PURE__ */ jsxs5(Text2, { children: [
+      v.x,
+      ":",
+      v.y,
+      ":",
+      v.z
+    ] }, i)) }),
+    /* @__PURE__ */ jsx5(NodeTrackConnections5, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var positions_logger_node_default = PositionsLoggerNode;
+
+// src/templates/generators/noise-billow-template.ts
+import { CoreHandleType } from "@awesome-flow/core/abstract";
+import { IDGenerator } from "@awesome-flow/core/utils";
+import { Position } from "@xyflow/system";
+
+// src/abstract/templates.ts
+var NoiseTemplateGroup = /* @__PURE__ */ ((NoiseTemplateGroup2) => {
+  NoiseTemplateGroup2["positions"] = "Positions";
+  NoiseTemplateGroup2["output"] = "Output";
+  NoiseTemplateGroup2["noiseGenerators"] = "Noise Generators";
+  NoiseTemplateGroup2["noiseModifiers"] = "Noise Modifiers";
+  NoiseTemplateGroup2["noiseSelectors"] = "Noise Selectors";
+  NoiseTemplateGroup2["noiseTransformers"] = "Noise Transformers";
+  return NoiseTemplateGroup2;
+})(NoiseTemplateGroup || {});
+
+// src/templates/generators/noise-billow-template.ts
+var NoiseBillowNodeTemplateFactory = class {
+  template = {
+    id: IDGenerator.template(),
+    type: "noise-billow" /* noiseBillow */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Billow Noise",
+      frequency: 0.1,
+      lacunarity: 2,
+      octaves: 5,
+      persistence: 0.5,
+      seed: 0
+    },
+    handles: [
+      {
+        position: Position.Left,
+        dataType: CoreHandleType.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-checkerboard-template.ts
+import { Position as Position2 } from "@xyflow/system";
+var NoiseCheckerboardNodeTemplateFactory = class {
+  template = {
+    type: "noise-checkerboard" /* noiseCheckerboard */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Checkerboard Noise"
+    },
+    handles: [
+      {
+        position: Position2.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-const-template.ts
+import { Position as Position3 } from "@xyflow/system";
+var NoiseConstNodeTemplateFactory = class {
+  template = {
+    type: "noise-constant" /* noiseConst */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Const Value Noise",
+      noise: 0,
+      min: -1,
+      max: 1
+    },
+    handles: [
+      {
+        position: Position3.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-cylinders-template.ts
+import { CoreHandleType as CoreHandleType2 } from "@awesome-flow/core/abstract";
+import { Position as Position4 } from "@xyflow/system";
+var NoiseCylindersNodeTemplateFactory = class {
+  template = {
+    type: "noise-cylinders" /* noiseCylinders */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Cylinders Noise",
+      frequency: 0.1
+    },
+    handles: [
+      {
+        position: Position4.Left,
+        dataType: CoreHandleType2.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position4.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-perlin-template.ts
+import { CoreHandleType as CoreHandleType3 } from "@awesome-flow/core/abstract";
+import { Position as Position5 } from "@xyflow/system";
+var NoisePerlinNodeTemplateFactory = class {
+  template = {
+    type: "noise-perlin" /* noisePerlin */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Perlin Noise",
+      frequency: 0.1,
+      lacunarity: 2,
+      octaves: 5,
+      persistence: 0.5,
+      seed: 0
+    },
+    handles: [
+      {
+        position: Position5.Left,
+        dataType: CoreHandleType3.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position5.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-ridgedmulti-template.ts
+import { CoreHandleType as CoreHandleType4 } from "@awesome-flow/core/abstract";
+import { Position as Position6 } from "@xyflow/system";
+var NoiseRidgedMultiNodeTemplateFactory = class {
+  template = {
+    type: "noise-ridged-multi" /* noiseRidgedMulti */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Ridged Multi Noise",
+      frequency: 0.1,
+      lacunarity: 2,
+      octaves: 6,
+      offset: 1,
+      gain: 2,
+      seed: 0
+    },
+    handles: [
+      {
+        position: Position6.Left,
+        dataType: CoreHandleType4.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position6.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-spheres-template.ts
+import { CoreHandleType as CoreHandleType5 } from "@awesome-flow/core/abstract";
+import { Position as Position7 } from "@xyflow/system";
+var NoiseSpheresNodeTemplateFactory = class {
+  template = {
+    type: "noise-spheres" /* noiseSpheres */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Spheres Noise",
+      frequency: 0.1
+    },
+    handles: [
+      {
+        position: Position7.Left,
+        dataType: CoreHandleType5.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position7.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/noise-voronoi-template.ts
+import { CoreHandleType as CoreHandleType6 } from "@awesome-flow/core/abstract";
+import { Position as Position8 } from "@xyflow/system";
+var NoiseVoronoiNodeTemplateFactory = class {
+  template = {
+    type: "noise-voronoi" /* noiseVoronoi */,
+    group: "Noise Generators" /* noiseGenerators */,
+    data: {
+      title: "Voronoi Noise",
+      frequency: 0.1,
+      displacement: 1,
+      distance: true,
+      seed: 0
+    },
+    handles: [
+      {
+        position: Position8.Left,
+        dataType: CoreHandleType6.variableProperty,
+        connection: "target"
+      },
+      {
+        position: Position8.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/position-const-template.ts
+import { Position as Position9 } from "@xyflow/system";
+var PositionConstNodeTemplateFactory = class {
+  template = {
+    type: "position" /* position */,
+    group: "Positions" /* positions */,
+    data: {
+      title: "Position Output",
+      position: { x: 0, y: 0, z: 0 }
+    },
+    handles: [
+      {
+        position: Position9.Right,
+        dataType: "position" /* position */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/generators/position-grid-template.ts
+import { Position as Position10 } from "@xyflow/system";
+var PositionGridNodeTemplateFactory = class {
+  template = {
+    type: "grid" /* grid */,
+    group: "Positions" /* positions */,
+    data: {
+      title: "Grid Output",
+      center: { x: 0, y: 0, z: 0 },
+      radius: 1
+    },
+    handles: [
+      {
+        position: Position10.Right,
+        dataType: "position" /* position */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/groups/module-group-template.ts
+import {
+  CoreTemplateGroup
+} from "@awesome-flow/core/abstract";
+import { IDGenerator as IDGenerator2 } from "@awesome-flow/core/utils";
+import { Position as Position11 } from "@xyflow/system";
+var ModuleGroupNodeTemplateFactory = class {
+  template = {
+    id: IDGenerator2.template(),
+    type: "group-module" /* groupModule */,
+    group: CoreTemplateGroup.groups,
+    data: {
+      title: "Modules Group",
+      isGroup: true,
+      initialSize: {
+        width: 300,
+        height: 200
+      },
+      collapsedSize: {
+        width: 300,
+        height: 80
+      }
+    },
+    handles: [
+      {
+        position: Position11.Bottom,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1,
+        hideOnCollapse: true
+      },
+      {
+        position: Position11.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-abs-template.ts
+import { Position as Position12 } from "@xyflow/system";
+var NoiseAbsNodeTemplateFactory = class {
+  template = {
+    type: "noise-abs" /* noiseAbs */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Abs Noise"
+    },
+    handles: [
+      {
+        position: Position12.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position12.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-clamp-template.ts
+import { Position as Position13 } from "@xyflow/system";
+var NoiseClampNodeTemplateFactory = class {
+  template = {
+    type: "noise-clamp" /* noiseClamp */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Clamp Noise",
+      lowerBound: -1,
+      upperBound: 1
+    },
+    handles: [
+      {
+        position: Position13.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position13.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-combine-template.ts
+import { Position as Position14 } from "@xyflow/system";
+var NoiseCombineNodeTemplateFactory = class {
+  template = {
+    type: "noise-combiner" /* noiseCombine */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Combine Noise",
+      operation: "add" /* add */
+    },
+    handles: [
+      {
+        position: Position14.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 2
+      },
+      {
+        position: Position14.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-curve-template.ts
+import { Position as Position15 } from "@xyflow/system";
+var NoiseCurveNodeTemplateFactory = class {
+  template = {
+    type: "noise-curve" /* noiseCurve */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Noise Curve",
+      points: []
+    },
+    handles: [
+      {
+        position: Position15.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      // {
+      //   position: Position.Left,
+      //   dataType: CoreHandleType.variableProperty,
+      //   connection: 'target',
+      // },
+      {
+        position: Position15.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-exponent-template.ts
+import { Position as Position16 } from "@xyflow/system";
+var NoiseExponentNodeTemplateFactory = class {
+  template = {
+    type: "noise-exponent" /* noiseExponent */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Noise Exponent",
+      exponent: 1
+    },
+    handles: [
+      {
+        position: Position16.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position16.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-invert-template.ts
+import { Position as Position17 } from "@xyflow/system";
+var NoiseInvertNodeTemplateFactory = class {
+  template = {
+    type: "noise-invert" /* noiseInvert */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Invert Noise"
+    },
+    handles: [
+      {
+        position: Position17.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position17.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-normalize-template.ts
+import { IDGenerator as IDGenerator3 } from "@awesome-flow/core/utils";
+import { Position as Position18 } from "@xyflow/system";
+var NoiseNormalizeNodeTemplateFactory = class {
+  template = {
+    id: IDGenerator3.template(),
+    type: "noise-normalize" /* noiseNormalize */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Normalize Noise",
+      intervalStart: -1,
+      intervalEnd: 1
+    },
+    handles: [
+      {
+        position: Position18.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position18.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-scalebias-template.ts
+import { Position as Position19 } from "@xyflow/system";
+var NoiseScaleBiasNodeTemplateFactory = class {
+  template = {
+    type: "noise-scale-bias" /* noiseScaleBias */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Scale/Bias Noise",
+      scale: 1,
+      bias: 0
+    },
+    handles: [
+      {
+        position: Position19.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position19.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/modifiers/noise-terrace-template.ts
+import { Position as Position20 } from "@xyflow/system";
+var NoiseTerraceNodeTemplateFactory = class {
+  template = {
+    type: "noise-terrace" /* noiseTerrace */,
+    group: "Noise Modifiers" /* noiseModifiers */,
+    data: {
+      title: "Noise Terrace",
+      points: []
+    },
+    handles: [
+      {
+        position: Position20.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position20.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/output/noise-logger-template.ts
+import { Position as Position21 } from "@xyflow/system";
+var NoiseLoggerNodeTemplateFactory = class {
+  template = {
+    type: "noise-logger" /* noiseLogger */,
+    group: "Output" /* output */,
+    data: {
+      title: "Noise Logger"
+    },
+    handles: [
+      {
+        position: Position21.Left,
+        dataType: "noise" /* noise */,
+        connection: "target"
+      }
+    ]
+  };
+};
+
+// src/templates/output/noise-output-template.ts
+import { Position as Position22 } from "@xyflow/system";
+var NoiseOutputNodeTemplateFactory = class {
+  template = {
+    type: "noise-output" /* noiseOutput */,
+    group: "Output" /* output */,
+    data: {
+      title: "Noise Output"
+    },
+    handles: [
+      {
+        position: Position22.Left,
+        dataType: "position" /* position */,
+        connection: "target"
+      },
+      {
+        position: Position22.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position22.Right,
+        dataType: "noise" /* noise */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/output/noise-raw-texture-template.ts
+import { Position as Position23 } from "@xyflow/system";
+var NoiseRawTextureTemplateFactory = class {
+  template = {
+    type: "texture-data" /* textureData */,
+    group: "Output" /* output */,
+    data: {
+      title: "Texture Data"
+    },
+    handles: [
+      {
+        position: Position23.Left,
+        dataType: "noise" /* noise */,
+        connection: "target",
+        maxConnections: 1
+      },
+      {
+        position: Position23.Right,
+        dataType: "texture" /* texture */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/output/position-logger-template.ts
+import { Position as Position24 } from "@xyflow/system";
+var PositionLoggerNodeTemplateFactory = class {
+  template = {
+    type: "position-logger" /* positionLogger */,
+    group: "Positions" /* positions */,
+    data: {
+      title: "Position Logger"
+    },
+    handles: [
+      {
+        position: Position24.Left,
+        dataType: "position" /* position */,
+        connection: "target"
+      }
+    ]
+  };
+};
+
+// src/templates/selectors/noise-blend-template.ts
+import { Position as Position25 } from "@xyflow/system";
+var NoiseBlendNodeTemplateFactory = class {
+  template = {
+    type: "noise-blend" /* noiseBlend */,
+    group: "Noise Selectors" /* noiseSelectors */,
+    data: {
+      title: "Noise Blend"
+    },
+    handles: [
+      {
+        position: Position25.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Modules",
+        dataId: "source" /* source */,
+        maxConnections: 2,
+        minConnections: 2
+      },
+      {
+        position: Position25.Left,
+        dataType: "module" /* module */,
+        dataId: "control" /* control */,
+        connection: "target",
+        label: "Control Module",
+        maxConnections: 1
+      },
+      {
+        position: Position25.Right,
+        dataType: "module" /* module */,
+        dataId: "output" /* output */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/selectors/noise-select-template.ts
+import { Position as Position26 } from "@xyflow/system";
+var NoiseSelectNodeTemplateFactory = class {
+  template = {
+    type: "noise-select" /* noiseSelect */,
+    group: "Noise Selectors" /* noiseSelectors */,
+    data: {
+      title: "Noise Select",
+      edgeFalloff: 0,
+      lowerBound: -1,
+      upperBound: 1
+    },
+    handles: [
+      {
+        position: Position26.Left,
+        dataType: "module" /* module */,
+        dataId: "source" /* source */,
+        connection: "target",
+        label: "Source Modules",
+        maxConnections: 2,
+        minConnections: 2
+      },
+      {
+        position: Position26.Left,
+        dataType: "module" /* module */,
+        dataId: "control" /* control */,
+        connection: "target",
+        label: "Control Module",
+        maxConnections: 1
+      },
+      {
+        position: Position26.Right,
+        dataType: "module" /* module */,
+        dataId: "output" /* output */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/transformers/noise-displace-template.ts
+import { Position as Position27 } from "@xyflow/system";
+var NoiseDisplaceNodeTemplateFactory = class {
+  template = {
+    type: "noise-displace" /* noiseDisplace */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Displace"
+    },
+    handles: [
+      {
+        position: Position27.Left,
+        connection: "target",
+        label: "Source Module",
+        dataType: "module" /* module */,
+        dataId: "source" /* sourceModule */,
+        maxConnections: 1
+      },
+      {
+        position: Position27.Left,
+        connection: "target",
+        label: "X Module",
+        dataType: "module" /* module */,
+        dataId: "x-module" /* xModule */,
+        maxConnections: 1
+      },
+      {
+        position: Position27.Left,
+        connection: "target",
+        label: "Y Module",
+        dataType: "module" /* module */,
+        dataId: "y-module" /* yModule */,
+        maxConnections: 1
+      },
+      {
+        position: Position27.Left,
+        connection: "target",
+        label: "Z Module",
+        dataType: "module" /* module */,
+        dataId: "z-module" /* zModule */,
+        maxConnections: 1
+      },
+      {
+        position: Position27.Right,
+        dataType: "module" /* module */,
+        dataId: "output" /* output */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/transformers/noise-rotate-point-template.ts
+import { Position as Position28 } from "@xyflow/system";
+var NoiseRotatePointNodeTemplateFactory = class {
+  template = {
+    type: "noise-rotate-point" /* noiseRotatePoint */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Rotate Point",
+      xAngle: 0,
+      yAngle: 0,
+      zAngle: 0
+    },
+    handles: [
+      {
+        position: Position28.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: Position28.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/transformers/noise-scale-point-template.ts
+import { Position as Position29 } from "@xyflow/system";
+var NoiseScalePointNodeTemplateFactory = class {
+  template = {
+    type: "noise-scale-point" /* noiseScalePoint */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Scale Point",
+      xScale: 1,
+      yScale: 1,
+      zScale: 1
+    },
+    handles: [
+      {
+        position: Position29.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: Position29.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/transformers/noise-translate-point-template.ts
+import { Position as Position30 } from "@xyflow/system";
+var NoiseTranslatePointNodeTemplateFactory = class {
+  template = {
+    type: "noise-translate-point" /* noiseTranslatePoint */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Translate Point",
+      translateX: 0,
+      translateY: 0,
+      translateZ: 0
+    },
+    handles: [
+      {
+        position: Position30.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: Position30.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/templates/transformers/noise-turbulence-template.ts
+import { CoreHandleType as CoreHandleType7 } from "@awesome-flow/core/abstract";
+import { Position as Position31 } from "@xyflow/system";
+var NoiseTurbulenceNodeTemplateFactory = class {
+  template = {
+    type: "noise-turbulence" /* noiseTurbulence */,
+    group: "Noise Transformers" /* noiseTransformers */,
+    data: {
+      title: "Noise Turbulence",
+      frequency: 1,
+      power: 1,
+      roughness: 1,
+      seed: 0
+    },
+    handles: [
+      {
+        position: Position31.Left,
+        dataType: "module" /* module */,
+        connection: "target",
+        label: "Source Module",
+        maxConnections: 1
+      },
+      {
+        position: Position31.Left,
+        dataType: CoreHandleType7.variableProperty,
+        label: "Variable Properties",
+        connection: "target"
+      },
+      {
+        position: Position31.Right,
+        dataType: "module" /* module */,
+        connection: "source"
+      }
+    ]
+  };
+};
+
+// src/abstract/node-types.ts
+var NoiseNodeType = /* @__PURE__ */ ((NoiseNodeType2) => {
+  NoiseNodeType2["position"] = "position";
+  NoiseNodeType2["grid"] = "grid";
+  NoiseNodeType2["textureData"] = "texture-data";
+  NoiseNodeType2["groupModule"] = "group-module";
+  NoiseNodeType2["positionLogger"] = "position-logger";
+  NoiseNodeType2["noiseLogger"] = "noise-logger";
+  NoiseNodeType2["noiseOutput"] = "noise-output";
+  NoiseNodeType2["noiseConst"] = "noise-constant";
+  NoiseNodeType2["noiseBillow"] = "noise-billow";
+  NoiseNodeType2["noiseCheckerboard"] = "noise-checkerboard";
+  NoiseNodeType2["noiseNormalize"] = "noise-normalize";
+  NoiseNodeType2["noiseCylinders"] = "noise-cylinders";
+  NoiseNodeType2["noisePerlin"] = "noise-perlin";
+  NoiseNodeType2["noiseRidgedMulti"] = "noise-ridged-multi";
+  NoiseNodeType2["noiseSpheres"] = "noise-spheres";
+  NoiseNodeType2["noiseVoronoi"] = "noise-voronoi";
+  NoiseNodeType2["noiseCombine"] = "noise-combiner";
+  NoiseNodeType2["noiseClamp"] = "noise-clamp";
+  NoiseNodeType2["noiseAbs"] = "noise-abs";
+  NoiseNodeType2["noiseCurve"] = "noise-curve";
+  NoiseNodeType2["noiseExponent"] = "noise-exponent";
+  NoiseNodeType2["noiseInvert"] = "noise-invert";
+  NoiseNodeType2["noiseScaleBias"] = "noise-scale-bias";
+  NoiseNodeType2["noiseTerrace"] = "noise-terrace";
+  NoiseNodeType2["noiseBlend"] = "noise-blend";
+  NoiseNodeType2["noiseSelect"] = "noise-select";
+  NoiseNodeType2["noiseDisplace"] = "noise-displace";
+  NoiseNodeType2["noiseRotatePoint"] = "noise-rotate-point";
+  NoiseNodeType2["noiseScalePoint"] = "noise-scale-point";
+  NoiseNodeType2["noiseTranslatePoint"] = "noise-translate-point";
+  NoiseNodeType2["noiseTurbulence"] = "noise-turbulence";
+  return NoiseNodeType2;
+})(NoiseNodeType || {});
+var noiseNodeTypes = {
+  ["group-module" /* groupModule */]: module_group_node_default,
+  ["position" /* position */]: position_const_node_default,
+  ["grid" /* grid */]: position_grid_node_default,
+  ["noise-output" /* noiseOutput */]: noise_output_node_default,
+  ["texture-data" /* textureData */]: noise_raw_texture_node_default,
+  ["noise-logger" /* noiseLogger */]: noise_logger_node_default,
+  ["position-logger" /* positionLogger */]: positions_logger_node_default,
+  ["noise-constant" /* noiseConst */]: noise_const_node_default,
+  ["noise-billow" /* noiseBillow */]: noise_billow_node_default,
+  ["noise-checkerboard" /* noiseCheckerboard */]: noise_checkerboard_node_default,
+  ["noise-cylinders" /* noiseCylinders */]: noise_cylinders_node_default,
+  ["noise-perlin" /* noisePerlin */]: noise_perlin_node_default,
+  ["noise-ridged-multi" /* noiseRidgedMulti */]: noise_ridgedmulti_node_default,
+  ["noise-spheres" /* noiseSpheres */]: noise_spheres_node_default,
+  ["noise-voronoi" /* noiseVoronoi */]: noise_voronoi_node_default,
+  ["noise-combiner" /* noiseCombine */]: noise_combine_node_default,
+  ["noise-clamp" /* noiseClamp */]: noise_clamp_node_default,
+  ["noise-abs" /* noiseAbs */]: noise_abs_node_default,
+  ["noise-normalize" /* noiseNormalize */]: noise_normalize_node_default,
+  ["noise-curve" /* noiseCurve */]: noise_curve_node_default,
+  ["noise-exponent" /* noiseExponent */]: noise_exponent_node_default,
+  ["noise-invert" /* noiseInvert */]: noise_invert_node_default,
+  ["noise-scale-bias" /* noiseScaleBias */]: noise_scale_bias_node_default,
+  ["noise-terrace" /* noiseTerrace */]: noise_terrace_node_default,
+  ["noise-blend" /* noiseBlend */]: noise_blend_node_default,
+  ["noise-select" /* noiseSelect */]: noise_select_node_default,
+  ["noise-displace" /* noiseDisplace */]: noise_displace_node_default,
+  ["noise-rotate-point" /* noiseRotatePoint */]: noise_rotate_point_node_default,
+  ["noise-scale-point" /* noiseScalePoint */]: noise_scale_point_node_default,
+  ["noise-translate-point" /* noiseTranslatePoint */]: noise_translate_point_node_default,
+  ["noise-turbulence" /* noiseTurbulence */]: noise_turbulence_node_default
+};
+var noiseNodeTemplates = {
+  ["noise-output" /* noiseOutput */]: new NoiseOutputNodeTemplateFactory(),
+  ["noise-billow" /* noiseBillow */]: new NoiseBillowNodeTemplateFactory(),
+  ["noise-checkerboard" /* noiseCheckerboard */]: new NoiseCheckerboardNodeTemplateFactory(),
+  ["noise-normalize" /* noiseNormalize */]: new NoiseNormalizeNodeTemplateFactory(),
+  ["noise-logger" /* noiseLogger */]: new NoiseLoggerNodeTemplateFactory(),
+  ["noise-constant" /* noiseConst */]: new NoiseConstNodeTemplateFactory(),
+  ["position" /* position */]: new PositionConstNodeTemplateFactory(),
+  ["position-logger" /* positionLogger */]: new PositionLoggerNodeTemplateFactory(),
+  ["grid" /* grid */]: new PositionGridNodeTemplateFactory(),
+  ["texture-data" /* textureData */]: new NoiseRawTextureTemplateFactory(),
+  ["noise-cylinders" /* noiseCylinders */]: new NoiseCylindersNodeTemplateFactory(),
+  ["noise-perlin" /* noisePerlin */]: new NoisePerlinNodeTemplateFactory(),
+  ["noise-ridged-multi" /* noiseRidgedMulti */]: new NoiseRidgedMultiNodeTemplateFactory(),
+  ["noise-spheres" /* noiseSpheres */]: new NoiseSpheresNodeTemplateFactory(),
+  ["noise-voronoi" /* noiseVoronoi */]: new NoiseVoronoiNodeTemplateFactory(),
+  ["noise-combiner" /* noiseCombine */]: new NoiseCombineNodeTemplateFactory(),
+  ["noise-clamp" /* noiseClamp */]: new NoiseClampNodeTemplateFactory(),
+  ["noise-abs" /* noiseAbs */]: new NoiseAbsNodeTemplateFactory(),
+  ["noise-curve" /* noiseCurve */]: new NoiseCurveNodeTemplateFactory(),
+  ["noise-exponent" /* noiseExponent */]: new NoiseExponentNodeTemplateFactory(),
+  ["noise-invert" /* noiseInvert */]: new NoiseInvertNodeTemplateFactory(),
+  ["noise-scale-bias" /* noiseScaleBias */]: new NoiseScaleBiasNodeTemplateFactory(),
+  ["noise-terrace" /* noiseTerrace */]: new NoiseTerraceNodeTemplateFactory(),
+  ["noise-blend" /* noiseBlend */]: new NoiseBlendNodeTemplateFactory(),
+  ["noise-select" /* noiseSelect */]: new NoiseSelectNodeTemplateFactory(),
+  ["noise-displace" /* noiseDisplace */]: new NoiseDisplaceNodeTemplateFactory(),
+  ["noise-rotate-point" /* noiseRotatePoint */]: new NoiseRotatePointNodeTemplateFactory(),
+  ["noise-scale-point" /* noiseScalePoint */]: new NoiseScalePointNodeTemplateFactory(),
+  ["noise-translate-point" /* noiseTranslatePoint */]: new NoiseTranslatePointNodeTemplateFactory(),
+  ["noise-turbulence" /* noiseTurbulence */]: new NoiseTurbulenceNodeTemplateFactory(),
+  ["group-module" /* groupModule */]: new ModuleGroupNodeTemplateFactory()
+};
+
+// src/nodes/output/noise-output-node.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function NoiseOutputNode({ id, selected, data, type }) {
+  const [size, setSize] = useState3(0);
+  const updateComputedData = useUpdateNodeComputedData4();
+  const onDataUpdated = useCallback3(
+    (handleData) => {
+      const incomingPositions = handleData["position" /* position */];
+      const incomingModule = handleData["module" /* module */];
+      if (incomingPositions?.length && incomingModule?.length && incomingModule[0]?.module) {
+        const { module } = incomingModule[0];
+        const noise = [];
+        for (const input of incomingPositions) {
+          for (const position of input.positions) {
+            const value = module.getValue(position.x, position.y, position.z);
+            noise.push({
+              position,
+              value
+            });
+          }
+        }
+        updateComputedData(id, { noise, module });
+        setSize(noise.length);
+      }
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs6(NodeContainer6, { id, selected, data, type, children: [
+    /* @__PURE__ */ jsx6(
+      HandlesIncomingDataStatus3,
+      {
+        nodeId: id,
+        handles: data.handles,
+        handleKey: "dataType",
+        onDataUpdated,
+        type: "target",
+        resetComputedData: true
+      }
+    ),
+    /* @__PURE__ */ jsxs6(Text3, { mt: 5, children: [
+      "Noise points: ",
+      size
+    ] }),
+    /* @__PURE__ */ jsx6(NodeTrackConnections6, { handles: data.handles, nodeId: id, type: "target" })
+  ] });
+}
+var noise_output_node_default = NoiseOutputNode;
+
+export {
+  noise_logger_node_default,
+  noise_output_node_default,
+  noise_raw_texture_node_default,
+  positions_logger_node_default,
+  noise_blend_node_default,
+  noise_select_node_default,
+  NoiseTemplateGroup,
+  NoiseBillowNodeTemplateFactory,
+  NoiseCheckerboardNodeTemplateFactory,
+  NoiseConstNodeTemplateFactory,
+  NoiseCylindersNodeTemplateFactory,
+  NoisePerlinNodeTemplateFactory,
+  NoiseRidgedMultiNodeTemplateFactory,
+  NoiseSpheresNodeTemplateFactory,
+  NoiseVoronoiNodeTemplateFactory,
+  PositionConstNodeTemplateFactory,
+  PositionGridNodeTemplateFactory,
+  ModuleGroupNodeTemplateFactory,
+  NoiseAbsNodeTemplateFactory,
+  NoiseClampNodeTemplateFactory,
+  NoiseCombineNodeTemplateFactory,
+  NoiseCurveNodeTemplateFactory,
+  NoiseExponentNodeTemplateFactory,
+  NoiseInvertNodeTemplateFactory,
+  NoiseNormalizeNodeTemplateFactory,
+  NoiseScaleBiasNodeTemplateFactory,
+  NoiseTerraceNodeTemplateFactory,
+  NoiseLoggerNodeTemplateFactory,
+  NoiseOutputNodeTemplateFactory,
+  NoiseRawTextureTemplateFactory,
+  PositionLoggerNodeTemplateFactory,
+  NoiseBlendNodeTemplateFactory,
+  NoiseSelectNodeTemplateFactory,
+  NoiseDisplaceNodeTemplateFactory,
+  NoiseRotatePointNodeTemplateFactory,
+  NoiseScalePointNodeTemplateFactory,
+  NoiseTranslatePointNodeTemplateFactory,
+  NoiseTurbulenceNodeTemplateFactory,
+  NoiseNodeType,
+  noiseNodeTypes,
+  noiseNodeTemplates
+};