diff options
Diffstat (limited to 'cc/delegated_renderer_layer_impl.cc')
-rw-r--r-- | cc/delegated_renderer_layer_impl.cc | 185 |
1 files changed, 185 insertions, 0 deletions
diff --git a/cc/delegated_renderer_layer_impl.cc b/cc/delegated_renderer_layer_impl.cc new file mode 100644 index 0000000..02d5698 --- /dev/null +++ b/cc/delegated_renderer_layer_impl.cc @@ -0,0 +1,185 @@ +// Copyright 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "config.h" + +#include "CCDelegatedRendererLayerImpl.h" + +#include "CCAppendQuadsData.h" +#include "CCQuadSink.h" +#include "CCMathUtil.h" +#include "CCRenderPassDrawQuad.h" +#include "CCRenderPassSink.h" + +namespace cc { + +CCDelegatedRendererLayerImpl::CCDelegatedRendererLayerImpl(int id) + : CCLayerImpl(id) +{ +} + +CCDelegatedRendererLayerImpl::~CCDelegatedRendererLayerImpl() +{ + clearRenderPasses(); +} + +bool CCDelegatedRendererLayerImpl::descendantDrawsContent() +{ + // FIXME: This could possibly return false even though there are some + // quads present as they could all be from a single layer (or set of + // layers without children). If this happens, then make a test that + // ensures the opacity is being changed on quads in the root RenderPass + // when this layer doesn't own a RenderSurface. + return !m_renderPassesInDrawOrder.isEmpty(); +} + +bool CCDelegatedRendererLayerImpl::hasContributingDelegatedRenderPasses() const +{ + // The root RenderPass for the layer is merged with its target + // RenderPass in each frame. So we only have extra RenderPasses + // to merge when we have a non-root RenderPass present. + return m_renderPassesInDrawOrder.size() > 1; +} + +void CCDelegatedRendererLayerImpl::setRenderPasses(ScopedPtrVector<CCRenderPass>& renderPassesInDrawOrder) +{ + FloatRect oldRootDamage; + if (!m_renderPassesInDrawOrder.isEmpty()) + oldRootDamage = m_renderPassesInDrawOrder.last()->damageRect(); + + clearRenderPasses(); + + for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) { + m_renderPassesIndexById.insert(std::pair<CCRenderPass::Id, int>(renderPassesInDrawOrder[i]->id(), i)); + m_renderPassesInDrawOrder.append(renderPassesInDrawOrder.take(i)); + } + renderPassesInDrawOrder.clear(); + + if (!m_renderPassesInDrawOrder.isEmpty()) { + FloatRect newRootDamage = m_renderPassesInDrawOrder.last()->damageRect(); + m_renderPassesInDrawOrder.last()->setDamageRect(unionRect(oldRootDamage, newRootDamage)); + } +} + +void CCDelegatedRendererLayerImpl::clearRenderPasses() +{ + // FIXME: Release the resources back to the nested compositor. + m_renderPassesIndexById.clear(); + m_renderPassesInDrawOrder.clear(); +} + +void CCDelegatedRendererLayerImpl::didLoseContext() +{ + clearRenderPasses(); +} + +static inline int indexToId(int index) { return index + 1; } +static inline int idToIndex(int id) { return id - 1; } + +CCRenderPass::Id CCDelegatedRendererLayerImpl::firstContributingRenderPassId() const +{ + return CCRenderPass::Id(id(), indexToId(0)); +} + +CCRenderPass::Id CCDelegatedRendererLayerImpl::nextContributingRenderPassId(CCRenderPass::Id previous) const +{ + return CCRenderPass::Id(previous.layerId, previous.index + 1); +} + +CCRenderPass::Id CCDelegatedRendererLayerImpl::convertDelegatedRenderPassId(CCRenderPass::Id delegatedRenderPassId) const +{ + base::hash_map<CCRenderPass::Id, int>::const_iterator it = m_renderPassesIndexById.find(delegatedRenderPassId); + ASSERT(it != m_renderPassesIndexById.end()); + unsigned delegatedRenderPassIndex = it->second; + return CCRenderPass::Id(id(), indexToId(delegatedRenderPassIndex)); +} + +void CCDelegatedRendererLayerImpl::appendContributingRenderPasses(CCRenderPassSink& renderPassSink) +{ + ASSERT(hasContributingDelegatedRenderPasses()); + + for (size_t i = 0; i < m_renderPassesInDrawOrder.size() - 1; ++i) { + CCRenderPass::Id outputRenderPassId = convertDelegatedRenderPassId(m_renderPassesInDrawOrder[i]->id()); + + // Don't clash with the RenderPass we generate if we own a RenderSurface. + ASSERT(outputRenderPassId.index > 0); + + renderPassSink.appendRenderPass(m_renderPassesInDrawOrder[i]->copy(outputRenderPassId)); + } +} + +void CCDelegatedRendererLayerImpl::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData) +{ + if (m_renderPassesInDrawOrder.isEmpty()) + return; + + CCRenderPass::Id targetRenderPassId = appendQuadsData.renderPassId; + + // If the index of the renderPassId is 0, then it is a renderPass generated for a layer + // in this compositor, not the delegated renderer. Then we want to merge our root renderPass with + // the target renderPass. Otherwise, it is some renderPass which we added from the delegated + // renderer. + bool shouldMergeRootRenderPassWithTarget = !targetRenderPassId.index; + if (shouldMergeRootRenderPassWithTarget) { + // Verify that the renderPass we are appending to is created our renderTarget. + ASSERT(targetRenderPassId.layerId == renderTarget()->id()); + + CCRenderPass* rootDelegatedRenderPass = m_renderPassesInDrawOrder.last(); + appendRenderPassQuads(quadSink, appendQuadsData, rootDelegatedRenderPass); + } else { + // Verify that the renderPass we are appending to was created by us. + ASSERT(targetRenderPassId.layerId == id()); + + int renderPassIndex = idToIndex(targetRenderPassId.index); + CCRenderPass* delegatedRenderPass = m_renderPassesInDrawOrder[renderPassIndex]; + appendRenderPassQuads(quadSink, appendQuadsData, delegatedRenderPass); + } +} + +void CCDelegatedRendererLayerImpl::appendRenderPassQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData, CCRenderPass* delegatedRenderPass) const +{ + const CCSharedQuadState* currentSharedQuadState = 0; + CCSharedQuadState* copiedSharedQuadState = 0; + for (size_t i = 0; i < delegatedRenderPass->quadList().size(); ++i) { + CCDrawQuad* quad = delegatedRenderPass->quadList()[i]; + + if (quad->sharedQuadState() != currentSharedQuadState) { + currentSharedQuadState = quad->sharedQuadState(); + copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->copy()); + bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layerId == id(); + if (!targetIsFromDelegatedRendererLayer) { + // Should be the root render pass. + ASSERT(delegatedRenderPass == m_renderPassesInDrawOrder.last()); + // This layer must be drawing to a renderTarget other than itself. + ASSERT(renderTarget() != this); + + copiedSharedQuadState->clippedRectInTarget = CCMathUtil::mapClippedRect(drawTransform(), copiedSharedQuadState->clippedRectInTarget); + copiedSharedQuadState->quadTransform = copiedSharedQuadState->quadTransform * drawTransform(); + copiedSharedQuadState->opacity *= drawOpacity(); + } + } + ASSERT(copiedSharedQuadState); + + scoped_ptr<CCDrawQuad> copyQuad; + if (quad->material() != CCDrawQuad::RenderPass) + copyQuad = quad->copy(copiedSharedQuadState); + else { + CCRenderPass::Id contributingDelegatedRenderPassId = CCRenderPassDrawQuad::materialCast(quad)->renderPassId(); + CCRenderPass::Id contributingRenderPassId = convertDelegatedRenderPassId(contributingDelegatedRenderPassId); + ASSERT(contributingRenderPassId != appendQuadsData.renderPassId); + + copyQuad = CCRenderPassDrawQuad::materialCast(quad)->copy(copiedSharedQuadState, contributingRenderPassId).PassAs<CCDrawQuad>(); + } + ASSERT(copyQuad.get()); + + quadSink.append(copyQuad.Pass(), appendQuadsData); + } +} + +const char* CCDelegatedRendererLayerImpl::layerTypeAsString() const +{ + return "DelegatedRendererLayer"; +} + +} |