KisDabCacheBase Class Reference

The KisDabCacheBase class provides caching for dabs into the brush paintop. More...

#include <kis_dab_cache_base.h>

Inheritance diagram for KisDabCacheBase:

Classes
struct	DabPosition
struct	Private
struct	SavedDabParameters

Public Member Functions
void	disableSubpixelPrecision ()
	KisDabCacheBase ()
bool	needSeparateOriginal (KisTextureOption *textureOption, KisSharpnessOption *sharpnessOption) const
void	setMirrorPostprocessing (KisMirrorOption *option)
void	setPrecisionOption (KisPrecisionOption *option)
	~KisDabCacheBase ()

Protected Member Functions
void	fetchDabGenerationInfo (bool hasDabInCache, KisDabCacheUtils::DabRenderingResources *resources, const KisDabCacheUtils::DabRequestInfo &request, KisDabCacheUtils::DabGenerationInfo *di, bool *shouldUseCache)

Private Member Functions
KisDabCacheBase::DabPosition	calculateDabRect (KisBrushSP brush, const QPointF &cursorPoint, KisDabShape, const KisPaintInformation &info, const MirrorProperties &mirrorProperties, KisSharpnessOption *sharpnessOption)
SavedDabParameters	getDabParameters (KisBrushSP brush, const KoColor &color, KisDabShape const &, const KisPaintInformation &info, double subPixelX, double subPixelY, qreal softnessFactor, qreal lightnessStrength, MirrorProperties mirrorProperties)

Private Attributes
Private *const	m_d

Detailed Description

The KisDabCacheBase class provides caching for dabs into the brush paintop.

This class adds caching of the dabs to the paintop system of Krita. Such cache makes the execution of the benchmarks up to 2 times faster. Subjectively, the real painting becomes much faster, especially with huge brushes. Artists report up to 20% speed gain while painting.

Of course, such caching makes the painting a bit less precise: we need to tolerate subpixel differences to allow the cache to work. Sometimes small difference in the size of a dab can also be acceptable. That is why I introduced levels of precision. They are graded from 1 to 5: from the fastest and less precise to the slowest, but with the best quality. You can see the slider in the paintop settings dialog. The ToolTip text explains which features of the brush are sacrificed on each precision level.

The texturing and mirroring problems are solved.

Definition at line 42 of file kis_dab_cache_base.h.

Constructor & Destructor Documentation

KisDabCacheBase()

KisDabCacheBase::KisDabCacheBase

(

)

Definition at line 90 of file kis_dab_cache_base.cpp.

    : m_d(new Private())
{
}

~KisDabCacheBase()

KisDabCacheBase::~KisDabCacheBase

(

)

Definition at line 95 of file kis_dab_cache_base.cpp.

{
    delete m_d;
}

References m_d.

Member Function Documentation

calculateDabRect()

KisDabCacheBase::DabPosition KisDabCacheBase::calculateDabRect ( KisBrushSP brush, const QPointF & cursorPoint, KisDabShape shape, const KisPaintInformation & info, const MirrorProperties & mirrorProperties, KisSharpnessOption * sharpnessOption )

inlineprivate

Definition at line 173 of file kis_dab_cache_base.cpp.

{
    qint32 x = 0, y = 0;
    qreal subPixelX = 0.0, subPixelY = 0.0;
 
    if (mirrorProperties.coordinateSystemFlipped) {
        shape = KisDabShape(shape.scale(), shape.ratio(), 2 * M_PI - shape.rotation());
    }
 
    QPointF hotSpot = brush->hotSpot(shape, info);
    QPointF pt = cursorPoint - hotSpot;
 
    if (sharpnessOption) {
        sharpnessOption->apply(info, pt, x, y, subPixelX, subPixelY);
    }
    else {
        KisPaintOp::splitCoordinate(pt.x(), &x, &subPixelX);
        KisPaintOp::splitCoordinate(pt.y(), &y, &subPixelY);
    }
 
    if (m_d->subPixelPrecisionDisabled) {
        subPixelX = 0;
        subPixelY = 0;
    }
 
    if (qIsNaN(subPixelX)) {
        subPixelX = 0;
    }
 
    if (qIsNaN(subPixelY)) {
        subPixelY = 0;
    }
 
    int width = brush->maskWidth(shape, subPixelX, subPixelY, info);
    int height = brush->maskHeight(shape, subPixelX, subPixelY, info);
 
    if (mirrorProperties.horizontalMirror) {
        subPixelX = Private::positiveFraction(-(cursorPoint.x() + hotSpot.x()));
        width = brush->maskWidth(shape, subPixelX, subPixelY, info);
        x = qRound(cursorPoint.x() + subPixelX + hotSpot.x()) - width;
    }
 
    if (mirrorProperties.verticalMirror) {
        subPixelY = Private::positiveFraction(-(cursorPoint.y() + hotSpot.y()));
        height = brush->maskHeight(shape, subPixelX, subPixelY, info);
        y = qRound(cursorPoint.y() + subPixelY + hotSpot.y()) - height;
    }
 
    return DabPosition(QRect(x, y, width, height),
                       QPointF(subPixelX, subPixelY),
                       shape.rotation());
}

