KisTextureOption Class Reference

#include <kis_texture_option.h>

Public Member Functions
void	apply (KisFixedPaintDeviceSP dab, const QPoint &offset, const KisPaintInformation &info)
	apply combine the texture map with the dab
bool	applyingGradient () const
	KisTextureOption (const KisPropertiesConfiguration *setting, KisResourcesInterfaceSP resourcesInterface, KoCanvasResourcesInterfaceSP canvasResourcesInterface, int levelOfDetail, KisBrushTextureFlags flags=None)

Static Public Member Functions
static bool	applyingGradient (const KisPropertiesConfiguration *settings)
static QList< KoResourceLoadResult >	prepareEmbeddedResources (const KisPropertiesConfigurationSP setting, KisResourcesInterfaceSP resourcesInterface)
static QList< KoResourceLoadResult >	prepareLinkedResources (const KisPropertiesConfigurationSP setting, KisResourcesInterfaceSP resourcesInterface)
static bool	requiresEffectiveCompositeOp (const KisPropertiesConfiguration *settings)

Public Attributes
bool	m_enabled {false}

Private Member Functions
void	applyGradient (KisFixedPaintDeviceSP dab, const QPoint &offset, const KisPaintInformation &info)
void	applyLightness (KisFixedPaintDeviceSP dab, const QPoint &offset, const KisPaintInformation &info)
int	effectiveOffsetX (const KisPaintInformation &info) const
int	effectiveOffsetY (const KisPaintInformation &info) const
void	fillProperties (const KisPropertiesConfiguration *setting, KisResourcesInterfaceSP resourcesInterface, KoCanvasResourcesInterfaceSP canvasResourcesInterface)

Private Attributes
KoCachedGradient	m_cachedGradient
KisCachedPaintDevice	m_cachedPaintDevice
KisBrushTextureFlags	m_flags
KoAbstractGradientSP	m_gradient
bool	m_isRandomOffsetX {false}
bool	m_isRandomOffsetY {false}
int	m_levelOfDetail {0}
KisTextureMaskInfoSP	m_maskInfo
int	m_offsetX {0}
int	m_offsetY {0}
KisStrengthOption	m_strengthOption
KisTextureOptionData::TexturingMode	m_texturingMode {KisTextureOptionData::MULTIPLY}
bool	m_useSoftTexturing {false}

Detailed Description

Definition at line 31 of file kis_texture_option.h.

Constructor & Destructor Documentation

KisTextureOption()

KisTextureOption::KisTextureOption	(	const KisPropertiesConfiguration *	setting,
		KisResourcesInterfaceSP	resourcesInterface,
		KoCanvasResourcesInterfaceSP	canvasResourcesInterface,
		int	levelOfDetail,
		KisBrushTextureFlags	flags = None )

Definition at line 44 of file kis_texture_option.cpp.

    : m_gradient(0)
    , m_levelOfDetail(levelOfDetail)
    , m_strengthOption(setting)
    , m_flags(flags)
{
    fillProperties(setting, resourcesInterface, canvasResourcesInterface);
}

References fillProperties().

Member Function Documentation

apply()

void KisTextureOption::apply	(	KisFixedPaintDeviceSP	dab,
		const QPoint &	offset,
		const KisPaintInformation &	info )

apply combine the texture map with the dab

Parameters

dab	the colored, final representation of the dab, after mirroring and everything.
offset	the position of the dab on the image. used to calculate the position of the mask pattern
info	the paint information

Definition at line 280 of file kis_texture_option.cpp.

