KisTangentTiltOption Class Reference

#include <KisTangentTiltOption.h>

Public Member Functions
void	apply (const KisPaintInformation &info, qreal *r, qreal *g, qreal *b)
	KisTangentTiltOption (const KisPropertiesConfiguration *setting)
void	swizzleAssign (qreal const horizontal, qreal const vertical, qreal const depth, qreal *component, int index, qreal maxvalue)

Private Member Functions
	KisTangentTiltOption (const KisTangentTiltOptionData &data)

Private Attributes
int	m_blueChannel
TangentTiltDirectionType	m_directionType
double	m_elevationSensitivity
int	m_greenChannel
double	m_mixValue
int	m_redChannel

Detailed Description

Definition at line 14 of file KisTangentTiltOption.h.

Constructor & Destructor Documentation

KisTangentTiltOption() [1/2]

KisTangentTiltOption::KisTangentTiltOption

(

const KisPropertiesConfiguration *

setting

)

Definition at line 12 of file KisTangentTiltOption.cpp.

    : KisTangentTiltOption(kpou::loadOptionData<KisTangentTiltOptionData>(setting))
{
}

KisTangentTiltOption() [2/2]

KisTangentTiltOption::KisTangentTiltOption ( const KisTangentTiltOptionData & data )

private

Definition at line 17 of file KisTangentTiltOption.cpp.

    : m_redChannel(data.redChannel)
    , m_greenChannel(data.greenChannel)
    , m_blueChannel(data.blueChannel)
    , m_directionType(data.directionType)
    , m_elevationSensitivity(data.elevationSensitivity)
    , m_mixValue(data.mixValue)
{
}

Member Function Documentation

apply()

void KisTangentTiltOption::apply	(	const KisPaintInformation &	info,
		qreal *	r,
		qreal *	g,
		qreal *	b )

Definition at line 39 of file KisTangentTiltOption.cpp.

{
    //formula based on https://www.cerebralmeltdown.com/programming_projects/Altitude%20and%20Azimuth%20to%20Vector/index.html
 
    /* It doesn't make sense of have higher than 8bit color depth.
     * Instead we make sure in the paintAt function of kis_tangent_normal_paintop to pick an 8bit space of the current
     * color space if the space is an RGB space. If not, it'll pick sRGB 8bit.
     */
    qreal halfvalue = 0.5;
    qreal maxvalue = 1.0;
 
    //have the azimuth and altitude in degrees.
    qreal direction = KisPaintInformation::tiltDirection(info, true)*360.0;
    qreal elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
 
    if (m_directionType == TangentTiltDirectionType::Tilt) {
        direction = KisPaintInformation::tiltDirection(info, true)*360.0;
        elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
    } else if (m_directionType == TangentTiltDirectionType::Direction) {
        direction = (0.75 + info.drawingAngle() / (2.0 * M_PI))*360.0;
        elevation= 0;//turns out that tablets that don't support tilt just return 90 degrees for elevation.
    } else if (m_directionType == TangentTiltDirectionType::Rotation) {
        direction = info.rotation();
        elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);//artpens have tilt-recognition, so this should work.
    } else if (m_directionType == TangentTiltDirectionType::Mix) {//mix of tilt+direction
        qreal mixamount = m_mixValue/100.0;
        direction = (KisPaintInformation::tiltDirection(info, true)*360.0*(1.0-mixamount))+((0.75 + info.drawingAngle() / (2.0 * M_PI))*360.0*(mixamount));
        elevation= (info.tiltElevation(info, 60.0, 60.0, true)*90.0);
    }
 
    //subtract/add the rotation of the canvas.
    if (m_directionType != TangentTiltDirectionType::Direction) {
        direction = normalizeAngleDegrees(direction - info.canvasRotation());
    }
 
    //limit the direction/elevation
 
    //qreal elevationMax = (m_elevationSensitivity*90.0)/100.0;
    qreal elevationT = elevation*(m_elevationSensitivity/100.0)+(90-(m_elevationSensitivity*90.0)/100.0);
    elevation = static_cast<int>(elevationT);
 
    //convert to radians.
    // Convert this to kis_global's radian function.
    direction = kisDegreesToRadians(direction);
    elevation = kisDegreesToRadians(elevation);
 
    //make variables for axes for easy switching later on.
    qreal horizontal, vertical, depth;
 
    //spherical coordinates always center themselves around the origin, leading to values. We need to work around those...
 
    horizontal = cos(elevation)*sin(direction);
    if (horizontal>0.0) {
        horizontal= halfvalue+(fabs(horizontal)*halfvalue);
    }
    else {
        horizontal= halfvalue-(fabs(horizontal)*halfvalue);
    }
    vertical = cos(elevation)*cos(direction);
    if (vertical>0.0) {
        vertical = halfvalue+(fabs(vertical)*halfvalue);
    }
    else {
        vertical = halfvalue-(fabs(vertical)*halfvalue);
    }
 
    if (info.canvasMirroredH()) {horizontal = maxvalue - horizontal;}
    if (info.canvasMirroredV()) {vertical = maxvalue - vertical;}
 
    depth = sin(elevation)*maxvalue;
 
    //assign right components to correct axes.
    swizzleAssign(horizontal, vertical, depth, r, m_redChannel, maxvalue);
    swizzleAssign(horizontal, vertical, depth, g, m_greenChannel, maxvalue);
    swizzleAssign(horizontal, vertical, depth, b, m_blueChannel, maxvalue);
}

References KisPaintInformation::canvasMirroredH(), KisPaintInformation::canvasMirroredV(), KisPaintInformation::canvasRotation(), Direction, KisPaintInformation::drawingAngle(), kisDegreesToRadians(), m_blueChannel, m_directionType, m_elevationSensitivity, m_greenChannel, m_mixValue, M_PI, m_redChannel, Mix, normalizeAngleDegrees(), KisPaintInformation::rotation(), Rotation, swizzleAssign(), Tilt, KisPaintInformation::tiltDirection(), and KisPaintInformation::tiltElevation().

swizzleAssign()

void KisTangentTiltOption::swizzleAssign	(	qreal const	horizontal,
		qreal const	vertical,
		qreal const	depth,
		qreal *	component,
		int	index,
		qreal	maxvalue )

Definition at line 27 of file KisTangentTiltOption.cpp.

{
    switch(index) {
    case 0: *component = horizontal; break;
    case 1: *component = maxvalue-horizontal; break;
    case 2: *component = vertical; break;
    case 3: *component = maxvalue-vertical; break;
    case 4: *component = depth; break;
    case 5: *component = maxvalue-depth; break;
    }
}

Member Data Documentation

m_blueChannel

int KisTangentTiltOption::m_blueChannel

private

Definition at line 30 of file KisTangentTiltOption.h.

m_directionType

TangentTiltDirectionType KisTangentTiltOption::m_directionType

private

Definition at line 31 of file KisTangentTiltOption.h.

m_elevationSensitivity

double KisTangentTiltOption::m_elevationSensitivity

private

Definition at line 32 of file KisTangentTiltOption.h.

m_greenChannel

int KisTangentTiltOption::m_greenChannel

private

Definition at line 29 of file KisTangentTiltOption.h.

m_mixValue

double KisTangentTiltOption::m_mixValue

private

Definition at line 33 of file KisTangentTiltOption.h.

m_redChannel

int KisTangentTiltOption::m_redChannel

private

Definition at line 28 of file KisTangentTiltOption.h.

---

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

• plugins/paintops/tangentnormal/KisTangentTiltOption.h
• plugins/paintops/tangentnormal/KisTangentTiltOption.cpp