HairyBrush Class Reference

#include <hairy_brush.h>

Public Member Functions
void	fromDabWithDensity (KisFixedPaintDeviceSP dab, qreal density)
	set the shape of the bristles according the dab
	HairyBrush ()
void	paintLine (KisPaintDeviceSP dab, KisPaintDeviceSP layer, const KisPaintInformation &pi1, const KisPaintInformation &pi2, qreal scale, qreal rotation)
void	setInkColor (const KoColor &color)
	set ink color for the whole bristle shape
void	setProperties (KisHairyProperties *properties)
	set parameters for the brush engine
	~HairyBrush ()

Private Member Functions
void	addBristleInk (Bristle *bristle, const QPointF &pos, const KoColor &color)
	paints single bristle
void	colorifyBristles (KisPaintDeviceSP source, QPointF point)
	similar to sample input color in spray
double	computeMousePressure (double distance)
	compute mouse pressure according distance
void	darkenPixel (int wx, int wy, const KoColor &color)
	check the opacity of dab pixel and if the opacity is less than color, it will copy color to dab
qreal	fetchInkDepletion (Bristle *bristle, int inkDepletionSize)
	fetch actual ink status according depletion curve
bool	firstStroke () const
void	initAndCache ()
void	opacityDepletion (Bristle *bristle, KoColor &bristleColor, qreal pressure, qreal inkDepletion)
	simulate running out of ink through opacity decreasing
void	paintParticle (QPointF pos, const KoColor &color)
	paint wu particle using composite operation
void	paintParticle (QPointF pos, const KoColor &color, qreal weight)
	paint wu particle by copying the color and setup just the opacity, weight is complementary to opacity of the color
void	plotPixel (int wx, int wy, const KoColor &color)
	composite single pixel to dab
void	repositionBristles (double angle, double slope)
void	saturationDepletion (Bristle *bristle, KoColor &bristleColor, qreal pressure, qreal inkDepletion)
	simulate running out of saturation

Private Attributes
QVector< Bristle * >	m_bristles
KoColor	m_color
const KoCompositeOp *	m_compositeOp {nullptr}
int	m_counter {0}
KisPaintDeviceSP	m_dab
KisRandomAccessorSP	m_dabAccessor
double	m_lastAngle {0.0}
double	m_oldPressure {1.0}
QHash< QString, QVariant >	m_params
quint32	m_pixelSize {0}
const KisHairyProperties *	m_properties {nullptr}
int	m_saturationId {-1}
Trajectory	m_trajectory
KoColorTransformation *	m_transfo {nullptr}
QTransform	m_transform

Detailed Description

Definition at line 56 of file hairy_brush.h.

Constructor & Destructor Documentation

HairyBrush()

HairyBrush::HairyBrush

(

)

Definition at line 28 of file hairy_brush.cpp.

{
    m_counter = 0;
    m_lastAngle = 0.0;
    m_oldPressure = 1.0f;
 
    m_saturationId = -1;
}

References m_counter, m_lastAngle, m_oldPressure, and m_saturationId.

~HairyBrush()

HairyBrush::~HairyBrush

(

)

Definition at line 37 of file hairy_brush.cpp.

{
    delete m_transfo;
    qDeleteAll(m_bristles.begin(), m_bristles.end());
    m_bristles.clear();
}

References m_bristles, and m_transfo.

Member Function Documentation

addBristleInk()

void HairyBrush::addBristleInk ( Bristle * bristle, const QPointF & pos, const KoColor & color )

inlineprivate

paints single bristle

Definition at line 296 of file hairy_brush.cpp.

{
    Q_UNUSED(bristle);
    if (m_properties->antialias) {
        if (m_properties->useCompositing) {
            paintParticle(pos, color);
        } else {
            paintParticle(pos, color, 1.0);
        }
    }
    else {
        int ix = qRound(pos.x());
        int iy = qRound(pos.y());
        if (m_properties->useCompositing) {
            plotPixel(ix, iy, color);
        }
        else {
            darkenPixel(ix, iy, color);
        }
    }
}