{
    if (!m_enabled) return;
    if (!m_maskInfo->isValid()) return;
 
    if (m_texturingMode == KisTextureOptionData::LIGHTNESS) {
        applyLightness(dab, offset, info);
        return;
    }
    else if (m_texturingMode == KisTextureOptionData::GRADIENT && m_gradient) {
        applyGradient(dab, offset, info);
        return;
    }
 
    QRect rect = dab->bounds();
    KisPaintDeviceSP mask = m_maskInfo->mask();
    const QRect maskBounds = m_maskInfo->maskBounds();
 
    KisCachedPaintDevice::Guard g(mask, KoColorSpaceRegistry::instance()->alpha8(), m_cachedPaintDevice);
    KisPaintDeviceSP maskPatch = g.device();
 
    int x = offset.x() % maskBounds.width() - effectiveOffsetX(info);
    int y = offset.y() % maskBounds.height() - effectiveOffsetY(info);
 
    const QRect maskPatchRect = QRect(x, y, rect.width(), rect.height());
 
    KisFillPainter fillPainter(maskPatch);
    fillPainter.setCompositeOpId(COMPOSITE_COPY);
    fillPainter.fillRect(kisGrowRect(maskPatchRect, 1), mask, maskBounds);
    fillPainter.end();
 
    // Compute final strength
    qreal strength = m_strengthOption.apply(info);
 
    // Select mask compositing op
    KoChannelInfo::enumChannelValueType alphaChannelType = KoChannelInfo::UINT8;
    int alphaChannelOffset = -1;
 
    const QList<KoChannelInfo *> channels = dab->colorSpace()->channels();
    for (quint32 i = 0; i < dab->pixelSize(); i++) {
        if (channels[i]->channelType() == KoChannelInfo::ALPHA) {
            // TODO: check correctness for 16bits!
            alphaChannelOffset = channels[i]->pos()/* * channels[i]->size()*/;
            alphaChannelType = channels[i]->channelValueType();
            break;
        }
    }
 
    KIS_SAFE_ASSERT_RECOVER (alphaChannelOffset >= 0) {
        alphaChannelOffset = 0;
    }
 
    QScopedPointer<KisMaskingBrushCompositeOpBase> compositeOp;
    QString compositeOpId;
 
    switch (m_texturingMode) {
    case KisTextureOptionData::MULTIPLY: compositeOpId = COMPOSITE_MULT; break;
    case KisTextureOptionData::SUBTRACT: compositeOpId = COMPOSITE_SUBTRACT; break;
    case KisTextureOptionData::DARKEN: compositeOpId = COMPOSITE_DARKEN; break;
    case KisTextureOptionData::OVERLAY: compositeOpId = COMPOSITE_OVERLAY; break;
    case KisTextureOptionData::COLOR_DODGE: compositeOpId = COMPOSITE_DODGE; break;
    case KisTextureOptionData::COLOR_BURN: compositeOpId = COMPOSITE_BURN; break;
    case KisTextureOptionData::LINEAR_DODGE: compositeOpId = COMPOSITE_LINEAR_DODGE; break;
    case KisTextureOptionData::LINEAR_BURN: compositeOpId = COMPOSITE_LINEAR_BURN; break;
    case KisTextureOptionData::HARD_MIX_PHOTOSHOP: compositeOpId = COMPOSITE_HARD_MIX_PHOTOSHOP; break;
    case KisTextureOptionData::HARD_MIX_SOFTER_PHOTOSHOP: compositeOpId = COMPOSITE_HARD_MIX_SOFTER_PHOTOSHOP; break;
    case KisTextureOptionData::HEIGHT: compositeOpId = "height"; break;
    case KisTextureOptionData::LINEAR_HEIGHT: compositeOpId = "linear_height"; break;
    case KisTextureOptionData::HEIGHT_PHOTOSHOP: compositeOpId = "height_photoshop"; break;
    case KisTextureOptionData::LINEAR_HEIGHT_PHOTOSHOP: compositeOpId = "linear_height_photoshop"; break;
    default: return;
    }
    compositeOp.reset(KisMaskingBrushCompositeOpFactory::createForAlphaSrc(
                        compositeOpId, alphaChannelType, dab->pixelSize(),
                        alphaChannelOffset, strength, m_useSoftTexturing));
 
    // Apply the mask to the dab
    {
        quint8 *dabIt = nullptr;
        KisRandomConstAccessorSP maskPatchIt = maskPatch->createRandomConstAccessorNG();
 
        qint32 dabY = dab->bounds().y();
        qint32 maskPatchY = maskPatchRect.y();
        qint32 rowsRemaining = dab->bounds().height();
        const qint32 dabRowStride = dab->bounds().width() * dab->pixelSize();
 
        while (rowsRemaining > 0) {
            qint32 dabX = dab->bounds().x();
            qint32 maskPatchX = maskPatchRect.x();
            const qint32 numContiguousMaskPatchRows = maskPatchIt->numContiguousRows(maskPatchY);
            const qint32 rows = std::min(rowsRemaining, numContiguousMaskPatchRows);
            qint32 columnsRemaining = dab->bounds().width();
 
            while (columnsRemaining > 0) {
                const qint32 numContiguousMaskPatchColumns = maskPatchIt->numContiguousColumns(maskPatchX);
                const qint32 columns = std::min(columnsRemaining, numContiguousMaskPatchColumns);
 
                const qint32 maskPatchRowStride = maskPatchIt->rowStride(maskPatchX, maskPatchY);
 
                dabIt = dab->data() + (dabY * dab->bounds().width() + dabX) * dab->pixelSize();
                maskPatchIt->moveTo(maskPatchX, maskPatchY);
 
                compositeOp->composite(maskPatchIt->rawDataConst(), maskPatchRowStride,
                                       dabIt, dabRowStride,
                                       columns, rows);
 
                dabX += columns;
                maskPatchX += columns;
                columnsRemaining -= columns;
 
            }
 
            dabY += rows;
            maskPatchY += rows;
            rowsRemaining -= rows;
        }
    }
}

