@woosh/meep-engine 2.46.4 → 2.46.5

package/src/engine/graphics/particles/node-based/codegen/glsl/GLSLCodeGenerator.js

@@ -0,0 +1,249 @@
+import { CodeGenerator } from "../CodeGenerator.js";
+import { CodeContext } from "../CodeContext.js";
+import { BitSet } from "../../../../../../core/binary/BitSet.js";
+import { PortDirection } from "../../../../../../core/model/node-graph/node/PortDirection.js";
+import LineBuilder from "../../../../../../core/codegen/LineBuilder.js";
+import { ParticleDataTypes } from "../../nodes/ParticleDataTypes.js";
+import { assert } from "../../../../../../core/assert.js";
+import { genAttributeInputName } from "./genAttributeInputName.js";
+import { genAttributeOutputName } from "./genAttributeOutputName.js";
+
+/**
+ *
+ * @param {ParticleDataTypes} type
+ * @returns {string}
+ */
+function genTypeSpecifier(type) {
+
+    switch (type) {
+        case ParticleDataTypes.Color:
+        case ParticleDataTypes.Vector4:
+            return 'vec4';
+        case ParticleDataTypes.Vector3:
+            return 'vec3';
+        case ParticleDataTypes.Vector2:
+            return 'vec2';
+        case ParticleDataTypes.Float:
+            return 'float';
+        default:
+            throw new Error(`Unsupported data type '${type}'`);
+    }
+}
+
+/**
+ *
+ * @param {string} name
+ * @param {ParticleDataTypes} type
+ * @returns {string}
+ */
+function genVarDeclaration(name, type) {
+    assert.typeOf(name, 'string', 'name');
+
+    return `${genTypeSpecifier(type)} ${name}`;
+}
+
+/**
+ *
+ * @param {CodeContext} context
+ * @param {LineBuilder} output
+ * @param {ParticleDataTypes} type
+ */
+function initializeDefaultValue(context, output, type) {
+
+    const id = context.identifier();
+
+    output.add(`${genVarDeclaration(id, type)};`);
+
+    return id;
+}
+
+
+/**
+ *
+ * @type {Connection[]}
+ */
+const temp_connections = [];
+
+export class GLSLCodeGenerator extends CodeGenerator {
+
+    /**
+     *
+     * @param {LineBuilder} output
+     * @param {NodeGraph} graph
+     * @param {FunctionModuleRegistry} module_registry
+     */
+    includeDependencies(output, graph, module_registry) {
+        const references = [];
+
+        graph.traverseNodes(node => {
+            const nodeDescription = node.description;
+
+            if (!nodeDescription.isShaderNode) {
+                return;
+            }
+
+            /**
+             * @type {FunctionModuleReference[]}
+             */
+            const dependencies = nodeDescription.dependencies;
+
+            Array.prototype.push.apply(references, dependencies);
+        });
+
+        const complete_references = module_registry.resolveDependencyTreeForReferences(references);
+
+        const module_list = complete_references.map(module_registry.getModuleByReference, module_registry);
+
+        const n = module_list.length;
+        for (let i = 0; i < n; i++) {
+            /**
+             *
+             * @type {FunctionModule}
+             */
+            const module = module_list[i];
+
+            module.generate(output);
+        }
+    }
+
+    generate({
+                 graph,
+                 modules,
+                 attributes,
+                 uniforms
+             }) {
+
+        /**
+         *
+         * @type {Set<NodeInstance>}
+         */
+        const open_set = new Set();
+        const closed_set = new BitSet();
+
+        const context = new CodeContext();
+
+        // TODO validate graph
+
+        const out_preamble = new LineBuilder();
+        out_preamble.add('#version 300 es');
+        out_preamble.add('precision highp float;');
+
+        // include dependency modules
+        this.includeDependencies(out_preamble, graph, modules);
+
+        // declare attributes
+        attributes.forEach(attribute => {
+            out_preamble.add(`in ${genTypeSpecifier(attribute.type)} ${genAttributeInputName(attribute)};`);
+            out_preamble.add(`out ${genTypeSpecifier(attribute.type)} ${genAttributeOutputName(attribute)};`);
+        });
+
+        // declare uniforms
+        uniforms.forEach(element => {
+            out_preamble.add(`uniform ${genTypeSpecifier(element.type)} ${element.name};`);
+        });
+
+        const out_main_body = new LineBuilder();
+
+        // add all output nodes to open set
+        graph.traverseNodes(open_set.add, open_set);
+
+        while (open_set.size > 0) {
+
+            const trash = [];
+
+
+            open_set_loop:for (const instance of open_set) {
+
+                /**
+                 *
+                 * @type {List<Connection>}
+                 */
+                const connection_count = graph.getConnectionsAttachedToNode(instance.id, temp_connections);
+
+                // gather output port variable names
+                const port_variables = [];
+
+                for (let i = 0; i < connection_count; i++) {
+
+                    const connection_id = temp_connections[i];
+
+                    /**
+                     *
+                     * @type {Connection}
+                     */
+                    const connection = graph.getConnection(connection_id);
+
+                    if (connection.target.instance === instance && connection.target.port.direction === PortDirection.In) {
+                        if (closed_set.get(connection.source.instance.id)) {
+                            port_variables[connection.target.port.id] = context.getIdentifier(connection.source.instance, connection.source.port);
+
+                        } else {
+
+                            // input not satisfied
+                            continue open_set_loop;
+                        }
+                    } else if (connection.source.instance === instance && connection.source.port.direction === PortDirection.In) {
+                        if (closed_set.get(connection.target.instance.id)) {
+                            port_variables[connection.source.port.id] = context.getIdentifier(connection.target.instance, connection.target.port);
+                        } else {
+
+                            // input not satisfied
+                            continue open_set_loop;
+                        }
+                    }
+
+                }
+
+                // create variables for all outputs
+                const nodeDescription = instance.description;
+                const ports = nodeDescription.getPorts();
+
+                for (let i = 0; i < ports.length; i++) {
+                    const port = ports[i];
+
+                    if (port.direction === PortDirection.Out) {
+                        const identifier = context.getIdentifier(instance, port);
+
+                        port_variables[port.id] = identifier;
+
+                        out_main_body.add(`${genVarDeclaration(identifier, port.dataType)};`);
+
+                    } else if (port_variables[port.id] === undefined) {
+
+                        // no input, lets create one
+                        port_variables[port.id] = initializeDefaultValue(context, out_main_body, port.dataType);
+                    }
+                }
+
+                // all connections are satisfied, lets materialize the node
+                trash.push(instance);
+                closed_set.set(instance.id, true);
+
+                //
+                nodeDescription.generate_code(instance, out_main_body, context, port_variables);
+            }
+
+            if (trash.length === 0) {
+                // no nodes materialized, can't proceed with the generation
+                throw new Error(`No more nodes could be materialized`);
+            }
+
+            for (let i = 0; i < trash.length; i++) {
+                const instance = trash[i];
+
+                open_set.delete(instance);
+            }
+        }
+
+        const b = new LineBuilder();
+
+        b.addLines(out_preamble);
+        b.add('void  main(){');
+        b.indent();
+        b.addLines(out_main_body);
+        b.dedent();
+        b.add('}');
+
+        return b.build();
+    }
+}

