#include <kis_phong_bumpmap_filter.h>

Inheritance diagram for KisFilterPhongBumpmap:

Public Member Functions
QRect	changedRect (const QRect &rect, const KisFilterConfigurationSP config, int lod) const override

KisConfigWidget *	createConfigurationWidget (QWidget *parent, const KisPaintDeviceSP dev, bool useForMasks) const override

KisFilterConfigurationSP	defaultConfiguration (KisResourcesInterfaceSP resourcesInterface) const override

	KisFilterPhongBumpmap ()

QRect	neededRect (const QRect &rect, const KisFilterConfigurationSP config, int lod) const override

void	processImpl (KisPaintDeviceSP device, const QRect &applyRect, const KisFilterConfigurationSP config, KoUpdater *progressUpdater) const override

Public Member Functions inherited from KisFilter
virtual bool	configurationAllowedForMask (KisFilterConfigurationSP config) const

virtual void	fixLoadedFilterConfigurationForMasks (KisFilterConfigurationSP config) const

	KisFilter (const KoID &id, const KoID &category, const QString &entry)

virtual bool	needsTransparentPixels (const KisFilterConfigurationSP config, const KoColorSpace *cs) const

void	process (const KisPaintDeviceSP src, KisPaintDeviceSP dst, KisSelectionSP selection, const QRect &applyRect, const KisFilterConfigurationSP config, KoUpdater *progressUpdater=0) const

void	process (KisPaintDeviceSP device, const QRect &applyRect, const KisFilterConfigurationSP config, KoUpdater *progressUpdater=0) const

virtual bool	supportsLevelOfDetail (const KisFilterConfigurationSP config, int lod) const

	~KisFilter () override

Public Member Functions inherited from KisBaseProcessor
KisBookmarkedConfigurationManager *	bookmarkManager ()

const KisBookmarkedConfigurationManager *	bookmarkManager () const

ColorSpaceIndependence	colorSpaceIndependence () const

virtual KisFilterConfigurationSP	factoryConfiguration (KisResourcesInterfaceSP resourcesInterface) const

QString	id () const

	KisBaseProcessor (const KoID &id, const KoID &category, const QString &entry)

KoID	menuCategory () const

QString	menuEntry () const

QString	name () const

	Private ()

QKeySequence	shortcut () const

bool	showConfigurationWidget ()
	If true, the filter wants to show a configuration widget.

bool	supportsAdjustmentLayers () const
	This filter can be used in adjustment layers.

bool	supportsPainting () const

bool	supportsThreading () const

virtual	~KisBaseProcessor ()

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Member Functions inherited from KisShared
bool	deref ()

bool	ref ()

int	refCount ()

QAtomicInt *	sharedWeakReference ()

Additional Inherited Members
Public Attributes inherited from KisBaseProcessor
KisBookmarkedConfigurationManager *	bookmarkManager

KoID	category

ColorSpaceIndependence	colorSpaceIndependence

QString	entry

KoID	id

QKeySequence	shortcut

bool	showConfigurationWidget

bool	supportsAdjustmentLayers

bool	supportsPainting

bool	supportsThreading

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Protected Member Functions inherited from KisFilter
QString	configEntryGroup () const

void	setSupportsLevelOfDetail (bool value)

Protected Member Functions inherited from KisBaseProcessor
void	init (const QString &configEntryGroup)

void	setColorSpaceIndependence (ColorSpaceIndependence v)

void	setShortcut (const QKeySequence &shortcut)

void	setShowConfigurationWidget (bool v)

void	setSupportsAdjustmentLayers (bool v)

void	setSupportsPainting (bool v)

void	setSupportsThreading (bool v)

Protected Member Functions inherited from KisShared
	KisShared ()

	~KisShared ()

Detailed Description

This class is an implementation of the phong illumination model. It uses a heightmap as an input mesh (normally taken from 1 channel of a colorspace) to achieve a bumpmapping effect with multiple illumination sources.

Definition at line 20 of file kis_phong_bumpmap_filter.h.

Constructor & Destructor Documentation

◆ KisFilterPhongBumpmap()

KisFilterPhongBumpmap::KisFilterPhongBumpmap ( )

Definition at line 24 of file kis_phong_bumpmap_filter.cpp.

                      : KisFilter(KoID("phongbumpmap", i18n("Phong Bumpmap")),
                                  FiltersCategoryMapId, i18n("&Phong Bumpmap..."))
{
    setColorSpaceIndependence(TO_LAB16);
    setSupportsPainting(true);
    setSupportsLevelOfDetail(true);
}