References KisHairyProperties::antialias, darkenPixel(), m_properties, paintParticle(), plotPixel(), and KisHairyProperties::useCompositing.

colorifyBristles()

void HairyBrush::colorifyBristles ( KisPaintDeviceSP source, QPointF point )

private

similar to sample input color in spray

Definition at line 418 of file hairy_brush.cpp.

{
    KoColor bristleColor(m_dab->colorSpace());
    KisCrossDeviceColorSamplerInt colorSampler(source, bristleColor);
 
    Bristle *b = 0;
    int size = m_bristles.size();
    for (int i = 0; i < size; i++) {
        b = m_bristles[i];
        int x = qRound(b->x() + point.x());
        int y = qRound(b->y() + point.y());
 
        colorSampler.sampleOldColor(x, y, bristleColor.data());
        b->setColor(bristleColor);
    }
 
}

References KisPaintDevice::colorSpace(), KoColor::data(), m_bristles, m_dab, KisCrossDeviceColorSamplerImpl< Traits >::sampleOldColor(), and source().

computeMousePressure()

double HairyBrush::computeMousePressure ( double distance )

private

compute mouse pressure according distance

Definition at line 401 of file hairy_brush.cpp.

{
    static const double scale = 20.0;
    static const double minPressure = 0.02;
 
    double oldPressure = m_oldPressure;
 
    double factor = 1.0 - distance / scale;
    if (factor < 0.0) factor = 0.0;
 
    double result = ((4.0 * oldPressure) + minPressure + factor) / 5.0;
 
    m_oldPressure = result;
    return result;
}

References distance(), and m_oldPressure.

darkenPixel()

void HairyBrush::darkenPixel ( int wx, int wy, const KoColor & color )

inlineprivate

check the opacity of dab pixel and if the opacity is less than color, it will copy color to dab

Definition at line 393 of file hairy_brush.cpp.

{
    m_dabAccessor->moveTo(wx, wy);
    if (m_dab->colorSpace()->opacityU8(m_dabAccessor->rawData()) < color.opacityU8()) {
        memcpy(m_dabAccessor->rawData(), color.data(), m_pixelSize);
    }
}

References KisPaintDevice::colorSpace(), KoColor::data(), m_dab, m_dabAccessor, m_pixelSize, KisRandomConstAccessorNG::moveTo(), KoColor::opacityU8(), KoColorSpace::opacityU8(), and KisBaseAccessor::rawData().

fetchInkDepletion()

qreal HairyBrush::fetchInkDepletion ( Bristle * bristle, int inkDepletionSize )

inlineprivate

fetch actual ink status according depletion curve

Definition at line 239 of file hairy_brush.cpp.

{
    if (bristle->counter() >= inkDepletionSize - 1) {
        return m_properties->inkDepletionCurve[inkDepletionSize - 1];
    } else {
        return m_properties->inkDepletionCurve[bristle->counter()];
    }
}

References Bristle::counter(), KisHairyProperties::inkDepletionCurve, and m_properties.

firstStroke()

bool HairyBrush::firstStroke ( ) const

inlineprivate

Definition at line 127 of file hairy_brush.h.

                                    {
        return (m_counter == 1);
    }

References m_counter.

fromDabWithDensity()

void HairyBrush::fromDabWithDensity	(	KisFixedPaintDeviceSP	dab,
		qreal	density )

set the shape of the bristles according the dab

Definition at line 58 of file hairy_brush.cpp.