package/src/engine/graphics/particles/node-based/codegen/glsl/genAttributeInputName.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {ParticleAttributeSpecification} attribute
+ * @return {string}
+ */
+export function genAttributeInputName(attribute){
+    return `in_${attribute.name}`;
+}

package/src/engine/graphics/particles/node-based/codegen/glsl/genAttributeOutputName.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {ParticleAttributeSpecification} attribute
+ * @return {string}
+ */
+export function genAttributeOutputName(attribute) {
+    return `out_${attribute.name}`;
+}

package/src/engine/graphics/particles/node-based/codegen/glsl/getTypeByteSize.js

@@ -0,0 +1,21 @@
+import { ParticleDataTypes } from "../../nodes/ParticleDataTypes.js";
+
+/**
+ *
+ * @param {ParticleDataTypes} type
+ * @returns {number}
+ */
+export function getTypeByteSize(type) {
+    switch (type) {
+        case ParticleDataTypes.Float:
+            return 4;
+        case ParticleDataTypes.Vector2:
+            return 8;
+        case ParticleDataTypes.Vector3:
+            return 12;
+        case ParticleDataTypes.Vector4:
+            return 16;
+        default:
+            throw  new Error(`Unsupported data type '${type}'`);
+    }
+}

package/src/engine/graphics/particles/node-based/codegen/glsl/modules/noise/curl/glslm_curlNoise.js

