docs: function BaseTexture(source, scaleMode, resolution)
  {
      EventEmitter.call(this);
  
      this.uuid = utils.uuid();
  
      /**
       * The Resolution of the texture.
       *
       * @member {number}
       */
      this.resolution = resolution || 1;
  
      /**
       * The width of the base texture set when the image has loaded
       *
       * @member {number}
       * @readOnly
       */
      this.width = 100;
  
      /**
       * The height of the base texture set when the image has loaded
       *
       * @member {number}
       * @readOnly
       */
      this.height = 100;
  
      // TODO docs
      // used to store the actual dimensions of the source
      /**
       * Used to store the actual width of the source of this texture
       *
       * @member {number}
       * @readOnly
       */
      this.realWidth = 100;
      /**
       * Used to store the actual height of the source of this texture
       *
       * @member {number}
       * @readOnly
       */
      this.realHeight = 100;
  
      /**
       * The scale mode to apply when scaling this texture
       *
       * @member {{number}}
       * @default scaleModes.LINEAR
       */
      this.scaleMode = scaleMode || CONST.SCALE_MODES.DEFAULT;
  
      /**
       * Set to true once the base texture has successfully loaded.
       *
       * This is never true if the underlying source fails to load or has no texture data.
       *
       * @member {boolean}
       * @readOnly
       */
      this.hasLoaded = false;
  
      /**
       * Set to true if the source is currently loading.
       *
       * If an Image source is loading the 'loaded' or 'error' event will be
       * dispatched when the operation ends. An underyling source that is
       * immediately-available bypasses loading entirely.
       *
       * @member {boolean}
       * @readonly
       */
      this.isLoading = false;
  
      /**
       * The image source that is used to create the texture.
       *
       * TODO: Make this a setter that calls loadSource();
       *
       * @member {Image|Canvas}
       * @readonly
       */
      this.source = null; // set in loadSource, if at all
  
      /**
       * Controls if RGB channels should be pre-multiplied by Alpha  (WebGL only)
       *
       * @member {boolean}
       * @default true
       */
      this.premultipliedAlpha = true;
  
      /**
       * @member {string}
       */
      this.imageUrl = null;
  
      /**
       * Wether or not the texture is a power of two, try to use power of two textures as much as you can
       * @member {boolean}
       * @private
       */
      this.isPowerOfTwo = false;
  
      // used for webGL
  
      /**
       *
       * Set this to true if a mipmap of this texture needs to be generated. This value needs to be set before the texture is used
       * Also the texture must be a power of two size to work
       *
       * @member {boolean}
       */
      this.mipmap = false;
  
      /**
       * A map of renderer IDs to webgl textures
       *
       * @member {object<number, WebGLTexture>}
       * @private
       */
      this._glTextures = [];
  
      // if no source passed don't try to load
      if (source)
      {
          this.loadSource(source);
      }
  
      /**
       * Fired when a not-immediately-available source finishes loading.
       *
       * @event loaded
       * @memberof BaseTexture#
       * @protected
       */
  
      /**
       * Fired when a not-immediately-available source fails to load.
       *
       * @event error
       * @memberof BaseTexture#
       * @protected
       */
  }