ParticleBrush Class Reference

#include <particle_brush.h>

Public Member Functions
void	draw (KisPaintDeviceSP dab, const KoColor &color, const QPointF &pos)
void	initParticles ()
	ParticleBrush ()
void	setInitialPosition (const QPointF &pos)
void	setProperties (KisParticleOpOptionData *properties)
	~ParticleBrush ()

Private Member Functions
void	paintParticle (KisRandomAccessorSP writeAccessor, const KoColorSpace *cs, const QPointF &pos, const KoColor &color, qreal weight, bool respectOpacity)

Private Attributes
QVector< qreal >	m_acceleration
QVector< QPointF >	m_particleNextPos
QVector< QPointF >	m_particlePos
KisParticleOpOptionData *	m_properties

Detailed Description

Definition at line 32 of file particle_brush.h.

Constructor & Destructor Documentation

ParticleBrush()

ParticleBrush::ParticleBrush

(

)

Definition at line 21 of file particle_brush.cpp.

{
    m_properties = 0;
}

References m_properties.

~ParticleBrush()

ParticleBrush::~ParticleBrush

(

)

Definition at line 26 of file particle_brush.cpp.

{
}

Member Function Documentation

draw()

void ParticleBrush::draw	(	KisPaintDeviceSP	dab,
		const KoColor &	color,
		const QPointF &	pos )

When the scale is negative the equation becomes unstable, and the point coordinates grow to infinity, so just limit them in that case.

Generally, the effect of instability might be quite interesting for the painters.

Definition at line 84 of file particle_brush.cpp.

{
    KisRandomAccessorSP accessor = dab->createRandomAccessorNG();
    const KoColorSpace * cs = dab->colorSpace();
 
    QRect boundingRect;
 
    if (m_properties->particleScaleX < 0 || m_properties->particleScaleY < 0 || m_properties->particleGravity < 0) {
        boundingRect = dab->defaultBounds()->bounds();
    }
 
    for (int i = 0; i < m_properties->particleIterations; i++) {
        for (int j = 0; j < m_properties->particleCount; j++) {
            /*
                m_time = 0.01;
                QPointF temp = m_position;
                QPointF dist = m_position - m_oldPosition;
                m_position = m_position + (dist + (m_acceleration*m_time*m_time));
                m_oldPosition = temp;
            */
 
            /*
                QPointF dist = info.pos() - m_position;
                dist *= 0.3; // scale
                dist *= 10; // force
                m_oldPosition += dist;
                m_oldPosition *= 0.989;
                m_position = m_position + m_oldPosition * m_time * m_time;
            */
 
 
            QPointF dist = pos - m_particlePos[j];
            dist.setX(dist.x() * m_properties->particleScaleX);
            dist.setY(dist.y() * m_properties->particleScaleY);
            dist = dist * m_acceleration[j];
            m_particleNextPos[j] = m_particleNextPos[j] + dist;
            m_particleNextPos[j] *= m_properties->particleGravity;
            m_particlePos[j] = m_particlePos[j] + (m_particleNextPos[j] * TIME);
 
            // If scale is negative, position can easily jump into infinity
            //  and then it won't be caught by contains();
            //  and then it will be passed to the lockless hashtable
            //  and then it will crash.
            // Hence better to catch infinity here and just not paint anything.
            QPointF pointF = m_particlePos[j];
 
            const qint32 max = 2147483600;
            const qint32 min = -max;
            bool nearInfinity = pointF.x() < min || pointF.x () > max || pointF.y() < min || pointF.y() > max;
            bool inside = boundingRect.contains(m_particlePos[j].toPoint());
 
            if (boundingRect.isEmpty() || (inside && !nearInfinity)) {
                paintParticle(accessor, cs, m_particlePos[j], color, m_properties->particleWeight, true);
            }
 
        }//for j
    }//for i
}

References KisDefaultBoundsBase::bounds(), KisPaintDevice::colorSpace(), KisPaintDevice::createRandomAccessorNG(), KisPaintDevice::defaultBounds(), m_acceleration, m_particleNextPos, m_particlePos, m_properties, paintParticle(), KisParticleOpOptionData::particleCount, KisParticleOpOptionData::particleGravity, KisParticleOpOptionData::particleIterations, KisParticleOpOptionData::particleScaleX, KisParticleOpOptionData::particleScaleY, KisParticleOpOptionData::particleWeight, and TIME.

initParticles()

void ParticleBrush::initParticles