@@ -0,0 +1,58 @@
+import { FunctionModule } from "../../../../modules/FunctionModule.js";
+import { FunctionSignature } from "../../../../modules/FunctionSignature.js";
+import { FunctionParameterSpecification } from "../../../../modules/FunctionParameterSpecification.js";
+import { PortDirection } from "../../../../../../../../../core/model/node-graph/node/PortDirection.js";
+import { ParticleDataTypes } from "../../../../../nodes/ParticleDataTypes.js";
+import { FunctionModuleReference } from "../../../../modules/FunctionModuleReference.js";
+import LineBuilder from "../../../../../../../../../core/codegen/LineBuilder.js";
+
+/**
+ * @link:  https://github.com/cabbibo/glsl-curl-noise/blob/master/curl.glsl
+ * @type {string}
+ */
+const code = `
+vec3 curlNoise( vec3 p ){
+  
+  const float e = .1;
+  vec3 dx = vec3( e   , 0.0 , 0.0 );
+  vec3 dy = vec3( 0.0 , e   , 0.0 );
+  vec3 dz = vec3( 0.0 , 0.0 , e   );
+
+  vec3 p_x0 = snoiseVec3( p - dx );
+  vec3 p_x1 = snoiseVec3( p + dx );
+  vec3 p_y0 = snoiseVec3( p - dy );
+  vec3 p_y1 = snoiseVec3( p + dy );
+  vec3 p_z0 = snoiseVec3( p - dz );
+  vec3 p_z1 = snoiseVec3( p + dz );
+
+  float x = p_y1.z - p_y0.z - p_z1.y + p_z0.y;
+  float y = p_z1.x - p_z0.x - p_x1.z + p_x0.z;
+  float z = p_x1.y - p_x0.y - p_y1.x + p_y0.x;
+
+  const float divisor = 1.0 / ( 2.0 * e );
+  return normalize( vec3( x , y , z ) * divisor );
+
+}
+`;
+
+export const glslm_curlNoise = FunctionModule.from({
+    id: 'glsl-noise/simplex/3d#curlNoise',
+    signature: FunctionSignature.from(
+        [
+            FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector3)
+        ],
+        ParticleDataTypes.Vector3
+    ),
+    dependencies: [
+        FunctionModuleReference.from(
+            'glsl-noise/simplex/3d#snoiseVec3',
+            FunctionSignature.from(
+                [
+                    FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector3)
+                ],
+                ParticleDataTypes.Vector3
+            )
+        )
+    ],
+    code_lines: LineBuilder.fromText(code)
+});

package/src/engine/graphics/particles/node-based/codegen/glsl/modules/noise/curl/glslm_snoiseVector3.js

