KisLsBevelEmbossFilter Class Reference

#include <kis_ls_bevel_emboss_filter.h>

Inheritance diagram for KisLsBevelEmbossFilter:

Public Member Functions
QRect	changedRect (const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override
KisLayerStyleFilter *	clone () const override
	KisLsBevelEmbossFilter ()
QRect	neededRect (const QRect &rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override
void	processDirectly (KisPaintDeviceSP src, KisMultipleProjection *dst, KisLayerStyleKnockoutBlower *blower, const QRect &applyRect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment *env) const override
Public Member Functions inherited from KisLayerStyleFilter
QString	id () const
	KisLayerStyleFilter (const KoID &id)
virtual	~KisLayerStyleFilter ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Private Member Functions
void	applyBevelEmboss (KisPaintDeviceSP srcDevice, KisMultipleProjection *dst, const QRect &applyRect, const psd_layer_effects_bevel_emboss *config, KisResourcesInterfaceSP resourcesInterface, KisLayerStyleFilterEnvironment *env) const
	KisLsBevelEmbossFilter (const KisLsBevelEmbossFilter &rhs)

Additional Inherited Members
Public Attributes inherited from KisLayerStyleFilter
KoID	id
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame
Protected Member Functions inherited from KisLayerStyleFilter
	KisLayerStyleFilter (const KisLayerStyleFilter &rhs)
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Detailed Description

Definition at line 17 of file kis_ls_bevel_emboss_filter.h.

Constructor & Destructor Documentation

KisLsBevelEmbossFilter() [1/2]

KisLsBevelEmbossFilter::KisLsBevelEmbossFilter

(

)

Definition at line 44 of file kis_ls_bevel_emboss_filter.cpp.

    : KisLayerStyleFilter(KoID("lsstroke", i18n("Stroke (style)")))
{
}

KisLsBevelEmbossFilter() [2/2]

KisLsBevelEmbossFilter::KisLsBevelEmbossFilter ( const KisLsBevelEmbossFilter & rhs )

private

Definition at line 54 of file kis_ls_bevel_emboss_filter.cpp.

    : KisLayerStyleFilter(rhs)
{
}

Member Function Documentation

applyBevelEmboss()

void KisLsBevelEmbossFilter::applyBevelEmboss ( KisPaintDeviceSP srcDevice, KisMultipleProjection * dst, const QRect & applyRect, const psd_layer_effects_bevel_emboss * config, KisResourcesInterfaceSP resourcesInterface, KisLayerStyleFilterEnvironment * env ) const

private

Definition at line 261 of file kis_ls_bevel_emboss_filter.cpp.

{
    if (applyRect.isEmpty()) return;
 
    BevelEmbossRectCalculator d(applyRect, config);
 
    KisCachedSelection::Guard s1(*env->cachedSelection());
    KisSelectionSP baseSelection = s1.selection();
    KisLsUtils::selectionFromAlphaChannel(srcDevice, baseSelection, d.initialFetchRect);
 
    KisPixelSelectionSP selection = baseSelection->pixelSelection();
 
    const int size = config->size();
 
    int limitingGrowSize = 0;
    KisCachedSelection::Guard s2(*env->cachedSelection());
    KisPixelSelectionSP bumpmapSelection = s2.selection()->pixelSelection();
 
    switch (config->style()) {
    case psd_bevel_outer_bevel:
        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, size, false, env);
        limitingGrowSize = size;
        break;
    case psd_bevel_inner_bevel:
        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, 0, false, env);
        limitingGrowSize = 0;
        break;
    case psd_bevel_emboss: {
        const int initialSize = std::ceil(qreal(size) / 2.0);
        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, size, initialSize, false, env);
        limitingGrowSize = initialSize;
        break;
    }
    case psd_bevel_pillow_emboss: {
        const int halfSizeF = std::floor(qreal(size) / 2.0);
        const int halfSizeC = std::ceil(qreal(size) / 2.0);
        // TODO: probably not correct!
        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, halfSizeC, halfSizeC, false, env);
        paintBevelSelection(selection, bumpmapSelection, d.applyBevelRect, halfSizeF, 0, true, env);
        limitingGrowSize = halfSizeC;
        break;
    }
    case psd_bevel_stroke_emboss:
        warnKrita << "WARNING: Stroke Emboss style is not implemented yet!";
        return;
    }
 
    KisCachedSelection::Guard s3(*env->cachedSelection());
    KisPixelSelectionSP limitingSelection = s3.selection()->pixelSelection();
    limitingSelection->makeCloneFromRough(selection, selection->selectedRect());
    {
        QRect changeRectUnused =
            KisLsUtils::growSelectionUniform(limitingSelection,
                                             limitingGrowSize,
                                             d.applyBevelRect);
        Q_UNUSED(changeRectUnused);
    }
 
    //bumpmapSelection->convertToQImage(0, QRect(0,0,300,300)).save("1_selection_xconv.png");
 
    if (config->textureEnabled()) {
        KisCachedSelection::Guard s4(*env->cachedSelection());
        KisPixelSelectionSP textureSelection = s4.selection()->pixelSelection();
 
        KisLsUtils::fillPattern(textureSelection, d.applyTextureRect, env,
                                config->textureScale(),
                                config->texturePattern(resourcesInterface),
                                config->textureHorizontalPhase(),
                                config->textureVerticalPhase(),
                                config->textureAlignWithLayer());
 
        int contrastadj = 0;
 
        {
            using namespace std;
 
            int tex_depth = config->textureDepth();
 
            if (tex_depth >= 0.0) {
                if (tex_depth <= 100.0) {
                    contrastadj = int(qRound((1-(tex_depth/100.0)) * -127));
                } else {
                    contrastadj = int(qRound(((tex_depth-100.0)/900.0) * 127));
                }
            } else {
                textureSelection->invert();
                if (tex_depth >= -100.0) {
                    contrastadj = int(qRound((1-(abs(tex_depth)/100.0)) * -127));
                } else {
                    contrastadj = int(qRound(((abs(tex_depth)-100.0)/900.0) * 127));
                }
            }
        }
 
        qreal contrast = qBound(-1.0, qreal(contrastadj) / 127.0, 1.0);
        mapPixelValues(textureSelection, ContrastOp(contrast), d.applyTextureRect);
 
        {
            KisPainter gc(bumpmapSelection);
            gc.setCompositeOpId(COMPOSITE_MULT);
            gc.bitBlt(d.applyTextureRect.topLeft(), textureSelection, d.applyTextureRect);
            gc.end();
        }
    }
 
    //bumpmapSelection->convertToQImage(0, QRect(0,0,300,300)).save("15_selection_texture.png");
 
    if (config->contourEnabled()) {
        if (config->range() != KisLsUtils::FULL_PERCENT_RANGE) {
            KisLsUtils::adjustRange(bumpmapSelection, d.applyContourRect, config->range());
        }
 
        KisLsUtils::applyContourCorrection(bumpmapSelection,
                                           d.applyContourRect,
                                           config->contourLookupTable(),
                                           config->antiAliased(),
                                           true);
    }
 
    bumpmap_vals_t bmvals;
 
    bmvals.azimuth = config->angle();
    bmvals.elevation = config->altitude();
    bmvals.depth = config->depth();
    bmvals.ambient = 0;
    bmvals.compensate = true;
    bmvals.invert = config->direction() == psd_direction_down;
    bmvals.type = LINEAR;
 
    bumpmap(bumpmapSelection, d.applyBumpmapRect, bmvals);
 
    //bumpmapSelection->convertToQImage(0, QRect(0,0,300,300)).save("3_selection_bumpmap.png");
 
    { // TODO: optimize!
 
        KisLsUtils::applyContourCorrection(bumpmapSelection,
                                           d.applyGlossContourRect,
                                           config->glossContourLookupTable(),
                                           config->glossAntiAliased(),
                                           true);
 
    }
 
    if (config->soften()) {
        KisLsUtils::applyGaussianWithTransaction(bumpmapSelection, d.applyGaussianRect, config->soften());
    }
 
 
    if (config->textureEnabled() && config->textureInvert()) {
        bumpmapSelection->invert();
    }
 
    selection->clear();
    mapPixelValues(bumpmapSelection, selection,
                   ShadowsFetchOp(), d.shadowHighlightsFinalRect);
    selection->applySelection(limitingSelection, SELECTION_INTERSECT);
 
    //dstDevice->convertToQImage(0, QRect(0,0,300,300)).save("4_dst_before_apply.png");
    //selection->convertToQImage(0, QRect(0,0,300,300)).save("4_shadows_sel.png");
 
    {
        KisPaintDeviceSP dstDevice = dst->getProjection("00_bevel_shadow",
                                                        config->shadowBlendMode(),
                                                        config->shadowOpacity(),
                                                        QBitArray(),
                                                        srcDevice);
 
        const KoColor fillColor(config->shadowColor(), dstDevice->colorSpace());
        const QRect &fillRect = d.shadowHighlightsFinalRect;
 
        KisCachedPaintDevice::Guard d1(dstDevice, *env->cachedPaintDevice());
        KisPaintDeviceSP fillDevice = d1.device();
        fillDevice->setDefaultPixel(fillColor);
 
        KisPainter::copyAreaOptimized(fillRect.topLeft(), fillDevice, dstDevice, fillRect, baseSelection);
    }
 
    selection->clear();
    mapPixelValues(bumpmapSelection, selection,
                   HighlightsFetchOp(), d.shadowHighlightsFinalRect);
    selection->applySelection(limitingSelection, SELECTION_INTERSECT);
 
    //selection->convertToQImage(0, QRect(0,0,300,300)).save("5_highlights_sel.png");
 
    {
        KisPaintDeviceSP dstDevice = dst->getProjection("01_bevel_highlight",
                                                        config->highlightBlendMode(),
                                                        config->highlightOpacity(),
                                                        QBitArray(),
                                                        srcDevice);
 
        const KoColor fillColor(config->highlightColor(), dstDevice->colorSpace());
        const QRect &fillRect = d.shadowHighlightsFinalRect;
 
        KisCachedPaintDevice::Guard d1(dstDevice, *env->cachedPaintDevice());
        KisPaintDeviceSP fillDevice = d1.device();
        fillDevice->setDefaultPixel(fillColor);
 
        KisPainter::copyAreaOptimized(fillRect.topLeft(), fillDevice, dstDevice, fillRect, baseSelection);
    }
}