{
    int width = dab->bounds().width();
    int height = dab->bounds().height();
 
    int centerX = width * 0.5;
    int centerY = height * 0.5;
 
    // make mask
    Bristle * bristle = nullptr;
    qreal alpha;
 
    quint8 * dabPointer = dab->data();
    quint8 pixelSize = dab->pixelSize();
    const KoColorSpace * cs = dab->colorSpace();
    KoColor bristleColor(cs);
 
    KisRandomSource randomSource(0);
 
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            alpha =  cs->opacityF(dabPointer);
            if (alpha != 0.0) {
                if (density == 1.0 || randomSource.generateNormalized() <= density) {
                    memcpy(bristleColor.data(), dabPointer, pixelSize);
 
                    bristle = new Bristle(x - centerX, y - centerY, alpha); // using value from image as length of bristle
                    bristle->setColor(bristleColor);
 
                    m_bristles.append(bristle);
                }
            }
            dabPointer += pixelSize;
        }
    }
}

References KisFixedPaintDevice::bounds(), KisFixedPaintDevice::colorSpace(), KisFixedPaintDevice::data(), KoColor::data(), KisRandomSource::generateNormalized(), m_bristles, KoColorSpace::opacityF(), KisFixedPaintDevice::pixelSize(), and Bristle::setColor().

initAndCache()

void HairyBrush::initAndCache ( )

private

Definition at line 45 of file hairy_brush.cpp.

{
    m_compositeOp = m_dab->colorSpace()->compositeOp(COMPOSITE_OVER);
    m_pixelSize = m_dab->colorSpace()->pixelSize();
 
    if (m_properties->useSaturation) {
        m_transfo = m_dab->colorSpace()->createColorTransformation("hsv_adjustment", m_params);
        if (m_transfo) {
            m_saturationId = m_transfo->parameterId("s");
        }
    }
}

References KisPaintDevice::colorSpace(), COMPOSITE_OVER, KoColorSpace::compositeOp(), KoColorSpace::createColorTransformation(), m_compositeOp, m_dab, m_params, m_pixelSize, m_properties, m_saturationId, m_transfo, KoColorTransformation::parameterId(), KoColorSpace::pixelSize(), and KisHairyProperties::useSaturation.

opacityDepletion()

void HairyBrush::opacityDepletion ( Bristle * bristle, KoColor & bristleColor, qreal pressure, qreal inkDepletion )

private

simulate running out of ink through opacity decreasing

Definition at line 277 of file hairy_brush.cpp.

{
    qreal opacity = OPACITY_OPAQUE_F;
    if (m_properties->useWeights) {
        opacity = pressure * m_properties->pressureWeight +
                  bristle->length() * m_properties->bristleLengthWeight +
                  bristle->inkAmount() * m_properties->bristleInkAmountWeight +
                  (1.0 - inkDepletion) * m_properties->inkDepletionWeight;
    }
    else {
        opacity =
            bristle->length() *
            bristle->inkAmount();
    }
 
    opacity = kisBoundFast(0.0, opacity, 1.0);
    bristleColor.setOpacity(opacity);
}

References KisHairyProperties::bristleInkAmountWeight, KisHairyProperties::bristleLengthWeight, Bristle::inkAmount(), KisHairyProperties::inkDepletionWeight, kisBoundFast(), Bristle::length(), m_properties, OPACITY_OPAQUE_F, KisHairyProperties::pressureWeight, KoColor::setOpacity(), and KisHairyProperties::useWeights.

paintLine()

void HairyBrush::paintLine	(	KisPaintDeviceSP	dab,
		KisPaintDeviceSP	layer,
		const KisPaintInformation &	pi1,
		const KisPaintInformation &	pi2,
		qreal	scale,
		qreal	rotation )

Definition at line 96 of file hairy_brush.cpp.