References KoChannelInfo::ALPHA, KisStandardOption< Data >::apply(), applyGradient(), applyLightness(), KisFixedPaintDevice::bounds(), KoColorSpace::channels, KisTextureOptionData::COLOR_BURN, KisTextureOptionData::COLOR_DODGE, KisFixedPaintDevice::colorSpace(), COMPOSITE_BURN, COMPOSITE_COPY, COMPOSITE_DARKEN, COMPOSITE_DODGE, COMPOSITE_HARD_MIX_PHOTOSHOP, COMPOSITE_HARD_MIX_SOFTER_PHOTOSHOP, COMPOSITE_LINEAR_BURN, COMPOSITE_LINEAR_DODGE, COMPOSITE_MULT, COMPOSITE_OVERLAY, COMPOSITE_SUBTRACT, KisMaskingBrushCompositeOpFactory::createForAlphaSrc(), KisPaintDevice::createRandomConstAccessorNG(), KisTextureOptionData::DARKEN, KisFixedPaintDevice::data(), KisCachedPaintDevice::Guard::device(), effectiveOffsetX(), effectiveOffsetY(), KisPainter::end(), KisFillPainter::fillRect(), KisTextureOptionData::GRADIENT, KisTextureOptionData::HARD_MIX_PHOTOSHOP, KisTextureOptionData::HARD_MIX_SOFTER_PHOTOSHOP, KisTextureOptionData::HEIGHT, KisTextureOptionData::HEIGHT_PHOTOSHOP, KoColorSpaceRegistry::instance(), KIS_SAFE_ASSERT_RECOVER, kisGrowRect(), KisTextureOptionData::LIGHTNESS, KisTextureOptionData::LINEAR_BURN, KisTextureOptionData::LINEAR_DODGE, KisTextureOptionData::LINEAR_HEIGHT, KisTextureOptionData::LINEAR_HEIGHT_PHOTOSHOP, m_cachedPaintDevice, m_enabled, m_gradient, m_maskInfo, m_strengthOption, m_texturingMode, m_useSoftTexturing, KisRandomConstAccessorNG::moveTo(), KisTextureOptionData::MULTIPLY, KisRandomConstAccessorNG::numContiguousColumns(), KisRandomConstAccessorNG::numContiguousRows(), KisTextureOptionData::OVERLAY, KisFixedPaintDevice::pixelSize(), KisBaseConstAccessor::rawDataConst(), KisRandomConstAccessorNG::rowStride(), KisPainter::setCompositeOpId(), KisTextureOptionData::SUBTRACT, and KoChannelInfo::UINT8.

applyGradient()

void KisTextureOption::applyGradient ( KisFixedPaintDeviceSP dab, const QPoint & offset, const KisPaintInformation & info )

private

