#include <kis_brushop.h>

Inheritance diagram for KisBrushOp:

Classes
struct	UpdateSharedState

Public Member Functions
std::pair< int, bool >	doAsynchronousUpdate (QVector< KisRunnableStrokeJobData * > &jobs) override

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

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

	~KisBrushOp () 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
	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 Types
typedef QSharedPointer< UpdateSharedState >	UpdateSharedStateSP

Protected Member Functions
void	addMirroringJobs (Qt::Orientation direction, QVector< QRect > &rects, UpdateSharedStateSP state, QVector< KisRunnableStrokeJobData * > &jobs)

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 ()

Protected Attributes
UpdateSharedStateSP	m_updateSharedState

Protected Attributes inherited from KisBrushBasedPaintOp
KisBrushSP	m_brush

KisDabCache *	m_dabCache

KisMirrorOption	m_mirrorOption

KisPrecisionOption	m_precisionOption

Private Attributes
KisAirbrushOptionData	m_airbrushData

KisRollingMeanAccumulatorWrapper	m_avgNumDabs

KisRollingMeanAccumulatorWrapper	m_avgSpacing

KisRollingMeanAccumulatorWrapper	m_avgUpdateTimePerDab

qreal	m_currentUpdatePeriod = 20.0

QScopedPointer< KisDabRenderingExecutor >	m_dabExecutor

const int	m_idealNumRects

KisLightnessStrengthOption	m_lightnessStrengthOption

KisPaintDeviceSP	m_lineCacheDevice

const int	m_maxUpdatePeriod

const int	m_minUpdatePeriod

KisFlowOpacityOption2	m_opacityOption

KisRateOption	m_rateOption

KisRatioOption	m_ratioOption

KisRotationOption	m_rotationOption

KisScatterOption	m_scatterOption

KisSharpnessOption	m_sharpnessOption

KisSizeOption	m_sizeOption

KisSoftnessOption	m_softnessOption

KisSpacingOption	m_spacingOption

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

Detailed Description

Definition at line 33 of file kis_brushop.h.

Member Typedef Documentation

◆ UpdateSharedStateSP

typedef QSharedPointer<UpdateSharedState> KisBrushOp::UpdateSharedStateSP

protected

Definition at line 53 of file kis_brushop.h.

Constructor & Destructor Documentation

◆ KisBrushOp()

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

Definition at line 47 of file kis_brushop.cpp.

    : KisBrushBasedPaintOp(settings, painter, SupportsGradientMode | SupportsLightnessMode)
    , m_sizeOption(settings.data())
    , m_ratioOption(settings.data())
    , m_rateOption(settings.data())
    , m_softnessOption(settings.data())
    , m_lightnessStrengthOption(settings.data())
    , m_spacingOption(settings.data())
    , m_scatterOption(settings.data())
    , m_sharpnessOption(settings.data())
    , m_rotationOption(settings.data())
    , m_opacityOption(settings.data(), node)
    , m_avgSpacing(50)
    , m_avgNumDabs(50)
    , m_avgUpdateTimePerDab(50)
    , m_idealNumRects(KisImageConfig(true).maxNumberOfThreads())
    , m_minUpdatePeriod(10)
    , m_maxUpdatePeriod(100)
{
    Q_UNUSED(image);
    Q_ASSERT(settings);
 
    m_airbrushData.read(settings.data());
    m_rotationOption.applyFanCornersInfo(this);
 
    m_precisionOption.setHasImprecisePositionOptions(
        m_precisionOption.hasImprecisePositionOptions()
        || m_scatterOption.isChecked() || m_rotationOption.isChecked()
        || m_airbrushData.isChecked);
 
    m_brush->notifyBrushIsGoingToBeClonedForStroke();
 
    KisBrushSP baseBrush = m_brush;
    auto resourcesFactory =
        [baseBrush, settings, painter] () {
            KisDabCacheUtils::DabRenderingResources *resources =
                new KisBrushOpResources(settings, painter);
            resources->brush = baseBrush->clone().dynamicCast<KisBrush>();
 
            return resources;
        };
 
 
    m_dabExecutor.reset(
        new KisDabRenderingExecutor(
                    painter->device()->compositionSourceColorSpace(),
                    resourcesFactory,
                    painter->runnableStrokeJobsInterface(),
                    &m_mirrorOption,
                    &m_precisionOption));
}

