diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});
diff --git a/src/core/renderers/webgl/managers/BlendModeManager.js b/src/core/renderers/webgl/managers/BlendModeManager.js
new file mode 100644
index 0000000..ec57910
--- /dev/null
+++ b/src/core/renderers/webgl/managers/BlendModeManager.js
@@ -0,0 +1,40 @@
+var WebGLManager = require('./WebGLManager');
+
+/**
+ * @class
+ * @namespace PIXI
+ * @param renderer {WebGLRenderer} The renderer this manager works for.
+ */
+function BlendModeManager(renderer)
+{
+    WebGLManager.call(this, renderer);
+
+    /**
+     * @member {number}
+     */
+    this.currentBlendMode = 99999;
+}
+
+BlendModeManager.prototype = Object.create(WebGLManager.prototype);
+BlendModeManager.prototype.constructor = BlendModeManager;
+module.exports = BlendModeManager;
+
+/**
+ * Sets-up the given blendMode from WebGL's point of view.
+ *
+ * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
+ */
+BlendModeManager.prototype.setBlendMode = function (blendMode)
+{
+    if (this.currentBlendMode === blendMode)
+    {
+        return false;
+    }
+
+    this.currentBlendMode = blendMode;
+
+    var mode = this.renderer.blendModes[this.currentBlendMode];
+    this.renderer.gl.blendFunc(mode[0], mode[1]);
+
+    return true;
+};

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});
diff --git a/src/core/renderers/webgl/managers/BlendModeManager.js b/src/core/renderers/webgl/managers/BlendModeManager.js
new file mode 100644
index 0000000..ec57910
--- /dev/null
+++ b/src/core/renderers/webgl/managers/BlendModeManager.js
@@ -0,0 +1,40 @@
+var WebGLManager = require('./WebGLManager');
+
+/**
+ * @class
+ * @namespace PIXI
+ * @param renderer {WebGLRenderer} The renderer this manager works for.
+ */
+function BlendModeManager(renderer)
+{
+    WebGLManager.call(this, renderer);
+
+    /**
+     * @member {number}
+     */
+    this.currentBlendMode = 99999;
+}
+
+BlendModeManager.prototype = Object.create(WebGLManager.prototype);
+BlendModeManager.prototype.constructor = BlendModeManager;
+module.exports = BlendModeManager;
+
+/**
+ * Sets-up the given blendMode from WebGL's point of view.
+ *
+ * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
+ */
+BlendModeManager.prototype.setBlendMode = function (blendMode)
+{
+    if (this.currentBlendMode === blendMode)
+    {
+        return false;
+    }
+
+    this.currentBlendMode = blendMode;
+
+    var mode = this.renderer.blendModes[this.currentBlendMode];
+    this.renderer.gl.blendFunc(mode[0], mode[1]);
+
+    return true;
+};
diff --git a/src/core/renderers/webgl/managers/MaskManager.js b/src/core/renderers/webgl/managers/MaskManager.js
index 8abe133..be38225 100644
--- a/src/core/renderers/webgl/managers/MaskManager.js
+++ b/src/core/renderers/webgl/managers/MaskManager.js
@@ -1,5 +1,5 @@
 var WebGLManager = require('./WebGLManager'),
-    AlphaMaskFilter = require('../utils/SpriteMaskFilter');
+    AlphaMaskFilter = require('../filters/SpriteMaskFilter');
 
 /**
  * @class

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});
diff --git a/src/core/renderers/webgl/managers/BlendModeManager.js b/src/core/renderers/webgl/managers/BlendModeManager.js
new file mode 100644
index 0000000..ec57910
--- /dev/null
+++ b/src/core/renderers/webgl/managers/BlendModeManager.js
@@ -0,0 +1,40 @@
+var WebGLManager = require('./WebGLManager');
+
+/**
+ * @class
+ * @namespace PIXI
+ * @param renderer {WebGLRenderer} The renderer this manager works for.
+ */
+function BlendModeManager(renderer)
+{
+    WebGLManager.call(this, renderer);
+
+    /**
+     * @member {number}
+     */
+    this.currentBlendMode = 99999;
+}
+
+BlendModeManager.prototype = Object.create(WebGLManager.prototype);
+BlendModeManager.prototype.constructor = BlendModeManager;
+module.exports = BlendModeManager;
+
+/**
+ * Sets-up the given blendMode from WebGL's point of view.
+ *
+ * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
+ */
+BlendModeManager.prototype.setBlendMode = function (blendMode)
+{
+    if (this.currentBlendMode === blendMode)
+    {
+        return false;
+    }
+
+    this.currentBlendMode = blendMode;
+
+    var mode = this.renderer.blendModes[this.currentBlendMode];
+    this.renderer.gl.blendFunc(mode[0], mode[1]);
+
+    return true;
+};
diff --git a/src/core/renderers/webgl/managers/MaskManager.js b/src/core/renderers/webgl/managers/MaskManager.js
index 8abe133..be38225 100644
--- a/src/core/renderers/webgl/managers/MaskManager.js
+++ b/src/core/renderers/webgl/managers/MaskManager.js
@@ -1,5 +1,5 @@
 var WebGLManager = require('./WebGLManager'),
-    AlphaMaskFilter = require('../utils/SpriteMaskFilter');
+    AlphaMaskFilter = require('../filters/SpriteMaskFilter');
 
 /**
  * @class
diff --git a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js b/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
deleted file mode 100644
index 35edbaf..0000000
--- a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
+++ /dev/null
@@ -1,40 +0,0 @@
-var WebGLManager = require('./WebGLManager');
-
-/**
- * @class
- * @namespace PIXI
- * @param renderer {WebGLRenderer} The renderer this manager works for.
- */
-function WebGLBlendModeManager(renderer)
-{
-    WebGLManager.call(this, renderer);
-
-    /**
-     * @member {number}
-     */
-    this.currentBlendMode = 99999;
-}
-
-WebGLBlendModeManager.prototype = Object.create(WebGLManager.prototype);
-WebGLBlendModeManager.prototype.constructor = WebGLBlendModeManager;
-module.exports = WebGLBlendModeManager;
-
-/**
- * Sets-up the given blendMode from WebGL's point of view.
- *
- * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
- */
-WebGLBlendModeManager.prototype.setBlendMode = function (blendMode)
-{
-    if (this.currentBlendMode === blendMode)
-    {
-        return false;
-    }
-
-    this.currentBlendMode = blendMode;
-
-    var mode = this.renderer.blendModes[this.currentBlendMode];
-    this.renderer.gl.blendFunc(mode[0], mode[1]);
-
-    return true;
-};

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});
diff --git a/src/core/renderers/webgl/managers/BlendModeManager.js b/src/core/renderers/webgl/managers/BlendModeManager.js
new file mode 100644
index 0000000..ec57910
--- /dev/null
+++ b/src/core/renderers/webgl/managers/BlendModeManager.js
@@ -0,0 +1,40 @@
+var WebGLManager = require('./WebGLManager');
+
+/**
+ * @class
+ * @namespace PIXI
+ * @param renderer {WebGLRenderer} The renderer this manager works for.
+ */
+function BlendModeManager(renderer)
+{
+    WebGLManager.call(this, renderer);
+
+    /**
+     * @member {number}
+     */
+    this.currentBlendMode = 99999;
+}
+
+BlendModeManager.prototype = Object.create(WebGLManager.prototype);
+BlendModeManager.prototype.constructor = BlendModeManager;
+module.exports = BlendModeManager;
+
+/**
+ * Sets-up the given blendMode from WebGL's point of view.
+ *
+ * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
+ */
+BlendModeManager.prototype.setBlendMode = function (blendMode)
+{
+    if (this.currentBlendMode === blendMode)
+    {
+        return false;
+    }
+
+    this.currentBlendMode = blendMode;
+
+    var mode = this.renderer.blendModes[this.currentBlendMode];
+    this.renderer.gl.blendFunc(mode[0], mode[1]);
+
+    return true;
+};
diff --git a/src/core/renderers/webgl/managers/MaskManager.js b/src/core/renderers/webgl/managers/MaskManager.js
index 8abe133..be38225 100644
--- a/src/core/renderers/webgl/managers/MaskManager.js
+++ b/src/core/renderers/webgl/managers/MaskManager.js
@@ -1,5 +1,5 @@
 var WebGLManager = require('./WebGLManager'),
