void CoordinatedGraphicsLayer::syncLayerState()
{
if (!m_shouldSyncLayerState)
return;
m_shouldSyncLayerState = false;
m_layerState.childrenTransform = childrenTransform();
m_layerState.contentsRect = contentsRect();
m_layerState.mask = toCoordinatedLayerID(maskLayer());
m_layerState.opacity = opacity();
m_layerState.replica = toCoordinatedLayerID(replicaLayer());
m_layerState.transform = transform();
m_layerState.anchorPoint = m_adjustedAnchorPoint;
m_layerState.pos = m_adjustedPosition;
m_layerState.size = m_adjustedSize;
if (m_layerState.flagsChanged) {
m_layerState.drawsContent = drawsContent();
m_layerState.contentsVisible = contentsAreVisible();
m_layerState.backfaceVisible = backfaceVisibility();
m_layerState.masksToBounds = masksToBounds();
m_layerState.preserves3D = preserves3D();
m_layerState.fixedToViewport = fixedToViewport();
m_layerState.showDebugBorders = isShowingDebugBorder();
m_layerState.showRepaintCounter = isShowingRepaintCounter();
m_layerState.isScrollable = isScrollable();
}
if (m_layerState.showDebugBorders)
updateDebugIndicators();
}
/* \reimp (GraphicsLayer.h)
*/
void GraphicsLayerTextureMapper::setPreserves3D(bool value)
{
if (value == preserves3D())
return;
GraphicsLayer::setPreserves3D(value);
notifyChange(TextureMapperLayer::Preserves3DChange);
}
float GraphicsLayer::accumulatedOpacity() const
{
if (!preserves3D())
return 1;
return m_opacity * (parent() ? parent()->accumulatedOpacity() : 1);
}
void WebGraphicsLayer::setPreserves3D(bool b)
{
if (preserves3D() == b)
return;
GraphicsLayer::setPreserves3D(b);
notifyChange();
}
void WebGraphicsLayer::setPreserves3D(bool b)
{
if (preserves3D() == b)
return;
GraphicsLayer::setPreserves3D(b);
didChangeGeometry();
}
void CoordinatedGraphicsLayer::setPreserves3D(bool b)
{
if (preserves3D() == b)
return;
GraphicsLayer::setPreserves3D(b);
m_layerState.preserves3D = b;
m_layerState.flagsChanged = true;
didChangeGeometry();
}
void LayerAndroid::updateGLPositionsAndScale(const TransformationMatrix& parentMatrix,
const FloatRect& clipping, float opacity,
float scale, bool forceCalculation,
bool disableFixedElemUpdate)
{
m_scale = scale;
opacity *= getOpacity();
setDrawOpacity(opacity);
// constantly recalculate the draw transform of layers that may require it (and their children)
forceCalculation |= hasDynamicTransform();
forceCalculation &= !(disableFixedElemUpdate && isPositionFixed());
if (forceCalculation)
updateLocalTransformAndClip(parentMatrix, clipping);
if (!countChildren() || !m_visible)
return;
TransformationMatrix localMatrix = m_drawTransformUnfudged;
// Flatten to 2D if the layer doesn't preserve 3D.
if (!preserves3D()) {
localMatrix.setM13(0);
localMatrix.setM23(0);
localMatrix.setM31(0);
localMatrix.setM32(0);
localMatrix.setM33(1);
localMatrix.setM34(0);
localMatrix.setM43(0);
}
// now apply it to our children
TransformationMatrix childMatrix;
childMatrix = localMatrix;
childMatrix.translate3d(getScrollOffset().x(), getScrollOffset().y(), 0);
if (!m_childrenTransform.isIdentity()) {
childMatrix.translate(getSize().width() * 0.5f, getSize().height() * 0.5f);
childMatrix.multiply(m_childrenTransform);
childMatrix.translate(-getSize().width() * 0.5f, -getSize().height() * 0.5f);
}
for (int i = 0; i < countChildren(); i++)
this->getChild(i)->updateGLPositionsAndScale(childMatrix, drawClip(),
opacity, scale, forceCalculation,
disableFixedElemUpdate);
}
void GraphicsLayer::distributeOpacity(float accumulatedOpacity)
{
// If this is a transform layer we need to distribute our opacity to all our children
// Incoming accumulatedOpacity is the contribution from our parent(s). We mutiply this by our own
// opacity to get the total contribution
accumulatedOpacity *= m_opacity;
setOpacityInternal(accumulatedOpacity);
if (preserves3D()) {
size_t numChildren = children().size();
for (size_t i = 0; i < numChildren; ++i)
children()[i]->distributeOpacity(accumulatedOpacity);
}
}
void WebGraphicsLayer::computeTransformedVisibleRect()
{
if (!m_shouldUpdateVisibleRect)
return;
m_shouldUpdateVisibleRect = false;
m_layerTransform.setLocalTransform(transform());
m_layerTransform.setPosition(position());
m_layerTransform.setAnchorPoint(anchorPoint());
m_layerTransform.setSize(size());
m_layerTransform.setFlattening(!preserves3D());
m_layerTransform.setChildrenTransform(childrenTransform());
m_layerTransform.combineTransforms(parent() ? toWebGraphicsLayer(parent())->m_layerTransform.combinedForChildren() : TransformationMatrix());
// The combined transform will be used in tiledBackingStoreVisibleRect.
adjustVisibleRect();
adjustContentsScale();
}
void WebGraphicsLayer::syncCompositingStateForThisLayerOnly()
{
if (!m_layerTreeTileClient)
m_layerTreeTileClient = layerTreeTileClient();
updateContentBuffers();
if (!m_modified)
return;
m_layerInfo.name = name();
m_layerInfo.anchorPoint = anchorPoint();
m_layerInfo.backfaceVisible = backfaceVisibility();
m_layerInfo.childrenTransform = childrenTransform();
m_layerInfo.contentsOpaque = contentsOpaque();
m_layerInfo.contentsRect = contentsRect();
m_layerInfo.drawsContent = drawsContent();
m_layerInfo.mask = toWebLayerID(maskLayer());
m_layerInfo.masksToBounds = masksToBounds();
m_layerInfo.opacity = opacity();
m_layerInfo.parent = toWebLayerID(parent());
m_layerInfo.pos = position();
m_layerInfo.preserves3D = preserves3D();
m_layerInfo.replica = toWebLayerID(replicaLayer());
m_layerInfo.size = size();
m_layerInfo.transform = transform();
m_contentNeedsDisplay = false;
m_layerInfo.children.clear();
for (size_t i = 0; i < children().size(); ++i)
m_layerInfo.children.append(toWebLayerID(children()[i]));
ASSERT(m_layerTreeTileClient);
if (m_layerInfo.imageIsUpdated && m_image && !m_layerInfo.imageBackingStoreID)
m_layerInfo.imageBackingStoreID = m_layerTreeTileClient->adoptImageBackingStore(m_image.get());
m_layerTreeTileClient->didSyncCompositingStateForLayer(m_layerInfo);
m_modified = false;
m_layerInfo.imageIsUpdated = false;
if (m_hasPendingAnimations)
notifyAnimationStarted(WTF::currentTime());
m_layerInfo.animations.clear();
m_hasPendingAnimations = false;
}
void WebGraphicsLayer::syncLayerState()
{
if (!m_shouldSyncLayerState)
return;
m_shouldSyncLayerState = false;
m_layerInfo.anchorPoint = anchorPoint();
m_layerInfo.backfaceVisible = backfaceVisibility();
m_layerInfo.childrenTransform = childrenTransform();
m_layerInfo.contentsOpaque = contentsOpaque();
m_layerInfo.contentsRect = contentsRect();
m_layerInfo.drawsContent = drawsContent();
m_layerInfo.mask = toWebLayerID(maskLayer());
m_layerInfo.masksToBounds = masksToBounds();
m_layerInfo.opacity = opacity();
m_layerInfo.parent = toWebLayerID(parent());
m_layerInfo.pos = position();
m_layerInfo.preserves3D = preserves3D();
m_layerInfo.replica = toWebLayerID(replicaLayer());
m_layerInfo.size = size();
m_layerInfo.transform = transform();
m_webGraphicsLayerClient->syncLayerState(m_id, m_layerInfo);
}
void CoordinatedGraphicsLayer::computeTransformedVisibleRect()
{
if (!m_shouldUpdateVisibleRect && !m_movingVisibleRect)
return;
m_shouldUpdateVisibleRect = false;
TransformationMatrix currentTransform = transform();
if (m_movingVisibleRect)
client().getCurrentTransform(this, currentTransform);
m_layerTransform.setLocalTransform(currentTransform);
m_layerTransform.setAnchorPoint(m_adjustedAnchorPoint);
m_layerTransform.setPosition(m_adjustedPosition);
m_layerTransform.setSize(m_adjustedSize);
m_layerTransform.setFlattening(!preserves3D());
m_layerTransform.setChildrenTransform(childrenTransform());
m_layerTransform.combineTransforms(parent() ? toCoordinatedGraphicsLayer(parent())->m_layerTransform.combinedForChildren() : TransformationMatrix());
m_cachedInverseTransform = m_layerTransform.combined().inverse();
// The combined transform will be used in tiledBackingStoreVisibleRect.
setNeedsVisibleRectAdjustment();
}
void GraphicsLayerTextureMapper::commitLayerChanges()
{
if (m_changeMask == NoChanges)
return;
if (m_changeMask & ChildrenChange) {
Vector<TextureMapperLayer*> textureMapperLayerChildren;
toTextureMapperLayerVector(children(), textureMapperLayerChildren);
m_layer->setChildren(textureMapperLayerChildren);
}
if (m_changeMask & MaskLayerChange)
m_layer->setMaskLayer(toTextureMapperLayer(maskLayer()));
if (m_changeMask & ReplicaLayerChange)
m_layer->setReplicaLayer(toTextureMapperLayer(replicaLayer()));
if (m_changeMask & PositionChange)
m_layer->setPosition(position());
if (m_changeMask & AnchorPointChange)
m_layer->setAnchorPoint(anchorPoint());
if (m_changeMask & SizeChange)
m_layer->setSize(size());
if (m_changeMask & TransformChange)
m_layer->setTransform(transform());
if (m_changeMask & ChildrenTransformChange)
m_layer->setChildrenTransform(childrenTransform());
if (m_changeMask & Preserves3DChange)
m_layer->setPreserves3D(preserves3D());
if (m_changeMask & ContentsRectChange)
m_layer->setContentsRect(contentsRect());
if (m_changeMask & MasksToBoundsChange)
m_layer->setMasksToBounds(masksToBounds());
if (m_changeMask & DrawsContentChange)
m_layer->setDrawsContent(drawsContent());
if (m_changeMask & ContentsVisibleChange)
m_layer->setContentsVisible(contentsAreVisible());
if (m_changeMask & ContentsOpaqueChange)
m_layer->setContentsOpaque(contentsOpaque());
if (m_changeMask & BackfaceVisibilityChange)
m_layer->setBackfaceVisibility(backfaceVisibility());
if (m_changeMask & OpacityChange)
m_layer->setOpacity(opacity());
if (m_changeMask & BackgroundColorChange)
m_layer->setSolidColor(solidColor());
#if ENABLE(CSS_FILTERS)
if (m_changeMask & FilterChange)
m_layer->setFilters(filters());
#endif
if (m_changeMask & BackingStoreChange)
m_layer->setBackingStore(m_backingStore);
if (m_changeMask & DebugVisualsChange)
m_layer->setDebugVisuals(isShowingDebugBorder(), debugBorderColor(), debugBorderWidth(), isShowingRepaintCounter());
if (m_changeMask & RepaintCountChange)
m_layer->setRepaintCount(repaintCount());
if (m_changeMask & ContentChange)
m_layer->setContentsLayer(platformLayer());
if (m_changeMask & AnimationChange)
m_layer->setAnimations(m_animations);
if (m_changeMask & AnimationStarted)
client()->notifyAnimationStarted(this, m_animationStartTime);
if (m_changeMask & FixedToViewporChange)
m_layer->setFixedToViewport(fixedToViewport());
if (m_changeMask & IsScrollableChange)
m_layer->setIsScrollable(isScrollable());
if (m_changeMask & CommittedScrollOffsetChange)
m_layer->didCommitScrollOffset(m_committedScrollOffset);
m_changeMask = NoChanges;
}
