gimp_bump_map.cpp File Reference

#include "gimp_bump_map.h"
#include <QRect>
#include "kis_pixel_selection.h"
#include "kis_image.h"
#include <memory>

Go to the source code of this file.

Classes
struct	bumpmap_params_t

Macros
#define	CLAMP(x, l, h)   qBound(l, x, h)
#define	G_PI   M_PI
#define	MAX(x, y)   qMax(x,y)
#define	MIN(x, y)   qMin(x,y)
#define	MOD(x, y)   ((x) % (y))

Typedefs
typedef bool	gboolean
typedef double	gdouble
typedef int	gint
typedef qint32	gint32
typedef quint8	guchar

Functions
void	bumpmap (KisPixelSelectionSP device, const QRect &selectionRect, const bumpmap_vals_t &bmvals)
void	bumpmap_init_params (bumpmap_params_t *params, const bumpmap_vals_t &bmvals)
void	bumpmap_row (const bumpmap_vals_t &bmvals, guchar *dest, gint width, const guchar *bm_row1, const guchar *bm_row2, const guchar *bm_row3, bumpmap_params_t *params)
void	convertRow (quint8 *data, int width, const quint8 *lut)

Macro Definition Documentation

CLAMP

#define CLAMP	(		x,
			l,
			h )   qBound(l, x, h)

Definition at line 30 of file gimp_bump_map.cpp.

G_PI

#define G_PI   M_PI

Definition at line 28 of file gimp_bump_map.cpp.

MAX

#define MAX	(		x,
			y )   qMax(x,y)

Definition at line 31 of file gimp_bump_map.cpp.

MIN

#define MIN	(		x,
			y )   qMin(x,y)

Definition at line 32 of file gimp_bump_map.cpp.

MOD

#define MOD	(		x,
			y )   ((x) % (y))

Definition at line 29 of file gimp_bump_map.cpp.

Typedef Documentation

gboolean

typedef bool gboolean

Definition at line 24 of file gimp_bump_map.cpp.

gdouble

typedef double gdouble

Definition at line 26 of file gimp_bump_map.cpp.

gint

typedef int gint

Definition at line 22 of file gimp_bump_map.cpp.

gint32

typedef qint32 gint32

Definition at line 23 of file gimp_bump_map.cpp.

guchar

typedef quint8 guchar

Definition at line 25 of file gimp_bump_map.cpp.

Function Documentation

bumpmap()

void bumpmap	(	KisPixelSelectionSP	device,
		const QRect &	selectionRect,
		const bumpmap_vals_t &	bmvals )

Definition at line 64 of file gimp_bump_map.cpp.

{
    KIS_ASSERT_RECOVER_RETURN(bmvals.xofs == 0);
    KIS_ASSERT_RECOVER_RETURN(bmvals.yofs == 0);
 
    bumpmap_params_t  params;
    bumpmap_init_params (&params, bmvals);
 
    const QRect dataRect = kisGrowRect(selectionRect, 1);
 
    const int dataRowSize = dataRect.width() * sizeof(quint8);
    const int selectionRowSize = selectionRect.width() * sizeof(quint8);
    QScopedArrayPointer<quint8> dstRow(new quint8[selectionRowSize]);
 
    std::unique_ptr<quint8[]> bmRow1(new quint8[dataRowSize]);
    std::unique_ptr<quint8[]> bmRow2(new quint8[dataRowSize]);
    std::unique_ptr<quint8[]> bmRow3(new quint8[dataRowSize]);
 
    device->readBytes(bmRow1.get(), dataRect.left(), dataRect.top(), dataRect.width(), 1);
    device->readBytes(bmRow2.get(), dataRect.left(), dataRect.top() + 1, dataRect.width(), 1);
    device->readBytes(bmRow3.get(), dataRect.left(), dataRect.top() + 2, dataRect.width(), 1);
 
    convertRow(bmRow1.get(), dataRect.width(), params.lut);
    convertRow(bmRow2.get(), dataRect.width(), params.lut);
    convertRow(bmRow3.get(), dataRect.width(), params.lut);
 
    for (int row = selectionRect.top();
         row < selectionRect.top() + selectionRect.height(); row++) {
 
        bumpmap_row (bmvals, dstRow.data(), selectionRect.width(),
                     bmRow1.get() + 1, bmRow2.get() + 1, bmRow3.get() + 1,
                     &params);
 
        device->writeBytes(dstRow.data(), selectionRect.left(), row, selectionRect.width(), 1);
 
        bmRow1.swap(bmRow2);
        bmRow2.swap(bmRow3);
 
        device->readBytes(bmRow3.get(), dataRect.left(), row + 1, dataRect.width(), 1);
        convertRow(bmRow3.get(), dataRect.width(), params.lut);
    }
}

