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

A WebGL-powered kinetic slider component using PIXI.js

'use strict';

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

function createZoomBlurFilter(config) {
  const shaderManager = ShaderResourceManager.ShaderResourceManager.getInstance();
  const options = {};
  if (config.center !== void 0) options.center = config.center;
  if (config.centerX !== void 0) options.centerX = config.centerX;
  if (config.centerY !== void 0) options.centerY = config.centerY;
  if (config.innerRadius !== void 0) options.innerRadius = config.innerRadius;
  if (config.radius !== void 0) options.radius = config.radius;
  if (config.strength !== void 0) options.strength = config.strength;
  const innerRadiusStr = (options.innerRadius || 0).toString();
  const shaderKey = `zoom-blur-filter-${innerRadiusStr}`;
  const filter = new pixiFilters.ZoomBlurFilter(options);
  try {
    shaderManager.registerFilter(filter, shaderKey);
  } catch (error) {
    console.warn("Error registering zoom blur filter with shader manager:", error);
  }
  const updateIntensity = (intensity) => {
    const normalizedIntensity = Math.max(0, Math.min(10, intensity));
    if (config.primaryProperty) {
      switch (config.primaryProperty) {
        case "strength":
          filter.strength = normalizedIntensity / 10;
          break;
        case "radius":
          if (normalizedIntensity >= 9.5) {
            filter.radius = -1;
          } else {
            filter.radius = 100 + normalizedIntensity * 80;
          }
          break;
        case "innerRadius":
          filter.innerRadius = normalizedIntensity * 20;
          break;
        case "centerX":
          filter.centerX = normalizedIntensity / 10;
          break;
        case "centerY":
          filter.centerY = normalizedIntensity / 10;
          break;
        case "center":
          const position = normalizedIntensity / 10;
          filter.centerX = position;
          filter.centerY = 0.5;
          break;
        default:
          filter.strength = normalizedIntensity / 10;
      }
    } else {
      filter.strength = normalizedIntensity / 10;
    }
  };
  updateIntensity(config.intensity);
  const reset = () => {
    if (config.centerX !== void 0) {
      filter.centerX = config.centerX;
    } else if (config.center?.x !== void 0) {
      filter.centerX = config.center.x;
    } else {
      filter.centerX = 0;
    }
    if (config.centerY !== void 0) {
      filter.centerY = config.centerY;
    } else if (config.center?.y !== void 0) {
      filter.centerY = config.center.y;
    } else {
      filter.centerY = 0;
    }
    filter.innerRadius = config.innerRadius !== void 0 ? config.innerRadius : 0;
    filter.radius = config.radius !== void 0 ? config.radius : -1;
    filter.strength = config.strength !== void 0 ? config.strength : 0.1;
  };
  const dispose = () => {
    try {
      shaderManager.releaseFilter(filter, shaderKey);
    } catch (error) {
      console.warn("Error releasing zoom blur filter shader:", error);
    }
    filter.destroy();
  };
  return { filter, updateIntensity, reset, dispose };
}

exports.createZoomBlurFilter = createZoomBlurFilter;
//# sourceMappingURL=zoomBlurFilter.cjs.map