KisTangentNormalPaintOp Class Reference

#include <kis_tangent_normal_paintop.h>

Inheritance diagram for KisTangentNormalPaintOp:

Public Member Functions
	KisTangentNormalPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
void	paintLine (const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance) override
	~KisTangentNormalPaintOp () override
Public Member Functions inherited from KisBrushBasedPaintOp
bool	canPaint () const override
	Reimplemented, false if brush is 0.
bool	checkSizeTooSmall (qreal scale)
KisSpacingInformation	effectiveSpacing (qreal scale) const
KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisAirbrushOptionData *airbrushOption, const KisSpacingOption *spacingOption, const KisPaintInformation &pi) const
KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisPaintInformation &pi) const
KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisSpacingOption &spacingOption, const KisPaintInformation &pi) const
	KisBrushBasedPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisBrushTextureFlags textureFlags=None)
	~KisBrushBasedPaintOp () override
Public Member Functions inherited from KisPaintOp
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 ()

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

Private Member Functions
KisSpacingInformation	computeSpacing (const KisPaintInformation &info, qreal scale, qreal rotation) const

Private Attributes
KisAirbrushOptionData	m_airbrushData
QRect	m_dstDabRect
KisFlowOption	m_flowOption
KisPaintDeviceSP	m_lineCacheDevice
KisFixedPaintDeviceSP	m_maskDab
KisFlowOpacityOption2	m_opacityOption
KisRateOption	m_rateOption
KisRotationOption	m_rotationOption
KisScatterOption	m_scatterOption
KisSharpnessOption	m_sharpnessOption
KisSizeOption	m_sizeOption
KisSoftnessOption	m_softnessOption
KisSpacingOption	m_spacingOption
KisTangentTiltOption	m_tangentTiltOption
KisPaintDeviceSP	m_tempDev

Additional Inherited Members
Static Public Member Functions inherited from KisBrushBasedPaintOp
static QList< KoResourceLoadResult >	prepareEmbeddedResources (const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface)
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)
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
Protected Attributes inherited from KisBrushBasedPaintOp
KisBrushSP	m_brush
KisDabCache *	m_dabCache
KisMirrorOption	m_mirrorOption
KisPrecisionOption	m_precisionOption

Detailed Description

Definition at line 29 of file kis_tangent_normal_paintop.h.

Constructor & Destructor Documentation

KisTangentNormalPaintOp()

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

Definition at line 25 of file kis_tangent_normal_paintop.cpp.

    : KisBrushBasedPaintOp(settings, painter)
    , m_tangentTiltOption(settings.data())
    , m_opacityOption(settings.data(), node)
    , m_flowOption(settings.data())
    , m_sizeOption(settings.data())
    , m_spacingOption(settings.data())
    , m_softnessOption(settings.data())
    , m_sharpnessOption(settings.data())
    , m_scatterOption(settings.data())
    , m_rotationOption(settings.data())
    , m_rateOption(settings.data())
    , m_tempDev(painter->device()->createCompositionSourceDevice())
 
{
    Q_UNUSED(image);
    //Init, read settings, etc//
    m_airbrushData.read(settings.data());
 
    m_dabCache->setSharpnessPostprocessing(&m_sharpnessOption);
    m_rotationOption.applyFanCornersInfo(this);
}

References KisRotationOption::applyFanCornersInfo(), KisSharedPtr< T >::data(), m_airbrushData, KisBrushBasedPaintOp::m_dabCache, m_rotationOption, m_sharpnessOption, KisAirbrushOptionData::read(), and KisDabCache::setSharpnessPostprocessing().

~KisTangentNormalPaintOp()

KisTangentNormalPaintOp::~KisTangentNormalPaintOp ( )

override

Definition at line 48 of file kis_tangent_normal_paintop.cpp.

{
    //destroy things here//
}

Member Function Documentation

computeSpacing()

KisSpacingInformation KisTangentNormalPaintOp::computeSpacing ( const KisPaintInformation & info, qreal scale, qreal rotation ) const

private

Definition at line 162 of file kis_tangent_normal_paintop.cpp.

{
    return effectiveSpacing(scale, rotation, &m_airbrushData, &m_spacingOption, info);
}

References KisBrushBasedPaintOp::effectiveSpacing(), m_airbrushData, and m_spacingOption.

