psblendmodes.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
#include <algorithm>
 
namespace nap
{
    namespace math
    {
        template <typename T>
        T darken(T target, T blend);
 
        template <typename T>
        T multiply(T target, T blend);
 
        template <typename T>
        T colorBurn(T target, T blend);
 
        template <typename T>
        T linearBurn(T target, T blend);
 
        template <typename T>
        T lighten(T target, T blend);
 
        template <typename T>
        T screen(T target, T blend);
 
        template <typename T>
        T colorDodge(T target, T blend);
 
        template <typename T>
        T linearDodge(T target, T blend);
 
        template <typename T>
        T overlay(T target, T blend);
 
        template <typename T>
        T softLight(T target, T blend);
 
        template <typename T>
        T hardLight(T target, T blend);
 
        template <typename T>
        T vividLight(T target, T blend);
 
        template <typename T>
        T linearLight(T target, T blend);
 
        template <typename T>
        T pinLight(T target, T blend);
 
        template <typename T>
        T difference(T target, T blend);
 
        template <typename T>
        T exclusion(T target, T blend);
    }
}
 
template <typename T>
T nap::math::darken(T target, T blend)
{
    return std::min(target, blend);
}
 
template <typename T>
T nap::math::multiply(T target, T blend)
{
    return target * blend;
}
 
template <typename T>
T nap::math::colorBurn(T target, T blend)
{
    return 1 - (1 - target) / blend;
}
 
template <typename T>
T nap::math::linearBurn(T target, T blend)
{
    return target + blend - 1;
}
 
template <typename T>
T nap::math::lighten(T target, T blend)
{
    return std::max(target, blend);
}
 
template <typename T>
T nap::math::screen(T target, T blend)
{
    return 1 - (1 - target) * (1 - blend);
}
 
template <typename T>
T nap::math::colorDodge(T target, T blend)
{
    return target / (1 - blend);
}
 
template <typename T>
T nap::math::linearDodge(T target, T blend)
{
    return target + blend;
}
 
template <typename T>
T nap::math::overlay(T target, T blend)
{
    if (target > 0.5)
        return (1 - (1 - 2 * (target - 0.5)) * (1 - blend));
    return ((2 * target) * blend);
}
 
template <typename T>
T nap::math::softLight(T target, T blend)
{
    if (blend > 0.5)
        return (1 - (1 - target) * (1 - (blend - 0.5)));
    return (blend <= 0.5) * (target * (blend + 0.5));
}
 
template <typename T>
T nap::math::hardLight(T target, T blend)
{
    if (blend > 0.5)
        return (1 - (1 - target) * (1 - 2 * (blend - 0.5)));
    return (blend <= 0.5) * (target * (2 * blend));
}
 
template <typename T>
T nap::math::vividLight(T target, T blend)
{
    if (blend > 0.5)
        return (1 - (1 - target) / (2 * (blend - 0.5)));
    return (target / (1 - 2 * blend));
}
 
template <typename T>
T nap::math::linearLight(T target, T blend)
{
    if (blend > 0.5)
        return (target + 2 * (blend - 0.5));
    return (blend <= 0.5) * (target + 2 * blend - 1);
}
 
template <typename T>
T nap::math::pinLight(T target, T blend)
{
    if (blend > 0.5)
        return (max(target, 2 * (blend - 0.5)));
    return (blend <= 0.5) * (min(target, 2 * blend));
}
 
template <typename T>
T nap::math::difference(T target, T blend)
{
    return target - blend;
}
 
template <typename T>
T nap::math::exclusion(T target, T blend)
{
    return 0.5 - 2 * (target - 0.5) * (blend - 0.5);
}