cc/delegated_renderer_layer_impl.cc

   1 // Copyright 2012 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/delegated_renderer_layer_impl.h"
   6
   7 #include "cc/append_quads_data.h"
   8 #include "cc/math_util.h"
   9 #include "cc/quad_sink.h"
  10 #include "cc/render_pass_draw_quad.h"
  11 #include "cc/render_pass_sink.h"
  12
  13 namespace cc {
  14
  15 DelegatedRendererLayerImpl::DelegatedRendererLayerImpl(LayerTreeImpl* treeImpl, int id)
  16     : LayerImpl(treeImpl, id)
  17 {
  18 }
  19
  20 DelegatedRendererLayerImpl::~DelegatedRendererLayerImpl()
  21 {
  22     clearRenderPasses();
  23 }
  24
  25 bool DelegatedRendererLayerImpl::hasDelegatedContent() const
  26 {
  27     return !m_renderPassesInDrawOrder.isEmpty();
  28 }
  29
  30 bool DelegatedRendererLayerImpl::hasContributingDelegatedRenderPasses() const
  31 {
  32     // The root RenderPass for the layer is merged with its target
  33     // RenderPass in each frame. So we only have extra RenderPasses
  34     // to merge when we have a non-root RenderPass present.
  35     return m_renderPassesInDrawOrder.size() > 1;
  36 }
  37
  38 void DelegatedRendererLayerImpl::setRenderPasses(ScopedPtrVector<RenderPass>& renderPassesInDrawOrder)
  39 {
  40     gfx::RectF oldRootDamage;
  41     if (!m_renderPassesInDrawOrder.isEmpty())
  42         oldRootDamage = m_renderPassesInDrawOrder.last()->damage_rect;
  43
  44     clearRenderPasses();
  45
  46     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) {
  47         m_renderPassesIndexById.insert(std::pair<RenderPass::Id, int>(renderPassesInDrawOrder[i]->id, i));
  48         m_renderPassesInDrawOrder.append(renderPassesInDrawOrder.take(i));
  49     }
  50     renderPassesInDrawOrder.clear();
  51
  52     if (!m_renderPassesInDrawOrder.isEmpty())
  53         m_renderPassesInDrawOrder.last()->damage_rect.Union(oldRootDamage);
  54 }
  55
  56 void DelegatedRendererLayerImpl::clearRenderPasses()
  57 {
  58     // FIXME: Release the resources back to the nested compositor.
  59     m_renderPassesIndexById.clear();
  60     m_renderPassesInDrawOrder.clear();
  61 }
  62
  63 void DelegatedRendererLayerImpl::didLoseOutputSurface()
  64 {
  65     clearRenderPasses();
  66 }
  67
  68 static inline int indexToId(int index) { return index + 1; }
  69 static inline int idToIndex(int id) { return id - 1; }
  70
  71 RenderPass::Id DelegatedRendererLayerImpl::firstContributingRenderPassId() const
  72 {
  73     return RenderPass::Id(id(), indexToId(0));
  74 }
  75
  76 RenderPass::Id DelegatedRendererLayerImpl::nextContributingRenderPassId(RenderPass::Id previous) const
  77 {
  78     return RenderPass::Id(previous.layer_id, previous.index + 1);
  79 }
  80
  81 RenderPass::Id DelegatedRendererLayerImpl::convertDelegatedRenderPassId(RenderPass::Id delegatedRenderPassId) const
  82 {
  83     base::hash_map<RenderPass::Id, int>::const_iterator it = m_renderPassesIndexById.find(delegatedRenderPassId);
  84     DCHECK(it != m_renderPassesIndexById.end());
  85     unsigned delegatedRenderPassIndex = it->second;
  86     return RenderPass::Id(id(), indexToId(delegatedRenderPassIndex));
  87 }
  88
  89 void DelegatedRendererLayerImpl::appendContributingRenderPasses(RenderPassSink& renderPassSink)
  90 {
  91     DCHECK(hasContributingDelegatedRenderPasses());
  92
  93     for (size_t i = 0; i < m_renderPassesInDrawOrder.size() - 1; ++i) {
  94         RenderPass::Id outputRenderPassId = convertDelegatedRenderPassId(m_renderPassesInDrawOrder[i]->id);
  95
  96         // Don't clash with the RenderPass we generate if we own a RenderSurfaceImpl.
  97         DCHECK(outputRenderPassId.index > 0);
  98
  99         renderPassSink.appendRenderPass(m_renderPassesInDrawOrder[i]->Copy(outputRenderPassId));
 100     }
 101 }
 102
 103 void DelegatedRendererLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
 104 {
 105     if (m_renderPassesInDrawOrder.isEmpty())
 106         return;
 107
 108     RenderPass::Id targetRenderPassId = appendQuadsData.renderPassId;
 109
 110     // If the index of the renderPassId is 0, then it is a renderPass generated for a layer
 111     // in this compositor, not the delegated renderer. Then we want to merge our root renderPass with
 112     // the target renderPass. Otherwise, it is some renderPass which we added from the delegated
 113     // renderer.
 114     bool shouldMergeRootRenderPassWithTarget = !targetRenderPassId.index;
 115     if (shouldMergeRootRenderPassWithTarget) {
 116         // Verify that the renderPass we are appending to is created our renderTarget.
 117         DCHECK(targetRenderPassId.layer_id == renderTarget()->id());
 118
 119         const RenderPass* rootDelegatedRenderPass = m_renderPassesInDrawOrder.last();
 120         appendRenderPassQuads(quadSink, appendQuadsData, rootDelegatedRenderPass);
 121     } else {
 122         // Verify that the renderPass we are appending to was created by us.
 123         DCHECK(targetRenderPassId.layer_id == id());
 124
 125         int renderPassIndex = idToIndex(targetRenderPassId.index);
 126         const RenderPass* delegatedRenderPass = m_renderPassesInDrawOrder[renderPassIndex];
 127         appendRenderPassQuads(quadSink, appendQuadsData, delegatedRenderPass);
 128     }
 129 }
 130
 131 void DelegatedRendererLayerImpl::appendRenderPassQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData, const RenderPass* delegatedRenderPass) const
 132 {
 133     const SharedQuadState* currentSharedQuadState = 0;
 134     SharedQuadState* copiedSharedQuadState = 0;
 135     for (size_t i = 0; i < delegatedRenderPass->quad_list.size(); ++i) {
 136         const DrawQuad* quad = delegatedRenderPass->quad_list[i];
 137
 138         if (quad->shared_quad_state != currentSharedQuadState) {
 139             currentSharedQuadState = quad->shared_quad_state;
 140             copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->Copy());
 141             bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layer_id == id();
 142             if (!targetIsFromDelegatedRendererLayer) {
 143               // Should be the root render pass.
 144               DCHECK(delegatedRenderPass == m_renderPassesInDrawOrder.last());
 145               // This layer must be drawing to a renderTarget other than itself.
 146               DCHECK(renderTarget() != this);
 147
 148               copiedSharedQuadState->content_to_target_transform = copiedSharedQuadState->content_to_target_transform * drawTransform();
 149               copiedSharedQuadState->clipped_rect_in_target = MathUtil::mapClippedRect(drawTransform(), copiedSharedQuadState->clipped_rect_in_target);
 150               copiedSharedQuadState->opacity *= drawOpacity();
 151             }
 152         }
 153         DCHECK(copiedSharedQuadState);
 154
 155         scoped_ptr<DrawQuad> copyQuad;
 156         if (quad->material != DrawQuad::RENDER_PASS)
 157             copyQuad = quad->Copy(copiedSharedQuadState);
 158         else {
 159             RenderPass::Id contributingDelegatedRenderPassId = RenderPassDrawQuad::MaterialCast(quad)->render_pass_id;
 160             RenderPass::Id contributingRenderPassId = convertDelegatedRenderPassId(contributingDelegatedRenderPassId);
 161             DCHECK(contributingRenderPassId != appendQuadsData.renderPassId);
 162
 163             copyQuad = RenderPassDrawQuad::MaterialCast(quad)->Copy(copiedSharedQuadState, contributingRenderPassId).PassAs<DrawQuad>();
 164         }
 165         DCHECK(copyQuad.get());
 166
 167         quadSink.append(copyQuad.Pass(), appendQuadsData);
 168     }
 169 }
 170
 171 const char* DelegatedRendererLayerImpl::layerTypeAsString() const
 172 {
 173     return "DelegatedRendererLayer";
 174 }
 175
 176 }  // namespace cc