cc/CCTiledLayerImpl.cpp

   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 "config.h"
   6
   7 #if USE(ACCELERATED_COMPOSITING)
   8
   9 #include "CCTiledLayerImpl.h"
  10
  11 #include "base/stringprintf.h"
  12 #include "CCAppendQuadsData.h"
  13 #include "CCCheckerboardDrawQuad.h"
  14 #include "CCDebugBorderDrawQuad.h"
  15 #include "CCLayerTilingData.h"
  16 #include "CCMathUtil.h"
  17 #include "CCQuadSink.h"
  18 #include "CCSolidColorDrawQuad.h"
  19 #include "CCTileDrawQuad.h"
  20 #include "FloatQuad.h"
  21 #include "GraphicsContext3D.h"
  22 #include "SkColor.h"
  23
  24 using namespace std;
  25 using WebKit::WebTransformationMatrix;
  26
  27 namespace WebCore {
  28
  29 static const int debugTileBorderWidth = 1;
  30 static const int debugTileBorderAlpha = 100;
  31 static const int debugTileBorderColorRed = 80;
  32 static const int debugTileBorderColorGreen = 200;
  33 static const int debugTileBorderColorBlue = 200;
  34 static const int debugTileBorderMissingTileColorRed = 255;
  35 static const int debugTileBorderMissingTileColorGreen = 0;
  36 static const int debugTileBorderMissingTileColorBlue = 0;
  37
  38 class DrawableTile : public CCLayerTilingData::Tile {
  39     WTF_MAKE_NONCOPYABLE(DrawableTile);
  40 public:
  41     static PassOwnPtr<DrawableTile> create() { return adoptPtr(new DrawableTile()); }
  42
  43     CCResourceProvider::ResourceId resourceId() const { return m_resourceId; }
  44     void setResourceId(CCResourceProvider::ResourceId resourceId) { m_resourceId = resourceId; }
  45
  46 private:
  47     DrawableTile() : m_resourceId(0) { }
  48
  49     CCResourceProvider::ResourceId m_resourceId;
  50 };
  51
  52 CCTiledLayerImpl::CCTiledLayerImpl(int id)
  53     : CCLayerImpl(id)
  54     , m_skipsDraw(true)
  55     , m_contentsSwizzled(false)
  56 {
  57 }
  58
  59 CCTiledLayerImpl::~CCTiledLayerImpl()
  60 {
  61 }
  62
  63 CCResourceProvider::ResourceId CCTiledLayerImpl::contentsResourceId() const
  64 {
  65     // This function is only valid for single texture layers, e.g. masks.
  66     ASSERT(m_tiler);
  67     ASSERT(m_tiler->numTilesX() == 1);
  68     ASSERT(m_tiler->numTilesY() == 1);
  69
  70     DrawableTile* tile = tileAt(0, 0);
  71     CCResourceProvider::ResourceId resourceId = tile ? tile->resourceId() : 0;
  72     ASSERT(resourceId);
  73
  74     return resourceId;
  75 }
  76
  77 void CCTiledLayerImpl::dumpLayerProperties(std::string* str, int indent) const
  78 {
  79     str->append(indentString(indent));
  80     base::StringAppendF(str, "skipsDraw: %d\n", (!m_tiler || m_skipsDraw));
  81     CCLayerImpl::dumpLayerProperties(str, indent);
  82 }
  83
  84 bool CCTiledLayerImpl::hasTileAt(int i, int j) const
  85 {
  86     return m_tiler->tileAt(i, j);
  87 }
  88
  89 bool CCTiledLayerImpl::hasTextureIdForTileAt(int i, int j) const
  90 {
  91     return hasTileAt(i, j) && tileAt(i, j)->resourceId();
  92 }
  93
  94 DrawableTile* CCTiledLayerImpl::tileAt(int i, int j) const
  95 {
  96     return static_cast<DrawableTile*>(m_tiler->tileAt(i, j));
  97 }
  98
  99 DrawableTile* CCTiledLayerImpl::createTile(int i, int j)
 100 {
 101     OwnPtr<DrawableTile> tile(DrawableTile::create());
 102     DrawableTile* addedTile = tile.get();
 103     m_tiler->addTile(tile.release(), i, j);
 104     return addedTile;
 105 }
 106
 107 void CCTiledLayerImpl::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData)
 108 {
 109     const IntRect& contentRect = visibleContentRect();
 110
 111     if (!m_tiler || m_tiler->hasEmptyBounds() || contentRect.isEmpty())
 112         return;
 113
 114     CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
 115     appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
 116
 117     int left, top, right, bottom;
 118     m_tiler->contentRectToTileIndices(contentRect, left, top, right, bottom);
 119
 120     if (hasDebugBorders()) {
 121         for (int j = top; j <= bottom; ++j) {
 122             for (int i = left; i <= right; ++i) {
 123                 DrawableTile* tile = tileAt(i, j);
 124                 IntRect tileRect = m_tiler->tileBounds(i, j);
 125                 SkColor borderColor;
 126
 127                 if (m_skipsDraw || !tile || !tile->resourceId())
 128                     borderColor = SkColorSetARGB(debugTileBorderAlpha, debugTileBorderMissingTileColorRed, debugTileBorderMissingTileColorGreen, debugTileBorderMissingTileColorBlue);
 129                 else
 130                     borderColor = SkColorSetARGB(debugTileBorderAlpha, debugTileBorderColorRed, debugTileBorderColorGreen, debugTileBorderColorBlue);
 131                 quadSink.append(CCDebugBorderDrawQuad::create(sharedQuadState, tileRect, borderColor, debugTileBorderWidth), appendQuadsData);
 132             }
 133         }
 134     }
 135
 136     if (m_skipsDraw)
 137         return;
 138
 139     for (int j = top; j <= bottom; ++j) {
 140         for (int i = left; i <= right; ++i) {
 141             DrawableTile* tile = tileAt(i, j);
 142             IntRect tileRect = m_tiler->tileBounds(i, j);
 143             IntRect displayRect = tileRect;
 144             tileRect.intersect(contentRect);
 145
 146             // Skip empty tiles.
 147             if (tileRect.isEmpty())
 148                 continue;
 149
 150             if (!tile || !tile->resourceId()) {
 151                 if (drawCheckerboardForMissingTiles())
 152                     appendQuadsData.hadMissingTiles |= quadSink.append(CCCheckerboardDrawQuad::create(sharedQuadState, tileRect), appendQuadsData);
 153                 else
 154                     appendQuadsData.hadMissingTiles |= quadSink.append(CCSolidColorDrawQuad::create(sharedQuadState, tileRect, backgroundColor()), appendQuadsData);
 155                 continue;
 156             }
 157
 158             IntRect tileOpaqueRect = tile->opaqueRect();
 159             tileOpaqueRect.intersect(contentRect);
 160
 161             // Keep track of how the top left has moved, so the texture can be
 162             // offset the same amount.
 163             IntSize displayOffset = tileRect.minXMinYCorner() - displayRect.minXMinYCorner();
 164             IntPoint textureOffset = m_tiler->textureOffset(i, j) + displayOffset;
 165             float tileWidth = static_cast<float>(m_tiler->tileSize().width());
 166             float tileHeight = static_cast<float>(m_tiler->tileSize().height());
 167             IntSize textureSize(tileWidth, tileHeight);
 168
 169             bool clipped = false;
 170             FloatQuad visibleContentInTargetQuad = CCMathUtil::mapQuad(drawTransform(), FloatQuad(visibleContentRect()), clipped);
 171             bool isAxisAlignedInTarget = !clipped && visibleContentInTargetQuad.isRectilinear();
 172             bool useAA = m_tiler->hasBorderTexels() && !isAxisAlignedInTarget;
 173
 174             bool leftEdgeAA = !i && useAA;
 175             bool topEdgeAA = !j && useAA;
 176             bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA;
 177             bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA;
 178
 179             const GC3Dint textureFilter = m_tiler->hasBorderTexels() ? GraphicsContext3D::LINEAR : GraphicsContext3D::NEAREST;
 180             quadSink.append(CCTileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), textureOffset, textureSize, textureFilter, contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA), appendQuadsData);
 181         }
 182     }
 183 }
 184
 185 void CCTiledLayerImpl::setTilingData(const CCLayerTilingData& tiler)
 186 {
 187     if (m_tiler)
 188         m_tiler->reset();
 189     else
 190         m_tiler = CCLayerTilingData::create(tiler.tileSize(), tiler.hasBorderTexels() ? CCLayerTilingData::HasBorderTexels : CCLayerTilingData::NoBorderTexels);
 191     *m_tiler = tiler;
 192 }
 193
 194 void CCTiledLayerImpl::pushTileProperties(int i, int j, CCResourceProvider::ResourceId resourceId, const IntRect& opaqueRect)
 195 {
 196     DrawableTile* tile = tileAt(i, j);
 197     if (!tile)
 198         tile = createTile(i, j);
 199     tile->setResourceId(resourceId);
 200     tile->setOpaqueRect(opaqueRect);
 201 }
 202
 203 Region CCTiledLayerImpl::visibleContentOpaqueRegion() const
 204 {
 205     if (m_skipsDraw)
 206         return Region();
 207     if (opaque())
 208         return visibleContentRect();
 209     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
 210 }
 211
 212 void CCTiledLayerImpl::didLoseContext()
 213 {
 214     m_tiler->reset();
 215 }
 216
 217 } // namespace WebCore
 218
 219 #endif // USE(ACCELERATED_COMPOSITING)