References KisSharpnessOption::apply(), MirrorProperties::coordinateSystemFlipped, MirrorProperties::horizontalMirror, m_d, M_PI, KisDabCacheBase::Private::positiveFraction(), KisDabShape::ratio(), KisDabShape::rotation(), KisDabShape::scale(), KisPaintOp::splitCoordinate(), KisDabCacheBase::Private::subPixelPrecisionDisabled, and MirrorProperties::verticalMirror.

disableSubpixelPrecision()

void KisDabCacheBase::disableSubpixelPrecision

(

)

Disables handling of the subPixelX and subPixelY values, this is needed at least for the Color Smudge paint op, which reads aligned areas from image, so additional offsets generated by the subpixel precision should be avoided

Definition at line 110 of file kis_dab_cache_base.cpp.

{
    m_d->subPixelPrecisionDisabled = true;
}

References m_d, and KisDabCacheBase::Private::subPixelPrecisionDisabled.

fetchDabGenerationInfo()

void KisDabCacheBase::fetchDabGenerationInfo ( bool hasDabInCache, KisDabCacheUtils::DabRenderingResources * resources, const KisDabCacheUtils::DabRequestInfo & request, KisDabCacheUtils::DabGenerationInfo * di, bool * shouldUseCache )

protected

Fetches all the necessary information for dab generation and tells if the caller must should reuse the preciously returned dab. * Please note that KisDabCacheBase has an internal state, that keeps the parameters of the previously generated (on a cache-miss) dab. This function automatically updates this state when 'shouldUseCache == false'. Therefore, the caller must generate the dab if and only if when 'shouldUseCache == false'. Otherwise the internal state will become inconsistent.

Parameters

hasDabInCache	shows if the caller has something in its cache
resources	rendering resources available for this dab
request	the request information
di	(OUT) calculated dab generation information
shouldUseCache	(OUT) shows whether the caller must use cache or not

Definition at line 231 of file kis_dab_cache_base.cpp.

{
    di->info = request.info;
    di->softnessFactor = request.softnessFactor;
    di->lightnessStrength = request.lightnessStrength;
 
    if (m_d->mirrorOption) {
        di->mirrorProperties = m_d->mirrorOption->apply(request.info);
    }
 
    DabPosition position = calculateDabRect(resources->brush,
                                            request.cursorPoint,
                                            request.shape,
                                            request.info,
                                            di->mirrorProperties,
                                            resources->sharpnessOption.data());
    di->shape = KisDabShape(request.shape.scale(), request.shape.ratio(), position.realAngle);
    di->dstDabRect = position.rect;
    di->subPixel = position.subPixel;
 
    const bool supportsCaching = resources->brush->supportsCaching();
 
    const KisUniformColorSource *uniformColorSource =
        resources->colorSource ? dynamic_cast<const KisUniformColorSource*>(resources->colorSource.data()) : 0;
 
    di->solidColorFill = !resources->colorSource || uniformColorSource;
    di->paintColor = uniformColorSource ?
        uniformColorSource->uniformColor() : request.color;
 
    SavedDabParameters newParams = getDabParameters(resources->brush,
                                                    di->paintColor,
                                                    di->shape,
                                                    di->info,
                                                    di->subPixel.x(),
                                                    di->subPixel.y(),
                                                    di->softnessFactor,
                                                    di->lightnessStrength,
                                                    di->mirrorProperties);
 
    int precisionLevel = 4;
    if (m_d->precisionOption) {
        const int effectiveDabSize = qMin(newParams.width, newParams.height);
        precisionLevel = m_d->precisionOption->effectivePrecisionLevel(effectiveDabSize) - 1;
    }
    *shouldUseCache = hasDabInCache && supportsCaching && di->solidColorFill &&
            newParams.compare(m_d->lastSavedDabParameters, precisionLevel);
 
    if (!*shouldUseCache) {
        m_d->lastSavedDabParameters = newParams;
    }
 
    di->needsPostprocessing = needSeparateOriginal(resources->textureOption.data(), resources->sharpnessOption.data());
}