-    AlphaMaskFilter = require('../utils/SpriteMaskFilter');
+    AlphaMaskFilter = require('../filters/SpriteMaskFilter');
 
 /**
  * @class
diff --git a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js b/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
deleted file mode 100644
index 35edbaf..0000000
--- a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
+++ /dev/null
@@ -1,40 +0,0 @@
-var WebGLManager = require('./WebGLManager');
-
-/**
- * @class
- * @namespace PIXI
- * @param renderer {WebGLRenderer} The renderer this manager works for.
- */
-function WebGLBlendModeManager(renderer)
-{
-    WebGLManager.call(this, renderer);
-
-    /**
-     * @member {number}
-     */
-    this.currentBlendMode = 99999;
-}
-
-WebGLBlendModeManager.prototype = Object.create(WebGLManager.prototype);
-WebGLBlendModeManager.prototype.constructor = WebGLBlendModeManager;
-module.exports = WebGLBlendModeManager;
-
-/**
- * Sets-up the given blendMode from WebGL's point of view.
- *
- * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
- */
-WebGLBlendModeManager.prototype.setBlendMode = function (blendMode)
-{
-    if (this.currentBlendMode === blendMode)
-    {
-        return false;
-    }
-
-    this.currentBlendMode = blendMode;
-
-    var mode = this.renderer.blendModes[this.currentBlendMode];
-    this.renderer.gl.blendFunc(mode[0], mode[1]);
-
-    return true;
-};
diff --git a/src/core/renderers/webgl/utils/AbstractFilter.js b/src/core/renderers/webgl/utils/AbstractFilter.js
deleted file mode 100644
index c440914..0000000
--- a/src/core/renderers/webgl/utils/AbstractFilter.js
+++ /dev/null
@@ -1,104 +0,0 @@
-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
- * @namespace PIXI
- * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
- * @param uniforms {object} An object containing the uniforms for this filter.
- */
-function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
-{
-    /**
-     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
-     * For example the blur filter has two passes blurX and blurY.
-     *
-     * @member {AbstractFilter[]}
-     * @private
-     */
-    this.passes = [this];
-
-    /**
-     * @member {Shader[]}
-     * @private
-     */
-    this.shaders = [];
-
-    /**
-     * @member {number}
-     */
-    this.padding = 0;
-
-    /**
-     * @member {object}
-     * @private
-     */
-    this.uniforms = uniforms || {};
-
-   
-    this.vertexSrc = vertexSrc;
-   
-    /**
-     * @member {string[]}
-     * @private
-     */
-    this.fragmentSrc = fragmentSrc;
-
-
-    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
-
-}
-
-AbstractFilter.prototype.constructor = AbstractFilter;
-module.exports = AbstractFilter;
-
-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;
-};
-
-AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
-{
-    var filterManager = renderer.filterManager,
-    shader = this.getShader(renderer);
-
-     // draw the filter...
-    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);
-    }
-};
-
-/*
-AbstractFilter.prototype.apply = function (frameBuffer)
-{
-    // TODO :)
-};
-*/

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});
diff --git a/src/core/renderers/webgl/managers/BlendModeManager.js b/src/core/renderers/webgl/managers/BlendModeManager.js
new file mode 100644
index 0000000..ec57910
--- /dev/null
+++ b/src/core/renderers/webgl/managers/BlendModeManager.js
@@ -0,0 +1,40 @@
+var WebGLManager = require('./WebGLManager');
+
+/**
+ * @class
+ * @namespace PIXI
+ * @param renderer {WebGLRenderer} The renderer this manager works for.
+ */
+function BlendModeManager(renderer)
+{
+    WebGLManager.call(this, renderer);
+
+    /**
+     * @member {number}
+     */
+    this.currentBlendMode = 99999;
+}
+
+BlendModeManager.prototype = Object.create(WebGLManager.prototype);
+BlendModeManager.prototype.constructor = BlendModeManager;
+module.exports = BlendModeManager;
+
+/**
+ * Sets-up the given blendMode from WebGL's point of view.
+ *
+ * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
+ */
+BlendModeManager.prototype.setBlendMode = function (blendMode)
+{
+    if (this.currentBlendMode === blendMode)
+    {
+        return false;
+    }
+
+    this.currentBlendMode = blendMode;
+
+    var mode = this.renderer.blendModes[this.currentBlendMode];
+    this.renderer.gl.blendFunc(mode[0], mode[1]);
+
+    return true;
+};
diff --git a/src/core/renderers/webgl/managers/MaskManager.js b/src/core/renderers/webgl/managers/MaskManager.js
index 8abe133..be38225 100644
--- a/src/core/renderers/webgl/managers/MaskManager.js
+++ b/src/core/renderers/webgl/managers/MaskManager.js
@@ -1,5 +1,5 @@
 var WebGLManager = require('./WebGLManager'),
-    AlphaMaskFilter = require('../utils/SpriteMaskFilter');
+    AlphaMaskFilter = require('../filters/SpriteMaskFilter');
 
 /**
  * @class
diff --git a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js b/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
deleted file mode 100644
index 35edbaf..0000000
--- a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
+++ /dev/null
@@ -1,40 +0,0 @@
-var WebGLManager = require('./WebGLManager');
-
-/**
- * @class
- * @namespace PIXI
- * @param renderer {WebGLRenderer} The renderer this manager works for.
- */
-function WebGLBlendModeManager(renderer)
-{
-    WebGLManager.call(this, renderer);
-
-    /**
-     * @member {number}
-     */
-    this.currentBlendMode = 99999;
-}
-
-WebGLBlendModeManager.prototype = Object.create(WebGLManager.prototype);
-WebGLBlendModeManager.prototype.constructor = WebGLBlendModeManager;
-module.exports = WebGLBlendModeManager;
-
-/**
- * Sets-up the given blendMode from WebGL's point of view.
- *
- * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
- */
-WebGLBlendModeManager.prototype.setBlendMode = function (blendMode)
-{
-    if (this.currentBlendMode === blendMode)
-    {
-        return false;
-    }
-
-    this.currentBlendMode = blendMode;
-
-    var mode = this.renderer.blendModes[this.currentBlendMode];
-    this.renderer.gl.blendFunc(mode[0], mode[1]);
-
-    return true;
-};
diff --git a/src/core/renderers/webgl/utils/AbstractFilter.js b/src/core/renderers/webgl/utils/AbstractFilter.js
deleted file mode 100644
index c440914..0000000
--- a/src/core/renderers/webgl/utils/AbstractFilter.js
+++ /dev/null
@@ -1,104 +0,0 @@
-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
- * @namespace PIXI
- * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
- * @param uniforms {object} An object containing the uniforms for this filter.
- */
-function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
-{
-    /**
-     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
-     * For example the blur filter has two passes blurX and blurY.
-     *
-     * @member {AbstractFilter[]}
-     * @private
-     */
-    this.passes = [this];
-
-    /**
-     * @member {Shader[]}
-     * @private
-     */
-    this.shaders = [];
-
-    /**
-     * @member {number}
-     */
-    this.padding = 0;
-
-    /**
-     * @member {object}
-     * @private
-     */
-    this.uniforms = uniforms || {};
-
-   
-    this.vertexSrc = vertexSrc;
-   
-    /**
-     * @member {string[]}
-     * @private
-     */
-    this.fragmentSrc = fragmentSrc;
-
-
-    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
-
-}
-
-AbstractFilter.prototype.constructor = AbstractFilter;
-module.exports = AbstractFilter;
-
-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;
-};
-
-AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
-{
-    var filterManager = renderer.filterManager,
-    shader = this.getShader(renderer);
-
-     // draw the filter...
-    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);
-    }
-};
-
-/*
-AbstractFilter.prototype.apply = function (frameBuffer)
-{
-    // TODO :)
-};
-*/
diff --git a/src/core/renderers/webgl/utils/SpriteMaskFilter.js b/src/core/renderers/webgl/utils/SpriteMaskFilter.js
deleted file mode 100644
index cceb88a..0000000
--- a/src/core/renderers/webgl/utils/SpriteMaskFilter.js
+++ /dev/null
@@ -1,121 +0,0 @@
-var AbstractFilter = require('./AbstractFilter'),
-    math =  require('../../../math');
-
-/**
- * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
- * You can use this filter to apply all manor of crazy warping effects
- * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
- *
- * @class
- * @extends AbstractFilter
- * @namespace PIXI
- * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
- */
-function SpriteMaskFilter(sprite)
-{
-    var maskMatrix = new math.Matrix();
-
-    AbstractFilter.call(this,
-    // vertex shader
-    [
-        'attribute vec2 aVertexPosition;',
-        'attribute vec2 aTextureCoord;',
-        'attribute vec4 aColor;',
-
-        'uniform mat3 projectionMatrix;',
-        'uniform mat3 otherMatrix;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'void main(void)',
-        '{',
-        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
-        '   vTextureCoord = aTextureCoord;',
-        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
-        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
-        '}'
-    ].join('\n'),
-    // fragment shader
-    [
-        'precision lowp float;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'uniform sampler2D uSampler;',
-        'uniform sampler2D mask;',
-
-        'void main(void)',
-        '{',
-        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
-        '   vec4 masky =  texture2D(mask, vMaskCoord);',
-        '   original *= (masky.r * masky.a);',
-        '   gl_FragColor =  original;',
-        '}'
-    ].join('\n'),
-    // uniforms
-    {
-        mask:           { type: 'sampler2D',    value: sprite.texture },
-        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
-    });
-
-    this.maskSprite = sprite;
-    this.maskMatrix = maskMatrix;
-}
-
-SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
-SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
-module.exports = SpriteMaskFilter;
-
-SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
-{
-    var filterManager = renderer.filterManager;
-
-    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
-
-    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
-
-    var shader = this.getShader(renderer);
-     // draw the filter...
-    filterManager.applyFilter(shader, input, output);
-};
-
-
-Object.defineProperties(SpriteMaskFilter.prototype, {
-    /**
-     * The texture used for the displacement map. Must be power of 2 sized texture.
-     *
-     * @member {Texture}
-     * @memberof SpriteMaskFilter#
-     */
-    map: {
-        get: function ()
-        {
-            return this.uniforms.mask.value;
-        },
-        set: function (value)
-        {
-            this.uniforms.mask.value = value;
-        }
-    },
-
-    /**
-     * The offset used to move the displacement map.
-     *
-     * @member {Point}
-     * @memberof SpriteMaskFilter#
-     */
-    offset: {
-        get: function()
-        {
-            return this.uniforms.offset.value;
-        },
-        set: function(value)
-        {
-            this.uniforms.offset.value = value;
-        }
-    }
-});

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});
diff --git a/src/core/renderers/webgl/managers/BlendModeManager.js b/src/core/renderers/webgl/managers/BlendModeManager.js
new file mode 100644
index 0000000..ec57910
--- /dev/null
+++ b/src/core/renderers/webgl/managers/BlendModeManager.js
@@ -0,0 +1,40 @@
+var WebGLManager = require('./WebGLManager');
+
+/**
+ * @class
+ * @namespace PIXI
+ * @param renderer {WebGLRenderer} The renderer this manager works for.
+ */
+function BlendModeManager(renderer)
+{
+    WebGLManager.call(this, renderer);
+
+    /**
+     * @member {number}
+     */
+    this.currentBlendMode = 99999;
+}
+
+BlendModeManager.prototype = Object.create(WebGLManager.prototype);
+BlendModeManager.prototype.constructor = BlendModeManager;
+module.exports = BlendModeManager;
+
+/**
+ * Sets-up the given blendMode from WebGL's point of view.
+ *
+ * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
+ */
+BlendModeManager.prototype.setBlendMode = function (blendMode)
+{
+    if (this.currentBlendMode === blendMode)
+    {
+        return false;
+    }
+
+    this.currentBlendMode = blendMode;
+
+    var mode = this.renderer.blendModes[this.currentBlendMode];
+    this.renderer.gl.blendFunc(mode[0], mode[1]);
+
+    return true;
+};
diff --git a/src/core/renderers/webgl/managers/MaskManager.js b/src/core/renderers/webgl/managers/MaskManager.js
index 8abe133..be38225 100644
--- a/src/core/renderers/webgl/managers/MaskManager.js
+++ b/src/core/renderers/webgl/managers/MaskManager.js
@@ -1,5 +1,5 @@
 var WebGLManager = require('./WebGLManager'),
