docs: function RenderTexture(renderer, width, height, scaleMode, resolution)
  {
      if (!renderer)
      {
          throw new Error('Unable to create RenderTexture, you must pass a renderer into the constructor.');
      }
  
      width = width || 100;
      height = height || 100;
      resolution = resolution || CONST.RESOLUTION;
  
      /**
       * The base texture object that this texture uses
       *
       * @member {BaseTexture}
       */
      var baseTexture = new BaseTexture();
      baseTexture.width = width;
      baseTexture.height = height;
      baseTexture.resolution = resolution;
      baseTexture.scaleMode = scaleMode || CONST.SCALE_MODES.DEFAULT;
      baseTexture.hasLoaded = true;
  
  
      Texture.call(this,
          baseTexture,
          new math.Rectangle(0, 0, width, height)
      );
  
  
      /**
       * The with of the render texture
       *
       * @member {number}
       */
      this.width = width;
  
      /**
       * The height of the render texture
       *
       * @member {number}
       */
      this.height = height;
  
      /**
       * The Resolution of the texture.
       *
       * @member {number}
       */
      this.resolution = resolution;
  
      /**
       * The framing rectangle of the render texture
       *
       * @member {Rectangle}
       */
      //this._frame = new math.Rectangle(0, 0, this.width * this.resolution, this.height * this.resolution);
  
      /**
       * This is the area of the BaseTexture image to actually copy to the Canvas / WebGL when rendering,
       * irrespective of the actual frame size or placement (which can be influenced by trimmed texture atlases)
       *
       * @member {Rectangle}
       */
      //this.crop = new math.Rectangle(0, 0, this.width * this.resolution, this.height * this.resolution);
  
      /**
       * Draw/render the given DisplayObject onto the texture.
       *
       * The displayObject and descendents are transformed during this operation.
       * If `updateTransform` is true then the transformations will be restored before the
       * method returns. Otherwise it is up to the calling code to correctly use or reset
       * the transformed display objects.
       *
       * The display object is always rendered with a worldAlpha value of 1.
       *
       * @method
       * @param displayObject {DisplayObject} The display object to render this texture on
       * @param [matrix] {Matrix} Optional matrix to apply to the display object before rendering.
       * @param [clear=false] {boolean} If true the texture will be cleared before the displayObject is drawn
       * @param [updateTransform=true] {boolean} If true the displayObject's worldTransform/worldAlpha and all children
       *  transformations will be restored. Not restoring this information will be a little faster.
       */
      this.render = null;
  
      /**
       * The renderer this RenderTexture uses. A RenderTexture can only belong to one renderer at the moment if its webGL.
       *
       * @member {CanvasRenderer|WebGLRenderer}
       */
      this.renderer = renderer;
  
      if (this.renderer.type === CONST.RENDERER_TYPE.WEBGL)
      {
          var gl = this.renderer.gl;
  
          this.textureBuffer = new RenderTarget(gl, this.width, this.height, baseTexture.scaleMode, this.resolution);//, this.baseTexture.scaleMode);
          this.baseTexture._glTextures[gl.id] =  this.textureBuffer.texture;
  
          //TODO refactor filter manager.. as really its no longer a manager if we use it here..
          this.filterManager = new FilterManager(this.renderer);
          this.filterManager.onContextChange();
          this.filterManager.resize(width, height);
          this.render = this.renderWebGL;
  
          // the creation of a filter manager unbinds the buffers..
          this.renderer.currentRenderer.start();
          this.renderer.currentRenderTarget.activate();
      }
      else
      {
  
          this.render = this.renderCanvas;
          this.textureBuffer = new CanvasBuffer(this.width* this.resolution, this.height* this.resolution);
          this.baseTexture.source = this.textureBuffer.canvas;
      }
  
      /**
       * @member {boolean}
       */
      this.valid = true;
  
      this._updateUvs();
  }