References KisMirrorOption::apply(), KisDabCacheUtils::DabRenderingResources::brush, calculateDabRect(), KisDabCacheUtils::DabRenderingResources::colorSource, KisDabCacheBase::SavedDabParameters::compare(), KisDabCacheUtils::DabGenerationInfo::dstDabRect, KisPrecisionOption::effectivePrecisionLevel(), getDabParameters(), KisDabCacheBase::SavedDabParameters::height, KisDabCacheUtils::DabGenerationInfo::info, KisDabCacheBase::Private::lastSavedDabParameters, KisDabCacheUtils::DabGenerationInfo::lightnessStrength, m_d, KisDabCacheBase::Private::mirrorOption, KisDabCacheUtils::DabGenerationInfo::mirrorProperties, needSeparateOriginal(), KisDabCacheUtils::DabGenerationInfo::needsPostprocessing, KisDabCacheUtils::DabGenerationInfo::paintColor, KisDabCacheBase::Private::precisionOption, KisDabCacheBase::DabPosition::realAngle, KisDabCacheBase::DabPosition::rect, KisDabCacheUtils::DabGenerationInfo::shape, KisDabCacheUtils::DabRenderingResources::sharpnessOption, KisDabCacheUtils::DabGenerationInfo::softnessFactor, KisDabCacheUtils::DabGenerationInfo::solidColorFill, KisDabCacheBase::DabPosition::subPixel, KisDabCacheUtils::DabGenerationInfo::subPixel, KisDabCacheUtils::DabRenderingResources::textureOption, KisUniformColorSource::uniformColor(), and KisDabCacheBase::SavedDabParameters::width.

getDabParameters()

KisDabCacheBase::SavedDabParameters KisDabCacheBase::getDabParameters ( KisBrushSP brush, const KoColor & color, KisDabShape const & shape, const KisPaintInformation & info, double subPixelX, double subPixelY, qreal softnessFactor, qreal lightnessStrength, MirrorProperties mirrorProperties )

inlineprivate

Definition at line 116 of file kis_dab_cache_base.cpp.

{
    SavedDabParameters params;
 
    params.color = color;
    params.angle = shape.rotation();
    params.width = brush->maskWidth(shape, subPixelX, subPixelY, info);
    params.height = brush->maskHeight(shape, subPixelX, subPixelY, info);
    params.subPixelX = subPixelX;
    params.subPixelY = subPixelY;
    params.softnessFactor = softnessFactor;
    params.lightnessStrength = lightnessStrength;
    params.index = brush->brushIndex();
    params.mirrorProperties = mirrorProperties;
    params.ratio = shape.ratio();
 
    return params;
}

References KisDabCacheBase::SavedDabParameters::angle, KisDabCacheBase::SavedDabParameters::color, KisDabCacheBase::SavedDabParameters::height, KisDabCacheBase::SavedDabParameters::index, KisDabCacheBase::SavedDabParameters::lightnessStrength, KisDabCacheBase::SavedDabParameters::mirrorProperties, KisDabShape::ratio(), KisDabCacheBase::SavedDabParameters::ratio, KisDabShape::rotation(), KisDabCacheBase::SavedDabParameters::softnessFactor, KisDabCacheBase::SavedDabParameters::subPixelX, KisDabCacheBase::SavedDabParameters::subPixelY, and KisDabCacheBase::SavedDabParameters::width.

needSeparateOriginal()

bool KisDabCacheBase::needSeparateOriginal	(	KisTextureOption *	textureOption,
		KisSharpnessOption *	sharpnessOption ) const

Return true if the dab needs postprocessing by special options like 'texture' or 'sharpness'

Definition at line 142 of file kis_dab_cache_base.cpp.

{
    return (textureOption && textureOption->m_enabled) ||
           (sharpnessOption && sharpnessOption->isChecked());
}

References KisCurveOption::isChecked(), and KisTextureOption::m_enabled.

setMirrorPostprocessing()

void KisDabCacheBase::setMirrorPostprocessing

(

KisMirrorOption *

option

)

Definition at line 100 of file kis_dab_cache_base.cpp.

{
    m_d->mirrorOption = option;
}

References m_d, and KisDabCacheBase::Private::mirrorOption.

setPrecisionOption()

void KisDabCacheBase::setPrecisionOption

(

KisPrecisionOption *

option

)

Definition at line 105 of file kis_dab_cache_base.cpp.

{
    m_d->precisionOption = option;
}

References m_d, and KisDabCacheBase::Private::precisionOption.

Member Data Documentation

m_d

Private* const KisDabCacheBase::m_d

private

Definition at line 109 of file kis_dab_cache_base.h.

---

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

• plugins/paintops/libpaintop/kis_dab_cache_base.h
• plugins/paintops/libpaintop/kis_dab_cache_base.cpp