-    AlphaMaskFilter = require('../utils/SpriteMaskFilter');
+    AlphaMaskFilter = require('../filters/SpriteMaskFilter');
 
 /**
  * @class
diff --git a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js b/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
deleted file mode 100644
index 35edbaf..0000000
--- a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
+++ /dev/null
@@ -1,40 +0,0 @@
-var WebGLManager = require('./WebGLManager');
-
-/**
- * @class
- * @namespace PIXI
- * @param renderer {WebGLRenderer} The renderer this manager works for.
- */
-function WebGLBlendModeManager(renderer)
-{
-    WebGLManager.call(this, renderer);
-
-    /**
-     * @member {number}
-     */
-    this.currentBlendMode = 99999;
-}
-
-WebGLBlendModeManager.prototype = Object.create(WebGLManager.prototype);
-WebGLBlendModeManager.prototype.constructor = WebGLBlendModeManager;
-module.exports = WebGLBlendModeManager;
-
-/**
- * Sets-up the given blendMode from WebGL's point of view.
- *
- * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
- */
-WebGLBlendModeManager.prototype.setBlendMode = function (blendMode)
-{
-    if (this.currentBlendMode === blendMode)
-    {
-        return false;
-    }
-
-    this.currentBlendMode = blendMode;
-
-    var mode = this.renderer.blendModes[this.currentBlendMode];
-    this.renderer.gl.blendFunc(mode[0], mode[1]);
-
-    return true;
-};
diff --git a/src/core/renderers/webgl/utils/AbstractFilter.js b/src/core/renderers/webgl/utils/AbstractFilter.js
deleted file mode 100644
index c440914..0000000
--- a/src/core/renderers/webgl/utils/AbstractFilter.js
+++ /dev/null
@@ -1,104 +0,0 @@
-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
- * @namespace PIXI
- * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
- * @param uniforms {object} An object containing the uniforms for this filter.
- */
-function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
-{
-    /**
-     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
-     * For example the blur filter has two passes blurX and blurY.
-     *
-     * @member {AbstractFilter[]}
-     * @private
-     */
-    this.passes = [this];
-
-    /**
-     * @member {Shader[]}
-     * @private
-     */
-    this.shaders = [];
-
-    /**
-     * @member {number}
-     */
-    this.padding = 0;
-
-    /**
-     * @member {object}
-     * @private
-     */
-    this.uniforms = uniforms || {};
-
-   
-    this.vertexSrc = vertexSrc;
-   
-    /**
-     * @member {string[]}
-     * @private
-     */
-    this.fragmentSrc = fragmentSrc;
-
-
-    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
-
-}
-
-AbstractFilter.prototype.constructor = AbstractFilter;
-module.exports = AbstractFilter;
-
-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;
-};
-
-AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
-{
-    var filterManager = renderer.filterManager,
-    shader = this.getShader(renderer);
-
-     // draw the filter...
-    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);
-    }
-};
-
-/*
-AbstractFilter.prototype.apply = function (frameBuffer)
-{
-    // TODO :)
-};
-*/
diff --git a/src/core/renderers/webgl/utils/SpriteMaskFilter.js b/src/core/renderers/webgl/utils/SpriteMaskFilter.js
deleted file mode 100644
index cceb88a..0000000
--- a/src/core/renderers/webgl/utils/SpriteMaskFilter.js
+++ /dev/null
@@ -1,121 +0,0 @@
-var AbstractFilter = require('./AbstractFilter'),
-    math =  require('../../../math');
-
-/**
- * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
- * You can use this filter to apply all manor of crazy warping effects
- * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
- *
- * @class
- * @extends AbstractFilter
- * @namespace PIXI
- * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
- */
-function SpriteMaskFilter(sprite)
-{
-    var maskMatrix = new math.Matrix();
-
-    AbstractFilter.call(this,
-    // vertex shader
-    [
-        'attribute vec2 aVertexPosition;',
-        'attribute vec2 aTextureCoord;',
-        'attribute vec4 aColor;',
-
-        'uniform mat3 projectionMatrix;',
-        'uniform mat3 otherMatrix;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'void main(void)',
-        '{',
-        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
-        '   vTextureCoord = aTextureCoord;',
-        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
-        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
-        '}'
-    ].join('\n'),
-    // fragment shader
-    [
-        'precision lowp float;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'uniform sampler2D uSampler;',
-        'uniform sampler2D mask;',
-
-        'void main(void)',
-        '{',
-        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
-        '   vec4 masky =  texture2D(mask, vMaskCoord);',
-        '   original *= (masky.r * masky.a);',
-        '   gl_FragColor =  original;',
-        '}'
-    ].join('\n'),
-    // uniforms
-    {
-        mask:           { type: 'sampler2D',    value: sprite.texture },
-        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
-    });
-
-    this.maskSprite = sprite;
-    this.maskMatrix = maskMatrix;
-}
-
-SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
-SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
-module.exports = SpriteMaskFilter;
-
-SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
-{
-    var filterManager = renderer.filterManager;
-
-    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
-
-    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
-
-    var shader = this.getShader(renderer);
-     // draw the filter...
-    filterManager.applyFilter(shader, input, output);
-};
-
-
-Object.defineProperties(SpriteMaskFilter.prototype, {
-    /**
-     * The texture used for the displacement map. Must be power of 2 sized texture.
-     *
-     * @member {Texture}
-     * @memberof SpriteMaskFilter#
-     */
-    map: {
-        get: function ()
-        {
-            return this.uniforms.mask.value;
-        },
-        set: function (value)
-        {
-            this.uniforms.mask.value = value;
-        }
-    },
-
-    /**
-     * The offset used to move the displacement map.
-     *
-     * @member {Point}
-     * @memberof SpriteMaskFilter#
-     */
-    offset: {
-        get: function()
-        {
-            return this.uniforms.offset.value;
-        },
-        set: function(value)
-        {
-            this.uniforms.offset.value = value;
-        }
-    }
-});
diff --git a/src/filters/BloomFilter.js b/src/filters/BloomFilter.js
index c10c658..23f2441 100644
--- a/src/filters/BloomFilter.js
+++ b/src/filters/BloomFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     BlurXFilter = require('./BlurXFilter'),
     BlurYFilter = require('./BlurYFilter'),
     CONST = require('../core/const');

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});
diff --git a/src/core/renderers/webgl/managers/BlendModeManager.js b/src/core/renderers/webgl/managers/BlendModeManager.js
new file mode 100644
index 0000000..ec57910
--- /dev/null
+++ b/src/core/renderers/webgl/managers/BlendModeManager.js
@@ -0,0 +1,40 @@
+var WebGLManager = require('./WebGLManager');
+
+/**
+ * @class
+ * @namespace PIXI
+ * @param renderer {WebGLRenderer} The renderer this manager works for.
+ */
+function BlendModeManager(renderer)
+{
+    WebGLManager.call(this, renderer);
+
+    /**
+     * @member {number}
+     */
+    this.currentBlendMode = 99999;
+}
+
+BlendModeManager.prototype = Object.create(WebGLManager.prototype);
+BlendModeManager.prototype.constructor = BlendModeManager;
+module.exports = BlendModeManager;
+
+/**
+ * Sets-up the given blendMode from WebGL's point of view.
+ *
+ * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
+ */
+BlendModeManager.prototype.setBlendMode = function (blendMode)
+{
+    if (this.currentBlendMode === blendMode)
+    {
+        return false;
+    }
+
+    this.currentBlendMode = blendMode;
+
+    var mode = this.renderer.blendModes[this.currentBlendMode];
+    this.renderer.gl.blendFunc(mode[0], mode[1]);
+
+    return true;
+};
diff --git a/src/core/renderers/webgl/managers/MaskManager.js b/src/core/renderers/webgl/managers/MaskManager.js
index 8abe133..be38225 100644
--- a/src/core/renderers/webgl/managers/MaskManager.js
+++ b/src/core/renderers/webgl/managers/MaskManager.js
@@ -1,5 +1,5 @@
 var WebGLManager = require('./WebGLManager'),
