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

A WebGL-powered kinetic slider component using PIXI.js

'use strict';

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

function createKawaseBlurFilter(config) {
  const shaderManager = ShaderResourceManager.ShaderResourceManager.getInstance();
  const options = {};
  if (config.clamp !== void 0) options.clamp = config.clamp;
  if (config.kernels !== void 0) options.kernels = config.kernels;
  if (config.pixelSize !== void 0) options.pixelSize = config.pixelSize;
  if (config.pixelSizeX !== void 0) options.pixelSizeX = config.pixelSizeX;
  if (config.pixelSizeY !== void 0) options.pixelSizeY = config.pixelSizeY;
  if (config.quality !== void 0) options.quality = config.quality;
  if (config.strength !== void 0) options.strength = config.strength;
  const qualityStr = (options.quality || 3).toString();
  const clampStr = options.clamp ? "clamp" : "noclamp";
  const shaderKey = `kawase-blur-filter-${qualityStr}-${clampStr}`;
  const filter = new pixiFilters.KawaseBlurFilter(options);
  try {
    shaderManager.registerFilter(filter, shaderKey);
  } catch (error) {
    console.warn("Error registering kawase 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 * 2;
          break;
        case "quality":
          filter.quality = Math.max(1, Math.round(normalizedIntensity));
          break;
        case "pixelSize":
          const pixelSize = 1 + normalizedIntensity / 2.5;
          filter.pixelSize = { x: pixelSize, y: pixelSize };
          break;
        default:
          filter.strength = normalizedIntensity * 2;
      }
    } else {
      filter.strength = normalizedIntensity * 2;
    }
  };
  updateIntensity(config.intensity);
  const reset = () => {
    filter.kernels = config.kernels !== void 0 ? config.kernels : [0];
    if (config.pixelSize !== void 0) {
      filter.pixelSize = config.pixelSize;
    } else if (config.pixelSizeX !== void 0 || config.pixelSizeY !== void 0) {
      const x = config.pixelSizeX !== void 0 ? config.pixelSizeX : 1;
      const y = config.pixelSizeY !== void 0 ? config.pixelSizeY : 1;
      filter.pixelSize = { x, y };
    } else {
      filter.pixelSize = { x: 1, y: 1 };
    }
    filter.quality = config.quality !== void 0 ? config.quality : 3;
    filter.strength = config.strength !== void 0 ? config.strength : 4;
    if (config.intensity !== void 0) {
      updateIntensity(config.intensity);
    }
  };
  const dispose = () => {
    try {
      shaderManager.releaseFilter(filter, shaderKey);
    } catch (error) {
      console.warn("Error releasing kawase blur filter shader:", error);
    }
    filter.destroy();
  };
  return { filter, updateIntensity, reset, dispose };
}

exports.createKawaseBlurFilter = createKawaseBlurFilter;
//# sourceMappingURL=kawaseBlurFilter.cjs.map