@openhps/core/src/three/nodes/materialx/lib/mx_noise.js

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.mx_worley_noise_vec3_1 = exports.mx_worley_noise_vec3_0 = exports.mx_worley_noise_vec3 = exports.mx_worley_noise_vec2_1 = exports.mx_worley_noise_vec2_0 = exports.mx_worley_noise_vec2 = exports.mx_worley_noise_float_1 = exports.mx_worley_noise_float_0 = exports.mx_worley_noise_float = exports.mx_worley_distance_1 = exports.mx_worley_distance_0 = exports.mx_worley_distance = exports.mx_trilerp_1 = exports.mx_trilerp_0 = exports.mx_trilerp = exports.mx_select = exports.mx_rotl32 = exports.mx_perlin_noise_vec3_1 = exports.mx_perlin_noise_vec3_0 = exports.mx_perlin_noise_vec3 = exports.mx_perlin_noise_float_1 = exports.mx_perlin_noise_float_0 = exports.mx_perlin_noise_float = exports.mx_negate_if = exports.mx_hash_vec3_1 = exports.mx_hash_vec3_0 = exports.mx_hash_vec3 = exports.mx_hash_int_4 = exports.mx_hash_int_3 = exports.mx_hash_int_2 = exports.mx_hash_int_1 = exports.mx_hash_int_0 = exports.mx_hash_int = exports.mx_gradient_vec3_1 = exports.mx_gradient_vec3_0 = exports.mx_gradient_vec3 = exports.mx_gradient_scale3d_1 = exports.mx_gradient_scale3d_0 = exports.mx_gradient_scale3d = exports.mx_gradient_scale2d_1 = exports.mx_gradient_scale2d_0 = exports.mx_gradient_scale2d = exports.mx_gradient_float_1 = exports.mx_gradient_float_0 = exports.mx_gradient_float = exports.mx_fractal_noise_vec4 = exports.mx_fractal_noise_vec3 = exports.mx_fractal_noise_vec2 = exports.mx_fractal_noise_float = exports.mx_floorfrac = exports.mx_floor = exports.mx_fade = exports.mx_cell_noise_vec3_3 = exports.mx_cell_noise_vec3_2 = exports.mx_cell_noise_vec3_1 = exports.mx_cell_noise_vec3_0 = exports.mx_cell_noise_vec3 = exports.mx_cell_noise_float_3 = exports.mx_cell_noise_float_2 = exports.mx_cell_noise_float_1 = exports.mx_cell_noise_float_0 = exports.mx_cell_noise_float = exports.mx_bjmix = exports.mx_bjfinal = exports.mx_bits_to_01 = exports.mx_bilerp_1 = exports.mx_bilerp_0 = exports.mx_bilerp = void 0;
var _TSLBase = require("../../tsl/TSLBase.js");
var _ConditionalNode = require("../../math/ConditionalNode.js");
var _OperatorNode = require("../../math/OperatorNode.js");
var _MathNode = require("../../math/MathNode.js");
var _FunctionOverloadingNode = require("../../utils/FunctionOverloadingNode.js");
var _LoopNode = require("../../utils/LoopNode.js");
// Three.js Transpiler
// https://raw.githubusercontent.com/AcademySoftwareFoundation/MaterialX/main/libraries/stdlib/genglsl/lib/mx_noise.glsl