paintAt()

KisSpacingInformation KisTangentNormalPaintOp::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 53 of file kis_tangent_normal_paintop.cpp.

{
    /*
     * For the color, the precision of tilt is only 60x60, and the precision of direction and rotation are 360 and 360*90.
     * You can't get more precise than 8bit. Therefore, we will check if the current space is RGB,
     * if so we request a profile with that space and 8bit bit depth, if not, just sRGB
     */
    KoColor currentColor = painter()->paintColor();
    QString currentSpace = currentColor.colorSpace()->colorModelId().id();
    const KoColorSpace* rgbColorSpace = KoColorSpaceRegistry::instance()->rgb8();
    if (currentSpace != "RGBA") {
        rgbColorSpace = KoColorSpaceRegistry::instance()->rgb8();
    } else {
        rgbColorSpace = currentColor.colorSpace();
    }
    QVector <float> channelValues(4);
    qreal r, g, b;
 
    if (currentColor.colorSpace()->colorDepthId().id()=="F16" || currentColor.colorSpace()->colorDepthId().id()=="F32"){
        channelValues[0] = 0.5;//red
        channelValues[1] = 0.5;//green
        channelValues[2] = 1.0;//blue
        channelValues[3] = 1.0;//alpha, leave alone.
 
 
        m_tangentTiltOption.apply(info, &r, &g, &b);
 
        channelValues[0] = r;//red
        channelValues[1] = g;//green
        channelValues[2] = b;//blue
    } else {
        channelValues[0] = 1.0;//blue
        channelValues[1] = 0.5;//green
        channelValues[2] = 0.5;//red
        channelValues[3] = 1.0;//alpha, leave alone.
 
        m_tangentTiltOption.apply(info, &r, &g, &b);
 
        channelValues[0] = b;//blue
        channelValues[1] = g;//green
        channelValues[2] = r;//red
    }
 
    quint8 data[MAX_PIXEL_SIZE];
    rgbColorSpace->fromNormalisedChannelsValue(data, channelValues);
    KoColor color(data, rgbColorSpace);//Should be default RGB(0.5,0.5,1.0)
    //draw stuff here, return kisspacinginformation.
    KisBrushSP brush = m_brush;
 
    if (!painter()->device() || !brush || !brush->canPaintFor(info)) {
        return KisSpacingInformation(1.0);
    }
 
    qreal scale    = m_sizeOption.apply(info);
    scale *= KisLodTransform::lodToScale(painter()->device());
    qreal rotation = m_rotationOption.apply(info);
    if (checkSizeTooSmall(scale)) return KisSpacingInformation();
    KisDabShape shape(scale, 1.0, rotation);
 
 
    QPointF cursorPos =
            m_scatterOption.apply(info,
                                  brush->maskWidth(shape, 0, 0, info),
                                  brush->maskHeight(shape, 0, 0, info));
 
    m_maskDab =
            m_dabCache->fetchDab(rgbColorSpace, color, cursorPos,
                                 shape,
                                 info, m_softnessOption.apply(info),
                                 &m_dstDabRect);
 
    if (m_dstDabRect.isEmpty()) return KisSpacingInformation(1.0);
 
    QRect dabRect = m_maskDab->bounds();
 
    // sanity check
    Q_ASSERT(m_dstDabRect.size() == dabRect.size());
    Q_UNUSED(dabRect);
 
    qreal  oldOpacityF = painter()->opacityF();
    QString oldCompositeOpId = painter()->compositeOpId();
 
 
    m_opacityOption.apply(painter(), info);
    //paint with the default color? Copied this from color smudge.//
    //painter()->setCompositeOp(COMPOSITE_COPY);
    //painter()->fill(0, 0, m_dstDabRect.width(), m_dstDabRect.height(), color);
    painter()->bltFixed(m_dstDabRect.topLeft(), m_maskDab, m_maskDab->bounds());
    painter()->renderMirrorMaskSafe(m_dstDabRect, m_maskDab, !m_dabCache->needSeparateOriginal());
 
    // restore original opacity and composite mode values
    painter()->setOpacityF(oldOpacityF);
    painter()->setCompositeOpId(oldCompositeOpId);
 
    return computeSpacing(info, scale, rotation);
}