-    AlphaMaskFilter = require('../utils/SpriteMaskFilter');
+    AlphaMaskFilter = require('../filters/SpriteMaskFilter');
 
 /**
  * @class
diff --git a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js b/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
deleted file mode 100644
index 35edbaf..0000000
--- a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
+++ /dev/null
@@ -1,40 +0,0 @@
-var WebGLManager = require('./WebGLManager');
-
-/**
- * @class
- * @namespace PIXI
- * @param renderer {WebGLRenderer} The renderer this manager works for.
- */
-function WebGLBlendModeManager(renderer)
-{
-    WebGLManager.call(this, renderer);
-
-    /**
-     * @member {number}
-     */
-    this.currentBlendMode = 99999;
-}
-
-WebGLBlendModeManager.prototype = Object.create(WebGLManager.prototype);
-WebGLBlendModeManager.prototype.constructor = WebGLBlendModeManager;
-module.exports = WebGLBlendModeManager;
-
-/**
- * Sets-up the given blendMode from WebGL's point of view.
- *
- * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
- */
-WebGLBlendModeManager.prototype.setBlendMode = function (blendMode)
-{
-    if (this.currentBlendMode === blendMode)
-    {
-        return false;
-    }
-
-    this.currentBlendMode = blendMode;
-
-    var mode = this.renderer.blendModes[this.currentBlendMode];
-    this.renderer.gl.blendFunc(mode[0], mode[1]);
-
-    return true;
-};
diff --git a/src/core/renderers/webgl/utils/AbstractFilter.js b/src/core/renderers/webgl/utils/AbstractFilter.js
deleted file mode 100644
index c440914..0000000
--- a/src/core/renderers/webgl/utils/AbstractFilter.js
+++ /dev/null
@@ -1,104 +0,0 @@
-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
- * @namespace PIXI
- * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
- * @param uniforms {object} An object containing the uniforms for this filter.
- */
-function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
-{
-    /**
-     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
-     * For example the blur filter has two passes blurX and blurY.
-     *
-     * @member {AbstractFilter[]}
-     * @private
-     */
-    this.passes = [this];
-
-    /**
-     * @member {Shader[]}
-     * @private
-     */
-    this.shaders = [];
-
-    /**
-     * @member {number}
-     */
-    this.padding = 0;
-
-    /**
-     * @member {object}
-     * @private
-     */
-    this.uniforms = uniforms || {};
-
-   
-    this.vertexSrc = vertexSrc;
-   
-    /**
-     * @member {string[]}
-     * @private
-     */
-    this.fragmentSrc = fragmentSrc;
-
-
-    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
-
-}
-
-AbstractFilter.prototype.constructor = AbstractFilter;
-module.exports = AbstractFilter;
-
-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;
-};
-
-AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
-{
-    var filterManager = renderer.filterManager,
-    shader = this.getShader(renderer);
-
-     // draw the filter...
-    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);
-    }
-};
-
-/*
-AbstractFilter.prototype.apply = function (frameBuffer)
-{
-    // TODO :)
-};
-*/
diff --git a/src/core/renderers/webgl/utils/SpriteMaskFilter.js b/src/core/renderers/webgl/utils/SpriteMaskFilter.js
deleted file mode 100644
index cceb88a..0000000
--- a/src/core/renderers/webgl/utils/SpriteMaskFilter.js
+++ /dev/null
@@ -1,121 +0,0 @@
-var AbstractFilter = require('./AbstractFilter'),
-    math =  require('../../../math');
-
-/**
- * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
- * You can use this filter to apply all manor of crazy warping effects
- * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
- *
- * @class
- * @extends AbstractFilter
- * @namespace PIXI
- * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
- */
-function SpriteMaskFilter(sprite)
-{
-    var maskMatrix = new math.Matrix();
-
-    AbstractFilter.call(this,
-    // vertex shader
-    [
-        'attribute vec2 aVertexPosition;',
-        'attribute vec2 aTextureCoord;',
-        'attribute vec4 aColor;',
-
-        'uniform mat3 projectionMatrix;',
-        'uniform mat3 otherMatrix;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'void main(void)',
-        '{',
-        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
-        '   vTextureCoord = aTextureCoord;',
-        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
-        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
-        '}'
-    ].join('\n'),
-    // fragment shader
-    [
-        'precision lowp float;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'uniform sampler2D uSampler;',
-        'uniform sampler2D mask;',
-
-        'void main(void)',
-        '{',
-        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
-        '   vec4 masky =  texture2D(mask, vMaskCoord);',
-        '   original *= (masky.r * masky.a);',
-        '   gl_FragColor =  original;',
-        '}'
-    ].join('\n'),
-    // uniforms
-    {
-        mask:           { type: 'sampler2D',    value: sprite.texture },
-        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
-    });
-
-    this.maskSprite = sprite;
-    this.maskMatrix = maskMatrix;
-}
-
-SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
-SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
-module.exports = SpriteMaskFilter;
-
-SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
-{
-    var filterManager = renderer.filterManager;
-
-    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
-
-    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
-
-    var shader = this.getShader(renderer);
-     // draw the filter...
-    filterManager.applyFilter(shader, input, output);
-};
-
-
-Object.defineProperties(SpriteMaskFilter.prototype, {
-    /**
-     * The texture used for the displacement map. Must be power of 2 sized texture.
-     *
-     * @member {Texture}
-     * @memberof SpriteMaskFilter#
-     */
-    map: {
-        get: function ()
-        {
-            return this.uniforms.mask.value;
-        },
-        set: function (value)
-        {
-            this.uniforms.mask.value = value;
-        }
-    },
-
-    /**
-     * The offset used to move the displacement map.
-     *
-     * @member {Point}
-     * @memberof SpriteMaskFilter#
-     */
-    offset: {
-        get: function()
-        {
-            return this.uniforms.offset.value;
-        },
-        set: function(value)
-        {
-            this.uniforms.offset.value = value;
-        }
-    }
-});
diff --git a/src/filters/BloomFilter.js b/src/filters/BloomFilter.js
index c10c658..23f2441 100644
--- a/src/filters/BloomFilter.js
+++ b/src/filters/BloomFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     BlurXFilter = require('./BlurXFilter'),
     BlurYFilter = require('./BlurYFilter'),
     CONST = require('../core/const');
diff --git a/src/filters/BlurFilter.js b/src/filters/BlurFilter.js
index e50f425..0907032 100644
--- a/src/filters/BlurFilter.js
+++ b/src/filters/BlurFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     BlurXFilter = require('./BlurXFilter'),
     BlurYFilter = require('./BlurYFilter');
 
