#include <KisColorSmudgeStrategyWithOverlay.h>

Inheritance diagram for KisColorSmudgeStrategyWithOverlay:

Public Member Functions
QVector< KisPainter * >	finalPainters ()

void	initializePainting () override

	KisColorSmudgeStrategyWithOverlay (KisPainter *painter, KisImageSP image, bool smearAlpha, bool useDullingMode, bool useOverlayMode)

QVector< QRect >	paintDab (const QRect &srcRect, const QRect &dstRect, const KoColor &currentPaintColor, qreal opacity, qreal colorRateValue, qreal smudgeRateValue, qreal maxPossibleSmudgeRateValue, qreal lightnessStrengthValue, qreal smudgeRadiusValue) override

virtual	~KisColorSmudgeStrategyWithOverlay ()

Public Member Functions inherited from KisColorSmudgeStrategyBase
void	blendBrush (const QVector< KisPainter * > dstPainters, KisColorSmudgeSourceSP srcSampleDevice, KisFixedPaintDeviceSP maskDab, bool preserveMaskDab, const QRect &srcRect, const QRect &dstRect, const KoColor &currentPaintColor, qreal opacity, qreal smudgeRateValue, qreal maxPossibleSmudgeRateValue, qreal colorRateValue, qreal smudgeRadiusValue)

void	blendInBackgroundWithDulling (KisFixedPaintDeviceSP dst, KisColorSmudgeSourceSP src, const QRect &dstRect, const KoColor &preparedDullingColor, const qreal smudgeRateOpacity)

void	blendInBackgroundWithSmearing (KisFixedPaintDeviceSP dst, KisColorSmudgeSourceSP src, const QRect &srcRect, const QRect &dstRect, const qreal smudgeRateOpacity)

virtual DabColoringStrategy &	coloringStrategy ()=0

virtual qreal	colorRateOpacity (qreal opacity, qreal smudgeRateValue, qreal colorRateValue, qreal maxPossibleSmudgeRateValue)

virtual qreal	dullingRateOpacity (qreal opacity, qreal smudgeRateValue)

virtual QString	finalCompositeOp (bool smearAlpha) const

virtual qreal	finalPainterOpacity (qreal opacity, qreal smudgeRateValue)

void	initializePaintingImpl (const KoColorSpace *dstColorSpace, bool smearAlpha, const QString &colorRateCompositeOpId)

	KisColorSmudgeStrategyBase (bool useDullingMode)

const KoColorSpace *	preciseColorSpace () const override

virtual void	sampleDullingColor (const QRect &srcRect, qreal sampleRadiusValue, KisColorSmudgeSourceSP sourceDevice, KisFixedPaintDeviceSP tempFixedDevice, KisFixedPaintDeviceSP maskDab, KoColor *resultColor)

virtual QString	smearCompositeOp (bool smearAlpha) const

virtual qreal	smearRateOpacity (qreal opacity, qreal smudgeRateValue)

Public Member Functions inherited from KisColorSmudgeStrategy
	KisColorSmudgeStrategy ()

virtual void	updateMask (KisDabCache dabCache, const KisPaintInformation &info, const KisDabShape &shape, const QPointF &cursorPoint, QRect dstDabRect, qreal lightnessStrength)=0

virtual	~KisColorSmudgeStrategy ()=default

Protected Attributes
QScopedPointer< KisOverlayPaintDeviceWrapper >	m_layerOverlayDevice

KisFixedPaintDeviceSP	m_maskDab

bool	m_shouldPreserveMaskDab = true

Protected Attributes inherited from KisColorSmudgeStrategyBase
const KoCompositeOp *	m_colorRateOp {nullptr}

KoColor	m_preparedDullingColor

const KoCompositeOp *	m_smearOp {nullptr}

Protected Attributes inherited from KisColorSmudgeStrategy
KisOptimizedByteArray::MemoryAllocatorSP	m_memoryAllocator

Private Attributes
KisPainter	m_finalPainter

QScopedPointer< KisOverlayPaintDeviceWrapper >	m_imageOverlayDevice

KisPainter *	m_initializationPainter = 0

QScopedPointer< KisPainter >	m_overlayPainter

bool	m_smearAlpha = true

KisColorSmudgeSourceSP	m_sourceWrapperDevice

Detailed Description

Definition at line 14 of file KisColorSmudgeStrategyWithOverlay.h.

Constructor & Destructor Documentation

◆ KisColorSmudgeStrategyWithOverlay()

KisColorSmudgeStrategyWithOverlay::KisColorSmudgeStrategyWithOverlay	(	KisPainter *	painter,
		KisImageSP	image,
		bool	smearAlpha,
		bool	useDullingMode,
		bool	useOverlayMode )