(

)

Definition at line 31 of file particle_brush.cpp.

{
    m_particlePos.resize(m_properties->particleCount);
    m_particleNextPos.resize(m_properties->particleCount);
    m_acceleration.resize(m_properties->particleCount);
}

References m_acceleration, m_particleNextPos, m_particlePos, m_properties, and KisParticleOpOptionData::particleCount.

paintParticle()

void ParticleBrush::paintParticle ( KisRandomAccessorSP writeAccessor, const KoColorSpace * cs, const QPointF & pos, const KoColor & color, qreal weight, bool respectOpacity )

private

paints wu particle, similar to spray version but you can turn on respecting opacity of the tool and add weight to opacity also the particle respects opacity in the destination pixel buffer

Definition at line 48 of file particle_brush.cpp.

{
    // opacity top left, right, bottom left, right
    KoColor myColor(color);
    quint8 opacity = respectOpacity ? myColor.opacityU8() : OPACITY_OPAQUE_U8;
 
    int ipx = floor(pos.x());
    int ipy = floor(pos.y());
    qreal fx = pos.x() - ipx;
    qreal fy = pos.y() - ipy;
 
    quint8 btl = qRound((1.0 - fx) * (1.0 - fy) * opacity * weight);
    quint8 btr = qRound((fx)  * (1.0 - fy) * opacity * weight);
    quint8 bbl = qRound((1.0 - fx) * (fy)  * opacity * weight);
    quint8 bbr = qRound((fx)  * (fy)  * opacity * weight);
 
    accWrite->moveTo(ipx  , ipy);
    myColor.setOpacity(quint8(kisBoundFast<quint16>(OPACITY_TRANSPARENT_U8, btl + cs->opacityU8(accWrite->rawData()), OPACITY_OPAQUE_U8)));
    memcpy(accWrite->rawData(), myColor.data(), cs->pixelSize());
 
    accWrite->moveTo(ipx + 1, ipy);
    myColor.setOpacity(quint8(kisBoundFast<quint16>(OPACITY_TRANSPARENT_U8, btr + cs->opacityU8(accWrite->rawData()), OPACITY_OPAQUE_U8)));
    memcpy(accWrite->rawData(), myColor.data(), cs->pixelSize());
 
    accWrite->moveTo(ipx, ipy + 1);
    myColor.setOpacity(quint8(kisBoundFast<quint16>(OPACITY_TRANSPARENT_U8, bbl + cs->opacityU8(accWrite->rawData()), OPACITY_OPAQUE_U8)));
    memcpy(accWrite->rawData(), myColor.data(), cs->pixelSize());
 
    accWrite->moveTo(ipx + 1, ipy + 1);
    myColor.setOpacity(quint8(kisBoundFast<quint16>(OPACITY_TRANSPARENT_U8, bbr + cs->opacityU8(accWrite->rawData()), OPACITY_OPAQUE_U8)));
    memcpy(accWrite->rawData(), myColor.data(), cs->pixelSize());
}

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

setInitialPosition()

void ParticleBrush::setInitialPosition

(

const QPointF &

pos

)

Definition at line 38 of file particle_brush.cpp.

{
    for (int i = 0; i < m_properties->particleCount; i++) {
        m_particlePos[i] = pos;
        m_particleNextPos[i] = pos;
        m_acceleration[i] = (i + m_properties->particleIterations) * 0.5;
    }
}

References m_acceleration, m_particleNextPos, m_particlePos, m_properties, KisParticleOpOptionData::particleCount, and KisParticleOpOptionData::particleIterations.

setProperties()

void ParticleBrush::setProperties ( KisParticleOpOptionData * properties )

inline

Definition at line 43 of file particle_brush.h.

                                                             {
        m_properties = properties;
    }

References m_properties.

Member Data Documentation

m_acceleration

QVector<qreal> ParticleBrush::m_acceleration

private

Definition at line 54 of file particle_brush.h.

m_particleNextPos

QVector<QPointF> ParticleBrush::m_particleNextPos

private

Definition at line 53 of file particle_brush.h.

m_particlePos

QVector<QPointF> ParticleBrush::m_particlePos

private

Definition at line 52 of file particle_brush.h.

m_properties

KisParticleOpOptionData* ParticleBrush::m_properties

private

Definition at line 56 of file particle_brush.h.

---

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

• plugins/paintops/particle/particle_brush.h
• plugins/paintops/particle/particle_brush.cpp