References KisBaseProcessor::setColorSpaceIndependence(), KisFilter::setSupportsLevelOfDetail(), KisBaseProcessor::setSupportsPainting(), and TO_LAB16.

Member Function Documentation

◆ changedRect()

QRect KisFilterPhongBumpmap::changedRect	(	const QRect &	rect,
		const KisFilterConfigurationSP	config,
		int	lod ) 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.

Reimplemented from KisFilter.

Definition at line 215 of file kis_phong_bumpmap_filter.cpp.

{
    return rect;
}

◆ createConfigurationWidget()

KisConfigWidget * KisFilterPhongBumpmap::createConfigurationWidget	(	QWidget *	parent,
		const KisPaintDeviceSP	dev,
		bool	useForMasks ) const

overridevirtual

Create the configuration widget for this processor.

Parameters

parent	the Qt owner widget of this widget
dev	the paintdevice this filter will act on
useForMasks	shown if the filer is going to be used in a mask. Some filters may provide limited options when applied as a mask (e.g. Gaussian Blur)

Reimplemented from KisBaseProcessor.

Definition at line 220 of file kis_phong_bumpmap_filter.cpp.

{
    KisPhongBumpmapConfigWidget *w = new KisPhongBumpmapConfigWidget(dev, parent);
    return w;
}

◆ defaultConfiguration()

KisFilterConfigurationSP KisFilterPhongBumpmap::defaultConfiguration ( KisResourcesInterfaceSP resourcesInterface ) const

overridevirtual

Return the configuration set as the default by the user or the default configuration from the filter writer as returned by factoryConfiguration.

This configuration is used by default for the configuration widget and given to the process function if there is no configuration widget.

Returns: the default configuration of this widget

Reimplemented from KisBaseProcessor.

Definition at line 180 of file kis_phong_bumpmap_filter.cpp.

{
    KisFilterConfigurationSP config = factoryConfiguration(resourcesInterface);
    config->setProperty(PHONG_AMBIENT_REFLECTIVITY, 0.2);
    config->setProperty(PHONG_DIFFUSE_REFLECTIVITY, 0.5);
    config->setProperty(PHONG_SPECULAR_REFLECTIVITY, 0.3);
    config->setProperty(PHONG_SHINYNESS_EXPONENT, 2);
    config->setProperty(USE_NORMALMAP_IS_ENABLED, false);
    config->setProperty(PHONG_DIFFUSE_REFLECTIVITY_IS_ENABLED, true);
    config->setProperty(PHONG_SPECULAR_REFLECTIVITY_IS_ENABLED, true);
    // Indexes are off by 1 simply because arrays start at 0 and the GUI naming scheme started at 1
    config->setProperty(PHONG_ILLUMINANT_IS_ENABLED[0], true);
    config->setProperty(PHONG_ILLUMINANT_IS_ENABLED[1], true);
    config->setProperty(PHONG_ILLUMINANT_IS_ENABLED[2], false);
    config->setProperty(PHONG_ILLUMINANT_IS_ENABLED[3], false);
    config->setProperty(PHONG_ILLUMINANT_COLOR[0], QColor(255, 255, 0));
    config->setProperty(PHONG_ILLUMINANT_COLOR[1], QColor(255, 0, 0));
    config->setProperty(PHONG_ILLUMINANT_COLOR[2], QColor(0, 0, 255));
    config->setProperty(PHONG_ILLUMINANT_COLOR[3], QColor(0, 255, 0));
    config->setProperty(PHONG_ILLUMINANT_AZIMUTH[0], 50);
    config->setProperty(PHONG_ILLUMINANT_AZIMUTH[1], 100);
    config->setProperty(PHONG_ILLUMINANT_AZIMUTH[2], 150);
    config->setProperty(PHONG_ILLUMINANT_AZIMUTH[3], 200);
    config->setProperty(PHONG_ILLUMINANT_INCLINATION[0], 25);
    config->setProperty(PHONG_ILLUMINANT_INCLINATION[1], 20);
    config->setProperty(PHONG_ILLUMINANT_INCLINATION[2], 30);
    config->setProperty(PHONG_ILLUMINANT_INCLINATION[3], 40);
    return config;
}

