@firecms/neat 0.7.1 → 0.9.0

package/dist/index.es.js

@@ -1,179 +1,277 @@
-const he = `void main() {
-    vUv = uv;
-
-    // SCROLLING LOGIC
-    // Separate multipliers for wave, color, and flow offsets
-    float waveOffset = -u_y_offset * u_y_offset_wave_multiplier;
-    float colorOffset = -u_y_offset * u_y_offset_color_multiplier;
-    float flowOffset = -u_y_offset * u_y_offset_flow_multiplier;
-
-    // 1. DISPLACEMENT (WAVES)
-    // We add waveOffset to Y to scroll the wave pattern
-    v_displacement_amount = cnoise( vec3(
-        u_wave_frequency_x * position.x + u_time,
-        u_wave_frequency_y * (position.y + waveOffset) + u_time,
-        u_time
-    ));
-
-    // 2. FLOW FIELD
-    // Apply flow offset to scroll the flow field mask
-    vec2 baseUv = vUv;
-    baseUv.y += flowOffset / u_plane_height; // Scale to match wave speed
-    vec2 flowUv = baseUv;
-
-    if (u_flow_enabled > 0.5) {
-        if (u_flow_ease > 0.0 || u_flow_distortion_a > 0.0) {
-            vec2 ppp = -1.0 + 2.0 * baseUv;
-            ppp += 0.1 * cos((1.5 * u_flow_scale) * ppp.yx + 1.1 * u_time + vec2(0.1, 1.1));
-            ppp += 0.1 * cos((2.3 * u_flow_scale) * ppp.yx + 1.3 * u_time + vec2(3.2, 3.4));
-            ppp += 0.1 * cos((2.2 * u_flow_scale) * ppp.yx + 1.7 * u_time + vec2(1.8, 5.2));
-            ppp += u_flow_distortion_a * cos((u_flow_distortion_b * u_flow_scale) * ppp.yx + 1.4 * u_time + vec2(6.3, 3.9));
-
-            float r = length(ppp);
-            flowUv = mix(baseUv, vec2(baseUv.x * (1.0 - u_flow_ease) + r * u_flow_ease, baseUv.y), u_flow_ease);
-        }
-    }
-
-    // Pass the standard flow UV to fragment shader (for texture)
-    vFlowUv = flowUv;
-
-    // 3. COLOR MIXING
-    // We take the computed flow UVs and apply the color offset
-    // Scale by plane height to match wave offset speed (world space vs UV space)
-    vec3 color = u_colors[0].color;
-    // ...
-    vec2 adjustedUv = flowUv;
-    adjustedUv.y += colorOffset / u_plane_height; // Scroll the color mixing pattern
-
-    vec2 noise_cord = adjustedUv * u_color_pressure;
-    const float minNoise = .0;
-    const float maxNoise = .9;
-
-    for (int i = 1; i < 6; i++) {
-        if (i < u_colors_count) {
-            if (u_colors[i].is_active > 0.5) {
-                float noiseFlow = (1. + float(i)) / 30.;
-                float noiseSpeed = (1. + float(i)) * 0.11;
-                float noiseSeed = 13. + float(i) * 7.;
-
-                float noise = snoise(
-                    vec3(
-                        noise_cord.x * u_color_pressure.x + u_time * noiseFlow * 2.,
-                        noise_cord.y * u_color_pressure.y,
-                        u_time * noiseSpeed
-                    ) + noiseSeed
-                ) - (.1 * float(i)) + (.5 * u_color_blending);
-
-                noise = clamp(noise, minNoise, maxNoise + float(i) * 0.02);
-                color = mix(color, u_colors[i].color, smoothstep(0.0, u_color_blending, noise));
-            }
-        }
-    }
-
-    v_color = color;
-
-    // 4. VERTEX POSITION
-    vec3 newPosition = position + normal * v_displacement_amount * u_wave_amplitude;
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(newPosition, 1.0);
-    v_new_position = gl_Position;
+const ct = `void main() {
+vUv = uv;
+vPosition = position;
+float waveOffset = -u_y_offset * u_y_offset_wave_multiplier;
+float colorOffset = -u_y_offset * u_y_offset_color_multiplier;
+float flowOffset = -u_y_offset * u_y_offset_flow_multiplier;
+v_displacement_amount = cnoise( vec3(
+u_wave_frequency_x * position.x + u_time,
+u_wave_frequency_y * (position.y + waveOffset) + u_time,
+u_time
+));
+vec2 baseUv = vUv;
+baseUv.y += flowOffset / u_plane_height;
+vec2 flowUv = baseUv;
+if (u_flow_enabled > 0.5) {
+if (u_flow_ease > 0.0 || u_flow_distortion_a > 0.0) {
+vec2 ppp = -1.0 + 2.0 * baseUv;
+ppp += 0.1 * cos((1.5 * u_flow_scale) * ppp.yx + 1.1 * u_time + vec2(0.1, 1.1));
+ppp += 0.1 * cos((2.3 * u_flow_scale) * ppp.yx + 1.3 * u_time + vec2(3.2, 3.4));
+ppp += 0.1 * cos((2.2 * u_flow_scale) * ppp.yx + 1.7 * u_time + vec2(1.8, 5.2));
+ppp += u_flow_distortion_a * cos((u_flow_distortion_b * u_flow_scale) * ppp.yx + 1.4 * u_time + vec2(6.3, 3.9));
+float r = length(ppp);
+flowUv = mix(baseUv, vec2(baseUv.x * (1.0 - u_flow_ease) + r * u_flow_ease, baseUv.y), u_flow_ease);
 }
-`, de = `float random(vec2 p) {
-    return fract(sin(dot(p, vec2(12.9898,78.233))) * 43758.5453);
 }
-
+vFlowUv = flowUv;
+vec3 color = u_colors[0].color;
+vec3 distortedPos = position;
+if (u_shape_type > 0.5) {
+if (u_flow_enabled > 0.5) {
+if (u_flow_ease > 0.0 || u_flow_distortion_a > 0.0) {
+vec3 ppp = position / 25.0;
+ppp.xyz += 0.1 * cos((1.5 * u_flow_scale) * ppp.yxz + 1.1 * u_time + vec3(0.1, 1.1, 2.1));
+ppp.xyz += 0.1 * cos((2.3 * u_flow_scale) * ppp.zxy + 1.3 * u_time + vec3(3.2, 3.4, 1.2));
+ppp.xyz += 0.1 * cos((2.2 * u_flow_scale) * ppp.yxz + 1.7 * u_time + vec3(1.8, 5.2, 3.1));
+ppp.xyz += u_flow_distortion_a * cos((u_flow_distortion_b * u_flow_scale) * ppp.zxy + 1.4 * u_time + vec3(6.3, 3.9, 4.5));
+float r = length(ppp);
+distortedPos = mix(position, vec3(
+position.x * (1.0 - u_flow_ease) + r * u_flow_ease * 25.0,
+position.y,
+position.z * (1.0 - u_flow_ease) + r * u_flow_ease * 25.0
+), u_flow_ease);
+}
+}
+}
+vec3 noise_cord;
+if (u_shape_type > 0.5) {
+noise_cord = vec3(distortedPos.x / 50.0, (distortedPos.y + colorOffset) / 50.0, distortedPos.z / 50.0);
+} else {
+vec2 adjustedUv = flowUv;
+adjustedUv.y += colorOffset / u_plane_height;
+noise_cord = vec3(adjustedUv, 0.0);
+}
+const float minNoise = .0;
+const float maxNoise = .9;
+for (int i = 1; i < 6; i++) {
+if (i < u_colors_count) {
+if (u_colors[i].is_active > 0.5) {
+float noiseFlow = (1. + float(i)) / 30.;
+float noiseSpeed = (1. + float(i)) * 0.11;
+float noiseSeed = 13. + float(i) * 7.;
+float noise_z = u_time * noiseSpeed;
+if (u_shape_type > 0.5) {
+noise_z = noise_cord.z * u_color_pressure.x * u_color_pressure.x + u_time * noiseSpeed;
+}
+float noise = snoise(
+vec3(
+noise_cord.x * u_color_pressure.x * u_color_pressure.x + u_time * noiseFlow * 2.,
+noise_cord.y * u_color_pressure.y * u_color_pressure.y,
+noise_z
+) + noiseSeed
+) - (.1 * float(i)) + (.5 * u_color_blending);
+noise = clamp(noise, minNoise, maxNoise + float(i) * 0.02);
+color = mix(color, u_colors[i].color, smoothstep(0.0, u_color_blending, noise));
+}
+}
+}
+v_color = color;
+vec3 newPosition = position + normal * v_displacement_amount * u_wave_amplitude;
+vec4 mvPosition = modelViewMatrix * vec4(newPosition, 1.0);
+vViewPosition = mvPosition.xyz;
+vNormal = normalize((modelViewMatrix * vec4(normal, 0.0)).xyz);
+gl_Position = projectionMatrix * mvPosition;
+v_new_position = gl_Position;
+}`, ht = `float random(vec2 p) {
+return fract(sin(dot(p, vec2(12.9898,78.233))) * 43758.5453);
+}
 float fbm(vec3 x) {
-    float value = 0.0;
-    float amplitude = 0.5;
-    float frequency = 1.0;
-    for (int i = 0; i < 4; i++) {
-        value += amplitude * snoise(x * frequency);
-        frequency *= 2.0;
-        amplitude *= 0.5;
-    }
-    return value;
+float value = 0.0;
+float amplitude = 0.5;
+float frequency = 1.0;
+for (int i = 0; i < 4; i++) {
+value += amplitude * snoise(x * frequency);
+frequency *= 2.0;
+amplitude *= 0.5;
+}
+return value;
+}
+vec3 hsl2rgb(float h, float s, float l) {
+vec3 rgb = clamp(abs(mod(h * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);
+return l + s * (rgb - 0.5) * (1.0 - abs(2.0 * l - 1.0));
 }
-
 void main() {
-    vec2 finalUv = vFlowUv;
-    
-    vec3 baseColor;
-
-    if (u_enable_procedural_texture > 0.5) {
-        // Calculate flow field distance for ease effect
-        vec2 ppp = -1.0 + 2.0 * finalUv;
-        ppp += 0.1 * cos((1.5 * u_flow_scale) * ppp.yx + 1.1 * u_time + vec2(0.1, 1.1));
-        ppp += 0.1 * cos((2.3 * u_flow_scale) * ppp.yx + 1.3 * u_time + vec2(3.2, 3.4));
-        ppp += 0.1 * cos((2.2 * u_flow_scale) * ppp.yx + 1.7 * u_time + vec2(1.8, 5.2));
-        ppp += u_flow_distortion_a * cos((u_flow_distortion_b * u_flow_scale) * ppp.yx + 1.4 * u_time + vec2(6.3, 3.9));
-        float r = length(ppp); // Flow distance
-        
-        // Ease blending: 0 = topographic (flow), 1 = image (UV)
-        float vx = (finalUv.x * u_texture_ease) + (r * (1.0 - u_texture_ease));
-        float vy = (finalUv.y * u_texture_ease) + (0.0 * (1.0 - u_texture_ease));
-        vec2 texUv = vec2(vx, vy);
-
-        // PARALLAX SCROLLING
-        // We manually apply a smaller offset here to make the texture lag behind
-        float parallaxFactor = 0.25; // 25% speed of the color mixing
-        texUv.y -= (u_y_offset * u_y_offset_color_multiplier / u_plane_height) * parallaxFactor;
-
-        texUv *= 1.5; // Tiling scale
-
-        vec4 texSample = texture2D(u_procedural_texture, texUv);
-        baseColor = texSample.rgb;
-    } else {
-        baseColor = v_color;
-    }
-
-    vec3 color = baseColor;
-
-    // Post-processing
-    color += v_displacement_amount * u_highlights;
-    // Replace pow() with direct multiplication to avoid negative base undefined behavior in GLSL
-    float shadowFactor = 1.0 - v_displacement_amount;
-    color -= shadowFactor * shadowFactor * u_shadows;
-    color = saturation(color, 1.0 + u_saturation);
-    color = color * u_brightness;
-
-    // Grain
-    vec2 noiseCoords = gl_FragCoord.xy / u_grain_scale;
-    float grain = 0.0;
-    
-    // Completely bypass expensive noise generation if grain is disabled
-    if (u_grain_intensity > 0.0) {
-        if (u_grain_speed != 0.0) {
-            grain = fbm(vec3(noiseCoords, u_time * u_grain_speed));
-        } else {
-            grain = fbm(vec3(noiseCoords, 0.0));
-        }
-
-        grain = grain * 0.5 + 0.5;
-        grain -= 0.5;
-        grain = (grain > u_grain_sparsity) ? grain : 0.0;
-        grain *= u_grain_intensity;
-    }
-
-    color += vec3(grain);
-
-    gl_FragColor = vec4(color, 1.0);
+vec2 finalUv = vFlowUv;
+vec3 baseColor;
+float texAlpha = 1.0;
+if (u_enable_procedural_texture > 0.5) {
+if (u_shape_type > 0.5) {
+float parallaxFactor = 0.25;
+float scrollOffset = (u_y_offset * u_y_offset_color_multiplier) * parallaxFactor;
+vec3 scrolledPos = vPosition;
+scrolledPos.y -= scrollOffset;
+vec3 p = (scrolledPos * 1.5) / 50.0;
+vec2 uvX = p.yz + vec2(0.5);
+vec2 uvY = p.zx + vec2(0.5);
+vec2 uvZ = p.xy + vec2(0.5);
+vec4 colX = texture2D(u_procedural_texture, fract(uvX));
+vec4 colY = texture2D(u_procedural_texture, fract(uvY));
+vec4 colZ = texture2D(u_procedural_texture, fract(uvZ));
+vec3 n = normalize(vNormal);
+vec3 blendWeights = abs(n);
+blendWeights = blendWeights / (blendWeights.x + blendWeights.y + blendWeights.z + 0.0001);
+vec4 texSample = colX * blendWeights.x + colY * blendWeights.y + colZ * blendWeights.z;
+baseColor = texSample.rgb;
+if (u_transparent_texture_void > 0.5) {
+texAlpha = texSample.a;
+}
+} else {
+vec2 ppp = -1.0 + 2.0 * finalUv;
+ppp += 0.1 * cos((1.5 * u_flow_scale) * ppp.yx + 1.1 * u_time + vec2(0.1, 1.1));
+ppp += 0.1 * cos((2.3 * u_flow_scale) * ppp.yx + 1.3 * u_time + vec2(3.2, 3.4));
+ppp += 0.1 * cos((2.2 * u_flow_scale) * ppp.yx + 1.7 * u_time + vec2(1.8, 5.2));
+ppp += u_flow_distortion_a * cos((u_flow_distortion_b * u_flow_scale) * ppp.yx + 1.4 * u_time + vec2(6.3, 3.9));
+float r = length(ppp);
+float vx = (finalUv.x * u_texture_ease) + (r * (1.0 - u_texture_ease));
+float vy = (finalUv.y * u_texture_ease) + (0.0 * (1.0 - u_texture_ease));
+vec2 texUv = vec2(vx, vy);
+float parallaxFactor = 0.25;
+texUv.y -= (u_y_offset * u_y_offset_color_multiplier / u_plane_height) * parallaxFactor;
+texUv *= 1.5;
+vec4 texSample = texture2D(u_procedural_texture, fract(texUv));
+baseColor = texSample.rgb;
+if (u_transparent_texture_void > 0.5) {
+texAlpha = texSample.a;
+}
+}
+} else {
+baseColor = v_color;
+}
+vec3 color = baseColor;
+if (u_domain_warp_enabled > 0.5) {
+vec3 p;
+if (u_shape_type > 0.5) {
+p = vec3((vPosition / 50.0 + vec3(0.5)) * u_domain_warp_scale);
+p.z += u_time * 0.15;
+} else {
+p = vec3(finalUv * u_domain_warp_scale, u_time * 0.15);
+}
+vec2 q = vec2(fbm(p), fbm(p + vec3(5.2, 1.3, 0.0)));
+float f = fbm(p + vec3(4.0 * q, 0.0));
+vec3 warpColor = color * (1.0 + f * 0.8 * u_domain_warp_intensity);
+float pattern = clamp(f * f * f + 0.6 * f * f + 0.5 * f, 0.0, 1.0);
+color = mix(color, warpColor * (0.6 + pattern * 0.8), u_domain_warp_intensity * 0.7);
+}
+vec3 normal = normalize(vNormal);
+vec3 viewDir = vec3(0.0, 0.0, 1.0);
+float ndotv = dot(normal, viewDir);
+if (u_shape_type > 0.5 && u_shape_type < 3.5) {
+if (ndotv < 0.0) {
+discard;
+}
+} else {
+if (ndotv < 0.0) {
+normal = -normal;
+ndotv = -ndotv;
+}
+}
+vec3 lightDir = normalize(vec3(1.0, 1.0, 1.0));
+float diffuse = max(dot(normal, lightDir), 0.0);
+vec3 halfDir = normalize(lightDir + viewDir);
+float specular = pow(max(dot(normal, halfDir), 0.0), 32.0);
+if (u_shape_type <= 0.5) {
+color += v_displacement_amount * u_highlights;
+float heightShadow = 1.0 - v_displacement_amount;
+color -= heightShadow * heightShadow * u_shadows;
+} else {
+color += specular * u_highlights;
+color += v_displacement_amount * u_highlights * 0.5;
+float heightShadow = 1.0 - v_displacement_amount;
+color -= heightShadow * heightShadow * u_shadows * 0.5;
+color -= (1.0 - diffuse) * u_shadows * 0.5;
 }
-`;
-function me() {
+color = saturation(color, 1.0 + u_saturation);
+color = color * u_brightness;
+if (u_iridescence_enabled > 0.5) {
+float hue = fract(v_displacement_amount * 0.5 + 0.5 + u_time * u_iridescence_speed * 0.05);
+vec3 iriColor = hsl2rgb(hue, 0.8, 0.6);
+color = mix(color, iriColor, u_iridescence_intensity * abs(v_displacement_amount) * 0.6);
+}
+if (u_fresnel_enabled > 0.5) {
+float slope = 1.0 - abs(v_displacement_amount);
+float fresnel = pow(max(slope, 0.0), u_fresnel_power);
+color += u_fresnel_color * fresnel * u_fresnel_intensity;
+}
+if (u_vignette_intensity > 0.0) {
+vec2 vigUv = vUv;
+if (u_shape_type > 0.5) {
+vigUv = (v_new_position.xy / v_new_position.w) * 0.5 + vec2(0.5);
+}
+float dist = length(vigUv - vec2(0.5));
+float vig = smoothstep(u_vignette_radius, u_vignette_radius * 0.3, dist);
+color *= mix(1.0, vig, u_vignette_intensity);
+}
+if (u_bloom_intensity > 0.0) {
+float luma = dot(color, vec3(0.2126, 0.7152, 0.0722));
+float bloomMask = smoothstep(u_bloom_threshold, 1.0, luma);
+color += color * bloomMask * u_bloom_intensity;
+}
+if (u_chromatic_aberration > 0.0) {
+float caAmount = u_chromatic_aberration * 0.008;
+vec2 caUv = vUv;
+if (u_shape_type > 0.5) {
+caUv = (v_new_position.xy / v_new_position.w) * 0.5 + vec2(0.5);
+}
+float dist = length(caUv - vec2(0.5));
+float rShift = v_displacement_amount + caAmount * dist;
+float bShift = v_displacement_amount - caAmount * dist;
+color.r *= 1.0 + rShift * caAmount * 10.0;
+color.b *= 1.0 - bShift * caAmount * 10.0;
+}
+float grain = 0.0;
+if (u_grain_intensity > 0.0) {
+vec2 noiseCoords = gl_FragCoord.xy / u_grain_scale;
+if (u_grain_speed != 0.0 || u_shape_type <= 0.5) {
+grain = fbm(vec3(noiseCoords, u_time * u_grain_speed));
+} else {
+grain = random(noiseCoords) - 0.5;
+}
+grain = grain * 0.5 + 0.5;
+grain -= 0.5;
+grain = (grain > u_grain_sparsity) ? grain : 0.0;
+grain *= u_grain_intensity;
+}
+color += vec3(grain);
+float edgeAlpha = 1.0;
+if (u_shape_type > 0.5) {
+edgeAlpha = smoothstep(0.0, u_silhouette_fade, ndotv);
+}
+if (u_shape_type == 3.0) {
+float vFade = smoothstep(0.0, u_cylinder_fade, vUv.y) * smoothstep(1.0, 1.0 - u_cylinder_fade, vUv.y);
+edgeAlpha *= vFade;
+} else if (u_shape_type == 4.0) {
+float uFade = smoothstep(0.0, u_ribbon_fade, vUv.x) * smoothstep(1.0, 1.0 - u_ribbon_fade, vUv.x);
+float vFade = smoothstep(0.0, u_ribbon_fade, vUv.y) * smoothstep(1.0, 1.0 - u_ribbon_fade, vUv.y);
+edgeAlpha *= uFade * vFade;
+}
+edgeAlpha *= texAlpha;
+gl_FragColor = vec4(color, edgeAlpha);
+}`;
+function ft() {
   return `precision highp float;
-
 attribute vec3 position;
 attribute vec3 normal;
 attribute vec2 uv;
-
 uniform mat4 modelViewMatrix;
 uniform mat4 projectionMatrix;
-
 varying vec2 vUv;
 varying vec2 vFlowUv;
 varying vec4 v_new_position;
 varying vec3 v_color;
 varying float v_displacement_amount;
-
+varying vec3 vViewPosition;
+varying vec3 vNormal;
+varying vec3 vPosition;
 uniform float u_time;
 uniform vec2 u_resolution;
 uniform vec2 u_color_pressure;
@@ -183,227 +281,201 @@ uniform float u_wave_amplitude;
 uniform float u_plane_width;
 uniform float u_plane_height;
 uniform float u_color_blending;
-
 uniform int u_colors_count;
 struct ColorStop {
-    float is_active;
-    vec3 color;
-    float influence;
+float is_active;
+vec3 color;
+float influence;
 };
 uniform ColorStop u_colors[6];
-
 uniform float u_y_offset;
 uniform float u_y_offset_wave_multiplier;
 uniform float u_y_offset_color_multiplier;
 uniform float u_y_offset_flow_multiplier;
-
-// Flow field uniforms
 uniform float u_flow_distortion_a;
 uniform float u_flow_distortion_b;
 uniform float u_flow_scale;
 uniform float u_flow_ease;
 uniform float u_flow_enabled;
-`;
+uniform float u_fresnel_enabled;
+uniform float u_fresnel_power;
+uniform float u_fresnel_intensity;
+uniform vec3 u_fresnel_color;
+uniform float u_shape_type;`;
 }
-function pe() {
+function dt() {
   return `precision highp float;
-
 varying vec2 vUv;
 varying vec2 vFlowUv;
+varying vec4 v_new_position;
 varying vec3 v_color;
 varying float v_displacement_amount;
-
+varying vec3 vViewPosition;
+varying vec3 vNormal;
+varying vec3 vPosition;
 uniform float u_time;
+uniform vec2 u_resolution;
 uniform float u_plane_height;
-
 uniform float u_shadows;
 uniform float u_highlights;
 uniform float u_saturation;
 uniform float u_brightness;
-uniform float u_grain_intensity; 
-uniform float u_grain_sparsity; 
-uniform float u_grain_scale; 
-uniform float u_grain_speed; 
-
+uniform float u_grain_intensity;
+uniform float u_grain_sparsity;
+uniform float u_grain_scale;
+uniform float u_grain_speed;
 uniform float u_y_offset;
 uniform float u_y_offset_color_multiplier;
-
-// Flow field uniforms
 uniform float u_flow_distortion_a;
 uniform float u_flow_distortion_b;
 uniform float u_flow_scale;
-
-// Procedural texture uniforms
 uniform sampler2D u_procedural_texture;
 uniform float u_enable_procedural_texture;
 uniform float u_texture_ease;
-`;
+uniform float u_domain_warp_enabled;
+uniform float u_domain_warp_intensity;
+uniform float u_domain_warp_scale;
+uniform float u_vignette_intensity;
+uniform float u_vignette_radius;
+uniform float u_fresnel_enabled;
+uniform float u_fresnel_power;
+uniform float u_fresnel_intensity;
+uniform vec3 u_fresnel_color;
+uniform float u_iridescence_enabled;
+uniform float u_iridescence_intensity;
+uniform float u_iridescence_speed;
+uniform float u_bloom_intensity;
+uniform float u_bloom_threshold;
+uniform float u_chromatic_aberration;
+uniform float u_shape_type;
+uniform float u_transparent_texture_void;
+uniform float u_silhouette_fade;
+uniform float u_cylinder_fade;
+uniform float u_ribbon_fade;`;
 }
-function Y() {
-  return `
-// 1. REPLACEMENT PERMUTE: 
-// Uses a hash function (fract/sin) instead of a modular lookup table.
-vec4 permute(vec4 x) {
-    return floor(fract(sin(x) * 43758.5453123) * 289.0);
+function oe() {
+  return `vec4 permute(vec4 x) {
+return floor(fract(sin(x) * 43758.5453123) * 289.0);
 }
-
-// Taylor Inverse Sqrt
 vec4 taylorInvSqrt(vec4 r) {
-  return 1.79284291400159 - 0.85373472095314 * r;
+return 1.79284291400159 - 0.85373472095314 * r;
 }
-
-// Fade function
 vec3 fade(vec3 t) {
-  return t*t*t*(t*(t*6.0-15.0)+10.0);
+return t*t*t*(t*(t*6.0-15.0)+10.0);
 }
-
-// 3D Simplex Noise
 float snoise(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 );
-
-  vec3 x1 = x0 - i1 + C.xxx;
-  vec3 x2 = x0 - i2 + C.yyy;
-  vec3 x3 = x0 - D.yyy;
-
-  // Permutations
-  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
-  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);
-
-  vec4 x_ = floor(j * ns.z);
-  vec4 y_ = floor(j - 7.0 * x_ );
-
-  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 = 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) ) );
+const vec2 C = vec2(1.0/6.0, 1.0/3.0) ;
+const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
+vec3 i = floor(v + dot(v, C.yyy) );
+vec3 x0 = v - i + dot(i, C.xxx) ;
+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 );
+vec3 x1 = x0 - i1 + C.xxx;
+vec3 x2 = x0 - i2 + C.yyy;
+vec3 x3 = x0 - D.yyy;
+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 ));
+float n_ = 0.142857142857;
+vec3 ns = n_ * D.wyz - D.xzx;
+vec4 j = p - 49.0 * floor(p * ns.z * ns.z);
+vec4 x_ = floor(j * ns.z);
+vec4 y_ = floor(j - 7.0 * x_ );
+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 = 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);
+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;
+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) ) );
 }