Definition at line 224 of file kis_texture_option.cpp.

                                                                                                                     {
    if (!m_enabled) return;
    if (!m_maskInfo->isValid()) return;
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_gradient && m_gradient->valid());
 
    KisPaintDeviceSP mask = m_maskInfo->mask();
    const QRect maskBounds = m_maskInfo->maskBounds();
    QRect rect = dab->bounds();
 
    KisCachedPaintDevice::Guard g(mask, KoColorSpaceRegistry::instance()->rgb8(), m_cachedPaintDevice);
    KisPaintDeviceSP fillDevice = g.device();
 
    int x = offset.x() % maskBounds.width() - effectiveOffsetX(info);
    int y = offset.y() % maskBounds.height() - effectiveOffsetY(info);
 
    const QRect maskPatchRect = QRect(x, y, rect.width(), rect.height());
 
    KisFillPainter fillPainter(fillDevice);
    fillPainter.setCompositeOpId(COMPOSITE_COPY);
    fillPainter.fillRect(kisGrowRect(maskPatchRect, 1), mask, maskBounds);
    fillPainter.end();
 
    qreal pressure = m_strengthOption.apply(info);
    quint8* dabData = dab->data();
 
    //for gradient textures...
    KoMixColorsOp* colorMix = dab->colorSpace()->mixColorsOp();
    qint16 colorWeights[2];
    colorWeights[0] = qRound(pressure * 255);
    colorWeights[1] = 255 - colorWeights[0];
    quint8* colors[2];
    m_cachedGradient.setColorSpace(dab->colorSpace()); //Change colorspace here so we don't have to convert each pixel drawn
 
    KisHLineIteratorSP iter = fillDevice->createHLineIteratorNG(x, y, rect.width());
    for (int row = 0; row < rect.height(); ++row) {
        for (int col = 0; col < rect.width(); ++col) {
 
            const QRgb* maskQRgb = reinterpret_cast<const QRgb*>(iter->oldRawData());
            qreal gradientvalue = qreal(qGray(*maskQRgb))/255.0;//qreal(*iter->oldRawData()) / 255.0;
            KoColor paintcolor;
            paintcolor.setColor(m_cachedGradient.cachedAt(gradientvalue), dab->colorSpace());
            qreal paintOpacity = paintcolor.opacityF() * (qreal(qAlpha(*maskQRgb)) / 255.0);
            paintcolor.setOpacity(qMin(paintOpacity, dab->colorSpace()->opacityF(dabData)));
            colors[0] = paintcolor.data();
            KoColor dabColor(dabData, dab->colorSpace());
            colors[1] = dabColor.data();
            colorMix->mixColors(colors, colorWeights, 2, dabData);
 
            iter->nextPixel();
            dabData += dab->pixelSize();
        }
        iter->nextRow();
    }
}

References KisStandardOption< Data >::apply(), KisFixedPaintDevice::bounds(), KoCachedGradient::cachedAt(), KisFixedPaintDevice::colorSpace(), COMPOSITE_COPY, KisPaintDevice::createHLineIteratorNG(), KisFixedPaintDevice::data(), KoColor::data(), KisCachedPaintDevice::Guard::device(), effectiveOffsetX(), effectiveOffsetY(), KisPainter::end(), KisFillPainter::fillRect(), KoColorSpaceRegistry::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN, kisGrowRect(), m_cachedGradient, m_cachedPaintDevice, m_enabled, m_gradient, m_maskInfo, m_strengthOption, KoMixColorsOp::mixColors(), KoColorSpace::mixColorsOp, KoColor::opacityF(), KoColorSpace::opacityF(), KisFixedPaintDevice::pixelSize(), KoColor::setColor(), KoCachedGradient::setColorSpace(), KisPainter::setCompositeOpId(), and KoColor::setOpacity().

applyingGradient() [1/2]

bool KisTextureOption::applyingGradient

(

)

const

Definition at line 169 of file kis_texture_option.cpp.

{
    return m_texturingMode == KisTextureOptionData::GRADIENT;
}

References KisTextureOptionData::GRADIENT, and m_texturingMode.

applyingGradient() [2/2]

bool KisTextureOption::applyingGradient ( const KisPropertiesConfiguration * settings )

static

Definition at line 174 of file kis_texture_option.cpp.

{
    KisTextureOptionData data;
    data.read(settings);
 
    return data.texturingMode == KisTextureOptionData::GRADIENT;
}