References KisLsUtils::adjustRange(), psd_layer_effects_bevel_emboss::altitude(), bumpmap_vals_t::ambient, psd_layer_effects_shadow_base::angle(), psd_layer_effects_shadow_base::antiAliased(), KisLsUtils::applyContourCorrection(), KisLsUtils::applyGaussianWithTransaction(), KisPixelSelection::applySelection(), bumpmap_vals_t::azimuth, KisPainter::bitBlt(), bumpmap(), KisLayerStyleFilterEnvironment::cachedPaintDevice(), KisLayerStyleFilterEnvironment::cachedSelection(), KisPixelSelection::clear(), KisPaintDevice::colorSpace(), bumpmap_vals_t::compensate, COMPOSITE_MULT, psd_layer_effects_bevel_emboss::contourEnabled(), psd_layer_effects_shadow_base::contourLookupTable(), KisPainter::copyAreaOptimized(), bumpmap_vals_t::depth, psd_layer_effects_bevel_emboss::depth(), KisCachedPaintDevice::Guard::device(), psd_layer_effects_bevel_emboss::direction(), bumpmap_vals_t::elevation, KisPainter::end(), KisLsUtils::fillPattern(), KisLsUtils::FULL_PERCENT_RANGE, KisMultipleProjection::getProjection(), psd_layer_effects_bevel_emboss::glossAntiAliased(), psd_layer_effects_bevel_emboss::glossContourLookupTable(), KisLsUtils::growSelectionUniform(), psd_layer_effects_bevel_emboss::highlightBlendMode(), psd_layer_effects_bevel_emboss::highlightColor(), psd_layer_effects_bevel_emboss::highlightOpacity(), KisPixelSelection::invert(), bumpmap_vals_t::invert, LINEAR, KisPaintDevice::makeCloneFromRough(), mapPixelValues(), paintBevelSelection(), KisSelection::pixelSelection, psd_bevel_emboss, psd_bevel_inner_bevel, psd_bevel_outer_bevel, psd_bevel_pillow_emboss, psd_bevel_stroke_emboss, psd_direction_down, psd_layer_effects_shadow_base::range(), s1, s2, s3, KisPixelSelection::selectedRect(), KisCachedSelection::Guard::selection(), SELECTION_INTERSECT, KisLsUtils::selectionFromAlphaChannel(), KisPainter::setCompositeOpId(), KisPaintDevice::setDefaultPixel(), psd_layer_effects_bevel_emboss::shadowBlendMode(), psd_layer_effects_bevel_emboss::shadowColor(), psd_layer_effects_bevel_emboss::shadowOpacity(), psd_layer_effects_shadow_base::size(), psd_layer_effects_bevel_emboss::soften(), psd_layer_effects_bevel_emboss::style(), psd_layer_effects_bevel_emboss::textureAlignWithLayer(), psd_layer_effects_bevel_emboss::textureDepth(), psd_layer_effects_bevel_emboss::textureEnabled(), psd_layer_effects_bevel_emboss::textureHorizontalPhase(), psd_layer_effects_bevel_emboss::textureInvert(), psd_layer_effects_bevel_emboss::texturePattern(), psd_layer_effects_bevel_emboss::textureScale(), psd_layer_effects_bevel_emboss::textureVerticalPhase(), bumpmap_vals_t::type, and warnKrita.

