DrawTargetTiled.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "DrawTargetTiled.h"
#include "Logging.h"
#include "PathHelpers.h"

namespace mozilla {
namespace gfx {

DrawTargetTiled::DrawTargetTiled() = default;

bool DrawTargetTiled::Init(const TileSet& aTiles) {
  if (!aTiles.mTileCount) {
    return false;
  }

  mTiles.reserve(aTiles.mTileCount);
  for (size_t i = 0; i < aTiles.mTileCount; ++i) {
    mTiles.push_back(TileInternal(aTiles.mTiles[i]));
    if (!aTiles.mTiles[i].mDrawTarget) {
      return false;
    }
    if (mTiles[0].mDrawTarget->GetFormat() !=
            mTiles.back().mDrawTarget->GetFormat() ||
        mTiles[0].mDrawTarget->GetBackendType() !=
            mTiles.back().mDrawTarget->GetBackendType()) {
      return false;
    }
    uint32_t newXMost =
        std::max(mRect.XMost(), mTiles[i].mTileOrigin.x +
                                    mTiles[i].mDrawTarget->GetSize().width);
    uint32_t newYMost =
        std::max(mRect.YMost(), mTiles[i].mTileOrigin.y +
                                    mTiles[i].mDrawTarget->GetSize().height);
    if (i == 0) {
      mRect.MoveTo(mTiles[0].mTileOrigin.x, mTiles[0].mTileOrigin.y);
    } else {
      mRect.MoveTo(std::min(mRect.X(), mTiles[i].mTileOrigin.x),
                   std::min(mRect.Y(), mTiles[i].mTileOrigin.y));
    }
    mRect.SetRightEdge(newXMost);
    mRect.SetBottomEdge(newYMost);
    mTiles[i].mDrawTarget->SetTransform(Matrix::Translation(
        -mTiles[i].mTileOrigin.x, -mTiles[i].mTileOrigin.y));
  }
  mFormat = mTiles[0].mDrawTarget->GetFormat();
  SetPermitSubpixelAA(IsOpaque(mFormat));
  return true;
}

already_AddRefed<SourceSurface> DrawTargetTiled::Snapshot() {
  return MakeAndAddRef<SnapshotTiled>(mTiles, mRect);
}

void DrawTargetTiled::DetachAllSnapshots() {}

// Skip the mClippedOut check since this is only used for Flush() which
// should happen even if we're clipped.
#define TILED_COMMAND(command)                   \
  void DrawTargetTiled::command() {              \
    for (size_t i = 0; i < mTiles.size(); i++) { \
      mTiles[i].mDrawTarget->command();          \
    }                                            \
  }
#define TILED_COMMAND1(command, type1)                                  \
  void DrawTargetTiled::command(type1 arg1) {                           \
    for (size_t i = 0; i < mTiles.size(); i++) {                        \
      if (!mTiles[i].mClippedOut) mTiles[i].mDrawTarget->command(arg1); \
    }                                                                   \
  }
#define TILED_COMMAND3(command, type1, type2, type3)                  \
  void DrawTargetTiled::command(type1 arg1, type2 arg2, type3 arg3) { \
    for (size_t i = 0; i < mTiles.size(); i++) {                      \
      if (!mTiles[i].mClippedOut)                                     \
        mTiles[i].mDrawTarget->command(arg1, arg2, arg3);             \
    }                                                                 \
  }
#define TILED_COMMAND4(command, type1, type2, type3, type4)         \
  void DrawTargetTiled::command(type1 arg1, type2 arg2, type3 arg3, \
                                type4 arg4) {                       \
    for (size_t i = 0; i < mTiles.size(); i++) {                    \
      if (!mTiles[i].mClippedOut)                                   \
        mTiles[i].mDrawTarget->command(arg1, arg2, arg3, arg4);     \
    }                                                               \
  }
#define TILED_COMMAND5(command, type1, type2, type3, type4, type5)    \
  void DrawTargetTiled::command(type1 arg1, type2 arg2, type3 arg3,   \
                                type4 arg4, type5 arg5) {             \
    for (size_t i = 0; i < mTiles.size(); i++) {                      \
      if (!mTiles[i].mClippedOut)                                     \
        mTiles[i].mDrawTarget->command(arg1, arg2, arg3, arg4, arg5); \
    }                                                                 \
  }

TILED_COMMAND(Flush)
TILED_COMMAND4(DrawFilter, FilterNode*, const Rect&, const Point&,
               const DrawOptions&)
TILED_COMMAND1(ClearRect, const Rect&)
TILED_COMMAND4(MaskSurface, const Pattern&, SourceSurface*, Point,
               const DrawOptions&)
TILED_COMMAND4(FillGlyphs, ScaledFont*, const GlyphBuffer&, const Pattern&,
               const DrawOptions&)
TILED_COMMAND3(Mask, const Pattern&, const Pattern&, const DrawOptions&)

void DrawTargetTiled::PushClip(const Path* aPath) {
  if (!mClippedOutTilesStack.append(std::vector<bool>(mTiles.size()))) {
    MOZ_CRASH("out of memory");
  }
  std::vector<bool>& clippedTiles = mClippedOutTilesStack.back();

  Rect deviceRect = aPath->GetBounds(mTransform);

  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut) {
      if (deviceRect.Intersects(
              Rect(mTiles[i].mTileOrigin.x, mTiles[i].mTileOrigin.y,
                   mTiles[i].mDrawTarget->GetSize().width,
                   mTiles[i].mDrawTarget->GetSize().height))) {
        mTiles[i].mDrawTarget->PushClip(aPath);
      } else {
        mTiles[i].mClippedOut = true;
        clippedTiles[i] = true;
      }
    }
  }
}