{
    m_counter++;
 
    qreal x1 = pi1.pos().x();
    qreal y1 = pi1.pos().y();
 
    qreal x2 = pi2.pos().x();
    qreal y2 = pi2.pos().y();
 
    qreal dx = x2 - x1;
    qreal dy = y2 - y1;
 
    // TODO:this angle is different from the drawing angle in sensor (info.angle()). The bug is caused probably due to
    // not computing the drag vector properly in paintBezierLine when smoothing is used
    //qreal angle = atan2(dy, dx);
    qreal angle = rotation;
 
    qreal mousePressure = 1.0;
    if (m_properties->useMousePressure) { // want pressure from mouse movement
        qreal distance = sqrt(dx * dx + dy * dy);
        mousePressure = (1.0 - computeMousePressure(distance));
        scale *= mousePressure;
    }
    // this pressure controls shear and ink depletion
    qreal pressure = mousePressure * (pi2.pressure() * 2);
 
    Bristle *bristle = 0;
    KoColor bristleColor(dab->colorSpace());
 
    m_dabAccessor = dab->createRandomAccessorNG();
 
    m_dab = dab;
 
    // initialization block
    if (firstStroke()) {
        initAndCache();
    }
 
    /*If this is first time the brush touches the canvas and
    we are using soak ink while ink depletion is enabled...*/
    if (m_properties->inkDepletionEnabled &&
            firstStroke() && m_properties->useSoakInk) {
        if (layer) {
            colorifyBristles(layer, pi1.pos());
        }
        else {
            dbgKrita << "Can't soak the ink from the layer";
        }
    }
 
    KisRandomSourceSP randomSource = pi2.randomSource();
 
    qreal fx1, fy1, fx2, fy2;
    qreal randomX, randomY;
    qreal shear;
 
    float inkDepletion = 0.0;
    int inkDepletionSize = m_properties->inkDepletionCurve.size();
    int bristleCount = m_bristles.size();
    int bristlePathSize;
    qreal threshold = 1.0 - pi2.pressure();
    for (int i = 0; i < bristleCount; i++) {
 
        if (!m_bristles.at(i)->enabled()) continue;
        bristle = m_bristles[i];
 
        randomX = (randomSource->generateNormalized() * 2 - 1.0) * m_properties->randomFactor;
        randomY = (randomSource->generateNormalized() * 2 - 1.0) * m_properties->randomFactor;
 
        shear = pressure * m_properties->shearFactor;
 
        m_transform.reset();
        m_transform.rotateRadians(-angle);
        m_transform.scale(scale, scale);
        m_transform.translate(randomX, randomY);
        m_transform.shear(shear, shear);
 
        if (firstStroke() || (!m_properties->connectedPath)) {
            // transform start dab
            m_transform.map(bristle->x(), bristle->y(), &fx1, &fy1);
            // transform end dab
            m_transform.map(bristle->x(), bristle->y(), &fx2, &fy2);
        }
        else {
            // continue the path of the bristle from the previous position
            fx1 = bristle->prevX();
            fy1 = bristle->prevY();
            m_transform.map(bristle->x(), bristle->y(), &fx2, &fy2);
        }
        // remember the end point
        bristle->setPrevX(fx2);
        bristle->setPrevY(fy2);
 
        // all coords relative to device position
        fx1 += x1;
        fy1 += y1;
 
        fx2 += x2;
        fy2 += y2;
 
        if (m_properties->threshold && (bristle->length() < threshold)) continue;
        // paint between first and last dab
        const QVector<QPointF> bristlePath = m_trajectory.getLinearTrajectory(QPointF(fx1, fy1), QPointF(fx2, fy2), 1.0);
        bristlePathSize = m_trajectory.size();
 
        // avoid overlapping bristle caps with antialias on
        if (m_properties->antialias) {
            bristlePathSize -= 1;
        }
 
        memcpy(bristleColor.data(), bristle->color().data() , m_pixelSize);
        for (int i = 0; i < bristlePathSize ; i++) {
 
            if (m_properties->inkDepletionEnabled) {
                inkDepletion = fetchInkDepletion(bristle, inkDepletionSize);
 
                if (m_properties->useSaturation && m_transfo != 0) {
                    saturationDepletion(bristle, bristleColor, pressure, inkDepletion);
                }
 
                if (m_properties->useOpacity) {
                    opacityDepletion(bristle, bristleColor, pressure, inkDepletion);
                }
 
            }
            else {
                if (bristleColor.opacityU8() != 0) {
                    bristleColor.setOpacity(bristle->length());
                }
            }
 
            addBristleInk(bristle, bristlePath.at(i), bristleColor);
            bristle->setInkAmount(1.0 - inkDepletion);
            bristle->upIncrement();
        }
 
    }
    m_dab = nullptr;
    m_dabAccessor = nullptr;
}