changedRect()

QRect KisLsBevelEmbossFilter::changedRect ( const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment * env ) const

overridevirtual

Similar to neededRect: some filters will alter a lot of pixels that are near to each other at the same time. So when you changed a single rectangle in a device, the actual rectangle that will feel the influence of this change might be bigger. Use this function to determine that rect.

Implements KisLayerStyleFilter.

Definition at line 497 of file kis_ls_bevel_emboss_filter.cpp.

{
    const psd_layer_effects_bevel_emboss *config = style->bevelAndEmboss();
    if (!config->effectEnabled()) return rect;
 
    KisLsUtils::LodWrapper<psd_layer_effects_bevel_emboss> w(env->currentLevelOfDetail(), config);
 
    BevelEmbossRectCalculator d(rect, w.config);
    return d.totalChangeRect(rect, w.config);
}

References KisLayerStyleFilterEnvironment::currentLevelOfDetail(), and psd_layer_effects_shadow_base::effectEnabled().

clone()

KisLayerStyleFilter * KisLsBevelEmbossFilter::clone ( ) const

overridevirtual

Implements KisLayerStyleFilter.

Definition at line 49 of file kis_ls_bevel_emboss_filter.cpp.

{
    return new KisLsBevelEmbossFilter(*this);
}

References KisLsBevelEmbossFilter().