-
-// Classic Perlin noise
 float cnoise(vec3 P)
 {
-  vec3 Pi0 = floor(P); 
-  vec3 Pi1 = Pi0 + vec3(1.0); 
-  
-  vec3 Pf0 = fract(P); 
-  vec3 Pf1 = Pf0 - vec3(1.0); 
-  vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-  vec4 iy = vec4(Pi0.yy, Pi1.yy);
-  vec4 iz0 = Pi0.zzzz;
-  vec4 iz1 = Pi1.zzzz;
-
-  vec4 ixy = permute(permute(ix) + iy);
-  vec4 ixy0 = permute(ixy + iz0);
-  vec4 ixy1 = permute(ixy + iz1);
-
-  vec4 gx0 = ixy0 * (1.0 / 7.0);
-  vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;
-  gx0 = fract(gx0);
-  vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
-  vec4 sz0 = step(gz0, vec4(0.0));
-  gx0 -= sz0 * (step(0.0, gx0) - 0.5);
-  gy0 -= sz0 * (step(0.0, gy0) - 0.5);
-
-  vec4 gx1 = ixy1 * (1.0 / 7.0);
-  vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;
-  gx1 = fract(gx1);
-  vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
-  vec4 sz1 = step(gz1, vec4(0.0));
-  gx1 -= sz1 * (step(0.0, gx1) - 0.5);
-  gy1 -= sz1 * (step(0.0, gy1) - 0.5);
-
-  vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);
-  vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);
-  vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);
-  vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);
-  vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);
-  vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);
-  vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);
-  vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);
-
-  vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
-  g000 *= norm0.x;
-  g010 *= norm0.y;
-  g100 *= norm0.z;
-  g110 *= norm0.w;
-  vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
-  g001 *= norm1.x;
-  g011 *= norm1.y;
-  g101 *= norm1.z;
-  g111 *= norm1.w;
-
-  float n000 = dot(g000, Pf0);
-  float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
-  float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
-  float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
-  float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
-  float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
-  float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
-  float n111 = dot(g111, Pf1);
-
-  vec3 fade_xyz = fade(Pf0);
-  vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
-  vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
-  float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
-  return 2.2 * n_xyz;
-}
-`;
+vec3 Pi0 = floor(P);
+vec3 Pi1 = Pi0 + vec3(1.0);
+vec3 Pf0 = fract(P);
+vec3 Pf1 = Pf0 - vec3(1.0);
+vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+vec4 iy = vec4(Pi0.yy, Pi1.yy);
+vec4 iz0 = Pi0.zzzz;
+vec4 iz1 = Pi1.zzzz;
+vec4 ixy = permute(permute(ix) + iy);
+vec4 ixy0 = permute(ixy + iz0);
+vec4 ixy1 = permute(ixy + iz1);
+vec4 gx0 = ixy0 * (1.0 / 7.0);
+vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5;
+gx0 = fract(gx0);
+vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0);
+vec4 sz0 = step(gz0, vec4(0.0));
+gx0 -= sz0 * (step(0.0, gx0) - 0.5);
+gy0 -= sz0 * (step(0.0, gy0) - 0.5);
+vec4 gx1 = ixy1 * (1.0 / 7.0);
+vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5;
+gx1 = fract(gx1);
+vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1);
+vec4 sz1 = step(gz1, vec4(0.0));
+gx1 -= sz1 * (step(0.0, gx1) - 0.5);
+gy1 -= sz1 * (step(0.0, gy1) - 0.5);
+vec3 g000 = vec3(gx0.x,gy0.x,gz0.x);
+vec3 g100 = vec3(gx0.y,gy0.y,gz0.y);
+vec3 g010 = vec3(gx0.z,gy0.z,gz0.z);
+vec3 g110 = vec3(gx0.w,gy0.w,gz0.w);
+vec3 g001 = vec3(gx1.x,gy1.x,gz1.x);
+vec3 g101 = vec3(gx1.y,gy1.y,gz1.y);
+vec3 g011 = vec3(gx1.z,gy1.z,gz1.z);
+vec3 g111 = vec3(gx1.w,gy1.w,gz1.w);
+vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+g000 *= norm0.x;
+g010 *= norm0.y;
+g100 *= norm0.z;
+g110 *= norm0.w;
+vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+g001 *= norm1.x;
+g011 *= norm1.y;
+g101 *= norm1.z;
+g111 *= norm1.w;
+float n000 = dot(g000, Pf0);
+float n100 = dot(g100, vec3(Pf1.x, Pf0.yz));
+float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z));
+float n110 = dot(g110, vec3(Pf1.xy, Pf0.z));
+float n001 = dot(g001, vec3(Pf0.xy, Pf1.z));
+float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z));
+float n011 = dot(g011, vec3(Pf0.x, Pf1.yz));
+float n111 = dot(g111, Pf1);
+vec3 fade_xyz = fade(Pf0);
+vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z);
+vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y);
+float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x);
+return 2.2 * n_xyz;
+}`;
 }