void DrawTargetTiled::PushClipRect(const Rect& aRect) {
  if (!mClippedOutTilesStack.append(std::vector<bool>(mTiles.size()))) {
    MOZ_CRASH("out of memory");
  }
  std::vector<bool>& clippedTiles = mClippedOutTilesStack.back();

  Rect deviceRect = mTransform.TransformBounds(aRect);

  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut) {
      if (deviceRect.Intersects(
              Rect(mTiles[i].mTileOrigin.x, mTiles[i].mTileOrigin.y,
                   mTiles[i].mDrawTarget->GetSize().width,
                   mTiles[i].mDrawTarget->GetSize().height))) {
        mTiles[i].mDrawTarget->PushClipRect(aRect);
      } else {
        mTiles[i].mClippedOut = true;
        clippedTiles[i] = true;
      }
    }
  }
}

void DrawTargetTiled::PopClip() {
  std::vector<bool>& clippedTiles = mClippedOutTilesStack.back();
  MOZ_ASSERT(clippedTiles.size() == mTiles.size());
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut) {
      mTiles[i].mDrawTarget->PopClip();
    } else if (clippedTiles[i]) {
      mTiles[i].mClippedOut = false;
    }
  }

  mClippedOutTilesStack.popBack();
}

void DrawTargetTiled::CopySurface(SourceSurface* aSurface,
                                  const IntRect& aSourceRect,
                                  const IntPoint& aDestination) {
  for (size_t i = 0; i < mTiles.size(); i++) {
    IntPoint tileOrigin = mTiles[i].mTileOrigin;
    IntSize tileSize = mTiles[i].mDrawTarget->GetSize();
    if (!IntRect(aDestination, aSourceRect.Size())
             .Intersects(IntRect(tileOrigin, tileSize))) {
      continue;
    }
    // CopySurface ignores the transform, account for that here.
    mTiles[i].mDrawTarget->CopySurface(aSurface, aSourceRect,
                                       aDestination - tileOrigin);
  }
}

void DrawTargetTiled::SetTransform(const Matrix& aTransform) {
  for (size_t i = 0; i < mTiles.size(); i++) {
    Matrix mat = aTransform;
    mat.PostTranslate(Float(-mTiles[i].mTileOrigin.x),
                      Float(-mTiles[i].mTileOrigin.y));
    mTiles[i].mDrawTarget->SetTransform(mat);
  }
  DrawTarget::SetTransform(aTransform);
}

void DrawTargetTiled::SetPermitSubpixelAA(bool aPermitSubpixelAA) {
  DrawTarget::SetPermitSubpixelAA(aPermitSubpixelAA);
  for (size_t i = 0; i < mTiles.size(); i++) {
    mTiles[i].mDrawTarget->SetPermitSubpixelAA(aPermitSubpixelAA);
  }
}

void DrawTargetTiled::DrawSurface(SourceSurface* aSurface, const Rect& aDest,
                                  const Rect& aSource,
                                  const DrawSurfaceOptions& aSurfaceOptions,
                                  const DrawOptions& aDrawOptions) {
  Rect deviceRect = mTransform.TransformBounds(aDest);
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut &&
        deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
                                   mTiles[i].mTileOrigin.y,
                                   mTiles[i].mDrawTarget->GetSize().width,
                                   mTiles[i].mDrawTarget->GetSize().height))) {
      mTiles[i].mDrawTarget->DrawSurface(aSurface, aDest, aSource,
                                         aSurfaceOptions, aDrawOptions);
    }
  }
}