References KisBaseProcessor::factoryConfiguration(), PHONG_AMBIENT_REFLECTIVITY, PHONG_DIFFUSE_REFLECTIVITY, PHONG_DIFFUSE_REFLECTIVITY_IS_ENABLED, PHONG_ILLUMINANT_AZIMUTH, PHONG_ILLUMINANT_COLOR, PHONG_ILLUMINANT_INCLINATION, PHONG_ILLUMINANT_IS_ENABLED, PHONG_SHINYNESS_EXPONENT, PHONG_SPECULAR_REFLECTIVITY, PHONG_SPECULAR_REFLECTIVITY_IS_ENABLED, and USE_NORMALMAP_IS_ENABLED.

◆ neededRect()

QRect KisFilterPhongBumpmap::neededRect	(	const QRect &	rect,
		const KisFilterConfigurationSP	config,
		int	lod ) const

overridevirtual

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

Reimplemented from KisFilter.

Definition at line 210 of file kis_phong_bumpmap_filter.cpp.

{
    return rect.adjusted(-1, -1, 1, 1);
}

◆ processImpl()

void KisFilterPhongBumpmap::processImpl	(	KisPaintDeviceSP	device,
		const QRect &	applyRect,
		const KisFilterConfigurationSP	config,
		KoUpdater *	progressUpdater ) const

overridevirtual

Override this function with the implementation of your filter.

This is a low level function that expects all the conditions for the

Parameters

device	be met. Use usual process() methods instead.
device	the paint device to filter
applyRect	the rectangle where the filter is applied
config	the parameters of the filter
progressUpdater	to pass on the progress the filter is making

Implements KisFilter.

Definition at line 33 of file kis_phong_bumpmap_filter.cpp.