References KisRotationOption::applyFanCornersInfo(), KisDabCacheUtils::DabRenderingResources::brush, KisPaintDevice::compositionSourceColorSpace(), KisSharedPtr< T >::data(), KisPainter::device, KisPrecisionOption::hasImprecisePositionOptions(), KisAirbrushOptionData::isChecked, KisCurveOption::isChecked(), m_airbrushData, KisBrushBasedPaintOp::m_brush, m_dabExecutor, KisBrushBasedPaintOp::m_mirrorOption, KisBrushBasedPaintOp::m_precisionOption, m_rotationOption, m_scatterOption, KisPaintOp::painter, KisAirbrushOptionData::read(), KisPainter::runnableStrokeJobsInterface, and KisPrecisionOption::setHasImprecisePositionOptions().

◆ ~KisBrushOp()

KisBrushOp::~KisBrushOp ( )

override

Definition at line 99 of file kis_brushop.cpp.

100{

101}

Member Function Documentation

◆ addMirroringJobs()

void KisBrushOp::addMirroringJobs	(	Qt::Orientation	direction,
		QVector< QRect > &	rects,
		UpdateSharedStateSP	state,
		QVector< KisRunnableStrokeJobData * > &	jobs )

protected

Some KisRenderedDab may share their devices, so we should mirror them carefully, avoiding doing that twice. KisDabRenderingQueue is implemented in a way that duplicated dabs can go only sequentially, one after another, so we don't have to use complex deduplication algorithms here.

Definition at line 166 of file kis_brushop.cpp.

{
    KritaUtils::addJobSequential(jobs, nullptr);
 
    KisFixedPaintDeviceSP prevDabDevice = 0;
    for (KisRenderedDab &dab : state->dabsQueue) {
        const bool skipMirrorPixels = prevDabDevice && prevDabDevice == dab.device;
 
        KritaUtils::addJobConcurrent(jobs,
            [state, &dab, direction, skipMirrorPixels] () {
                state->painter->mirrorDab(direction, &dab, skipMirrorPixels);
            }
        );
 
        prevDabDevice = dab.device;
    }
 
    KritaUtils::addJobSequential(jobs, nullptr);
 
    for (QRect &rc : rects) {
        state->painter->mirrorRect(direction, &rc);
 
        KritaUtils::addJobConcurrent(jobs,
            [rc, state] () {
                state->painter->bltFixed(rc, state->dabsQueue);
            }
        );
    }
 
    state->allDirtyRects.append(rects);
}

References KritaUtils::addJobConcurrent(), KritaUtils::addJobSequential(), and KisPaintOp::dab.

◆ doAsynchronousUpdate()

std::pair< int, bool > KisBrushOp::doAsynchronousUpdate ( QVector< KisRunnableStrokeJobData * > & jobs )

overridevirtual

If the preset supports asynchronous updates, then the stroke execution core will call this method with a desired frame rate. The jobs that should be run to prepare the update are returned via jobs

Returns: a pair of <the desired FPS rate (period of updates); are there any unprocessed update jobs left?>

In WA mode we do two things:

1) We ensure that the parallel threads do not access the same are on the image. For normal updates that is ensured by the code in KisImage and the scheduler. Here we should do that manually by adjusting 'rects' so that they would not intersect in the wrapped space.

2) We duplicate dabs, to ensure that all the pieces of dabs are painted inside the wrapped rect. No pieces are dabs are painted twice, because we paint only the parts intersecting the wrap rect.

After the dab has been rendered once, we should mirror it either one (h or v) or three (h and v) times. This sequence of 'if's achieves the goal without any extra copying. Please note that it has no 'else' branches, which is done intentionally!