void DrawTargetTiled::FillRect(const Rect& aRect, const Pattern& aPattern,
                               const DrawOptions& aDrawOptions) {
  Rect deviceRect = mTransform.TransformBounds(aRect);
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut &&
        deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
                                   mTiles[i].mTileOrigin.y,
                                   mTiles[i].mDrawTarget->GetSize().width,
                                   mTiles[i].mDrawTarget->GetSize().height))) {
      mTiles[i].mDrawTarget->FillRect(aRect, aPattern, aDrawOptions);
    }
  }
}

void DrawTargetTiled::Stroke(const Path* aPath, const Pattern& aPattern,
                             const StrokeOptions& aStrokeOptions,
                             const DrawOptions& aDrawOptions) {
  // Approximate the stroke extents, since Path::GetStrokeExtents can be slow
  Rect deviceRect = aPath->GetBounds(mTransform);
  deviceRect.Inflate(MaxStrokeExtents(aStrokeOptions, mTransform));
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut &&
        deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
                                   mTiles[i].mTileOrigin.y,
                                   mTiles[i].mDrawTarget->GetSize().width,
                                   mTiles[i].mDrawTarget->GetSize().height))) {
      mTiles[i].mDrawTarget->Stroke(aPath, aPattern, aStrokeOptions,
                                    aDrawOptions);
    }
  }
}

void DrawTargetTiled::StrokeRect(const Rect& aRect, const Pattern& aPattern,
                                 const StrokeOptions& aStrokeOptions,
                                 const DrawOptions& aDrawOptions) {
  Rect deviceRect = mTransform.TransformBounds(aRect);
  Margin strokeMargin = MaxStrokeExtents(aStrokeOptions, mTransform);
  Rect outerRect = deviceRect;
  outerRect.Inflate(strokeMargin);
  Rect innerRect;
  if (mTransform.IsRectilinear()) {
    // If rects are mapped to rects, we can compute the inner rect
    // of the stroked rect.
    innerRect = deviceRect;
    innerRect.Deflate(strokeMargin);
  }
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (mTiles[i].mClippedOut) {
      continue;
    }
    Rect tileRect(mTiles[i].mTileOrigin.x, mTiles[i].mTileOrigin.y,
                  mTiles[i].mDrawTarget->GetSize().width,
                  mTiles[i].mDrawTarget->GetSize().height);
    if (outerRect.Intersects(tileRect) && !innerRect.Contains(tileRect)) {
      mTiles[i].mDrawTarget->StrokeRect(aRect, aPattern, aStrokeOptions,
                                        aDrawOptions);
    }
  }
}

void DrawTargetTiled::StrokeLine(const Point& aStart, const Point& aEnd,
                                 const Pattern& aPattern,
                                 const StrokeOptions& aStrokeOptions,
                                 const DrawOptions& aDrawOptions) {
  Rect lineBounds = Rect(aStart, Size()).UnionEdges(Rect(aEnd, Size()));
  Rect deviceRect = mTransform.TransformBounds(lineBounds);
  deviceRect.Inflate(MaxStrokeExtents(aStrokeOptions, mTransform));
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut &&
        deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
                                   mTiles[i].mTileOrigin.y,
                                   mTiles[i].mDrawTarget->GetSize().width,
                                   mTiles[i].mDrawTarget->GetSize().height))) {
      mTiles[i].mDrawTarget->StrokeLine(aStart, aEnd, aPattern, aStrokeOptions,
                                        aDrawOptions);
    }
  }
}

void DrawTargetTiled::Fill(const Path* aPath, const Pattern& aPattern,
                           const DrawOptions& aDrawOptions) {
  Rect deviceRect = aPath->GetBounds(mTransform);
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut &&
        deviceRect.Intersects(Rect(mTiles[i].mTileOrigin.x,
                                   mTiles[i].mTileOrigin.y,
                                   mTiles[i].mDrawTarget->GetSize().width,
                                   mTiles[i].mDrawTarget->GetSize().height))) {
      mTiles[i].mDrawTarget->Fill(aPath, aPattern, aDrawOptions);
    }
  }
}