References addBristleInk(), KisHairyProperties::antialias, colorifyBristles(), KisPaintDevice::colorSpace(), computeMousePressure(), KisHairyProperties::connectedPath, KisPaintDevice::createRandomAccessorNG(), KoColor::data(), dbgKrita, distance(), fetchInkDepletion(), firstStroke(), KisRandomSource::generateNormalized(), Trajectory::getLinearTrajectory(), initAndCache(), KisHairyProperties::inkDepletionCurve, KisHairyProperties::inkDepletionEnabled, m_bristles, m_counter, m_dab, m_dabAccessor, m_pixelSize, m_properties, m_trajectory, m_transfo, m_transform, opacityDepletion(), KoColor::opacityU8(), KisPaintInformation::pos(), KisPaintInformation::pressure(), KisHairyProperties::randomFactor, KisPaintInformation::randomSource(), saturationDepletion(), KoColor::setOpacity(), KisHairyProperties::shearFactor, Trajectory::size(), KisHairyProperties::threshold, KisHairyProperties::useMousePressure, KisHairyProperties::useOpacity, KisHairyProperties::useSaturation, and KisHairyProperties::useSoakInk.

paintParticle() [1/2]

void HairyBrush::paintParticle ( QPointF pos, const KoColor & color )

private

paint wu particle using composite operation

Definition at line 357 of file hairy_brush.cpp.

{
    // opacity top left, right, bottom left, right
    memcpy(m_color.data(), color.data(), m_pixelSize);
    quint8 opacity = color.opacityU8();
 
    int ipx = int (pos.x());
    int ipy = int (pos.y());
    qreal fx = qAbs(pos.x() - ipx);
    qreal fy = qAbs(pos.y() - ipy);
 
    quint8 btl = qRound((1.0 - fx) * (1.0 - fy) * opacity);
    quint8 btr = qRound((fx)  * (1.0 - fy) * opacity);
    quint8 bbl = qRound((1.0 - fx) * (fy)  * opacity);
    quint8 bbr = qRound((fx)  * (fy)  * opacity);
 
    m_color.setOpacity(btl);
    plotPixel(ipx  , ipy, m_color);
 
    m_color.setOpacity(btr);
    plotPixel(ipx + 1  , ipy, m_color);
 
    m_color.setOpacity(bbl);
    plotPixel(ipx  , ipy + 1, m_color);
 
    m_color.setOpacity(bbr);
    plotPixel(ipx + 1 , ipy + 1, m_color);
}

References KoColor::data(), m_color, m_pixelSize, KoColor::opacityU8(), plotPixel(), and KoColor::setOpacity().

paintParticle() [2/2]

void HairyBrush::paintParticle ( QPointF pos, const KoColor & color, qreal weight )

private

paint wu particle by copying the color and setup just the opacity, weight is complementary to opacity of the color

Definition at line 318 of file hairy_brush.cpp.