NOTE: using currentUpdateTimePerDab in the calculation for the next update time instead of the average one makes rendering speed about 40% faster. It happens because the adaptation period is shorter than if it used

Reimplemented from KisPaintOp.

Definition at line 207 of file kis_brushop.cpp.

{
    bool someDabsAreStillInQueue = false;
    const bool hasPreparedDabsAtStart = m_dabExecutor->hasPreparedDabs();
 
    if (!m_updateSharedState && hasPreparedDabsAtStart) {
 
        m_updateSharedState = toQShared(new UpdateSharedState());
        UpdateSharedStateSP state = m_updateSharedState;
 
        state->painter = painter();
 
        {
            const qreal dabRenderingTime = m_dabExecutor->averageDabRenderingTime();
            const qreal totalRenderingTimePerDab = dabRenderingTime + m_avgUpdateTimePerDab.rollingMeanSafe();
 
            // we limit the number of fetched dabs to fit the maximum update period and not
            // make visual hiccups
            const int dabsLimit =
                totalRenderingTimePerDab > 0 ?
                    qMax(10, int(m_maxUpdatePeriod  / totalRenderingTimePerDab * m_idealNumRects)) :
                    -1;
 
            state->dabsQueue = m_dabExecutor->takeReadyDabs(painter()->hasMirroring(), dabsLimit, &someDabsAreStillInQueue);
        }
 
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!state->dabsQueue.isEmpty(),
                                             std::make_pair(m_currentUpdatePeriod, false));
 
        const int diameter = m_dabExecutor->averageDabSize();
        const qreal spacing = m_avgSpacing.rollingMean();
 
        const int idealNumRects = m_idealNumRects;
 
        QVector<QRect> rects;
 
        // wrap the dabs if needed
        if (painter()->device()->defaultBounds()->wrapAroundMode()) {
            const QRect wrapRect = painter()->device()->defaultBounds()->imageBorderRect();
            const WrapAroundAxis wrapAroundModeAxis = painter()->device()->defaultBounds()->wrapAroundModeAxis();
 
            QList<KisRenderedDab> wrappedDabs;
 
            Q_FOREACH (const KisRenderedDab &dab, state->dabsQueue) {
                const QVector<QPoint> normalizationOrigins =
                    KisWrappedRect::normalizationOriginsForRect(dab.realBounds(), wrapRect, wrapAroundModeAxis);
 
                Q_FOREACH(const QPoint &pt, normalizationOrigins) {
                    KisRenderedDab newDab = dab;
 
                    newDab.offset = pt;
                    rects.append(KisWrappedRect::clipToWrapRect(newDab.realBounds(), wrapRect, wrapAroundModeAxis));
                    wrappedDabs.append(newDab);
                }
            }
 
            state->dabsQueue = wrappedDabs;
 
        } else {
            // just get all rects
            Q_FOREACH (const KisRenderedDab &dab, state->dabsQueue) {
                rects.append(dab.realBounds());
            }
        }
 
        // split/merge rects into non-overlapping areas
        rects = KisPaintOpUtils::splitDabsIntoRects(rects,
                                                    idealNumRects, diameter, spacing);
 
        state->allDirtyRects = rects;
 
        Q_FOREACH (const KisRenderedDab &dab, state->dabsQueue) {
            state->dabPoints.append(dab.realBounds().center());
        }
 
        state->dabRenderingTimer.start();
 
        Q_FOREACH (const QRect &rc, rects) {
            KritaUtils::addJobConcurrent(jobs,
                [rc, state] () {
                    state->painter->bltFixed(rc, state->dabsQueue);
                }
            );
        }
 
        if (state->painter->hasHorizontalMirroring()) {
            addMirroringJobs(Qt::Horizontal, rects, state, jobs);
        }
 
        if (state->painter->hasVerticalMirroring()) {
            addMirroringJobs(Qt::Vertical, rects, state, jobs);
        }
 
        if (state->painter->hasHorizontalMirroring() && state->painter->hasVerticalMirroring()) {
            addMirroringJobs(Qt::Horizontal, rects, state, jobs);
        }
 
        KritaUtils::addJobSequential(jobs,
                [state, this, someDabsAreStillInQueue] () {
                    Q_FOREACH(const QRect &rc, state->allDirtyRects) {
                        state->painter->addDirtyRect(rc);
                    }
 
                    state->painter->setAverageOpacity(state->dabsQueue.last().averageOpacity);
 
                    const int updateRenderingTime = state->dabRenderingTimer.elapsed();
                    const qreal dabRenderingTime = m_dabExecutor->averageDabRenderingTime();
 
                    m_avgNumDabs(state->dabsQueue.size());
 
                    const qreal currentUpdateTimePerDab = qreal(updateRenderingTime) / state->dabsQueue.size();
                    m_avgUpdateTimePerDab(currentUpdateTimePerDab);
 
                    const qreal totalRenderingTimePerDab = dabRenderingTime + currentUpdateTimePerDab;
 
                    const int approxDabRenderingTime =
                        qreal(totalRenderingTimePerDab) * m_avgNumDabs.rollingMean() / m_idealNumRects;
 
                    m_currentUpdatePeriod =
                        someDabsAreStillInQueue ? m_minUpdatePeriod :
                        qBound(m_minUpdatePeriod, int(1.5 * approxDabRenderingTime), m_maxUpdatePeriod);
 
 
                    { // debug chunk
//                        ENTER_FUNCTION() << ppVar(state->allDirtyRects.size()) << ppVar(state->dabsQueue.size()) << ppVar(dabRenderingTime) << ppVar(updateRenderingTime);
//                        ENTER_FUNCTION() << ppVar(m_currentUpdatePeriod) << ppVar(someDabsAreStillInQueue);
                    }
 
                    // release all the dab devices
                    state->dabsQueue.clear();
 
                    m_updateSharedState.clear();
                }
        );
    } else if (m_updateSharedState && hasPreparedDabsAtStart) {
        someDabsAreStillInQueue = true;
    }
 
    return std::make_pair(m_currentUpdatePeriod, someDabsAreStillInQueue);
}

