omni::BlendBrush Class Reference

BlendBrush for drawing on the blendmask Holds an internal pixel buffer. More...

#include <BlendBrush.h>

Collaboration diagram for omni::BlendBrush:

Public Member Functions
	BlendBrush ()
	Default constructor. More...
	BlendBrush (QVector2D const &_size, float _feather=1.0)
	Constructor with a size and feather value (1.0 by default) Updates internal pixel buffer. More...
QVector2D const &	size () const
	Returns brush size. More...
void	setSize (QVector2D const &_size)
	Sets size of the brush. Minimum size is 2 pixels, maximum size is 512 pixels. More...
void	changeSize (QVector2D const &_delta)
	Increase/Decrease size of the brush with a certain delta value Minimum size is 2 pixels, maximum size is 512 pixels. More...
float	feather () const
	Return feather value. More...
float	opacity () const
	Return opacity value. More...
void	setOpacity (float _opacity)
	Set opacity value Value must be between 0.0 and 1.0 and is clamped if necessary. A value 0.0 means a hard brush, a value of 1.0 means soft brush. More...
void	setFeather (float _feather)
	Set feather value Value must be between 0.0 and 1.0 and is clamped if necessary. A value 0.0 means a hard brush, a value of 1.0 means soft brush. More...
bool	invert () const
	Returns true if the brush is inverted (aka eraser mode) More...
void	setInvert (bool _invert)
	Sets inverted flag of the brush. More...
void	setBrush (QVector2D const &_size, float _feather, float _opacity, bool _invert)
	Set brush settings and generate pixel buffer. More...
void	stamp (const QPointF &_pos, Buffer< uint8_t > &_buf) const
	Draws internal pixel buffer in given blend buffer. More...
float	drawLine (const QPointF &_p0, const QPointF &_p1, Buffer< uint8_t > &_buf, float _leftOver=0.0)
	Draws a lot from point _p0 to _p1 on given pixel buffer. More...
Buffer< float > const &	buffer () const
void	toStream (QDataStream &) const
	Write blend brush to stream. More...
void	fromStream (QDataStream &)
	Read blend brush from stream. More...

Private Member Functions
void	generate ()
	Generate internal pixel buffer with given size and feather parameters. More...

Static Private Member Functions
static QVector2D	clampBrushSize (QVector2D const &)
	Keep brush size within certain limits. More...

Private Attributes
Buffer< float >	buffer_
	Internal pixel buffer. More...
float	opacity_ = 1.0
QVector2D	size_
float	feather_ = 1.0
bool	invert_ = false

Friends
bool	operator== (BlendBrush const &, BlendBrush const &)
	Test for equality, buffer is ignored. More...

Detailed Description

BlendBrush for drawing on the blendmask Holds an internal pixel buffer.

Constructor & Destructor Documentation

omni::BlendBrush::BlendBrush

(

)

Default constructor.

                           : size_(100.0,100.0)
    {
        generate();
    }

omni::BlendBrush::BlendBrush	(	QVector2D const &	_size,
		float	_feather = 1.0
	)

Constructor with a size and feather value (1.0 by default) Updates internal pixel buffer.

                                                                 :
        size_(_size),
        feather_(_feather)
    {
        generate();
    }

Member Function Documentation

Buffer< float > const & omni::BlendBrush::buffer

(

)

const

    {
        return buffer_;
    }

void omni::BlendBrush::changeSize

(

QVector2D const &

_delta

)

Increase/Decrease size of the brush with a certain delta value Minimum size is 2 pixels, maximum size is 512 pixels.

    {
        setSize(size_ + _delta);
    }

QVector2D omni::BlendBrush::clampBrushSize ( QVector2D const &  _size )

staticprivate

Keep brush size within certain limits.

                                                               {
        float _aspect = _size.x() / _size.y();
        return QVector2D(
          qBound(30.0f,_size.x(),  400.0f),
          qBound(30.0f / _aspect,_size.y(),  400.0f / _aspect));
    }

float omni::BlendBrush::drawLine	(	const QPointF &	_p0,
		const QPointF &	_p1,
		Buffer< uint8_t > &	_buf,
		float	_leftOver = 0.0
	)

Draws a lot from point _p0 to _p1 on given pixel buffer.

Parameters

_p0	Start point
_p1	End point
_buf	Buffer to be drawn
_leftOver	Left over value to compensate positioning errors from previous moves

Returns

New left over value

    {
        float _spacing = size_.length() / 10.0;
        if (_spacing < 0.5) _spacing = 0.5;

        QVector2D _step(0.0, 0.0);

        // Calculate vector and distance
        QVector2D _delta(_p1 - _p0);
        float     _dist = _delta.length();

        float _invDist = 0.0;

        if (_dist > 0.0)
        {
            _invDist = 1.0 / _dist;
            _step   += _delta * _invDist;
        }

        // Draw line
        QVector2D _offset(0.0, 0.0);
        float     _totalDistance = _leftOver + _dist;

        while (_totalDistance >= _spacing)
        {
            if (_leftOver > 0)
            {
                _offset   += _step * (_spacing - _leftOver);
                _leftOver -= _spacing;
            }
            else
            {
                _offset += _step * _spacing;
            }

            // Draw stamp
            stamp(_p0 + _offset.toPointF(), _buf);

            _totalDistance -= _spacing;
        }

        return _totalDistance;
    }

float omni::BlendBrush::feather

(

)

const

Return feather value.

    {
        return feather_;
    }

void omni::BlendBrush::fromStream

(

QDataStream &

_is

)