{
    // opacity top left, right, bottom left, right
    quint8 opacity = color.opacityU8();
    opacity *= weight;
 
    int ipx = int (pos.x());
    int ipy = int (pos.y());
    qreal fx = qAbs(pos.x() - ipx);
    qreal fy = qAbs(pos.y() - ipy);
 
    quint8 btl = qRound((1.0 - fx) * (1.0 - fy) * opacity);
    quint8 btr = qRound((fx)  * (1.0 - fy) * opacity);
    quint8 bbl = qRound((1.0 - fx) * (fy)  * opacity);
    quint8 bbr = qRound((fx)  * (fy)  * opacity);
 
    const KoColorSpace * cs = m_dab->colorSpace();
 
    m_dabAccessor->moveTo(ipx  , ipy);
    btl = quint8(kisBoundFast<quint16>(OPACITY_TRANSPARENT_U8, btl + cs->opacityU8(m_dabAccessor->rawData()), OPACITY_OPAQUE_U8));
    memcpy(m_dabAccessor->rawData(), color.data(), cs->pixelSize());
    cs->setOpacity(m_dabAccessor->rawData(), btl, 1);
 
    m_dabAccessor->moveTo(ipx + 1, ipy);
    btr =  quint8(kisBoundFast<quint16>(OPACITY_TRANSPARENT_U8, btr + cs->opacityU8(m_dabAccessor->rawData()), OPACITY_OPAQUE_U8));
    memcpy(m_dabAccessor->rawData(), color.data(), cs->pixelSize());
    cs->setOpacity(m_dabAccessor->rawData(), btr, 1);
 
    m_dabAccessor->moveTo(ipx, ipy + 1);
    bbl = quint8(kisBoundFast<quint16>(OPACITY_TRANSPARENT_U8, bbl + cs->opacityU8(m_dabAccessor->rawData()), OPACITY_OPAQUE_U8));
    memcpy(m_dabAccessor->rawData(), color.data(), cs->pixelSize());
    cs->setOpacity(m_dabAccessor->rawData(), bbl, 1);
 
    m_dabAccessor->moveTo(ipx + 1, ipy + 1);
    bbr = quint8(kisBoundFast<quint16>(OPACITY_TRANSPARENT_U8, bbr + cs->opacityU8(m_dabAccessor->rawData()), OPACITY_OPAQUE_U8));
    memcpy(m_dabAccessor->rawData(), color.data(), cs->pixelSize());
    cs->setOpacity(m_dabAccessor->rawData(), bbr, 1);
}

References KisPaintDevice::colorSpace(), KoColor::data(), m_dab, m_dabAccessor, KisRandomConstAccessorNG::moveTo(), OPACITY_OPAQUE_U8, OPACITY_TRANSPARENT_U8, KoColor::opacityU8(), KoColorSpace::opacityU8(), KoColorSpace::pixelSize(), KisBaseAccessor::rawData(), and KoColorSpace::setOpacity().

plotPixel()

void HairyBrush::plotPixel ( int wx, int wy, const KoColor & color )

inlineprivate

composite single pixel to dab

Definition at line 387 of file hairy_brush.cpp.

{
    m_dabAccessor->moveTo(wx, wy);
    m_compositeOp->composite(m_dabAccessor->rawData(), m_pixelSize, color.data() , m_pixelSize, 0, 0, 1, 1, OPACITY_OPAQUE_F);
}

References KoCompositeOp::composite(), KoColor::data(), m_compositeOp, m_dabAccessor, m_pixelSize, KisRandomConstAccessorNG::moveTo(), OPACITY_OPAQUE_F, and KisBaseAccessor::rawData().

repositionBristles()

void HairyBrush::repositionBristles ( double angle, double slope )

private

saturationDepletion()

void HairyBrush::saturationDepletion ( Bristle * bristle, KoColor & bristleColor, qreal pressure, qreal inkDepletion )

private

simulate running out of saturation

Definition at line 249 of file hairy_brush.cpp.