References KritaUtils::addJobConcurrent(), KritaUtils::addJobSequential(), addMirroringJobs(), KisWrappedRect::clipToWrapRect(), KisPaintOp::dab, KisPaintDevice::defaultBounds(), KisPainter::device, KisDefaultBoundsBase::imageBorderRect(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_avgNumDabs, m_avgSpacing, m_avgUpdateTimePerDab, m_currentUpdatePeriod, m_dabExecutor, m_idealNumRects, m_maxUpdatePeriod, m_minUpdatePeriod, m_updateSharedState, KisWrappedRect::normalizationOriginsForRect(), KisRenderedDab::offset, KisPaintOp::painter, KisRenderedDab::realBounds(), KisRollingMeanAccumulatorWrapper::rollingMean(), KisRollingMeanAccumulatorWrapper::rollingMeanSafe(), KisPaintOpUtils::splitDabsIntoRects(), toQShared(), and KisDefaultBoundsBase::wrapAroundModeAxis().

◆ paintAt()

KisSpacingInformation KisBrushOp::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 103 of file kis_brushop.cpp.

{
    if (!painter()->device()) return KisSpacingInformation(1.0);
 
    KisBrushSP brush = m_brush;
    Q_ASSERT(brush);
    if (!brush)
        return KisSpacingInformation(1.0);
 
    if (!brush->canPaintFor(info))
        return KisSpacingInformation(1.0);
 
    qreal scale = m_sizeOption.apply(info);
    scale *= KisLodTransform::lodToScale(painter()->device());
    if (checkSizeTooSmall(scale)) return KisSpacingInformation();
 
    qreal rotation = m_rotationOption.apply(info);
    qreal ratio = m_ratioOption.apply(info);
 
    KisDabShape shape(scale, ratio, rotation);
    QPointF cursorPos =
        m_scatterOption.apply(info,
                              brush->maskWidth(shape, 0, 0, info),
                              brush->maskHeight(shape, 0, 0, info));
 
    qreal dabOpacity = OPACITY_OPAQUE_F;
    qreal dabFlow = OPACITY_OPAQUE_F;
 
    m_opacityOption.apply(info, &dabOpacity, &dabFlow);
 
    KisDabCacheUtils::DabRequestInfo request(painter()->paintColor(),
                                             cursorPos,
                                             shape,
                                             info,
                                             m_softnessOption.apply(info),
                                             m_lightnessStrengthOption.apply(info));
 
    m_dabExecutor->addDab(request, dabOpacity, dabFlow);
 
 
    KisSpacingInformation spacingInfo =
        effectiveSpacing(scale, rotation, &m_airbrushData, &m_spacingOption, info);
 
    // gather statistics about dabs
    m_avgSpacing(spacingInfo.scalarApprox());
 
    return spacingInfo;
}

References KisRotationOption::apply(), KisStandardOption< Data >::apply(), KisScatterOption::apply(), KisFlowOpacityOption2::apply(), KisBrushBasedPaintOp::checkSizeTooSmall(), KisBrushBasedPaintOp::effectiveSpacing(), KisLodTransformBase::lodToScale(), m_airbrushData, m_avgSpacing, KisBrushBasedPaintOp::m_brush, m_dabExecutor, m_lightnessStrengthOption, m_opacityOption, m_ratioOption, m_rotationOption, m_scatterOption, m_sizeOption, m_softnessOption, m_spacingOption, OPACITY_OPAQUE_F, KisPaintOp::painter, and KisSpacingInformation::scalarApprox().

◆ paintLine()

void KisBrushOp::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 384 of file kis_brushop.cpp.

{
    if (m_sharpnessOption.isChecked() && m_brush && (m_brush->width() == 1) && (m_brush->height() == 1)) {
 
        if (!m_lineCacheDevice) {
            m_lineCacheDevice = source()->createCompositionSourceDevice();
        }
        else {
            m_lineCacheDevice->clear();
        }
 
        KisPainter p(m_lineCacheDevice);
        p.setPaintColor(painter()->paintColor());
        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());
    //fixes Bug 338011
    painter()->renderMirrorMask(rc, m_lineCacheDevice);
    }
    else {
        KisPaintOp::paintLine(pi1, pi2, currentDistance);
    }
}