@@ -28,10 +28,10 @@
 {
     var filterManager = renderer.filterManager;
 
-    var renderTarget = filterManager.getRenderTarget();
+    var renderTarget = filterManager.getRenderTarget(true);
 
     this.blurXFilter.applyFilter(renderer, input, renderTarget);
-    
+
     this.blurYFilter.applyFilter(renderer, renderTarget, output);
 
     filterManager.returnRenderTarget( renderTarget );

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});
diff --git a/src/core/renderers/webgl/managers/BlendModeManager.js b/src/core/renderers/webgl/managers/BlendModeManager.js
new file mode 100644
index 0000000..ec57910
--- /dev/null
+++ b/src/core/renderers/webgl/managers/BlendModeManager.js
@@ -0,0 +1,40 @@
+var WebGLManager = require('./WebGLManager');
+
+/**
+ * @class
+ * @namespace PIXI
+ * @param renderer {WebGLRenderer} The renderer this manager works for.
+ */
+function BlendModeManager(renderer)
+{
+    WebGLManager.call(this, renderer);
+
+    /**
+     * @member {number}
+     */
+    this.currentBlendMode = 99999;
+}
+
+BlendModeManager.prototype = Object.create(WebGLManager.prototype);
+BlendModeManager.prototype.constructor = BlendModeManager;
+module.exports = BlendModeManager;
+
+/**
+ * Sets-up the given blendMode from WebGL's point of view.
+ *
+ * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
+ */
+BlendModeManager.prototype.setBlendMode = function (blendMode)
+{
+    if (this.currentBlendMode === blendMode)
+    {
+        return false;
+    }
+
+    this.currentBlendMode = blendMode;
+
+    var mode = this.renderer.blendModes[this.currentBlendMode];
+    this.renderer.gl.blendFunc(mode[0], mode[1]);
+
+    return true;
+};
diff --git a/src/core/renderers/webgl/managers/MaskManager.js b/src/core/renderers/webgl/managers/MaskManager.js
index 8abe133..be38225 100644
--- a/src/core/renderers/webgl/managers/MaskManager.js
+++ b/src/core/renderers/webgl/managers/MaskManager.js
@@ -1,5 +1,5 @@
 var WebGLManager = require('./WebGLManager'),
-    AlphaMaskFilter = require('../utils/SpriteMaskFilter');
+    AlphaMaskFilter = require('../filters/SpriteMaskFilter');
 
 /**
  * @class
diff --git a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js b/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
deleted file mode 100644
index 35edbaf..0000000
--- a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
+++ /dev/null
@@ -1,40 +0,0 @@
-var WebGLManager = require('./WebGLManager');
-
-/**
- * @class
- * @namespace PIXI
- * @param renderer {WebGLRenderer} The renderer this manager works for.
- */
-function WebGLBlendModeManager(renderer)
-{
-    WebGLManager.call(this, renderer);
-
-    /**
-     * @member {number}
-     */
-    this.currentBlendMode = 99999;
-}
-
-WebGLBlendModeManager.prototype = Object.create(WebGLManager.prototype);
-WebGLBlendModeManager.prototype.constructor = WebGLBlendModeManager;
-module.exports = WebGLBlendModeManager;
-
-/**
- * Sets-up the given blendMode from WebGL's point of view.
- *
- * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
- */
-WebGLBlendModeManager.prototype.setBlendMode = function (blendMode)
-{
-    if (this.currentBlendMode === blendMode)
-    {
-        return false;
-    }
-
-    this.currentBlendMode = blendMode;
-
-    var mode = this.renderer.blendModes[this.currentBlendMode];
-    this.renderer.gl.blendFunc(mode[0], mode[1]);
-
-    return true;
-};
diff --git a/src/core/renderers/webgl/utils/AbstractFilter.js b/src/core/renderers/webgl/utils/AbstractFilter.js
deleted file mode 100644
index c440914..0000000
--- a/src/core/renderers/webgl/utils/AbstractFilter.js
+++ /dev/null
@@ -1,104 +0,0 @@
-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
- * @namespace PIXI
- * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
- * @param uniforms {object} An object containing the uniforms for this filter.
- */
-function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
-{
-    /**
-     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
-     * For example the blur filter has two passes blurX and blurY.
-     *
-     * @member {AbstractFilter[]}
-     * @private
-     */
-    this.passes = [this];
-
-    /**
-     * @member {Shader[]}
-     * @private
-     */
-    this.shaders = [];
-
-    /**
-     * @member {number}
-     */
-    this.padding = 0;
-
-    /**
-     * @member {object}
-     * @private
-     */
-    this.uniforms = uniforms || {};
-
-   
-    this.vertexSrc = vertexSrc;
-   
-    /**
-     * @member {string[]}
-     * @private
-     */
-    this.fragmentSrc = fragmentSrc;
-
-
-    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
-
-}
-
-AbstractFilter.prototype.constructor = AbstractFilter;
-module.exports = AbstractFilter;
-
-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;
-};
-
-AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
-{
-    var filterManager = renderer.filterManager,
-    shader = this.getShader(renderer);
-
-     // draw the filter...
-    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);
-    }
-};
-
-/*
-AbstractFilter.prototype.apply = function (frameBuffer)
-{
-    // TODO :)
-};
-*/
diff --git a/src/core/renderers/webgl/utils/SpriteMaskFilter.js b/src/core/renderers/webgl/utils/SpriteMaskFilter.js
deleted file mode 100644
index cceb88a..0000000
--- a/src/core/renderers/webgl/utils/SpriteMaskFilter.js
+++ /dev/null
@@ -1,121 +0,0 @@
-var AbstractFilter = require('./AbstractFilter'),
-    math =  require('../../../math');
-
-/**
- * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
- * You can use this filter to apply all manor of crazy warping effects
- * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
- *
- * @class
- * @extends AbstractFilter
- * @namespace PIXI
- * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
- */
-function SpriteMaskFilter(sprite)
-{
-    var maskMatrix = new math.Matrix();
-
-    AbstractFilter.call(this,
-    // vertex shader
-    [
-        'attribute vec2 aVertexPosition;',
-        'attribute vec2 aTextureCoord;',
-        'attribute vec4 aColor;',
-
-        'uniform mat3 projectionMatrix;',
-        'uniform mat3 otherMatrix;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'void main(void)',
-        '{',
-        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
-        '   vTextureCoord = aTextureCoord;',
-        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
-        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
-        '}'
-    ].join('\n'),
-    // fragment shader
-    [
-        'precision lowp float;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'uniform sampler2D uSampler;',
-        'uniform sampler2D mask;',
-
-        'void main(void)',
-        '{',
-        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
-        '   vec4 masky =  texture2D(mask, vMaskCoord);',
-        '   original *= (masky.r * masky.a);',
-        '   gl_FragColor =  original;',
-        '}'
-    ].join('\n'),
-    // uniforms
-    {
-        mask:           { type: 'sampler2D',    value: sprite.texture },
-        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
-    });
-
-    this.maskSprite = sprite;
-    this.maskMatrix = maskMatrix;
-}
-
-SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
-SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
-module.exports = SpriteMaskFilter;
-
-SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
-{
-    var filterManager = renderer.filterManager;
-
-    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
-
-    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
-
-    var shader = this.getShader(renderer);
-     // draw the filter...
-    filterManager.applyFilter(shader, input, output);
-};
-
-
-Object.defineProperties(SpriteMaskFilter.prototype, {
-    /**
-     * The texture used for the displacement map. Must be power of 2 sized texture.
-     *
-     * @member {Texture}
-     * @memberof SpriteMaskFilter#
-     */
-    map: {
-        get: function ()
-        {
-            return this.uniforms.mask.value;
-        },
-        set: function (value)
-        {
-            this.uniforms.mask.value = value;
-        }
-    },
-
-    /**
-     * The offset used to move the displacement map.
-     *
-     * @member {Point}
-     * @memberof SpriteMaskFilter#
-     */
-    offset: {
-        get: function()
-        {
-            return this.uniforms.offset.value;
-        },
-        set: function(value)
-        {
-            this.uniforms.offset.value = value;
-        }
-    }
-});
diff --git a/src/filters/BloomFilter.js b/src/filters/BloomFilter.js
index c10c658..23f2441 100644
--- a/src/filters/BloomFilter.js
+++ b/src/filters/BloomFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     BlurXFilter = require('./BlurXFilter'),
     BlurYFilter = require('./BlurYFilter'),
     CONST = require('../core/const');
diff --git a/src/filters/BlurFilter.js b/src/filters/BlurFilter.js
index e50f425..0907032 100644
--- a/src/filters/BlurFilter.js
+++ b/src/filters/BlurFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     BlurXFilter = require('./BlurXFilter'),
     BlurYFilter = require('./BlurYFilter');
 
