| /* | |
| * Copyright 2025 Rive | |
| */ | |
| #include "common/rand.hpp" | |
| #include <catch.hpp> | |
| // <array> is included in "cpp.glsl" so include it here first so that it | |
| // doesn't try to put all of its functions into the glsl_cross namespace | |
| #include <array> | |
| namespace glsl_cross | |
| { | |
| #ifdef _MSC_VER | |
| #pragma warning(push) | |
| // The shader code writes float constants without the "f" suffix, so disable | |
| // this warning since there ends up being a lot of it: | |
| // truncation from 'double' to 'glsl_cross::half' | |
| #pragma warning(disable : 4305) | |
| #endif | |
| #include "cpp.glsl" | |
| #include "generated/shaders/constants.minified.glsl" | |
| #if 0 | |
| // "common.glsl" is currently too complicated to compile for C++. If we really | |
| // need it we can make it work, but for now it works to just declare our own | |
| // version of a couple required functions | |
| #include "generated/shaders/common.minified.glsl" | |
| #else | |
| static half3 unmultiply_rgb(half4 premul) | |
| { | |
| // We *could* return preciesly 1 when premul.rgb == premul.a, but we can | |
| // also be approximate here. The blend modes that depend on this exact level | |
| // of precision (colordodge and colorburn) account for it with dstPremul. | |
| return premul.rgb * (premul.a != .0 ? 1. / premul.a : .0); | |
| } | |
| static half min_component(half3 v) { return min(v.x, min(v.y, v.z)); } | |
| static half max_component(half3 v) { return max(v.x, max(v.y, v.z)); } | |
| #endif | |
| #define FRAGMENT | |
| #define ENABLE_ADVANCED_BLEND true | |
| #define ENABLE_HSL_BLEND_MODES true | |
| #include "generated/shaders/advanced_blend.minified.glsl" | |
| #ifdef _MSC_VER | |
| #pragma warning(pop) | |
| #endif | |
| constexpr static float INF = std::numeric_limits<float>::infinity(); | |
| TEST_CASE("glsl_mix", "[advanced_blend]") | |
| { | |
| CHECK(simd::all(mix(make_half3(0, 0, 0), | |
| make_half3(1, 1, 1), | |
| equal(make_half3(1, 2, 3), make_half3(2))) == | |
| make_half3(0, 1, 0))); | |
| } | |
| TEST_CASE("glsl_sign", "[advanced_blend]") | |
| { | |
| CHECK(simd::all(sign(make_half4(-1, 0, .001f, 1)) == | |
| make_half4(-1, 0, 1, 1))); | |
| } | |
| TEST_CASE("glsl_unmultiply_rgb", "[advanced_blend]") | |
| { | |
| // 0 if a == 0 | |
| CHECK(simd::all(unmultiply_rgb(make_half4(0, 0, 0, 0)) == make_half3(0))); | |
| CHECK(simd::all(unmultiply_rgb(make_half4(.25f, .5f, .75f, 0)) == | |
| make_half3(0))); | |
| CHECK(simd::all(unmultiply_rgb(make_half4(-1, 0, 1, 0)) == make_half3(0))); | |
| CHECK(simd::all(unmultiply_rgb(make_half4(-1.0001f, 1, 1.0001f, 0)) == | |
| make_half3(0))); | |
| // rgb / a otherwise | |
| CHECK(simd::all(unmultiply_rgb(make_half4(.1f, .2f, .4f, .5f)) == | |
| make_half3(.2f, .4f, .8f))); | |
| } | |
| static half3 advanced_blend_coeffs_with_dst_alpha(half3 src, | |
| half3 dst, | |
| float dstAlpha, | |
| uint16_t mode) | |
| { | |
| return advanced_blend_coeffs(src, | |
| make_half4(dst.x * dstAlpha, | |
| dst.y * dstAlpha, | |
| dst.z * dstAlpha, | |
| dstAlpha), | |
| mode); | |
| } | |
| TEST_CASE("glsl_colordodge", "[advanced_blend]") | |
| { | |
| // If dstAlpha == 0, always 0, even if dst is invalid premul data. | |
| CHECK(simd::all(advanced_blend_coeffs(make_half3(0), | |
| make_half4(0, 0, 0, 0), | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all(advanced_blend_coeffs(make_half3(1, 1.001f, INF), | |
| make_half4(0, 0, 0, 0), | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all(advanced_blend_coeffs(make_half3(-.0001f, -1, -INF), | |
| make_half4(0, 0, 0, 0), | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all(advanced_blend_coeffs(make_half3(0), | |
| make_half4(.0001f, 1, INF, 0), | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all(advanced_blend_coeffs(make_half3(1, 1.001f, INF), | |
| make_half4(.0001f, 1, INF, 0), | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all(advanced_blend_coeffs(make_half3(-.0001f, -1, -INF), | |
| make_half4(.0001f, 1, INF, 0), | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all(advanced_blend_coeffs(make_half3(0), | |
| make_half4(-.0001f, -1, -INF, 0), | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all(advanced_blend_coeffs(make_half3(1, 1.001f, INF), | |
| make_half4(-.0001f, -1, -INF, 0), | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all(advanced_blend_coeffs(make_half3(-.0001f, -1, -INF), | |
| make_half4(-.0001f, -1, -INF, 0), | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| for (float dstAlpha : | |
| {0.f, 1.f / 255, .25f, .5f, 254.f / 255, 1.f, 256.f / 255}) | |
| { | |
| // 0, if Cd <= 0 | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(0), | |
| make_half3(0, -.001f, -1), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(0), | |
| make_half3(-10, -100, -INF), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(1), | |
| make_half3(0, -.001f, -1), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(1), | |
| make_half3(-10, -100, -INF), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(-INF, INF, NAN), | |
| make_half3(0, -.001f, -1), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(-INF, INF, NAN), | |
| make_half3(-10, -100, -INF), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 0)); | |
| // 1, if Cd > 0 and Cs >= 1 | |
| if (dstAlpha != 0) | |
| { | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(1, 1.00001f, 2), | |
| make_half3(1e-10f), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(10, 100, INF), | |
| make_half3(1e-10f), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(1, 1.00001f, 2), | |
| make_half3(1), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(10, 100, INF), | |
| make_half3(1), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(1, 1.00001f, 2), | |
| make_half3(1.0001f), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(10, 100, INF), | |
| make_half3(1.0001f), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(1, 1.00001f, 2), | |
| make_half3(INF), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(10, 100, INF), | |
| make_half3(INF), | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE) == 1)); | |
| } | |
| // min(1,Cd/(1-Cs)), if Cd > 0 and Cs < 1 | |
| Rand rando; | |
| for (int j = 0; j < 100; ++j) | |
| { | |
| half3 src = make_half3(rando.f32(), rando.f32(), rando.f32()); | |
| assert(simd::all(0 <= src && src <= 1)); | |
| half3 dst = dstAlpha == 0 | |
| ? make_half3(0) | |
| : make_half3(rando.f32(), rando.f32(), rando.f32()); | |
| assert(simd::all(0 <= dst && dst <= 1)); | |
| half3 coeffs = | |
| advanced_blend_coeffs_with_dst_alpha(src, | |
| dst, | |
| dstAlpha, | |
| BLEND_MODE_COLORDODGE); | |
| for (int i = 0; i < 3; ++i) | |
| { | |
| if (dst[i] <= 0) | |
| CHECK(coeffs[i] == 0); | |
| else if (src[i] >= 1) | |
| CHECK(coeffs[i] == 1); | |
| else | |
| CHECK(coeffs[i] == | |
| Approx(std::min(1.f, dst[i] / (1 - src[i])))); | |
| } | |
| } | |
| } | |
| } | |
| TEST_CASE("glsl_colorburn", "[advanced_blend]") | |
| { | |
| for (float dstAlpha : | |
| {.0f, 1.f / 255, .25f, .5f, 254.f / 255, 1.f, 256.f / 255}) | |
| { | |
| // 1, if Cd >= 1 | |
| if (dstAlpha != 0) | |
| { | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(0), | |
| make_half3(1, 1.001f, 2), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(0), | |
| make_half3(10, 100, INF), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(1), | |
| make_half3(1, 1.001f, 2), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(1), | |
| make_half3(10, 100, INF), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(-INF, INF, NAN), | |
| make_half3(1, 1.001f, 2), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 1)); | |
| CHECK(simd::all(advanced_blend_coeffs_with_dst_alpha( | |
| make_half3(-INF, INF, NAN), | |
| make_half3(10, 100, INF), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 1)); | |
| } | |
| // 0, if Cd < 1 and Cs <= 0 | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(0, -1e-1f, -1), | |
| make_half3(1 - 1e-6f), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(-10, -100, -INF), | |
| make_half3(1 - 1e-6f), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(0, -1e-1f, -1), | |
| make_half3(0), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(-10, -100, -INF), | |
| make_half3(0), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(0, -1e-1f, -1), | |
| make_half3(-1e-6f), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(-10, -100, -INF), | |
| make_half3(-1e-6f), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(0, -1e-1f, -1), | |
| make_half3(-INF), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 0)); | |
| CHECK(simd::all( | |
| advanced_blend_coeffs_with_dst_alpha(make_half3(-10, -100, -INF), | |
| make_half3(-INF), | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN) == 0)); | |
| // 1 - min(1,(1-Cd)/Cs), if Cd < 1 and Cs > 0 | |
| Rand rando; | |
| for (int j = 0; j < 100; ++j) | |
| { | |
| half3 src = make_half3(rando.f32(), rando.f32(), rando.f32()); | |
| assert(simd::all(0 <= src && src <= 1)); | |
| half3 dst = dstAlpha == 0 | |
| ? make_half3(0) | |
| : make_half3(rando.f32(), rando.f32(), rando.f32()); | |
| assert(simd::all(0 <= dst && dst <= 1)); | |
| half3 coeffs = | |
| advanced_blend_coeffs_with_dst_alpha(src, | |
| dst, | |
| dstAlpha, | |
| BLEND_MODE_COLORBURN); | |
| for (int i = 0; i < 3; ++i) | |
| { | |
| if (dst[i] >= 1 && dstAlpha != 0) | |
| CHECK(coeffs[i] == 1); | |
| else if (src[i] <= 0) | |
| CHECK(coeffs[i] == 0); | |
| else | |
| CHECK(coeffs[i] == | |
| Approx(1.f - std::min(1.f, (1.f - dst[i]) / src[i]))); | |
| } | |
| } | |
| } | |
| } | |
| namespace blend_spec_functions | |
| { | |
| using vec3 = simd::gvec<float, 3>; | |
| using simd::dot; | |
| // Functions copied (nearly) unmodified (except for formatting) from | |
| // https://registry.khronos.org/OpenGL/extensions/NV/NV_blend_equation_advanced.txt | |
| float minv3(vec3 c) { return min(min(c.r, c.g), c.b); } | |
| float maxv3(vec3 c) { return max(max(c.r, c.g), c.b); } | |
| float lumv3(vec3 c) { return dot(c, vec3{0.30f, 0.59f, 0.11f}); } | |
| float satv3(vec3 c) { return maxv3(c) - minv3(c); } | |
| // If any color components are outside [0,1], adjust the color to | |
| // get the components in range. | |
| vec3 ClipColor(vec3 color) | |
| { | |
| float lum = lumv3(color); | |
| float mincol = minv3(color); | |
| float maxcol = maxv3(color); | |
| if (mincol < 0.0) | |
| { | |
| color = lum + ((color - lum) * lum) / (lum - mincol); | |
| } | |
| if (maxcol > 1.0) | |
| { | |
| color = lum + ((color - lum) * (1 - lum)) / (maxcol - lum); | |
| } | |
| return color; | |
| } | |
| // Take the base RGB color <cbase> and override its luminosity | |
| // with that of the RGB color <clum>. | |
| vec3 SetLum(vec3 cbase, vec3 clum) | |
| { | |
| float lbase = lumv3(cbase); | |
| float llum = lumv3(clum); | |
| float ldiff = llum - lbase; | |
| vec3 color = cbase + vec3(ldiff); | |
| return ClipColor(color); | |
| } | |
| // Take the base RGB color <cbase> and override its saturation with | |
| // that of the RGB color <csat>. The override the luminosity of the | |
| // result with that of the RGB color <clum>. | |
| vec3 SetLumSat(vec3 cbase, vec3 csat, vec3 clum) | |
| { | |
| float minbase = minv3(cbase); | |
| float sbase = satv3(cbase); | |
| float ssat = satv3(csat); | |
| vec3 color; | |
| if (sbase > 0) | |
| { | |
| // Equivalent (modulo rounding errors) to setting the | |
| // smallest (R,G,B) component to 0, the largest to <ssat>, | |
| // and interpolating the "middle" component based on its | |
| // original value relative to the smallest/largest. | |
| color = (cbase - minbase) * ssat / sbase; | |
| } | |
| else | |
| { | |
| color = vec3(0.0); | |
| } | |
| return SetLum(color, clum); | |
| } | |
| } // namespace blend_spec_functions | |
| // Helper to compare the outputs of 2 functions over a reasonable selection of | |
| // color values. | |
| template <typename Func1, typename Func2> | |
| void test_color_pairs(Func1&& func1, Func2&& func2) | |
| { | |
| constexpr auto COLOR_STEP_COUNT = 6; | |
| for (int riX = 0; riX < COLOR_STEP_COUNT; riX++) | |
| { | |
| for (int giX = 0; giX < COLOR_STEP_COUNT; giX++) | |
| { | |
| for (int biX = 0; biX < COLOR_STEP_COUNT; biX++) | |
| { | |
| for (int riY = 0; riY < COLOR_STEP_COUNT; riY++) | |
| { | |
| for (int giY = 0; giY < COLOR_STEP_COUNT; giY++) | |
| { | |
| for (int biY = 0; biY < COLOR_STEP_COUNT; biY++) | |
| { | |
| simd::gvec<float, 3> x = { | |
| float(riX) / float(COLOR_STEP_COUNT - 1), | |
| float(giX) / float(COLOR_STEP_COUNT - 1), | |
| float(biX) / float(COLOR_STEP_COUNT - 1), | |
| }; | |
| simd::gvec<float, 3> y = { | |
| float(riY) / float(COLOR_STEP_COUNT - 1), | |
| float(giY) / float(COLOR_STEP_COUNT - 1), | |
| float(biY) / float(COLOR_STEP_COUNT - 1), | |
| }; | |
| // Snap the colors to 8-bit values | |
| x = simd::floor(x * 255.0f) / 255.0f; | |
| y = simd::floor(x * 255.0f) / 255.0f; | |
| auto r1 = func1(x, y); | |
| auto r2 = func2(x, y); | |
| auto d = r1 - r2; | |
| float maxDiff = | |
| max(std::abs(blend_spec_functions::minv3(d)), | |
| blend_spec_functions::maxv3(d)); | |
| CHECK(maxDiff <= 1e-4); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| TEST_CASE("glsl_color_blend", "[advanced_blend]") | |
| { | |
| test_color_pairs( | |
| [](auto a, auto b) { return blend_spec_functions::SetLum(a, b); }, | |
| [](auto a, auto b) { | |
| return glsl_cross::advanced_blend_coeffs_with_dst_alpha( | |
| a, | |
| b, | |
| 1.0f, | |
| BLEND_MODE_COLOR); | |
| }); | |
| } | |
| TEST_CASE("glsl_luminosity_blend", "[advanced_blend]") | |
| { | |
| test_color_pairs( | |
| [](auto a, auto b) { return blend_spec_functions::SetLum(b, a); }, | |
| [](auto a, auto b) { | |
| return glsl_cross::advanced_blend_coeffs_with_dst_alpha( | |
| a, | |
| b, | |
| 1.0f, | |
| BLEND_MODE_LUMINOSITY); | |
| }); | |
| } | |
| TEST_CASE("glsl_saturation_blend", "[advanced_blend]") | |
| { | |
| test_color_pairs( | |
| [](auto a, auto b) { return blend_spec_functions::SetLumSat(b, a, b); }, | |
| [](auto a, auto b) { | |
| return glsl_cross::advanced_blend_coeffs_with_dst_alpha( | |
| a, | |
| b, | |
| 1.0f, | |
| BLEND_MODE_SATURATION); | |
| }); | |
| } | |
| TEST_CASE("glsl_hue_blend", "[advanced_blend]") | |
| { | |
| test_color_pairs( | |
| [](auto a, auto b) { return blend_spec_functions::SetLumSat(a, b, b); }, | |
| [](auto a, auto b) { | |
| return glsl_cross::advanced_blend_coeffs_with_dst_alpha( | |
| a, | |
| b, | |
| 1.0f, | |
| BLEND_MODE_HUE); | |
| }); | |
| } | |
| } // namespace glsl_cross |