void TextureMapperLayer::paintSelfAndChildrenWithReplica(const TextureMapperPaintOptions& options)
{
if (m_state.replicaLayer) {
TextureMapperPaintOptions replicaOptions(options);
replicaOptions.transform
.multiply(m_state.replicaLayer->m_currentTransform.combined())
.multiply(m_currentTransform.combined().inverse().valueOr(TransformationMatrix()));
paintSelfAndChildren(replicaOptions);
}
paintSelfAndChildren(options);
}
void TextureMapperLayer::paintSelfAndChildrenWithReplica(const TextureMapperPaintOptions& options)
{
if (m_state.replicaLayer) {
TextureMapperPaintOptions replicaOptions(options);
// We choose either the content's mask or the replica's mask.
// FIXME: blend the two if both exist.
if (m_state.replicaLayer->m_state.maskLayer)
replicaOptions.mask = m_state.replicaLayer->m_state.maskLayer->texture();
replicaOptions.transform
.multiply(m_state.replicaLayer->m_transform.combined())
.multiply(m_transform.combined().inverse());
paintSelfAndChildren(replicaOptions);
}
paintSelfAndChildren(options);
}
PassRefPtr<BitmapTexture> TextureMapperLayer::paintIntoSurface(const TextureMapperPaintOptions& options, const IntSize& size)
{
RefPtr<BitmapTexture> surface = options.textureMapper->acquireTextureFromPool(size);
TextureMapperPaintOptions paintOptions(options);
paintOptions.surface = surface;
options.textureMapper->bindSurface(surface.get());
paintSelfAndChildren(paintOptions);
if (m_state.maskLayer)
m_state.maskLayer->applyMask(options);
surface = surface->applyFilters(options.textureMapper, m_currentFilters);
options.textureMapper->bindSurface(surface.get());
return surface.release();
}
PassRefPtr<BitmapTexture> TextureMapperLayer::paintIntoSurface(const TextureMapperPaintOptions& options, const IntSize& size)
{
RefPtr<BitmapTexture> surface = options.textureMapper->acquireTextureFromPool(size);
TextureMapperPaintOptions paintOptions(options);
paintOptions.surface = surface;
options.textureMapper->bindSurface(surface.get());
paintSelfAndChildren(paintOptions);
if (m_state.maskLayer)
m_state.maskLayer->applyMask(options);
#if ENABLE(CSS_FILTERS)
if (!m_currentFilters.isEmpty())
surface = applyFilters(m_currentFilters, options.textureMapper, surface.get());
#endif
options.textureMapper->bindSurface(surface.get());
return surface;
}
void TextureMapperNode::paintRecursive(TexmapPaintOptions options)
{
bool isDirty = m_state.dirty;
m_state.dirty = false;
if ((m_size.isEmpty() && (m_state.masksToBounds
|| m_children.isEmpty())) || !m_state.visible || options.opacity < 0.01 || m_state.opacity < 0.01)
return;
computeReplicaTransform();
if (m_state.maskLayer)
m_state.maskLayer->m_state.dirty = false;
if (m_state.replicaLayer) {
m_state.replicaLayer->m_state.dirty = false;
if (m_state.replicaLayer->m_state.maskLayer)
m_state.replicaLayer->m_state.maskLayer->m_state.dirty = false;
}
const bool isSurface = (m_layerType == ClipLayer
|| m_layerType == TransparencyLayer
|| (m_layerType == RootLayer
&& (options.textureMapper->allowSurfaceForRoot() || m_state.hasSurfaceDescendants)
));
const IntRect boundingRectfromNearestSurface = m_transforms.targetBoundingRect;
options.opacity *= m_state.opacity;
TexmapPaintOptions optionsForDescendants(options);
optionsForDescendants.opacity = isSurface ? 1 : options.opacity;
options.isSurface = isSurface;
if (m_layerType == ClipLayer) {
optionsForDescendants.visibleRect = TransformationMatrix().translate(-boundingRectfromNearestSurface.x(), -boundingRectfromNearestSurface.y()).mapRect(options.visibleRect);
optionsForDescendants.scissorRect = IntRect(0, 0, m_size.width(), m_size.height());
}
if (m_layerType == ScissorLayer)
optionsForDescendants.scissorRect.intersect(m_transforms.targetBoundingRect);
options.textureMapper->setClip(optionsForDescendants.scissorRect);
TextureMapperCacheLock(m_texture.get());
TextureMapperCacheLock(m_surface.get());
TextureMapperCacheLock(m_replicaSurface.get());
options.cache->purge();
if (isSurface) {
ASSERT(m_surface);
if (!m_surface->isValid())
isDirty = true;
if (m_state.tiled) {
m_surface->reset(options.visibleRect.size());
m_surface->setOffset(options.visibleRect.location());
} else if (isDirty)
m_surface->reset(m_layerType == TransparencyLayer ? options.surface->size() : m_size);
options.cache->mark(m_surface.get());
options.textureMapper->bindSurface(m_surface.get());
optionsForDescendants.surface = m_surface.get();
} else if (m_surface)
m_surface->destroy();
if (isDirty || !isSurface || m_state.tiled || !m_surface->isValid())
paintSelfAndChildren(options, optionsForDescendants);
paintSurface(options);
}