@@ -0,0 +1,44 @@
+import { FunctionModule } from "../../../../modules/FunctionModule.js";
+import { FunctionSignature } from "../../../../modules/FunctionSignature.js";
+import { FunctionParameterSpecification } from "../../../../modules/FunctionParameterSpecification.js";
+import { PortDirection } from "../../../../../../../../../core/model/node-graph/node/PortDirection.js";
+import { ParticleDataTypes } from "../../../../../nodes/ParticleDataTypes.js";
+import { FunctionModuleReference } from "../../../../modules/FunctionModuleReference.js";
+import LineBuilder from "../../../../../../../../../core/codegen/LineBuilder.js";
+
+/**
+ * @link:  https://github.com/cabbibo/glsl-curl-noise/blob/master/curl.glsl
+ * @type {string}
+ */
+const code = `
+vec3 snoiseVec3( vec3 x ){
+
+  float s  = snoise(vec3( x ));
+  float s1 = snoise(vec3( x.y - 19.1 , x.z + 33.4 , x.x + 47.2 ));
+  float s2 = snoise(vec3( x.z + 74.2 , x.x - 124.5 , x.y + 99.4 ));
+  vec3 c = vec3( s , s1 , s2 );
+  return c;
+
+}
+`;
+
+export const glslm_snoiseVec3 = FunctionModule.from({
+    id: 'glsl-noise/simplex/3d#snoiseVec3',
+    signature: FunctionSignature.from(
+        [
+            FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector3)
+        ],
+        ParticleDataTypes.Vector3
+    ),
+    dependencies: [
+        FunctionModuleReference.from(
+            'glsl-noise/simplex/3d#snoise',
+            FunctionSignature.from([
+                    FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector3)
+                ],
+                ParticleDataTypes.Float
+            )
+        )
+    ],
+    code_lines: LineBuilder.fromText(code)
+});

package/src/engine/graphics/particles/node-based/codegen/glsl/modules/noise/simplex/3d/glslm_mod289_v3.js

@@ -0,0 +1,28 @@
+import { FunctionModule } from "../../../../../modules/FunctionModule.js";
+import { FunctionSignature } from "../../../../../modules/FunctionSignature.js";
+import { FunctionParameterSpecification } from "../../../../../modules/FunctionParameterSpecification.js";
+import { PortDirection } from "../../../../../../../../../../core/model/node-graph/node/PortDirection.js";
+import { ParticleDataTypes } from "../../../../../../nodes/ParticleDataTypes.js";
+import LineBuilder from "../../../../../../../../../../core/codegen/LineBuilder.js";
+
+/**
+ * @link:  https://github.com/hughsk/glsl-noise/blob/master/simplex/3d.glsl
+ * @type {string}
+ */
+const code = `
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+`;
+
+export const glslm_mod289_v3 = FunctionModule.from({
+    id: 'glsl-noise/simplex/3d#mod289_v3',
+    signature: FunctionSignature.from(
+        [
+            FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector3)
+        ],
+        ParticleDataTypes.Vector3
+    ),
+    dependencies: [],
+    code_lines: LineBuilder.fromText(code)
+});

package/src/engine/graphics/particles/node-based/codegen/glsl/modules/noise/simplex/3d/glslm_mod289_v4.js

@@ -0,0 +1,28 @@
+import { FunctionModule } from "../../../../../modules/FunctionModule.js";
+import { FunctionSignature } from "../../../../../modules/FunctionSignature.js";
+import { FunctionParameterSpecification } from "../../../../../modules/FunctionParameterSpecification.js";
+import { PortDirection } from "../../../../../../../../../../core/model/node-graph/node/PortDirection.js";
+import { ParticleDataTypes } from "../../../../../../nodes/ParticleDataTypes.js";
+import LineBuilder from "../../../../../../../../../../core/codegen/LineBuilder.js";
+
+/**
+ * @link:  https://github.com/hughsk/glsl-noise/blob/master/simplex/3d.glsl
+ * @type {string}
+ */
+const code = `
+vec4 mod289(vec4 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+`;
+
+export const glslm_mod289_v4 = FunctionModule.from({
+    id: 'glsl-noise/simplex/3d#mod289_v4',
+    signature: FunctionSignature.from(
+        [
+            FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector4)
+        ],
+        ParticleDataTypes.Vector4
+    ),
+    dependencies: [],
+    code_lines: LineBuilder.fromText(code)
+});

