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

A WebGL-powered kinetic slider component using PIXI.js

'use strict';

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

function createMotionBlurFilter(config) {
  const shaderManager = ShaderResourceManager.ShaderResourceManager.getInstance();
  const options = {};
  if (config.kernelSize !== void 0) options.kernelSize = config.kernelSize;
  if (config.offset !== void 0) options.offset = config.offset;
  if (config.velocity !== void 0) options.velocity = config.velocity;
  if (config.velocityX !== void 0) options.velocityX = config.velocityX;
  if (config.velocityY !== void 0) options.velocityY = config.velocityY;
  const kernelSizeStr = (options.kernelSize || 5).toString();
  const shaderKey = `motion-blur-filter-${kernelSizeStr}`;
  const filter = new pixiFilters.MotionBlurFilter(options);
  try {
    shaderManager.registerFilter(filter, shaderKey);
  } catch (error) {
    console.warn("Error registering motion 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 "velocity":
          if (config.direction) {
            const angle = config.direction * Math.PI / 180;
            const velocityMagnitude = normalizedIntensity * 2;
            filter.velocityX = Math.cos(angle) * velocityMagnitude;
            filter.velocityY = Math.sin(angle) * velocityMagnitude;
          } else {
            filter.velocityX = normalizedIntensity * 2;
            filter.velocityY = 0;
          }
          break;
        case "velocityX":
          filter.velocityX = normalizedIntensity * 2;
          break;
        case "velocityY":
          filter.velocityY = normalizedIntensity * 2;
          break;
        case "kernelSize":
          const rawSize = 5 + Math.floor(normalizedIntensity);
          filter.kernelSize = rawSize % 2 === 0 ? rawSize + 1 : rawSize;
          break;
        case "offset":
          filter.offset = normalizedIntensity;
          break;
        default:
          filter.velocityX = normalizedIntensity * 2;
      }
    } else {
      if (config.direction !== void 0) {
        const angle = config.direction * Math.PI / 180;
        const velocityMagnitude = normalizedIntensity * 2;
        filter.velocityX = Math.cos(angle) * velocityMagnitude;
        filter.velocityY = Math.sin(angle) * velocityMagnitude;
      } else {
        filter.velocityX = normalizedIntensity * 2;
        filter.velocityY = 0;
      }
    }
  };
  updateIntensity(config.intensity);
  const reset = () => {
    filter.kernelSize = config.kernelSize !== void 0 ? config.kernelSize : 5;
    filter.offset = config.offset !== void 0 ? config.offset : 0;
    if (config.velocityX !== void 0) {
      filter.velocityX = config.velocityX;
    } else if (config.velocity?.x !== void 0) {
      filter.velocityX = config.velocity.x;
    } else {
      filter.velocityX = 0;
    }
    if (config.velocityY !== void 0) {
      filter.velocityY = config.velocityY;
    } else if (config.velocity?.y !== void 0) {
      filter.velocityY = config.velocity.y;
    } else {
      filter.velocityY = 0;
    }
    if (config.direction !== void 0 && config.velocityX === void 0 && config.velocityY === void 0 && config.velocity === void 0) {
      const angle = config.direction * Math.PI / 180;
      const defaultVelocity = 0;
      filter.velocityX = Math.cos(angle) * defaultVelocity;
      filter.velocityY = Math.sin(angle) * defaultVelocity;
    }
  };
  const dispose = () => {
    try {
      shaderManager.releaseFilter(filter, shaderKey);
    } catch (error) {
      console.warn("Error releasing motion blur filter shader:", error);
    }
    filter.destroy();
  };
  return { filter, updateIntensity, reset, dispose };
}

exports.createMotionBlurFilter = createMotionBlurFilter;
//# sourceMappingURL=motionBlurFilter.cjs.map