KisDabCache Class Reference

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

#include <kis_dab_cache.h>

Inheritance diagram for KisDabCache:

Classes
struct	Private

Public Member Functions
KisFixedPaintDeviceSP	fetchDab (const KoColorSpace *cs, const KoColor &color, const QPointF &cursorPoint, KisDabShape const &, const KisPaintInformation &info, qreal softnessFactor, QRect *dstDabRect, qreal lightnessStrength=1.0)
KisFixedPaintDeviceSP	fetchDab (const KoColorSpace *cs, KisColorSource *colorSource, const QPointF &cursorPoint, KisDabShape const &, const KisPaintInformation &info, qreal softnessFactor, QRect *dstDabRect, qreal lightnessStrength=1.0)
KisFixedPaintDeviceSP	fetchNormalizedImageDab (const KoColorSpace *cs, const QPointF &cursorPoint, KisDabShape const &shape, const KisPaintInformation &info, qreal softnessFactor, QRect *dstDabRect)
	KisDabCache (KisBrushSP brush)
bool	needSeparateOriginal () const
void	setSharpnessPostprocessing (KisSharpnessOption *option)
void	setTexturePostprocessing (KisTextureOption *option)
	~KisDabCache ()
Public Member Functions inherited from KisDabCacheBase
void	disableSubpixelPrecision ()
	KisDabCacheBase ()
bool	needSeparateOriginal (KisTextureOption *textureOption, KisSharpnessOption *sharpnessOption) const
void	setMirrorPostprocessing (KisMirrorOption *option)
void	setPrecisionOption (KisPrecisionOption *option)
	~KisDabCacheBase ()

Private Member Functions
KisFixedPaintDeviceSP	fetchDabCommon (const KoColorSpace *cs, KisColorSource *colorSource, const KoColor &color, const QPointF &cursorPoint, KisDabShape, const KisPaintInformation &info, qreal softnessFactor, QRect *dstDabRect, qreal lightnessStrength=1.0, bool forceNormalizedRGBAImageStamp=false)
KisFixedPaintDeviceSP	fetchFromCache (KisDabCacheUtils::DabRenderingResources *resources, const KisPaintInformation &info, QRect *dstDabRect)

Private Attributes
Private *const	m_d

Additional Inherited Members
Protected Member Functions inherited from KisDabCacheBase
void	fetchDabGenerationInfo (bool hasDabInCache, KisDabCacheUtils::DabRenderingResources *resources, const KisDabCacheUtils::DabRequestInfo &request, KisDabCacheUtils::DabGenerationInfo *di, bool *shouldUseCache)

Detailed Description

The KisDabCache 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 41 of file kis_dab_cache.h.

Constructor & Destructor Documentation

KisDabCache()

KisDabCache::KisDabCache

(

KisBrushSP

brush

)

Definition at line 39 of file kis_dab_cache.cpp.

    : m_d(new Private(brush))
{
}

~KisDabCache()

KisDabCache::~KisDabCache

(

)

Definition at line 44 of file kis_dab_cache.cpp.

{
    delete m_d;
}

References m_d.

Member Function Documentation

fetchDab() [1/2]

KisFixedPaintDeviceSP KisDabCache::fetchDab	(	const KoColorSpace *	cs,
		const KoColor &	color,
		const QPointF &	cursorPoint,
		KisDabShape const &	shape,
		const KisPaintInformation &	info,
		qreal	softnessFactor,
		QRect *	dstDabRect,
		qreal	lightnessStrength = 1.0 )

Definition at line 85 of file kis_dab_cache.cpp.

{
    return fetchDabCommon(cs, 0, color,
                          cursorPoint,
                          shape,
                          info,
                          softnessFactor,
                          dstDabRect,
                          lightnessStrength);
}

References fetchDabCommon().

fetchDab() [2/2]

KisFixedPaintDeviceSP KisDabCache::fetchDab	(	const KoColorSpace *	cs,
		KisColorSource *	colorSource,
		const QPointF &	cursorPoint,
		KisDabShape const &	shape,
		const KisPaintInformation &	info,
		qreal	softnessFactor,
		QRect *	dstDabRect,
		qreal	lightnessStrength = 1.0 )

Definition at line 65 of file kis_dab_cache.cpp.

{
    //Q_UNUSED(lightnessStrength);
 
    return fetchDabCommon(cs, colorSource, KoColor(),
                          cursorPoint,
                          shape,
                          info,
                          softnessFactor,
                          dstDabRect,
                          lightnessStrength);
}

References fetchDabCommon().

fetchDabCommon()

KisFixedPaintDeviceSP KisDabCache::fetchDabCommon ( const KoColorSpace * cs, KisColorSource * colorSource, const KoColor & color, const QPointF & cursorPoint, KisDabShape shape, const KisPaintInformation & info, qreal softnessFactor, QRect * dstDabRect, qreal lightnessStrength = 1.0, bool forceNormalizedRGBAImageStamp = false )

inlineprivate

Definition at line 153 of file kis_dab_cache.cpp.

