docs: function() {
          var ox = this._origin.x + this._x,
              oy = this._origin.y + this._y,
              rad = -this._rotation * DEG_TO_RAD;
          // axis-aligned (unrotated) coordinates, relative to the origin point
          var dx1 = this._x - this._bx1 - ox,
              dx2 = this._x + this._w + this._bx2 - ox,
              dy1 = this._y - this._by1 - oy,
              dy2 = this._y + this._h + this._by2 - oy;
  
          var ct = rounded_cos(rad),
              st = rounded_sin(rad);
  
          // Calculate the new points relative to the origin, then find the new (absolute) bounding coordinates!
          var x0 = dx1 * ct + dy1 * st,
              y0 = -dx1 * st + dy1 * ct,
              x1 = dx2 * ct + dy1 * st,
              y1 = -dx2 * st + dy1 * ct,
              x2 = dx2 * ct + dy2 * st,
              y2 = -dx2 * st + dy2 * ct,
              x3 = dx1 * ct + dy2 * st,
              y3 = -dx1 * st + dy2 * ct,
              minx = Math.floor(Math.min(x0, x1, x2, x3) + ox),
              miny = Math.floor(Math.min(y0, y1, y2, y3) + oy),
              maxx = Math.ceil(Math.max(x0, x1, x2, x3) + ox),
              maxy = Math.ceil(Math.max(y0, y1, y2, y3) + oy);
          if (!this._mbr) {
              this._mbr = {
                  _x: minx,
                  _y: miny,
                  _w: maxx - minx,
                  _h: maxy - miny
              };
          } else {
              this._mbr._x = minx;
              this._mbr._y = miny;
              this._mbr._w = maxx - minx;
              this._mbr._h = maxy - miny;
          }
  
          // If a collision hitbox exists AND sits outside the entity, find a bounding box for both.
          // `_cbr` contains information about a bounding circle of the hitbox.
          // The bounds of `_cbr` will be the union of the `_mbr` and the bounding box of that circle.
          // This will not be a minimal region, but since it's only used for the broad phase pass it's good enough.
          //
          // cbr is calculated by the `_checkBounds` method of the "Collision" component
          if (this._cbr) {
              var cbr = this._cbr;
              var cx = cbr.cx,
                  cy = cbr.cy,
                  r = cbr.r;
              var cx2 = ox + (cx + this._x - ox) * ct + (cy + this._y - oy) * st;
              var cy2 = oy - (cx + this._x - ox) * st + (cy + this._y - oy) * ct;
              cbr._x = Math.min(cx2 - r, minx);
              cbr._y = Math.min(cy2 - r, miny);
              cbr._w = Math.max(cx2 + r, maxx) - cbr._x;
              cbr._h = Math.max(cy2 + r, maxy) - cbr._y;
          }
      }