Definition at line 18 of file KisColorSmudgeStrategyWithOverlay.cpp.

        : KisColorSmudgeStrategyBase(useDullingMode)
        , m_maskDab(new KisFixedPaintDevice(KoColorSpaceRegistry::instance()->alpha8()))
        , m_smearAlpha(smearAlpha)
        , m_initializationPainter(painter)
{
    if (useOverlayMode && image) {
        m_imageOverlayDevice.reset(new KisOverlayPaintDeviceWrapper(image->projection(), 1, KisOverlayPaintDeviceWrapper::PreciseMode));
        m_layerOverlayDevice.reset(new KisOverlayPaintDeviceWrapper(painter->device(), 1, KisOverlayPaintDeviceWrapper::LazyPreciseMode, m_imageOverlayDevice->overlayColorSpace()));
        m_sourceWrapperDevice.reset(new KisColorSmudgeSourceImage(image, *m_imageOverlayDevice));
    } else {
        m_layerOverlayDevice.reset(new KisOverlayPaintDeviceWrapper(painter->device(), 1, KisOverlayPaintDeviceWrapper::LazyPreciseMode));
        m_sourceWrapperDevice.reset(new KisColorSmudgeSourcePaintDevice(*m_layerOverlayDevice));
    }
}

References KisPainter::device, KisOverlayPaintDeviceWrapper::LazyPreciseMode, m_imageOverlayDevice, m_layerOverlayDevice, m_sourceWrapperDevice, KisOverlayPaintDeviceWrapper::PreciseMode, and KisImage::projection().

◆ ~KisColorSmudgeStrategyWithOverlay()

KisColorSmudgeStrategyWithOverlay::~KisColorSmudgeStrategyWithOverlay ( )

virtual

Definition at line 36 of file KisColorSmudgeStrategyWithOverlay.cpp.

                                                                      {
 
}

Member Function Documentation

◆ finalPainters()

QVector< KisPainter * > KisColorSmudgeStrategyWithOverlay::finalPainters ( )

Definition at line 62 of file KisColorSmudgeStrategyWithOverlay.cpp.

{
    QVector<KisPainter*> result;
    result << &m_finalPainter;
    if (m_overlayPainter) {
        result << m_overlayPainter.data();
    }
    return result;
}

References m_finalPainter, and m_overlayPainter.

◆ initializePainting()

void KisColorSmudgeStrategyWithOverlay::initializePainting ( )

overridevirtual

Implements KisColorSmudgeStrategy.

Definition at line 40 of file KisColorSmudgeStrategyWithOverlay.cpp.

{
    initializePaintingImpl(m_layerOverlayDevice->overlayColorSpace(),
                           m_smearAlpha,
                           m_initializationPainter->compositeOpId());
 
    m_finalPainter.begin(m_layerOverlayDevice->overlay());
    m_finalPainter.setCompositeOpId(finalCompositeOp(m_smearAlpha));
    m_finalPainter.setSelection(m_initializationPainter->selection());
    m_finalPainter.setChannelFlags(m_initializationPainter->channelFlags());
    m_finalPainter.copyMirrorInformationFrom(m_initializationPainter);
 
    if (m_imageOverlayDevice) {
        m_overlayPainter.reset(new KisPainter());
        m_overlayPainter->begin(m_imageOverlayDevice->overlay());
        m_overlayPainter->setCompositeOpId(finalCompositeOp(m_smearAlpha));
        m_overlayPainter->setSelection(m_initializationPainter->selection());
        m_overlayPainter->setChannelFlags(m_initializationPainter->channelFlags());
        m_overlayPainter->copyMirrorInformationFrom(m_initializationPainter);
    }
}

References KisPainter::begin(), KisPainter::channelFlags(), KisPainter::compositeOpId, KisPainter::copyMirrorInformationFrom(), KisColorSmudgeStrategyBase::finalCompositeOp(), KisColorSmudgeStrategyBase::initializePaintingImpl(), m_finalPainter, m_imageOverlayDevice, m_initializationPainter, m_layerOverlayDevice, m_overlayPainter, m_smearAlpha, KisPainter::selection, KisPainter::setChannelFlags(), KisPainter::setCompositeOpId(), and KisPainter::setSelection().

◆ paintDab()

QVector< QRect > KisColorSmudgeStrategyWithOverlay::paintDab	(	const QRect &	srcRect,
		const QRect &	dstRect,
		const KoColor &	currentPaintColor,
		qreal	opacity,
		qreal	colorRateValue,
		qreal	smudgeRateValue,
		qreal	maxPossibleSmudgeRateValue,
		qreal	lightnessStrengthValue,
		qreal	smudgeRadiusValue )

overridevirtual

If we have m_imageOverlayDevice set, then m_sourceWrapperOverlay points to it, not to the layer's overlay. Therefore, we should read from it as well.

Implements KisColorSmudgeStrategy.

Definition at line 72 of file KisColorSmudgeStrategyWithOverlay.cpp.

{
    Q_UNUSED(lightnessStrengthValue);
 
    const QVector<QRect> mirroredRects = m_finalPainter.calculateAllMirroredRects(dstRect);
 
    QVector<QRect> readRects;
    readRects << mirroredRects;
    readRects << srcRect;
 
    m_sourceWrapperDevice->readRects(readRects);
 
    if (m_imageOverlayDevice) {
        m_layerOverlayDevice->readRects(readRects);
    }
 
    blendBrush(finalPainters(),
               m_sourceWrapperDevice,
               m_maskDab, m_shouldPreserveMaskDab,
               srcRect, dstRect,
               currentPaintColor,
               opacity,
               smudgeRateValue,
               maxPossibleSmudgeRateValue,
               colorRateValue, smudgeRadiusValue);
 
    m_layerOverlayDevice->writeRects(mirroredRects);
 
    return mirroredRects;
}