@@ -28,10 +28,10 @@
 {
     var filterManager = renderer.filterManager;
 
-    var renderTarget = filterManager.getRenderTarget();
+    var renderTarget = filterManager.getRenderTarget(true);
 
     this.blurXFilter.applyFilter(renderer, input, renderTarget);
-    
+
     this.blurYFilter.applyFilter(renderer, renderTarget, output);
 
     filterManager.returnRenderTarget( renderTarget );
diff --git a/src/filters/BlurXFilter.js b/src/filters/BlurXFilter.js
index bddd4dd..d56401a 100644
--- a/src/filters/BlurXFilter.js
+++ b/src/filters/BlurXFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     blurFactor = 1 / 7000;
 
 /**

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});
diff --git a/src/core/renderers/webgl/managers/BlendModeManager.js b/src/core/renderers/webgl/managers/BlendModeManager.js
new file mode 100644
index 0000000..ec57910
--- /dev/null
+++ b/src/core/renderers/webgl/managers/BlendModeManager.js
@@ -0,0 +1,40 @@
+var WebGLManager = require('./WebGLManager');
+
+/**
+ * @class
+ * @namespace PIXI
+ * @param renderer {WebGLRenderer} The renderer this manager works for.
+ */
+function BlendModeManager(renderer)
+{
+    WebGLManager.call(this, renderer);
+
+    /**
+     * @member {number}
+     */
+    this.currentBlendMode = 99999;
+}
+
+BlendModeManager.prototype = Object.create(WebGLManager.prototype);
+BlendModeManager.prototype.constructor = BlendModeManager;
+module.exports = BlendModeManager;
+
+/**
+ * Sets-up the given blendMode from WebGL's point of view.
+ *
+ * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
+ */
+BlendModeManager.prototype.setBlendMode = function (blendMode)
+{
+    if (this.currentBlendMode === blendMode)
+    {
+        return false;
+    }
+
+    this.currentBlendMode = blendMode;
+
+    var mode = this.renderer.blendModes[this.currentBlendMode];
+    this.renderer.gl.blendFunc(mode[0], mode[1]);
+
+    return true;
+};
diff --git a/src/core/renderers/webgl/managers/MaskManager.js b/src/core/renderers/webgl/managers/MaskManager.js
index 8abe133..be38225 100644
--- a/src/core/renderers/webgl/managers/MaskManager.js
+++ b/src/core/renderers/webgl/managers/MaskManager.js
@@ -1,5 +1,5 @@
 var WebGLManager = require('./WebGLManager'),
-    AlphaMaskFilter = require('../utils/SpriteMaskFilter');
+    AlphaMaskFilter = require('../filters/SpriteMaskFilter');
 
 /**
  * @class
diff --git a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js b/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
deleted file mode 100644
index 35edbaf..0000000
--- a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
+++ /dev/null
@@ -1,40 +0,0 @@
-var WebGLManager = require('./WebGLManager');
-
-/**
- * @class
- * @namespace PIXI
- * @param renderer {WebGLRenderer} The renderer this manager works for.
- */
-function WebGLBlendModeManager(renderer)
-{
-    WebGLManager.call(this, renderer);
-
-    /**
-     * @member {number}
-     */
-    this.currentBlendMode = 99999;
-}
-
-WebGLBlendModeManager.prototype = Object.create(WebGLManager.prototype);
-WebGLBlendModeManager.prototype.constructor = WebGLBlendModeManager;
-module.exports = WebGLBlendModeManager;
-
-/**
- * Sets-up the given blendMode from WebGL's point of view.
- *
- * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
- */
-WebGLBlendModeManager.prototype.setBlendMode = function (blendMode)
-{
-    if (this.currentBlendMode === blendMode)
-    {
-        return false;
-    }
-
-    this.currentBlendMode = blendMode;
-
-    var mode = this.renderer.blendModes[this.currentBlendMode];
-    this.renderer.gl.blendFunc(mode[0], mode[1]);
-
-    return true;
-};
diff --git a/src/core/renderers/webgl/utils/AbstractFilter.js b/src/core/renderers/webgl/utils/AbstractFilter.js
deleted file mode 100644
index c440914..0000000
--- a/src/core/renderers/webgl/utils/AbstractFilter.js
+++ /dev/null
@@ -1,104 +0,0 @@
-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
- * @namespace PIXI
- * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
- * @param uniforms {object} An object containing the uniforms for this filter.
- */
-function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
-{
-    /**
-     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
-     * For example the blur filter has two passes blurX and blurY.
-     *
-     * @member {AbstractFilter[]}
-     * @private
-     */
-    this.passes = [this];
-
-    /**
-     * @member {Shader[]}
-     * @private
-     */
-    this.shaders = [];
-
-    /**
-     * @member {number}
-     */
-    this.padding = 0;
-
-    /**
-     * @member {object}
-     * @private
-     */
-    this.uniforms = uniforms || {};
-
-   
-    this.vertexSrc = vertexSrc;
-   
-    /**
-     * @member {string[]}
-     * @private
-     */
-    this.fragmentSrc = fragmentSrc;
-
-
-    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
-
-}
-
-AbstractFilter.prototype.constructor = AbstractFilter;
-module.exports = AbstractFilter;
-
-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;
-};
-
-AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
-{
-    var filterManager = renderer.filterManager,
-    shader = this.getShader(renderer);
-
-     // draw the filter...
-    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);
-    }
-};
-
-/*
-AbstractFilter.prototype.apply = function (frameBuffer)
-{
-    // TODO :)
-};
-*/
diff --git a/src/core/renderers/webgl/utils/SpriteMaskFilter.js b/src/core/renderers/webgl/utils/SpriteMaskFilter.js
deleted file mode 100644
index cceb88a..0000000
--- a/src/core/renderers/webgl/utils/SpriteMaskFilter.js
+++ /dev/null
@@ -1,121 +0,0 @@
-var AbstractFilter = require('./AbstractFilter'),
-    math =  require('../../../math');
-
-/**
- * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
- * You can use this filter to apply all manor of crazy warping effects
- * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
- *
- * @class
- * @extends AbstractFilter
- * @namespace PIXI
- * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
- */
-function SpriteMaskFilter(sprite)
-{
-    var maskMatrix = new math.Matrix();
-
-    AbstractFilter.call(this,
-    // vertex shader
-    [
-        'attribute vec2 aVertexPosition;',
-        'attribute vec2 aTextureCoord;',
-        'attribute vec4 aColor;',
-
-        'uniform mat3 projectionMatrix;',
-        'uniform mat3 otherMatrix;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'void main(void)',
-        '{',
-        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
-        '   vTextureCoord = aTextureCoord;',
-        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
-        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
-        '}'
-    ].join('\n'),
-    // fragment shader
-    [
-        'precision lowp float;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'uniform sampler2D uSampler;',
-        'uniform sampler2D mask;',
-
-        'void main(void)',
-        '{',
-        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
-        '   vec4 masky =  texture2D(mask, vMaskCoord);',
-        '   original *= (masky.r * masky.a);',
-        '   gl_FragColor =  original;',
-        '}'
-    ].join('\n'),
-    // uniforms
-    {
-        mask:           { type: 'sampler2D',    value: sprite.texture },
-        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
-    });
-
-    this.maskSprite = sprite;
-    this.maskMatrix = maskMatrix;
-}
-
-SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
-SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
-module.exports = SpriteMaskFilter;
-
-SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
-{
-    var filterManager = renderer.filterManager;
-
-    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
-
-    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
-
-    var shader = this.getShader(renderer);
-     // draw the filter...
-    filterManager.applyFilter(shader, input, output);
-};
-
-
-Object.defineProperties(SpriteMaskFilter.prototype, {
-    /**
-     * The texture used for the displacement map. Must be power of 2 sized texture.
-     *
-     * @member {Texture}
-     * @memberof SpriteMaskFilter#
-     */
-    map: {
-        get: function ()
-        {
-            return this.uniforms.mask.value;
-        },
-        set: function (value)
-        {
-            this.uniforms.mask.value = value;
-        }
-    },
-
-    /**
-     * The offset used to move the displacement map.
-     *
-     * @member {Point}
-     * @memberof SpriteMaskFilter#
-     */
-    offset: {
-        get: function()
-        {
-            return this.uniforms.offset.value;
-        },
-        set: function(value)
-        {
-            this.uniforms.offset.value = value;
-        }
-    }
-});
diff --git a/src/filters/BloomFilter.js b/src/filters/BloomFilter.js
index c10c658..23f2441 100644
--- a/src/filters/BloomFilter.js
+++ b/src/filters/BloomFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     BlurXFilter = require('./BlurXFilter'),
     BlurYFilter = require('./BlurYFilter'),
     CONST = require('../core/const');
diff --git a/src/filters/BlurFilter.js b/src/filters/BlurFilter.js
index e50f425..0907032 100644
--- a/src/filters/BlurFilter.js
+++ b/src/filters/BlurFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     BlurXFilter = require('./BlurXFilter'),
     BlurYFilter = require('./BlurYFilter');
 
