kinetic-slider/dist/cjs/filters/simplexNoiseFilter.cjs

A WebGL-powered kinetic slider component using PIXI.js

'use strict';

var pixiFilters = require('pixi-filters');
var ShaderResourceManager = require('../managers/ShaderResourceManager.cjs');

function createSimplexNoiseFilter(config) {
  const shaderManager = ShaderResourceManager.ShaderResourceManager.getInstance();
  const options = {};
  if (config.noiseScale !== void 0) options.noiseScale = config.noiseScale;
  if (config.offsetX !== void 0) options.offsetX = config.offsetX;
  if (config.offsetY !== void 0) options.offsetY = config.offsetY;
  if (config.offsetZ !== void 0) options.offsetZ = config.offsetZ;
  if (config.step !== void 0) options.step = config.step;
  if (config.strength !== void 0) options.strength = config.strength;
  const stepStr = (options.step || -1).toString();
  const shaderKey = `simplex-noise-filter-${stepStr}`;
  const filter = new pixiFilters.SimplexNoiseFilter(options);
  try {
    shaderManager.registerFilter(filter, shaderKey);
  } catch (error) {
    console.warn("Error registering simplex noise filter with shader manager:", error);
  }
  const updateIntensity = (intensity) => {
    const normalizedIntensity = Math.max(0, Math.min(10, intensity));
    if (config.primaryProperty) {
      switch (config.primaryProperty) {
        case "noiseScale":
          filter.noiseScale = 1 + normalizedIntensity * 1.9;
          break;
        case "strength":
          filter.strength = normalizedIntensity / 10;
          break;
        case "step":
          filter.step = normalizedIntensity > 0 ? normalizedIntensity / 10 : -1;
          break;
        case "offset":
          const offsetValue = normalizedIntensity * 10;
          filter.offsetX = offsetValue;
          filter.offsetY = offsetValue;
          filter.offsetZ = offsetValue;
          break;
        case "offsetX":
          filter.offsetX = normalizedIntensity * 10;
          break;
        case "offsetY":
          filter.offsetY = normalizedIntensity * 10;
          break;
        case "offsetZ":
          filter.offsetZ = normalizedIntensity * 10;
          break;
        default:
          filter.strength = normalizedIntensity / 10;
      }
    } else {
      filter.strength = normalizedIntensity / 10;
    }
  };
  updateIntensity(config.intensity);
  const reset = () => {
    filter.noiseScale = config.noiseScale !== void 0 ? config.noiseScale : 10;
    filter.offsetX = config.offsetX !== void 0 ? config.offsetX : 0;
    filter.offsetY = config.offsetY !== void 0 ? config.offsetY : 0;
    filter.offsetZ = config.offsetZ !== void 0 ? config.offsetZ : 0;
    filter.step = config.step !== void 0 ? config.step : -1;
    filter.strength = config.strength !== void 0 ? config.strength : 0;
    if (config.intensity !== void 0) {
      updateIntensity(config.intensity);
    }
  };
  const dispose = () => {
    try {
      shaderManager.releaseFilter(filter, shaderKey);
    } catch (error) {
      console.warn("Error releasing simplex noise filter shader:", error);
    }
    filter.destroy();
  };
  return { filter, updateIntensity, reset, dispose };
}

exports.createSimplexNoiseFilter = createSimplexNoiseFilter;
//# sourceMappingURL=simplexNoiseFilter.cjs.map