@pacem/pacem-3d 1.0.0-abel → 1.0.0-amaldi

package/dist/browser/pacem-3d.js

@@ -1,3 +1,8 @@
+/*!
+ * @pacem/pacem-3d v1.0.0-amaldi (https://js.pacem.it)
+ * Pacem (https://pacem.it)
+ * Licensed under Apache-2.0
+ */
 (function (pacemFoundation, pacemCore, pacemNumerical) {
     'use strict';
 
@@ -2295,35 +2300,35 @@
                 19, 3, 16, 19, 16, 17, 19, 18, 5, 19, 5, 1,
                 19, 1, 4, 18, 14, 10, 18, 10, 6, 18, 6, 5,
                 3, 2, 8, 3, 8, 12, 3, 12, 16];
-            const textureCoordsString = `0.5 0.999501, 0.5 0.999501, 0.191292 0.808708, 0.5 0.690792,
-                0.191292 0.808708, 0.191292 0.808708, 0.5 0.690792,
-                0.808708 0.808708, 0.000499517 0.5, 0.309208 0.5, 0.5 0.309208,
-                0.191292 0.191292, 0.191292 0.191292, 0.309208 0.5,
-                0.191292 0.191292, 0.5 0.000499517, 0.5 0.309208, 0.808708 0.191292,
-                0.000499517 0.5, 0.309208 0.5, 0.690792 0.5, 0.808708 0.808708,
-                0.5 0.999501, 0.690792 0.5, 0.5 0.999501, 0.191292 0.808708,
-                0.690792 0.5, 0.191292 0.808708, 0.309208 0.5, 0.309208 0.5,
-                0.191292 0.191292, 0.5 0.000499517, 0.309208 0.5, 0.5 0.000499517,
-                0.808708 0.191292, 0.309208 0.5, 0.808708 0.191292,
-                0.690792 0.5, 0.191292 0.808708, 0.309208 0.5, 0.690792 0.5,
-                0.191292 0.808708, 0.690792 0.5, 0.808708 0.808708,
-                0.191292 0.808708, 0.808708 0.808708, 0.808708 0.808708,
-                0.5 0.690792, 0.5 0.309208, 0.808708 0.808708, 0.5 0.309208,
-                0.808708 0.191292, 0.808708 0.191292, 0.9995 0.5, 0.191292 0.191292,
-                0.5 0.000499517, 0.808708 0.191292, 0.191292 0.191292,
-                0.808708 0.191292, 0.690792 0.5, 0.191292 0.191292,
-                0.690792 0.5, 0.191292 0.191292, 0.5 0.000499517, 0.808708 0.191292,
-                0.191292 0.191292, 0.808708 0.191292, 0.690792 0.5,
-                0.690792 0.5, 0.309208 0.5, 0.690792 0.5, 0.808708 0.808708,
-                0.5 0.999501, 0.690792 0.5, 0.5 0.999501, 0.191292 0.808708,
-                0.690792 0.5, 0.191292 0.808708, 0.5 0.000499517, 0.808708 0.191292,
-                0.690792 0.5, 0.5 0.000499517, 0.690792 0.5, 0.309208 0.5,
-                0.309208 0.5, 0.191292 0.191292, 0.9995 0.5, 0.808708 0.808708,
-                0.5 0.690792, 0.9995 0.5, 0.5 0.690792, 0.5 0.309208,
-                0.9995 0.5, 0.5 0.309208, 0.309208 0.5, 0.690792 0.5,
-                0.808708 0.808708, 0.309208 0.5, 0.808708 0.808708,
-                0.5 0.999501, 0.000499517 0.5, 0.5 0.309208, 0.000499517 0.5,
-                0.5 0.690792, 0.5 0.690792, 0.000499517 0.5, 0.5 0.690792,
+            const textureCoordsString = `0.5 0.999501, 0.5 0.999501, 0.191292 0.808708, 0.5 0.690792,
+                0.191292 0.808708, 0.191292 0.808708, 0.5 0.690792,
+                0.808708 0.808708, 0.000499517 0.5, 0.309208 0.5, 0.5 0.309208,
+                0.191292 0.191292, 0.191292 0.191292, 0.309208 0.5,
+                0.191292 0.191292, 0.5 0.000499517, 0.5 0.309208, 0.808708 0.191292,
+                0.000499517 0.5, 0.309208 0.5, 0.690792 0.5, 0.808708 0.808708,
+                0.5 0.999501, 0.690792 0.5, 0.5 0.999501, 0.191292 0.808708,
+                0.690792 0.5, 0.191292 0.808708, 0.309208 0.5, 0.309208 0.5,
+                0.191292 0.191292, 0.5 0.000499517, 0.309208 0.5, 0.5 0.000499517,
+                0.808708 0.191292, 0.309208 0.5, 0.808708 0.191292,
+                0.690792 0.5, 0.191292 0.808708, 0.309208 0.5, 0.690792 0.5,
+                0.191292 0.808708, 0.690792 0.5, 0.808708 0.808708,
+                0.191292 0.808708, 0.808708 0.808708, 0.808708 0.808708,
+                0.5 0.690792, 0.5 0.309208, 0.808708 0.808708, 0.5 0.309208,
+                0.808708 0.191292, 0.808708 0.191292, 0.9995 0.5, 0.191292 0.191292,
+                0.5 0.000499517, 0.808708 0.191292, 0.191292 0.191292,
+                0.808708 0.191292, 0.690792 0.5, 0.191292 0.191292,
+                0.690792 0.5, 0.191292 0.191292, 0.5 0.000499517, 0.808708 0.191292,
+                0.191292 0.191292, 0.808708 0.191292, 0.690792 0.5,
+                0.690792 0.5, 0.309208 0.5, 0.690792 0.5, 0.808708 0.808708,
+                0.5 0.999501, 0.690792 0.5, 0.5 0.999501, 0.191292 0.808708,
+                0.690792 0.5, 0.191292 0.808708, 0.5 0.000499517, 0.808708 0.191292,
+                0.690792 0.5, 0.5 0.000499517, 0.690792 0.5, 0.309208 0.5,
+                0.309208 0.5, 0.191292 0.191292, 0.9995 0.5, 0.808708 0.808708,
+                0.5 0.690792, 0.9995 0.5, 0.5 0.690792, 0.5 0.309208,
+                0.9995 0.5, 0.5 0.309208, 0.309208 0.5, 0.690792 0.5,
+                0.808708 0.808708, 0.309208 0.5, 0.808708 0.808708,
+                0.5 0.999501, 0.000499517 0.5, 0.5 0.309208, 0.000499517 0.5,
+                0.5 0.690792, 0.5 0.690792, 0.000499517 0.5, 0.5 0.690792,
                 0.191292 0.191292`;
             const texIndices = [20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
                 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
@@ -3444,35 +3449,35 @@
         const opts = pacemCore.Utils.extend({}, DefaultBasicMaterialFragmentOptions, options);
         const definitions = adaptWGSLStringArray$1(extensions.definitions), bindings = adaptWGSLStringArray$1(extensions.bindings), modifiers = adaptWGSLModifierStringArray$1(extensions.modifiers);
         const color = VERTEX_COLOR_REFERENCE, lighting = LIGHTING_COLOR_REFERENCE, ambient = AMBIENT_COLOR_REFERENCE;
-        return `// definitions
-
-${definitions}
-
-// bindings
-@group(${opts.storageMaterialGroupIndex}) @binding(${opts.storageMaterialBindingIndex}) var<storage, read> diffuseColor: vec4f;
-${bindings}
-
-const empty = vec4f(0,0,0,0);
-const white = vec4f(1,1,1,1);
-
-@fragment fn main (
-    @builtin(position) position: vec4f,                                                 // clip-space position
-    @location(${opts.outputNormalLocation}) normal: vec3f,                              // world-space normal
-    @location(${opts.outputVertexLocation}) vertex: vec3f,                              // world-space position
-    @location(${opts.outputUvLocation}) uv: vec2f,
-    @location(${opts.outputVertexIndexLocation}) @interpolate(flat) index: u32,         // vertex index,
-    @location(${opts.outputRayIndexLocation}) ray: vec3f,                               // ray (eye-to-vertex) vector
-    @location(${opts.outputInstanceIndexLocation}) @interpolate(flat) instance : u32,   // instance index
-) -> @location(0) vec4f {
-    var ${color} = diffuseColor;
-    var ${ambient}: vec4f = empty;
-    var ${lighting}: vec4f = empty;
-
-    // modifiers
-    ${modifiers}
-
-    ${lighting} = select(white, ${lighting}, ${lighting}.a > 0);
-    return ${color} * ${lighting} + ${ambient};
+        return `// definitions
+
+${definitions}
+
+// bindings
+@group(${opts.storageMaterialGroupIndex}) @binding(${opts.storageMaterialBindingIndex}) var<storage, read> diffuseColor: vec4f;
+${bindings}
+
+const empty = vec4f(0,0,0,0);
+const white = vec4f(1,1,1,1);
+
+@fragment fn main (
+    @builtin(position) position: vec4f,                                                 // clip-space position
+    @location(${opts.outputNormalLocation}) normal: vec3f,                              // world-space normal
+    @location(${opts.outputVertexLocation}) vertex: vec3f,                              // world-space position
+    @location(${opts.outputUvLocation}) uv: vec2f,
+    @location(${opts.outputVertexIndexLocation}) @interpolate(flat) index: u32,         // vertex index,
+    @location(${opts.outputRayIndexLocation}) ray: vec3f,                               // ray (eye-to-vertex) vector
+    @location(${opts.outputInstanceIndexLocation}) @interpolate(flat) instance : u32,   // instance index
+) -> @location(0) vec4f {
+    var ${color} = diffuseColor;
+    var ${ambient}: vec4f = empty;
+    var ${lighting}: vec4f = empty;
+
+    // modifiers
+    ${modifiers}
+
+    ${lighting} = select(white, ${lighting}, ${lighting}.a > 0);
+    return ${color} * ${lighting} + ${ambient};
 }`;
     }
 
@@ -3501,30 +3506,30 @@ const white = vec4f(1,1,1,1);
     function getLineMaterialFragmentWgsl(extensions = {}, options = DefaultLineMaterialFragmentOptions) {
         const opts = pacemCore.Utils.extend({}, DefaultLineMaterialFragmentOptions, options);
         const definitions = adaptWGSLStringArray(extensions.definitions), bindings = adaptWGSLStringArray(extensions.bindings), modifiers = adaptWGSLModifierStringArray(extensions.modifiers);
-        return `// definitions
-${definitions}
-
-// bindings
-@group(${options.storageMaterialGroupIndex}) @binding(${options.storageMaterialBindingIndex}) var<storage, read> vertexColors: array<vec4f>;
-${bindings}
-
-fn getVertexColor(index: u32) -> vec4f {
-    let numColors = arrayLength(&vertexColors);
-    let vertexColorIndex = index % numColors;
-    return vertexColors[vertexColorIndex];
-}
-
-@fragment fn main (
-    @builtin(position) position: vec4f,                                                 // clip-space position
-    @location(${opts.outputInstanceIndexLocation}) @interpolate(flat) instance: u32,    // instance index
-    @location(${opts.outputVertexIndexLocation}) @interpolate(flat) index: u32          // vertex index
-) -> @location(0) vec4f {
-    var output = getVertexColor(index);
-
-    // modifiers
-    ${modifiers}
-
-    return output;
+        return `// definitions
+${definitions}
+
+// bindings
+@group(${options.storageMaterialGroupIndex}) @binding(${options.storageMaterialBindingIndex}) var<storage, read> vertexColors: array<vec4f>;
+${bindings}
+
+fn getVertexColor(index: u32) -> vec4f {
+    let numColors = arrayLength(&vertexColors);
+    let vertexColorIndex = index % numColors;
+    return vertexColors[vertexColorIndex];
+}
+
+@fragment fn main (
+    @builtin(position) position: vec4f,                                                 // clip-space position
+    @location(${opts.outputInstanceIndexLocation}) @interpolate(flat) instance: u32,    // instance index
+    @location(${opts.outputVertexIndexLocation}) @interpolate(flat) index: u32          // vertex index
+) -> @location(0) vec4f {
+    var output = getVertexColor(index);
+
+    // modifiers
+    ${modifiers}
+
+    return output;
 }`;
     }
 
@@ -3683,8 +3688,8 @@ fn getVertexColor(index: u32) -> vec4f {
         if (!pacemCore.Utils.isNullOrEmpty(modifierInput)) {
             const { name: modifierName, args: [arg0, arg1], body: modifierBody } = extractMeshVertexModifierFunctionComponents(modifierInput);
             modifyInstructionInput = `${modifierName}(vertexInput, interaction)`;
-            modifierFnInput = `fn ${modifierName} (${arg0}: ${WGSL_VERTEXINPUT_STRUCT_NAME}, ${arg1}: ${WGSL_INTERACTIONDATA_STRUCT_NAME}) -> ${WGSL_VERTEXINPUT_STRUCT_NAME} {
-    ${modifierBody}
+            modifierFnInput = `fn ${modifierName} (${arg0}: ${WGSL_VERTEXINPUT_STRUCT_NAME}, ${arg1}: ${WGSL_INTERACTIONDATA_STRUCT_NAME}) -> ${WGSL_VERTEXINPUT_STRUCT_NAME} {
+    ${modifierBody}
 }`;
         }
         // vertex output modifier?
@@ -3693,74 +3698,74 @@ fn getVertexColor(index: u32) -> vec4f {
         if (!pacemCore.Utils.isNullOrEmpty(modifierOutput)) {
             const { name: modifierName, args: [arg0, arg1], body: modifierBody } = extractMeshVertexModifierFunctionComponents(modifierOutput);
             modifyInstructionOutput = `${modifierName}(output, interaction)`;
-            modifierFnOutput = `fn ${modifierName} (${arg0}: ${WGSL_VERTEXINPUT_STRUCT_NAME}, ${arg1}: ${WGSL_INTERACTIONDATA_STRUCT_NAME}) -> ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
-    ${modifierBody}
+            modifierFnOutput = `fn ${modifierName} (${arg0}: ${WGSL_VERTEXINPUT_STRUCT_NAME}, ${arg1}: ${WGSL_INTERACTIONDATA_STRUCT_NAME}) -> ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
+    ${modifierBody}
 }`;
         }
         const opts = pacemCore.Utils.extend({}, DefaultMeshVertexOptions, options);
-        return `struct ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
-    @builtin(position) position : vec4f,                                                // clip space position
-    @location(${opts.outputNormalLocation}) normal: vec3f,                              // world space normal
-    @location(${opts.outputVertexLocation}) vertex : vec3f,                             // world space position
-    @location(${opts.outputUvLocation}) uv : vec2f,                                     // texture coordinates
-    @location(${opts.outputVertexIndexLocation}) @interpolate(flat) index : u32,        // vertex index
-    @location(${opts.outputRayLocation}) ray : vec3f,                                   // eye-to-point vector in world space
-    @location(${opts.outputInstanceIndexLocation}) @interpolate(flat) instance : u32,   // instance index
-}
-
-struct ${WGSL_VERTEXINPUT_STRUCT_NAME} {
-    @location(${opts.inputPositionLocation}) position: vec3f,
-    @location(${opts.inputNormalLocation}) normal: vec3f,
-    @location(${opts.inputUvLocation}) uv: vec2f,
-    @builtin(vertex_index) index: u32,
-    @builtin(instance_index) instance: u32,
-}
-
-struct Transforms {
-    world: mat4x4f,
-    normal: mat3x3f,
-}
-
-struct Camera {
-    view: mat4x4f,
-    projection: mat4x4f,
-    position: vec3f,
-}
-
-struct ${WGSL_INTERACTIONDATA_STRUCT_NAME} {
-    // mouse coordinatges in NDC space ([-1,1], [-1,1])
-    cursor: vec2f,
-    // canvas size in pixels
-    resolution: vec2f,
-    // some phase timer (e.g. time since mouse down, or time since last click, etc.)
-    time: f32,
-}
-
-${modifierFnInput}
-
-${modifierFnOutput}
-
-@group(${opts.uniformWorldGroupIndex}) @binding(${opts.uniformWorldBindingIndex}) var<uniform> transforms: Transforms;
-@group(${opts.uniformViewGroupIndex}) @binding(${opts.uniformViewBindingIndex}) var<uniform> camera: Camera;
-@group(${opts.uniformInteractionGroupIndex}) @binding(${opts.uniformInteractionBindingIndex}) var<uniform> interaction: ${WGSL_INTERACTIONDATA_STRUCT_NAME};
-
-@vertex fn main(vertexInput: ${WGSL_VERTEXINPUT_STRUCT_NAME}) -> ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
-    let input = ${modifyInstructionInput};
-    let position4 = vec4f(input.position, 1.0);
-    let worldTransform = transforms.world;
-    let viewProjectionTransform = camera.projection;
-    let worldViewProjectionTransform = viewProjectionTransform * worldTransform;
-    let worldPosition = (worldTransform * position4).xyz;
-    let output = ${WGSL_VERTEXOUTPUT_STRUCT_NAME}(
-        worldViewProjectionTransform * position4,
-        transforms.normal * input.normal,
-        worldPosition,
-        input.uv,
-        input.index,
-        normalize(worldPosition - camera.position),
-        input.instance
-    );
-    return ${modifyInstructionOutput};
+        return `struct ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
+    @builtin(position) position : vec4f,                                                // clip space position
+    @location(${opts.outputNormalLocation}) normal: vec3f,                              // world space normal
+    @location(${opts.outputVertexLocation}) vertex : vec3f,                             // world space position
+    @location(${opts.outputUvLocation}) uv : vec2f,                                     // texture coordinates
+    @location(${opts.outputVertexIndexLocation}) @interpolate(flat) index : u32,        // vertex index
+    @location(${opts.outputRayLocation}) ray : vec3f,                                   // eye-to-point vector in world space
+    @location(${opts.outputInstanceIndexLocation}) @interpolate(flat) instance : u32,   // instance index
+}
+
+struct ${WGSL_VERTEXINPUT_STRUCT_NAME} {
+    @location(${opts.inputPositionLocation}) position: vec3f,
+    @location(${opts.inputNormalLocation}) normal: vec3f,
+    @location(${opts.inputUvLocation}) uv: vec2f,
+    @builtin(vertex_index) index: u32,
+    @builtin(instance_index) instance: u32,
+}
+
+struct Transforms {
+    world: mat4x4f,
+    normal: mat3x3f,
+}
+
+struct Camera {
+    view: mat4x4f,
+    projection: mat4x4f,
+    position: vec3f,
+}
+
+struct ${WGSL_INTERACTIONDATA_STRUCT_NAME} {
+    // mouse coordinatges in NDC space ([-1,1], [-1,1])
+    cursor: vec2f,
+    // canvas size in pixels
+    resolution: vec2f,
+    // some phase timer (e.g. time since mouse down, or time since last click, etc.)
+    time: f32,
+}
+
+${modifierFnInput}
+
+${modifierFnOutput}
+
+@group(${opts.uniformWorldGroupIndex}) @binding(${opts.uniformWorldBindingIndex}) var<uniform> transforms: Transforms;
+@group(${opts.uniformViewGroupIndex}) @binding(${opts.uniformViewBindingIndex}) var<uniform> camera: Camera;
+@group(${opts.uniformInteractionGroupIndex}) @binding(${opts.uniformInteractionBindingIndex}) var<uniform> interaction: ${WGSL_INTERACTIONDATA_STRUCT_NAME};
+
+@vertex fn main(vertexInput: ${WGSL_VERTEXINPUT_STRUCT_NAME}) -> ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
+    let input = ${modifyInstructionInput};
+    let position4 = vec4f(input.position, 1.0);
+    let worldTransform = transforms.world;
+    let viewProjectionTransform = camera.projection;
+    let worldViewProjectionTransform = viewProjectionTransform * worldTransform;
+    let worldPosition = (worldTransform * position4).xyz;
+    let output = ${WGSL_VERTEXOUTPUT_STRUCT_NAME}(
+        worldViewProjectionTransform * position4,
+        transforms.normal * input.normal,
+        worldPosition,
+        input.uv,
+        input.index,
+        normalize(worldPosition - camera.position),
+        input.instance
+    );
+    return ${modifyInstructionOutput};
 }`;
     }
 
@@ -3778,160 +3783,160 @@ ${modifierFnOutput}
         uniformWorldBindingIndex: UNIFORM_BINDING_INDEX_TRANSFORM,
     };
     function getVertexOutputStructDefinition(opts) {
-        return `struct ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
-    @builtin(position) position : vec4f,                                                // clip space position
-    @location(${opts.outputInstanceIndexLocation}) @interpolate(flat) instance : u32,   // instance index
-    @location(${opts.outputVertexIndexLocation}) @interpolate(flat) index : u32,        // vertex index
+        return `struct ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
+    @builtin(position) position : vec4f,                                                // clip space position
+    @location(${opts.outputInstanceIndexLocation}) @interpolate(flat) instance : u32,   // instance index
+    @location(${opts.outputVertexIndexLocation}) @interpolate(flat) index : u32,        // vertex index
 }`;
     }
     function getDefaultLineVertexWgsl(options = DefaultLineVertexOptions) {
         const opts = pacemCore.Utils.extend({}, DefaultLineVertexOptions, options);
-        return `${getVertexOutputStructDefinition(opts)}
-
-struct Transforms {
-    world: mat4x4f,
-    normal: mat3x3f,
-}
-
-struct Camera {
-    view: mat4x4f,
-    projection: mat4x4f,
-    position: vec3f
-}
-
-@group(${opts.uniformWorldGroupIndex}) @binding(${opts.uniformWorldBindingIndex}) var<uniform> transforms: Transforms;
-@group(${opts.uniformViewGroupIndex}) @binding(${opts.uniformViewBindingIndex}) var<uniform> camera: Camera;
-@group(${opts.storagePositionsGroupIndex}) @binding(${opts.storagePositionsBindingIndex}) var<storage, read> positions: array<f32>;
-
-@vertex fn main(@builtin(instance_index) instance: u32,
-        @builtin(vertex_index) index: u32) -> ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
-
-    let x = positions[3u * index + 0u];
-    let y = positions[3u * index + 1u];
-    let z = positions[3u * index + 2u];
-    let position4 = vec4f(x, y, z, 1.0);
-    let worldTransform = transforms.world;
-    let viewProjectionTransform = camera.projection;
-    let worldViewProjectionTransform = viewProjectionTransform * worldTransform;
-    let worldPosition = (worldTransform * position4).xyz;
-    return ${WGSL_VERTEXOUTPUT_STRUCT_NAME}(
-        worldViewProjectionTransform * position4,
-        instance,
-        index);
+        return `${getVertexOutputStructDefinition(opts)}
+
+struct Transforms {
+    world: mat4x4f,
+    normal: mat3x3f,
+}
+
+struct Camera {
+    view: mat4x4f,
+    projection: mat4x4f,
+    position: vec3f
+}
+
+@group(${opts.uniformWorldGroupIndex}) @binding(${opts.uniformWorldBindingIndex}) var<uniform> transforms: Transforms;
+@group(${opts.uniformViewGroupIndex}) @binding(${opts.uniformViewBindingIndex}) var<uniform> camera: Camera;
+@group(${opts.storagePositionsGroupIndex}) @binding(${opts.storagePositionsBindingIndex}) var<storage, read> positions: array<f32>;
+
+@vertex fn main(@builtin(instance_index) instance: u32,
+        @builtin(vertex_index) index: u32) -> ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
+
+    let x = positions[3u * index + 0u];
+    let y = positions[3u * index + 1u];
+    let z = positions[3u * index + 2u];
+    let position4 = vec4f(x, y, z, 1.0);
+    let worldTransform = transforms.world;
+    let viewProjectionTransform = camera.projection;
+    let worldViewProjectionTransform = viewProjectionTransform * worldTransform;
+    let worldPosition = (worldTransform * position4).xyz;
+    return ${WGSL_VERTEXOUTPUT_STRUCT_NAME}(
+        worldViewProjectionTransform * position4,
+        instance,
+        index);
 }`;
     }
     function getFatLineVertexWgsl(options = DefaultLineVertexOptions) {
         const opts = pacemCore.Utils.extend({}, DefaultLineVertexOptions, options);
-        return `${getVertexOutputStructDefinition(opts)}
-
-struct Transforms {
-    world: mat4x4f,
-    normal: mat3x3f,
-}
-
-struct Camera {
-    view: mat4x4f,
-    projection: mat4x4f,
-    position: vec3f
-}
-
-struct Pixels {
-    viewportWidth: f32,
-    viewportHeight: f32,
-    halfLineWidth: f32
-}
-
-@group(${opts.uniformWorldGroupIndex}) @binding(${opts.uniformWorldBindingIndex}) var<uniform> transforms: Transforms;
-@group(${opts.uniformViewGroupIndex}) @binding(${opts.uniformViewBindingIndex}) var<uniform> camera: Camera;
-@group(${opts.storagePositionsGroupIndex}) @binding(${opts.storagePositionsBindingIndex}) var<storage, read> positions: array<f32>;
-@group(${opts.uniformDimensionsGroupIndex}) @binding(${opts.uniformDimensionsBindingIndex}) var<uniform> dimensions: Pixels;
-
-fn computeClipPosition(index: u32) -> vec4f {
-    let x = positions[3u * index + 0u];
-    let y = positions[3u * index + 1u];
-    let z = positions[3u * index + 2u];
-    let position4 = vec4f(x, y, z, 1.0);
-    let worldTransform = transforms.world;
-    let viewProjectionTransform = camera.projection;
-    let worldViewProjectionTransform = viewProjectionTransform * worldTransform;
-    return worldViewProjectionTransform * position4;
-}
-
-fn computeOffsetPosition(p0: vec4f, p1: vec4f, index: u32) -> vec4f {
-
-   let viewportSize = vec2f(dimensions.viewportWidth, dimensions.viewportHeight);
-   let normalizedSize = normalize(viewportSize);
-   let halfThickness = dimensions.halfLineWidth / dimensions.viewportWidth;
-   let p0ndc = p0.xyz / p0.w;
-   let p1ndc = p1.xyz / p1.w;
-   let dir = normalize((p1ndc - p0ndc).xy);
-   let offsetX = halfThickness * 2.0 / normalizedSize.x;
-   let offsetY = halfThickness * 2.0 / normalizedSize.y;
-
-   // perp
-   let perp0 = vec2f(-dir.y * offsetX, dir.x * offsetY);
-   let perp1 = perp0;
-
-    /*
-
-        position0-0 -----*----- position0-1
-                    |\\       |
-                    | \\      |
-                    |  \\     |
-                    |   \\    |
-                    |    \\   |
-                    |     \\  |
-                    |      \\ |
-                    |       \\|
-        position1-0 -----*----- position1-1
-
-        indexes:
-        ------------
-        p0-0 -> 0, 3
-        p0-1 -> 5
-        p1-0 -> 1
-        p1-1 -> 2, 4
-    */
-
-   var outPos: vec2f;
-   var w = p0.w;
-   var z = p0.z;
-   if (index == 0 || index == 3){
-       outPos = p0ndc.xy - perp0;
-   }
-   else if (index == 1){
-       outPos = p1ndc.xy - perp1;
-       w = p1.w;
-       z = p1.z;
-   }
-   else if (index == 5){
-       outPos = p0ndc.xy + perp0;
-   }
-   else { //if (index == 2 || index == 4)
-       outPos = p1ndc.xy + perp1;
-       w = p1.w;
-       z = p1.z;
-   }
-
-   // return vec4f(outPos , 0, 1.0);
-   return vec4f(outPos * w, z, w);
-}
-
-@vertex fn main(@builtin(instance_index) instance: u32,
-        @builtin(vertex_index) index: u32) -> ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
-
-    // vertex index starting at 1
-    let position0 = computeClipPosition(instance);
-    let position1 = computeClipPosition(instance + 1);
-
-    // apply offset
-    let position = computeOffsetPosition(position0, position1, index);
-
-    return ${WGSL_VERTEXOUTPUT_STRUCT_NAME}(
-        position,
-        instance,
-        index
-    );
+        return `${getVertexOutputStructDefinition(opts)}
+
+struct Transforms {
+    world: mat4x4f,
+    normal: mat3x3f,
+}
+
+struct Camera {
+    view: mat4x4f,
+    projection: mat4x4f,
+    position: vec3f
+}
+
+struct Pixels {
+    viewportWidth: f32,
+    viewportHeight: f32,
+    halfLineWidth: f32
+}
+
+@group(${opts.uniformWorldGroupIndex}) @binding(${opts.uniformWorldBindingIndex}) var<uniform> transforms: Transforms;
+@group(${opts.uniformViewGroupIndex}) @binding(${opts.uniformViewBindingIndex}) var<uniform> camera: Camera;
+@group(${opts.storagePositionsGroupIndex}) @binding(${opts.storagePositionsBindingIndex}) var<storage, read> positions: array<f32>;
+@group(${opts.uniformDimensionsGroupIndex}) @binding(${opts.uniformDimensionsBindingIndex}) var<uniform> dimensions: Pixels;
+
+fn computeClipPosition(index: u32) -> vec4f {
+    let x = positions[3u * index + 0u];
+    let y = positions[3u * index + 1u];
+    let z = positions[3u * index + 2u];
+    let position4 = vec4f(x, y, z, 1.0);
+    let worldTransform = transforms.world;
+    let viewProjectionTransform = camera.projection;
+    let worldViewProjectionTransform = viewProjectionTransform * worldTransform;
+    return worldViewProjectionTransform * position4;
+}
+
+fn computeOffsetPosition(p0: vec4f, p1: vec4f, index: u32) -> vec4f {
+
+   let viewportSize = vec2f(dimensions.viewportWidth, dimensions.viewportHeight);
+   let normalizedSize = normalize(viewportSize);
+   let halfThickness = dimensions.halfLineWidth / dimensions.viewportWidth;
+   let p0ndc = p0.xyz / p0.w;
+   let p1ndc = p1.xyz / p1.w;
+   let dir = normalize((p1ndc - p0ndc).xy);
+   let offsetX = halfThickness * 2.0 / normalizedSize.x;
+   let offsetY = halfThickness * 2.0 / normalizedSize.y;
+
+   // perp
+   let perp0 = vec2f(-dir.y * offsetX, dir.x * offsetY);
+   let perp1 = perp0;
+
+    /*
+
+        position0-0 -----*----- position0-1
+                    |\\       |
+                    | \\      |
+                    |  \\     |
+                    |   \\    |
+                    |    \\   |
+                    |     \\  |
+                    |      \\ |
+                    |       \\|
+        position1-0 -----*----- position1-1
+
+        indexes:
+        ------------
+        p0-0 -> 0, 3
+        p0-1 -> 5
+        p1-0 -> 1
+        p1-1 -> 2, 4
+    */
+
+   var outPos: vec2f;
+   var w = p0.w;
+   var z = p0.z;
+   if (index == 0 || index == 3){
+       outPos = p0ndc.xy - perp0;
+   }
+   else if (index == 1){
+       outPos = p1ndc.xy - perp1;
+       w = p1.w;
+       z = p1.z;
+   }
+   else if (index == 5){
+       outPos = p0ndc.xy + perp0;
+   }
+   else { //if (index == 2 || index == 4)
+       outPos = p1ndc.xy + perp1;
+       w = p1.w;
+       z = p1.z;
+   }
+
+   // return vec4f(outPos , 0, 1.0);
+   return vec4f(outPos * w, z, w);
+}
+
+@vertex fn main(@builtin(instance_index) instance: u32,
+        @builtin(vertex_index) index: u32) -> ${WGSL_VERTEXOUTPUT_STRUCT_NAME} {
+
+    // vertex index starting at 1
+    let position0 = computeClipPosition(instance);
+    let position1 = computeClipPosition(instance + 1);
+
+    // apply offset
+    let position = computeOffsetPosition(position0, position1, index);
+
+    return ${WGSL_VERTEXOUTPUT_STRUCT_NAME}(
+        position,
+        instance,
+        index
+    );
 }`;
     }
 
@@ -3940,16 +3945,16 @@ fn computeOffsetPosition(p0: vec4f, p1: vec4f, index: u32) -> vec4f {
      * Generate a WGSL piece of code that eases 3D picking using color strategy.
      */
     function getColorPickingFragmentWgsl(groupIndex = UNIFORM_GROUP_INDEX_COLORPICKING) {
-        return `struct ColorPicker {
-    id: u32,
-  };
-
-  @group(${groupIndex}) @binding(0) var<uniform> colorPicker: ColorPicker;
-
-  @fragment
-  fn main(@builtin(position) position: vec4f) -> @location(0) u32 {
-    return colorPicker.id;
-  }
+        return `struct ColorPicker {
+    id: u32,
+  };
+
+  @group(${groupIndex}) @binding(0) var<uniform> colorPicker: ColorPicker;
+
+  @fragment
+  fn main(@builtin(position) position: vec4f) -> @location(0) u32 {
+    return colorPicker.id;
+  }
   `;
     }
 