void DrawTargetTiled::PushLayer(bool aOpaque, Float aOpacity,
                                SourceSurface* aMask,
                                const Matrix& aMaskTransform,
                                const IntRect& aBounds, bool aCopyBackground) {
  // XXX - not sure this is what we want or whether we want to continue drawing
  // to a larger intermediate surface, that would require tweaking the code in
  // here a little though.
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut) {
      IntRect bounds = aBounds;
      bounds.MoveBy(-mTiles[i].mTileOrigin);
      mTiles[i].mDrawTarget->PushLayer(aOpaque, aOpacity, aMask, aMaskTransform,
                                       bounds, aCopyBackground);
    }
  }

  PushedLayer layer(GetPermitSubpixelAA());
  mPushedLayers.push_back(layer);
  SetPermitSubpixelAA(aOpaque);
}

void DrawTargetTiled::PushLayerWithBlend(bool aOpaque, Float aOpacity,
                                         SourceSurface* aMask,
                                         const Matrix& aMaskTransform,
                                         const IntRect& aBounds,
                                         bool aCopyBackground,
                                         CompositionOp aOp) {
  // XXX - not sure this is what we want or whether we want to continue drawing
  // to a larger intermediate surface, that would require tweaking the code in
  // here a little though.
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut) {
      IntRect bounds = aBounds;
      bounds.MoveBy(-mTiles[i].mTileOrigin);
      mTiles[i].mDrawTarget->PushLayerWithBlend(aOpaque, aOpacity, aMask,
                                                aMaskTransform, bounds,
                                                aCopyBackground, aOp);
    }
  }

  PushedLayer layer(GetPermitSubpixelAA());
  mPushedLayers.push_back(layer);
  SetPermitSubpixelAA(aOpaque);
}

void DrawTargetTiled::PopLayer() {
  // XXX - not sure this is what we want or whether we want to continue drawing
  // to a larger intermediate surface, that would require tweaking the code in
  // here a little though.
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut) {
      mTiles[i].mDrawTarget->PopLayer();
    }
  }

  MOZ_ASSERT(mPushedLayers.size());
  const PushedLayer& layer = mPushedLayers.back();
  SetPermitSubpixelAA(layer.mOldPermitSubpixelAA);
  mPushedLayers.pop_back();
}

RefPtr<DrawTarget> DrawTargetTiled::CreateClippedDrawTarget(
    const Rect& aBounds, SurfaceFormat aFormat) {
  Rect deviceRect = mTransform.TransformBounds(aBounds);

  // Build up an approximation of the current clip rect by unioning
  // the tiles that are not clipped
  Rect clipRectApproximation;
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (!mTiles[i].mClippedOut) {
      clipRectApproximation = clipRectApproximation.Union(
          Rect(mTiles[i].mTileOrigin.x, mTiles[i].mTileOrigin.y,
               mTiles[i].mDrawTarget->GetSize().width,
               mTiles[i].mDrawTarget->GetSize().height));
    }
  }

  IntRect clipBounds;
  if (!aBounds.IsEmpty()) {
    clipBounds = IntRect::RoundOut(deviceRect.Intersect(clipRectApproximation));
  } else {
    clipBounds = IntRect::RoundOut(clipRectApproximation);
  }

  RefPtr<DrawTarget> result;
  if (!clipBounds.IsEmpty()) {
    RefPtr<DrawTarget> dt = CreateSimilarDrawTarget(
        IntSize(clipBounds.width, clipBounds.height), aFormat);
    result = gfx::Factory::CreateOffsetDrawTarget(
        dt, IntPoint(clipBounds.x, clipBounds.y));
    result->SetTransform(mTransform);
  } else {
    // Everything is clipped but we still want some kind of surface
    result = CreateSimilarDrawTarget(IntSize(1, 1), aFormat);
  }
  return result;
}

void DrawTargetTiled::PadEdges(const IntRegion& aRegion) {
  for (size_t i = 0; i < mTiles.size(); i++) {
    if (mTiles[i].mClippedOut) {
      continue;
    }

    auto tileRect =
        RoundedOut(Rect(mTiles[i].mTileOrigin.x, mTiles[i].mTileOrigin.y,
                        mTiles[i].mDrawTarget->GetSize().width,
                        mTiles[i].mDrawTarget->GetSize().height));

    // We only need to pad edges on tiles that intersect the edge of the region
    if (aRegion.Intersects(tileRect) && !aRegion.Contains(tileRect)) {
      IntRegion padRegion = aRegion;
      padRegion.MoveBy(-mTiles[i].mTileOrigin);
      padRegion.AndWith(IntRect(0, 0, mTiles[i].mDrawTarget->GetSize().width,
                                mTiles[i].mDrawTarget->GetSize().height));
      mTiles[i].mDrawTarget->PadEdges(padRegion);
    }
  }
}

}  // namespace gfx
}  // namespace mozilla