References bumpmap_init_params(), bumpmap_row(), convertRow(), KIS_ASSERT_RECOVER_RETURN, kisGrowRect(), bumpmap_params_t::lut, KisPaintDevice::readBytes(), KisPaintDevice::writeBytes(), bumpmap_vals_t::xofs, and bumpmap_vals_t::yofs.

bumpmap_init_params()

void bumpmap_init_params	(	bumpmap_params_t *	params,
		const bumpmap_vals_t &	bmvals )

Definition at line 109 of file gimp_bump_map.cpp.

{
  /* Convert to radians */
  const gdouble azimuth   = G_PI * bmvals.azimuth / 180.0;
  const gdouble elevation = G_PI * bmvals.elevation / 180.0;
 
  gint lz, nz;
  gint i;
 
  /* Calculate the light vector */
  params->lx = cos (azimuth) * cos (elevation) * 255.0;
  params->ly = sin (azimuth) * cos (elevation) * 255.0;
  lz         = sin (elevation) * 255.0;
 
  /* Calculate constant Z component of surface normal */
  /*              (depth may be 0 if non-interactive) */
  nz           = (6 * 255) / qMax (bmvals.depth, 1);
  params->nz2  = nz * nz;
  params->nzlz = nz * lz;
 
  /* Optimize for vertical normals */
  params->background = lz;
 
  /* Calculate darkness compensation factor */
  params->compensation = sin(elevation);
 
  /* Create look-up table for map type */
  for (i = 0; i < 256; i++)
    {
      gdouble n;
 
      switch (bmvals.type)
        {
        case SPHERICAL:
          n = i / 255.0 - 1.0;
          params->lut[i] = (int) (255.0 * sqrt(1.0 - n * n) + 0.5);
          break;
 
        case SINUSOIDAL:
          n = i / 255.0;
          params->lut[i] = (int) (255.0 *
                                  (sin((-G_PI / 2.0) + G_PI * n) + 1.0) /
                                  2.0 + 0.5);
          break;
 
        case LINEAR:
        default:
          params->lut[i] = i;
        }
 
      if (bmvals.invert)
        params->lut[i] = 255 - params->lut[i];
    }
}

References bumpmap_vals_t::azimuth, bumpmap_params_t::background, bumpmap_params_t::compensation, bumpmap_vals_t::depth, bumpmap_vals_t::elevation, G_PI, bumpmap_vals_t::invert, LINEAR, bumpmap_params_t::lut, bumpmap_params_t::lx, bumpmap_params_t::ly, bumpmap_params_t::nz2, bumpmap_params_t::nzlz, SINUSOIDAL, SPHERICAL, and bumpmap_vals_t::type.

bumpmap_row()

void bumpmap_row	(	const bumpmap_vals_t &	bmvals,
		guchar *	dest,
		gint	width,
		const guchar *	bm_row1,
		const guchar *	bm_row2,
		const guchar *	bm_row3,
		bumpmap_params_t *	params )

Definition at line 165 of file gimp_bump_map.cpp.

{
    gint xofs1, xofs2;
    gint x;
 
    for (x = 0; x < width; x++) {
        gint xofs3;
        gint shade;
        gint nx, ny;
 
        /* Calculate surface normal from bump map */
 
        xofs2 = x;
        xofs1 = xofs2 - 1;
        xofs3 = xofs2 + 1;
 
        nx = (bm_row1[xofs1] + bm_row2[xofs1] + bm_row3[xofs1] -
              bm_row1[xofs3] - bm_row2[xofs3] - bm_row3[xofs3]);
        ny = (bm_row3[xofs1] + bm_row3[xofs2] + bm_row3[xofs3] -
              bm_row1[xofs1] - bm_row1[xofs2] - bm_row1[xofs3]);
 
        /* Shade */
 
        if ((nx == 0) && (ny == 0)) {
            shade = params->background;
        } else {
            gint ndotl = nx * params->lx + ny * params->ly + params->nzlz;
 
            if (ndotl < 0) {
                shade = params->compensation * bmvals.ambient;
            } else {
                shade = ndotl / sqrt (nx * nx + ny * ny + params->nz2);
 
                shade = shade + MAX(0.0, (255 * params->compensation - shade)) *
                    bmvals.ambient / 255;
            }
        }
 
        /* Paint */
 
        if (bmvals.compensate) {
            int result  = shade / params->compensation;
            *dest++ = MIN(255, result);
        } else {
            *dest++ = shade;
        }
    }
}

References bumpmap_vals_t::ambient, bumpmap_params_t::background, bumpmap_vals_t::compensate, bumpmap_params_t::compensation, bumpmap_params_t::lx, bumpmap_params_t::ly, MAX, MIN, bumpmap_params_t::nz2, and bumpmap_params_t::nzlz.

convertRow()

void convertRow	(	quint8 *	data,
		int	width,
		const quint8 *	lut )

Definition at line 56 of file gimp_bump_map.cpp.

{
    for (int i = 0; i < width; i++) {
        *data = lut[*data];
        data++;
    }
}