KisHairyPaintOp Class Reference

#include <kis_hairy_paintop.h>

Inheritance diagram for KisHairyPaintOp:

Public Member Functions
	KisHairyPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
void	paintLine (const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance) override
Public Member Functions inherited from KisPaintOp
virtual bool	canPaint () const
virtual std::pair< int, bool >	doAsynchronousUpdate (QVector< KisRunnableStrokeJobData * > &jobs)
	KisPaintOp (KisPainter *painter)
void	paintAt (const KisPaintInformation &info, KisDistanceInformation *currentDistance)
virtual void	paintBezierCurve (const KisPaintInformation &pi1, const QPointF &control1, const QPointF &control2, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)
	Private (KisPaintOp *_q)
void	updateSpacing (const KisPaintInformation &info, KisDistanceInformation &currentDistance) const
void	updateTiming (const KisPaintInformation &info, KisDistanceInformation &currentDistance) const
virtual	~KisPaintOp ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Static Public Member Functions
static QList< KoResourceLoadResult >	prepareLinkedResources (const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface)
Static Public Member Functions inherited from KisPaintOp
static void	splitCoordinate (qreal coordinate, qint32 *whole, qreal *fraction)

Protected Member Functions
KisSpacingInformation	paintAt (const KisPaintInformation &info) override
KisSpacingInformation	updateSpacingImpl (const KisPaintInformation &info) const override
Protected Member Functions inherited from KisPaintOp
KisFixedPaintDeviceSP	cachedDab ()
KisFixedPaintDeviceSP	cachedDab (const KoColorSpace *cs)
KisPainter *	painter () const
KisPaintDeviceSP	source () const
virtual KisTimingInformation	updateTimingImpl (const KisPaintInformation &info) const
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Private Member Functions
void	loadSettings ()

Private Attributes
HairyBrush	m_brush
KisPaintDeviceSP	m_dab
KisPaintDeviceSP	m_dev
KisHairyBristleOptionData	m_hairyBristleOption
KisHairyInkOptionData	m_hairyInkOption
KisOpacityOption	m_opacityOption
KisHairyProperties	m_properties
KisRotationOption	m_rotationOption
KisSizeOption	m_sizeOption

Additional Inherited Members
Public Attributes inherited from KisPaintOp
KisFixedPaintDeviceSP	dab
bool	fanCornersEnabled {false}
qreal	fanCornersStep {1.0}
KisPainter *	painter {nullptr}
KisPaintOp *	q {nullptr}
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Detailed Description

Definition at line 28 of file kis_hairy_paintop.h.

Constructor & Destructor Documentation

KisHairyPaintOp()

KisHairyPaintOp::KisHairyPaintOp	(	const KisPaintOpSettingsSP	settings,
		KisPainter *	painter,
		KisNodeSP	node,
		KisImageSP	image )

Definition at line 32 of file kis_hairy_paintop.cpp.

    : KisPaintOp(painter)
    , m_opacityOption(settings.data(), node)
    , m_sizeOption(settings.data())
    , m_rotationOption(settings.data())
{
    Q_UNUSED(image);
    Q_ASSERT(settings);
 
    m_hairyBristleOption.read(settings.data());
    m_hairyInkOption.read(settings.data());
 
    m_dev = node ? node->paintDevice() : 0;
 
    KisBrushOptionProperties brushOption;
    brushOption.readOptionSetting(settings, settings->resourcesInterface(), settings->canvasResourcesInterface());
    KisBrushSP brush = brushOption.brush();
    KisFixedPaintDeviceSP dab = cachedDab(painter->device()->compositionSourceColorSpace());
 
    // properly initialize fake paint information to avoid warnings
    KisPaintInformation fakePaintInformation;
    fakePaintInformation.setRandomSource(new KisRandomSource());
    fakePaintInformation.setPerStrokeRandomSource(new KisPerStrokeRandomSource());
 
    if (brush->brushApplication() == IMAGESTAMP) {
        dab = brush->paintDevice(source()->colorSpace(), KisDabShape(), fakePaintInformation);
    } else {
        brush->mask(dab, painter->paintColor(), KisDabShape(), fakePaintInformation);
    }
 
    m_brush.fromDabWithDensity(dab, m_hairyBristleOption.densityFactor * 0.01);
    m_brush.setInkColor(painter->paintColor());
 
    loadSettings();
    m_brush.setProperties(&m_properties);
}

References KisBrushOptionProperties::brush(), KisPaintOp::cachedDab(), KisPaintDevice::compositionSourceColorSpace(), KisPaintOp::dab, KisSharedPtr< T >::data(), KisHairyBristleOptionData::densityFactor, KisPainter::device, HairyBrush::fromDabWithDensity(), IMAGESTAMP, loadSettings(), m_brush, m_dev, m_hairyBristleOption, m_hairyInkOption, m_properties, KisPainter::paintColor, KisBaseNode::paintDevice(), KisPaintOp::painter, KisHairyBristleOptionData::read(), KisHairyInkOptionData::read(), KisPaintopPropertiesCanvasResourcesBase::readOptionSetting(), HairyBrush::setInkColor(), KisPaintInformation::setPerStrokeRandomSource(), HairyBrush::setProperties(), KisPaintInformation::setRandomSource(), and KisPaintOp::source().

