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

A WebGL-powered kinetic slider component using PIXI.js

'use strict';

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

function createCRTFilter(config) {
  const shaderManager = ShaderResourceManager.ShaderResourceManager.getInstance();
  const options = {};
  if (config.curvature !== void 0) options.curvature = config.curvature;
  if (config.lineContrast !== void 0) options.lineContrast = config.lineContrast;
  if (config.lineWidth !== void 0) options.lineWidth = config.lineWidth;
  if (config.noise !== void 0) options.noise = config.noise;
  if (config.noiseSize !== void 0) options.noiseSize = config.noiseSize;
  if (config.seed !== void 0) options.seed = config.seed;
  if (config.time !== void 0) options.time = config.time;
  if (config.verticalLine !== void 0) options.verticalLine = config.verticalLine;
  if (config.vignetting !== void 0) options.vignetting = config.vignetting;
  if (config.vignettingAlpha !== void 0) options.vignettingAlpha = config.vignettingAlpha;
  if (config.vignettingBlur !== void 0) options.vignettingBlur = config.vignettingBlur;
  const primaryProp = config.primaryProperty || "noise";
  const shaderKey = `crt-filter-${primaryProp}-${config.verticalLine || false}`;
  const filter = new pixiFilters.CRTFilter(options);
  try {
    shaderManager.registerFilter(filter, shaderKey);
  } catch (error) {
    console.warn("Error registering CRT filter with shader manager:", error);
  }
  const updateIntensity = (intensity) => {
    const normalizedIntensity = Math.max(0, Math.min(10, intensity));
    if (config.primaryProperty) {
      switch (config.primaryProperty) {
        case "noise":
          filter.noise = normalizedIntensity / 10;
          break;
        case "curvature":
          filter.curvature = normalizedIntensity;
          break;
        case "lineContrast":
          filter.lineContrast = normalizedIntensity / 10;
          break;
        case "lineWidth":
          filter.lineWidth = 0.5 + normalizedIntensity / 2;
          break;
        case "vignetting":
          filter.vignetting = normalizedIntensity / 10;
          break;
        case "vignettingAlpha":
          filter.vignettingAlpha = normalizedIntensity / 10;
          break;
        default:
          filter.noise = normalizedIntensity / 10;
      }
    } else {
      filter.noise = normalizedIntensity / 10;
      if (normalizedIntensity > 5) {
        filter.curvature = (normalizedIntensity - 5) / 2;
        filter.vignetting = 0.3 + (normalizedIntensity - 5) / 20;
      }
    }
  };
  updateIntensity(config.intensity);
  const reset = () => {
    filter.curvature = config.curvature !== void 0 ? config.curvature : 1;
    filter.verticalLine = config.verticalLine !== void 0 ? config.verticalLine : false;
    filter.lineContrast = config.lineContrast !== void 0 ? config.lineContrast : 0.25;
    filter.lineWidth = config.lineWidth !== void 0 ? config.lineWidth : 1;
    filter.noise = config.noise !== void 0 ? config.noise : 0.3;
    filter.noiseSize = config.noiseSize !== void 0 ? config.noiseSize : 0;
    filter.seed = config.seed !== void 0 ? config.seed : 0;
    filter.time = config.time !== void 0 ? config.time : 0.3;
    filter.vignetting = config.vignetting !== void 0 ? config.vignetting : 0.3;
    filter.vignettingAlpha = config.vignettingAlpha !== void 0 ? config.vignettingAlpha : 1;
    filter.vignettingBlur = config.vignettingBlur !== void 0 ? config.vignettingBlur : 0.3;
    if (config.intensity !== void 0) {
      updateIntensity(config.intensity);
    }
  };
  const dispose = () => {
    try {
      shaderManager.releaseFilter(filter, shaderKey);
    } catch (error) {
      console.warn("Error releasing CRT filter shader:", error);
    }
    filter.destroy();
  };
  return { filter, updateIntensity, reset, dispose };
}

exports.createCRTFilter = createCRTFilter;
//# sourceMappingURL=crtFilter.cjs.map