{
    if (!config) return;
 
    if (progressUpdater) progressUpdater->setProgress(0);
 
    QString userChosenHeightChannel = config->getString(PHONG_HEIGHT_CHANNEL, "FAIL");
    bool m_usenormalmap = config->getBool(USE_NORMALMAP_IS_ENABLED);
 
    if (userChosenHeightChannel == "FAIL") {
        return;
    }
 
    const QList<KoChannelInfo*> channels = device->colorSpace()->channels();
    KoChannelInfo *m_heightChannel = 0;
 
    Q_FOREACH (KoChannelInfo* channel, channels) {
        if (userChosenHeightChannel == channel->name()) {
            m_heightChannel = channel;
        }
    }
 
    if (!m_heightChannel) {
        m_heightChannel = channels.first();
    }
    KIS_ASSERT_RECOVER_RETURN(m_heightChannel);
 
    QRect inputArea = applyRect;
    QRect outputArea = applyRect;
    if (m_usenormalmap==false) {
        inputArea.adjust(-1, -1, 1, 1);
    }
 
    quint32 posup;
    quint32 posdown;
    quint32 posleft;
    quint32 posright;
    QColor I; //Reflected light
 
    if (progressUpdater) progressUpdater->setProgress(1);
 
    //======Preparation paraphernalia=======
 
    //Hardcoded facts about Phong Bumpmap: it _will_ generate an RGBA16 bumpmap
    const quint8    BYTE_DEPTH_OF_BUMPMAP    = 2;      // 16 bits per channel
    const quint8    CHANNEL_COUNT_OF_BUMPMAP = 4;      // RGBA
    const quint32   pixelsOfInputArea        = abs(inputArea.width() * inputArea.height());
    const quint32   pixelsOfOutputArea       = abs(outputArea.width() * outputArea.height());
    const quint8    pixelSize                = BYTE_DEPTH_OF_BUMPMAP * CHANNEL_COUNT_OF_BUMPMAP;
    const quint32   bytesToFillBumpmapArea   = pixelsOfOutputArea * pixelSize;
    QVector<quint8> bumpmap(bytesToFillBumpmapArea);
    quint8         *bumpmapDataPointer       = bumpmap.data();
    quint32         ki                       = KoChannelInfo::displayPositionToChannelIndex(m_heightChannel->displayPosition(), channels);
    PhongPixelProcessor tileRenderer(pixelsOfInputArea, config);
 
 
    if (progressUpdater) progressUpdater->setProgress(2);
 
    //===============RENDER=================
 
    QVector<PtrToDouble> toDoubleFuncPtr(channels.count());
    KisMathToolbox mathToolbox;
    if (!mathToolbox.getToDoubleChannelPtr(channels, toDoubleFuncPtr)) {
        return;
    }
 
    KisHLineConstIteratorSP iterator;
    quint32 curPixel = 0;
    iterator = device->createHLineConstIteratorNG(inputArea.x(),
                                             inputArea.y(),
                                             inputArea.width()
                                             );
 
    if (m_usenormalmap==false) {
        for (qint32 srcRow = 0; srcRow < inputArea.height(); ++srcRow) {
            do {
                const quint8 *data = iterator->oldRawData();
                tileRenderer.realheightmap[curPixel] = toDoubleFuncPtr[ki](data, channels[ki]->pos());
                curPixel++;
            }
            while (iterator->nextPixel());
            iterator->nextRow();
        }
        if (progressUpdater) progressUpdater->setProgress(50);
 
        const int tileHeightMinus1 = inputArea.height() - 1;
        const int tileWidthMinus1 = inputArea.width() - 1;
 
        // Foreach INNER pixel in tile
        for (int y = 1; y < tileHeightMinus1; ++y) {
            for (int x = 1; x < tileWidthMinus1; ++x) {
                posup   = (y + 1) * inputArea.width() + x;
                posdown = (y - 1) * inputArea.width() + x;
                posleft  = y * inputArea.width() + x - 1;
                posright = y * inputArea.width() + x + 1;
 
 
               memcpy(bumpmapDataPointer,
                      tileRenderer.IlluminatePixelFromHeightmap(posup, posdown, posleft, posright).data(),
                      pixelSize);
 
               bumpmapDataPointer += pixelSize;
            }
        }
    } else {
        for (qint32 srcRow = 0; srcRow < inputArea.height(); ++srcRow) {
            do {
                const quint8 *data = iterator->oldRawData();
                tileRenderer.realheightmap[curPixel] = toDoubleFuncPtr[ki](data, channels[ki]->pos());
                QVector <float> current_pixel_values(4);
                device->colorSpace()->normalisedChannelsValue(data, current_pixel_values );
 
                //dbgKrita<< "Vector:" << current_pixel_values[2] << "," << current_pixel_values[1] << "," << current_pixel_values[0];
                memcpy(bumpmapDataPointer,
                      tileRenderer.IlluminatePixelFromNormalmap(current_pixel_values[2], current_pixel_values[1], current_pixel_values[0]).data(),
                      pixelSize);
 
                curPixel++;
                //pointer that crashes here, but not in the other if statement.
                bumpmapDataPointer += pixelSize;
 
 
 
            }
            while (iterator->nextPixel());
            iterator->nextRow();
        }
    }
 
    if (progressUpdater) progressUpdater->setProgress(90);
 
    KisPaintDeviceSP bumpmapPaintDevice = new KisPaintDevice(KoColorSpaceRegistry::instance()->rgb16());
    bumpmapPaintDevice->writeBytes(bumpmap.data(), outputArea.x(), outputArea.y(), outputArea.width(), outputArea.height());
    bumpmapPaintDevice->convertTo(device->colorSpace(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
    KisPainter copier(device);
    copier.bitBlt(outputArea.x(), outputArea.y(), bumpmapPaintDevice,
                  outputArea.x(), outputArea.y(), outputArea.width(), outputArea.height());
    //device->prepareClone(bumpmapPaintDevice);
    //device->makeCloneFrom(bumpmapPaintDevice, bumpmapPaintDevice->extent());  // THIS COULD BE BUG GY
 
    if (progressUpdater) progressUpdater->setProgress(100);
}

References KisPainter::bitBlt(), bumpmap(), KoColorSpace::channels, KisPaintDevice::colorSpace(), KisPaintDevice::convertTo(), KisPaintDevice::createHLineConstIteratorNG(), KoChannelInfo::displayPosition(), KoChannelInfo::displayPositionToChannelIndex(), KisMathToolbox::getToDoubleChannelPtr(), PhongPixelProcessor::IlluminatePixelFromHeightmap(), PhongPixelProcessor::IlluminatePixelFromNormalmap(), KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KIS_ASSERT_RECOVER_RETURN, KoChannelInfo::name(), KisBaseConstIteratorNG::nextPixel(), KisHLineConstIteratorNG::nextRow(), KoColorSpace::normalisedChannelsValue(), KisBaseConstAccessor::oldRawData(), PHONG_HEIGHT_CHANNEL, PhongPixelProcessor::realheightmap, KoUpdater::setProgress(), USE_NORMALMAP_IS_ENABLED, and KisPaintDevice::writeBytes().

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

plugins/filters/phongbumpmap/kis_phong_bumpmap_filter.h
plugins/filters/phongbumpmap/kis_phong_bumpmap_filter.cpp

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisFilterPhongBumpmap()

Member Function Documentation

◆ changedRect()

◆ createConfigurationWidget()

◆ defaultConfiguration()

◆ neededRect()

◆ processImpl()