IntRect TextureMapperLayer::intermediateSurfaceRect(const TransformationMatrix& matrix) { IntRect rect; TransformationMatrix localTransform = TransformationMatrix(matrix).multiply(m_transform.combined()); rect = enclosingIntRect(localTransform.mapRect(layerRect())); if (!m_state.masksToBounds && !m_state.maskLayer) { for (size_t i = 0; i < m_children.size(); ++i) rect.unite(m_children[i]->intermediateSurfaceRect(matrix)); } #if ENABLE(CSS_FILTERS) if (m_filters.hasOutsets()) { int leftOutset; int topOutset; int bottomOutset; int rightOutset; m_filters.getOutsets(topOutset, rightOutset, bottomOutset, leftOutset); IntRect unfilteredTargetRect(rect); rect.move(std::max(0, -leftOutset), std::max(0, -topOutset)); rect.expand(leftOutset + rightOutset, topOutset + bottomOutset); rect.unite(unfilteredTargetRect); } #endif if (m_state.replicaLayer) rect.unite(m_state.replicaLayer->intermediateSurfaceRect(matrix)); return rect; }
void TextureMapperLayer::computeOverlapRegions(Region& overlapRegion, Region& nonOverlapRegion, ResolveSelfOverlapMode mode) { if (!m_state.visible || !m_state.contentsVisible) return; FloatRect boundingRect; if (m_backingStore || m_state.masksToBounds || m_state.maskLayer || hasFilters()) boundingRect = layerRect(); else if (m_contentsLayer || m_state.solidColor.alpha()) boundingRect = m_state.contentsRect; if (m_currentFilters.hasOutsets()) { FilterOutsets outsets = m_currentFilters.outsets(); IntRect unfilteredTargetRect(boundingRect); boundingRect.move(std::max(0, -outsets.left()), std::max(0, -outsets.top())); boundingRect.expand(outsets.left() + outsets.right(), outsets.top() + outsets.bottom()); boundingRect.unite(unfilteredTargetRect); } TransformationMatrix replicaMatrix; if (m_state.replicaLayer) { replicaMatrix = replicaTransform(); boundingRect.unite(replicaMatrix.mapRect(boundingRect)); } boundingRect = m_currentTransform.combined().mapRect(boundingRect); // Count all masks and filters as overlap layers. if (hasFilters() || m_state.maskLayer || (m_state.replicaLayer && m_state.replicaLayer->m_state.maskLayer)) { Region newOverlapRegion(enclosingIntRect(boundingRect)); nonOverlapRegion.subtract(newOverlapRegion); overlapRegion.unite(newOverlapRegion); return; } Region newOverlapRegion; Region newNonOverlapRegion(enclosingIntRect(boundingRect)); if (!m_state.masksToBounds) { for (auto* child : m_children) child->computeOverlapRegions(newOverlapRegion, newNonOverlapRegion, ResolveSelfOverlapIfNeeded); } if (m_state.replicaLayer) { newOverlapRegion.unite(replicaMatrix.mapRect(newOverlapRegion.bounds())); Region replicaRegion(replicaMatrix.mapRect(newNonOverlapRegion.bounds())); resolveOverlaps(replicaRegion, newOverlapRegion, newNonOverlapRegion); } if ((mode != ResolveSelfOverlapAlways) && shouldBlend()) { newNonOverlapRegion.unite(newOverlapRegion); newOverlapRegion = Region(); } overlapRegion.unite(newOverlapRegion); resolveOverlaps(newNonOverlapRegion, overlapRegion, nonOverlapRegion); }
static PassRefPtr<BitmapTexture> applyFilters(const FilterOperations& filters, TextureMapper* textureMapper, BitmapTexture* source, IntRect& targetRect) { if (!filters.size()) return source; RefPtr<BitmapTexture> filterSurface(source); int leftOutset, topOutset, bottomOutset, rightOutset; if (filters.hasOutsets()) { filters.getOutsets(topOutset, rightOutset, bottomOutset, leftOutset); IntRect unfilteredTargetRect(targetRect); targetRect.move(std::max(0, -leftOutset), std::max(0, -topOutset)); targetRect.expand(leftOutset + rightOutset, topOutset + bottomOutset); targetRect.unite(unfilteredTargetRect); filterSurface = textureMapper->acquireTextureFromPool(targetRect.size()); } return filterSurface->applyFilters(*source, filters); }