@@ -28,10 +28,10 @@
 {
     var filterManager = renderer.filterManager;
 
-    var renderTarget = filterManager.getRenderTarget();
+    var renderTarget = filterManager.getRenderTarget(true);
 
     this.blurXFilter.applyFilter(renderer, input, renderTarget);
-    
+
     this.blurYFilter.applyFilter(renderer, renderTarget, output);
 
     filterManager.returnRenderTarget( renderTarget );
diff --git a/src/filters/BlurXFilter.js b/src/filters/BlurXFilter.js
index bddd4dd..d56401a 100644
--- a/src/filters/BlurXFilter.js
+++ b/src/filters/BlurXFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     blurFactor = 1 / 7000;
 
 /**
diff --git a/src/filters/BlurYFilter.js b/src/filters/BlurYFilter.js
index 5496dac..515adf6 100644
--- a/src/filters/BlurYFilter.js
+++ b/src/filters/BlurYFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     blurFactor = 1 / 7000;
 
 /**

diff --git a/src/core/renderers/webgl/WebGLRenderer.js b/src/core/renderers/webgl/WebGLRenderer.js
index 9aa97c7..f68d6ce 100644
--- a/src/core/renderers/webgl/WebGLRenderer.js
+++ b/src/core/renderers/webgl/WebGLRenderer.js
@@ -2,7 +2,7 @@
     MaskManager = require('./managers/MaskManager'),
     StencilManager = require('./managers/StencilManager'),
     FilterManager = require('./managers/FilterManager'),
-    WebGLBlendModeManager = require('./managers/WebGLBlendModeManager'),
+    BlendModeManager = require('./managers/BlendModeManager'),
     RenderTarget = require('./utils/RenderTarget'),
     ObjectRenderer = require('./utils/ObjectRenderer'),
     math = require('../../math'),
@@ -201,9 +201,9 @@
 
     /**
      * Manages the blendModes
-     * @member {WebGLBlendModeManager}
+     * @member {BlendModeManager}
      */
-    this.blendModeManager = new WebGLBlendModeManager(this);
+    this.blendModeManager = new BlendModeManager(this);
 
     this.blendModes = null;
 
diff --git a/src/core/renderers/webgl/filters/AbstractFilter.js b/src/core/renderers/webgl/filters/AbstractFilter.js
new file mode 100644
index 0000000..c440914
--- /dev/null
+++ b/src/core/renderers/webgl/filters/AbstractFilter.js
@@ -0,0 +1,104 @@
+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
+ * @namespace PIXI
+ * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
+ * @param uniforms {object} An object containing the uniforms for this filter.
+ */
+function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
+{
+    /**
+     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
+     * For example the blur filter has two passes blurX and blurY.
+     *
+     * @member {AbstractFilter[]}
+     * @private
+     */
+    this.passes = [this];
+
+    /**
+     * @member {Shader[]}
+     * @private
+     */
+    this.shaders = [];
+
+    /**
+     * @member {number}
+     */
+    this.padding = 0;
+
+    /**
+     * @member {object}
+     * @private
+     */
+    this.uniforms = uniforms || {};
+
+   
+    this.vertexSrc = vertexSrc;
+   
+    /**
+     * @member {string[]}
+     * @private
+     */
+    this.fragmentSrc = fragmentSrc;
+
+
+    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
+
+}
+
+AbstractFilter.prototype.constructor = AbstractFilter;
+module.exports = AbstractFilter;
+
+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;
+};
+
+AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
+{
+    var filterManager = renderer.filterManager,
+    shader = this.getShader(renderer);
+
+     // draw the filter...
+    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);
+    }
+};
+
+/*
+AbstractFilter.prototype.apply = function (frameBuffer)
+{
+    // TODO :)
+};
+*/
diff --git a/src/core/renderers/webgl/filters/SpriteMaskFilter.js b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
new file mode 100644
index 0000000..cceb88a
--- /dev/null
+++ b/src/core/renderers/webgl/filters/SpriteMaskFilter.js
@@ -0,0 +1,121 @@
+var AbstractFilter = require('./AbstractFilter'),
+    math =  require('../../../math');
+
+/**
+ * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
+ * You can use this filter to apply all manor of crazy warping effects
+ * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
+ *
+ * @class
+ * @extends AbstractFilter
+ * @namespace PIXI
+ * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
+ */
+function SpriteMaskFilter(sprite)
+{
+    var maskMatrix = new math.Matrix();
+
+    AbstractFilter.call(this,
+    // vertex shader
+    [
+        'attribute vec2 aVertexPosition;',
+        'attribute vec2 aTextureCoord;',
+        'attribute vec4 aColor;',
+
+        'uniform mat3 projectionMatrix;',
+        'uniform mat3 otherMatrix;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'void main(void)',
+        '{',
+        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
+        '   vTextureCoord = aTextureCoord;',
+        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
+        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
+        '}'
+    ].join('\n'),
+    // fragment shader
+    [
+        'precision lowp float;',
+
+        'varying vec2 vMaskCoord;',
+        'varying vec2 vTextureCoord;',
+        'varying vec4 vColor;',
+
+        'uniform sampler2D uSampler;',
+        'uniform sampler2D mask;',
+
+        'void main(void)',
+        '{',
+        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
+        '   vec4 masky =  texture2D(mask, vMaskCoord);',
+        '   original *= (masky.r * masky.a);',
+        '   gl_FragColor =  original;',
+        '}'
+    ].join('\n'),
+    // uniforms
+    {
+        mask:           { type: 'sampler2D',    value: sprite.texture },
+        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
+    });
+
+    this.maskSprite = sprite;
+    this.maskMatrix = maskMatrix;
+}
+
+SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
+SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
+module.exports = SpriteMaskFilter;
+
+SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
+{
+    var filterManager = renderer.filterManager;
+
+    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
+
+    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
+
+    var shader = this.getShader(renderer);
+     // draw the filter...
+    filterManager.applyFilter(shader, input, output);
+};
+
+
+Object.defineProperties(SpriteMaskFilter.prototype, {
+    /**
+     * The texture used for the displacement map. Must be power of 2 sized texture.
+     *
+     * @member {Texture}
+     * @memberof SpriteMaskFilter#
+     */
+    map: {
+        get: function ()
+        {
+            return this.uniforms.mask.value;
+        },
+        set: function (value)
+        {
+            this.uniforms.mask.value = value;
+        }
+    },
+
+    /**
+     * The offset used to move the displacement map.
+     *
+     * @member {Point}
+     * @memberof SpriteMaskFilter#
+     */
+    offset: {
+        get: function()
+        {
+            return this.uniforms.offset.value;
+        },
+        set: function(value)
+        {
+            this.uniforms.offset.value = value;
+        }
+    }
+});
diff --git a/src/core/renderers/webgl/managers/BlendModeManager.js b/src/core/renderers/webgl/managers/BlendModeManager.js
new file mode 100644
index 0000000..ec57910
--- /dev/null
+++ b/src/core/renderers/webgl/managers/BlendModeManager.js
@@ -0,0 +1,40 @@
+var WebGLManager = require('./WebGLManager');
+
+/**
+ * @class
+ * @namespace PIXI
+ * @param renderer {WebGLRenderer} The renderer this manager works for.
+ */
+function BlendModeManager(renderer)
+{
+    WebGLManager.call(this, renderer);
+
+    /**
+     * @member {number}
+     */
+    this.currentBlendMode = 99999;
+}
+
+BlendModeManager.prototype = Object.create(WebGLManager.prototype);
+BlendModeManager.prototype.constructor = BlendModeManager;
+module.exports = BlendModeManager;
+
+/**
+ * Sets-up the given blendMode from WebGL's point of view.
+ *
+ * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
+ */
+BlendModeManager.prototype.setBlendMode = function (blendMode)
+{
+    if (this.currentBlendMode === blendMode)
+    {
+        return false;
+    }
+
+    this.currentBlendMode = blendMode;
+
+    var mode = this.renderer.blendModes[this.currentBlendMode];
+    this.renderer.gl.blendFunc(mode[0], mode[1]);
+
+    return true;
+};
diff --git a/src/core/renderers/webgl/managers/MaskManager.js b/src/core/renderers/webgl/managers/MaskManager.js
index 8abe133..be38225 100644
--- a/src/core/renderers/webgl/managers/MaskManager.js
+++ b/src/core/renderers/webgl/managers/MaskManager.js
@@ -1,5 +1,5 @@
 var WebGLManager = require('./WebGLManager'),
