#include <kis_brush_mask_scalar_applicator.h>

Inheritance diagram for KisBrushMaskScalarApplicator< MaskGenerator, impl >:

Public Member Functions
	KisBrushMaskScalarApplicator (MaskGenerator *maskGenerator)

void	process (const QRect &rect) override

Public Member Functions inherited from KisBrushMaskApplicatorBase
void	initializeData (const MaskProcessingData *data)

virtual	~KisBrushMaskApplicatorBase ()=default

Protected Member Functions
void	processScalar (const QRect &rect)

Protected Attributes
MaskGenerator *	m_maskGenerator

KisRandomSource	m_randomSource

Protected Attributes inherited from KisBrushMaskApplicatorBase
const MaskProcessingData *	m_d = nullptr

Detailed Description

template<class MaskGenerator, typename impl>
struct KisBrushMaskScalarApplicator< MaskGenerator, impl >

Definition at line 17 of file kis_brush_mask_scalar_applicator.h.

Constructor & Destructor Documentation

◆ KisBrushMaskScalarApplicator()

template<class MaskGenerator , typename impl >

KisBrushMaskScalarApplicator< MaskGenerator, impl >::KisBrushMaskScalarApplicator ( MaskGenerator * maskGenerator )

inline

Definition at line 18 of file kis_brush_mask_scalar_applicator.h.

        : m_maskGenerator(maskGenerator)
    {
    }

Member Function Documentation

◆ process()

template<class MaskGenerator , typename impl >

void KisBrushMaskScalarApplicator< MaskGenerator, impl >::process ( const QRect & rect )

inlineoverridevirtual

Implements KisBrushMaskApplicatorBase.

Definition at line 23 of file kis_brush_mask_scalar_applicator.h.

    {
        processScalar(rect);
    }

References KisBrushMaskScalarApplicator< MaskGenerator, impl >::processScalar().

◆ processScalar()

template<class MaskGenerator , typename impl >

void KisBrushMaskScalarApplicator< MaskGenerator, impl >::processScalar ( const QRect & rect )

inlineprotected

Definition at line 29 of file kis_brush_mask_scalar_applicator.h.

    {
        const MaskProcessingData *m_d = KisBrushMaskApplicatorBase::m_d;
        MaskGenerator *m_maskGenerator = KisBrushMaskScalarApplicator<MaskGenerator, impl>::m_maskGenerator;
 
        qreal random = 1.0;
        quint8 *dabPointer = m_d->device->data() + rect.y() * rect.width() * m_d->pixelSize;
        quint8 alphaValue = OPACITY_TRANSPARENT_U8;
        // this offset is needed when brush size is smaller then fixed device size
        int offset = (m_d->device->bounds().width() - rect.width()) * m_d->pixelSize;
        int supersample = 1;
        if (m_maskGenerator->shouldSupersample()) {
            // strengthen supersampling from 3x3 for very small dabs, to smooth out dashed strokes
            supersample = (m_maskGenerator->shouldSupersample6x6() ? 6 : 3);
        }
        double invss = 1.0 / supersample;
        int samplearea = pow2(supersample);
        for (int y = rect.y(); y < rect.y() + rect.height(); y++) {
            for (int x = rect.x(); x < rect.x() + rect.width(); x++) {
                int value = 0;
                for (int sy = 0; sy < supersample; sy++) {
                    for (int sx = 0; sx < supersample; sx++) {
                        double x_ = x + sx * invss - m_d->centerX;
                        double y_ = y + sy * invss - m_d->centerY;
                        double maskX = m_d->cosa * x_ - m_d->sina * y_;
                        double maskY = m_d->sina * x_ + m_d->cosa * y_;
                        value += m_maskGenerator->valueAt(maskX, maskY);
                    }
                }
                if (supersample != 1)
                    value /= samplearea;
 
                if (m_d->randomness != 0.0) {
                    random = (1.0 - m_d->randomness) + m_d->randomness * m_randomSource.generateNormalized();
                }
 
                alphaValue = quint8((OPACITY_OPAQUE_U8 - value) * random);
 
                // avoid computation of random numbers if density is full
                if (m_d->density != 1.0) {
                    // compute density only for visible pixels of the mask
                    if (alphaValue != OPACITY_TRANSPARENT_U8) {
                        if (!(m_d->density >= m_randomSource.generateNormalized())) {
                            alphaValue = OPACITY_TRANSPARENT_U8;
                        }
                    }
                }
 
                if (m_d->color) {
                    memcpy(dabPointer, m_d->color, static_cast<size_t>(m_d->pixelSize));
                }
 
                m_d->colorSpace->applyAlphaU8Mask(dabPointer, &alphaValue, 1);
                dabPointer += m_d->pixelSize;
            } // endfor x
            dabPointer += offset;
        } // endfor y
    }