cc/tiled_layer_impl.cc

   1 // Copyright 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/tiled_layer_impl.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/stringprintf.h"
   9 #include "cc/append_quads_data.h"
  10 #include "cc/checkerboard_draw_quad.h"
  11 #include "cc/debug_border_draw_quad.h"
  12 #include "cc/debug_colors.h"
  13 #include "cc/layer_tiling_data.h"
  14 #include "cc/math_util.h"
  15 #include "cc/quad_sink.h"
  16 #include "cc/solid_color_draw_quad.h"
  17 #include "cc/tile_draw_quad.h"
  18 #include "third_party/khronos/GLES2/gl2.h"
  19 #include "third_party/skia/include/core/SkColor.h"
  20 #include "ui/gfx/quad_f.h"
  21
  22 using namespace std;
  23
  24 namespace cc {
  25
  26 class DrawableTile : public LayerTilingData::Tile {
  27 public:
  28     static scoped_ptr<DrawableTile> create() { return make_scoped_ptr(new DrawableTile()); }
  29
  30     ResourceProvider::ResourceId resourceId() const { return m_resourceId; }
  31     void setResourceId(ResourceProvider::ResourceId resourceId) { m_resourceId = resourceId; }
  32     bool contentsSwizzled() { return m_contentsSwizzled; }
  33     void setContentsSwizzled(bool contentsSwizzled) { m_contentsSwizzled = contentsSwizzled; }
  34
  35 private:
  36     DrawableTile()
  37         : m_resourceId(0)
  38         , m_contentsSwizzled(false) { }
  39
  40     ResourceProvider::ResourceId m_resourceId;
  41     bool m_contentsSwizzled;
  42
  43     DISALLOW_COPY_AND_ASSIGN(DrawableTile);
  44 };
  45
  46 TiledLayerImpl::TiledLayerImpl(int id)
  47     : LayerImpl(id)
  48     , m_skipsDraw(true)
  49 {
  50 }
  51
  52 TiledLayerImpl::~TiledLayerImpl()
  53 {
  54 }
  55
  56 ResourceProvider::ResourceId TiledLayerImpl::contentsResourceId() const
  57 {
  58     // This function is only valid for single texture layers, e.g. masks.
  59     DCHECK(m_tiler);
  60     DCHECK(m_tiler->numTilesX() == 1);
  61     DCHECK(m_tiler->numTilesY() == 1);
  62
  63     DrawableTile* tile = tileAt(0, 0);
  64     ResourceProvider::ResourceId resourceId = tile ? tile->resourceId() : 0;
  65     return resourceId;
  66 }
  67
  68 void TiledLayerImpl::dumpLayerProperties(std::string* str, int indent) const
  69 {
  70     str->append(indentString(indent));
  71     base::StringAppendF(str, "skipsDraw: %d\n", (!m_tiler || m_skipsDraw));
  72     LayerImpl::dumpLayerProperties(str, indent);
  73 }
  74
  75 bool TiledLayerImpl::hasTileAt(int i, int j) const
  76 {
  77     return m_tiler->tileAt(i, j);
  78 }
  79
  80 bool TiledLayerImpl::hasResourceIdForTileAt(int i, int j) const
  81 {
  82     return hasTileAt(i, j) && tileAt(i, j)->resourceId();
  83 }
  84
  85 DrawableTile* TiledLayerImpl::tileAt(int i, int j) const
  86 {
  87     return static_cast<DrawableTile*>(m_tiler->tileAt(i, j));
  88 }
  89
  90 DrawableTile* TiledLayerImpl::createTile(int i, int j)
  91 {
  92     scoped_ptr<DrawableTile> tile(DrawableTile::create());
  93     DrawableTile* addedTile = tile.get();
  94     m_tiler->addTile(tile.PassAs<LayerTilingData::Tile>(), i, j);
  95     return addedTile;
  96 }
  97
  98 void TiledLayerImpl::getDebugBorderProperties(SkColor* color, float* width) const
  99 {
 100     *color = DebugColors::TiledContentLayerBorderColor();
 101     *width = DebugColors::TiledContentLayerBorderWidth(layerTreeHostImpl());
 102 }
 103
 104 void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
 105 {
 106     const gfx::Rect& contentRect = visibleContentRect();
 107
 108     if (!m_tiler || m_tiler->hasEmptyBounds() || contentRect.IsEmpty())
 109         return;
 110
 111     SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
 112     appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
 113
 114     int left, top, right, bottom;
 115     m_tiler->contentRectToTileIndices(contentRect, left, top, right, bottom);
 116
 117     if (showDebugBorders()) {
 118         for (int j = top; j <= bottom; ++j) {
 119             for (int i = left; i <= right; ++i) {
 120                 DrawableTile* tile = tileAt(i, j);
 121                 gfx::Rect tileRect = m_tiler->tileBounds(i, j);
 122                 SkColor borderColor;
 123                 float borderWidth;
 124
 125                 if (m_skipsDraw || !tile || !tile->resourceId()) {
 126                     borderColor = DebugColors::MissingTileBorderColor();
 127                     borderWidth = DebugColors::MissingTileBorderWidth(layerTreeHostImpl());
 128                 } else {
 129                     borderColor = DebugColors::TileBorderColor();
 130                     borderWidth = DebugColors::TileBorderWidth(layerTreeHostImpl());
 131                 }
 132                 scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
 133                 debugBorderQuad->SetNew(sharedQuadState, tileRect, borderColor, borderWidth);
 134                 quadSink.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
 135             }
 136         }
 137     }
 138
 139     if (m_skipsDraw)
 140         return;
 141
 142     for (int j = top; j <= bottom; ++j) {
 143         for (int i = left; i <= right; ++i) {
 144             DrawableTile* tile = tileAt(i, j);
 145             gfx::Rect tileRect = m_tiler->tileBounds(i, j);
 146             gfx::Rect displayRect = tileRect;
 147             tileRect.Intersect(contentRect);
 148
 149             // Skip empty tiles.
 150             if (tileRect.IsEmpty())
 151                 continue;
 152
 153             if (!tile || !tile->resourceId()) {
 154                 if (drawCheckerboardForMissingTiles()) {
 155                     SkColor checkerColor;
 156                     if (showDebugBorders())
 157                         checkerColor = tile ? DebugColors::InvalidatedTileCheckerboardColor() : DebugColors::EvictedTileCheckerboardColor();
 158                     else
 159                         checkerColor = DebugColors::DefaultCheckerboardColor();
 160
 161                     scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create();
 162                     checkerboardQuad->SetNew(sharedQuadState, tileRect, checkerColor);
 163                     appendQuadsData.hadMissingTiles |= quadSink.append(checkerboardQuad.PassAs<DrawQuad>(), appendQuadsData);
 164                 } else {
 165                     scoped_ptr<SolidColorDrawQuad> solidColorQuad = SolidColorDrawQuad::Create();
 166                     solidColorQuad->SetNew(sharedQuadState, tileRect, backgroundColor());
 167                     appendQuadsData.hadMissingTiles |= quadSink.append(solidColorQuad.PassAs<DrawQuad>(), appendQuadsData);
 168                 }
 169                 continue;
 170             }
 171
 172             gfx::Rect tileOpaqueRect = contentsOpaque() ? tileRect : gfx::IntersectRects(tile->opaqueRect(), contentRect);
 173
 174             // Keep track of how the top left has moved, so the texture can be
 175             // offset the same amount.
 176             gfx::Vector2d displayOffset = tileRect.origin() - displayRect.origin();
 177             gfx::Vector2d textureOffset = m_tiler->textureOffset(i, j) + displayOffset;
 178             gfx::RectF texCoordRect = gfx::RectF(tileRect.size()) + textureOffset;
 179
 180             float tileWidth = static_cast<float>(m_tiler->tileSize().width());
 181             float tileHeight = static_cast<float>(m_tiler->tileSize().height());
 182             gfx::Size textureSize(tileWidth, tileHeight);
 183
 184             bool clipped = false;
 185             gfx::QuadF visibleContentInTargetQuad = MathUtil::mapQuad(drawTransform(), gfx::QuadF(visibleContentRect()), clipped);
 186             bool isAxisAlignedInTarget = !clipped && visibleContentInTargetQuad.IsRectilinear();
 187             bool useAA = m_tiler->hasBorderTexels() && !isAxisAlignedInTarget;
 188
 189             bool leftEdgeAA = !i && useAA;
 190             bool topEdgeAA = !j && useAA;
 191             bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA;
 192             bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA;
 193
 194             scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
 195             quad->SetNew(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
 196             quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 197         }
 198     }
 199 }
 200
 201 void TiledLayerImpl::setTilingData(const LayerTilingData& tiler)
 202 {
 203     if (m_tiler)
 204         m_tiler->reset();
 205     else
 206         m_tiler = LayerTilingData::create(tiler.tileSize(), tiler.hasBorderTexels() ? LayerTilingData::HasBorderTexels : LayerTilingData::NoBorderTexels);
 207     *m_tiler = tiler;
 208 }
 209
 210 void TiledLayerImpl::pushTileProperties(int i, int j, ResourceProvider::ResourceId resourceId, const gfx::Rect& opaqueRect, bool contentsSwizzled)
 211 {
 212     DrawableTile* tile = tileAt(i, j);
 213     if (!tile)
 214         tile = createTile(i, j);
 215     tile->setResourceId(resourceId);
 216     tile->setOpaqueRect(opaqueRect);
 217     tile->setContentsSwizzled(contentsSwizzled);
 218 }
 219
 220 void TiledLayerImpl::pushInvalidTile(int i, int j)
 221 {
 222     DrawableTile* tile = tileAt(i, j);
 223     if (!tile)
 224         tile = createTile(i, j);
 225     tile->setResourceId(0);
 226     tile->setOpaqueRect(gfx::Rect());
 227     tile->setContentsSwizzled(false);
 228 }
 229
 230 Region TiledLayerImpl::visibleContentOpaqueRegion() const
 231 {
 232     if (m_skipsDraw)
 233         return Region();
 234     if (contentsOpaque())
 235         return visibleContentRect();
 236     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
 237 }
 238
 239 void TiledLayerImpl::didLoseContext()
 240 {
 241     m_tiler->reset();
 242 }
 243
 244 const char* TiledLayerImpl::layerTypeAsString() const
 245 {
 246     return "ContentLayer";
 247 }
 248
 249 }  // namespace cc