void LayerRendererChromium::paintLayerContents(const LayerList& renderSurfaceLayerList)
{
for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex].get();
RenderSurfaceChromium* renderSurface = renderSurfaceLayer->renderSurface();
ASSERT(renderSurface);
// Make sure any renderSurfaceLayer is associated with this layerRenderer.
// This is a defensive assignment in case the owner of this layer hasn't
// set the layerRenderer on this layer already.
renderSurfaceLayer->setLayerRenderer(this);
// Render surfaces whose drawable area has zero width or height
// will have no layers associated with them and should be skipped.
if (!renderSurface->m_layerList.size())
continue;
LayerList& layerList = renderSurface->m_layerList;
ASSERT(layerList.size());
for (unsigned layerIndex = 0; layerIndex < layerList.size(); ++layerIndex) {
CCLayerImpl* ccLayerImpl = layerList[layerIndex].get();
// Layers that start a new render surface will be painted when the render
// surface's list is processed.
if (ccLayerImpl->renderSurface() && ccLayerImpl->renderSurface() != renderSurface)
continue;
LayerChromium* layer = ccLayerImpl->owner();
layer->setLayerRenderer(this);
if (layer->maskLayer())
layer->maskLayer()->setLayerRenderer(this);
if (layer->replicaLayer()) {
layer->replicaLayer()->setLayerRenderer(this);
if (layer->replicaLayer()->maskLayer())
layer->replicaLayer()->maskLayer()->setLayerRenderer(this);
}
if (layer->bounds().isEmpty())
continue;
IntRect targetSurfaceRect = ccLayerImpl->targetRenderSurface() ? ccLayerImpl->targetRenderSurface()->contentRect() : m_defaultRenderSurface->contentRect();
IntRect scissorRect = layer->ccLayerImpl()->scissorRect();
if (!scissorRect.isEmpty())
targetSurfaceRect.intersect(scissorRect);
if (layer->drawsContent())
layer->paintContentsIfDirty(targetSurfaceRect);
if (layer->maskLayer() && layer->maskLayer()->drawsContent())
layer->maskLayer()->paintContentsIfDirty(targetSurfaceRect);
if (layer->replicaLayer() && layer->replicaLayer()->drawsContent())
layer->replicaLayer()->paintContentsIfDirty(targetSurfaceRect);
if (layer->replicaLayer() && layer->replicaLayer()->maskLayer() && layer->replicaLayer()->maskLayer()->drawsContent())
layer->replicaLayer()->maskLayer()->paintContentsIfDirty(targetSurfaceRect);
}
}
}
void CCLayerTreeHostImpl::trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList)
{
// For now, we use damage tracking to compute a global scissor. To do this, we must
// compute all damage tracking before drawing anything, so that we know the root
// damage rect. The root damage rect is then used to scissor each surface.
for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex];
CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface();
ASSERT(renderSurface);
renderSurface->damageTracker()->updateDamageTrackingState(renderSurface->layerList(), renderSurfaceLayer->id(), renderSurfaceLayer->maskLayer());
}
}
void LayerRendererChromium::updateCompositorResourcesRecursive(LayerChromium* layer)
{
const Vector<RefPtr<LayerChromium> >& children = layer->children();
for (size_t i = 0; i < children.size(); ++i)
updateCompositorResourcesRecursive(children[i].get());
if (layer->bounds().isEmpty())
return;
if (layer->maskLayer())
updateCompositorResourcesRecursive(layer->maskLayer());
if (layer->replicaLayer())
updateCompositorResourcesRecursive(layer->replicaLayer());
CCLayerImpl* drawLayer = layer->ccLayerImpl();
if (drawLayer->drawsContent())
drawLayer->updateCompositorResources();
layer->pushPropertiesTo(drawLayer);
}
void CCRenderSurface::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData, bool forReplica, CCRenderPass::Id renderPassId)
{
ASSERT(!forReplica || m_owningLayer->hasReplica());
IntRect clippedRectInTarget = computeClippedRectInTarget(m_owningLayer);
bool isOpaque = false;
const WebTransformationMatrix& drawTransform = forReplica ? m_replicaDrawTransform : m_drawTransform;
CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(CCSharedQuadState::create(drawTransform, m_contentRect, clippedRectInTarget, m_drawOpacity, isOpaque));
if (m_owningLayer->hasDebugBorders()) {
int red = forReplica ? debugReplicaBorderColorRed : debugSurfaceBorderColorRed;
int green = forReplica ? debugReplicaBorderColorGreen : debugSurfaceBorderColorGreen;
int blue = forReplica ? debugReplicaBorderColorBlue : debugSurfaceBorderColorBlue;
SkColor color = SkColorSetARGB(debugSurfaceBorderAlpha, red, green, blue);
quadSink.append(CCDebugBorderDrawQuad::create(sharedQuadState, contentRect(), color, debugSurfaceBorderWidth), appendQuadsData);
}
// FIXME: By using the same RenderSurface for both the content and its reflection,
// it's currently not possible to apply a separate mask to the reflection layer
// or correctly handle opacity in reflections (opacity must be applied after drawing
// both the layer and its reflection). The solution is to introduce yet another RenderSurface
// to draw the layer and its reflection in. For now we only apply a separate reflection
// mask if the contents don't have a mask of their own.
CCLayerImpl* maskLayer = m_owningLayer->maskLayer();
if (maskLayer && (!maskLayer->drawsContent() || maskLayer->bounds().isEmpty()))
maskLayer = 0;
if (!maskLayer && forReplica) {
maskLayer = m_owningLayer->replicaLayer()->maskLayer();
if (maskLayer && (!maskLayer->drawsContent() || maskLayer->bounds().isEmpty()))
maskLayer = 0;
}
float maskTexCoordScaleX = 1;
float maskTexCoordScaleY = 1;
float maskTexCoordOffsetX = 1;
float maskTexCoordOffsetY = 1;
if (maskLayer) {
maskTexCoordScaleX = static_cast<float>(contentRect().width()) / maskLayer->contentBounds().width();
maskTexCoordScaleY = static_cast<float>(contentRect().height()) / maskLayer->contentBounds().height();
maskTexCoordOffsetX = static_cast<float>(contentRect().x()) / contentRect().width() * maskTexCoordScaleX;
maskTexCoordOffsetY = static_cast<float>(contentRect().y()) / contentRect().height() * maskTexCoordScaleY;
}
CCResourceProvider::ResourceId maskResourceId = maskLayer ? maskLayer->contentsResourceId() : 0;
IntRect contentsChangedSinceLastFrame = contentsChanged() ? m_contentRect : IntRect();
quadSink.append(CCRenderPassDrawQuad::create(sharedQuadState, contentRect(), renderPassId, forReplica, maskResourceId, contentsChangedSinceLastFrame,
maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY), appendQuadsData);
}
void CCLayerTreeHostImpl::calculateRenderPasses(CCRenderPassList& passes, CCLayerList& renderSurfaceLayerList)
{
renderSurfaceLayerList.append(rootLayer());
if (!rootLayer()->renderSurface())
rootLayer()->createRenderSurface();
rootLayer()->renderSurface()->clearLayerList();
rootLayer()->renderSurface()->setContentRect(IntRect(IntPoint(), viewportSize()));
rootLayer()->setClipRect(IntRect(IntPoint(), viewportSize()));
{
TransformationMatrix identityMatrix;
TRACE_EVENT("CCLayerTreeHostImpl::calcDrawEtc", this, 0);
CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootLayer(), rootLayer(), identityMatrix, identityMatrix, renderSurfaceLayerList, rootLayer()->renderSurface()->layerList(), &m_layerSorter, layerRendererCapabilities().maxTextureSize);
}
if (layerRendererCapabilities().usingPartialSwap)
trackDamageForAllSurfaces(rootLayer(), renderSurfaceLayerList);
m_rootDamageRect = rootLayer()->renderSurface()->damageTracker()->currentDamageRect();
for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex];
CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface();
OwnPtr<CCRenderPass> pass = CCRenderPass::create(renderSurface);
FloatRect surfaceDamageRect;
if (layerRendererCapabilities().usingPartialSwap)
surfaceDamageRect = damageInSurfaceSpace(renderSurfaceLayer, m_rootDamageRect);
pass->setSurfaceDamageRect(surfaceDamageRect);
const CCLayerList& layerList = renderSurface->layerList();
for (unsigned layerIndex = 0; layerIndex < layerList.size(); ++layerIndex) {
CCLayerImpl* layer = layerList[layerIndex];
if (layer->visibleLayerRect().isEmpty())
continue;
if (CCLayerTreeHostCommon::renderSurfaceContributesToTarget(layer, renderSurfaceLayer->id())) {
pass->appendQuadsForRenderSurfaceLayer(layer);
continue;
}
layer->willDraw(m_layerRenderer.get());
pass->appendQuadsForLayer(layer);
}
passes.append(pass.release());
}
}
void CCDamageTracker::extendDamageForRenderSurface(CCLayerImpl* layer, FloatRect& targetDamageRect)
{
// There are two ways a "descendant surface" can damage regions of the "target surface":
// 1. Property change:
// - a surface's geometry can change because of
// - changes to descendants (i.e. the subtree) that affect the surface's content rect
// - changes to ancestor layers that propagate their property changes to their entire subtree.
// - just like layers, both the old surface rect and new surface rect will
// damage the target surface in this case.
//
// 2. Damage rect: This surface may have been damaged by its own layerList as well, and that damage
// should propagate to the target surface.
//
CCRenderSurface* renderSurface = layer->renderSurface();
bool surfaceIsNew = false;
FloatRect oldSurfaceRect = removeRectFromCurrentFrame(layer->id(), surfaceIsNew);
FloatRect surfaceRectInTargetSpace = renderSurface->drawableContentRect(); // already includes replica if it exists.
saveRectForNextFrame(layer->id(), surfaceRectInTargetSpace);
FloatRect damageRectInLocalSpace;
if (surfaceIsNew || renderSurface->surfacePropertyChanged() || layer->layerSurfacePropertyChanged()) {
// The entire surface contributes damage.
damageRectInLocalSpace = renderSurface->contentRect();
// The surface's old region is now exposed on the target surface, too.
targetDamageRect.uniteIfNonZero(oldSurfaceRect);
} else {
// Only the surface's damageRect will damage the target surface.
damageRectInLocalSpace = renderSurface->damageTracker()->currentDamageRect();
}
// If there was damage, transform it to target space, and possibly contribute its reflection if needed.
if (!damageRectInLocalSpace.isEmpty()) {
const WebTransformationMatrix& drawTransform = renderSurface->drawTransform();
FloatRect damageRectInTargetSpace = CCMathUtil::mapClippedRect(drawTransform, damageRectInLocalSpace);
targetDamageRect.uniteIfNonZero(damageRectInTargetSpace);
if (layer->replicaLayer()) {
const WebTransformationMatrix& replicaDrawTransform = renderSurface->replicaDrawTransform();
targetDamageRect.uniteIfNonZero(CCMathUtil::mapClippedRect(replicaDrawTransform, damageRectInLocalSpace));
}
}
// If there was damage on the replica's mask, then the target surface receives that damage as well.
if (layer->replicaLayer() && layer->replicaLayer()->maskLayer()) {
CCLayerImpl* replicaMaskLayer = layer->replicaLayer()->maskLayer();
bool replicaIsNew = false;
removeRectFromCurrentFrame(replicaMaskLayer->id(), replicaIsNew);
const WebTransformationMatrix& replicaDrawTransform = renderSurface->replicaDrawTransform();
FloatRect replicaMaskLayerRect = CCMathUtil::mapClippedRect(replicaDrawTransform, FloatRect(FloatPoint::zero(), FloatSize(replicaMaskLayer->bounds().width(), replicaMaskLayer->bounds().height())));
saveRectForNextFrame(replicaMaskLayer->id(), replicaMaskLayerRect);
// In the current implementation, a change in the replica mask damages the entire replica region.
if (replicaIsNew || replicaMaskLayer->layerPropertyChanged() || !replicaMaskLayer->updateRect().isEmpty())
targetDamageRect.uniteIfNonZero(replicaMaskLayerRect);
}
// If the layer has a background filter, this may cause pixels in our surface to be expanded, so we will need to expand any damage
// at or below this layer. We expand the damage from this layer too, as we need to readback those pixels from the surface with only
// the contents of layers below this one in them. This means we need to redraw any pixels in the surface being used for the blur in
// this layer this frame.
if (layer->backgroundFilters().hasFilterThatMovesPixels())
expandDamageRectInsideRectWithFilters(targetDamageRect, surfaceRectInTargetSpace, layer->backgroundFilters());
}
void CCDamageTracker::extendDamageForRenderSurface(CCLayerImpl* layer, FloatRect& targetDamageRect)
{
// There are two ways a "descendant surface" can damage regions of the "target surface":
// 1. Property change:
// - a surface's geometry can change because of
// - changes to descendants (i.e. the subtree) that affect the surface's content rect
// - changes to ancestor layers that propagate their property changes to their entire subtree.
// - just like layers, both the old surface rect and new surface rect will
// damage the target surface in this case.
//
// 2. Damage rect: This surface may have been damaged by its own layerList as well, and that damage
// should propagate to the target surface.
//
CCRenderSurface* renderSurface = layer->renderSurface();
bool surfaceIsNew = false;
FloatRect oldSurfaceRect = removeRectFromCurrentFrame(layer->id(), surfaceIsNew);
FloatRect surfaceRectInTargetSpace = renderSurface->drawableContentRect(); // already includes replica if it exists.
saveRectForNextFrame(layer->id(), surfaceRectInTargetSpace);
FloatRect damageRectInLocalSpace;
if (surfaceIsNew || renderSurface->surfacePropertyChanged()) {
// The entire surface contributes damage.
damageRectInLocalSpace = renderSurface->contentRect();
// The surface's old region is now exposed on the target surface, too.
targetDamageRect.uniteIfNonZero(oldSurfaceRect);
} else {
// Only the surface's damageRect will damage the target surface.
damageRectInLocalSpace = renderSurface->damageTracker()->currentDamageRect();
}
// If there was damage, transform it to target space, and possibly contribute its reflection if needed.
if (!damageRectInLocalSpace.isEmpty()) {
const TransformationMatrix& originTransform = renderSurface->originTransform();
FloatRect damageRectInTargetSpace = CCMathUtil::mapClippedRect(originTransform, damageRectInLocalSpace);
targetDamageRect.uniteIfNonZero(damageRectInTargetSpace);
if (layer->replicaLayer()) {
const TransformationMatrix& replicaOriginTransform = renderSurface->replicaOriginTransform();
targetDamageRect.uniteIfNonZero(CCMathUtil::mapClippedRect(replicaOriginTransform, damageRectInLocalSpace));
}
}
// If there was damage on the replica's mask, then the target surface receives that damage as well.
if (layer->replicaLayer() && layer->replicaLayer()->maskLayer()) {
CCLayerImpl* replicaMaskLayer = layer->replicaLayer()->maskLayer();
bool replicaIsNew = false;
removeRectFromCurrentFrame(replicaMaskLayer->id(), replicaIsNew);
// Compute the replica's "originTransform" that maps from the replica's origin space to the target surface origin space.
const TransformationMatrix& replicaOriginTransform = renderSurface->replicaOriginTransform();
FloatRect replicaMaskLayerRect = CCMathUtil::mapClippedRect(replicaOriginTransform, FloatRect(FloatPoint::zero(), FloatSize(replicaMaskLayer->bounds().width(), replicaMaskLayer->bounds().height())));
saveRectForNextFrame(replicaMaskLayer->id(), replicaMaskLayerRect);
// In the current implementation, a change in the replica mask damages the entire replica region.
if (replicaIsNew || replicaMaskLayer->layerPropertyChanged() || !replicaMaskLayer->updateRect().isEmpty())
targetDamageRect.uniteIfNonZero(replicaMaskLayerRect);
}
}
void LayerRendererChromium::drawLayersInternal()
{
if (viewportSize().isEmpty() || !rootLayer())
return;
TRACE_EVENT("LayerRendererChromium::drawLayers", this, 0);
CCLayerImpl* rootDrawLayer = rootLayer();
makeContextCurrent();
if (!rootDrawLayer->renderSurface())
rootDrawLayer->createRenderSurface();
rootDrawLayer->renderSurface()->setContentRect(IntRect(IntPoint(), viewportSize()));
rootDrawLayer->setScissorRect(IntRect(IntPoint(), viewportSize()));
CCLayerList renderSurfaceLayerList;
renderSurfaceLayerList.append(rootDrawLayer);
m_defaultRenderSurface = rootDrawLayer->renderSurface();
m_defaultRenderSurface->clearLayerList();
{
TRACE_EVENT("LayerRendererChromium::drawLayersInternal::calcDrawEtc", this, 0);
CCLayerTreeHostCommon::calculateDrawTransformsAndVisibility(rootDrawLayer, rootDrawLayer, m_zoomAnimatorTransform, m_zoomAnimatorTransform, renderSurfaceLayerList, m_defaultRenderSurface->layerList(), &m_layerSorter, m_capabilities.maxTextureSize);
}
// The GL viewport covers the entire visible area, including the scrollbars.
GLC(m_context.get(), m_context->viewport(0, 0, viewportWidth(), viewportHeight()));
m_windowMatrix = screenMatrix(0, 0, viewportWidth(), viewportHeight());
// Bind the common vertex attributes used for drawing all the layers.
m_sharedGeometry->prepareForDraw();
GLC(m_context.get(), m_context->disable(GraphicsContext3D::SCISSOR_TEST));
GLC(m_context.get(), m_context->disable(GraphicsContext3D::DEPTH_TEST));
GLC(m_context.get(), m_context->disable(GraphicsContext3D::CULL_FACE));
useRenderSurface(m_defaultRenderSurface);
if (m_zoomAnimatorTransform.isIdentity())
// Clear to blue to make it easier to spot unrendered regions.
m_context->clearColor(0, 0, 1, 1);
else
// Clear to grey, as zoom animation may leave unrendered regions.
// FIXME(wjmaclean): Render some interesting texture in unrendered regions.
m_context->clearColor(0.25, 0.25, 0.25, 1);
m_context->colorMask(true, true, true, true);
m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
GLC(m_context.get(), m_context->enable(GraphicsContext3D::BLEND));
GLC(m_context.get(), m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));
GLC(m_context.get(), m_context->enable(GraphicsContext3D::SCISSOR_TEST));
// Update the contents of the render surfaces. We traverse the array from
// back to front to guarantee that nested render surfaces get rendered in the
// correct order.
for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex].get();
CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface();
ASSERT(renderSurface);
renderSurface->setSkipsDraw(true);
// Render surfaces whose drawable area has zero width or height
// will have no layers associated with them and should be skipped.
if (!renderSurface->layerList().size())
continue;
// Skip completely transparent render surfaces.
if (!renderSurface->drawOpacity())
continue;
if (useRenderSurface(renderSurface)) {
renderSurface->setSkipsDraw(false);
if (renderSurfaceLayer != rootDrawLayer) {
GLC(m_context.get(), m_context->disable(GraphicsContext3D::SCISSOR_TEST));
GLC(m_context.get(), m_context->clearColor(0, 0, 0, 0));
GLC(m_context.get(), m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT));
GLC(m_context.get(), m_context->enable(GraphicsContext3D::SCISSOR_TEST));
}
const CCLayerList& layerList = renderSurface->layerList();
for (unsigned layerIndex = 0; layerIndex < layerList.size(); ++layerIndex)
drawLayer(layerList[layerIndex].get(), renderSurface);
}
}
if (m_headsUpDisplay->enabled()) {
GLC(m_context.get(), m_context->enable(GraphicsContext3D::BLEND));
GLC(m_context.get(), m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));
GLC(m_context.get(), m_context->disable(GraphicsContext3D::SCISSOR_TEST));
useRenderSurface(m_defaultRenderSurface);
m_headsUpDisplay->draw();
}
GLC(m_context.get(), m_context->disable(GraphicsContext3D::SCISSOR_TEST));
GLC(m_context.get(), m_context->disable(GraphicsContext3D::BLEND));
}
// Recursively walks the layer tree starting at the given node and computes all the
// necessary transformations, scissor rectangles, render surfaces, etc.
void LayerRendererChromium::updatePropertiesAndRenderSurfaces(CCLayerImpl* layer, const TransformationMatrix& parentMatrix, LayerList& renderSurfaceLayerList, LayerList& layerList)
{
// Compute the new matrix transformation that will be applied to this layer and
// all its children. It's important to remember that the layer's position
// is the position of the layer's anchor point. Also, the coordinate system used
// assumes that the origin is at the lower left even though the coordinates the browser
// gives us for the layers are for the upper left corner. The Y flip happens via
// the orthographic projection applied at render time.
// The transformation chain for the layer is (using the Matrix x Vector order):
// M = M[p] * Tr[l] * M[l] * Tr[c]
// Where M[p] is the parent matrix passed down to the function
// Tr[l] is the translation matrix locating the layer's anchor point
// Tr[c] is the translation offset between the anchor point and the center of the layer
// M[l] is the layer's matrix (applied at the anchor point)
// This transform creates a coordinate system whose origin is the center of the layer.
// Note that the final matrix used by the shader for the layer is P * M * S . This final product
// is computed in drawTexturedQuad().
// Where: P is the projection matrix
// M is the layer's matrix computed above
// S is the scale adjustment (to scale up to the layer size)
IntSize bounds = layer->bounds();
FloatPoint anchorPoint = layer->anchorPoint();
FloatPoint position = layer->position();
// Offset between anchor point and the center of the quad.
float centerOffsetX = (0.5 - anchorPoint.x()) * bounds.width();
float centerOffsetY = (0.5 - anchorPoint.y()) * bounds.height();
TransformationMatrix layerLocalTransform;
// LT = Tr[l]
layerLocalTransform.translate3d(position.x(), position.y(), layer->anchorPointZ());
// LT = Tr[l] * M[l]
layerLocalTransform.multiply(layer->transform());
// LT = Tr[l] * M[l] * Tr[c]
layerLocalTransform.translate3d(centerOffsetX, centerOffsetY, -layer->anchorPointZ());
TransformationMatrix combinedTransform = parentMatrix;
combinedTransform = combinedTransform.multiply(layerLocalTransform);
FloatRect layerRect(-0.5 * layer->bounds().width(), -0.5 * layer->bounds().height(), layer->bounds().width(), layer->bounds().height());
IntRect transformedLayerRect;
// The layer and its descendants render on a new RenderSurface if any of
// these conditions hold:
// 1. The layer clips its descendants and its transform is not a simple translation.
// 2. If the layer has opacity != 1 and does not have a preserves-3d transform style.
// 3. The layer uses a mask
// 4. The layer has a replica (used for reflections)
// 5. The layer doesn't preserve-3d but is the child of a layer which does.
// If a layer preserves-3d then we don't create a RenderSurface for it to avoid flattening
// out its children. The opacity value of the children layers is multiplied by the opacity
// of their parent.
bool useSurfaceForClipping = layer->masksToBounds() && !isScaleOrTranslation(combinedTransform);
bool useSurfaceForOpacity = layer->opacity() != 1 && !layer->preserves3D();
bool useSurfaceForMasking = layer->maskLayer();
bool useSurfaceForReflection = layer->replicaLayer();
bool useSurfaceForFlatDescendants = layer->parent() && layer->parent()->preserves3D() && !layer->preserves3D() && layer->descendantsDrawsContent();
if (useSurfaceForMasking || useSurfaceForReflection || useSurfaceForFlatDescendants || ((useSurfaceForClipping || useSurfaceForOpacity) && layer->descendantsDrawsContent())) {
RenderSurfaceChromium* renderSurface = layer->renderSurface();
if (!renderSurface)
renderSurface = layer->createRenderSurface();
// The origin of the new surface is the upper left corner of the layer.
TransformationMatrix drawTransform;
drawTransform.translate3d(0.5 * bounds.width(), 0.5 * bounds.height(), 0);
layer->setDrawTransform(drawTransform);
transformedLayerRect = IntRect(0, 0, bounds.width(), bounds.height());
// Layer's opacity will be applied when drawing the render surface.
renderSurface->m_drawOpacity = layer->opacity();
if (layer->parent() && layer->parent()->preserves3D())
renderSurface->m_drawOpacity *= layer->parent()->drawOpacity();
layer->setDrawOpacity(1);
TransformationMatrix layerOriginTransform = combinedTransform;
layerOriginTransform.translate3d(-0.5 * bounds.width(), -0.5 * bounds.height(), 0);
renderSurface->m_originTransform = layerOriginTransform;
layer->setScissorRect(IntRect());
// The render surface scissor rect is the scissor rect that needs to
// be applied before drawing the render surface onto its containing
// surface and is therefore expressed in the parent's coordinate system.
renderSurface->m_scissorRect = layer->parent() ? layer->parent()->scissorRect() : layer->scissorRect();
renderSurface->m_layerList.clear();
if (layer->maskLayer()) {
renderSurface->m_maskLayer = layer->maskLayer();
layer->maskLayer()->setTargetRenderSurface(renderSurface);
} else
renderSurface->m_maskLayer = 0;
if (layer->replicaLayer() && layer->replicaLayer()->maskLayer())
layer->replicaLayer()->maskLayer()->setTargetRenderSurface(renderSurface);
renderSurfaceLayerList.append(layer);
} else {
// DT = M[p] * LT
layer->setDrawTransform(combinedTransform);
transformedLayerRect = enclosingIntRect(layer->drawTransform().mapRect(layerRect));
layer->setDrawOpacity(layer->opacity());
if (layer->parent()) {
if (layer->parent()->preserves3D())
layer->setDrawOpacity(layer->drawOpacity() * layer->parent()->drawOpacity());
// Layers inherit the scissor rect from their parent.
layer->setScissorRect(layer->parent()->scissorRect());
layer->setTargetRenderSurface(layer->parent()->targetRenderSurface());
}
if (layer != m_rootCCLayerImpl.get())
layer->clearRenderSurface();
if (layer->masksToBounds()) {
IntRect scissor = transformedLayerRect;
if (!layer->scissorRect().isEmpty())
scissor.intersect(layer->scissorRect());
layer->setScissorRect(scissor);
}
}
if (layer->renderSurface())
layer->setTargetRenderSurface(layer->renderSurface());
else {
ASSERT(layer->parent());
layer->setTargetRenderSurface(layer->parent()->targetRenderSurface());
}
// drawableContentRect() is always stored in the coordinate system of the
// RenderSurface the layer draws into.
if (layer->drawsContent())
layer->setDrawableContentRect(transformedLayerRect);
else
layer->setDrawableContentRect(IntRect());
TransformationMatrix sublayerMatrix = layer->drawTransform();
// Flatten to 2D if the layer doesn't preserve 3D.
if (!layer->preserves3D()) {
sublayerMatrix.setM13(0);
sublayerMatrix.setM23(0);
sublayerMatrix.setM31(0);
sublayerMatrix.setM32(0);
sublayerMatrix.setM33(1);
sublayerMatrix.setM34(0);
sublayerMatrix.setM43(0);
}
// Apply the sublayer transform at the center of the layer.
sublayerMatrix.multiply(layer->sublayerTransform());
// The origin of the children is the top left corner of the layer, not the
// center. The matrix passed down to the children is therefore:
// M[s] = M * Tr[-center]
sublayerMatrix.translate3d(-bounds.width() * 0.5, -bounds.height() * 0.5, 0);
LayerList& descendants = (layer->renderSurface() ? layer->renderSurface()->m_layerList : layerList);
descendants.append(layer);
unsigned thisLayerIndex = descendants.size() - 1;
for (size_t i = 0; i < layer->children().size(); ++i) {
CCLayerImpl* child = layer->children()[i].get();
updatePropertiesAndRenderSurfaces(child, sublayerMatrix, renderSurfaceLayerList, descendants);
if (child->renderSurface()) {
RenderSurfaceChromium* childRenderSurface = child->renderSurface();
IntRect drawableContentRect = layer->drawableContentRect();
drawableContentRect.unite(enclosingIntRect(childRenderSurface->drawableContentRect()));
layer->setDrawableContentRect(drawableContentRect);
descendants.append(child);
} else {
IntRect drawableContentRect = layer->drawableContentRect();
drawableContentRect.unite(child->drawableContentRect());
layer->setDrawableContentRect(drawableContentRect);
}
}
if (layer->masksToBounds() || useSurfaceForMasking) {
IntRect drawableContentRect = layer->drawableContentRect();
drawableContentRect.intersect(transformedLayerRect);
layer->setDrawableContentRect(drawableContentRect);
}
if (layer->renderSurface() && layer != m_rootCCLayerImpl.get()) {
RenderSurfaceChromium* renderSurface = layer->renderSurface();
renderSurface->m_contentRect = layer->drawableContentRect();
FloatPoint surfaceCenter = renderSurface->contentRectCenter();
// Restrict the RenderSurface size to the portion that's visible.
FloatSize centerOffsetDueToClipping;
// Don't clip if the layer is reflected as the reflection shouldn't be
// clipped.
if (!layer->replicaLayer()) {
if (!layer->scissorRect().isEmpty())
renderSurface->m_contentRect.intersect(layer->scissorRect());
FloatPoint clippedSurfaceCenter = renderSurface->contentRectCenter();
centerOffsetDueToClipping = clippedSurfaceCenter - surfaceCenter;
}
// The RenderSurface backing texture cannot exceed the maximum supported
// texture size.
renderSurface->m_contentRect.setWidth(std::min(renderSurface->m_contentRect.width(), m_maxTextureSize));
renderSurface->m_contentRect.setHeight(std::min(renderSurface->m_contentRect.height(), m_maxTextureSize));
if (renderSurface->m_contentRect.isEmpty())
renderSurface->m_layerList.clear();
// Since the layer starts a new render surface we need to adjust its
// scissor rect to be expressed in the new surface's coordinate system.
layer->setScissorRect(layer->drawableContentRect());
// Adjust the origin of the transform to be the center of the render surface.
renderSurface->m_drawTransform = renderSurface->m_originTransform;
renderSurface->m_drawTransform.translate3d(surfaceCenter.x() + centerOffsetDueToClipping.width(), surfaceCenter.y() + centerOffsetDueToClipping.height(), 0);
// Compute the transformation matrix used to draw the replica of the render
// surface.
if (layer->replicaLayer()) {
renderSurface->m_replicaDrawTransform = renderSurface->m_originTransform;
renderSurface->m_replicaDrawTransform.translate3d(layer->replicaLayer()->position().x(), layer->replicaLayer()->position().y(), 0);
renderSurface->m_replicaDrawTransform.multiply(layer->replicaLayer()->transform());
renderSurface->m_replicaDrawTransform.translate3d(surfaceCenter.x() - anchorPoint.x() * bounds.width(), surfaceCenter.y() - anchorPoint.y() * bounds.height(), 0);
}
}
// If preserves-3d then sort all the descendants in 3D so that they can be
// drawn from back to front. If the preserves-3d property is also set on the parent then
// skip the sorting as the parent will sort all the descendants anyway.
if (layer->preserves3D() && (!layer->parent() || !layer->parent()->preserves3D()))
m_layerSorter.sort(&descendants.at(thisLayerIndex), descendants.end());
}
void LayerRendererChromium::drawLayers(const LayerList& renderSurfaceLayerList)
{
TRACE_EVENT("LayerRendererChromium::drawLayers", this, 0);
CCLayerImpl* rootDrawLayer = m_rootLayer->ccLayerImpl();
makeContextCurrent();
// The GL viewport covers the entire visible area, including the scrollbars.
GLC(m_context.get(), m_context->viewport(0, 0, m_viewportVisibleRect.width(), m_viewportVisibleRect.height()));
// Bind the common vertex attributes used for drawing all the layers.
m_sharedGeometry->prepareForDraw();
// FIXME: These calls can be made once, when the compositor context is initialized.
GLC(m_context.get(), m_context->disable(GraphicsContext3D::DEPTH_TEST));
GLC(m_context.get(), m_context->disable(GraphicsContext3D::CULL_FACE));
// Blending disabled by default. Root layer alpha channel on Windows is incorrect when Skia uses ClearType.
GLC(m_context.get(), m_context->disable(GraphicsContext3D::BLEND));
useRenderSurface(m_defaultRenderSurface);
// Clear to blue to make it easier to spot unrendered regions.
m_context->clearColor(0, 0, 1, 1);
m_context->colorMask(true, true, true, true);
m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT);
// Mask out writes to alpha channel: subpixel antialiasing via Skia results in invalid
// zero alpha values on text glyphs. The root layer is always opaque.
m_context->colorMask(true, true, true, false);
drawRootLayer();
// Re-enable color writes to layers, which may be partially transparent.
m_context->colorMask(true, true, true, true);
GLC(m_context.get(), m_context->enable(GraphicsContext3D::BLEND));
GLC(m_context.get(), m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));
GLC(m_context.get(), m_context->enable(GraphicsContext3D::SCISSOR_TEST));
// Update the contents of the render surfaces. We traverse the array from
// back to front to guarantee that nested render surfaces get rendered in the
// correct order.
for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex].get();
ASSERT(renderSurfaceLayer->renderSurface());
// Render surfaces whose drawable area has zero width or height
// will have no layers associated with them and should be skipped.
if (!renderSurfaceLayer->renderSurface()->m_layerList.size())
continue;
if (useRenderSurface(renderSurfaceLayer->renderSurface())) {
if (renderSurfaceLayer != rootDrawLayer) {
GLC(m_context.get(), m_context->disable(GraphicsContext3D::SCISSOR_TEST));
GLC(m_context.get(), m_context->clearColor(0, 0, 0, 0));
GLC(m_context.get(), m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT));
GLC(m_context.get(), m_context->enable(GraphicsContext3D::SCISSOR_TEST));
}
LayerList& layerList = renderSurfaceLayer->renderSurface()->m_layerList;
ASSERT(layerList.size());
for (unsigned layerIndex = 0; layerIndex < layerList.size(); ++layerIndex)
drawLayer(layerList[layerIndex].get(), renderSurfaceLayer->renderSurface());
}
}
if (m_headsUpDisplay->enabled()) {
GLC(m_context.get(), m_context->enable(GraphicsContext3D::BLEND));
GLC(m_context.get(), m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA));
GLC(m_context.get(), m_context->disable(GraphicsContext3D::SCISSOR_TEST));
useRenderSurface(m_defaultRenderSurface);
m_headsUpDisplay->draw();
}
GLC(m_context.get(), m_context->disable(GraphicsContext3D::SCISSOR_TEST));
GLC(m_context.get(), m_context->disable(GraphicsContext3D::BLEND));
}
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);
}
}
}