@@ -3992,16 +3997,16 @@ fn computeOffsetPosition(p0: vec4f, p1: vec4f, index: u32) -> vec4f {
         }
         return {
             // type definitions
-            definitions: [`struct DirectionalLight {
-    color: vec4f,
-    direction: vec3f,
-    intensity: f32
-}`, `fn computeDirectional(normal: vec3f, color: vec4f, light: DirectionalLight) -> vec4f {
-    let n = normalize(normal);
-    let d = normalize(light.direction);
-    let factor = light.intensity * .5 * (1.0 + dot(n, -d));
-    let output = color.rgb * light.color.rgb * factor;
-    return vec4f(output, color.a);
+            definitions: [`struct DirectionalLight {
+    color: vec4f,
+    direction: vec3f,
+    intensity: f32
+}`, `fn computeDirectional(normal: vec3f, color: vec4f, light: DirectionalLight) -> vec4f {
+    let n = normalize(normal);
+    let d = normalize(light.direction);
+    let factor = light.intensity * .5 * (1.0 + dot(n, -d));
+    let output = color.rgb * light.color.rgb * factor;
+    return vec4f(output, color.a);
 }`],
             // bindings
             bindings: [`@group(${group}) @binding(${binding}) var<uniform> ${lightReference}: DirectionalLight;`],
@@ -4023,24 +4028,24 @@ fn computeOffsetPosition(p0: vec4f, p1: vec4f, index: u32) -> vec4f {
         }
         return {
             // type definitions
-            definitions: [`struct OmniLight {
-    color: vec4f,
-    position: vec3f,
-    intensity: f32
-}`, `fn computeOmni(position: vec3f, normal: vec3f, ray: vec3f, color: vec4f, specularColor: vec4f, shininess: f32, light: OmniLight) -> vec4f {
-
-    // color
-    let n = normalize(normal);
-    let d = normalize(position - light.position);
-    let factor = light.intensity * .5 * (1.0 + dot(n, -d));
-
-    // specular
-    let r = normalize(ray);
-    let halfVector = normalize(d + r);
-    let specular = specularColor.rgb * shininess * dot(n, -halfVector);
-
-    let output = color.rgb * light.color.rgb * factor + specular;
-    return vec4f(output, color.a);
+            definitions: [`struct OmniLight {
+    color: vec4f,
+    position: vec3f,
+    intensity: f32
+}`, `fn computeOmni(position: vec3f, normal: vec3f, ray: vec3f, color: vec4f, specularColor: vec4f, shininess: f32, light: OmniLight) -> vec4f {
+
+    // color
+    let n = normalize(normal);
+    let d = normalize(position - light.position);
+    let factor = light.intensity * .5 * (1.0 + dot(n, -d));
+
+    // specular
+    let r = normalize(ray);
+    let halfVector = normalize(d + r);
+    let specular = specularColor.rgb * shininess * dot(n, -halfVector);
+
+    let output = color.rgb * light.color.rgb * factor + specular;
+    return vec4f(output, color.a);
 }`],
             // bindings
             bindings: [`@group(${group}) @binding(${binding}) var<uniform> ${lightReference}: OmniLight;`],
@@ -4058,11 +4063,11 @@ fn computeOffsetPosition(p0: vec4f, p1: vec4f, index: u32) -> vec4f {
         }
         return {
             // type definitions
-            definitions: [`struct AmbientLight {
-    color: vec4f,
-    intensity: f32
-}`, `fn computeAmbient(color: vec4f, light: AmbientLight) -> vec4f {
-    return vec4f(light.intensity * color.rgb * light.color.rgb, color.a);
+            definitions: [`struct AmbientLight {
+    color: vec4f,
+    intensity: f32
+}`, `fn computeAmbient(color: vec4f, light: AmbientLight) -> vec4f {
+    return vec4f(light.intensity * color.rgb * light.color.rgb, color.a);
 }`],
             // bindings
             bindings: [`@group(${group}) @binding(${binding}) var<uniform> ${lightReference}: AmbientLight;`],