References KisRotationOption::apply(), KisStandardOption< Data >::apply(), KisTangentTiltOption::apply(), KisScatterOption::apply(), KisFlowOpacityOption2::apply(), KisPainter::bltFixed(), KisFixedPaintDevice::bounds(), KisBrushBasedPaintOp::checkSizeTooSmall(), KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KoColor::colorSpace(), KisPainter::compositeOpId, computeSpacing(), KisDabCache::fetchDab(), KoColorSpace::fromNormalisedChannelsValue(), KoID::id(), KoColorSpaceRegistry::instance(), KisLodTransformBase::lodToScale(), KisBrushBasedPaintOp::m_brush, KisBrushBasedPaintOp::m_dabCache, m_dstDabRect, m_maskDab, m_opacityOption, m_rotationOption, m_scatterOption, m_sizeOption, m_softnessOption, m_tangentTiltOption, MAX_PIXEL_SIZE, KisDabCache::needSeparateOriginal(), KisPainter::opacityF(), KisPainter::paintColor, KisPaintOp::painter, KisPainter::renderMirrorMaskSafe(), KoColorSpaceRegistry::rgb8(), KisPainter::setCompositeOpId(), and KisPainter::setOpacityF().

paintLine()

void KisTangentNormalPaintOp::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.

Reimplemented from KisPaintOp.

Definition at line 168 of file kis_tangent_normal_paintop.cpp.

{
    if (m_sharpnessOption.isChecked() && m_brush && (m_brush->width() == 1) && (m_brush->height() == 1)) {
 
        if (!m_lineCacheDevice) {
            m_lineCacheDevice = m_tempDev;
        }
        else {
            m_lineCacheDevice->clear();
        }
 
        KisPainter p(m_lineCacheDevice);
        KoColor currentColor = painter()->paintColor();
        QString currentSpace = currentColor.colorSpace()->colorModelId().id();
        const KoColorSpace* rgbColorSpace = KoColorSpaceRegistry::instance()->rgb8();
        if (currentSpace != "RGBA") {
            rgbColorSpace = KoColorSpaceRegistry::instance()->rgb8();
        } else {
            rgbColorSpace = currentColor.colorSpace();
        }
        QVector <float> channelValues(4);
        qreal r, g, b;
 
        if (currentColor.colorSpace()->colorDepthId().id()=="F16" || currentColor.colorSpace()->colorDepthId().id()=="F32"){
            channelValues[0] = 0.5;//red
            channelValues[1] = 0.5;//green
            channelValues[2] = 1.0;//blue
            channelValues[3] = 1.0;//alpha, leave alone.
 
 
            m_tangentTiltOption.apply(pi2, &r, &g, &b);
 
            channelValues[0] = r;//red
            channelValues[1] = g;//green
            channelValues[2] = b;//blue
        } else {
            channelValues[0] = 1.0;//blue
            channelValues[1] = 0.5;//green
            channelValues[2] = 0.5;//red
            channelValues[3] = 1.0;//alpha, leave alone.
 
            m_tangentTiltOption.apply(pi2, &r, &g, &b);
 
            channelValues[0] = b;//blue
            channelValues[1] = g;//green
            channelValues[2] = r;//red
        }
 
        quint8 data[4];
        rgbColorSpace->fromNormalisedChannelsValue(data, channelValues);
        KoColor color(data, rgbColorSpace);
        p.setPaintColor(color);
        p.drawDDALine(pi1.pos(), pi2.pos());
 
        QRect rc = m_lineCacheDevice->extent();
        painter()->bitBlt(rc.x(), rc.y(), m_lineCacheDevice, rc.x(), rc.y(), rc.width(), rc.height());
        painter()->renderMirrorMask(rc, m_lineCacheDevice);
    }
    else {
        KisPaintOp::paintLine(pi1, pi2, currentDistance);
    }
}

References KisTangentTiltOption::apply(), KisPainter::bitBlt(), KisPaintDevice::clear(), KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KoColor::colorSpace(), KisPaintDevice::extent(), KoColorSpace::fromNormalisedChannelsValue(), KoID::id(), KoColorSpaceRegistry::instance(), KisCurveOption::isChecked(), KisBrushBasedPaintOp::m_brush, m_lineCacheDevice, m_sharpnessOption, m_tangentTiltOption, m_tempDev, p, KisPainter::paintColor, KisPaintOp::painter, KisPaintOp::paintLine(), KisPaintInformation::pos(), KisPainter::renderMirrorMask(), and KoColorSpaceRegistry::rgb8().

