void CCLayerTreeHost::updateLayers(LayerChromium* rootLayer, CCTextureUpdater& updater)
{
TRACE_EVENT("CCLayerTreeHost::updateLayers", this, 0);
if (!rootLayer->renderSurface())
rootLayer->createRenderSurface();
rootLayer->renderSurface()->setContentRect(IntRect(IntPoint(0, 0), deviceViewportSize()));
IntRect rootClipRect(IntPoint(), deviceViewportSize());
rootLayer->setClipRect(rootClipRect);
LayerList updateList;
updateList.append(rootLayer);
RenderSurfaceChromium* rootRenderSurface = rootLayer->renderSurface();
rootRenderSurface->clearLayerList();
{
TRACE_EVENT("CCLayerTreeHost::updateLayers::calcDrawEtc", this, 0);
WebTransformationMatrix identityMatrix;
WebTransformationMatrix deviceScaleTransform;
deviceScaleTransform.scale(m_deviceScaleFactor);
CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, updateList, rootRenderSurface->layerList(), layerRendererCapabilities().maxTextureSize);
FloatRect rootScissorRect(FloatPoint(0, 0), viewportSize());
CCLayerTreeHostCommon::calculateVisibleAndScissorRects(updateList, rootScissorRect);
}
// Reset partial texture update requests.
m_partialTextureUpdateRequests = 0;
reserveTextures(updateList);
paintLayerContents(updateList, PaintVisible, updater);
if (!m_triggerIdlePaints)
return;
size_t preferredLimitBytes = m_contentsTextureManager->preferredMemoryLimitBytes();
size_t maxLimitBytes = m_contentsTextureManager->maxMemoryLimitBytes();
m_contentsTextureManager->reduceMemoryToLimit(preferredLimitBytes);
if (m_contentsTextureManager->currentMemoryUseBytes() >= preferredLimitBytes)
return;
// Idle painting should fail when we hit the preferred memory limit,
// otherwise it will always push us towards the maximum limit.
m_contentsTextureManager->setMaxMemoryLimitBytes(preferredLimitBytes);
// The second (idle) paint will be a no-op in layers where painting already occured above.
paintLayerContents(updateList, PaintIdle, updater);
m_contentsTextureManager->setMaxMemoryLimitBytes(maxLimitBytes);
for (size_t i = 0; i < updateList.size(); ++i)
updateList[i]->clearRenderSurface();
}
void DeprecatedPaintLayerPainter::paintLayerContentsAndReflection(GraphicsContext* context, const DeprecatedPaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, FragmentPolicy fragmentPolicy)
{
ASSERT(m_paintLayer.isSelfPaintingLayer() || m_paintLayer.hasSelfPaintingLayerDescendant());
PaintLayerFlags localPaintFlags = paintFlags & ~(PaintLayerAppliedTransform);
// Paint the reflection first if we have one.
if (m_paintLayer.reflectionInfo()) {
ScopeRecorder scopeRecorder(*context);
m_paintLayer.reflectionInfo()->paint(context, paintingInfo, localPaintFlags | PaintLayerPaintingReflection);
}
localPaintFlags |= PaintLayerPaintingCompositingAllPhases;
paintLayerContents(context, paintingInfo, localPaintFlags, fragmentPolicy);
}
PaintLayerPainter::PaintResult PaintLayerPainter::paintLayerContentsAndReflection(GraphicsContext& context, const PaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, FragmentPolicy fragmentPolicy)
{
ASSERT(m_paintLayer.isSelfPaintingLayer() || m_paintLayer.hasSelfPaintingLayerDescendant());
PaintLayerFlags localPaintFlags = paintFlags & ~(PaintLayerAppliedTransform);
PaintResult result = FullyPainted;
// Paint the reflection first if we have one.
if (m_paintLayer.reflectionInfo()) {
ScopeRecorder scopeRecorder(context);
if (m_paintLayer.reflectionInfo()->paint(context, paintingInfo, localPaintFlags) == MayBeClippedByPaintDirtyRect)
result = MayBeClippedByPaintDirtyRect;
}
localPaintFlags |= PaintLayerPaintingCompositingAllPhases;
if (paintLayerContents(context, paintingInfo, localPaintFlags, fragmentPolicy) == MayBeClippedByPaintDirtyRect)
result = MayBeClippedByPaintDirtyRect;
return result;
}
void CCLayerTreeHost::updateLayers(LayerChromium* rootLayer, CCTextureUpdater& updater)
{
TRACE_EVENT0("cc", "CCLayerTreeHost::updateLayers");
if (!rootLayer->renderSurface())
rootLayer->createRenderSurface();
rootLayer->renderSurface()->setContentRect(IntRect(IntPoint(0, 0), deviceViewportSize()));
IntRect rootClipRect(IntPoint(), deviceViewportSize());
rootLayer->setClipRect(rootClipRect);
LayerList updateList;
updateList.append(rootLayer);
RenderSurfaceChromium* rootRenderSurface = rootLayer->renderSurface();
rootRenderSurface->clearLayerList();
{
TRACE_EVENT0("cc", "CCLayerTreeHost::updateLayers::calcDrawEtc");
WebTransformationMatrix identityMatrix;
WebTransformationMatrix deviceScaleTransform;
deviceScaleTransform.scale(m_deviceScaleFactor);
CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, updateList, rootRenderSurface->layerList(), layerRendererCapabilities().maxTextureSize);
FloatRect rootScissorRect(FloatPoint(0, 0), viewportSize());
CCLayerTreeHostCommon::calculateVisibleAndScissorRects(updateList, rootScissorRect);
}
// Reset partial texture update requests.
m_partialTextureUpdateRequests = 0;
prioritizeTextures(updateList);
bool needMoreUpdates = paintLayerContents(updateList, updater);
if (m_triggerIdleUpdates && needMoreUpdates)
setNeedsCommit();
for (size_t i = 0; i < updateList.size(); ++i)
updateList[i]->clearRenderSurface();
}
void CCLayerTreeHost::updateLayers(LayerChromium* rootLayer, CCTextureUpdateQueue& queue)
{
TRACE_EVENT0("cc", "CCLayerTreeHost::updateLayers");
LayerList updateList;
{
TRACE_EVENT0("cc", "CCLayerTreeHost::updateLayers::calcDrawEtc");
CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize(), m_deviceScaleFactor, rendererCapabilities().maxTextureSize, updateList);
CCLayerTreeHostCommon::calculateVisibleRects(updateList);
}
// Reset partial texture update requests.
m_partialTextureUpdateRequests = 0;
bool needMoreUpdates = paintLayerContents(updateList, queue);
if (m_triggerIdleUpdates && needMoreUpdates)
setNeedsCommit();
for (size_t i = 0; i < updateList.size(); ++i)
updateList[i]->clearRenderSurface();
}
void LayerRendererChromium::updateLayers(LayerList& renderSurfaceLayerList)
{
TRACE_EVENT("LayerRendererChromium::updateLayers", this, 0);
CCLayerImpl* rootDrawLayer = m_rootLayer->ccLayerImpl();
if (!rootDrawLayer->renderSurface())
rootDrawLayer->createRenderSurface();
ASSERT(rootDrawLayer->renderSurface());
rootDrawLayer->renderSurface()->m_contentRect = IntRect(IntPoint(0, 0), m_viewportVisibleRect.size());
IntRect rootScissorRect(m_viewportVisibleRect);
// The scissorRect should not include the scroll offset.
rootScissorRect.move(-m_viewportScrollPosition.x(), -m_viewportScrollPosition.y());
rootDrawLayer->setScissorRect(rootScissorRect);
m_defaultRenderSurface = rootDrawLayer->renderSurface();
renderSurfaceLayerList.append(rootDrawLayer);
TransformationMatrix identityMatrix;
m_defaultRenderSurface->m_layerList.clear();
// Unfortunately, updatePropertiesAndRenderSurfaces() currently both updates the layers and updates the draw state
// (transforms, etc). It'd be nicer if operations on the presentation layers happened later, but the draw
// transforms are needed by large layers to determine visibility. Tiling will fix this by eliminating the
// concept of a large content layer.
updatePropertiesAndRenderSurfaces(rootDrawLayer, identityMatrix, renderSurfaceLayerList, m_defaultRenderSurface->m_layerList);
#ifndef NDEBUG
s_inPaintLayerContents = true;
#endif
paintLayerContents(renderSurfaceLayerList);
#ifndef NDEBUG
s_inPaintLayerContents = false;
#endif
// FIXME: Before updateCompositorResourcesRecursive, when the compositor runs in
// its own thread, and when the copyTexImage2D bug is fixed, insert
// a glWaitLatch(Compositor->Offscreen) on all child contexts here instead
// of after updateCompositorResourcesRecursive.
// Also uncomment the glSetLatch(Compositor->Offscreen) code in addChildContext.
// if (hardwareCompositing() && m_contextSupportsLatch) {
// // For each child context:
// // glWaitLatch(Compositor->Offscreen);
// ChildContextMap::iterator i = m_childContexts.begin();
// for (; i != m_childContexts.end(); ++i) {
// Extensions3DChromium* ext = static_cast<Extensions3DChromium*>(i->first->getExtensions());
// GC3Duint childToParentLatchId, parentToChildLatchId;
// ext->getParentToChildLatchCHROMIUM(&parentToChildLatchId);
// ext->waitLatchCHROMIUM(parentToChildLatchId);
// }
// }
updateCompositorResourcesRecursive(m_rootLayer.get());
// After updateCompositorResourcesRecursive, set/wait latches for all child
// contexts. This will prevent the compositor from using any of the child
// parent textures while WebGL commands are executing from javascript *and*
// while the final parent texture is being blit'd. copyTexImage2D
// uses the parent texture as a temporary resolve buffer, so that's why the
// waitLatch is below, to block the compositor from using the parent texture
// until the next WebGL SwapBuffers (or copyTextureToParentTexture for
// Canvas2D).
if (hardwareCompositing() && m_contextSupportsLatch) {
m_childContextsWereCopied = true;
// For each child context:
// glSetLatch(Offscreen->Compositor);
// glWaitLatch(Compositor->Offscreen);
ChildContextMap::iterator i = m_childContexts.begin();
for (; i != m_childContexts.end(); ++i) {
Extensions3DChromium* ext = static_cast<Extensions3DChromium*>(i->first->getExtensions());
GC3Duint childToParentLatchId, parentToChildLatchId;
ext->getParentToChildLatchCHROMIUM(&parentToChildLatchId);
ext->getChildToParentLatchCHROMIUM(&childToParentLatchId);
ext->setLatchCHROMIUM(childToParentLatchId);
ext->waitLatchCHROMIUM(parentToChildLatchId);
}
}
}