References KisPainter::bitBlt(), KisPaintDevice::clear(), KisPaintDevice::createCompositionSourceDevice(), KisPaintDevice::extent(), KisCurveOption::isChecked(), KisBrushBasedPaintOp::m_brush, m_lineCacheDevice, m_sharpnessOption, p, KisPaintOp::painter, KisPaintOp::paintLine(), KisPaintInformation::pos(), KisPainter::renderMirrorMask(), and KisPaintOp::source().

◆ updateSpacingImpl()

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

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 372 of file kis_brushop.cpp.

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

References KisRotationOption::apply(), KisStandardOption< Data >::apply(), KisBrushBasedPaintOp::effectiveSpacing(), KisLodTransformBase::lodToScale(), m_airbrushData, m_rotationOption, m_sizeOption, m_spacingOption, and KisPaintOp::painter.

◆ updateTimingImpl()

KisTimingInformation KisBrushOp::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 379 of file kis_brushop.cpp.

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

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

Member Data Documentation

◆ m_airbrushData

KisAirbrushOptionData KisBrushOp::m_airbrushData

private

Definition at line 64 of file kis_brushop.h.

◆ m_avgNumDabs

KisRollingMeanAccumulatorWrapper KisBrushOp::m_avgNumDabs

private

Definition at line 83 of file kis_brushop.h.

◆ m_avgSpacing

KisRollingMeanAccumulatorWrapper KisBrushOp::m_avgSpacing

private

Definition at line 82 of file kis_brushop.h.