-    AlphaMaskFilter = require('../utils/SpriteMaskFilter');
+    AlphaMaskFilter = require('../filters/SpriteMaskFilter');
 
 /**
  * @class
diff --git a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js b/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
deleted file mode 100644
index 35edbaf..0000000
--- a/src/core/renderers/webgl/managers/WebGLBlendModeManager.js
+++ /dev/null
@@ -1,40 +0,0 @@
-var WebGLManager = require('./WebGLManager');
-
-/**
- * @class
- * @namespace PIXI
- * @param renderer {WebGLRenderer} The renderer this manager works for.
- */
-function WebGLBlendModeManager(renderer)
-{
-    WebGLManager.call(this, renderer);
-
-    /**
-     * @member {number}
-     */
-    this.currentBlendMode = 99999;
-}
-
-WebGLBlendModeManager.prototype = Object.create(WebGLManager.prototype);
-WebGLBlendModeManager.prototype.constructor = WebGLBlendModeManager;
-module.exports = WebGLBlendModeManager;
-
-/**
- * Sets-up the given blendMode from WebGL's point of view.
- *
- * @param blendMode {number} the blendMode, should be a Pixi const, such as BlendModes.ADD
- */
-WebGLBlendModeManager.prototype.setBlendMode = function (blendMode)
-{
-    if (this.currentBlendMode === blendMode)
-    {
-        return false;
-    }
-
-    this.currentBlendMode = blendMode;
-
-    var mode = this.renderer.blendModes[this.currentBlendMode];
-    this.renderer.gl.blendFunc(mode[0], mode[1]);
-
-    return true;
-};
diff --git a/src/core/renderers/webgl/utils/AbstractFilter.js b/src/core/renderers/webgl/utils/AbstractFilter.js
deleted file mode 100644
index c440914..0000000
--- a/src/core/renderers/webgl/utils/AbstractFilter.js
+++ /dev/null
@@ -1,104 +0,0 @@
-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
- * @namespace PIXI
- * @param fragmentSrc {string|string[]} The fragment source in an array of strings.
- * @param uniforms {object} An object containing the uniforms for this filter.
- */
-function AbstractFilter(vertexSrc, fragmentSrc, uniforms)
-{
-    /**
-     * An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
-     * For example the blur filter has two passes blurX and blurY.
-     *
-     * @member {AbstractFilter[]}
-     * @private
-     */
-    this.passes = [this];
-
-    /**
-     * @member {Shader[]}
-     * @private
-     */
-    this.shaders = [];
-
-    /**
-     * @member {number}
-     */
-    this.padding = 0;
-
-    /**
-     * @member {object}
-     * @private
-     */
-    this.uniforms = uniforms || {};
-
-   
-    this.vertexSrc = vertexSrc;
-   
-    /**
-     * @member {string[]}
-     * @private
-     */
-    this.fragmentSrc = fragmentSrc;
-
-
-    //typeof fragmentSrc === 'string' ? fragmentSrc.split('') : (fragmentSrc || []);
-
-}
-
-AbstractFilter.prototype.constructor = AbstractFilter;
-module.exports = AbstractFilter;
-
-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;
-};
-
-AbstractFilter.prototype.applyFilter = function (renderer, input, output, clear)
-{
-    var filterManager = renderer.filterManager,
-    shader = this.getShader(renderer);
-
-     // draw the filter...
-    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);
-    }
-};
-
-/*
-AbstractFilter.prototype.apply = function (frameBuffer)
-{
-    // TODO :)
-};
-*/
diff --git a/src/core/renderers/webgl/utils/SpriteMaskFilter.js b/src/core/renderers/webgl/utils/SpriteMaskFilter.js
deleted file mode 100644
index cceb88a..0000000
--- a/src/core/renderers/webgl/utils/SpriteMaskFilter.js
+++ /dev/null
@@ -1,121 +0,0 @@
-var AbstractFilter = require('./AbstractFilter'),
-    math =  require('../../../math');
-
-/**
- * The SpriteMaskFilter class uses the pixel values from the specified texture (called the displacement map) to perform a displacement of an object.
- * You can use this filter to apply all manor of crazy warping effects
- * Currently the r property of the texture is used to offset the x and the g property of the texture is used to offset the y.
- *
- * @class
- * @extends AbstractFilter
- * @namespace PIXI
- * @param texture {Texture} The texture used for the displacement map * must be power of 2 texture at the moment
- */
-function SpriteMaskFilter(sprite)
-{
-    var maskMatrix = new math.Matrix();
-
-    AbstractFilter.call(this,
-    // vertex shader
-    [
-        'attribute vec2 aVertexPosition;',
-        'attribute vec2 aTextureCoord;',
-        'attribute vec4 aColor;',
-
-        'uniform mat3 projectionMatrix;',
-        'uniform mat3 otherMatrix;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'void main(void)',
-        '{',
-        '   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);',
-        '   vTextureCoord = aTextureCoord;',
-        '   vMaskCoord = ( otherMatrix * vec3( aTextureCoord, 1.0)  ).xy;',
-        '   vColor = vec4(aColor.rgb * aColor.a, aColor.a);',
-        '}'
-    ].join('\n'),
-    // fragment shader
-    [
-        'precision lowp float;',
-
-        'varying vec2 vMaskCoord;',
-        'varying vec2 vTextureCoord;',
-        'varying vec4 vColor;',
-
-        'uniform sampler2D uSampler;',
-        'uniform sampler2D mask;',
-
-        'void main(void)',
-        '{',
-        '   vec4 original =  texture2D(uSampler, vTextureCoord);',
-        '   vec4 masky =  texture2D(mask, vMaskCoord);',
-        '   original *= (masky.r * masky.a);',
-        '   gl_FragColor =  original;',
-        '}'
-    ].join('\n'),
-    // uniforms
-    {
-        mask:           { type: 'sampler2D',    value: sprite.texture },
-        otherMatrix:    { type: 'mat3', value: maskMatrix.toArray(true) }
-    });
-
-    this.maskSprite = sprite;
-    this.maskMatrix = maskMatrix;
-}
-
-SpriteMaskFilter.prototype = Object.create(AbstractFilter.prototype);
-SpriteMaskFilter.prototype.constructor = SpriteMaskFilter;
-module.exports = SpriteMaskFilter;
-
-SpriteMaskFilter.prototype.applyFilter = function (renderer, input, output)
-{
-    var filterManager = renderer.filterManager;
-
-    filterManager.calculateMappedMatrix(input.frame, this.maskSprite, this.maskMatrix);
-
-    this.uniforms.otherMatrix.value = this.maskMatrix.toArray(true);
-
-    var shader = this.getShader(renderer);
-     // draw the filter...
-    filterManager.applyFilter(shader, input, output);
-};
-
-
-Object.defineProperties(SpriteMaskFilter.prototype, {
-    /**
-     * The texture used for the displacement map. Must be power of 2 sized texture.
-     *
-     * @member {Texture}
-     * @memberof SpriteMaskFilter#
-     */
-    map: {
-        get: function ()
-        {
-            return this.uniforms.mask.value;
-        },
-        set: function (value)
-        {
-            this.uniforms.mask.value = value;
-        }
-    },
-
-    /**
-     * The offset used to move the displacement map.
-     *
-     * @member {Point}
-     * @memberof SpriteMaskFilter#
-     */
-    offset: {
-        get: function()
-        {
-            return this.uniforms.offset.value;
-        },
-        set: function(value)
-        {
-            this.uniforms.offset.value = value;
-        }
-    }
-});
diff --git a/src/filters/BloomFilter.js b/src/filters/BloomFilter.js
index c10c658..23f2441 100644
--- a/src/filters/BloomFilter.js
+++ b/src/filters/BloomFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     BlurXFilter = require('./BlurXFilter'),
     BlurYFilter = require('./BlurYFilter'),
     CONST = require('../core/const');
diff --git a/src/filters/BlurFilter.js b/src/filters/BlurFilter.js
index e50f425..0907032 100644
--- a/src/filters/BlurFilter.js
+++ b/src/filters/BlurFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     BlurXFilter = require('./BlurXFilter'),
     BlurYFilter = require('./BlurYFilter');
 
@@ -28,10 +28,10 @@
 {
     var filterManager = renderer.filterManager;
 
-    var renderTarget = filterManager.getRenderTarget();
+    var renderTarget = filterManager.getRenderTarget(true);
 
     this.blurXFilter.applyFilter(renderer, input, renderTarget);
-    
+
     this.blurYFilter.applyFilter(renderer, renderTarget, output);
 
     filterManager.returnRenderTarget( renderTarget );
diff --git a/src/filters/BlurXFilter.js b/src/filters/BlurXFilter.js
index bddd4dd..d56401a 100644
--- a/src/filters/BlurXFilter.js
+++ b/src/filters/BlurXFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     blurFactor = 1 / 7000;
 
 /**
diff --git a/src/filters/BlurYFilter.js b/src/filters/BlurYFilter.js
index 5496dac..515adf6 100644
--- a/src/filters/BlurYFilter.js
+++ b/src/filters/BlurYFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter'),
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter'),
     blurFactor = 1 / 7000;
 
 /**
diff --git a/src/filters/GrayFilter.js b/src/filters/GrayFilter.js
index 7bdf651..a799ce8 100644
--- a/src/filters/GrayFilter.js
+++ b/src/filters/GrayFilter.js
@@ -1,4 +1,4 @@
-var AbstractFilter = require('../core/renderers/webGL/utils/AbstractFilter');
+var AbstractFilter = require('../core/renderers/webGL/filters/AbstractFilter');
 
 /**
  * This greyscales the palette of your Display Objects.