const mx_select = exports.mx_select = /*@__PURE__*/(0, _TSLBase.Fn)(([b_immutable, t_immutable, f_immutable]) => {
  const f = (0, _TSLBase.float)(f_immutable).toVar();
  const t = (0, _TSLBase.float)(t_immutable).toVar();
  const b = (0, _TSLBase.bool)(b_immutable).toVar();
  return (0, _ConditionalNode.select)(b, t, f);
}).setLayout({
  name: 'mx_select',
  type: 'float',
  inputs: [{
    name: 'b',
    type: 'bool'
  }, {
    name: 't',
    type: 'float'
  }, {
    name: 'f',
    type: 'float'
  }]
});
const mx_negate_if = exports.mx_negate_if = /*@__PURE__*/(0, _TSLBase.Fn)(([val_immutable, b_immutable]) => {
  const b = (0, _TSLBase.bool)(b_immutable).toVar();
  const val = (0, _TSLBase.float)(val_immutable).toVar();
  return (0, _ConditionalNode.select)(b, val.negate(), val);
}).setLayout({
  name: 'mx_negate_if',
  type: 'float',
  inputs: [{
    name: 'val',
    type: 'float'
  }, {
    name: 'b',
    type: 'bool'
  }]
});
const mx_floor = exports.mx_floor = /*@__PURE__*/(0, _TSLBase.Fn)(([x_immutable]) => {
  const x = (0, _TSLBase.float)(x_immutable).toVar();
  return (0, _TSLBase.int)((0, _MathNode.floor)(x));
}).setLayout({
  name: 'mx_floor',
  type: 'int',
  inputs: [{
    name: 'x',
    type: 'float'
  }]
});
const mx_floorfrac = exports.mx_floorfrac = /*@__PURE__*/(0, _TSLBase.Fn)(([x_immutable, i]) => {
  const x = (0, _TSLBase.float)(x_immutable).toVar();
  i.assign(mx_floor(x));
  return x.sub((0, _TSLBase.float)(i));
});
const mx_bilerp_0 = exports.mx_bilerp_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([v0_immutable, v1_immutable, v2_immutable, v3_immutable, s_immutable, t_immutable]) => {
  const t = (0, _TSLBase.float)(t_immutable).toVar();
  const s = (0, _TSLBase.float)(s_immutable).toVar();
  const v3 = (0, _TSLBase.float)(v3_immutable).toVar();
  const v2 = (0, _TSLBase.float)(v2_immutable).toVar();
  const v1 = (0, _TSLBase.float)(v1_immutable).toVar();
  const v0 = (0, _TSLBase.float)(v0_immutable).toVar();
  const s1 = (0, _TSLBase.float)((0, _OperatorNode.sub)(1.0, s)).toVar();
  return (0, _OperatorNode.sub)(1.0, t).mul(v0.mul(s1).add(v1.mul(s))).add(t.mul(v2.mul(s1).add(v3.mul(s))));
}).setLayout({
  name: 'mx_bilerp_0',
  type: 'float',
  inputs: [{
    name: 'v0',
    type: 'float'
  }, {
    name: 'v1',
    type: 'float'
  }, {
    name: 'v2',
    type: 'float'
  }, {
    name: 'v3',
    type: 'float'
  }, {
    name: 's',
    type: 'float'
  }, {
    name: 't',
    type: 'float'
  }]
});
const mx_bilerp_1 = exports.mx_bilerp_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([v0_immutable, v1_immutable, v2_immutable, v3_immutable, s_immutable, t_immutable]) => {
  const t = (0, _TSLBase.float)(t_immutable).toVar();
  const s = (0, _TSLBase.float)(s_immutable).toVar();
  const v3 = (0, _TSLBase.vec3)(v3_immutable).toVar();
  const v2 = (0, _TSLBase.vec3)(v2_immutable).toVar();
  const v1 = (0, _TSLBase.vec3)(v1_immutable).toVar();
  const v0 = (0, _TSLBase.vec3)(v0_immutable).toVar();
  const s1 = (0, _TSLBase.float)((0, _OperatorNode.sub)(1.0, s)).toVar();
  return (0, _OperatorNode.sub)(1.0, t).mul(v0.mul(s1).add(v1.mul(s))).add(t.mul(v2.mul(s1).add(v3.mul(s))));
}).setLayout({
  name: 'mx_bilerp_1',
  type: 'vec3',
  inputs: [{
    name: 'v0',
    type: 'vec3'
  }, {
    name: 'v1',
    type: 'vec3'
  }, {
    name: 'v2',
    type: 'vec3'
  }, {
    name: 'v3',
    type: 'vec3'
  }, {
    name: 's',
    type: 'float'
  }, {
    name: 't',
    type: 'float'
  }]
});
const mx_bilerp = exports.mx_bilerp = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_bilerp_0, mx_bilerp_1]);
const mx_trilerp_0 = exports.mx_trilerp_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([v0_immutable, v1_immutable, v2_immutable, v3_immutable, v4_immutable, v5_immutable, v6_immutable, v7_immutable, s_immutable, t_immutable, r_immutable]) => {
  const r = (0, _TSLBase.float)(r_immutable).toVar();
  const t = (0, _TSLBase.float)(t_immutable).toVar();
  const s = (0, _TSLBase.float)(s_immutable).toVar();
  const v7 = (0, _TSLBase.float)(v7_immutable).toVar();
  const v6 = (0, _TSLBase.float)(v6_immutable).toVar();
  const v5 = (0, _TSLBase.float)(v5_immutable).toVar();
  const v4 = (0, _TSLBase.float)(v4_immutable).toVar();
  const v3 = (0, _TSLBase.float)(v3_immutable).toVar();
  const v2 = (0, _TSLBase.float)(v2_immutable).toVar();
  const v1 = (0, _TSLBase.float)(v1_immutable).toVar();
  const v0 = (0, _TSLBase.float)(v0_immutable).toVar();
  const s1 = (0, _TSLBase.float)((0, _OperatorNode.sub)(1.0, s)).toVar();
  const t1 = (0, _TSLBase.float)((0, _OperatorNode.sub)(1.0, t)).toVar();
  const r1 = (0, _TSLBase.float)((0, _OperatorNode.sub)(1.0, r)).toVar();
  return r1.mul(t1.mul(v0.mul(s1).add(v1.mul(s))).add(t.mul(v2.mul(s1).add(v3.mul(s))))).add(r.mul(t1.mul(v4.mul(s1).add(v5.mul(s))).add(t.mul(v6.mul(s1).add(v7.mul(s))))));
}).setLayout({
  name: 'mx_trilerp_0',
  type: 'float',
  inputs: [{
    name: 'v0',
    type: 'float'
  }, {
    name: 'v1',
    type: 'float'
  }, {
    name: 'v2',
    type: 'float'
  }, {
    name: 'v3',
    type: 'float'
  }, {
    name: 'v4',
    type: 'float'
  }, {
    name: 'v5',
    type: 'float'
  }, {
    name: 'v6',
    type: 'float'
  }, {
    name: 'v7',
    type: 'float'
  }, {
    name: 's',
    type: 'float'
  }, {
    name: 't',
    type: 'float'
  }, {
    name: 'r',
    type: 'float'
  }]
});
const mx_trilerp_1 = exports.mx_trilerp_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([v0_immutable, v1_immutable, v2_immutable, v3_immutable, v4_immutable, v5_immutable, v6_immutable, v7_immutable, s_immutable, t_immutable, r_immutable]) => {
  const r = (0, _TSLBase.float)(r_immutable).toVar();
  const t = (0, _TSLBase.float)(t_immutable).toVar();
  const s = (0, _TSLBase.float)(s_immutable).toVar();
  const v7 = (0, _TSLBase.vec3)(v7_immutable).toVar();
  const v6 = (0, _TSLBase.vec3)(v6_immutable).toVar();
  const v5 = (0, _TSLBase.vec3)(v5_immutable).toVar();
  const v4 = (0, _TSLBase.vec3)(v4_immutable).toVar();
  const v3 = (0, _TSLBase.vec3)(v3_immutable).toVar();
  const v2 = (0, _TSLBase.vec3)(v2_immutable).toVar();
  const v1 = (0, _TSLBase.vec3)(v1_immutable).toVar();
  const v0 = (0, _TSLBase.vec3)(v0_immutable).toVar();
  const s1 = (0, _TSLBase.float)((0, _OperatorNode.sub)(1.0, s)).toVar();
  const t1 = (0, _TSLBase.float)((0, _OperatorNode.sub)(1.0, t)).toVar();
  const r1 = (0, _TSLBase.float)((0, _OperatorNode.sub)(1.0, r)).toVar();
  return r1.mul(t1.mul(v0.mul(s1).add(v1.mul(s))).add(t.mul(v2.mul(s1).add(v3.mul(s))))).add(r.mul(t1.mul(v4.mul(s1).add(v5.mul(s))).add(t.mul(v6.mul(s1).add(v7.mul(s))))));
}).setLayout({
  name: 'mx_trilerp_1',
  type: 'vec3',
  inputs: [{
    name: 'v0',
    type: 'vec3'
  }, {
    name: 'v1',
    type: 'vec3'
  }, {
    name: 'v2',
    type: 'vec3'
  }, {
    name: 'v3',
    type: 'vec3'
  }, {
    name: 'v4',
    type: 'vec3'
  }, {
    name: 'v5',
    type: 'vec3'
  }, {
    name: 'v6',
    type: 'vec3'
  }, {
    name: 'v7',
    type: 'vec3'
  }, {
    name: 's',
    type: 'float'
  }, {
    name: 't',
    type: 'float'
  }, {
    name: 'r',
    type: 'float'
  }]
});
const mx_trilerp = exports.mx_trilerp = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_trilerp_0, mx_trilerp_1]);
const mx_gradient_float_0 = exports.mx_gradient_float_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([hash_immutable, x_immutable, y_immutable]) => {
  const y = (0, _TSLBase.float)(y_immutable).toVar();
  const x = (0, _TSLBase.float)(x_immutable).toVar();
  const hash = (0, _TSLBase.uint)(hash_immutable).toVar();
  const h = (0, _TSLBase.uint)(hash.bitAnd((0, _TSLBase.uint)(7))).toVar();
  const u = (0, _TSLBase.float)(mx_select(h.lessThan((0, _TSLBase.uint)(4)), x, y)).toVar();
  const v = (0, _TSLBase.float)((0, _OperatorNode.mul)(2.0, mx_select(h.lessThan((0, _TSLBase.uint)(4)), y, x))).toVar();
  return mx_negate_if(u, (0, _TSLBase.bool)(h.bitAnd((0, _TSLBase.uint)(1)))).add(mx_negate_if(v, (0, _TSLBase.bool)(h.bitAnd((0, _TSLBase.uint)(2)))));
}).setLayout({
  name: 'mx_gradient_float_0',
  type: 'float',
  inputs: [{
    name: 'hash',
    type: 'uint'
  }, {
    name: 'x',
    type: 'float'
  }, {
    name: 'y',
    type: 'float'
  }]
});
const mx_gradient_float_1 = exports.mx_gradient_float_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([hash_immutable, x_immutable, y_immutable, z_immutable]) => {
  const z = (0, _TSLBase.float)(z_immutable).toVar();
  const y = (0, _TSLBase.float)(y_immutable).toVar();
  const x = (0, _TSLBase.float)(x_immutable).toVar();
  const hash = (0, _TSLBase.uint)(hash_immutable).toVar();
  const h = (0, _TSLBase.uint)(hash.bitAnd((0, _TSLBase.uint)(15))).toVar();
  const u = (0, _TSLBase.float)(mx_select(h.lessThan((0, _TSLBase.uint)(8)), x, y)).toVar();
  const v = (0, _TSLBase.float)(mx_select(h.lessThan((0, _TSLBase.uint)(4)), y, mx_select(h.equal((0, _TSLBase.uint)(12)).or(h.equal((0, _TSLBase.uint)(14))), x, z))).toVar();
  return mx_negate_if(u, (0, _TSLBase.bool)(h.bitAnd((0, _TSLBase.uint)(1)))).add(mx_negate_if(v, (0, _TSLBase.bool)(h.bitAnd((0, _TSLBase.uint)(2)))));
}).setLayout({
  name: 'mx_gradient_float_1',
  type: 'float',
  inputs: [{
    name: 'hash',
    type: 'uint'
  }, {
    name: 'x',
    type: 'float'
  }, {
    name: 'y',
    type: 'float'
  }, {
    name: 'z',
    type: 'float'
  }]
});
const mx_gradient_float = exports.mx_gradient_float = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_gradient_float_0, mx_gradient_float_1]);
const mx_gradient_vec3_0 = exports.mx_gradient_vec3_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([hash_immutable, x_immutable, y_immutable]) => {
  const y = (0, _TSLBase.float)(y_immutable).toVar();
  const x = (0, _TSLBase.float)(x_immutable).toVar();
  const hash = (0, _TSLBase.uvec3)(hash_immutable).toVar();
  return (0, _TSLBase.vec3)(mx_gradient_float(hash.x, x, y), mx_gradient_float(hash.y, x, y), mx_gradient_float(hash.z, x, y));
}).setLayout({
  name: 'mx_gradient_vec3_0',
  type: 'vec3',
  inputs: [{
    name: 'hash',
    type: 'uvec3'
  }, {
    name: 'x',
    type: 'float'
  }, {
    name: 'y',
    type: 'float'
  }]
});
const mx_gradient_vec3_1 = exports.mx_gradient_vec3_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([hash_immutable, x_immutable, y_immutable, z_immutable]) => {
  const z = (0, _TSLBase.float)(z_immutable).toVar();
  const y = (0, _TSLBase.float)(y_immutable).toVar();
  const x = (0, _TSLBase.float)(x_immutable).toVar();
  const hash = (0, _TSLBase.uvec3)(hash_immutable).toVar();
  return (0, _TSLBase.vec3)(mx_gradient_float(hash.x, x, y, z), mx_gradient_float(hash.y, x, y, z), mx_gradient_float(hash.z, x, y, z));
}).setLayout({
  name: 'mx_gradient_vec3_1',
  type: 'vec3',
  inputs: [{
    name: 'hash',
    type: 'uvec3'
  }, {
    name: 'x',
    type: 'float'
  }, {
    name: 'y',
    type: 'float'
  }, {
    name: 'z',
    type: 'float'
  }]
});
const mx_gradient_vec3 = exports.mx_gradient_vec3 = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_gradient_vec3_0, mx_gradient_vec3_1]);
const mx_gradient_scale2d_0 = exports.mx_gradient_scale2d_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([v_immutable]) => {
  const v = (0, _TSLBase.float)(v_immutable).toVar();
  return (0, _OperatorNode.mul)(0.6616, v);
}).setLayout({
  name: 'mx_gradient_scale2d_0',
  type: 'float',
  inputs: [{
    name: 'v',
    type: 'float'
  }]
});
const mx_gradient_scale3d_0 = exports.mx_gradient_scale3d_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([v_immutable]) => {
  const v = (0, _TSLBase.float)(v_immutable).toVar();
  return (0, _OperatorNode.mul)(0.9820, v);
}).setLayout({
  name: 'mx_gradient_scale3d_0',
  type: 'float',
  inputs: [{
    name: 'v',
    type: 'float'
  }]
});
const mx_gradient_scale2d_1 = exports.mx_gradient_scale2d_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([v_immutable]) => {
  const v = (0, _TSLBase.vec3)(v_immutable).toVar();
  return (0, _OperatorNode.mul)(0.6616, v);
}).setLayout({
  name: 'mx_gradient_scale2d_1',
  type: 'vec3',
  inputs: [{
    name: 'v',
    type: 'vec3'
  }]
});
const mx_gradient_scale2d = exports.mx_gradient_scale2d = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_gradient_scale2d_0, mx_gradient_scale2d_1]);
const mx_gradient_scale3d_1 = exports.mx_gradient_scale3d_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([v_immutable]) => {
  const v = (0, _TSLBase.vec3)(v_immutable).toVar();
  return (0, _OperatorNode.mul)(0.9820, v);
}).setLayout({
  name: 'mx_gradient_scale3d_1',
  type: 'vec3',
  inputs: [{
    name: 'v',
    type: 'vec3'
  }]
});
const mx_gradient_scale3d = exports.mx_gradient_scale3d = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_gradient_scale3d_0, mx_gradient_scale3d_1]);
const mx_rotl32 = exports.mx_rotl32 = /*@__PURE__*/(0, _TSLBase.Fn)(([x_immutable, k_immutable]) => {
  const k = (0, _TSLBase.int)(k_immutable).toVar();
  const x = (0, _TSLBase.uint)(x_immutable).toVar();
  return x.shiftLeft(k).bitOr(x.shiftRight((0, _TSLBase.int)(32).sub(k)));
}).setLayout({
  name: 'mx_rotl32',
  type: 'uint',
  inputs: [{
    name: 'x',
    type: 'uint'
  }, {
    name: 'k',
    type: 'int'
  }]
});
const mx_bjmix = exports.mx_bjmix = /*@__PURE__*/(0, _TSLBase.Fn)(([a, b, c]) => {
  a.subAssign(c);
  a.bitXorAssign(mx_rotl32(c, (0, _TSLBase.int)(4)));
  c.addAssign(b);
  b.subAssign(a);
  b.bitXorAssign(mx_rotl32(a, (0, _TSLBase.int)(6)));
  a.addAssign(c);
  c.subAssign(b);
  c.bitXorAssign(mx_rotl32(b, (0, _TSLBase.int)(8)));
  b.addAssign(a);
  a.subAssign(c);
  a.bitXorAssign(mx_rotl32(c, (0, _TSLBase.int)(16)));
  c.addAssign(b);
  b.subAssign(a);
  b.bitXorAssign(mx_rotl32(a, (0, _TSLBase.int)(19)));
  a.addAssign(c);
  c.subAssign(b);
  c.bitXorAssign(mx_rotl32(b, (0, _TSLBase.int)(4)));
  b.addAssign(a);
});
const mx_bjfinal = exports.mx_bjfinal = /*@__PURE__*/(0, _TSLBase.Fn)(([a_immutable, b_immutable, c_immutable]) => {
  const c = (0, _TSLBase.uint)(c_immutable).toVar();
  const b = (0, _TSLBase.uint)(b_immutable).toVar();
  const a = (0, _TSLBase.uint)(a_immutable).toVar();
  c.bitXorAssign(b);
  c.subAssign(mx_rotl32(b, (0, _TSLBase.int)(14)));
  a.bitXorAssign(c);
  a.subAssign(mx_rotl32(c, (0, _TSLBase.int)(11)));
  b.bitXorAssign(a);
  b.subAssign(mx_rotl32(a, (0, _TSLBase.int)(25)));
  c.bitXorAssign(b);
  c.subAssign(mx_rotl32(b, (0, _TSLBase.int)(16)));
  a.bitXorAssign(c);
  a.subAssign(mx_rotl32(c, (0, _TSLBase.int)(4)));
  b.bitXorAssign(a);
  b.subAssign(mx_rotl32(a, (0, _TSLBase.int)(14)));
  c.bitXorAssign(b);
  c.subAssign(mx_rotl32(b, (0, _TSLBase.int)(24)));
  return c;
}).setLayout({
  name: 'mx_bjfinal',
  type: 'uint',
  inputs: [{
    name: 'a',
    type: 'uint'
  }, {
    name: 'b',
    type: 'uint'
  }, {
    name: 'c',
    type: 'uint'
  }]
});
const mx_bits_to_01 = exports.mx_bits_to_01 = /*@__PURE__*/(0, _TSLBase.Fn)(([bits_immutable]) => {
  const bits = (0, _TSLBase.uint)(bits_immutable).toVar();
  return (0, _TSLBase.float)(bits).div((0, _TSLBase.float)((0, _TSLBase.uint)((0, _TSLBase.int)(0xffffffff))));
}).setLayout({
  name: 'mx_bits_to_01',
  type: 'float',
  inputs: [{
    name: 'bits',
    type: 'uint'
  }]
});
const mx_fade = exports.mx_fade = /*@__PURE__*/(0, _TSLBase.Fn)(([t_immutable]) => {
  const t = (0, _TSLBase.float)(t_immutable).toVar();
  return t.mul(t).mul(t).mul(t.mul(t.mul(6.0).sub(15.0)).add(10.0));
}).setLayout({
  name: 'mx_fade',
  type: 'float',
  inputs: [{
    name: 't',
    type: 'float'
  }]
});
const mx_hash_int_0 = exports.mx_hash_int_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([x_immutable]) => {
  const x = (0, _TSLBase.int)(x_immutable).toVar();
  const len = (0, _TSLBase.uint)((0, _TSLBase.uint)(1)).toVar();
  const seed = (0, _TSLBase.uint)((0, _TSLBase.uint)((0, _TSLBase.int)(0xdeadbeef)).add(len.shiftLeft((0, _TSLBase.uint)(2))).add((0, _TSLBase.uint)(13))).toVar();
  return mx_bjfinal(seed.add((0, _TSLBase.uint)(x)), seed, seed);
}).setLayout({
  name: 'mx_hash_int_0',
  type: 'uint',
  inputs: [{
    name: 'x',
    type: 'int'
  }]
});
const mx_hash_int_1 = exports.mx_hash_int_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([x_immutable, y_immutable]) => {
  const y = (0, _TSLBase.int)(y_immutable).toVar();
  const x = (0, _TSLBase.int)(x_immutable).toVar();
  const len = (0, _TSLBase.uint)((0, _TSLBase.uint)(2)).toVar();
  const a = (0, _TSLBase.uint)().toVar(),
    b = (0, _TSLBase.uint)().toVar(),
    c = (0, _TSLBase.uint)().toVar();
  a.assign(b.assign(c.assign((0, _TSLBase.uint)((0, _TSLBase.int)(0xdeadbeef)).add(len.shiftLeft((0, _TSLBase.uint)(2))).add((0, _TSLBase.uint)(13)))));
  a.addAssign((0, _TSLBase.uint)(x));
  b.addAssign((0, _TSLBase.uint)(y));
  return mx_bjfinal(a, b, c);
}).setLayout({
  name: 'mx_hash_int_1',
  type: 'uint',
  inputs: [{
    name: 'x',
    type: 'int'
  }, {
    name: 'y',
    type: 'int'
  }]
});
const mx_hash_int_2 = exports.mx_hash_int_2 = /*@__PURE__*/(0, _TSLBase.Fn)(([x_immutable, y_immutable, z_immutable]) => {
  const z = (0, _TSLBase.int)(z_immutable).toVar();
  const y = (0, _TSLBase.int)(y_immutable).toVar();
  const x = (0, _TSLBase.int)(x_immutable).toVar();
  const len = (0, _TSLBase.uint)((0, _TSLBase.uint)(3)).toVar();
  const a = (0, _TSLBase.uint)().toVar(),
    b = (0, _TSLBase.uint)().toVar(),
    c = (0, _TSLBase.uint)().toVar();
  a.assign(b.assign(c.assign((0, _TSLBase.uint)((0, _TSLBase.int)(0xdeadbeef)).add(len.shiftLeft((0, _TSLBase.uint)(2))).add((0, _TSLBase.uint)(13)))));
  a.addAssign((0, _TSLBase.uint)(x));
  b.addAssign((0, _TSLBase.uint)(y));
  c.addAssign((0, _TSLBase.uint)(z));
  return mx_bjfinal(a, b, c);
}).setLayout({
  name: 'mx_hash_int_2',
  type: 'uint',
  inputs: [{
    name: 'x',
    type: 'int'
  }, {
    name: 'y',
    type: 'int'
  }, {
    name: 'z',
    type: 'int'
  }]
});
const mx_hash_int_3 = exports.mx_hash_int_3 = /*@__PURE__*/(0, _TSLBase.Fn)(([x_immutable, y_immutable, z_immutable, xx_immutable]) => {
  const xx = (0, _TSLBase.int)(xx_immutable).toVar();
  const z = (0, _TSLBase.int)(z_immutable).toVar();
  const y = (0, _TSLBase.int)(y_immutable).toVar();
  const x = (0, _TSLBase.int)(x_immutable).toVar();
  const len = (0, _TSLBase.uint)((0, _TSLBase.uint)(4)).toVar();
  const a = (0, _TSLBase.uint)().toVar(),
    b = (0, _TSLBase.uint)().toVar(),
    c = (0, _TSLBase.uint)().toVar();
  a.assign(b.assign(c.assign((0, _TSLBase.uint)((0, _TSLBase.int)(0xdeadbeef)).add(len.shiftLeft((0, _TSLBase.uint)(2))).add((0, _TSLBase.uint)(13)))));
  a.addAssign((0, _TSLBase.uint)(x));
  b.addAssign((0, _TSLBase.uint)(y));
  c.addAssign((0, _TSLBase.uint)(z));
  mx_bjmix(a, b, c);
  a.addAssign((0, _TSLBase.uint)(xx));
  return mx_bjfinal(a, b, c);
}).setLayout({
  name: 'mx_hash_int_3',
  type: 'uint',
  inputs: [{
    name: 'x',
    type: 'int'
  }, {
    name: 'y',
    type: 'int'
  }, {
    name: 'z',
    type: 'int'
  }, {
    name: 'xx',
    type: 'int'
  }]
});
const mx_hash_int_4 = exports.mx_hash_int_4 = /*@__PURE__*/(0, _TSLBase.Fn)(([x_immutable, y_immutable, z_immutable, xx_immutable, yy_immutable]) => {
  const yy = (0, _TSLBase.int)(yy_immutable).toVar();
  const xx = (0, _TSLBase.int)(xx_immutable).toVar();
  const z = (0, _TSLBase.int)(z_immutable).toVar();
  const y = (0, _TSLBase.int)(y_immutable).toVar();
  const x = (0, _TSLBase.int)(x_immutable).toVar();
  const len = (0, _TSLBase.uint)((0, _TSLBase.uint)(5)).toVar();
  const a = (0, _TSLBase.uint)().toVar(),
    b = (0, _TSLBase.uint)().toVar(),
    c = (0, _TSLBase.uint)().toVar();
  a.assign(b.assign(c.assign((0, _TSLBase.uint)((0, _TSLBase.int)(0xdeadbeef)).add(len.shiftLeft((0, _TSLBase.uint)(2))).add((0, _TSLBase.uint)(13)))));
  a.addAssign((0, _TSLBase.uint)(x));
  b.addAssign((0, _TSLBase.uint)(y));
  c.addAssign((0, _TSLBase.uint)(z));
  mx_bjmix(a, b, c);
  a.addAssign((0, _TSLBase.uint)(xx));
  b.addAssign((0, _TSLBase.uint)(yy));
  return mx_bjfinal(a, b, c);
}).setLayout({
  name: 'mx_hash_int_4',
  type: 'uint',
  inputs: [{
    name: 'x',
    type: 'int'
  }, {
    name: 'y',
    type: 'int'
  }, {
    name: 'z',
    type: 'int'
  }, {
    name: 'xx',
    type: 'int'
  }, {
    name: 'yy',
    type: 'int'
  }]
});
const mx_hash_int = exports.mx_hash_int = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_hash_int_0, mx_hash_int_1, mx_hash_int_2, mx_hash_int_3, mx_hash_int_4]);
const mx_hash_vec3_0 = exports.mx_hash_vec3_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([x_immutable, y_immutable]) => {
  const y = (0, _TSLBase.int)(y_immutable).toVar();
  const x = (0, _TSLBase.int)(x_immutable).toVar();
  const h = (0, _TSLBase.uint)(mx_hash_int(x, y)).toVar();
  const result = (0, _TSLBase.uvec3)().toVar();
  result.x.assign(h.bitAnd((0, _TSLBase.int)(0xFF)));
  result.y.assign(h.shiftRight((0, _TSLBase.int)(8)).bitAnd((0, _TSLBase.int)(0xFF)));
  result.z.assign(h.shiftRight((0, _TSLBase.int)(16)).bitAnd((0, _TSLBase.int)(0xFF)));
  return result;
}).setLayout({
  name: 'mx_hash_vec3_0',
  type: 'uvec3',
  inputs: [{
    name: 'x',
    type: 'int'
  }, {
    name: 'y',
    type: 'int'
  }]
});
const mx_hash_vec3_1 = exports.mx_hash_vec3_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([x_immutable, y_immutable, z_immutable]) => {
  const z = (0, _TSLBase.int)(z_immutable).toVar();
  const y = (0, _TSLBase.int)(y_immutable).toVar();
  const x = (0, _TSLBase.int)(x_immutable).toVar();
  const h = (0, _TSLBase.uint)(mx_hash_int(x, y, z)).toVar();
  const result = (0, _TSLBase.uvec3)().toVar();
  result.x.assign(h.bitAnd((0, _TSLBase.int)(0xFF)));
  result.y.assign(h.shiftRight((0, _TSLBase.int)(8)).bitAnd((0, _TSLBase.int)(0xFF)));
  result.z.assign(h.shiftRight((0, _TSLBase.int)(16)).bitAnd((0, _TSLBase.int)(0xFF)));
  return result;
}).setLayout({
  name: 'mx_hash_vec3_1',
  type: 'uvec3',
  inputs: [{
    name: 'x',
    type: 'int'
  }, {
    name: 'y',
    type: 'int'
  }, {
    name: 'z',
    type: 'int'
  }]
});
const mx_hash_vec3 = exports.mx_hash_vec3 = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_hash_vec3_0, mx_hash_vec3_1]);
const mx_perlin_noise_float_0 = exports.mx_perlin_noise_float_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.vec2)(p_immutable).toVar();
  const X = (0, _TSLBase.int)().toVar(),
    Y = (0, _TSLBase.int)().toVar();
  const fx = (0, _TSLBase.float)(mx_floorfrac(p.x, X)).toVar();
  const fy = (0, _TSLBase.float)(mx_floorfrac(p.y, Y)).toVar();
  const u = (0, _TSLBase.float)(mx_fade(fx)).toVar();
  const v = (0, _TSLBase.float)(mx_fade(fy)).toVar();
  const result = (0, _TSLBase.float)(mx_bilerp(mx_gradient_float(mx_hash_int(X, Y), fx, fy), mx_gradient_float(mx_hash_int(X.add((0, _TSLBase.int)(1)), Y), fx.sub(1.0), fy), mx_gradient_float(mx_hash_int(X, Y.add((0, _TSLBase.int)(1))), fx, fy.sub(1.0)), mx_gradient_float(mx_hash_int(X.add((0, _TSLBase.int)(1)), Y.add((0, _TSLBase.int)(1))), fx.sub(1.0), fy.sub(1.0)), u, v)).toVar();
  return mx_gradient_scale2d(result);
}).setLayout({
  name: 'mx_perlin_noise_float_0',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'vec2'
  }]
});
const mx_perlin_noise_float_1 = exports.mx_perlin_noise_float_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  const X = (0, _TSLBase.int)().toVar(),
    Y = (0, _TSLBase.int)().toVar(),
    Z = (0, _TSLBase.int)().toVar();
  const fx = (0, _TSLBase.float)(mx_floorfrac(p.x, X)).toVar();
  const fy = (0, _TSLBase.float)(mx_floorfrac(p.y, Y)).toVar();
  const fz = (0, _TSLBase.float)(mx_floorfrac(p.z, Z)).toVar();
  const u = (0, _TSLBase.float)(mx_fade(fx)).toVar();
  const v = (0, _TSLBase.float)(mx_fade(fy)).toVar();
  const w = (0, _TSLBase.float)(mx_fade(fz)).toVar();
  const result = (0, _TSLBase.float)(mx_trilerp(mx_gradient_float(mx_hash_int(X, Y, Z), fx, fy, fz), mx_gradient_float(mx_hash_int(X.add((0, _TSLBase.int)(1)), Y, Z), fx.sub(1.0), fy, fz), mx_gradient_float(mx_hash_int(X, Y.add((0, _TSLBase.int)(1)), Z), fx, fy.sub(1.0), fz), mx_gradient_float(mx_hash_int(X.add((0, _TSLBase.int)(1)), Y.add((0, _TSLBase.int)(1)), Z), fx.sub(1.0), fy.sub(1.0), fz), mx_gradient_float(mx_hash_int(X, Y, Z.add((0, _TSLBase.int)(1))), fx, fy, fz.sub(1.0)), mx_gradient_float(mx_hash_int(X.add((0, _TSLBase.int)(1)), Y, Z.add((0, _TSLBase.int)(1))), fx.sub(1.0), fy, fz.sub(1.0)), mx_gradient_float(mx_hash_int(X, Y.add((0, _TSLBase.int)(1)), Z.add((0, _TSLBase.int)(1))), fx, fy.sub(1.0), fz.sub(1.0)), mx_gradient_float(mx_hash_int(X.add((0, _TSLBase.int)(1)), Y.add((0, _TSLBase.int)(1)), Z.add((0, _TSLBase.int)(1))), fx.sub(1.0), fy.sub(1.0), fz.sub(1.0)), u, v, w)).toVar();
  return mx_gradient_scale3d(result);
}).setLayout({
  name: 'mx_perlin_noise_float_1',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'vec3'
  }]
});
const mx_perlin_noise_float = exports.mx_perlin_noise_float = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_perlin_noise_float_0, mx_perlin_noise_float_1]);
const mx_perlin_noise_vec3_0 = exports.mx_perlin_noise_vec3_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.vec2)(p_immutable).toVar();
  const X = (0, _TSLBase.int)().toVar(),
    Y = (0, _TSLBase.int)().toVar();
  const fx = (0, _TSLBase.float)(mx_floorfrac(p.x, X)).toVar();
  const fy = (0, _TSLBase.float)(mx_floorfrac(p.y, Y)).toVar();
  const u = (0, _TSLBase.float)(mx_fade(fx)).toVar();
  const v = (0, _TSLBase.float)(mx_fade(fy)).toVar();
  const result = (0, _TSLBase.vec3)(mx_bilerp(mx_gradient_vec3(mx_hash_vec3(X, Y), fx, fy), mx_gradient_vec3(mx_hash_vec3(X.add((0, _TSLBase.int)(1)), Y), fx.sub(1.0), fy), mx_gradient_vec3(mx_hash_vec3(X, Y.add((0, _TSLBase.int)(1))), fx, fy.sub(1.0)), mx_gradient_vec3(mx_hash_vec3(X.add((0, _TSLBase.int)(1)), Y.add((0, _TSLBase.int)(1))), fx.sub(1.0), fy.sub(1.0)), u, v)).toVar();
  return mx_gradient_scale2d(result);
}).setLayout({
  name: 'mx_perlin_noise_vec3_0',
  type: 'vec3',
  inputs: [{
    name: 'p',
    type: 'vec2'
  }]
});
const mx_perlin_noise_vec3_1 = exports.mx_perlin_noise_vec3_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  const X = (0, _TSLBase.int)().toVar(),
    Y = (0, _TSLBase.int)().toVar(),
    Z = (0, _TSLBase.int)().toVar();
  const fx = (0, _TSLBase.float)(mx_floorfrac(p.x, X)).toVar();
  const fy = (0, _TSLBase.float)(mx_floorfrac(p.y, Y)).toVar();
  const fz = (0, _TSLBase.float)(mx_floorfrac(p.z, Z)).toVar();
  const u = (0, _TSLBase.float)(mx_fade(fx)).toVar();
  const v = (0, _TSLBase.float)(mx_fade(fy)).toVar();
  const w = (0, _TSLBase.float)(mx_fade(fz)).toVar();
  const result = (0, _TSLBase.vec3)(mx_trilerp(mx_gradient_vec3(mx_hash_vec3(X, Y, Z), fx, fy, fz), mx_gradient_vec3(mx_hash_vec3(X.add((0, _TSLBase.int)(1)), Y, Z), fx.sub(1.0), fy, fz), mx_gradient_vec3(mx_hash_vec3(X, Y.add((0, _TSLBase.int)(1)), Z), fx, fy.sub(1.0), fz), mx_gradient_vec3(mx_hash_vec3(X.add((0, _TSLBase.int)(1)), Y.add((0, _TSLBase.int)(1)), Z), fx.sub(1.0), fy.sub(1.0), fz), mx_gradient_vec3(mx_hash_vec3(X, Y, Z.add((0, _TSLBase.int)(1))), fx, fy, fz.sub(1.0)), mx_gradient_vec3(mx_hash_vec3(X.add((0, _TSLBase.int)(1)), Y, Z.add((0, _TSLBase.int)(1))), fx.sub(1.0), fy, fz.sub(1.0)), mx_gradient_vec3(mx_hash_vec3(X, Y.add((0, _TSLBase.int)(1)), Z.add((0, _TSLBase.int)(1))), fx, fy.sub(1.0), fz.sub(1.0)), mx_gradient_vec3(mx_hash_vec3(X.add((0, _TSLBase.int)(1)), Y.add((0, _TSLBase.int)(1)), Z.add((0, _TSLBase.int)(1))), fx.sub(1.0), fy.sub(1.0), fz.sub(1.0)), u, v, w)).toVar();
  return mx_gradient_scale3d(result);
}).setLayout({
  name: 'mx_perlin_noise_vec3_1',
  type: 'vec3',
  inputs: [{
    name: 'p',
    type: 'vec3'
  }]
});
const mx_perlin_noise_vec3 = exports.mx_perlin_noise_vec3 = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_perlin_noise_vec3_0, mx_perlin_noise_vec3_1]);
const mx_cell_noise_float_0 = exports.mx_cell_noise_float_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.float)(p_immutable).toVar();
  const ix = (0, _TSLBase.int)(mx_floor(p)).toVar();
  return mx_bits_to_01(mx_hash_int(ix));
}).setLayout({
  name: 'mx_cell_noise_float_0',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'float'
  }]
});
const mx_cell_noise_float_1 = exports.mx_cell_noise_float_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.vec2)(p_immutable).toVar();
  const ix = (0, _TSLBase.int)(mx_floor(p.x)).toVar();
  const iy = (0, _TSLBase.int)(mx_floor(p.y)).toVar();
  return mx_bits_to_01(mx_hash_int(ix, iy));
}).setLayout({
  name: 'mx_cell_noise_float_1',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'vec2'
  }]
});
const mx_cell_noise_float_2 = exports.mx_cell_noise_float_2 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  const ix = (0, _TSLBase.int)(mx_floor(p.x)).toVar();
  const iy = (0, _TSLBase.int)(mx_floor(p.y)).toVar();
  const iz = (0, _TSLBase.int)(mx_floor(p.z)).toVar();
  return mx_bits_to_01(mx_hash_int(ix, iy, iz));
}).setLayout({
  name: 'mx_cell_noise_float_2',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'vec3'
  }]
});
const mx_cell_noise_float_3 = exports.mx_cell_noise_float_3 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.vec4)(p_immutable).toVar();
  const ix = (0, _TSLBase.int)(mx_floor(p.x)).toVar();
  const iy = (0, _TSLBase.int)(mx_floor(p.y)).toVar();
  const iz = (0, _TSLBase.int)(mx_floor(p.z)).toVar();
  const iw = (0, _TSLBase.int)(mx_floor(p.w)).toVar();
  return mx_bits_to_01(mx_hash_int(ix, iy, iz, iw));
}).setLayout({
  name: 'mx_cell_noise_float_3',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'vec4'
  }]
});
const mx_cell_noise_float = exports.mx_cell_noise_float = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_cell_noise_float_0, mx_cell_noise_float_1, mx_cell_noise_float_2, mx_cell_noise_float_3]);
const mx_cell_noise_vec3_0 = exports.mx_cell_noise_vec3_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.float)(p_immutable).toVar();
  const ix = (0, _TSLBase.int)(mx_floor(p)).toVar();
  return (0, _TSLBase.vec3)(mx_bits_to_01(mx_hash_int(ix, (0, _TSLBase.int)(0))), mx_bits_to_01(mx_hash_int(ix, (0, _TSLBase.int)(1))), mx_bits_to_01(mx_hash_int(ix, (0, _TSLBase.int)(2))));
}).setLayout({
  name: 'mx_cell_noise_vec3_0',
  type: 'vec3',
  inputs: [{
    name: 'p',
    type: 'float'
  }]
});
const mx_cell_noise_vec3_1 = exports.mx_cell_noise_vec3_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.vec2)(p_immutable).toVar();
  const ix = (0, _TSLBase.int)(mx_floor(p.x)).toVar();
  const iy = (0, _TSLBase.int)(mx_floor(p.y)).toVar();
  return (0, _TSLBase.vec3)(mx_bits_to_01(mx_hash_int(ix, iy, (0, _TSLBase.int)(0))), mx_bits_to_01(mx_hash_int(ix, iy, (0, _TSLBase.int)(1))), mx_bits_to_01(mx_hash_int(ix, iy, (0, _TSLBase.int)(2))));
}).setLayout({
  name: 'mx_cell_noise_vec3_1',
  type: 'vec3',
  inputs: [{
    name: 'p',
    type: 'vec2'
  }]
});
const mx_cell_noise_vec3_2 = exports.mx_cell_noise_vec3_2 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  const ix = (0, _TSLBase.int)(mx_floor(p.x)).toVar();
  const iy = (0, _TSLBase.int)(mx_floor(p.y)).toVar();
  const iz = (0, _TSLBase.int)(mx_floor(p.z)).toVar();
  return (0, _TSLBase.vec3)(mx_bits_to_01(mx_hash_int(ix, iy, iz, (0, _TSLBase.int)(0))), mx_bits_to_01(mx_hash_int(ix, iy, iz, (0, _TSLBase.int)(1))), mx_bits_to_01(mx_hash_int(ix, iy, iz, (0, _TSLBase.int)(2))));
}).setLayout({
  name: 'mx_cell_noise_vec3_2',
  type: 'vec3',
  inputs: [{
    name: 'p',
    type: 'vec3'
  }]
});
const mx_cell_noise_vec3_3 = exports.mx_cell_noise_vec3_3 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable]) => {
  const p = (0, _TSLBase.vec4)(p_immutable).toVar();
  const ix = (0, _TSLBase.int)(mx_floor(p.x)).toVar();
  const iy = (0, _TSLBase.int)(mx_floor(p.y)).toVar();
  const iz = (0, _TSLBase.int)(mx_floor(p.z)).toVar();
  const iw = (0, _TSLBase.int)(mx_floor(p.w)).toVar();
  return (0, _TSLBase.vec3)(mx_bits_to_01(mx_hash_int(ix, iy, iz, iw, (0, _TSLBase.int)(0))), mx_bits_to_01(mx_hash_int(ix, iy, iz, iw, (0, _TSLBase.int)(1))), mx_bits_to_01(mx_hash_int(ix, iy, iz, iw, (0, _TSLBase.int)(2))));
}).setLayout({
  name: 'mx_cell_noise_vec3_3',
  type: 'vec3',
  inputs: [{
    name: 'p',
    type: 'vec4'
  }]
});
const mx_cell_noise_vec3 = exports.mx_cell_noise_vec3 = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_cell_noise_vec3_0, mx_cell_noise_vec3_1, mx_cell_noise_vec3_2, mx_cell_noise_vec3_3]);
const mx_fractal_noise_float = exports.mx_fractal_noise_float = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, octaves_immutable, lacunarity_immutable, diminish_immutable]) => {
  const diminish = (0, _TSLBase.float)(diminish_immutable).toVar();
  const lacunarity = (0, _TSLBase.float)(lacunarity_immutable).toVar();
  const octaves = (0, _TSLBase.int)(octaves_immutable).toVar();
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  const result = (0, _TSLBase.float)(0.0).toVar();
  const amplitude = (0, _TSLBase.float)(1.0).toVar();
  (0, _LoopNode.Loop)(octaves, () => {
    result.addAssign(amplitude.mul(mx_perlin_noise_float(p)));
    amplitude.mulAssign(diminish);
    p.mulAssign(lacunarity);
  });
  return result;
}).setLayout({
  name: 'mx_fractal_noise_float',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'vec3'
  }, {
    name: 'octaves',
    type: 'int'
  }, {
    name: 'lacunarity',
    type: 'float'
  }, {
    name: 'diminish',
    type: 'float'
  }]
});
const mx_fractal_noise_vec3 = exports.mx_fractal_noise_vec3 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, octaves_immutable, lacunarity_immutable, diminish_immutable]) => {
  const diminish = (0, _TSLBase.float)(diminish_immutable).toVar();
  const lacunarity = (0, _TSLBase.float)(lacunarity_immutable).toVar();
  const octaves = (0, _TSLBase.int)(octaves_immutable).toVar();
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  const result = (0, _TSLBase.vec3)(0.0).toVar();
  const amplitude = (0, _TSLBase.float)(1.0).toVar();
  (0, _LoopNode.Loop)(octaves, () => {
    result.addAssign(amplitude.mul(mx_perlin_noise_vec3(p)));
    amplitude.mulAssign(diminish);
    p.mulAssign(lacunarity);
  });
  return result;
}).setLayout({
  name: 'mx_fractal_noise_vec3',
  type: 'vec3',
  inputs: [{
    name: 'p',
    type: 'vec3'
  }, {
    name: 'octaves',
    type: 'int'
  }, {
    name: 'lacunarity',
    type: 'float'
  }, {
    name: 'diminish',
    type: 'float'
  }]
});
const mx_fractal_noise_vec2 = exports.mx_fractal_noise_vec2 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, octaves_immutable, lacunarity_immutable, diminish_immutable]) => {
  const diminish = (0, _TSLBase.float)(diminish_immutable).toVar();
  const lacunarity = (0, _TSLBase.float)(lacunarity_immutable).toVar();
  const octaves = (0, _TSLBase.int)(octaves_immutable).toVar();
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  return (0, _TSLBase.vec2)(mx_fractal_noise_float(p, octaves, lacunarity, diminish), mx_fractal_noise_float(p.add((0, _TSLBase.vec3)((0, _TSLBase.int)(19), (0, _TSLBase.int)(193), (0, _TSLBase.int)(17))), octaves, lacunarity, diminish));
}).setLayout({
  name: 'mx_fractal_noise_vec2',
  type: 'vec2',
  inputs: [{
    name: 'p',
    type: 'vec3'
  }, {
    name: 'octaves',
    type: 'int'
  }, {
    name: 'lacunarity',
    type: 'float'
  }, {
    name: 'diminish',
    type: 'float'
  }]
});
const mx_fractal_noise_vec4 = exports.mx_fractal_noise_vec4 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, octaves_immutable, lacunarity_immutable, diminish_immutable]) => {
  const diminish = (0, _TSLBase.float)(diminish_immutable).toVar();
  const lacunarity = (0, _TSLBase.float)(lacunarity_immutable).toVar();
  const octaves = (0, _TSLBase.int)(octaves_immutable).toVar();
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  const c = (0, _TSLBase.vec3)(mx_fractal_noise_vec3(p, octaves, lacunarity, diminish)).toVar();
  const f = (0, _TSLBase.float)(mx_fractal_noise_float(p.add((0, _TSLBase.vec3)((0, _TSLBase.int)(19), (0, _TSLBase.int)(193), (0, _TSLBase.int)(17))), octaves, lacunarity, diminish)).toVar();
  return (0, _TSLBase.vec4)(c, f);
}).setLayout({
  name: 'mx_fractal_noise_vec4',
  type: 'vec4',
  inputs: [{
    name: 'p',
    type: 'vec3'
  }, {
    name: 'octaves',
    type: 'int'
  }, {
    name: 'lacunarity',
    type: 'float'
  }, {
    name: 'diminish',
    type: 'float'
  }]
});
const mx_worley_distance_0 = exports.mx_worley_distance_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, x_immutable, y_immutable, xoff_immutable, yoff_immutable, jitter_immutable, metric_immutable]) => {
  const metric = (0, _TSLBase.int)(metric_immutable).toVar();
  const jitter = (0, _TSLBase.float)(jitter_immutable).toVar();
  const yoff = (0, _TSLBase.int)(yoff_immutable).toVar();
  const xoff = (0, _TSLBase.int)(xoff_immutable).toVar();
  const y = (0, _TSLBase.int)(y_immutable).toVar();
  const x = (0, _TSLBase.int)(x_immutable).toVar();
  const p = (0, _TSLBase.vec2)(p_immutable).toVar();
  const tmp = (0, _TSLBase.vec3)(mx_cell_noise_vec3((0, _TSLBase.vec2)(x.add(xoff), y.add(yoff)))).toVar();
  const off = (0, _TSLBase.vec2)(tmp.x, tmp.y).toVar();
  off.subAssign(0.5);
  off.mulAssign(jitter);
  off.addAssign(0.5);
  const cellpos = (0, _TSLBase.vec2)((0, _TSLBase.vec2)((0, _TSLBase.float)(x), (0, _TSLBase.float)(y)).add(off)).toVar();
  const diff = (0, _TSLBase.vec2)(cellpos.sub(p)).toVar();
  (0, _TSLBase.If)(metric.equal((0, _TSLBase.int)(2)), () => {
    return (0, _MathNode.abs)(diff.x).add((0, _MathNode.abs)(diff.y));
  });
  (0, _TSLBase.If)(metric.equal((0, _TSLBase.int)(3)), () => {
    return (0, _MathNode.max)((0, _MathNode.abs)(diff.x), (0, _MathNode.abs)(diff.y));
  });
  return (0, _MathNode.dot)(diff, diff);
}).setLayout({
  name: 'mx_worley_distance_0',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'vec2'
  }, {
    name: 'x',
    type: 'int'
  }, {
    name: 'y',
    type: 'int'
  }, {
    name: 'xoff',
    type: 'int'
  }, {
    name: 'yoff',
    type: 'int'
  }, {
    name: 'jitter',
    type: 'float'
  }, {
    name: 'metric',
    type: 'int'
  }]
});
const mx_worley_distance_1 = exports.mx_worley_distance_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, x_immutable, y_immutable, z_immutable, xoff_immutable, yoff_immutable, zoff_immutable, jitter_immutable, metric_immutable]) => {
  const metric = (0, _TSLBase.int)(metric_immutable).toVar();
  const jitter = (0, _TSLBase.float)(jitter_immutable).toVar();
  const zoff = (0, _TSLBase.int)(zoff_immutable).toVar();
  const yoff = (0, _TSLBase.int)(yoff_immutable).toVar();
  const xoff = (0, _TSLBase.int)(xoff_immutable).toVar();
  const z = (0, _TSLBase.int)(z_immutable).toVar();
  const y = (0, _TSLBase.int)(y_immutable).toVar();
  const x = (0, _TSLBase.int)(x_immutable).toVar();
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  const off = (0, _TSLBase.vec3)(mx_cell_noise_vec3((0, _TSLBase.vec3)(x.add(xoff), y.add(yoff), z.add(zoff)))).toVar();
  off.subAssign(0.5);
  off.mulAssign(jitter);
  off.addAssign(0.5);
  const cellpos = (0, _TSLBase.vec3)((0, _TSLBase.vec3)((0, _TSLBase.float)(x), (0, _TSLBase.float)(y), (0, _TSLBase.float)(z)).add(off)).toVar();
  const diff = (0, _TSLBase.vec3)(cellpos.sub(p)).toVar();
  (0, _TSLBase.If)(metric.equal((0, _TSLBase.int)(2)), () => {
    return (0, _MathNode.abs)(diff.x).add((0, _MathNode.abs)(diff.y)).add((0, _MathNode.abs)(diff.z));
  });
  (0, _TSLBase.If)(metric.equal((0, _TSLBase.int)(3)), () => {
    return (0, _MathNode.max)((0, _MathNode.max)((0, _MathNode.abs)(diff.x), (0, _MathNode.abs)(diff.y)), (0, _MathNode.abs)(diff.z));
  });
  return (0, _MathNode.dot)(diff, diff);
}).setLayout({
  name: 'mx_worley_distance_1',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'vec3'
  }, {
    name: 'x',
    type: 'int'
  }, {
    name: 'y',
    type: 'int'
  }, {
    name: 'z',
    type: 'int'
  }, {
    name: 'xoff',
    type: 'int'
  }, {
    name: 'yoff',
    type: 'int'
  }, {
    name: 'zoff',
    type: 'int'
  }, {
    name: 'jitter',
    type: 'float'
  }, {
    name: 'metric',
    type: 'int'
  }]
});
const mx_worley_distance = exports.mx_worley_distance = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_worley_distance_0, mx_worley_distance_1]);
const mx_worley_noise_float_0 = exports.mx_worley_noise_float_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, jitter_immutable, metric_immutable]) => {
  const metric = (0, _TSLBase.int)(metric_immutable).toVar();
  const jitter = (0, _TSLBase.float)(jitter_immutable).toVar();
  const p = (0, _TSLBase.vec2)(p_immutable).toVar();
  const X = (0, _TSLBase.int)().toVar(),
    Y = (0, _TSLBase.int)().toVar();
  const localpos = (0, _TSLBase.vec2)(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y)).toVar();
  const sqdist = (0, _TSLBase.float)(1e6).toVar();
  (0, _LoopNode.Loop)({
    start: -1,
    end: (0, _TSLBase.int)(1),
    name: 'x',
    condition: '<='
  }, ({
    x
  }) => {
    (0, _LoopNode.Loop)({
      start: -1,
      end: (0, _TSLBase.int)(1),
      name: 'y',
      condition: '<='
    }, ({
      y
    }) => {
      const dist = (0, _TSLBase.float)(mx_worley_distance(localpos, x, y, X, Y, jitter, metric)).toVar();
      sqdist.assign((0, _MathNode.min)(sqdist, dist));
    });
  });
  (0, _TSLBase.If)(metric.equal((0, _TSLBase.int)(0)), () => {
    sqdist.assign((0, _MathNode.sqrt)(sqdist));
  });
  return sqdist;
}).setLayout({
  name: 'mx_worley_noise_float_0',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'vec2'
  }, {
    name: 'jitter',
    type: 'float'
  }, {
    name: 'metric',
    type: 'int'
  }]
});
const mx_worley_noise_vec2_0 = exports.mx_worley_noise_vec2_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, jitter_immutable, metric_immutable]) => {
  const metric = (0, _TSLBase.int)(metric_immutable).toVar();
  const jitter = (0, _TSLBase.float)(jitter_immutable).toVar();
  const p = (0, _TSLBase.vec2)(p_immutable).toVar();
  const X = (0, _TSLBase.int)().toVar(),
    Y = (0, _TSLBase.int)().toVar();
  const localpos = (0, _TSLBase.vec2)(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y)).toVar();
  const sqdist = (0, _TSLBase.vec2)(1e6, 1e6).toVar();
  (0, _LoopNode.Loop)({
    start: -1,
    end: (0, _TSLBase.int)(1),
    name: 'x',
    condition: '<='
  }, ({
    x
  }) => {
    (0, _LoopNode.Loop)({
      start: -1,
      end: (0, _TSLBase.int)(1),
      name: 'y',
      condition: '<='
    }, ({
      y
    }) => {
      const dist = (0, _TSLBase.float)(mx_worley_distance(localpos, x, y, X, Y, jitter, metric)).toVar();
      (0, _TSLBase.If)(dist.lessThan(sqdist.x), () => {
        sqdist.y.assign(sqdist.x);
        sqdist.x.assign(dist);
      }).ElseIf(dist.lessThan(sqdist.y), () => {
        sqdist.y.assign(dist);
      });
    });
  });
  (0, _TSLBase.If)(metric.equal((0, _TSLBase.int)(0)), () => {
    sqdist.assign((0, _MathNode.sqrt)(sqdist));
  });
  return sqdist;
}).setLayout({
  name: 'mx_worley_noise_vec2_0',
  type: 'vec2',
  inputs: [{
    name: 'p',
    type: 'vec2'
  }, {
    name: 'jitter',
    type: 'float'
  }, {
    name: 'metric',
    type: 'int'
  }]
});
const mx_worley_noise_vec3_0 = exports.mx_worley_noise_vec3_0 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, jitter_immutable, metric_immutable]) => {
  const metric = (0, _TSLBase.int)(metric_immutable).toVar();
  const jitter = (0, _TSLBase.float)(jitter_immutable).toVar();
  const p = (0, _TSLBase.vec2)(p_immutable).toVar();
  const X = (0, _TSLBase.int)().toVar(),
    Y = (0, _TSLBase.int)().toVar();
  const localpos = (0, _TSLBase.vec2)(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y)).toVar();
  const sqdist = (0, _TSLBase.vec3)(1e6, 1e6, 1e6).toVar();
  (0, _LoopNode.Loop)({
    start: -1,
    end: (0, _TSLBase.int)(1),
    name: 'x',
    condition: '<='
  }, ({
    x
  }) => {
    (0, _LoopNode.Loop)({
      start: -1,
      end: (0, _TSLBase.int)(1),
      name: 'y',
      condition: '<='
    }, ({
      y
    }) => {
      const dist = (0, _TSLBase.float)(mx_worley_distance(localpos, x, y, X, Y, jitter, metric)).toVar();
      (0, _TSLBase.If)(dist.lessThan(sqdist.x), () => {
        sqdist.z.assign(sqdist.y);
        sqdist.y.assign(sqdist.x);
        sqdist.x.assign(dist);
      }).ElseIf(dist.lessThan(sqdist.y), () => {
        sqdist.z.assign(sqdist.y);
        sqdist.y.assign(dist);
      }).ElseIf(dist.lessThan(sqdist.z), () => {
        sqdist.z.assign(dist);
      });
    });
  });
  (0, _TSLBase.If)(metric.equal((0, _TSLBase.int)(0)), () => {
    sqdist.assign((0, _MathNode.sqrt)(sqdist));
  });
  return sqdist;
}).setLayout({
  name: 'mx_worley_noise_vec3_0',
  type: 'vec3',
  inputs: [{
    name: 'p',
    type: 'vec2'
  }, {
    name: 'jitter',
    type: 'float'
  }, {
    name: 'metric',
    type: 'int'
  }]
});
const mx_worley_noise_float_1 = exports.mx_worley_noise_float_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, jitter_immutable, metric_immutable]) => {
  const metric = (0, _TSLBase.int)(metric_immutable).toVar();
  const jitter = (0, _TSLBase.float)(jitter_immutable).toVar();
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  const X = (0, _TSLBase.int)().toVar(),
    Y = (0, _TSLBase.int)().toVar(),
    Z = (0, _TSLBase.int)().toVar();
  const localpos = (0, _TSLBase.vec3)(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y), mx_floorfrac(p.z, Z)).toVar();
  const sqdist = (0, _TSLBase.float)(1e6).toVar();
  (0, _LoopNode.Loop)({
    start: -1,
    end: (0, _TSLBase.int)(1),
    name: 'x',
    condition: '<='
  }, ({
    x
  }) => {
    (0, _LoopNode.Loop)({
      start: -1,
      end: (0, _TSLBase.int)(1),
      name: 'y',
      condition: '<='
    }, ({
      y
    }) => {
      (0, _LoopNode.Loop)({
        start: -1,
        end: (0, _TSLBase.int)(1),
        name: 'z',
        condition: '<='
      }, ({
        z
      }) => {
        const dist = (0, _TSLBase.float)(mx_worley_distance(localpos, x, y, z, X, Y, Z, jitter, metric)).toVar();
        sqdist.assign((0, _MathNode.min)(sqdist, dist));
      });
    });
  });
  (0, _TSLBase.If)(metric.equal((0, _TSLBase.int)(0)), () => {
    sqdist.assign((0, _MathNode.sqrt)(sqdist));
  });
  return sqdist;
}).setLayout({
  name: 'mx_worley_noise_float_1',
  type: 'float',
  inputs: [{
    name: 'p',
    type: 'vec3'
  }, {
    name: 'jitter',
    type: 'float'
  }, {
    name: 'metric',
    type: 'int'
  }]
});
const mx_worley_noise_float = exports.mx_worley_noise_float = /*@__PURE__*/(0, _FunctionOverloadingNode.overloadingFn)([mx_worley_noise_float_0, mx_worley_noise_float_1]);
const mx_worley_noise_vec2_1 = exports.mx_worley_noise_vec2_1 = /*@__PURE__*/(0, _TSLBase.Fn)(([p_immutable, jitter_immutable, metric_immutable]) => {
  const metric = (0, _TSLBase.int)(metric_immutable).toVar();
  const jitter = (0, _TSLBase.float)(jitter_immutable).toVar();
  const p = (0, _TSLBase.vec3)(p_immutable).toVar();
  const X = (0, _TSLBase.int)().toVar(),
    Y = (0, _TSLBase.int)().toVar(),
    Z = (0, _TSLBase.int)().toVar();
  const localpos = (0, _TSLBase.vec3)(mx_floorfrac(p.x, X), mx_floorfrac(p.y, Y), mx_floorfrac(p.z, Z)).toVar();
  const sqdist = (0, _TSLBase.vec2)(1e6, 1e6).toVar();
  (0, _LoopNode.Loop)({
    start: -1,
    end: (0, _TSLBase.int)(1),
    name: 'x',
    condition: '<='
  }, ({
    x
  }) => {
    (0, _LoopNode.Loop)({
      start: -1,
      end: (0, _TSLBase.int)(1),
      name: 'y',
      condition: '<='
    }, ({
      y
    }) => {
      (0, _LoopNode.Loop)({
        start: -1,
        end: (0, _TSLBase.int)(1),
        name: 'z',