References KisTextureOptionData::GRADIENT, KisTextureOptionData::read(), and KisTextureOptionData::texturingMode.

applyLightness()

void KisTextureOption::applyLightness ( KisFixedPaintDeviceSP dab, const QPoint & offset, const KisPaintInformation & info )

private

Definition at line 191 of file kis_texture_option.cpp.

                                                                                                                      {
    if (!m_enabled) return;
    if (!m_maskInfo->isValid()) return;
 
    KisPaintDeviceSP mask = m_maskInfo->mask();
 
    const QRect rect = dab->bounds();
    const QRect maskBounds = m_maskInfo->maskBounds();
 
    KisCachedPaintDevice::Guard g(mask, KoColorSpaceRegistry::instance()->rgb8(), m_cachedPaintDevice);
    KisPaintDeviceSP fillMaskDevice = g.device();
 
    int x = offset.x() % maskBounds.width() - effectiveOffsetX(info);
    int y = offset.y() % maskBounds.height() - effectiveOffsetY(info);
 
    const QRect maskPatchRect = QRect(x, y, rect.width(), rect.height());
 
    KisFillPainter fillMaskPainter(fillMaskDevice);
    fillMaskPainter.setCompositeOpId(COMPOSITE_COPY);
    fillMaskPainter.fillRect(kisGrowRect(maskPatchRect, 1), mask, maskBounds);
    fillMaskPainter.end();
 
    qreal pressure = m_strengthOption.apply(info);
    quint8* dabData = dab->data();
 
    KisSequentialConstIterator it(fillMaskDevice, QRect(x, y, rect.width(), rect.height()));
    while (it.nextPixel()) {
        const QRgb *maskQRgb = reinterpret_cast<const QRgb*>(it.oldRawData());
        dab->colorSpace()->fillGrayBrushWithColorAndLightnessWithStrength(dabData, maskQRgb, dabData, pressure, 1);
        dabData += dab->pixelSize();
    }
}

References KisStandardOption< Data >::apply(), KisFixedPaintDevice::bounds(), KisFixedPaintDevice::colorSpace(), COMPOSITE_COPY, KisFixedPaintDevice::data(), KisCachedPaintDevice::Guard::device(), effectiveOffsetX(), effectiveOffsetY(), KisPainter::end(), KoColorSpace::fillGrayBrushWithColorAndLightnessWithStrength(), KisFillPainter::fillRect(), KoColorSpaceRegistry::instance(), kisGrowRect(), m_cachedPaintDevice, m_enabled, m_maskInfo, m_strengthOption, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixel(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::oldRawData(), KisFixedPaintDevice::pixelSize(), and KisPainter::setCompositeOpId().

effectiveOffsetX()

int KisTextureOption::effectiveOffsetX ( const KisPaintInformation & info ) const

private

Definition at line 115 of file kis_texture_option.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_maskInfo, 0);
    return m_isRandomOffsetX ?
        info.perStrokeRandomSource()->generate("texture_offset_x", 0, m_maskInfo->maskBounds().width()) :
        m_offsetX;
}

References KisPerStrokeRandomSource::generate(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_isRandomOffsetX, m_maskInfo, m_offsetX, and KisPaintInformation::perStrokeRandomSource().

effectiveOffsetY()

int KisTextureOption::effectiveOffsetY ( const KisPaintInformation & info ) const

private

Definition at line 123 of file kis_texture_option.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_maskInfo, 0);
    return m_isRandomOffsetY ?
        info.perStrokeRandomSource()->generate("texture_offset_y", 0, m_maskInfo->maskBounds().height()) :
        m_offsetY;
}