updateSpacingImpl()

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

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 150 of file kis_tangent_normal_paintop.cpp.

{
    qreal scale = m_sizeOption.apply(info) * KisLodTransform::lodToScale(painter()->device());
    qreal rotation = m_rotationOption.apply(info);
    return computeSpacing(info, scale, rotation);
}

References KisRotationOption::apply(), KisStandardOption< Data >::apply(), computeSpacing(), KisLodTransformBase::lodToScale(), m_rotationOption, m_sizeOption, and KisPaintOp::painter.

updateTimingImpl()

KisTimingInformation KisTangentNormalPaintOp::updateTimingImpl ( const KisPaintInformation & info ) const

overrideprotectedvirtual

Implementation of a timing update. The default implementation always disables timing. This is suitable for paintops that do not support airbrushing.

Reimplemented from KisPaintOp.

Definition at line 157 of file kis_tangent_normal_paintop.cpp.

{
    return KisPaintOpPluginUtils::effectiveTiming(&m_airbrushData, &m_rateOption, info);
}

References KisPaintOpPluginUtils::effectiveTiming(), m_airbrushData, and m_rateOption.

Member Data Documentation

m_airbrushData

KisAirbrushOptionData KisTangentNormalPaintOp::m_airbrushData

private

Definition at line 64 of file kis_tangent_normal_paintop.h.

m_dstDabRect

QRect KisTangentNormalPaintOp::m_dstDabRect

private

Definition at line 69 of file kis_tangent_normal_paintop.h.

m_flowOption

KisFlowOption KisTangentNormalPaintOp::m_flowOption

private

Definition at line 57 of file kis_tangent_normal_paintop.h.

m_lineCacheDevice

KisPaintDeviceSP KisTangentNormalPaintOp::m_lineCacheDevice

private

Definition at line 71 of file kis_tangent_normal_paintop.h.

m_maskDab

KisFixedPaintDeviceSP KisTangentNormalPaintOp::m_maskDab

private

Definition at line 67 of file kis_tangent_normal_paintop.h.

m_opacityOption

KisFlowOpacityOption2 KisTangentNormalPaintOp::m_opacityOption

private

Definition at line 56 of file kis_tangent_normal_paintop.h.

m_rateOption

KisRateOption KisTangentNormalPaintOp::m_rateOption

private

Definition at line 65 of file kis_tangent_normal_paintop.h.

m_rotationOption

KisRotationOption KisTangentNormalPaintOp::m_rotationOption

private

Definition at line 63 of file kis_tangent_normal_paintop.h.

m_scatterOption

KisScatterOption KisTangentNormalPaintOp::m_scatterOption

private

Definition at line 62 of file kis_tangent_normal_paintop.h.

m_sharpnessOption

KisSharpnessOption KisTangentNormalPaintOp::m_sharpnessOption

private

Definition at line 61 of file kis_tangent_normal_paintop.h.

m_sizeOption

KisSizeOption KisTangentNormalPaintOp::m_sizeOption

private

Definition at line 58 of file kis_tangent_normal_paintop.h.

m_softnessOption

KisSoftnessOption KisTangentNormalPaintOp::m_softnessOption

private

Definition at line 60 of file kis_tangent_normal_paintop.h.

m_spacingOption

KisSpacingOption KisTangentNormalPaintOp::m_spacingOption

private

Definition at line 59 of file kis_tangent_normal_paintop.h.

m_tangentTiltOption

KisTangentTiltOption KisTangentNormalPaintOp::m_tangentTiltOption

private

Definition at line 54 of file kis_tangent_normal_paintop.h.

m_tempDev

KisPaintDeviceSP KisTangentNormalPaintOp::m_tempDev

private

Definition at line 68 of file kis_tangent_normal_paintop.h.

---

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

• plugins/paintops/tangentnormal/kis_tangent_normal_paintop.h
• plugins/paintops/tangentnormal/kis_tangent_normal_paintop.cpp