FilterEffectRenderer.h [plain text]
#ifndef FilterEffectRenderer_h
#define FilterEffectRenderer_h
#if ENABLE(CSS_FILTERS)
#include "Filter.h"
#include "FilterEffect.h"
#include "FilterOperations.h"
#include "FloatRect.h"
#include "GraphicsContext.h"
#include "ImageBuffer.h"
#include "IntRectExtent.h"
#include "LayoutRect.h"
#include "SVGFilterBuilder.h"
#include "SourceGraphic.h"
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
namespace WebCore {
class Document;
class GraphicsContext;
class RenderElement;
class RenderLayer;
typedef Vector<RefPtr<FilterEffect>> FilterEffectList;
enum FilterConsumer {
FilterProperty,
FilterFunction
};
class FilterEffectRendererHelper {
public:
FilterEffectRendererHelper(bool haveFilterEffect)
: m_renderLayer(0)
, m_haveFilterEffect(haveFilterEffect)
, m_startedFilterEffect(false)
{
}
bool haveFilterEffect() const { return m_haveFilterEffect; }
bool hasStartedFilterEffect() const { return m_startedFilterEffect; }
bool prepareFilterEffect(RenderLayer*, const LayoutRect& filterBoxRect, const LayoutRect& dirtyRect, const LayoutRect& layerRepaintRect);
bool beginFilterEffect();
void applyFilterEffect(GraphicsContext* destinationContext);
GraphicsContext* filterContext() const;
const LayoutRect& repaintRect() const { return m_repaintRect; }
private:
RenderLayer* m_renderLayer; LayoutPoint m_paintOffset;
LayoutRect m_repaintRect;
bool m_haveFilterEffect;
bool m_startedFilterEffect;
};
class FilterEffectRenderer final : public Filter {
WTF_MAKE_FAST_ALLOCATED;
public:
static RefPtr<FilterEffectRenderer> create()
{
return adoptRef(new FilterEffectRenderer);
}
void setSourceImageRect(const FloatRect& sourceImageRect)
{
m_sourceDrawingRegion = sourceImageRect;
setMaxEffectRects(sourceImageRect);
setFilterRegion(sourceImageRect);
m_graphicsBufferAttached = false;
}
virtual FloatRect sourceImageRect() const override { return m_sourceDrawingRegion; }
void setFilterRegion(const FloatRect& filterRegion) { m_filterRegion = filterRegion; }
virtual FloatRect filterRegion() const override { return m_filterRegion; }
GraphicsContext* inputContext();
ImageBuffer* output() const { return lastEffect()->asImageBuffer(); }
bool build(RenderElement*, const FilterOperations&, FilterConsumer);
PassRefPtr<FilterEffect> buildReferenceFilter(RenderElement*, PassRefPtr<FilterEffect> previousEffect, ReferenceFilterOperation*);
bool updateBackingStoreRect(const FloatRect& filterRect);
void allocateBackingStoreIfNeeded();
void clearIntermediateResults();
void apply();
IntRect outputRect() const { return lastEffect()->hasResult() ? lastEffect()->requestedRegionOfInputImageData(IntRect(m_filterRegion)) : IntRect(); }
bool hasFilterThatMovesPixels() const { return m_hasFilterThatMovesPixels; }
LayoutRect computeSourceImageRectForDirtyRect(const LayoutRect& filterBoxRect, const LayoutRect& dirtyRect);
private:
void setMaxEffectRects(const FloatRect& effectRect)
{
for (size_t i = 0; i < m_effects.size(); ++i) {
RefPtr<FilterEffect> effect = m_effects.at(i);
effect->setMaxEffectRect(effectRect);
}
}
FilterEffect* lastEffect() const
{
if (!m_effects.isEmpty())
return m_effects.last().get();
return nullptr;
}
FilterEffectRenderer();
virtual ~FilterEffectRenderer();
FloatRect m_sourceDrawingRegion;
FloatRect m_filterRegion;
FilterEffectList m_effects;
RefPtr<SourceGraphic> m_sourceGraphic;
IntRectExtent m_outsets;
bool m_graphicsBufferAttached;
bool m_hasFilterThatMovesPixels;
};
}
#endif // ENABLE(CSS_FILTERS)
#endif // FilterEffectRenderer_h