Read blend brush from stream.

                                                {
        PropertyMap _map;
        _is >> _map;
        _map.get("size",    size_);
        _map.get("feather", feather_);
        _map.get("opacity", opacity_);
        _map.get("invert",  invert_);
        generate();
    }

void omni::BlendBrush::generate ( )

private

Generate internal pixel buffer with given size and feather parameters.

    {
        int _sizeX = std::max(int(size().x() + 1), 2);
        int _sizeY = std::max(int(size().y() + 1), 2);
        buffer_.resize(_sizeX, _sizeY);

        float _r = 0.49;
        float _innerRadius = _r - _r * feather();


        // For each pixel
        for (int y = 0; y < _sizeY; ++y)
            for (int x = 0; x < _sizeX; ++x)
            {
              QVector2D _pos(float(x) / _sizeX - 0.5, float(y) / _sizeY - 0.5);

                float _distance = _pos.length();

                // Pixel value
                float _v = ((_distance - _innerRadius) / (_r - _innerRadius)) *
                           opacity_ + 1.0 - opacity_;

                // Clamp and set pixel value
                buffer_(x, y) = qBound(0.0f, _v, 1.0f);
            }
    }

bool omni::BlendBrush::invert

(

)

const

Returns true if the brush is inverted (aka eraser mode)

    {
        return invert_;
    }

float omni::BlendBrush::opacity

(

)

const

Return opacity value.

                                    {
        return opacity_;
    }

void omni::BlendBrush::setBrush	(	QVector2D const &	_size,
		float	_feather,
		float	_opacity,
		bool	_invert
	)

Set brush settings and generate pixel buffer.

    {
        size_ = clampBrushSize(_size);

        feather_ = _feather;

        if (feather_ < 0.0) feather_ = 0.0;
        if (feather_ > 10.0) feather_ = 10.0;
        invert_ = _invert;

        if (opacity_ < 0.0) {
            opacity_ = 0.0;
        }

        if (opacity_ > 1.0) {
            opacity_ = 1.0;
        }
        opacity_ = _opacity;
        generate();
    }

void omni::BlendBrush::setFeather

(

float

_feather

)

Set feather value Value must be between 0.0 and 1.0 and is clamped if necessary. A value 0.0 means a hard brush, a value of 1.0 means soft brush.

    {
        feather_ = _feather;

        if (feather_ < 0.0) feather_ = 0.0;

        if (feather_ > 10.0) feather_ = 10.0;
        generate();
    }

void omni::BlendBrush::setInvert

(

bool

_invert

)

Sets inverted flag of the brush.

    {
        invert_ = _invert;
        generate();
    }

void omni::BlendBrush::setOpacity

(

float

_opacity

)

Set opacity value Value must be between 0.0 and 1.0 and is clamped if necessary. A value 0.0 means a hard brush, a value of 1.0 means soft brush.

                                              {
        opacity_ = _opacity;

        if (opacity_ < 0.0) {
            opacity_ = 0.0;
        }

        if (opacity_ > 1.0) {
            opacity_ = 1.0;
        }
        generate();
    }

void omni::BlendBrush::setSize

(

QVector2D const &

_size

)

Sets size of the brush. Minimum size is 2 pixels, maximum size is 512 pixels.

    {
        size_ = clampBrushSize(_size);
        generate();
    }

QVector2D const & omni::BlendBrush::size

(

)

const

Returns brush size.

    {
        return size_;
    }

void omni::BlendBrush::stamp	(	const QPointF &	_pos,
		Buffer< uint8_t > &	_buf
	)		const

Draws internal pixel buffer in given blend buffer.

    {
        int _sizeX = size().x();
        int _sizeY = size().y();
        QVector2D r     = size() * 0.5;

        int dx = _p.x() - r.x();
        int dy = _p.y() - r.y();

        for (int i = 0; i < _sizeX; ++i)
        {
            int _posx = int(i + dx);

            if ((_posx < 0) || (_posx >= _buf.width())) continue;

            for (int j = 0; j < _sizeY; ++j)
            {
                int _posy = int(j + dy);

                if ((_posy < 0) || (_posy >= _buf.height())) continue;

                auto  _v   = buffer_(i, j);
                auto& _pix = _buf(_posx, _posy);

                if (invert())
                {
                    _pix = _pix * _v;
                }
                else
                {
                    _pix = (255 - (255 - _buf(_posx, _posy)) * _v);
                }
            }
        }
    }

void omni::BlendBrush::toStream

(

QDataStream &

_os

)

const

Write blend brush to stream.

                                                    {
        PropertyMap _map;

        _map("size", size_)
            ("feather", feather_)
            ("opacity", opacity_)
            ("invert", invert_);
        _os << _map;
    }

Friends And Related Function Documentation

bool operator== ( BlendBrush const &  _lhs, BlendBrush const &  _rhs  )

friend

Test for equality, buffer is ignored.

    {
        return
            OMNI_TEST_MEMBER_EQUAL(size_) &&
            OMNI_TEST_MEMBER_EQUAL(feather_) &&
            OMNI_TEST_MEMBER_EQUAL(opacity_) &&
            OMNI_TEST_MEMBER_EQUAL(invert_);
    }

Field Documentation

Buffer<float> omni::BlendBrush::buffer_

private

Internal pixel buffer.

float omni::BlendBrush::feather_ = 1.0

private

bool omni::BlendBrush::invert_ = false

private

float omni::BlendBrush::opacity_ = 1.0

private

QVector2D omni::BlendBrush::size_

private

---

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

• include/omni/BlendBrush.h
• src/lib/BlendBrush.cpp