CFReorientedNormalMapCombine< channels_type > Struct Template Reference

#include <KoCompositeOpFunctions.h>

Inheritance diagram for CFReorientedNormalMapCombine< channels_type >:

Static Public Member Functions
static void	composeChannels (float srcR, float srcG, float srcB, float &dstR, float &dstG, float &dstB)
Static Public Member Functions inherited from KoClampedSourceAndDestinationCompositeOpGenericFunctorBase< channels_type >
static channels_type	clampDestinationChannelValue (channels_type value)
static channels_type	clampSourceChannelValue (channels_type value)

Detailed Description

template<typename channels_type>
struct CFReorientedNormalMapCombine< channels_type >

Definition at line 54 of file KoCompositeOpFunctions.h.

Member Function Documentation

composeChannels()

template<typename channels_type >

static void CFReorientedNormalMapCombine< channels_type >::composeChannels ( float srcR, float srcG, float srcB, float & dstR, float & dstG, float & dstB )

inlinestatic

If the source vector has zero height, then we should just skip all the changes (with seems to be the behavior of the formula around the null point)

If the destination vector has zero height, then we should skip its modification (since we cannot rotate it in any way

If the resulting length of the vector is zero, then just keep the destination unchanged. Usually it means that the destination vector is null (i.e. dstR == dstG == dstB == 0.5)

Definition at line 56 of file KoCompositeOpFunctions.h.

                                                                                                           {
        // see https://blog.selfshadow.com/publications/blending-in-detail/ by Barre-Brisebois and Hill
 
        using namespace Arithmetic;
 
        if (isZeroValueFuzzy(srcB)) {
            return;
        }
 
        float tx = 2*srcR-1;
        float ty = 2*srcG-1;
        float tz = 2*srcB;
        float ux = -2*dstR+1;
        float uy = -2*dstG+1;
        float uz = 2*dstB-1;
        float k = (tx*ux+ty*uy+tz*uz)/tz; // dot(t,u)/t.z
        float rx = tx*k-ux;
        float ry = ty*k-uy;
        float rz = tz*k-uz;
 
        float finalLength = rx*rx+ry*ry+rz*rz;
 
 
        if (isZeroValueStrict(finalLength)) {
            return;
        }
 
        k = 1 / sqrt(finalLength); // normalize result
        rx *= k;
        ry *= k;
        rz *= k;
        dstR = rx*0.5+0.5;
        dstG = ry*0.5+0.5;
        dstB = rz*0.5+0.5;
    }

---

The documentation for this struct was generated from the following file:

• libs/pigment/compositeops/KoCompositeOpFunctions.h