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

A WebGL-powered kinetic slider component using PIXI.js

'use strict';

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

const shaderManager = ShaderResourceManager.ShaderResourceManager.getInstance();
function createTiltShiftFilter(config) {
  const options = {};
  if (config.blur !== void 0) options.blur = config.blur;
  if (config.gradientBlur !== void 0) options.gradientBlur = config.gradientBlur;
  if (config.start !== void 0) options.start = config.start;
  if (config.startX !== void 0) options.startX = config.startX;
  if (config.startY !== void 0) options.startY = config.startY;
  if (config.end !== void 0) options.end = config.end;
  if (config.endX !== void 0) options.endX = config.endX;
  if (config.endY !== void 0) options.endY = config.endY;
  const filter = new pixiFilters.TiltShiftFilter(options);
  const shaderKey = `tiltshift-${config.blur || 8}-${config.gradientBlur || 600}`;
  try {
    shaderManager.getShaderProgram(shaderKey, filter);
  } catch (error) {
    console.warn("Failed to register tiltShift filter with shader manager:", error);
  }
  const updateIntensity = (intensity) => {
    const normalizedIntensity = Math.max(0, Math.min(10, intensity));
    if (config.primaryProperty) {
      switch (config.primaryProperty) {
        case "blur":
          filter.blur = normalizedIntensity * 2;
          break;
        case "gradientBlur":
          filter.gradientBlur = normalizedIntensity * 200;
          break;
        case "focusArea":
          const centerY = 0.5;
          const focusHeight = 1 - normalizedIntensity * 0.08;
          const halfHeight = focusHeight / 2;
          filter.startY = centerY - halfHeight;
          filter.endY = centerY + halfHeight;
          break;
        default:
          filter.blur = normalizedIntensity * 2;
      }
    } else {
      filter.blur = normalizedIntensity * 2;
      filter.gradientBlur = normalizedIntensity * 200;
    }
  };
  updateIntensity(config.intensity);
  const reset = () => {
    filter.blur = config.blur !== void 0 ? config.blur : 8;
    filter.gradientBlur = config.gradientBlur !== void 0 ? config.gradientBlur : 600;
    if (config.startX !== void 0) {
      filter.startX = config.startX;
    } else if (config.start?.x !== void 0) {
      filter.startX = config.start.x;
    } else {
      filter.startX = 0;
    }
    if (config.startY !== void 0) {
      filter.startY = config.startY;
    } else if (config.start?.y !== void 0) {
      filter.startY = config.start.y;
    } else {
      filter.startY = 0.3;
    }
    if (config.endX !== void 0) {
      filter.endX = config.endX;
    } else if (config.end?.x !== void 0) {
      filter.endX = config.end.x;
    } else {
      filter.endX = 1;
    }
    if (config.endY !== void 0) {
      filter.endY = config.endY;
    } else if (config.end?.y !== void 0) {
      filter.endY = config.end.y;
    } else {
      filter.endY = 0.7;
    }
  };
  const dispose = () => {
    try {
      shaderManager.releaseShader(shaderKey);
    } catch (error) {
      console.warn("Failed to release tiltShift filter shader:", error);
    }
    if (filter.destroy) {
      filter.destroy();
    }
  };
  const result = {
    filter,
    updateIntensity,
    reset,
    dispose
  };
  return result;
}

exports.createTiltShiftFilter = createTiltShiftFilter;
//# sourceMappingURL=tiltShiftFilter.cjs.map