-function j() {
-  return `
-vec3 saturation(vec3 rgb, float adjustment) {
-    const vec3 W = vec3(0.2125, 0.7154, 0.0721);
-    vec3 intensity = vec3(dot(rgb, W));
-    return mix(intensity, rgb, adjustment);
+function re() {
+  return `vec3 saturation(vec3 rgb, float adjustment) {
+const vec3 W = vec3(0.2125, 0.7154, 0.0721);
+vec3 intensity = vec3(dot(rgb, W));
+return mix(intensity, rgb, adjustment);
+}`;
 }
-`;
-}
-class J {
+class he {
   elements;
   constructor() {
     this.elements = new Float32Array([
@@ -425,15 +497,23 @@ class J {
       1
     ]);
   }
-  translate(e, i, o) {
-    return this.elements[12] += this.elements[0] * e + this.elements[4] * i + this.elements[8] * o, this.elements[13] += this.elements[1] * e + this.elements[5] * i + this.elements[9] * o, this.elements[14] += this.elements[2] * e + this.elements[6] * i + this.elements[10] * o, this.elements[15] += this.elements[3] * e + this.elements[7] * i + this.elements[11] * o, this;
+  translate(e, i, r) {
+    return this.elements[12] += this.elements[0] * e + this.elements[4] * i + this.elements[8] * r, this.elements[13] += this.elements[1] * e + this.elements[5] * i + this.elements[9] * r, this.elements[14] += this.elements[2] * e + this.elements[6] * i + this.elements[10] * r, this.elements[15] += this.elements[3] * e + this.elements[7] * i + this.elements[11] * r, this;
   }
   rotateX(e) {
-    const i = Math.cos(e), o = Math.sin(e), t = this.elements[4], b = this.elements[5], y = this.elements[6], n = this.elements[7], p = this.elements[8], v = this.elements[9], T = this.elements[10], x = this.elements[11];
-    return this.elements[4] = i * t + o * p, this.elements[5] = i * b + o * v, this.elements[6] = i * y + o * T, this.elements[7] = i * n + o * x, this.elements[8] = i * p - o * t, this.elements[9] = i * v - o * b, this.elements[10] = i * T - o * y, this.elements[11] = i * x - o * n, this;
+    const i = Math.cos(e), r = Math.sin(e), t = this.elements[4], y = this.elements[5], x = this.elements[6], o = this.elements[7], l = this.elements[8], _ = this.elements[9], b = this.elements[10], a = this.elements[11];
+    return this.elements[4] = i * t + r * l, this.elements[5] = i * y + r * _, this.elements[6] = i * x + r * b, this.elements[7] = i * o + r * a, this.elements[8] = i * l - r * t, this.elements[9] = i * _ - r * y, this.elements[10] = i * b - r * x, this.elements[11] = i * a - r * o, this;
+  }
+  rotateY(e) {
+    const i = Math.cos(e), r = Math.sin(e), t = this.elements[0], y = this.elements[1], x = this.elements[2], o = this.elements[3], l = this.elements[8], _ = this.elements[9], b = this.elements[10], a = this.elements[11];
+    return this.elements[0] = i * t - r * l, this.elements[1] = i * y - r * _, this.elements[2] = i * x - r * b, this.elements[3] = i * o - r * a, this.elements[8] = r * t + i * l, this.elements[9] = r * y + i * _, this.elements[10] = r * x + i * b, this.elements[11] = r * o + i * a, this;
+  }
+  rotateZ(e) {
+    const i = Math.cos(e), r = Math.sin(e), t = this.elements[0], y = this.elements[1], x = this.elements[2], o = this.elements[3], l = this.elements[4], _ = this.elements[5], b = this.elements[6], a = this.elements[7];
+    return this.elements[0] = i * t + r * l, this.elements[1] = i * y + r * _, this.elements[2] = i * x + r * b, this.elements[3] = i * o + r * a, this.elements[4] = -r * t + i * l, this.elements[5] = -r * y + i * _, this.elements[6] = -r * x + i * b, this.elements[7] = -r * o + i * a, this;
   }
 }
-class ge {
+class mt {
   left;
   right;
   top;
@@ -442,11 +522,12 @@ class ge {
   far;
   position;
   projectionMatrix;
-  constructor(e, i, o, t, b, y) {
-    this.left = e, this.right = i, this.top = o, this.bottom = t, this.near = b, this.far = y, this.position = [0, 0, 0], this.projectionMatrix = new J(), this.updateProjectionMatrix();
+  zoom;
+  constructor(e, i, r, t, y, x) {
+    this.left = e, this.right = i, this.top = r, this.bottom = t, this.near = y, this.far = x, this.position = [0, 0, 0], this.zoom = 1, this.projectionMatrix = new he(), this.updateProjectionMatrix();
   }
   updateProjectionMatrix() {
-    const e = 1 / (this.right - this.left), i = 1 / (this.top - this.bottom), o = 1 / (this.far - this.near), t = (this.right + this.left) * e, b = (this.top + this.bottom) * i, y = (this.far + this.near) * o;
+    const e = 1 / (this.right - this.left), i = 1 / (this.top - this.bottom), r = 1 / (this.far - this.near), t = (this.right + this.left) * e, y = (this.top + this.bottom) * i, x = (this.far + this.near) * r;
     this.projectionMatrix.elements = new Float32Array([
       2 * e,
       0,
@@ -458,51 +539,188 @@ class ge {
       0,
       0,
       0,
-      -2 * o,
+      -2 * r,
       0,
       -t,
-      -b,
       -y,
+      -x,
       1
     ]);
   }
 }
-function H(a, e, i, o = 50, t = 50) {
-  const n = e * i / 1e6 * o * t / 1.5, p = e / i, v = Math.sqrt(n * p), T = n / v;
-  let x = -o / 2, h = Math.min((x + v) / 1.5, o / 2), w = t / 4, R = Math.max((w - T) / 2, -t / 4);
-  if (p < 1) {
-    const E = p;
-    x = x * E, h = h * E;
-    const g = 1.05;
-    x = x * g, h = h * g, w = w * g, R = R * g;
-  }
-  a.left = x, a.right = h, a.top = w, a.bottom = R, a.near = -100, a.far = 1e3, a.updateProjectionMatrix();
+function G(s, e, i, r = 50, t = 50, y = "plane", x = 1) {
+  s.zoom = x;
+  const o = e / i;
+  if (y === "plane") {
+    const b = e * i / 1e6 * r * t / 1.5, a = Math.sqrt(b * o), h = b / a;
+    let p = -r / 2, c = Math.min((p + a) / 1.5, r / 2), f = t / 4, R = Math.max((f - h) / 2, -t / 4);
+    if (o < 1) {
+      const g = o;
+      p = p * g, c = c * g;
+      const v = 1.05;
+      p = p * v, c = c * v, f = f * v, R = R * v;
+    }
+    s.left = p, s.right = c, s.top = f, s.bottom = R;
+  } else {
+    let l = 25;
+    if (y === "sphere" ? l = 30 : y === "torus" ? l = 35 : y === "cylinder" && (l = 30), o >= 1)
+      s.left = -l * o, s.right = l * o, s.top = l, s.bottom = -l;
+    else {
+      s.left = -l, s.right = l, s.top = l / o, s.bottom = -l / o;
+      const _ = 1.05;
+      s.left *= _, s.right *= _, s.top *= _, s.bottom *= _;
+    }
+  }
+  s.left /= x, s.right /= x, s.top /= x, s.bottom /= x, s.near = -100, s.far = 1e3, s.updateProjectionMatrix();
+}
+function se(s, e, i, r) {
+  const t = s / 2, y = e / 2, x = Math.floor(i), o = Math.floor(r), l = x + 1, _ = o + 1, b = s / x, a = e / o, h = [], p = [], c = [], f = [];
+  for (let v = 0; v < _; v++) {
+    const w = v * a - y;
+    for (let u = 0; u < l; u++) {
+      const T = u * b - t;
+      p.push(T, -w, 0), c.push(0, 0, 1), f.push(u / x), f.push(1 - v / o);
+    }
+  }
+  for (let v = 0; v < o; v++)
+    for (let w = 0; w < x; w++) {
+      const u = w + l * v, T = w + l * (v + 1), A = w + 1 + l * (v + 1), C = w + 1 + l * v;
+      h.push(u, T, C), h.push(T, A, C);
+    }
+  const R = p.length / 3 > 65535, g = [];
+  for (let v = 0; v < h.length; v += 3) {
+    const w = h[v], u = h[v + 1], T = h[v + 2];
+    g.push(w, u, u, T, T, w);
+  }
+  return {
+    position: new Float32Array(p),
+    normal: new Float32Array(c),
+    uv: new Float32Array(f),
+    index: R ? new Uint32Array(h) : new Uint16Array(h),
+    wireframeIndex: R ? new Uint32Array(g) : new Uint16Array(g)
+  };
+}
+function ne(s, e, i) {
+  const r = [], t = [], y = [], x = [], o = Math.floor(e), l = Math.floor(i);
+  for (let a = 0; a <= l; a++) {
+    const h = a / l, p = h * Math.PI;
+    for (let c = 0; c <= o; c++) {
+      const f = c / o, R = f * Math.PI * 2, g = -s * Math.sin(p) * Math.cos(R), v = s * Math.cos(p), w = s * Math.sin(p) * Math.sin(R);
+      r.push(g, v, w);
+      const u = Math.sqrt(g * g + v * v + w * w);
+      t.push(g / u, v / u, w / u), y.push(f, 1 - h);
+    }
+  }
+  for (let a = 0; a < l; a++)
+    for (let h = 0; h < o; h++) {
+      const p = h + (o + 1) * a, c = h + (o + 1) * (a + 1), f = h + 1 + (o + 1) * (a + 1), R = h + 1 + (o + 1) * a;
+      x.push(p, c, R), x.push(c, f, R);
+    }
+  const _ = r.length / 3 > 65535, b = [];
+  for (let a = 0; a < x.length; a += 3) {
+    const h = x[a], p = x[a + 1], c = x[a + 2];
+    b.push(h, p, p, c, c, h);
+  }
+  return {
+    position: new Float32Array(r),
+    normal: new Float32Array(t),
+    uv: new Float32Array(y),
+    index: _ ? new Uint32Array(x) : new Uint16Array(x),
+    wireframeIndex: _ ? new Uint32Array(b) : new Uint16Array(b)
+  };
+}
+function ae(s, e, i, r) {
+  const t = [], y = [], x = [], o = [], l = Math.floor(i), _ = Math.floor(r);
+  for (let h = 0; h <= l; h++) {
+    const p = h / l * Math.PI * 2;
+    for (let c = 0; c <= _; c++) {
+      const f = c / _ * Math.PI * 2, R = (s + e * Math.cos(p)) * Math.cos(f), g = (s + e * Math.cos(p)) * Math.sin(f), v = e * Math.sin(p);
+      t.push(R, g, v);
+      const w = s * Math.cos(f), u = s * Math.sin(f), T = R - w, A = g - u, C = v, m = Math.sqrt(T * T + A * A + C * C);
+      y.push(T / m, A / m, C / m), x.push(c / _, h / l);
+    }
+  }
+  for (let h = 1; h <= l; h++)
+    for (let p = 1; p <= _; p++) {
+      const c = (_ + 1) * h + p - 1, f = (_ + 1) * (h - 1) + p - 1, R = (_ + 1) * (h - 1) + p, g = (_ + 1) * h + p;
+      o.push(c, f, g), o.push(f, R, g);
+    }
+  const b = t.length / 3 > 65535, a = [];
+  for (let h = 0; h < o.length; h += 3) {
+    const p = o[h], c = o[h + 1], f = o[h + 2];
+    a.push(p, c, c, f, f, p);
+  }
+  return {
+    position: new Float32Array(t),
+    normal: new Float32Array(y),
+    uv: new Float32Array(x),
+    index: b ? new Uint32Array(o) : new Uint16Array(o),
+    wireframeIndex: b ? new Uint32Array(a) : new Uint16Array(a)
+  };
 }
-function xe(a, e, i, o) {
-  const t = a / 2, b = e / 2, y = Math.floor(i), n = Math.floor(o), p = y + 1, v = n + 1, T = a / y, x = e / n, h = [], w = [], R = [], E = [];
-  for (let c = 0; c < v; c++) {
-    const l = c * x - b;
-    for (let m = 0; m < p; m++) {
-      const s = m * T - t;
-      w.push(s, -l, 0), R.push(0, 0, 1), E.push(m / y), E.push(1 - c / n);
+function le(s, e, i, r, t) {
+  const y = [], x = [], o = [], l = [], _ = Math.floor(r), b = Math.floor(t), a = i / 2;
+  for (let c = 0; c <= b; c++) {
+    const f = c / b, R = f * i - a, g = f * (e - s) + s;
+    for (let v = 0; v <= _; v++) {
+      const w = v / _, u = w * Math.PI * 2, T = Math.sin(u), A = Math.cos(u);
+      y.push(g * T, -R, g * A), x.push(T, 0, A), o.push(w, 1 - f);
     }
   }
-  for (let c = 0; c < n; c++)
-    for (let l = 0; l < y; l++) {
-      const m = l + p * c, s = l + p * (c + 1), f = l + 1 + p * (c + 1), _ = l + 1 + p * c;
-      h.push(m, s, _), h.push(s, f, _);
+  for (let c = 0; c < b; c++)
+    for (let f = 0; f < _; f++) {
+      const R = f + (_ + 1) * c, g = f + (_ + 1) * (c + 1), v = f + 1 + (_ + 1) * (c + 1), w = f + 1 + (_ + 1) * c;
+      l.push(R, g, w), l.push(g, v, w);
     }
-  const g = w.length / 3 > 65535, A = [];
-  for (let c = 0; c < h.length; c += 3) {
-    const l = h[c], m = h[c + 1], s = h[c + 2];
-    A.push(l, m, m, s, s, l);
+  const h = y.length / 3 > 65535, p = [];
+  for (let c = 0; c < l.length; c += 3) {
+    const f = l[c], R = l[c + 1], g = l[c + 2];
+    p.push(f, R, R, g, g, f);
   }
   return {
-    position: new Float32Array(w),
-    normal: new Float32Array(R),
-    uv: new Float32Array(E),
-    index: g ? new Uint32Array(h) : new Uint16Array(h),
-    wireframeIndex: g ? new Uint32Array(A) : new Uint16Array(A)
+    position: new Float32Array(y),
+    normal: new Float32Array(x),
+    uv: new Float32Array(o),
+    index: h ? new Uint32Array(l) : new Uint16Array(l),
+    wireframeIndex: h ? new Uint32Array(p) : new Uint16Array(p)
+  };
+}
+function ue(s, e, i, r, t, y) {
+  const x = s / 2, o = e / 2, l = Math.floor(i), _ = Math.floor(r), b = l + 1, a = _ + 1, h = s / l, p = e / _, c = [], f = [], R = [], g = [];
+  for (let u = 0; u < a; u++) {
+    const T = u * p - o;
+    for (let A = 0; A < b; A++) {
+      const C = A * h - x;
+      let m = C, F = T, D = 0, z = 0, M = 0, P = 1;
+      if (Math.abs(t) > 1e-3) {
+        const E = s / t, S = C / E;
+        m = E * Math.sin(S), D = E * (1 - Math.cos(S)), z = Math.sin(S), P = Math.cos(S);
+      }
+      if (Math.abs(y) > 1e-3) {
+        const E = T / e * y, S = Math.cos(E), U = Math.sin(E), B = m * S - D * U, W = m * U + D * S;
+        m = B, D = W;
+        const I = z * S - P * U, O = z * U + P * S;
+        z = I, P = O;
+      }
+      c.push(m, -F, D), f.push(z, M, P), R.push(A / l), R.push(1 - u / _);
+    }
+  }
+  for (let u = 0; u < _; u++)
+    for (let T = 0; T < l; T++) {
+      const A = T + b * u, C = T + b * (u + 1), m = T + 1 + b * (u + 1), F = T + 1 + b * u;
+      g.push(A, C, F), g.push(C, m, F);
+    }
+  const v = c.length / 3 > 65535, w = [];
+  for (let u = 0; u < g.length; u += 3) {
+    const T = g[u], A = g[u + 1], C = g[u + 2];
+    w.push(T, A, A, C, C, T);
+  }
+  return {
+    position: new Float32Array(c),
+    normal: new Float32Array(f),
+    uv: new Float32Array(R),
+    index: v ? new Uint32Array(g) : new Uint16Array(g),
+    wireframeIndex: v ? new Uint32Array(w) : new Uint16Array(w)
   };
 }
 console.info(
@@ -515,8 +733,8 @@ https://neat.firecms.co`,
   "font-weight: bold; font-size: 14px; color: #FF5772;",
   "color: inherit;"
 );
-const $ = 50, K = 80, O = 6, ye = Se();
-class Te {
+const N = 50, Y = 80, j = 6, pt = xt();
+class bt {
   _ref;
   _speed = -1;
   _horizontalPressure = -1;
@@ -533,6 +751,7 @@ class Te {
   _grainSparsity = -1;
   _grainSpeed = -1;
   _colorBlending = -1;
+  _resolution = 1;
   _colors = [];
   _wireframe = !1;
   _backgroundColor = "#FFFFFF";
@@ -552,6 +771,47 @@ class Te {
   _textureColorBlending = 0.01;
   _textureSeed = 333;
   _textureEase = 0.5;
+  _transparentTextureVoid = !1;
+  _domainWarpEnabled = !1;
+  _domainWarpIntensity = 0.5;
+  _domainWarpScale = 1;
+  _vignetteIntensity = 0.5;
+  _vignetteRadius = 0.8;
+  _fresnelEnabled = !1;
+  _fresnelPower = 2;
+  _fresnelIntensity = 0.5;
+  _fresnelColor = "#FFFFFF";
+  _fresnelColorRgb = [1, 1, 1];
+  _iridescenceEnabled = !1;
+  _iridescenceIntensity = 0.5;
+  _iridescenceSpeed = 1;
+  _bloomIntensity = 0;
+  _bloomThreshold = 0.7;
+  _chromaticAberration = 0;
+  _silhouetteFade = 0.25;
+  _cylinderFade = 0.08;
+  _ribbonFade = 0.05;
+  _shapeType = "plane";
+  _shapeRotationX = 0;
+  _shapeRotationY = 0;
+  _shapeRotationZ = 0;
+  _shapeAutoRotateSpeedX = 0;
+  _shapeAutoRotateSpeedY = 0;
+  _sphereRadius = 15;
+  _torusRadius = 15;
+  _torusTube = 5;
+  _cylinderRadius = 10;
+  _cylinderHeight = 40;
+  _planeBend = 0;
+  _planeTwist = 0;
+  _cameraLock = !1;
+  _cameraX = 0;
+  _cameraY = 0;
+  _cameraZ = 0;
+  _cameraRotationX = 0;
+  _cameraRotationY = 0;
+  _cameraRotationZ = 0;
+  _cameraZoom = 1;
   _proceduralTexture = null;
   _proceduralBackgroundColor = "#000000";
   _textureShapeTriangles = 20;
@@ -567,6 +827,10 @@ class Te {
   _yOffsetWaveMultiplier = 4e-3;
   _yOffsetColorMultiplier = 4e-3;
   _yOffsetFlowMultiplier = 4e-3;
+  _sourceCanvas = null;
+  _sourceCtx = null;
+  _maskedCanvas = null;
+  _maskedCtx = null;
   _resizeTimeoutId = null;
   _textureNeedsUpdate = !1;
   _linkCheckCounter = 0;
@@ -576,84 +840,139 @@ class Te {
   constructor(e) {
     const {
       ref: i,
-      speed: o = 4,
+      speed: r = 4,
       horizontalPressure: t = 3,
-      verticalPressure: b = 3,
-      waveFrequencyX: y = 5,
-      waveFrequencyY: n = 5,
-      waveAmplitude: p = 3,
-      colors: v,
-      highlights: T = 4,
-      shadows: x = 4,
+      verticalPressure: y = 3,
+      waveFrequencyX: x = 5,
+      waveFrequencyY: o = 5,
+      waveAmplitude: l = 3,
+      colors: _,
+      highlights: b = 4,
+      shadows: a = 4,
       colorSaturation: h = 0,
-      colorBrightness: w = 1,
-      colorBlending: R = 5,
-      grainScale: E = 2,
-      grainIntensity: g = 0.55,
-      grainSparsity: A = 0,
-      grainSpeed: c = 0.1,
-      wireframe: l = !1,
-      backgroundColor: m = "#FFFFFF",
-      backgroundAlpha: s = 1,
-      resolution: f = 1,
-      seed: _,
-      yOffset: d = 0,
-      yOffsetWaveMultiplier: z = 4,
-      yOffsetColorMultiplier: C = 4,
-      yOffsetFlowMultiplier: F = 4,
+      colorBrightness: p = 1,
+      colorBlending: c = 5,
+      grainScale: f = 2,
+      grainIntensity: R = 0.55,
+      grainSparsity: g = 0,
+      grainSpeed: v = 0.1,
+      wireframe: w = !1,
+      backgroundColor: u = "#FFFFFF",
+      backgroundAlpha: T = 1,
+      resolution: A = 1,
+      seed: C,
+      yOffset: m = 0,
+      yOffsetWaveMultiplier: F = 4,
+      yOffsetColorMultiplier: D = 4,
+      yOffsetFlowMultiplier: z = 4,
       flowDistortionA: M = 0,
-      flowDistortionB: N = 0,
-      flowScale: W = 1,
-      flowEase: D = 0,
-      flowEnabled: S = !0,
-      enableProceduralTexture: U = !1,
-      textureVoidLikelihood: Q = 0.45,
-      textureVoidWidthMin: ee = 200,
-      textureVoidWidthMax: te = 486,
-      textureBandDensity: ie = 2.15,
-      textureColorBlending: re = 0.01,
-      textureSeed: oe = 333,
-      textureEase: se = 0.5,
-      proceduralBackgroundColor: ne = "#000000",
-      textureShapeTriangles: ae = 20,
-      textureShapeCircles: le = 15,
-      textureShapeBars: ue = 15,
-      textureShapeSquiggles: fe = 10
+      flowDistortionB: P = 0,
+      flowScale: E = 1,
+      flowEase: S = 0,
+      flowEnabled: U = !0,
+      enableProceduralTexture: B = !1,
+      textureVoidLikelihood: W = 0.45,
+      textureVoidWidthMin: I = 200,
+      textureVoidWidthMax: O = 486,
+      textureBandDensity: fe = 2.15,
+      textureColorBlending: de = 0.01,
+      textureSeed: me = 333,
+      textureEase: pe = 0.5,
+      proceduralBackgroundColor: ge = "#000000",
+      transparentTextureVoid: ye = !1,
+      textureShapeTriangles: xe = 20,
+      textureShapeCircles: ve = 15,
+      textureShapeBars: be = 15,
+      textureShapeSquiggles: we = 10,
+      domainWarpEnabled: Se = !1,
+      domainWarpIntensity: Re = 0.5,
+      domainWarpScale: Te = 1,
+      vignetteIntensity: Ee = 0,
+      vignetteRadius: Ae = 0.8,
+      fresnelEnabled: Fe = !1,
+      fresnelPower: ze = 2,
+      fresnelIntensity: Ce = 0.5,
+      fresnelColor: Me = "#FFFFFF",
+      iridescenceEnabled: De = !1,
+      iridescenceIntensity: Pe = 0.5,
+      iridescenceSpeed: Ue = 1,
+      bloomIntensity: Ie = 0,
+      bloomThreshold: Be = 0.7,
+      chromaticAberration: Le = 0,
+      silhouetteFade: We = 0.25,
+      cylinderFade: Xe = 0.08,
+      ribbonFade: Ne = 0.05,
+      cameraLock: Ye = !1,
+      cameraX: Oe = 0,
+      cameraY: ke = 0,
+      cameraZ: Ve = 0,
+      cameraRotationX: qe = 0,
+      cameraRotationY: Ze = 0,
+      cameraRotationZ: Ge = 0,
+      cameraZoom: je = 1,
+      shapeType: He = "plane",
+      shapeRotationX: $e = 0,
+      shapeRotationY: Ke = 0,
+      shapeRotationZ: Je = 0,
+      shapeAutoRotateSpeedX: Qe = 0,
+      shapeAutoRotateSpeedY: et = 0,
+      sphereRadius: tt = 15,
+      torusRadius: it = 15,
+      torusTube: ot = 5,
+      cylinderRadius: rt = 10,
+      cylinderHeight: st = 40,
+      planeBend: nt = 0,
+      planeTwist: at = 0
     } = e;
-    this._ref = i, this.destroy = this.destroy.bind(this), this._initScene = this._initScene.bind(this), this.speed = o, this.horizontalPressure = t, this.verticalPressure = b, this.waveFrequencyX = y, this.waveFrequencyY = n, this.waveAmplitude = p, this.colorBlending = R, this.grainScale = E, this.grainIntensity = g, this.grainSparsity = A, this.grainSpeed = c, this.colors = v, this.shadows = x, this.highlights = T, this.colorSaturation = h, this.colorBrightness = w, this.wireframe = l, this.backgroundColor = m, this.backgroundAlpha = s, this.yOffset = d, this.yOffsetWaveMultiplier = z, this.yOffsetColorMultiplier = C, this.yOffsetFlowMultiplier = F, this.flowDistortionA = M, this.flowDistortionB = N, this.flowScale = W, this.flowEase = D, this.flowEnabled = S, this.enableProceduralTexture = U, this.textureVoidLikelihood = Q, this.textureVoidWidthMin = ee, this.textureVoidWidthMax = te, this.textureBandDensity = ie, this.textureColorBlending = re, this.textureSeed = oe, this.textureEase = se, this._proceduralBackgroundColor = ne, this._textureShapeTriangles = ae, this._textureShapeCircles = le, this._textureShapeBars = ue, this._textureShapeSquiggles = fe, this.glState = this._initScene(f), Ee();
-    let k = _ !== void 0 ? _ : we(), X = performance.now();
-    const q = () => {
-      const { gl: r, program: I, locations: u, indexCount: B, indexType: L } = this.glState;
-      if (this._linkCheckCounter++, this._linkCheckCounter >= 300 && (this._linkCheckCounter = 0, (!this._linkElement || !document.contains(this._linkElement)) && (this._linkElement = ve(i))), this._initialized) {
-        const V = performance.now();
-        if (k += (V - X) / 1e3 * this._speed, X = V, r.useProgram(I), r.uniform1f(u.uniforms.u_time, k), this._uniformsDirty && (r.uniform2f(u.uniforms.u_resolution, this._ref.clientWidth, this._ref.clientHeight), r.uniform2f(u.uniforms.u_color_pressure, this._horizontalPressure, this._verticalPressure), r.uniform1f(u.uniforms.u_wave_frequency_x, this._waveFrequencyX), r.uniform1f(u.uniforms.u_wave_frequency_y, this._waveFrequencyY), r.uniform1f(u.uniforms.u_wave_amplitude, this._waveAmplitude), r.uniform1f(u.uniforms.u_color_blending, this._colorBlending), r.uniform1f(u.uniforms.u_shadows, this._shadows), r.uniform1f(u.uniforms.u_highlights, this._highlights), r.uniform1f(u.uniforms.u_saturation, this._saturation), r.uniform1f(u.uniforms.u_brightness, this._brightness), r.uniform1f(u.uniforms.u_grain_intensity, this._grainIntensity), r.uniform1f(u.uniforms.u_grain_sparsity, this._grainSparsity), r.uniform1f(u.uniforms.u_grain_speed, this._grainSpeed), r.uniform1f(u.uniforms.u_grain_scale, this._grainScale), r.uniform1f(u.uniforms.u_y_offset, this._yOffset), r.uniform1f(u.uniforms.u_y_offset_wave_multiplier, this._yOffsetWaveMultiplier), r.uniform1f(u.uniforms.u_y_offset_color_multiplier, this._yOffsetColorMultiplier), r.uniform1f(u.uniforms.u_y_offset_flow_multiplier, this._yOffsetFlowMultiplier), r.uniform1f(u.uniforms.u_flow_distortion_a, this._flowDistortionA), r.uniform1f(u.uniforms.u_flow_distortion_b, this._flowDistortionB), r.uniform1f(u.uniforms.u_flow_scale, this._flowScale), r.uniform1f(u.uniforms.u_flow_ease, this._flowEase), r.uniform1f(u.uniforms.u_flow_enabled, this._flowEnabled ? 1 : 0), r.uniform1f(u.uniforms.u_enable_procedural_texture, this._enableProceduralTexture ? 1 : 0), r.uniform1f(u.uniforms.u_texture_ease, this._textureEase), this._uniformsDirty = !1), this._textureNeedsUpdate && this._enableProceduralTexture && (this._proceduralTexture && r.deleteTexture(this._proceduralTexture), this._proceduralTexture = this._createProceduralTexture(r), this._textureNeedsUpdate = !1, this._textureDirty = !0), this._textureDirty && this._proceduralTexture && (r.activeTexture(r.TEXTURE1), r.bindTexture(r.TEXTURE_2D, this._proceduralTexture), r.uniform1i(u.uniforms.u_procedural_texture, 1), this._textureDirty = !1), this._colorsChanged) {
+    this._ref = i, this.destroy = this.destroy.bind(this), this._initScene = this._initScene.bind(this), this.speed = r, this.horizontalPressure = t, this.verticalPressure = y, this.waveFrequencyX = x, this.waveFrequencyY = o, this.waveAmplitude = l, this.colorBlending = c, this._resolution = A, this.grainScale = f, this.grainIntensity = R, this.grainSparsity = g, this.grainSpeed = v, this.colors = _, this.shadows = a, this.highlights = b, this.colorSaturation = h, this.colorBrightness = p, this.wireframe = w, this.backgroundColor = u, this.backgroundAlpha = T, this.yOffset = m, this.yOffsetWaveMultiplier = F, this.yOffsetColorMultiplier = D, this.yOffsetFlowMultiplier = z, this.flowDistortionA = M, this.flowDistortionB = P, this.flowScale = E, this.flowEase = S, this.flowEnabled = U, this.enableProceduralTexture = B, this.textureVoidLikelihood = W, this.textureVoidWidthMin = I, this.textureVoidWidthMax = O, this.textureBandDensity = fe, this.textureColorBlending = de, this.textureSeed = me, this.textureEase = pe, this._proceduralBackgroundColor = ge, this.transparentTextureVoid = ye, this._textureShapeTriangles = xe, this._textureShapeCircles = ve, this._textureShapeBars = be, this._textureShapeSquiggles = we, this.domainWarpEnabled = Se, this.domainWarpIntensity = Re, this.domainWarpScale = Te, this.vignetteIntensity = Ee, this.vignetteRadius = Ae, this.fresnelEnabled = Fe, this.fresnelPower = ze, this.fresnelIntensity = Ce, this.fresnelColor = Me, this.iridescenceEnabled = De, this.iridescenceIntensity = Pe, this.iridescenceSpeed = Ue, this.bloomIntensity = Ie, this.bloomThreshold = Be, this.chromaticAberration = Le, this.silhouetteFade = We, this.cylinderFade = Xe, this.ribbonFade = Ne, this._cameraLock = Ye, this._cameraX = Oe, this._cameraY = ke, this._cameraZ = Ve, this._cameraRotationX = qe, this._cameraRotationY = Ze, this._cameraRotationZ = Ge, this._cameraZoom = je, this._shapeType = He, this._shapeRotationX = $e, this._shapeRotationY = Ke, this._shapeRotationZ = Je, this._shapeAutoRotateSpeedX = Qe, this._shapeAutoRotateSpeedY = et, this._sphereRadius = tt, this._torusRadius = it, this._torusTube = ot, this._cylinderRadius = rt, this._cylinderHeight = st, this._planeBend = nt, this._planeTwist = at, this.glState = this._initScene(A), vt();
+    let q = C !== void 0 ? C : yt(), K = performance.now();
+    const J = () => {
+      const { gl: n, program: Z, locations: d, indexCount: k, indexType: V } = this.glState;
+      if (this._linkCheckCounter++, this._linkCheckCounter >= 300 && (this._linkCheckCounter = 0, (!this._linkElement || !document.contains(this._linkElement)) && (this._linkElement = gt(i))), this._initialized) {
+        const Q = performance.now();
+        q += (Q - K) / 1e3 * this._speed, K = Q, n.useProgram(Z), n.uniform1f(d.uniforms.u_time, q);
+        const H = this.glState.camera, X = new he();
+        X.translate(
+          -H.position[0] - this._cameraX,
+          -H.position[1] - this._cameraY,
+          -H.position[2] - this._cameraZ
+        ), X.translate(0, 0, -1), X.rotateX(-this._cameraRotationX), X.rotateY(-this._cameraRotationY), X.rotateZ(-this._cameraRotationZ);
+        let $ = this._shapeRotationX, ee = this._shapeRotationY, ut = this._shapeRotationZ;
+        this._shapeAutoRotateSpeedX !== 0 && ($ += q * this._shapeAutoRotateSpeedX * 0.1), this._shapeAutoRotateSpeedY !== 0 && (ee += q * this._shapeAutoRotateSpeedY * 0.1), this._shapeType === "plane" || this._shapeType === "ribbon" ? X.rotateX($ - Math.PI / 3.5) : X.rotateX($), X.rotateY(ee), X.rotateZ(ut);
+        const te = d.uniforms.modelViewMatrix;
+        if (te && n.uniformMatrix4fv(te, !1, X.elements), this._uniformsDirty) {
+          n.uniform2f(d.uniforms.u_resolution, this._ref.clientWidth, this._ref.clientHeight), n.uniform2f(d.uniforms.u_color_pressure, this._horizontalPressure, this._verticalPressure), n.uniform1f(d.uniforms.u_wave_frequency_x, this._waveFrequencyX), n.uniform1f(d.uniforms.u_wave_frequency_y, this._waveFrequencyY), n.uniform1f(d.uniforms.u_wave_amplitude, this._waveAmplitude), n.uniform1f(d.uniforms.u_color_blending, this._colorBlending), n.uniform1f(d.uniforms.u_shadows, this._shadows), n.uniform1f(d.uniforms.u_highlights, this._highlights), n.uniform1f(d.uniforms.u_saturation, this._saturation), n.uniform1f(d.uniforms.u_brightness, this._brightness), n.uniform1f(d.uniforms.u_grain_intensity, this._grainIntensity), n.uniform1f(d.uniforms.u_grain_sparsity, this._grainSparsity), n.uniform1f(d.uniforms.u_grain_speed, this._grainSpeed), n.uniform1f(d.uniforms.u_grain_scale, this._grainScale), n.uniform1f(d.uniforms.u_y_offset, this._yOffset), n.uniform1f(d.uniforms.u_y_offset_wave_multiplier, this._yOffsetWaveMultiplier), n.uniform1f(d.uniforms.u_y_offset_color_multiplier, this._yOffsetColorMultiplier), n.uniform1f(d.uniforms.u_y_offset_flow_multiplier, this._yOffsetFlowMultiplier), n.uniform1f(d.uniforms.u_flow_distortion_a, this._flowDistortionA), n.uniform1f(d.uniforms.u_flow_distortion_b, this._flowDistortionB), n.uniform1f(d.uniforms.u_flow_scale, this._flowScale), n.uniform1f(d.uniforms.u_flow_ease, this._flowEase), n.uniform1f(d.uniforms.u_flow_enabled, this._flowEnabled ? 1 : 0);
+          let L = 0;
+          this._shapeType === "sphere" ? L = 1 : this._shapeType === "torus" ? L = 2 : this._shapeType === "cylinder" ? L = 3 : this._shapeType === "ribbon" && (L = 4), n.uniform1f(d.uniforms.u_shape_type, L), n.uniform1f(d.uniforms.u_enable_procedural_texture, this._enableProceduralTexture ? 1 : 0), n.uniform1f(d.uniforms.u_texture_ease, this._textureEase), n.uniform1f(d.uniforms.u_transparent_texture_void, this._transparentTextureVoid ? 1 : 0), n.uniform1f(d.uniforms.u_domain_warp_enabled, this._domainWarpEnabled ? 1 : 0), n.uniform1f(d.uniforms.u_domain_warp_intensity, this._domainWarpIntensity), n.uniform1f(d.uniforms.u_domain_warp_scale, this._domainWarpScale), n.uniform1f(d.uniforms.u_vignette_intensity, this._vignetteIntensity), n.uniform1f(d.uniforms.u_vignette_radius, this._vignetteRadius), n.uniform1f(d.uniforms.u_fresnel_enabled, this._fresnelEnabled ? 1 : 0), n.uniform1f(d.uniforms.u_fresnel_power, this._fresnelPower), n.uniform1f(d.uniforms.u_fresnel_intensity, this._fresnelIntensity), n.uniform3fv(d.uniforms.u_fresnel_color, this._fresnelColorRgb), n.uniform1f(d.uniforms.u_iridescence_enabled, this._iridescenceEnabled ? 1 : 0), n.uniform1f(d.uniforms.u_iridescence_intensity, this._iridescenceIntensity), n.uniform1f(d.uniforms.u_iridescence_speed, this._iridescenceSpeed), n.uniform1f(d.uniforms.u_bloom_intensity, this._bloomIntensity), n.uniform1f(d.uniforms.u_bloom_threshold, this._bloomThreshold), n.uniform1f(d.uniforms.u_chromatic_aberration, this._chromaticAberration), n.uniform1f(d.uniforms.u_silhouette_fade, this._silhouetteFade), n.uniform1f(d.uniforms.u_cylinder_fade, this._cylinderFade), n.uniform1f(d.uniforms.u_ribbon_fade, this._ribbonFade), this._uniformsDirty = !1;
+        }
+        if (this._textureNeedsUpdate && this._enableProceduralTexture && (this._proceduralTexture && n.deleteTexture(this._proceduralTexture), this._proceduralTexture = this._createProceduralTexture(n), this._textureNeedsUpdate = !1, this._textureDirty = !0), this._textureDirty && this._proceduralTexture && (n.activeTexture(n.TEXTURE1), n.bindTexture(n.TEXTURE_2D, this._proceduralTexture), n.uniform1i(d.uniforms.u_procedural_texture, 1), this._textureDirty = !1), this._colorsChanged) {
           this._colorsChanged = !1;
-          for (let P = 0; P < O; P++)
-            if (P < this._colors.length) {
-              const G = this._colors[P], _e = this._cachedColorRgb[P] || [0, 0, 0];
-              r.uniform1f(u.uniforms[`u_colors[${P}].is_active`], G.enabled ? 1 : 0), r.uniform3fv(u.uniforms[`u_colors[${P}].color`], _e), r.uniform1f(u.uniforms[`u_colors[${P}].influence`], G.influence || 0);
+          for (let L = 0; L < j; L++)
+            if (L < this._colors.length) {
+              const ie = this._colors[L], _t = this._cachedColorRgb[L] || [0, 0, 0];
+              n.uniform1f(d.uniforms[`u_colors[${L}].is_active`], ie.enabled ? 1 : 0), n.uniform3fv(d.uniforms[`u_colors[${L}].color`], _t), n.uniform1f(d.uniforms[`u_colors[${L}].influence`], ie.influence || 0);
             } else
-              r.uniform1f(u.uniforms[`u_colors[${P}].is_active`], 0);
-          r.uniform1i(u.uniforms.u_colors_count, O);
+              n.uniform1f(d.uniforms[`u_colors[${L}].is_active`], 0);
+          n.uniform1i(d.uniforms.u_colors_count, j);
         }
       }
-      r.clearColor(
+      n.clearColor(
         this._backgroundColorRgb[0],
         this._backgroundColorRgb[1],
         this._backgroundColorRgb[2],
         this._backgroundAlpha
-      ), r.clear(r.COLOR_BUFFER_BIT | r.DEPTH_BUFFER_BIT), this._wireframe ? (r.bindBuffer(r.ELEMENT_ARRAY_BUFFER, this.glState.buffers.wireframeIndex), r.drawElements(r.LINES, this.glState.wireframeIndexCount, L, 0), r.bindBuffer(r.ELEMENT_ARRAY_BUFFER, this.glState.buffers.index)) : r.drawElements(r.TRIANGLES, B, L, 0), this.requestRef = requestAnimationFrame(q);
-    }, ce = () => {
-      const { gl: r, camera: I } = this.glState, u = this._ref.clientWidth, B = this._ref.clientHeight;
-      this._ref.width = u, this._ref.height = B, r.viewport(0, 0, u, B), H(I, u, B);
-      const L = r.getUniformLocation(this.glState.program, "projectionMatrix");
-      r.useProgram(this.glState.program), r.uniformMatrix4fv(L, !1, I.projectionMatrix.elements);
+      ), n.clear(n.COLOR_BUFFER_BIT | n.DEPTH_BUFFER_BIT), this._wireframe ? (n.bindBuffer(n.ELEMENT_ARRAY_BUFFER, this.glState.buffers.wireframeIndex), n.drawElements(n.LINES, this.glState.wireframeIndexCount, V, 0), n.bindBuffer(n.ELEMENT_ARRAY_BUFFER, this.glState.buffers.index)) : n.drawElements(n.TRIANGLES, k, V, 0), this.requestRef = requestAnimationFrame(J);
+    }, lt = () => {
+      const { gl: n, camera: Z } = this.glState, d = this._ref.clientWidth, k = this._ref.clientHeight;
+      this._ref.width = d, this._ref.height = k, n.viewport(0, 0, d, k), G(Z, d, k, N, Y, this._shapeType, this._cameraZoom);
+      const V = this.glState.locations.uniforms.projectionMatrix;
+      n.useProgram(this.glState.program), V && n.uniformMatrix4fv(V, !1, Z.projectionMatrix.elements);
     };
     this.sizeObserver = new ResizeObserver(() => {
       this._resizeTimeoutId !== null && clearTimeout(this._resizeTimeoutId), this._resizeTimeoutId = window.setTimeout(() => {
-        ce(), this._resizeTimeoutId = null;
+        lt(), this._resizeTimeoutId = null;
       }, 100);
-    }), this.sizeObserver.observe(i), q();
+    }), this.sizeObserver.observe(i), J();
   }
   destroy() {
     if (cancelAnimationFrame(this.requestRef), this.sizeObserver.disconnect(), this._resizeTimeoutId !== null && (clearTimeout(this._resizeTimeoutId), this._resizeTimeoutId = null), this._linkElement && this._linkElement.parentElement && (this._linkElement.parentElement.removeChild(this._linkElement), this._linkElement = null), this.glState) {
@@ -664,72 +983,191 @@ class Te {
   }
   downloadAsPNG(e = "neat.png") {
     const i = this._ref.toDataURL("image/png");
-    be(i, e);
+    ce(i, e);
+  }
+  recordVideo(e = {}) {
+    const {
+      durationMs: i = 5e3,
+      filename: r = "neat.firecms.co",
+      format: t,
+      onProgress: y,
+      onComplete: x
+    } = e, o = this._ref, l = e.width || o.width || o.clientWidth, _ = e.height || o.height || o.clientHeight, b = document.createElement("canvas");
+    b.width = l, b.height = _;
+    const a = b.getContext("2d"), h = b.captureStream(0), p = h.getVideoTracks()[0], c = [
+      "video/mp4;codecs=avc1",
+      "video/mp4;codecs=avc1,opus",
+      "video/mp4"
+    ], f = [
+      "video/webm;codecs=vp9,opus",
+      "video/webm;codecs=vp9",
+      "video/webm;codecs=vp8,opus",
+      "video/webm"
+    ];
+    let R;
+    t === "mp4" ? R = [...c, ...f] : t === "webm" ? R = [...f, ...c] : R = [...c, ...f];
+    let g = "video/webm";
+    for (const E of R)
+      if (MediaRecorder.isTypeSupported(E)) {
+        g = E;
+        break;
+      }
+    const v = l * _, w = 8e6, u = 1280 * 720, T = Math.round(w * Math.max(1, v / u)), A = new MediaRecorder(h, {
+      mimeType: g,
+      videoBitsPerSecond: T
+    }), C = [];
+    A.ondataavailable = (E) => {
+      E.data.size > 0 && C.push(E.data);
+    };
+    let m = !1, F;
+    const D = performance.now();
+    let z = 0;
+    const M = () => {
+      if (m)
+        return;
+      a.clearRect(0, 0, l, _), a.drawImage(o, 0, 0, l, _);
+      const E = Math.max(14, Math.round(_ * 0.025));
+      if (a.font = `bold ${E}px "Sofia Sans", sans-serif`, a.textAlign = "right", a.textBaseline = "bottom", a.shadowColor = "rgba(0,0,0,0.5)", a.shadowBlur = 4, a.shadowOffsetX = 1, a.shadowOffsetY = 1, a.fillStyle = "rgba(255,255,255,0.7)", a.fillText("NEAT", l - E * 0.8, _ - E * 0.5), a.shadowColor = "transparent", a.shadowBlur = 0, a.shadowOffsetX = 0, a.shadowOffsetY = 0, p.requestFrame && p.requestFrame(), y) {
+        const S = performance.now();
+        S - z > 250 && (z = S, y(Math.min(0.99, (S - D) / i)));
+      }
+      F = requestAnimationFrame(M);
+    };
+    A.onstop = () => {
+      m = !0, cancelAnimationFrame(F);
+      const E = g.startsWith("video/mp4"), S = E ? ".mp4" : ".webm", U = E ? "video/mp4" : "video/webm", B = r + S, W = new Blob(C, { type: U }), I = URL.createObjectURL(W);
+      ce(I, B), setTimeout(() => URL.revokeObjectURL(I), 3e4), y?.(1), x?.();
+    }, M(), A.start(100);
+    const P = window.setTimeout(() => {
+      A.state === "recording" && A.stop();
+    }, i);
+    return () => {
+      clearTimeout(P), A.state === "recording" && A.stop();
+    };
+  }
+  get speed() {
+    return this._speed * 20;
   }
   set speed(e) {
     this._uniformsDirty = !0, this._speed = e / 20;
   }
+  get horizontalPressure() {
+    return this._horizontalPressure * 4;
+  }
   set horizontalPressure(e) {
     this._uniformsDirty = !0, this._horizontalPressure = e / 4;
   }
+  get verticalPressure() {
+    return this._verticalPressure * 4;
+  }
   set verticalPressure(e) {
     this._uniformsDirty = !0, this._verticalPressure = e / 4;
   }
+  get waveFrequencyX() {
+    return this._waveFrequencyX / 0.04;
+  }
   set waveFrequencyX(e) {
     this._uniformsDirty = !0, this._waveFrequencyX = e * 0.04;
   }
+  get waveFrequencyY() {
+    return this._waveFrequencyY / 0.04;
+  }
   set waveFrequencyY(e) {
     this._uniformsDirty = !0, this._waveFrequencyY = e * 0.04;
   }
+  get waveAmplitude() {
+    return this._waveAmplitude / 0.75;
+  }
   set waveAmplitude(e) {
     this._uniformsDirty = !0, this._waveAmplitude = e * 0.75;
   }
+  get colors() {
+    return this._colors;
+  }
   set colors(e) {
     this._uniformsDirty = !0, this._colors = e, this._cachedColorRgb = e.map((i) => this._hexToRgb(i.color)), this._colorsChanged = !0;
   }
+  get highlights() {
+    return this._highlights * 100;
+  }
   set highlights(e) {
     this._uniformsDirty = !0, this._highlights = e / 100;
   }
+  get shadows() {
+    return this._shadows * 100;
+  }
   set shadows(e) {
     this._uniformsDirty = !0, this._shadows = e / 100;
   }
+  get colorSaturation() {
+    return this._saturation * 10;
+  }
   set colorSaturation(e) {
     this._uniformsDirty = !0, this._saturation = e / 10;
   }
+  get colorBrightness() {
+    return this._brightness;
+  }
   set colorBrightness(e) {
     this._uniformsDirty = !0, this._brightness = e;
   }
+  get colorBlending() {
+    return this._colorBlending * 10;
+  }
   set colorBlending(e) {
     this._uniformsDirty = !0, this._colorBlending = e / 10;
   }
+  get grainScale() {
+    return this._grainScale;
+  }
   set grainScale(e) {
     this._uniformsDirty = !0, this._grainScale = e == 0 ? 1 : e;
   }
+  get grainIntensity() {
+    return this._grainIntensity;
+  }
   set grainIntensity(e) {
     this._uniformsDirty = !0, this._grainIntensity = e;
   }
+  get grainSparsity() {
+    return this._grainSparsity;
+  }
   set grainSparsity(e) {
     this._uniformsDirty = !0, this._grainSparsity = e;
   }
+  get grainSpeed() {
+    return this._grainSpeed;
+  }
   set grainSpeed(e) {
     this._uniformsDirty = !0, this._grainSpeed = e;
   }
+  get wireframe() {
+    return this._wireframe;
+  }
   set wireframe(e) {
     this._uniformsDirty = !0, this._wireframe = e;
   }
+  get resolution() {
+    return this._resolution;
+  }
   set resolution(e) {
-    if (this._uniformsDirty = !0, this.glState) {
-      const i = this.glState.gl;
-      i.deleteProgram(this.glState.program), i.deleteBuffer(this.glState.buffers.position), i.deleteBuffer(this.glState.buffers.normal), i.deleteBuffer(this.glState.buffers.uv), i.deleteBuffer(this.glState.buffers.index), i.deleteBuffer(this.glState.buffers.wireframeIndex);
-    }
-    this.glState = this._initScene(e);
+    this._resolution !== e && (this._resolution = e, this._updateGeometry());
+  }
+  get backgroundColor() {
+    return this._backgroundColor;
   }
   set backgroundColor(e) {
     this._uniformsDirty = !0, this._backgroundColor = e, this._backgroundColorRgb = this._hexToRgb(e);
   }
+  get backgroundAlpha() {
+    return this._backgroundAlpha;
+  }
   set backgroundAlpha(e) {
     this._uniformsDirty = !0, this._backgroundAlpha = e;
   }
+  get yOffset() {
+    return this._yOffset;
+  }
   set yOffset(e) {
     this._uniformsDirty = !0, this._yOffset = e;
   }
@@ -751,15 +1189,27 @@ class Te {
   set yOffsetFlowMultiplier(e) {
     this._uniformsDirty = !0, this._yOffsetFlowMultiplier = e / 1e3;
   }
+  get flowDistortionA() {
+    return this._flowDistortionA;
+  }
   set flowDistortionA(e) {
     this._uniformsDirty = !0, this._flowDistortionA = e;
   }
+  get flowDistortionB() {
+    return this._flowDistortionB;
+  }
   set flowDistortionB(e) {
     this._uniformsDirty = !0, this._flowDistortionB = e;
   }
+  get flowScale() {
+    return this._flowScale;
+  }
   set flowScale(e) {
     this._uniformsDirty = !0, this._flowScale = e;
   }
+  get flowEase() {
+    return this._flowEase;
+  }
   set flowEase(e) {
     this._uniformsDirty = !0, this._flowEase = e;
   }
@@ -769,24 +1219,45 @@ class Te {
   get flowEnabled() {
     return this._flowEnabled;
   }
+  get enableProceduralTexture() {
+    return this._enableProceduralTexture;
+  }
   set enableProceduralTexture(e) {
     this._uniformsDirty = !0, this._enableProceduralTexture = e, e && !this._proceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  get textureVoidLikelihood() {
+    return this._textureVoidLikelihood;
+  }
   set textureVoidLikelihood(e) {
     this._uniformsDirty = !0, this._textureVoidLikelihood = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  get textureVoidWidthMin() {
+    return this._textureVoidWidthMin;
+  }
   set textureVoidWidthMin(e) {
     this._uniformsDirty = !0, this._textureVoidWidthMin = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  get textureVoidWidthMax() {
+    return this._textureVoidWidthMax;
+  }
   set textureVoidWidthMax(e) {
     this._uniformsDirty = !0, this._textureVoidWidthMax = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  get textureBandDensity() {
+    return this._textureBandDensity;
+  }
   set textureBandDensity(e) {
     this._uniformsDirty = !0, this._textureBandDensity = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  get textureColorBlending() {
+    return this._textureColorBlending;
+  }
   set textureColorBlending(e) {
     this._uniformsDirty = !0, this._textureColorBlending = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  get textureSeed() {
+    return this._textureSeed;
+  }
   set textureSeed(e) {
     this._uniformsDirty = !0, this._textureSeed = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
@@ -796,21 +1267,55 @@ class Te {
   set textureEase(e) {
     this._uniformsDirty = !0, this._textureEase = e;
   }
+  get transparentTextureVoid() {
+    return this._transparentTextureVoid;
+  }
+  set transparentTextureVoid(e) {
+    this._uniformsDirty = !0, this._transparentTextureVoid = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
+  }
+  get proceduralBackgroundColor() {
+    return this._proceduralBackgroundColor;
+  }
   set proceduralBackgroundColor(e) {
     this._uniformsDirty = !0, this._proceduralBackgroundColor = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  get textureShapeTriangles() {
+    return this._textureShapeTriangles;
+  }
   set textureShapeTriangles(e) {
     this._uniformsDirty = !0, this._textureShapeTriangles = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  get textureShapeCircles() {
+    return this._textureShapeCircles;
+  }
   set textureShapeCircles(e) {
     this._uniformsDirty = !0, this._textureShapeCircles = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  get textureShapeBars() {
+    return this._textureShapeBars;
+  }
   set textureShapeBars(e) {
     this._uniformsDirty = !0, this._textureShapeBars = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  get textureShapeSquiggles() {
+    return this._textureShapeSquiggles;
+  }
   set textureShapeSquiggles(e) {
     this._uniformsDirty = !0, this._textureShapeSquiggles = e, this._enableProceduralTexture && (this._textureNeedsUpdate = !0);
   }
+  _updateGeometry() {
+    if (!this.glState)
+      return;
+    const e = this.glState.gl, i = this._resolution || 1;
+    let r;
+    this._shapeType === "sphere" ? r = ne(this._sphereRadius, 120 * i, 120 * i) : this._shapeType === "torus" ? r = ae(this._torusRadius, this._torusTube, 120 * i, 120 * i) : this._shapeType === "cylinder" ? r = le(this._cylinderRadius, this._cylinderRadius, this._cylinderHeight, 120 * i, 120 * i) : this._shapeType === "ribbon" ? r = ue(N, Y, 240 * i, 240 * i, this._planeBend, this._planeTwist) : r = se(N, Y, 240 * i, 240 * i);
+    const { position: t, normal: y, uv: x, index: o, wireframeIndex: l } = r;
+    e.bindBuffer(e.ARRAY_BUFFER, this.glState.buffers.position), e.bufferData(e.ARRAY_BUFFER, t, e.STATIC_DRAW), e.bindBuffer(e.ARRAY_BUFFER, this.glState.buffers.normal), e.bufferData(e.ARRAY_BUFFER, y, e.STATIC_DRAW), e.bindBuffer(e.ARRAY_BUFFER, this.glState.buffers.uv), e.bufferData(e.ARRAY_BUFFER, x, e.STATIC_DRAW), e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, this.glState.buffers.index), e.bufferData(e.ELEMENT_ARRAY_BUFFER, o, e.STATIC_DRAW), e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, this.glState.buffers.wireframeIndex), e.bufferData(e.ELEMENT_ARRAY_BUFFER, l, e.STATIC_DRAW), e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, this.glState.buffers.index), this.glState.indexCount = o.length, this.glState.wireframeIndexCount = l.length, this.glState.indexType = o instanceof Uint32Array ? e.UNSIGNED_INT : e.UNSIGNED_SHORT;
+    const _ = this._ref.clientWidth, b = this._ref.clientHeight;
+    G(this.glState.camera, _, b, N, Y, this._shapeType, this._cameraZoom);
+    const a = this.glState.locations.uniforms.projectionMatrix;
+    e.useProgram(this.glState.program), a && e.uniformMatrix4fv(a, !1, this.glState.camera.projectionMatrix.elements), this._uniformsDirty = !0;
+  }
   _hexToRgb(e) {
     const i = parseInt(e.replace("#", ""), 16);
     return [
@@ -820,53 +1325,53 @@ class Te {
     ];
   }
   _initScene(e) {
-    const i = this._ref.clientWidth, o = this._ref.clientHeight, t = this._ref.getContext("webgl2", { alpha: !0, preserveDrawingBuffer: !0, antialias: !0 }) || this._ref.getContext("webgl", { alpha: !0, preserveDrawingBuffer: !0, antialias: !0 });
+    const i = this._ref.clientWidth, r = this._ref.clientHeight, t = this._ref.getContext("webgl2", { alpha: !0, preserveDrawingBuffer: !0, antialias: !0 }) || this._ref.getContext("webgl", { alpha: !0, preserveDrawingBuffer: !0, antialias: !0 });
     if (!t)
       throw new Error("WebGL not supported");
-    t.getExtension("OES_standard_derivatives"), t.getExtension("OES_element_index_uint"), t.viewport(0, 0, i, o);
-    const { position: b, normal: y, uv: n, index: p, wireframeIndex: v } = xe($, K, 240 * e, 240 * e), T = t.createBuffer();
-    t.bindBuffer(t.ARRAY_BUFFER, T), t.bufferData(t.ARRAY_BUFFER, b, t.STATIC_DRAW);
-    const x = t.createBuffer();
-    t.bindBuffer(t.ARRAY_BUFFER, x), t.bufferData(t.ARRAY_BUFFER, y, t.STATIC_DRAW);
+    t.getExtension("OES_standard_derivatives"), t.getExtension("OES_element_index_uint"), t.viewport(0, 0, i, r);
+    let y;
+    this._shapeType === "sphere" ? y = ne(this._sphereRadius, 120 * e, 120 * e) : this._shapeType === "torus" ? y = ae(this._torusRadius, this._torusTube, 120 * e, 120 * e) : this._shapeType === "cylinder" ? y = le(this._cylinderRadius, this._cylinderRadius, this._cylinderHeight, 120 * e, 120 * e) : this._shapeType === "ribbon" ? y = ue(N, Y, 240 * e, 240 * e, this._planeBend, this._planeTwist) : y = se(N, Y, 240 * e, 240 * e);
+    const { position: x, normal: o, uv: l, index: _, wireframeIndex: b } = y, a = t.createBuffer();
+    t.bindBuffer(t.ARRAY_BUFFER, a), t.bufferData(t.ARRAY_BUFFER, x, t.STATIC_DRAW);
     const h = t.createBuffer();
-    t.bindBuffer(t.ARRAY_BUFFER, h), t.bufferData(t.ARRAY_BUFFER, n, t.STATIC_DRAW);
-    const w = t.createBuffer();
-    t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, w), t.bufferData(t.ELEMENT_ARRAY_BUFFER, p, t.STATIC_DRAW);
-    const R = t.createBuffer();
-    t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, R), t.bufferData(t.ELEMENT_ARRAY_BUFFER, v, t.STATIC_DRAW), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, w);
-    const E = me() + `
-` + Y() + `
-` + j() + `
-` + he, g = t.createShader(t.VERTEX_SHADER);
-    t.shaderSource(g, E), t.compileShader(g), t.getShaderParameter(g, t.COMPILE_STATUS) || (console.log("VERTEX_SHADER_ERROR_START"), console.log("Vertex shader error: ", t.getShaderInfoLog(g)), console.log("GL Error Code:", t.getError()), console.log("Vertex Shader Source Dump:"), console.log(E.split(`
+    t.bindBuffer(t.ARRAY_BUFFER, h), t.bufferData(t.ARRAY_BUFFER, o, t.STATIC_DRAW);
+    const p = t.createBuffer();
+    t.bindBuffer(t.ARRAY_BUFFER, p), t.bufferData(t.ARRAY_BUFFER, l, t.STATIC_DRAW);
+    const c = t.createBuffer();
+    t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, c), t.bufferData(t.ELEMENT_ARRAY_BUFFER, _, t.STATIC_DRAW);
+    const f = t.createBuffer();
+    t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, f), t.bufferData(t.ELEMENT_ARRAY_BUFFER, b, t.STATIC_DRAW), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, c);
+    const R = ft() + `
+` + oe() + `
+` + re() + `
+` + ct, g = t.createShader(t.VERTEX_SHADER);
+    t.shaderSource(g, R), t.compileShader(g), t.getShaderParameter(g, t.COMPILE_STATUS) || (console.log("VERTEX_SHADER_ERROR_START"), console.log("Vertex shader error: ", t.getShaderInfoLog(g)), console.log("GL Error Code:", t.getError()), console.log("Vertex Shader Source Dump:"), console.log(R.split(`
 `).map((S, U) => `${U + 1}: ${S}`).join(`
 `)), console.log("VERTEX_SHADER_ERROR_END"));
-    const A = pe() + `
-` + j() + `
-` + Y() + `
-` + de, c = t.createShader(t.FRAGMENT_SHADER);
-    t.shaderSource(c, A), t.compileShader(c), t.getShaderParameter(c, t.COMPILE_STATUS) || (console.log("FRAGMENT_SHADER_ERROR_START"), console.log("Fragment shader error: ", t.getShaderInfoLog(c)), console.log("GL Error Code:", t.getError()), console.log("Fragment Shader Source Dump:"), console.log(A.split(`
+    const v = dt() + `
+` + re() + `
+` + oe() + `
+` + ht, w = t.createShader(t.FRAGMENT_SHADER);
+    t.shaderSource(w, v), t.compileShader(w), t.getShaderParameter(w, t.COMPILE_STATUS) || (console.log("FRAGMENT_SHADER_ERROR_START"), console.log("Fragment shader error: ", t.getShaderInfoLog(w)), console.log("GL Error Code:", t.getError()), console.log("Fragment Shader Source Dump:"), console.log(v.split(`
 `).map((S, U) => `${U + 1}: ${S}`).join(`
 `)), console.log("FRAGMENT_SHADER_ERROR_END"));
-    const l = t.createProgram();
-    t.attachShader(l, g), t.attachShader(l, c), t.linkProgram(l), t.getProgramParameter(l, t.LINK_STATUS) || (console.log("PROGRAM_LINK_ERROR_START"), console.log("Program linking error: ", t.getProgramInfoLog(l)), console.log("GL Error Code:", t.getError()), console.log("PROGRAM_LINK_ERROR_END")), t.useProgram(l);
-    const m = new ge(0, 0, 0, 0, 0, 1e3);
-    m.position = [0, 0, 5], H(m, i, o);
-    const s = t.getAttribLocation(l, "position"), f = t.getAttribLocation(l, "normal"), _ = t.getAttribLocation(l, "uv");
-    t.enableVertexAttribArray(s), t.bindBuffer(t.ARRAY_BUFFER, T), t.vertexAttribPointer(s, 3, t.FLOAT, !1, 0, 0), t.enableVertexAttribArray(f), t.bindBuffer(t.ARRAY_BUFFER, x), t.vertexAttribPointer(f, 3, t.FLOAT, !1, 0, 0), t.enableVertexAttribArray(_), t.bindBuffer(t.ARRAY_BUFFER, h), t.vertexAttribPointer(_, 2, t.FLOAT, !1, 0, 0), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, w);
-    const d = new J();
-    d.translate(-m.position[0], -m.position[1], -m.position[2]), d.translate(0, 0, -1), d.rotateX(-Math.PI / 3.5);
-    const z = t.getUniformLocation(l, "modelViewMatrix");
-    t.uniformMatrix4fv(z, !1, d.elements);
-    const C = t.getUniformLocation(l, "projectionMatrix");
-    t.uniformMatrix4fv(C, !1, m.projectionMatrix.elements);
-    const F = t.getUniformLocation(l, "u_plane_width");
-    t.uniform1f(F, $);
-    const M = t.getUniformLocation(l, "u_plane_height");
-    t.uniform1f(M, K);
-    const N = t.getUniformLocation(l, "u_colors_count");
-    t.uniform1i(N, O);
-    const W = [
+    const u = t.createProgram();
+    t.attachShader(u, g), t.attachShader(u, w), t.linkProgram(u), t.getProgramParameter(u, t.LINK_STATUS) || (console.log("PROGRAM_LINK_ERROR_START"), console.log("Program linking error: ", t.getProgramInfoLog(u)), console.log("GL Error Code:", t.getError()), console.log("PROGRAM_LINK_ERROR_END")), t.useProgram(u);
+    const T = new mt(0, 0, 0, 0, 0, 1e3);
+    T.position = [0, 0, 5], G(T, i, r, N, Y, this._shapeType, this._cameraZoom);
+    const A = t.getAttribLocation(u, "position"), C = t.getAttribLocation(u, "normal"), m = t.getAttribLocation(u, "uv");
+    t.enableVertexAttribArray(A), t.bindBuffer(t.ARRAY_BUFFER, a), t.vertexAttribPointer(A, 3, t.FLOAT, !1, 0, 0), t.enableVertexAttribArray(C), t.bindBuffer(t.ARRAY_BUFFER, h), t.vertexAttribPointer(C, 3, t.FLOAT, !1, 0, 0), t.enableVertexAttribArray(m), t.bindBuffer(t.ARRAY_BUFFER, p), t.vertexAttribPointer(m, 2, t.FLOAT, !1, 0, 0), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, c);
+    const F = t.getUniformLocation(u, "projectionMatrix");
+    t.uniformMatrix4fv(F, !1, T.projectionMatrix.elements);
+    const D = t.getUniformLocation(u, "u_plane_width");
+    t.uniform1f(D, N);
+    const z = t.getUniformLocation(u, "u_plane_height");
+    t.uniform1f(z, Y);
+    const M = t.getUniformLocation(u, "u_colors_count");
+    t.uniform1i(M, j);
+    const P = [
+      "projectionMatrix",
+      "modelViewMatrix",
       "u_time",
       "u_resolution",
       "u_color_pressure",
@@ -894,178 +1399,463 @@ class Te {
       "u_procedural_texture",
       "u_enable_procedural_texture",
       "u_texture_ease",
+      "u_transparent_texture_void",
       "u_saturation",
       "u_brightness",
-      "u_color_blending"
-    ], D = {
-      attributes: { position: s, normal: f, uv: _ },
+      "u_color_blending",
+      "u_domain_warp_enabled",
+      "u_domain_warp_intensity",
+      "u_domain_warp_scale",
+      "u_vignette_intensity",
+      "u_vignette_radius",
+      "u_fresnel_enabled",
+      "u_fresnel_power",
+      "u_fresnel_intensity",
+      "u_fresnel_color",
+      "u_iridescence_enabled",
+      "u_iridescence_intensity",
+      "u_iridescence_speed",
+      "u_bloom_intensity",
+      "u_bloom_threshold",
+      "u_chromatic_aberration",
+      "u_shape_type",
+      "u_silhouette_fade",
+      "u_cylinder_fade",
+      "u_ribbon_fade"
+    ], E = {
+      attributes: { position: A, normal: C, uv: m },
       uniforms: {}
     };
-    W.forEach((S) => {
-      D.uniforms[S] = t.getUniformLocation(l, S);
+    P.forEach((S) => {
+      E.uniforms[S] = t.getUniformLocation(u, S);
     });
-    for (let S = 0; S < O; S++)
-      D.uniforms[`u_colors[${S}].is_active`] = t.getUniformLocation(l, `u_colors[${S}].is_active`), D.uniforms[`u_colors[${S}].color`] = t.getUniformLocation(l, `u_colors[${S}].color`), D.uniforms[`u_colors[${S}].influence`] = t.getUniformLocation(l, `u_colors[${S}].influence`);
+    for (let S = 0; S < j; S++)
+      E.uniforms[`u_colors[${S}].is_active`] = t.getUniformLocation(u, `u_colors[${S}].is_active`), E.uniforms[`u_colors[${S}].color`] = t.getUniformLocation(u, `u_colors[${S}].color`), E.uniforms[`u_colors[${S}].influence`] = t.getUniformLocation(u, `u_colors[${S}].influence`);
     return this._initialized = !0, this._uniformsDirty = !0, this._colorsChanged = !0, this._textureDirty = !0, t.enable(t.BLEND), t.blendFunc(t.SRC_ALPHA, t.ONE_MINUS_SRC_ALPHA), t.enable(t.DEPTH_TEST), {
       gl: t,
-      program: l,
+      program: u,
       buffers: {
-        position: T,
-        normal: x,
-        uv: h,
-        index: w,
-        wireframeIndex: R
+        position: a,
+        normal: h,
+        uv: p,
+        index: c,
+        wireframeIndex: f
       },
-      locations: D,
-      camera: m,
-      indexCount: p.length,
-      wireframeIndexCount: v.length,
-      indexType: p instanceof Uint32Array ? t.UNSIGNED_INT : t.UNSIGNED_SHORT
+      locations: E,
+      camera: T,
+      indexCount: _.length,
+      wireframeIndexCount: b.length,
+      indexType: _ instanceof Uint32Array ? t.UNSIGNED_INT : t.UNSIGNED_SHORT
     };
   }
   _createProceduralTexture(e) {
-    const o = document.createElement("canvas");
-    o.width = 1024, o.height = 1024;
-    const t = o.getContext("2d", { willReadFrequently: !0 });
+    this._sourceCanvas || (this._sourceCanvas = document.createElement("canvas"), this._sourceCanvas.width = 1024, this._sourceCanvas.height = 1024, this._sourceCtx = this._sourceCanvas.getContext("2d"));
+    const r = this._sourceCanvas, t = this._sourceCtx;
     if (!t)
       return null;
-    let b = this._textureSeed;
-    const y = this._textureSeed;
-    function n() {
-      const s = Math.sin(b++) * 1e4;
-      return s - Math.floor(s);
+    let y = this._textureSeed;
+    const x = this._textureSeed;
+    function o() {
+      const m = Math.sin(y++) * 1e4;
+      return m - Math.floor(m);
     }
-    const p = (s) => {
-      b = y + s;
-    }, v = this._colors.filter((s) => s.enabled).map((s) => s.color);
-    if (v.length === 0)
+    const l = (m) => {
+      y = x + m;
+    }, _ = this._colors.filter((m) => m.enabled).map((m) => m.color);
+    if (_.length === 0)
       return null;
-    function T(s) {
-      const f = parseInt(s.replace("#", ""), 16);
+    const b = this._shapeType !== "plane", a = b ? [-1, 0, 1] : [0], h = b ? [-1, 0, 1] : [0];
+    function p(m) {
+      const F = parseInt(m.replace("#", ""), 16);
       return {
-        r: f >> 16 & 255,
-        g: f >> 8 & 255,
-        b: f & 255
+        r: F >> 16 & 255,
+        g: F >> 8 & 255,
+        b: F & 255
       };
     }
-    function x(s, f, _) {
-      return "#" + ((1 << 24) + (Math.round(s) << 16) + (Math.round(f) << 8) + Math.round(_)).toString(16).slice(1).padStart(6, "0");
+    function c(m, F, D) {
+      return "#" + ((1 << 24) + (Math.round(m) << 16) + (Math.round(F) << 8) + Math.round(D)).toString(16).slice(1).padStart(6, "0");
     }
-    const h = () => {
-      const s = v[Math.floor(n() * v.length)], f = v[Math.floor(n() * v.length)], _ = n() * this._textureColorBlending, d = T(s), z = T(f), C = d.r + (z.r - d.r) * _, F = d.g + (z.g - d.g) * _, M = d.b + (z.b - d.b) * _;
-      return x(C, F, M);
-    }, w = this._proceduralBackgroundColor || "#000000";
-    t.fillStyle = w, t.fillRect(0, 0, 1024, 1024);
-    const R = t.createLinearGradient(0, 0, 0, 1024);
-    R.addColorStop(0, h()), R.addColorStop(1, h()), t.fillStyle = R, t.fillRect(0, 0, 1024, 1024);
-    for (let s = 0; s < this._textureShapeTriangles; s++) {
-      t.fillStyle = h(), t.beginPath();
-      const f = n() * 1024, _ = n() * 1024, d = 100 + n() * 300;
-      t.moveTo(f, _), t.lineTo(f + (n() - 0.5) * d, _ + (n() - 0.5) * d), t.lineTo(f + (n() - 0.5) * d, _ + (n() - 0.5) * d), t.fill();
+    const f = () => {
+      const m = _[Math.floor(o() * _.length)], F = _[Math.floor(o() * _.length)], D = o() * this._textureColorBlending, z = p(m), M = p(F), P = z.r + (M.r - z.r) * D, E = z.g + (M.g - z.g) * D, S = z.b + (M.b - z.b) * D;
+      return c(P, E, S);
+    }, R = this._proceduralBackgroundColor || "#000000";
+    t.fillStyle = R, t.fillRect(0, 0, 1024, 1024);
+    const g = t.createLinearGradient(0, 0, 0, 1024);
+    g.addColorStop(0, f()), g.addColorStop(1, f()), t.fillStyle = g, t.fillRect(0, 0, 1024, 1024);
+    for (let m = 0; m < this._textureShapeTriangles; m++) {
+      const F = f(), D = o() * 1024, z = o() * 1024, M = 100 + o() * 300, P = (o() - 0.5) * M, E = (o() - 0.5) * M, S = (o() - 0.5) * M, U = (o() - 0.5) * M;
+      for (const B of a)
+        for (const W of h) {
+          t.fillStyle = F, t.beginPath();
+          const I = D + B * 1024, O = z + W * 1024;
+          t.moveTo(I, O), t.lineTo(I + P, O + E), t.lineTo(I + S, O + U), t.fill();
+        }
+    }
+    for (let m = 0; m < this._textureShapeCircles; m++) {
+      const F = f(), D = 10 + o() * 50, z = o() * 1024, M = o() * 1024, P = 50 + o() * 150;
+      for (const E of a)
+        for (const S of h)
+          t.strokeStyle = F, t.lineWidth = D, t.beginPath(), t.arc(z + E * 1024, M + S * 1024, P, 0, Math.PI * 2), t.stroke();
     }
-    for (let s = 0; s < this._textureShapeCircles; s++) {
-      t.strokeStyle = h(), t.lineWidth = 10 + n() * 50, t.beginPath();
-      const f = n() * 1024, _ = n() * 1024, d = 50 + n() * 150;
-      t.arc(f, _, d, 0, Math.PI * 2), t.stroke();
+    for (let m = 0; m < this._textureShapeBars; m++) {
+      const F = f(), D = o() * 1024, z = o() * 1024, M = o() * Math.PI;
+      for (const P of a)
+        for (const E of h)
+          t.fillStyle = F, t.save(), t.translate(D + P * 1024, z + E * 1024), t.rotate(M), t.fillRect(-150, -25, 300, 50), t.restore();
     }
-    for (let s = 0; s < this._textureShapeBars; s++)
-      t.fillStyle = h(), t.save(), t.translate(n() * 1024, n() * 1024), t.rotate(n() * Math.PI), t.fillRect(-150, -25, 300, 50), t.restore();
     t.lineWidth = 15, t.lineCap = "round";
-    for (let s = 0; s < this._textureShapeSquiggles; s++) {
-      t.strokeStyle = h(), t.beginPath();
-      let f = n() * 1024, _ = n() * 1024;
-      t.moveTo(f, _);
-      for (let d = 0; d < 4; d++)
-        t.bezierCurveTo(
-          f + (n() - 0.5) * 300,
-          _ + (n() - 0.5) * 300,
-          f + (n() - 0.5) * 300,
-          _ + (n() - 0.5) * 300,
-          f + (n() - 0.5) * 300,
-          _ + (n() - 0.5) * 300
-        ), f += (n() - 0.5) * 300, _ += (n() - 0.5) * 300;
-      t.stroke();
+    for (let m = 0; m < this._textureShapeSquiggles; m++) {
+      const F = f(), D = o() * 1024, z = o() * 1024, M = [];
+      let P = 0, E = 0;
+      for (let S = 0; S < 4; S++) {
+        const U = P + (o() - 0.5) * 300, B = E + (o() - 0.5) * 300;
+        M.push({
+          cx1: P + (o() - 0.5) * 300,
+          cy1: E + (o() - 0.5) * 300,
+          cx2: P + (o() - 0.5) * 300,
+          cy2: E + (o() - 0.5) * 300,
+          ex: U,
+          ey: B
+        }), P = U, E = B;
+      }
+      for (const S of a)
+        for (const U of h) {
+          t.strokeStyle = F, t.beginPath();
+          const B = D + S * 1024, W = z + U * 1024;
+          t.moveTo(B, W);
+          for (const I of M)
+            t.bezierCurveTo(
+              B + I.cx1,
+              W + I.cy1,
+              B + I.cx2,
+              W + I.cy2,
+              B + I.ex,
+              W + I.ey
+            );
+          t.stroke();
+        }
     }
-    p(5e4);
-    const E = document.createElement("canvas");
-    E.width = 1024, E.height = 1024;
-    const g = E.getContext("2d", { willReadFrequently: !0 });
-    if (!g)
+    l(5e4), this._maskedCanvas || (this._maskedCanvas = document.createElement("canvas"), this._maskedCanvas.width = 1024, this._maskedCanvas.height = 1024, this._maskedCtx = this._maskedCanvas.getContext("2d"));
+    const v = this._maskedCanvas, w = this._maskedCtx;
+    if (!w)
       return null;
-    g.fillStyle = w, g.fillRect(0, 0, 1024, 1024);
-    let A = 0;
-    const c = [];
-    for (; A < 1024; )
-      if (n() < this._textureVoidLikelihood) {
-        const f = this._textureVoidWidthMin + n() * (this._textureVoidWidthMax - this._textureVoidWidthMin);
-        c.push({ type: "void", x: A, width: f }), A += f;
+    this._transparentTextureVoid ? w.clearRect(0, 0, 1024, 1024) : (w.fillStyle = R, w.fillRect(0, 0, 1024, 1024));
+    let u = 0;
+    const T = [];
+    for (; u < 1024; )
+      if (o() < this._textureVoidLikelihood) {
+        const F = this._textureVoidWidthMin + o() * (this._textureVoidWidthMax - this._textureVoidWidthMin);
+        T.push({ type: "void", x: u, width: F }), u += F;
       } else {
-        const f = 50 + n() * 200;
-        c.push({ type: "matter", x: A, width: f }), A += f;
+        const F = 50 + o() * 200;
+        T.push({ type: "matter", x: u, width: F }), u += F;
       }
-    for (const s of c)
-      if (s.type === "matter") {
-        const f = s.x, _ = Math.min(s.x + s.width, 1024);
-        let d = f;
-        for (; d < _; ) {
-          const z = (2 + n() * 20) / this._textureBandDensity, C = Math.floor(n() * 1024);
-          g.drawImage(
-            o,
-            C,
+    for (const m of T)
+      if (m.type === "matter") {
+        const F = m.x, D = Math.min(m.x + m.width, 1024);
+        let z = F;
+        for (; z < D; ) {
+          const M = (2 + o() * 20) / this._textureBandDensity, P = Math.floor(o() * 1024);
+          w.drawImage(
+            r,
+            P,
             0,
-            z,
+            M,
             1024,
-            d,
-            0,
             z,
+            0,
+            M,
             1024
-          ), d += z;
+          ), z += M;
         }
       }
-    const l = e.createTexture();
-    e.bindTexture(e.TEXTURE_2D, l), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, e.RGBA, e.UNSIGNED_BYTE, E), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.REPEAT), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.REPEAT), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR_MIPMAP_LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.LINEAR), e.generateMipmap(e.TEXTURE_2D);
-    const m = e.getExtension("EXT_texture_filter_anisotropic") || e.getExtension("MOZ_EXT_texture_filter_anisotropic") || e.getExtension("WEBKIT_EXT_texture_filter_anisotropic");
-    if (m) {
-      const s = e.getParameter(m.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
-      e.texParameterf(e.TEXTURE_2D, m.TEXTURE_MAX_ANISOTROPY_EXT, Math.min(16, s));
+    const A = e.createTexture();
+    e.bindTexture(e.TEXTURE_2D, A), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, e.RGBA, e.UNSIGNED_BYTE, v), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.REPEAT), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.REPEAT), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR_MIPMAP_LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.LINEAR), e.generateMipmap(e.TEXTURE_2D);
+    const C = e.getExtension("EXT_texture_filter_anisotropic") || e.getExtension("MOZ_EXT_texture_filter_anisotropic") || e.getExtension("WEBKIT_EXT_texture_filter_anisotropic");
+    if (C) {
+      const m = e.getParameter(C.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
+      e.texParameterf(e.TEXTURE_2D, C.TEXTURE_MAX_ANISOTROPY_EXT, Math.min(16, m));
     }
-    return l;
+    return A;
+  }
+  get silhouetteFade() {
+    return this._silhouetteFade;
+  }
+  set silhouetteFade(e) {
+    this._silhouetteFade !== e && (this._silhouetteFade = e, this._uniformsDirty = !0);
+  }
+  get cylinderFade() {
+    return this._cylinderFade;
+  }
+  set cylinderFade(e) {
+    this._cylinderFade !== e && (this._cylinderFade = e, this._uniformsDirty = !0);
+  }
+  get ribbonFade() {
+    return this._ribbonFade;
+  }
+  set ribbonFade(e) {
+    this._ribbonFade !== e && (this._ribbonFade = e, this._uniformsDirty = !0);
+  }
+  get domainWarpEnabled() {
+    return this._domainWarpEnabled;
+  }
+  set domainWarpEnabled(e) {
+    this._domainWarpEnabled !== e && (this._domainWarpEnabled = e, this._uniformsDirty = !0);
+  }
+  get domainWarpIntensity() {
+    return this._domainWarpIntensity;
+  }
+  set domainWarpIntensity(e) {
+    this._domainWarpIntensity !== e && (this._domainWarpIntensity = e, this._uniformsDirty = !0);
+  }
+  get domainWarpScale() {
+    return this._domainWarpScale;
+  }
+  set domainWarpScale(e) {
+    this._domainWarpScale !== e && (this._domainWarpScale = e, this._uniformsDirty = !0);
+  }
+  get vignetteIntensity() {
+    return this._vignetteIntensity;
+  }
+  set vignetteIntensity(e) {
+    this._vignetteIntensity !== e && (this._vignetteIntensity = e, this._uniformsDirty = !0);
+  }
+  get vignetteRadius() {
+    return this._vignetteRadius;
+  }
+  set vignetteRadius(e) {
+    this._vignetteRadius !== e && (this._vignetteRadius = e, this._uniformsDirty = !0);
+  }
+  get fresnelEnabled() {
+    return this._fresnelEnabled;
+  }
+  set fresnelEnabled(e) {
+    this._fresnelEnabled !== e && (this._fresnelEnabled = e, this._uniformsDirty = !0);
+  }
+  get fresnelPower() {
+    return this._fresnelPower;
+  }
+  set fresnelPower(e) {
+    this._fresnelPower !== e && (this._fresnelPower = e, this._uniformsDirty = !0);
+  }
+  get fresnelIntensity() {
+    return this._fresnelIntensity;
+  }
+  set fresnelIntensity(e) {
+    this._fresnelIntensity !== e && (this._fresnelIntensity = e, this._uniformsDirty = !0);
+  }
+  get fresnelColor() {
+    return this._fresnelColor;
+  }
+  set fresnelColor(e) {
+    this._fresnelColor !== e && (this._fresnelColor = e, this._fresnelColorRgb = this._hexToRgb(e), this._uniformsDirty = !0);
+  }
+  get iridescenceEnabled() {
+    return this._iridescenceEnabled;
+  }
+  set iridescenceEnabled(e) {
+    this._iridescenceEnabled !== e && (this._iridescenceEnabled = e, this._uniformsDirty = !0);
+  }
+  get iridescenceIntensity() {
+    return this._iridescenceIntensity;
+  }
+  set iridescenceIntensity(e) {
+    this._iridescenceIntensity !== e && (this._iridescenceIntensity = e, this._uniformsDirty = !0);
+  }
+  get iridescenceSpeed() {
+    return this._iridescenceSpeed;
+  }
+  set iridescenceSpeed(e) {
+    this._iridescenceSpeed !== e && (this._iridescenceSpeed = e, this._uniformsDirty = !0);
+  }
+  get bloomIntensity() {
+    return this._bloomIntensity;
+  }
+  set bloomIntensity(e) {
+    this._bloomIntensity !== e && (this._bloomIntensity = e, this._uniformsDirty = !0);
+  }
+  get bloomThreshold() {
+    return this._bloomThreshold;
+  }
+  set bloomThreshold(e) {
+    this._bloomThreshold !== e && (this._bloomThreshold = e, this._uniformsDirty = !0);
+  }
+  get chromaticAberration() {
+    return this._chromaticAberration;
+  }
+  set chromaticAberration(e) {
+    this._chromaticAberration !== e && (this._chromaticAberration = e, this._uniformsDirty = !0);
+  }
+  get shapeType() {
+    return this._shapeType;
+  }
+  set shapeType(e) {
+    this._shapeType !== e && (this._shapeType = e, this._updateGeometry());
+  }
+  get shapeRotationX() {
+    return this._shapeRotationX;
+  }
+  set shapeRotationX(e) {
+    this._shapeRotationX = e, this._uniformsDirty = !0;
+  }
+  get shapeRotationY() {
+    return this._shapeRotationY;
+  }
+  set shapeRotationY(e) {
+    this._shapeRotationY = e, this._uniformsDirty = !0;
+  }
+  get shapeRotationZ() {
+    return this._shapeRotationZ;
+  }
+  set shapeRotationZ(e) {
+    this._shapeRotationZ = e, this._uniformsDirty = !0;
+  }
+  get shapeAutoRotateSpeedX() {
+    return this._shapeAutoRotateSpeedX;
+  }
+  set shapeAutoRotateSpeedX(e) {
+    this._shapeAutoRotateSpeedX = e, this._uniformsDirty = !0;
+  }
+  get shapeAutoRotateSpeedY() {
+    return this._shapeAutoRotateSpeedY;
+  }
+  set shapeAutoRotateSpeedY(e) {
+    this._shapeAutoRotateSpeedY = e, this._uniformsDirty = !0;
+  }
+  get sphereRadius() {
+    return this._sphereRadius;
+  }
+  set sphereRadius(e) {
+    this._sphereRadius !== e && (this._sphereRadius = e, this._updateGeometry());
+  }
+  get torusRadius() {
+    return this._torusRadius;
+  }
+  set torusRadius(e) {
+    this._torusRadius !== e && (this._torusRadius = e, this._updateGeometry());
+  }
+  get torusTube() {
+    return this._torusTube;
+  }
+  set torusTube(e) {
+    this._torusTube !== e && (this._torusTube = e, this._updateGeometry());
+  }
+  get cylinderRadius() {
+    return this._cylinderRadius;
+  }
+  set cylinderRadius(e) {
+    this._cylinderRadius !== e && (this._cylinderRadius = e, this._updateGeometry());
+  }
+  get cylinderHeight() {
+    return this._cylinderHeight;
+  }
+  set cylinderHeight(e) {
+    this._cylinderHeight !== e && (this._cylinderHeight = e, this._updateGeometry());
+  }
+  get planeBend() {
+    return this._planeBend;
+  }
+  set planeBend(e) {
+    this._planeBend !== e && (this._planeBend = e, this._updateGeometry());
+  }
+  get planeTwist() {
+    return this._planeTwist;
+  }
+  set planeTwist(e) {
+    this._planeTwist !== e && (this._planeTwist = e, this._updateGeometry());
+  }
+  get cameraLock() {
+    return this._cameraLock;
+  }
+  set cameraLock(e) {
+    this._cameraLock = e;
+  }
+  get cameraX() {
+    return this._cameraX;
+  }
+  set cameraX(e) {
+    this._cameraX = e, this._uniformsDirty = !0;
+  }
+  get cameraY() {
+    return this._cameraY;
+  }
+  set cameraY(e) {
+    this._cameraY = e, this._uniformsDirty = !0;
+  }
+  get cameraZ() {
+    return this._cameraZ;
+  }
+  set cameraZ(e) {
+    this._cameraZ = e, this._uniformsDirty = !0;
+  }
+  get cameraRotationX() {
+    return this._cameraRotationX;
+  }
+  set cameraRotationX(e) {
+    this._cameraRotationX = e, this._uniformsDirty = !0;
+  }
+  get cameraRotationY() {
+    return this._cameraRotationY;
+  }
+  set cameraRotationY(e) {
+    this._cameraRotationY = e, this._uniformsDirty = !0;
+  }
+  get cameraRotationZ() {
+    return this._cameraRotationZ;
+  }
+  set cameraRotationZ(e) {
+    this._cameraRotationZ = e, this._uniformsDirty = !0;
+  }
+  get cameraZoom() {
+    return this._cameraZoom;
+  }
+  set cameraZoom(e) {
+    this._cameraZoom !== e && (this._cameraZoom = e, this._updateCameraFrustum());
+  }
+  _updateCameraFrustum() {
+    if (!this.glState)
+      return;
+    const e = this.glState.gl, i = this._ref.clientWidth, r = this._ref.clientHeight;
+    G(this.glState.camera, i, r, N, Y, this._shapeType, this._cameraZoom);
+    const t = this.glState.locations.uniforms.projectionMatrix;
+    e.useProgram(this.glState.program), t && e.uniformMatrix4fv(t, !1, this.glState.camera.projectionMatrix.elements), this._uniformsDirty = !0;
   }
 }
-const Z = (a) => {
-  a.id = ye, a.href = "https://neat.firecms.co", a.target = "_blank", a.style.position = "absolute", a.style.display = "block", a.style.bottom = "0", a.style.right = "0", a.style.padding = "10px", a.style.color = "#dcdcdc", a.style.opacity = "0.8", a.style.fontFamily = "sans-serif", a.style.fontSize = "16px", a.style.fontWeight = "bold", a.style.textDecoration = "none", a.style.zIndex = "10000", a.style.pointerEvents = "auto", a.setAttribute("data-n", "1"), a.innerHTML = "NEAT";
-}, ve = (a) => {
-  const e = a.parentElement;
+const _e = (s) => {
+  s.id = pt, s.href = "https://neat.firecms.co", s.target = "_blank", s.style.position = "absolute", s.style.display = "block", s.style.bottom = "0", s.style.right = "0", s.style.padding = "10px", s.style.color = "#dcdcdc", s.style.opacity = "0.8", s.style.fontFamily = "sans-serif", s.style.fontSize = "16px", s.style.fontWeight = "bold", s.style.textDecoration = "none", s.style.zIndex = "10000", s.style.pointerEvents = "auto", s.setAttribute("data-n", "1"), s.innerHTML = "NEAT";
+}, gt = (s) => {
+  const e = s.parentElement;
   if (e && getComputedStyle(e).position === "static" && (e.style.position = "relative"), e) {
-    const o = e.querySelector("a[data-n]");
-    if (o)
-      return Z(o), o;
+    const r = e.querySelector("a[data-n]");
+    if (r)
+      return _e(r), r;
   }
   const i = document.createElement("a");
-  return Z(i), e?.appendChild(i), i;
+  return _e(i), e?.appendChild(i), i;
 };
-function we() {
-  const a = new Date(), e = a.getMinutes(), i = a.getSeconds();
+function yt() {
+  const s = new Date(), e = s.getMinutes(), i = s.getSeconds();
   return e * 60 + i;
 }
-function Se(a = 6) {
+function xt(s = 6) {
   const e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
   let i = "";
-  for (let o = 0; o < a; o++) {
+  for (let r = 0; r < s; r++) {
     const t = Math.floor(Math.random() * e.length);
     i += e.charAt(t);
   }
   return i;
 }
-function be(a, e) {
+function ce(s, e) {
   const i = document.createElement("a");
-  i.download = e, i.href = a, document.body.appendChild(i), i.click(), document.body.removeChild(i);
+  i.download = e, i.href = s, document.body.appendChild(i), i.click(), document.body.removeChild(i);
 }
-function Ee() {
+function vt() {
   if (document.getElementById("neat-seo-schema"))
     return;
-  const a = document.createElement("script");
-  a.id = "neat-seo-schema", a.type = "application/ld+json", a.text = JSON.stringify({
+  const s = document.createElement("script");
+  s.id = "neat-seo-schema", s.type = "application/ld+json", s.text = JSON.stringify({
     "@context": "https://schema.org",
     "@type": "WebSite",
     name: "NEAT Gradient",
@@ -1076,19 +1866,19 @@ function Ee() {
       url: "https://firecms.co"
     },
     description: "Beautiful, fast, heavily customizable, WebGL based gradients."
-  }), document.head.appendChild(a);
+  }), document.head.appendChild(s);
   const e = document.createElement("div");
   e.style.position = "absolute", e.style.width = "1px", e.style.height = "1px", e.style.padding = "0", e.style.margin = "-1px", e.style.overflow = "hidden", e.style.clip = "rect(0, 0, 0, 0)", e.style.whiteSpace = "nowrap", e.style.borderWidth = "0";
   try {
-    const i = e.attachShadow({ mode: "closed" }), o = document.createElement("a");
-    o.href = "https://firecms.co", o.textContent = "FireCMS", i.appendChild(o);
+    const i = e.attachShadow({ mode: "closed" }), r = document.createElement("a");
+    r.href = "https://firecms.co", r.textContent = "FireCMS", i.appendChild(r);
   } catch {
-    const o = document.createElement("a");
-    o.href = "https://firecms.co", o.textContent = "FireCMS", e.appendChild(o);
+    const r = document.createElement("a");
+    r.href = "https://firecms.co", r.textContent = "FireCMS", e.appendChild(r);
   }
   document.body.appendChild(e);
 }
 export {
-  Te as NeatGradient
+  bt as NeatGradient
 };
 //# sourceMappingURL=index.es.js.map