neededRect()

QRect KisLsBevelEmbossFilter::neededRect ( const QRect & rect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment * env ) const

overridevirtual

Some filters need pixels outside the current processing rect to compute the new value (for instance, convolution filters)

Implements KisLayerStyleFilter.

Definition at line 486 of file kis_ls_bevel_emboss_filter.cpp.

{
    const psd_layer_effects_bevel_emboss *config = style->bevelAndEmboss();
    if (!config->effectEnabled()) return rect;
 
    KisLsUtils::LodWrapper<psd_layer_effects_bevel_emboss> w(env->currentLevelOfDetail(), config);
 
    BevelEmbossRectCalculator d(rect, w.config);
    return d.totalNeedRect(rect, w.config);
}

References KisLayerStyleFilterEnvironment::currentLevelOfDetail(), and psd_layer_effects_shadow_base::effectEnabled().

processDirectly()

void KisLsBevelEmbossFilter::processDirectly ( KisPaintDeviceSP src, KisMultipleProjection * dst, KisLayerStyleKnockoutBlower * blower, const QRect & applyRect, KisPSDLayerStyleSP style, KisLayerStyleFilterEnvironment * env ) const

overridevirtual

Implements KisLayerStyleFilter.

Definition at line 468 of file kis_ls_bevel_emboss_filter.cpp.

{
    Q_UNUSED(env);
    Q_UNUSED(blower);
    KIS_ASSERT_RECOVER_RETURN(style);
 
    const psd_layer_effects_bevel_emboss *config = style->bevelAndEmboss();
    if (!KisLsUtils::checkEffectEnabled(config, dst)) return;
 
    KisLsUtils::LodWrapper<psd_layer_effects_bevel_emboss> w(env->currentLevelOfDetail(), config);
    applyBevelEmboss(src, dst, applyRect, w.config, style->resourcesInterface(), env);
}

References applyBevelEmboss(), KisLsUtils::checkEffectEnabled(), KisLayerStyleFilterEnvironment::currentLevelOfDetail(), and KIS_ASSERT_RECOVER_RETURN.

---

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

• libs/image/layerstyles/kis_ls_bevel_emboss_filter.h
• libs/image/layerstyles/kis_ls_bevel_emboss_filter.cpp