Member Function Documentation

loadSettings()

void KisHairyPaintOp::loadSettings ( )

private

Definition at line 75 of file kis_hairy_paintop.cpp.

{
    m_properties.inkAmount = m_hairyInkOption.inkAmount;
    //TODO: wait for the transfer function with variable size
 
    m_properties.inkDepletionCurve = KisCubicCurve(m_hairyInkOption.inkDepletionCurve).floatTransfer(m_hairyInkOption.inkAmount);
 
    m_properties.inkDepletionEnabled = m_hairyInkOption.inkDepletionEnabled;
    m_properties.useSaturation = m_hairyInkOption.useSaturation;
    m_properties.useOpacity = m_hairyInkOption.useOpacity;
    m_properties.useWeights = m_hairyInkOption.useWeights;
 
    m_properties.pressureWeight = m_hairyInkOption.pressureWeight / 100.0;
    m_properties.bristleLengthWeight = m_hairyInkOption.bristleLengthWeight / 100.0;
    m_properties.bristleInkAmountWeight = m_hairyInkOption.bristleInkAmountWeight / 100.0;
    m_properties.inkDepletionWeight = m_hairyInkOption.inkDepletionWeight;
    m_properties.useSoakInk = m_hairyInkOption.useSoakInk;
 
    m_properties.useMousePressure = m_hairyBristleOption.useMousePressure;
    m_properties.shearFactor = m_hairyBristleOption.shearFactor;
    m_properties.randomFactor = m_hairyBristleOption.randomFactor;
    m_properties.scaleFactor = m_hairyBristleOption.scaleFactor;
    m_properties.threshold = m_hairyBristleOption.threshold;
    m_properties.antialias = m_hairyBristleOption.antialias;
    m_properties.useCompositing = m_hairyBristleOption.useCompositing;
    m_properties.connectedPath = m_hairyBristleOption.connectedPath;
}

References KisHairyProperties::antialias, KisHairyBristleOptionData::antialias, KisHairyProperties::bristleInkAmountWeight, KisHairyInkOptionData::bristleInkAmountWeight, KisHairyProperties::bristleLengthWeight, KisHairyInkOptionData::bristleLengthWeight, KisHairyProperties::connectedPath, KisHairyBristleOptionData::connectedPath, KisCubicCurve::floatTransfer(), KisHairyProperties::inkAmount, KisHairyInkOptionData::inkAmount, KisHairyProperties::inkDepletionCurve, KisHairyInkOptionData::inkDepletionCurve, KisHairyProperties::inkDepletionEnabled, KisHairyInkOptionData::inkDepletionEnabled, KisHairyProperties::inkDepletionWeight, KisHairyInkOptionData::inkDepletionWeight, m_hairyBristleOption, m_hairyInkOption, m_properties, KisHairyProperties::pressureWeight, KisHairyInkOptionData::pressureWeight, KisHairyProperties::randomFactor, KisHairyBristleOptionData::randomFactor, KisHairyProperties::scaleFactor, KisHairyBristleOptionData::scaleFactor, KisHairyProperties::shearFactor, KisHairyBristleOptionData::shearFactor, KisHairyProperties::threshold, KisHairyBristleOptionData::threshold, KisHairyProperties::useCompositing, KisHairyBristleOptionData::useCompositing, KisHairyProperties::useMousePressure, KisHairyBristleOptionData::useMousePressure, KisHairyProperties::useOpacity, KisHairyInkOptionData::useOpacity, KisHairyProperties::useSaturation, KisHairyInkOptionData::useSaturation, KisHairyProperties::useSoakInk, KisHairyInkOptionData::useSoakInk, KisHairyProperties::useWeights, and KisHairyInkOptionData::useWeights.

paintAt()

KisSpacingInformation KisHairyPaintOp::paintAt ( const KisPaintInformation & info )

overrideprotectedvirtual

The implementation of painting of a dab and updating spacing. This does NOT need to update the timing information.

Implements KisPaintOp.

Definition at line 104 of file kis_hairy_paintop.cpp.

{
    return updateSpacingImpl(info);
}

References updateSpacingImpl().

paintLine()

void KisHairyPaintOp::paintLine ( const KisPaintInformation & pi1, const KisPaintInformation & pi2, KisDistanceInformation * currentDistance )

overridevirtual

Draw a line between pos1 and pos2 using the currently set brush and color. If savedDist is less than zero, the brush is painted at pos1 before being painted along the line using the spacing setting.

Returns