References KisPerStrokeRandomSource::generate(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_isRandomOffsetY, m_maskInfo, m_offsetY, and KisPaintInformation::perStrokeRandomSource().

fillProperties()

void KisTextureOption::fillProperties ( const KisPropertiesConfiguration * setting, KisResourcesInterfaceSP resourcesInterface, KoCanvasResourcesInterfaceSP canvasResourcesInterface )

private

Definition at line 57 of file kis_texture_option.cpp.

{
    KisTextureOptionData data;
    data.read(setting);
 
    if (data.textureData.isNull()) {
        m_enabled = false;
        return;
    }
 
    m_texturingMode = data.texturingMode;
    m_useSoftTexturing = data.useSoftTexturing;
 
    if (!(m_flags & SupportsLightnessMode) && (m_texturingMode == KisTextureOptionData::LIGHTNESS)) {
        m_texturingMode = KisTextureOptionData::SUBTRACT;
    }
 
    if (!(m_flags & SupportsGradientMode) && (m_texturingMode == KisTextureOptionData::GRADIENT)) {
        m_texturingMode = KisTextureOptionData::SUBTRACT;
    }
 
    const bool preserveAlpha = m_texturingMode == KisTextureOptionData::LIGHTNESS || m_texturingMode == KisTextureOptionData::GRADIENT;
 
    QString effectiveCompositeOp = COMPOSITE_OVER;
    bool additionalInvert = false;
 
    if (canvasResourcesInterface && data.autoInvertOnErase) {
        effectiveCompositeOp = canvasResourcesInterface->resource(KoCanvasResource::CurrentEffectiveCompositeOp).toString();
        KIS_SAFE_ASSERT_RECOVER (!effectiveCompositeOp.isEmpty()) {
            effectiveCompositeOp = COMPOSITE_OVER;
        }
        additionalInvert = effectiveCompositeOp == COMPOSITE_ERASE;
    }
 
    m_maskInfo = toQShared(new KisTextureMaskInfo(m_levelOfDetail, preserveAlpha));
    if (!m_maskInfo->fillProperties(setting, resourcesInterface, additionalInvert)) {
        warnKrita << "WARNING: Couldn't load the pattern for a stroke (KisTextureProperties)";
        m_enabled = false;
        return;
    }
 
    m_maskInfo = KisTextureMaskInfoCache::instance()->fetchCachedTextureInfo(m_maskInfo);
 
    m_enabled = data.isEnabled;
    m_offsetX = data.offsetX;
    m_offsetY = data.offsetY;
    m_isRandomOffsetX = data.isRandomOffsetX;
    m_isRandomOffsetY = data.isRandomOffsetY;
 
    if (m_texturingMode == KisTextureOptionData::GRADIENT && canvasResourcesInterface) {
        KoAbstractGradientSP gradient = canvasResourcesInterface->resource(KoCanvasResource::CurrentGradient).value<KoAbstractGradientSP>()->cloneAndBakeVariableColors(canvasResourcesInterface);
        if (gradient) {
            m_gradient = gradient;
            m_cachedGradient.setGradient(gradient, 256);
        }
    }
}

References KisTextureOptionData::autoInvertOnErase, COMPOSITE_ERASE, COMPOSITE_OVER, KoCanvasResource::CurrentEffectiveCompositeOp, KoCanvasResource::CurrentGradient, KisTextureMaskInfoCache::fetchCachedTextureInfo(), KisTextureOptionData::GRADIENT, KisTextureMaskInfoCache::instance(), KisTextureOptionData::isEnabled, KisEmbeddedTextureData::isNull(), KisTextureOptionData::isRandomOffsetX, KisTextureOptionData::isRandomOffsetY, KIS_SAFE_ASSERT_RECOVER, KisTextureOptionData::LIGHTNESS, m_cachedGradient, m_enabled, m_flags, m_gradient, m_isRandomOffsetX, m_isRandomOffsetY, m_levelOfDetail, m_maskInfo, m_offsetX, m_offsetY, m_texturingMode, m_useSoftTexturing, KisTextureOptionData::offsetX, KisTextureOptionData::offsetY, KisTextureOptionData::read(), KoCachedGradient::setGradient(), KisTextureOptionData::SUBTRACT, SupportsGradientMode, SupportsLightnessMode, KisTextureOptionData::textureData, KisTextureOptionData::texturingMode, toQShared(), KisTextureOptionData::useSoftTexturing, and warnKrita.

prepareEmbeddedResources()

QList< KoResourceLoadResult > KisTextureOption::prepareEmbeddedResources ( const KisPropertiesConfigurationSP setting, KisResourcesInterfaceSP resourcesInterface )

static

We cannot use m_enabled here because it is not initialized at this stage. fillProperties() is not necessary for this call, because it is extremely slow.

Definition at line 131 of file kis_texture_option.cpp.

{
    QList<KoResourceLoadResult> patterns;
 
    KisTextureOptionData data;
    data.read(setting.data());
 
    if (data.isEnabled && !data.textureData.patternBase64.isEmpty()) {
        patterns << data.textureData.loadLinkedPattern(resourcesInterface);
    }
 
    return patterns;
}

References KisSharedPtr< T >::data(), KisTextureOptionData::isEnabled, KisEmbeddedTextureData::loadLinkedPattern(), KisEmbeddedTextureData::patternBase64, KisTextureOptionData::read(), and KisTextureOptionData::textureData.

prepareLinkedResources()

QList< KoResourceLoadResult > KisTextureOption::prepareLinkedResources ( const KisPropertiesConfigurationSP setting, KisResourcesInterfaceSP resourcesInterface )

static

We cannot use m_enabled here because it is not initialized at this stage. fillProperties() is not necessary for this call, because it is extremely slow.

Definition at line 150 of file kis_texture_option.cpp.

{
    QList<KoResourceLoadResult> patterns;
 
    KisTextureOptionData data;
    data.read(setting.data());
 
    if (data.isEnabled && data.textureData.patternBase64.isEmpty()) {
        patterns << data.textureData.loadLinkedPattern(resourcesInterface);
    }
 
    return patterns;
}

References KisSharedPtr< T >::data(), KisTextureOptionData::isEnabled, KisEmbeddedTextureData::loadLinkedPattern(), KisEmbeddedTextureData::patternBase64, KisTextureOptionData::read(), and KisTextureOptionData::textureData.

requiresEffectiveCompositeOp()

bool KisTextureOption::requiresEffectiveCompositeOp ( const KisPropertiesConfiguration * settings )

static

Definition at line 182 of file kis_texture_option.cpp.

{
    KisTextureOptionData data;
    data.read(settings);
 
    return data.isEnabled && data.autoInvertOnErase;
}

References KisTextureOptionData::autoInvertOnErase, KisTextureOptionData::isEnabled, and KisTextureOptionData::read().

Member Data Documentation

m_cachedGradient

KoCachedGradient KisTextureOption::m_cachedGradient

private

Definition at line 70 of file kis_texture_option.h.

m_cachedPaintDevice

KisCachedPaintDevice KisTextureOption::m_cachedPaintDevice

private

Definition at line 78 of file kis_texture_option.h.

m_enabled

bool KisTextureOption::m_enabled {false}

Definition at line 39 of file kis_texture_option.h.

{false};

m_flags

KisBrushTextureFlags KisTextureOption::m_flags

private

Definition at line 77 of file kis_texture_option.h.

m_gradient

KoAbstractGradientSP KisTextureOption::m_gradient

private

Definition at line 69 of file kis_texture_option.h.

m_isRandomOffsetX

bool KisTextureOption::m_isRandomOffsetX {false}

private

Definition at line 65 of file kis_texture_option.h.

{false};

m_isRandomOffsetY

bool KisTextureOption::m_isRandomOffsetY {false}

private

Definition at line 66 of file kis_texture_option.h.

{false};

m_levelOfDetail

int KisTextureOption::m_levelOfDetail {0}

private

Definition at line 72 of file kis_texture_option.h.

{0};

m_maskInfo

KisTextureMaskInfoSP KisTextureOption::m_maskInfo

private

Definition at line 76 of file kis_texture_option.h.

m_offsetX

int KisTextureOption::m_offsetX {0}

private

Definition at line 63 of file kis_texture_option.h.

{0};

m_offsetY

int KisTextureOption::m_offsetY {0}

private

Definition at line 64 of file kis_texture_option.h.

{0};

m_strengthOption

KisStrengthOption KisTextureOption::m_strengthOption

private

Definition at line 75 of file kis_texture_option.h.

m_texturingMode

KisTextureOptionData::TexturingMode KisTextureOption::m_texturingMode {KisTextureOptionData::MULTIPLY}

private

Definition at line 67 of file kis_texture_option.h.

{KisTextureOptionData::MULTIPLY};

m_useSoftTexturing

bool KisTextureOption::m_useSoftTexturing {false}

private

Definition at line 68 of file kis_texture_option.h.

{false};

---

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

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