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

A WebGL-powered kinetic slider component using PIXI.js

'use strict';

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

function createTwistFilter(config) {
  const shaderManager = ShaderResourceManager.ShaderResourceManager.getInstance();
  const options = {};
  if (config.angle !== void 0) options.angle = config.angle;
  if (config.radius !== void 0) options.radius = config.radius;
  if (config.offset !== void 0) options.offset = config.offset;
  if (config.offsetX !== void 0) options.offsetX = config.offsetX;
  if (config.offsetY !== void 0) options.offsetY = config.offsetY;
  const shaderKey = "twist-filter";
  const filter = new pixiFilters.TwistFilter(options);
  try {
    shaderManager.registerFilter(filter, shaderKey);
  } catch (error) {
    console.warn("Error registering twist filter with shader manager:", error);
  }
  const updateIntensity = (intensity) => {
    const normalizedIntensity = Math.max(0, Math.min(10, intensity));
    if (config.primaryProperty) {
      switch (config.primaryProperty) {
        case "angle":
          filter.angle = normalizedIntensity * 2;
          break;
        case "radius":
          filter.radius = 50 + normalizedIntensity * 45;
          break;
        case "center":
          const position = normalizedIntensity / 10;
          filter.offsetX = position - 0.5;
          filter.offsetY = position - 0.5;
          break;
        case "offsetX":
          filter.offsetX = normalizedIntensity / 10 - 0.5;
          break;
        case "offsetY":
          filter.offsetY = normalizedIntensity / 10 - 0.5;
          break;
        default:
          filter.angle = normalizedIntensity * 2;
      }
    } else {
      filter.angle = normalizedIntensity * 2;
    }
  };
  updateIntensity(config.intensity);
  const reset = () => {
    filter.angle = config.angle !== void 0 ? config.angle : 4;
    filter.radius = config.radius !== void 0 ? config.radius : 200;
    if (config.offsetX !== void 0) {
      filter.offsetX = config.offsetX;
    } else if (config.offset?.x !== void 0) {
      filter.offsetX = config.offset.x;
    } else {
      filter.offsetX = 0;
    }
    if (config.offsetY !== void 0) {
      filter.offsetY = config.offsetY;
    } else if (config.offset?.y !== void 0) {
      filter.offsetY = config.offset.y;
    } else {
      filter.offsetY = 0;
    }
  };
  const dispose = () => {
    try {
      shaderManager.releaseFilter(filter, shaderKey);
    } catch (error) {
      console.warn("Error releasing twist filter shader:", error);
    }
    filter.destroy();
  };
  return { filter, updateIntensity, reset, dispose };
}

exports.createTwistFilter = createTwistFilter;
//# sourceMappingURL=twistFilter.cjs.map