Na}{

File Content: wgl_webgl_fluid.js

(function ($) {
  "use strict";

Here's the new load parameter for your <code>GUI</code>'s constructor:

<input id="dg-local-storage" type="checkbox"/> Automatically save
    values to <code>localStorage</code> on exit.

<div id="dg-local-explain">The values saved to <code>localStorage</code> will
      override those passed to <code>dat.GUI</code>'s constructor. This makes it
      easier to work incrementally, but <code>localStorage</code> is fragile,
      and your friends may not see the same values you do.

</div>

</div>`), this.parent)
          throw new Error("You can only call remember on a top level GUI.");
        var e2 = this;
        S.each(Array.prototype.slice.call(arguments), function (t2) {
          e2.__rememberedObjects.length === 0 && v(e2), e2.__rememberedObjects.indexOf(t2) === -1 && e2.__rememberedObjects.push(t2);
        }), this.autoPlace && w(this, this.width);
      }, getRoot: function () {
        for (var e2 = this; e2.parent;)
          e2 = e2.parent;
        return e2;
      }, getSaveObject: function () {
        var e2 = this.load;
        return e2.closed = this.closed, this.__rememberedObjects.length > 0 && (e2.preset = this.preset, e2.remembered || (e2.remembered = {}), e2.remembered[this.preset] = x(this)), e2.folders = {}, S.each(this.__folders, function (t2, n2) {
          e2.folders[n2] = t2.getSaveObject();
        }), e2;
      }, save: function () {
        this.load.remembered || (this.load.remembered = {}), this.load.remembered[this.preset] = x(this), _(this, false), this.saveToLocalStorageIfPossible();
      }, saveAs: function (e2) {
        this.load.remembered || (this.load.remembered = {}, this.load.remembered[se] = x(this, true)), this.load.remembered[e2] = x(this), this.preset = e2, g(this, e2, true), this.saveToLocalStorageIfPossible();
      }, revert: function (e2) {
        S.each(this.__controllers, function (t2) {
          this.getRoot().load.remembered ? p(e2 || this.getRoot(), t2) : t2.setValue(t2.initialValue), t2.__onFinishChange && t2.__onFinishChange.call(t2, t2.getValue());
        }, this), S.each(this.__folders, function (e3) {
          e3.revert(e3);
        }), e2 || _(this.getRoot(), false);
      }, listen: function (e2) {
        var t2 = this.__listening.length === 0;
        this.__listening.push(e2), t2 && C(this.__listening);
      }, updateDisplay: function () {
        S.each(this.__controllers, function (e2) {
          e2.updateDisplay();
        }), S.each(this.__folders, function (e2) {
          e2.updateDisplay();
        });
      }
    });
    var pe = { Color: I, math: N, interpret: R }, fe = { Controller: z, BooleanController: K, OptionController: Y, StringController: J, NumberController: W, NumberControllerBox: Q, NumberControllerSlider: q, FunctionController: Z, ColorController: $ }, me = { dom: X }, ge = { GUI: he }, be = he, ve = { color: pe, controllers: fe, dom: me, gui: ge, GUI: be };
    e.color = pe, e.controllers = fe, e.dom = me, e.gui = ge, e.GUI = be, e.default = ve, Object.defineProperty(e, "__esModule", { value: true });
  });

function initCanvas(el, config) {
    const canvas = el;
    resizeCanvas();
    config = __spreadValues({
      IMMEDIATE: true,
      TRIGGER: "hover",
      SIM_RESOLUTION: 128,
      DYE_RESOLUTION: 1024,
      CAPTURE_RESOLUTION: 512,
      DENSITY_DISSIPATION: 1,
      VELOCITY_DISSIPATION: 0.2,
      PRESSURE: 0.8,
      PRESSURE_ITERATIONS: 20,
      CURL: 30,
      SPLAT_RADIUS: 0.25,
      SPLAT_FORCE: 6e3,
      SHADING: true,
      COLORFUL: true,
      COLOR_UPDATE_SPEED: 10,
      PAUSED: false,
      BACK_COLOR: { r: 0, g: 0, b: 0 },
      TRANSPARENT: false,
      BLOOM: true,
      BLOOM_ITERATIONS: 8,
      BLOOM_RESOLUTION: 256,
      BLOOM_INTENSITY: 0.8,
      BLOOM_THRESHOLD: 0.6,
      BLOOM_SOFT_KNEE: 0.7,
      SUNRAYS: true,
      SUNRAYS_RESOLUTION: 196,
      SUNRAYS_WEIGHT: 1,
      TYPE_COLOR: false,
      COLOR: webgl_fluid_settings.color
    }, config);

let animationButton = document.querySelectorAll(".animation_fluid, .filter_animation_fluid .isotope-filter a");

for (let i = 0; i < animationButton.length; i++) {
      animationButton[i].addEventListener("click", function() {
        splatStack.push(parseInt(Math.random() * 20) + 5);
      });
    }
    function updatePointerDownData(pointer, id, posX, posY) {
      pointer.id = id;
      pointer.down = true;
      pointer.moved = false;
      pointer.texcoordX = posX / canvas.width;
      pointer.texcoordY = 1 - posY / canvas.height;
      pointer.prevTexcoordX = pointer.texcoordX;
      pointer.prevTexcoordY = pointer.texcoordY;
      pointer.deltaX = 0;
      pointer.deltaY = 0;
      pointer.color = generateColor();
    }
    function updatePointerMoveData(pointer, posX, posY) {
      if (config.TRIGGER === "click") {
        pointer.moved = pointer.down;
      }
      pointer.prevTexcoordX = pointer.texcoordX;
      pointer.prevTexcoordY = pointer.texcoordY;
      pointer.texcoordX = posX / canvas.width;
      pointer.texcoordY = 1 - posY / canvas.height;
      pointer.deltaX = correctDeltaX(pointer.texcoordX - pointer.prevTexcoordX);
      pointer.deltaY = correctDeltaY(pointer.texcoordY - pointer.prevTexcoordY);
      if (config.TRIGGER === "hover") {
        pointer.moved = Math.abs(pointer.deltaX) > 0 || Math.abs(pointer.deltaY) > 0;
      }
    }
    function updatePointerUpData(pointer) {
      pointer.down = false;
    }
    function correctDeltaX(delta) {
      let aspectRatio = canvas.width / canvas.height;
      if (aspectRatio < 1)
        delta *= aspectRatio;
      return delta;
    }
    function correctDeltaY(delta) {
      let aspectRatio = canvas.width / canvas.height;
      if (aspectRatio > 1)
        delta /= aspectRatio;
      return delta;
    }
    function generateColor() {
      let c = {};

if ('simple' === config.TYPE_COLOR) {
        var color = hexToRgb(config.COLOR);
        color = color.split(',');
        c.r = parseInt(color[0]) / 1000;
        c.g = parseInt(color[1]) / 1000;
        c.b = parseInt(color[2]) / 1000;
      } else {
        c = HSVtoRGB(Math.random(), 1, 1);
        c.r *= 0.15;
        c.g *= 0.15;
        c.b *= 0.15;
      }

return c;
    }
    function HSVtoRGB(h, s, v) {
      let r, g, b, i, f, p, q, t;
      i = Math.floor(h * 6);
      f = h * 6 - i;
      p = v * (1 - s);
      q = v * (1 - f * s);
      t = v * (1 - (1 - f) * s);
      switch (i % 6) {
        case 0:
          r = v, g = t, b = p;
          break;
        case 1:
          r = q, g = v, b = p;
          break;
        case 2:
          r = p, g = v, b = t;
          break;
        case 3:
          r = p, g = q, b = v;
          break;
        case 4:
          r = t, g = p, b = v;
          break;
        case 5:
          r = v, g = p, b = q;
          break;
      }
      return {
        r,
        g,
        b
      };
    }

let reDrawType, reDrawColor, reDrawResolution, reDrawVelocity, reDrawDensity, reDrawPressure, reDrawSplatRadius, reBackSpaceAnimation;

function fluidAnimation(reinit = false)
  {
    if(reinit){
      jQuery( "#wgl-webgl-fluid" ).remove();
      jQuery('.wgl-canvas-outer').append( "<canvas id='wgl-webgl-fluid'></canvas>" );
    }

initCanvas(document.getElementById('wgl-webgl-fluid'), {
      IMMEDIATE: false, // Whether to trigger multiple random splats when initialized
      TRIGGER: 'hover',
      SIM_RESOLUTION: reinit ? reDrawResolution : parseInt(webgl_fluid_settings.resolution),
      DYE_RESOLUTION: 512,
      DENSITY_DISSIPATION: reinit ? parseFloat(reDrawDensity) : parseFloat(webgl_fluid_settings.density),
      VELOCITY_DISSIPATION: reinit ? parseFloat(reDrawVelocity) : parseFloat(webgl_fluid_settings.velocity),
      PRESSURE: reinit ? parseFloat(reDrawPressure) : parseFloat(webgl_fluid_settings.pressure),
      PRESSURE_ITERATIONS: 20,
      CURL: 5,
      SPLAT_RADIUS: reinit ? parseFloat(reDrawSplatRadius) : parseFloat(webgl_fluid_settings.splat_radius),
      SHADING: true,
      COLORFUL: true,
      PAUSED: false,
      BACK_COLOR: { r: 0, g: 0, b: 0 },
      BLOOM: false,
      BLOOM_ITERATIONS: 8,
      BLOOM_RESOLUTION: 256,
      BLOOM_INTENSITY: 0.8,
      BLOOM_THRESHOLD: 0.6,
      BLOOM_SOFT_KNEE: 0.7,
      POINTER_COLOR: [{ r: 0, g: 0, b: 0 }],
      SOUND_SENSITIVITY:0,
      AUDIO_RESPONSIVE: false,
      FREQ_RANGE: 8,
      FREQ_RANGE_START: 0,
      TRANSPARENT: true,
      TYPE_COLOR: reinit ? reDrawType : webgl_fluid_settings.color_type,
      COLOR: reinit ? reDrawColor : webgl_fluid_settings.color,
      BACKSPACE_ANIMATION: reinit ? reBackSpaceAnimation : webgl_fluid_settings.backspace_animation
    });
  }

function changePageSettings(){
    reDrawType = elementor.settings.page.model.get('webgl_fluid_color_type');
    reDrawColor = elementor.settings.page.model.get('webgl_fluid_color_idle');
    reDrawResolution = elementor.settings.page.model.get('webgl_fluid_resolution');
    reDrawVelocity = elementor.settings.page.model.get('webgl_fluid_velocity').size;
    reDrawDensity = elementor.settings.page.model.get('webgl_fluid_density').size;
    reDrawPressure = elementor.settings.page.model.get('webgl_fluid_pressure').size;
    reDrawSplatRadius = elementor.settings.page.model.get('webgl_fluid_splat_radius').size;
    reBackSpaceAnimation = elementor.settings.page.model.get('backspace_animation');

fluidAnimation(true);
  }

function changeFrontSettings(){
    reDrawType = this.webgl_fluid_color_type.value;
    reDrawColor = this.fluid_color_idle.value;
    reDrawResolution = this.webgl_fluid_resolution.value;
    reDrawVelocity = this.velocity_input.value;
    reDrawDensity = this.density_input.value;
    reDrawPressure = this.pressure_input.value;
    reDrawSplatRadius = this.splat_radius_input.value;
    reBackSpaceAnimation = this.webgl_fluid_backspace.checked ? 'yes' : false;

if('random' === this.webgl_fluid_color_type.value){
      if(this.fluid_color_idle.closest('.wgl-control').classList.contains("show")){
        this.fluid_color_idle.closest('.wgl-control').classList.remove("show");
        this.fluid_color_idle.closest('.wgl-control').classList.add('hide');
      }
    }else{
      if(this.fluid_color_idle.closest('.wgl-control').classList.contains("hide")){
        this.fluid_color_idle.closest('.wgl-control').classList.add("show");
        this.fluid_color_idle.closest('.wgl-control').classList.remove('hide');
      }
    }

document.querySelector('.wgl-canvas-outer').style.opacity = this.fluid_opacity_input.value;
    fluidAnimation(true);
  }

jQuery(window).on('elementor/frontend/init', function () {

let elementorEditor = "undefined" !== typeof elementor && "undefined" !== typeof elementor.settings.page;

if (elementorEditor) {
      elementor.settings.page.model.on('change', changePageSettings);
    }else{
      let form = document.getElementsByClassName("wgl-fluid-switcher__form");
      if (form.length) {
        form = form[0];
        form.addEventListener('change', changeFrontSettings);

fluidAnimation();

let el = document.getElementsByClassName("wgl-fluid-switcher__link");
    if (el.length) {
      el = el[0];
      el.addEventListener("click", (e) => {
        e.preventDefault();
        el.parentNode.classList.toggle("active");
      }, false);
    }

let newEvent;

window.addEventListener('mousemove', event => {
      newEvent = new event.constructor(
        event.type, event);
    })

document.addEventListener('mousemove', event => {
      if (event.isTrusted && newEvent) {
        document.getElementById('wgl-webgl-fluid').dispatchEvent(newEvent);
      }
    })

});

})(jQuery);

Name	Size	Permission
wgl_elementor_widgets.js	11694 bytes	0644
wgl_text_path.js	26108 bytes	0644
wgl_webgl_fluid.js	119901 bytes	0644