the drag distance, that is the remains of the distance between p1 and p2 not covered because the currently set brush has a spacing greater than that distance.

Even though we don't use spacing in hairy brush, we should still initialize its distance information to ensure drawing angle and other history-based sensors work fine.

Reimplemented from KisPaintOp.

Definition at line 116 of file kis_hairy_paintop.cpp.

{
    Q_UNUSED(currentDistance);
    if (!painter()) return;
 
    if (!m_dab) {
        m_dab = source()->createCompositionSourceDevice();
    }
    else {
        m_dab->clear();
    }
 
    KisPaintInformation pi(pi2);
    KisPaintInformation::DistanceInformationRegistrar r =
        pi.registerDistanceInformation(currentDistance);
 
    // Hairy Brush is capable of working with zero scale,
    // so no additional checks for 'zero'ness are needed
    qreal scale = m_sizeOption.apply(pi);
    scale *= KisLodTransform::lodToScale(painter()->device());
    qreal rotation = m_rotationOption.apply(pi);
    m_opacityOption.apply(painter(), pi);
 
    const bool mirrorFlip = pi1.canvasMirroredH() != pi1.canvasMirroredV();
 
    // we don't use spacing here (the brush itself is used only once
    // during initialization), so we should just skip the distance info
    // update
 
    m_brush.paintLine(m_dab, m_dev, pi1, pi, scale * m_hairyBristleOption.scaleFactor, mirrorFlip ? -rotation : rotation);
 
    //QRect rc = m_dab->exactBounds();
    QRect rc = m_dab->extent();
    painter()->bitBlt(rc.topLeft(), m_dab, rc);
    painter()->renderMirrorMask(rc, m_dab);
 
    // we don't use spacing in hairy brush, but history is
    // still important for us
    currentDistance->registerPaintedDab(pi,
                                        KisSpacingInformation(),
                                        KisTimingInformation());
}

References KisRotationOption::apply(), KisStandardOption< Data >::apply(), KisOpacityOption::apply(), KisPainter::bitBlt(), KisPaintInformation::canvasMirroredH(), KisPaintInformation::canvasMirroredV(), KisPaintDevice::clear(), KisPaintDevice::createCompositionSourceDevice(), KisPaintDevice::extent(), KisLodTransformBase::lodToScale(), m_brush, m_dab, m_dev, m_hairyBristleOption, m_opacityOption, m_rotationOption, m_sizeOption, KisPaintOp::painter, HairyBrush::paintLine(), KisPaintInformation::registerDistanceInformation(), KisDistanceInformation::registerPaintedDab(), KisPainter::renderMirrorMask(), KisHairyBristleOptionData::scaleFactor, and KisPaintOp::source().

prepareLinkedResources()

QList< KoResourceLoadResult > KisHairyPaintOp::prepareLinkedResources ( const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface )

static

Definition at line 69 of file kis_hairy_paintop.cpp.

{
    KisBrushOptionProperties brushOption;
    return brushOption.prepareLinkedResources(settings, resourcesInterface);
}

References KisPaintopPropertiesCanvasResourcesBase::prepareLinkedResources().

updateSpacingImpl()

KisSpacingInformation KisHairyPaintOp::updateSpacingImpl ( const KisPaintInformation & info ) const

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 109 of file kis_hairy_paintop.cpp.

{
    Q_UNUSED(info);
    return KisSpacingInformation(0.5);
}

Member Data Documentation

m_brush

HairyBrush KisHairyPaintOp::m_brush

private

Definition at line 49 of file kis_hairy_paintop.h.

m_dab

KisPaintDeviceSP KisHairyPaintOp::m_dab

private

Definition at line 47 of file kis_hairy_paintop.h.

m_dev

KisPaintDeviceSP KisHairyPaintOp::m_dev

private

Definition at line 48 of file kis_hairy_paintop.h.

m_hairyBristleOption

KisHairyBristleOptionData KisHairyPaintOp::m_hairyBristleOption

private

Definition at line 44 of file kis_hairy_paintop.h.

m_hairyInkOption

KisHairyInkOptionData KisHairyPaintOp::m_hairyInkOption

private

Definition at line 45 of file kis_hairy_paintop.h.

m_opacityOption

KisOpacityOption KisHairyPaintOp::m_opacityOption

private

Definition at line 50 of file kis_hairy_paintop.h.

m_properties

KisHairyProperties KisHairyPaintOp::m_properties

private

Definition at line 43 of file kis_hairy_paintop.h.

m_rotationOption

KisRotationOption KisHairyPaintOp::m_rotationOption

private

Definition at line 52 of file kis_hairy_paintop.h.

m_sizeOption

KisSizeOption KisHairyPaintOp::m_sizeOption

private

Definition at line 51 of file kis_hairy_paintop.h.

---

The documentation for this class was generated from the following files:

• plugins/paintops/hairy/kis_hairy_paintop.h
• plugins/paintops/hairy/kis_hairy_paintop.cpp