package/src/engine/graphics/particles/node-based/codegen/glsl/modules/noise/simplex/3d/glslm_permute.js

@@ -0,0 +1,39 @@
+import { FunctionModule } from "../../../../../modules/FunctionModule.js";
+import { FunctionSignature } from "../../../../../modules/FunctionSignature.js";
+import { FunctionParameterSpecification } from "../../../../../modules/FunctionParameterSpecification.js";
+import { PortDirection } from "../../../../../../../../../../core/model/node-graph/node/PortDirection.js";
+import { ParticleDataTypes } from "../../../../../../nodes/ParticleDataTypes.js";
+import LineBuilder from "../../../../../../../../../../core/codegen/LineBuilder.js";
+import { FunctionModuleReference } from "../../../../../modules/FunctionModuleReference.js";
+
+/**
+ * @link:  https://github.com/hughsk/glsl-noise/blob/master/simplex/3d.glsl
+ * @type {string}
+ */
+const code = `
+vec4 permute(vec4 x) {
+     return mod289(((x*34.0)+1.0)*x);
+}
+`;
+
+export const glslm_permute = FunctionModule.from({
+    id: 'glsl-noise/simplex/3d#permute',
+    signature: FunctionSignature.from(
+        [
+            FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector4)
+        ],
+        ParticleDataTypes.Vector4
+    ),
+    dependencies: [
+        FunctionModuleReference.from(
+            'glsl-noise/simplex/3d#mod289_v4',
+            FunctionSignature.from(
+                [
+                    FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector4)
+                ],
+                ParticleDataTypes.Vector4
+            )
+        )
+    ],
+    code_lines: LineBuilder.fromText(code)
+});

package/src/engine/graphics/particles/node-based/codegen/glsl/modules/noise/simplex/3d/glslm_snoise.js