{
    qreal saturation;
    if (m_properties->useWeights) {
        // new weighted way (experiment)
        saturation = (
                         (pressure * m_properties->pressureWeight) +
                         (bristle->length() * m_properties->bristleLengthWeight) +
                         (bristle->inkAmount() * m_properties->bristleInkAmountWeight) +
                         ((1.0 - inkDepletion) * m_properties->inkDepletionWeight)) - 1.0;
    }
    else {
        // old way of computing saturation
        saturation = (
                         pressure *
                         bristle->length() *
                         bristle->inkAmount() *
                         (1.0 - inkDepletion)) - 1.0;
 
    }
    m_transfo->setParameter(m_transfo->parameterId("h"), 0.0);
    m_transfo->setParameter(m_transfo->parameterId("v"), 0.0);
    m_transfo->setParameter(m_saturationId, saturation);
    m_transfo->setParameter(3, 1);//sets the type to
    m_transfo->setParameter(4, false);//sets the colorize to none.
    m_transfo->transform(bristleColor.data(), bristleColor.data() , 1);
}

References KisHairyProperties::bristleInkAmountWeight, KisHairyProperties::bristleLengthWeight, KoColor::data(), Bristle::inkAmount(), KisHairyProperties::inkDepletionWeight, Bristle::length(), m_properties, m_saturationId, m_transfo, KoColorTransformation::parameterId(), KisHairyProperties::pressureWeight, KoColorTransformation::setParameter(), KoColorTransformation::transform(), and KisHairyProperties::useWeights.

setInkColor()

void HairyBrush::setInkColor ( const KoColor & color )

inline

set ink color for the whole bristle shape

Definition at line 65 of file hairy_brush.h.

                                           {
        m_color = color;
    }

References m_color.

setProperties()

void HairyBrush::setProperties ( KisHairyProperties * properties )

inline

set parameters for the brush engine

Definition at line 69 of file hairy_brush.h.

                                                        {
        m_properties = properties;
    }

References m_properties.

Member Data Documentation

m_bristles

QVector<Bristle*> HairyBrush::m_bristles

private

Definition at line 105 of file hairy_brush.h.

m_color

KoColor HairyBrush::m_color

private

Definition at line 121 of file hairy_brush.h.

m_compositeOp

const KoCompositeOp* HairyBrush::m_compositeOp {nullptr}

private

Definition at line 114 of file hairy_brush.h.

{nullptr};

m_counter

int HairyBrush::m_counter {0}

private

Definition at line 117 of file hairy_brush.h.

{0};

m_dab

KisPaintDeviceSP HairyBrush::m_dab

private

Definition at line 112 of file hairy_brush.h.

m_dabAccessor

KisRandomAccessorSP HairyBrush::m_dabAccessor

private

Definition at line 113 of file hairy_brush.h.

m_lastAngle

double HairyBrush::m_lastAngle {0.0}

private

Definition at line 119 of file hairy_brush.h.

{0.0};

m_oldPressure

double HairyBrush::m_oldPressure {1.0}

private

Definition at line 120 of file hairy_brush.h.

{1.0};

m_params

QHash<QString, QVariant> HairyBrush::m_params

private

Definition at line 110 of file hairy_brush.h.

m_pixelSize

quint32 HairyBrush::m_pixelSize {0}

private

Definition at line 115 of file hairy_brush.h.

{0};

m_properties

const KisHairyProperties* HairyBrush::m_properties {nullptr}

private

Definition at line 103 of file hairy_brush.h.

{nullptr};

m_saturationId

int HairyBrush::m_saturationId {-1}

private

Definition at line 123 of file hairy_brush.h.

{-1};

m_trajectory

Trajectory HairyBrush::m_trajectory

private

Definition at line 109 of file hairy_brush.h.

m_transfo

KoColorTransformation* HairyBrush::m_transfo {nullptr}

private

Definition at line 124 of file hairy_brush.h.

{nullptr};

m_transform

QTransform HairyBrush::m_transform

private

Definition at line 106 of file hairy_brush.h.

---

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

• plugins/paintops/hairy/hairy_brush.h
• plugins/paintops/hairy/hairy_brush.cpp