cc/render_surface_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/render_surface_impl.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "base/stringprintf.h"
  11 #include "cc/damage_tracker.h"
  12 #include "cc/debug_border_draw_quad.h"
  13 #include "cc/debug_colors.h"
  14 #include "cc/delegated_renderer_layer_impl.h"
  15 #include "cc/layer_impl.h"
  16 #include "cc/math_util.h"
  17 #include "cc/quad_sink.h"
  18 #include "cc/render_pass.h"
  19 #include "cc/render_pass_draw_quad.h"
  20 #include "cc/render_pass_sink.h"
  21 #include "cc/shared_quad_state.h"
  22 #include "third_party/skia/include/core/SkImageFilter.h"
  23 #include "ui/gfx/rect_conversions.h"
  24 #include "ui/gfx/transform.h"
  25
  26 namespace cc {
  27
  28 RenderSurfaceImpl::RenderSurfaceImpl(LayerImpl* owningLayer)
  29     : m_owningLayer(owningLayer)
  30     , m_surfacePropertyChanged(false)
  31     , m_drawOpacity(1)
  32     , m_drawOpacityIsAnimating(false)
  33     , m_targetSurfaceTransformsAreAnimating(false)
  34     , m_screenSpaceTransformsAreAnimating(false)
  35     , m_isClipped(false)
  36     , m_nearestAncestorThatMovesPixels(0)
  37     , m_targetRenderSurfaceLayerIndexHistory(0)
  38     , m_currentLayerIndexHistory(0)
  39 {
  40     m_damageTracker = DamageTracker::create();
  41 }
  42
  43 RenderSurfaceImpl::~RenderSurfaceImpl()
  44 {
  45 }
  46
  47 gfx::RectF RenderSurfaceImpl::drawableContentRect() const
  48 {
  49     gfx::RectF drawableContentRect = MathUtil::mapClippedRect(m_drawTransform, m_contentRect);
  50     if (m_owningLayer->hasReplica())
  51         drawableContentRect.Union(MathUtil::mapClippedRect(m_replicaDrawTransform, m_contentRect));
  52
  53     return drawableContentRect;
  54 }
  55
  56 std::string RenderSurfaceImpl::name() const
  57 {
  58     return base::StringPrintf("RenderSurfaceImpl(id=%i,owner=%s)", m_owningLayer->id(), m_owningLayer->debugName().data());
  59 }
  60
  61 static std::string indentString(int indent)
  62 {
  63     std::string str;
  64     for (int i = 0; i != indent; ++i)
  65         str.append("  ");
  66     return str;
  67 }
  68
  69 void RenderSurfaceImpl::dumpSurface(std::string* str, int indent) const
  70 {
  71     std::string indentStr = indentString(indent);
  72     str->append(indentStr);
  73     base::StringAppendF(str, "%s\n", name().data());
  74
  75     indentStr.append("  ");
  76     str->append(indentStr);
  77     base::StringAppendF(str, "contentRect: (%d, %d, %d, %d)\n", m_contentRect.x(), m_contentRect.y(), m_contentRect.width(), m_contentRect.height());
  78
  79     str->append(indentStr);
  80     base::StringAppendF(str, "drawTransform: %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f\n",
  81         m_drawTransform.matrix().getDouble(0, 0), m_drawTransform.matrix().getDouble(0, 1), m_drawTransform.matrix().getDouble(0, 2), m_drawTransform.matrix().getDouble(0, 3),
  82         m_drawTransform.matrix().getDouble(1, 0), m_drawTransform.matrix().getDouble(1, 1), m_drawTransform.matrix().getDouble(1, 2), m_drawTransform.matrix().getDouble(1, 3),
  83         m_drawTransform.matrix().getDouble(2, 0), m_drawTransform.matrix().getDouble(2, 1), m_drawTransform.matrix().getDouble(2, 2), m_drawTransform.matrix().getDouble(2, 3),
  84         m_drawTransform.matrix().getDouble(3, 0), m_drawTransform.matrix().getDouble(3, 1), m_drawTransform.matrix().getDouble(3, 2), m_drawTransform.matrix().getDouble(3, 3));
  85
  86     str->append(indentStr);
  87     base::StringAppendF(str, "damageRect is pos(%f, %f), size(%f, %f)\n",
  88         m_damageTracker->currentDamageRect().x(), m_damageTracker->currentDamageRect().y(),
  89         m_damageTracker->currentDamageRect().width(), m_damageTracker->currentDamageRect().height());
  90 }
  91
  92 int RenderSurfaceImpl::owningLayerId() const
  93 {
  94     return m_owningLayer ? m_owningLayer->id() : 0;
  95 }
  96
  97
  98 void RenderSurfaceImpl::setClipRect(const gfx::Rect& clipRect)
  99 {
 100     if (m_clipRect == clipRect)
 101         return;
 102
 103     m_surfacePropertyChanged = true;
 104     m_clipRect = clipRect;
 105 }
 106
 107 bool RenderSurfaceImpl::contentsChanged() const
 108 {
 109     return !m_damageTracker->currentDamageRect().IsEmpty();
 110 }
 111
 112 void RenderSurfaceImpl::setContentRect(const gfx::Rect& contentRect)
 113 {
 114     if (m_contentRect == contentRect)
 115         return;
 116
 117     m_surfacePropertyChanged = true;
 118     m_contentRect = contentRect;
 119 }
 120
 121 bool RenderSurfaceImpl::surfacePropertyChanged() const
 122 {
 123     // Surface property changes are tracked as follows:
 124     //
 125     // - m_surfacePropertyChanged is flagged when the clipRect or contentRect change. As
 126     //   of now, these are the only two properties that can be affected by descendant layers.
 127     //
 128     // - all other property changes come from the owning layer (or some ancestor layer
 129     //   that propagates its change to the owning layer).
 130     //
 131     DCHECK(m_owningLayer);
 132     return m_surfacePropertyChanged || m_owningLayer->layerPropertyChanged();
 133 }
 134
 135 bool RenderSurfaceImpl::surfacePropertyChangedOnlyFromDescendant() const
 136 {
 137     return m_surfacePropertyChanged && !m_owningLayer->layerPropertyChanged();
 138 }
 139
 140 void RenderSurfaceImpl::addContributingDelegatedRenderPassLayer(LayerImpl* layer)
 141 {
 142     DCHECK(std::find(m_layerList.begin(), m_layerList.end(), layer) != m_layerList.end());
 143     DelegatedRendererLayerImpl* delegatedRendererLayer = static_cast<DelegatedRendererLayerImpl*>(layer);
 144     m_contributingDelegatedRenderPassLayerList.push_back(delegatedRendererLayer);
 145 }
 146
 147 void RenderSurfaceImpl::clearLayerLists()
 148 {
 149     m_layerList.clear();
 150     m_contributingDelegatedRenderPassLayerList.clear();
 151 }
 152
 153 static inline gfx::Rect computeClippedRectInTarget(const LayerImpl* owningLayer)
 154 {
 155     DCHECK(owningLayer->parent());
 156
 157     const LayerImpl* renderTarget = owningLayer->parent()->renderTarget();
 158     const RenderSurfaceImpl* self = owningLayer->renderSurface();
 159
 160     gfx::Rect clippedRectInTarget = self->clipRect();
 161     if (owningLayer->backgroundFilters().hasFilterThatMovesPixels()) {
 162         // If the layer has background filters that move pixels, we cannot scissor as tightly.
 163         // FIXME: this should be able to be a tighter scissor, perhaps expanded by the filter outsets?
 164         clippedRectInTarget = renderTarget->renderSurface()->contentRect();
 165     } else if (clippedRectInTarget.IsEmpty()) {
 166         // For surfaces, empty clipRect means that the surface does not clip anything.
 167         clippedRectInTarget = renderTarget->renderSurface()->contentRect();
 168         clippedRectInTarget.Intersect(gfx::ToEnclosingRect(self->drawableContentRect()));
 169     } else
 170         clippedRectInTarget.Intersect(gfx::ToEnclosingRect(self->drawableContentRect()));
 171     return clippedRectInTarget;
 172 }
 173
 174 RenderPass::Id RenderSurfaceImpl::renderPassId()
 175 {
 176     int layerId = m_owningLayer->id();
 177     int subId = 0;
 178     DCHECK(layerId > 0);
 179     return RenderPass::Id(layerId, subId);
 180 }
 181
 182 void RenderSurfaceImpl::appendRenderPasses(RenderPassSink& passSink)
 183 {
 184     for (size_t i = 0; i < m_contributingDelegatedRenderPassLayerList.size(); ++i)
 185         m_contributingDelegatedRenderPassLayerList[i]->appendContributingRenderPasses(passSink);
 186
 187     scoped_ptr<RenderPass> pass = RenderPass::Create();
 188     pass->SetNew(renderPassId(), m_contentRect, m_damageTracker->currentDamageRect(), m_screenSpaceTransform);
 189     passSink.appendRenderPass(pass.Pass());
 190 }
 191
 192 void RenderSurfaceImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData, bool forReplica, RenderPass::Id renderPassId)
 193 {
 194     DCHECK(!forReplica || m_owningLayer->hasReplica());
 195
 196     gfx::Rect clippedRectInTarget = computeClippedRectInTarget(m_owningLayer);
 197     const gfx::Transform& drawTransform = forReplica ? m_replicaDrawTransform : m_drawTransform;
 198     SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(SharedQuadState::Create());
 199     sharedQuadState->SetAll(drawTransform, m_contentRect, clippedRectInTarget, m_clipRect, m_isClipped, m_drawOpacity);
 200
 201     if (m_owningLayer->showDebugBorders()) {
 202         SkColor color = forReplica ? DebugColors::SurfaceReplicaBorderColor() : DebugColors::SurfaceBorderColor();
 203         float width = forReplica ? DebugColors::SurfaceReplicaBorderWidth(m_owningLayer->layerTreeImpl()) : DebugColors::SurfaceBorderWidth(m_owningLayer->layerTreeImpl());
 204         scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
 205         debugBorderQuad->SetNew(sharedQuadState, contentRect(), color, width);
 206         quadSink.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
 207     }
 208
 209     // FIXME: By using the same RenderSurfaceImpl for both the content and its reflection,
 210     // it's currently not possible to apply a separate mask to the reflection layer
 211     // or correctly handle opacity in reflections (opacity must be applied after drawing
 212     // both the layer and its reflection). The solution is to introduce yet another RenderSurfaceImpl
 213     // to draw the layer and its reflection in. For now we only apply a separate reflection
 214     // mask if the contents don't have a mask of their own.
 215     LayerImpl* maskLayer = m_owningLayer->maskLayer();
 216     if (maskLayer && (!maskLayer->drawsContent() || maskLayer->bounds().IsEmpty()))
 217         maskLayer = 0;
 218
 219     if (!maskLayer && forReplica) {
 220         maskLayer = m_owningLayer->replicaLayer()->maskLayer();
 221         if (maskLayer && (!maskLayer->drawsContent() || maskLayer->bounds().IsEmpty()))
 222             maskLayer = 0;
 223     }
 224
 225     gfx::RectF maskUVRect(0.0f, 0.0f, 1.0f, 1.0f);
 226     if (maskLayer) {
 227         float scaleX = contentRect().width() / maskLayer->contentsScaleX() / maskLayer->bounds().width();
 228         float scaleY = contentRect().height() / maskLayer->contentsScaleY() / maskLayer->bounds().height();
 229
 230         maskUVRect = gfx::RectF(static_cast<float>(contentRect().x()) / contentRect().width() * scaleX,
 231                                 static_cast<float>(contentRect().y()) / contentRect().height() * scaleY,
 232                                 scaleX,
 233                                 scaleY);
 234     }
 235
 236     ResourceProvider::ResourceId maskResourceId = maskLayer ? maskLayer->contentsResourceId() : 0;
 237     gfx::Rect contentsChangedSinceLastFrame = contentsChanged() ? m_contentRect : gfx::Rect();
 238
 239     scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
 240     quad->SetNew(sharedQuadState, contentRect(), renderPassId, forReplica, maskResourceId, contentsChangedSinceLastFrame, maskUVRect, m_owningLayer->filters(), m_owningLayer->filter(), m_owningLayer->backgroundFilters());
 241     quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 242 }
 243
 244 }  // namespace cc