{
    Q_ASSERT(dstDabRect);
    //Q_UNUSED(lightnessStrength);
 
    bool hasDabInCache = true;
 
    if (!m_d->dab || *m_d->dab->colorSpace() != *cs) {
        m_d->dab = new KisFixedPaintDevice(cs);
        hasDabInCache = false;
    }
 
    using namespace KisDabCacheUtils;
 
    // 0. Notify brush that we ar going to paint a new dab
 
    m_d->brush->prepareForSeqNo(info, m_d->seqNo);
    m_d->seqNo++;
 
    // 1. Calculate new dab parameters and whether we can reuse the cache
 
    TemporaryResourcesWithoutOwning resources;
    resources.brush = m_d->brush;
    resources.colorSourceDevice = m_d->colorSourceDevice;
 
    // NOTE: we use a special subclass of resources that will NOT
    //       delete options on destruction!
    resources.colorSource.reset(colorSource);
    resources.sharpnessOption.reset(m_d->sharpnessOption);
    resources.textureOption.reset(m_d->textureOption);
 
 
    DabGenerationInfo di;
    bool shouldUseCache = false;
 
    fetchDabGenerationInfo(hasDabInCache,
                           &resources,
                           DabRequestInfo(
                               color,
                               cursorPoint,
                               shape,
                               info,
                               softnessFactor,
                               lightnessStrength),
                           &di,
                           &shouldUseCache);
 
    *dstDabRect = di.dstDabRect;
 
 
    // 2. Try return a saved dab from the cache
 
    if (shouldUseCache) {
        return fetchFromCache(&resources, info, dstDabRect);
    }
 
    // 3. Generate new dab
 
    generateDab(di, &resources, &m_d->dab, forceNormalizedRGBAImageStamp);
 
    // 4. Do postprocessing
    if (di.needsPostprocessing) {
        if (!m_d->dabOriginal || *cs != *m_d->dabOriginal->colorSpace()) {
            m_d->dabOriginal = new KisFixedPaintDevice(cs);
        }
 
        *m_d->dabOriginal = *m_d->dab;
 
        postProcessDab(m_d->dab, di.dstDabRect.topLeft(), info, &resources);
    }
 
    return m_d->dab;
}

References KisDabCache::Private::brush, KisDabCacheUtils::DabRenderingResources::brush, KisDabCacheUtils::DabRenderingResources::colorSource, KisDabCache::Private::colorSourceDevice, KisDabCacheUtils::DabRenderingResources::colorSourceDevice, KisFixedPaintDevice::colorSpace(), KisDabCache::Private::dab, KisDabCache::Private::dabOriginal, KisDabCacheUtils::DabGenerationInfo::dstDabRect, KisDabCacheBase::fetchDabGenerationInfo(), fetchFromCache(), m_d, KisDabCacheUtils::DabGenerationInfo::needsPostprocessing, KisDabCache::Private::seqNo, KisDabCache::Private::sharpnessOption, KisDabCacheUtils::DabRenderingResources::sharpnessOption, KisDabCache::Private::textureOption, and KisDabCacheUtils::DabRenderingResources::textureOption.

fetchFromCache()

KisFixedPaintDeviceSP KisDabCache::fetchFromCache ( KisDabCacheUtils::DabRenderingResources * resources, const KisPaintInformation & info, QRect * dstDabRect )

inlineprivate

Definition at line 121 of file kis_dab_cache.cpp.

{
    if (needSeparateOriginal()) {
        *m_d->dab = *m_d->dabOriginal;
        *dstDabRect = KisDabCacheUtils::correctDabRectWhenFetchedFromCache(*dstDabRect, m_d->dab->bounds().size());
        KisDabCacheUtils::postProcessDab(m_d->dab, dstDabRect->topLeft(), info, resources);
    }
    else {
        *dstDabRect = KisDabCacheUtils::correctDabRectWhenFetchedFromCache(*dstDabRect, m_d->dab->bounds().size());
    }
 
    return m_d->dab;
}

References KisFixedPaintDevice::bounds(), KisDabCacheUtils::correctDabRectWhenFetchedFromCache(), KisDabCache::Private::dab, KisDabCache::Private::dabOriginal, m_d, needSeparateOriginal(), and KisDabCacheUtils::postProcessDab().

fetchNormalizedImageDab()

KisFixedPaintDeviceSP KisDabCache::fetchNormalizedImageDab	(	const KoColorSpace *	cs,
		const QPointF &	cursorPoint,
		KisDabShape const &	shape,
		const KisPaintInformation &	info,
		qreal	softnessFactor,
		QRect *	dstDabRect )

Definition at line 103 of file kis_dab_cache.cpp.

{
    return fetchDabCommon(cs, 0, KoColor(),
                          cursorPoint,
                          shape,
                          info,
                          softnessFactor,
                          dstDabRect,
                          1.0,
                          true);
}

References fetchDabCommon().

needSeparateOriginal()

bool KisDabCache::needSeparateOriginal

(

)

const

Definition at line 59 of file kis_dab_cache.cpp.

{
    return KisDabCacheBase::needSeparateOriginal(m_d->textureOption, m_d->sharpnessOption);
}

References m_d, KisDabCacheBase::needSeparateOriginal(), KisDabCache::Private::sharpnessOption, and KisDabCache::Private::textureOption.

setSharpnessPostprocessing()

void KisDabCache::setSharpnessPostprocessing

(

KisSharpnessOption *

option

)

Definition at line 49 of file kis_dab_cache.cpp.

{
    m_d->sharpnessOption = option;
}

References m_d, and KisDabCache::Private::sharpnessOption.

setTexturePostprocessing()

void KisDabCache::setTexturePostprocessing

(

KisTextureOption *

option

)

Definition at line 54 of file kis_dab_cache.cpp.

{
    m_d->textureOption = option;
}

References m_d, and KisDabCache::Private::textureOption.

Member Data Documentation

m_d

Private* const KisDabCache::m_d

private

Definition at line 97 of file kis_dab_cache.h.

---

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

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