◆ m_avgUpdateTimePerDab

KisRollingMeanAccumulatorWrapper KisBrushOp::m_avgUpdateTimePerDab

private

Definition at line 84 of file kis_brushop.h.

◆ m_currentUpdatePeriod

qreal KisBrushOp::m_currentUpdatePeriod = 20.0

private

Definition at line 81 of file kis_brushop.h.

◆ m_dabExecutor

QScopedPointer<KisDabRenderingExecutor> KisBrushOp::m_dabExecutor

private

Definition at line 80 of file kis_brushop.h.

◆ m_idealNumRects

const int KisBrushOp::m_idealNumRects

private

Definition at line 86 of file kis_brushop.h.

◆ m_lightnessStrengthOption

KisLightnessStrengthOption KisBrushOp::m_lightnessStrengthOption

private

Definition at line 70 of file kis_brushop.h.

◆ m_lineCacheDevice

KisPaintDeviceSP KisBrushOp::m_lineCacheDevice

private

Definition at line 78 of file kis_brushop.h.

◆ m_maxUpdatePeriod

const int KisBrushOp::m_maxUpdatePeriod

private

Definition at line 89 of file kis_brushop.h.

◆ m_minUpdatePeriod

const int KisBrushOp::m_minUpdatePeriod

private

Definition at line 88 of file kis_brushop.h.

◆ m_opacityOption

KisFlowOpacityOption2 KisBrushOp::m_opacityOption

private

Definition at line 75 of file kis_brushop.h.

◆ m_rateOption

KisRateOption KisBrushOp::m_rateOption

private

Definition at line 68 of file kis_brushop.h.

◆ m_ratioOption

KisRatioOption KisBrushOp::m_ratioOption

private

Definition at line 67 of file kis_brushop.h.

◆ m_rotationOption

KisRotationOption KisBrushOp::m_rotationOption

private

Definition at line 74 of file kis_brushop.h.

◆ m_scatterOption

KisScatterOption KisBrushOp::m_scatterOption

private

Definition at line 72 of file kis_brushop.h.

◆ m_sharpnessOption

KisSharpnessOption KisBrushOp::m_sharpnessOption

private

Definition at line 73 of file kis_brushop.h.

◆ m_sizeOption

KisSizeOption KisBrushOp::m_sizeOption

private

Definition at line 66 of file kis_brushop.h.

◆ m_softnessOption

KisSoftnessOption KisBrushOp::m_softnessOption

private

Definition at line 69 of file kis_brushop.h.

◆ m_spacingOption

KisSpacingOption KisBrushOp::m_spacingOption

private

Definition at line 71 of file kis_brushop.h.

◆ m_updateSharedState

UpdateSharedStateSP KisBrushOp::m_updateSharedState

protected

Definition at line 60 of file kis_brushop.h.

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

plugins/paintops/defaultpaintops/brush/kis_brushop.h
plugins/paintops/defaultpaintops/brush/kis_brushop.cpp

Classes

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ UpdateSharedStateSP

Constructor & Destructor Documentation

◆ KisBrushOp()

◆ ~KisBrushOp()

Member Function Documentation

◆ addMirroringJobs()

◆ doAsynchronousUpdate()

◆ paintAt()

◆ paintLine()

◆ updateSpacingImpl()

◆ updateTimingImpl()

Member Data Documentation

◆ m_airbrushData

◆ m_avgNumDabs

◆ m_avgSpacing

◆ m_avgUpdateTimePerDab

◆ m_currentUpdatePeriod

◆ m_dabExecutor

◆ m_idealNumRects

◆ m_lightnessStrengthOption

◆ m_lineCacheDevice

◆ m_maxUpdatePeriod

◆ m_minUpdatePeriod

◆ m_opacityOption

◆ m_rateOption

◆ m_ratioOption

◆ m_rotationOption

◆ m_scatterOption

◆ m_sharpnessOption

◆ m_sizeOption

◆ m_softnessOption

◆ m_spacingOption

◆ m_updateSharedState