@@ -0,0 +1,124 @@
+import { FunctionModule } from "../../../../../modules/FunctionModule.js";
+import { FunctionSignature } from "../../../../../modules/FunctionSignature.js";
+import { ParticleDataTypes } from "../../../../../../nodes/ParticleDataTypes.js";
+import { FunctionParameterSpecification } from "../../../../../modules/FunctionParameterSpecification.js";
+import { PortDirection } from "../../../../../../../../../../core/model/node-graph/node/PortDirection.js";
+import LineBuilder from "../../../../../../../../../../core/codegen/LineBuilder.js";
+import { FunctionModuleReference } from "../../../../../modules/FunctionModuleReference.js";
+
+const code = `
+float snoise(in vec3 v)
+  {
+  const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
+  const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);
+
+// First corner
+  vec3 i  = floor(v + dot(v, C.yyy) );
+  vec3 x0 =   v - i + dot(i, C.xxx) ;
+
+// Other corners
+  vec3 g = step(x0.yzx, x0.xyz);
+  vec3 l = 1.0 - g;
+  vec3 i1 = min( g.xyz, l.zxy );
+  vec3 i2 = max( g.xyz, l.zxy );
+
+  //   x0 = x0 - 0.0 + 0.0 * C.xxx;
+  //   x1 = x0 - i1  + 1.0 * C.xxx;
+  //   x2 = x0 - i2  + 2.0 * C.xxx;
+  //   x3 = x0 - 1.0 + 3.0 * C.xxx;
+  vec3 x1 = x0 - i1 + C.xxx;
+  vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
+  vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y
+
+// Permutations
+  i = mod289(i);
+  vec4 p = permute( permute( permute(
+             i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
+           + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
+           + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
+
+// Gradients: 7x7 points over a square, mapped onto an octahedron.
+// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+  float n_ = 0.142857142857; // 1.0/7.0
+  vec3  ns = n_ * D.wyz - D.xzx;
+
+  vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)
+
+  vec4 x_ = floor(j * ns.z);
+  vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)
+
+  vec4 x = x_ *ns.x + ns.yyyy;
+  vec4 y = y_ *ns.x + ns.yyyy;
+  vec4 h = 1.0 - abs(x) - abs(y);
+
+  vec4 b0 = vec4( x.xy, y.xy );
+  vec4 b1 = vec4( x.zw, y.zw );
+
+  //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
+  //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
+  vec4 s0 = floor(b0)*2.0 + 1.0;
+  vec4 s1 = floor(b1)*2.0 + 1.0;
+  vec4 sh = -step(h, vec4(0.0));
+
+  vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
+  vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
+
+  vec3 p0 = vec3(a0.xy,h.x);
+  vec3 p1 = vec3(a0.zw,h.y);
+  vec3 p2 = vec3(a1.xy,h.z);
+  vec3 p3 = vec3(a1.zw,h.w);
+
+//Normalise gradients
+  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+  p0 *= norm.x;
+  p1 *= norm.y;
+  p2 *= norm.z;
+  p3 *= norm.w;
+
+// Mix final noise value
+  vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
+  m = m * m;
+  
+  return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
+                                dot(p2,x2), dot(p3,x3) ) );
+  }
+`
+
+export const glslm_snoise = FunctionModule.from({
+    id: 'glsl-noise/simplex/3d#snoise',
+    signature: FunctionSignature.from([
+            FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector3),
+        ],
+        ParticleDataTypes.Float
+    ),
+    dependencies: [
+        FunctionModuleReference.from(
+            'glsl-noise/simplex/3d#taylorInvSqrt',
+            FunctionSignature.from(
+                [
+                    FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector4)
+                ],
+                ParticleDataTypes.Vector4
+            )
+        ),
+        FunctionModuleReference.from(
+            'glsl-noise/simplex/3d#permute',
+            FunctionSignature.from(
+                [
+                    FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector4)
+                ],
+                ParticleDataTypes.Vector4
+            )
+        ),
+        FunctionModuleReference.from(
+            'glsl-noise/simplex/3d#mod289_v3',
+            FunctionSignature.from(
+                [
+                    FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector3)
+                ],
+                ParticleDataTypes.Vector3
+            )
+        )
+    ],
+    code_lines: LineBuilder.fromText(code)
+});

package/src/engine/graphics/particles/node-based/codegen/glsl/modules/noise/simplex/3d/glslm_tylorInvSqrt.js

@@ -0,0 +1,30 @@
+import { FunctionModule } from "../../../../../modules/FunctionModule.js";
+import { FunctionSignature } from "../../../../../modules/FunctionSignature.js";
+import { FunctionParameterSpecification } from "../../../../../modules/FunctionParameterSpecification.js";
+import { PortDirection } from "../../../../../../../../../../core/model/node-graph/node/PortDirection.js";
+import { ParticleDataTypes } from "../../../../../../nodes/ParticleDataTypes.js";
+import LineBuilder from "../../../../../../../../../../core/codegen/LineBuilder.js";
+
+
+/**
+ * @link:  https://github.com/hughsk/glsl-noise/blob/master/simplex/3d.glsl
+ * @type {string}
+ */
+const code = `
+vec4 taylorInvSqrt(vec4 r)
+{
+  return 1.79284291400159 - 0.85373472095314 * r;
+}
+`;
+
+export const glslm_taylorInvSqrt = FunctionModule.from({
+    id: 'glsl-noise/simplex/3d#taylorInvSqrt',
+    signature: FunctionSignature.from(
+        [
+            FunctionParameterSpecification.from(PortDirection.In, ParticleDataTypes.Vector4)
+        ],
+        ParticleDataTypes.Vector4
+    ),
+    dependencies: [],
+    code_lines: LineBuilder.fromText(code)
+});