Source: gfx/core/renderers/webgl/filters/AbstractFilter.js

var DefaultShader = require('../shaders/TextureShader');

/**
 * This is the base class for creating a PIXI filter. Currently only WebGL supports filters.
 * If you want to make a custom filter this should be your base class.
 *
 * @class
 * @param vertexSrc {string|string[]} The vertex shader source as an array of strings.
 * @param fragmentSrc {string|string[]} The fragment shader source as an array of strings.
 * @param uniforms {object} An object containing the uniforms for this filter.
 */
function AbstractFilter(vertexSrc, fragmentSrc, uniforms) {

    /**
     * An array of shaders
     * @member {PIXI.Shader[]}
     * @private
     */
  this.shaders = [];

    /**
     * The extra padding that the filter might need
     * @member {number}
     */
  this.padding = 0;

    /**
     * The uniforms as an object
     * @member {object}
     */
  this.uniforms = uniforms || {};


    /**
     * The code of the vertex shader
     * @member {string[]}
     * @private
     */
  this.vertexSrc = vertexSrc || DefaultShader.defaultVertexSrc;

    /**
     * The code of the frament shader
     * @member {string[]}
     * @private
     */
  this.fragmentSrc = fragmentSrc || DefaultShader.defaultFragmentSrc;

    // TODO a reminder - would be cool to have lower res filters as this would give better performance.

    // typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);

}

AbstractFilter.prototype.constructor = AbstractFilter;
module.exports = AbstractFilter;

/**
 * Grabs a shader from the current renderer
 *
 * @param renderer {PIXI.WebGLRenderer} The renderer to retrieve the shader from
 */
AbstractFilter.prototype.getShader = function(renderer) {
  var gl = renderer.gl;

  var shader = this.shaders[gl.id];

  if (!shader) {
    shader = new DefaultShader(renderer.shaderManager,
            this.vertexSrc,
            this.fragmentSrc,
            this.uniforms,
            this.attributes
        );

    this.shaders[gl.id] = shader;
  }

  return shader;
};

/**
 * Applies the filter
 *
 * @param renderer {PIXI.WebGLRenderer} The renderer to retrieve the filter from
 * @param input {PIXI.RenderTarget}
 * @param output {PIXI.RenderTarget}
 * @param clear {boolean} Whether or not we want to clear the outputTarget
 */
AbstractFilter.prototype.applyFilter = function(renderer, input, output, clear) {
  var shader = this.getShader(renderer);

  renderer.filterManager.applyFilter(shader, input, output, clear);
};

/**
 * Syncs a uniform between the class object and the shaders.
 *
 */
AbstractFilter.prototype.syncUniform = function(uniform) {
  for (var i = 0, j = this.shaders.length; i < j; ++i) {
    this.shaders[i].syncUniform(uniform);
  }
};