DPF

DISTRHO Plugin Framework
Log | Files | Refs | Submodules | README | LICENSE

Color.cpp (10687B)


      1 /*
      2  * DISTRHO Plugin Framework (DPF)
      3  * Copyright (C) 2012-2021 Filipe Coelho <falktx@falktx.com>
      4  *
      5  * Permission to use, copy, modify, and/or distribute this software for any purpose with
      6  * or without fee is hereby granted, provided that the above copyright notice and this
      7  * permission notice appear in all copies.
      8  *
      9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
     10  * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
     11  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
     12  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
     13  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
     14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
     15  */
     16 
     17 #include "tests.hpp"
     18 
     19 #define DPF_TEST_COLOR_CPP
     20 #include "dgl/src/Color.cpp"
     21 
     22 // --------------------------------------------------------------------------------------------------------------------
     23 
     24 int main()
     25 {
     26     USE_NAMESPACE_DGL;
     27 
     28     // constructor with no arguments, must give solid black
     29     {
     30         Color c;
     31         DISTRHO_ASSERT_EQUAL(c.red, 0.0f, "red value is 0");
     32         DISTRHO_ASSERT_EQUAL(c.green, 0.0f, "green value is 0");
     33         DISTRHO_ASSERT_EQUAL(c.blue, 0.0f, "blue value is 0");
     34         DISTRHO_ASSERT_EQUAL(c.alpha, 1.0f, "alpha value is 1");
     35     }
     36 
     37     // constructor gives correct floating-point values (arguments are r, g, b, a; in order)
     38     {
     39         Color c(0.1f, 0.2f, 0.3f, 0.4f);
     40         DISTRHO_ASSERT_EQUAL(c.red, 0.1f, "red value is 0.1");
     41         DISTRHO_ASSERT_EQUAL(c.green, 0.2f, "green value is 0.2");
     42         DISTRHO_ASSERT_EQUAL(c.blue, 0.3f, "blue value is 0.3");
     43         DISTRHO_ASSERT_EQUAL(c.alpha, 0.4f, "alpha value is 0.4");
     44     }
     45 
     46     // constructor gives correct integer values normalized to float (arguments are r, g, b, a; in order)
     47     {
     48         Color c(51, 102, 153);
     49         DISTRHO_ASSERT_SAFE_EQUAL(c.red, 0.2f, "red value is 0.2 (integer 51)");
     50         DISTRHO_ASSERT_SAFE_EQUAL(c.green, 0.4f, "green value is 0.4 (integer 102)");
     51         DISTRHO_ASSERT_SAFE_EQUAL(c.blue, 0.6f, "blue value is 0.6 (integer 153)");
     52         DISTRHO_ASSERT_SAFE_EQUAL(c.alpha, 1.0f, "alpha value is 1");
     53 
     54         Color white(255, 255, 255);
     55         DISTRHO_ASSERT_EQUAL(white.red, 1.0f, "white's red value is 1");
     56         DISTRHO_ASSERT_EQUAL(white.green, 1.0f, "white's green value is 1");
     57         DISTRHO_ASSERT_EQUAL(white.blue, 1.0f, "white's blue value is 1");
     58         DISTRHO_ASSERT_EQUAL(white.alpha, 1.0f, "white alpha value is 1");
     59     }
     60 
     61     // copy colors around
     62     {
     63         Color black;
     64         Color halfTransparentWhite(1.0f, 1.0f, 1.0f, 0.5f);
     65 
     66         // constructor copy
     67         Color test(halfTransparentWhite);
     68         DISTRHO_ASSERT_EQUAL(test.red, 1.0f, "copied white's red value is 1.0");
     69         DISTRHO_ASSERT_EQUAL(test.green, 1.0f, "copied white's green value is 1");
     70         DISTRHO_ASSERT_EQUAL(test.blue, 1.0f, "copied white's blue value is 1");
     71         DISTRHO_ASSERT_EQUAL(test.alpha, 0.5f, "copied white's alpha value is 0.5");
     72 
     73         // assign operator
     74         test = black;
     75         DISTRHO_ASSERT_EQUAL(test.red, 0.0f, "assigned black's red value is 0");
     76         DISTRHO_ASSERT_EQUAL(test.green, 0.0f, "assigned black's green value is 0");
     77         DISTRHO_ASSERT_EQUAL(test.blue, 0.0f, "assigned black's blue value is 0");
     78         DISTRHO_ASSERT_EQUAL(test.alpha, 1.0f, "assigned black's alpha value is 1");
     79     }
     80 
     81     // simple color comparisons
     82     {
     83         Color black1, black2;
     84         Color white(1.0f, 1.0f, 1.0f);
     85         Color halfTransparentWhite(1.0f, 1.0f, 1.0f, 0.5f);
     86 
     87         // logic operators
     88         DISTRHO_ASSERT_EQUAL(black1, black1, "color equals itself");
     89         DISTRHO_ASSERT_EQUAL(black1, black2, "black equals black");
     90         DISTRHO_ASSERT_NOT_EQUAL(black1, white, "black is not white");
     91         DISTRHO_ASSERT_NOT_EQUAL(black1, halfTransparentWhite, "black is not half-transparent white");
     92         DISTRHO_ASSERT_NOT_EQUAL(white, halfTransparentWhite, "white is not half-transparent white");
     93 
     94         // class functions (truthful)
     95         DISTRHO_ASSERT_EQUAL(black1.isEqual(black1), true, "color equals itself");
     96         DISTRHO_ASSERT_EQUAL(black1.isEqual(black2), true, "black equals black");
     97         DISTRHO_ASSERT_EQUAL(black1.isNotEqual(white), true, "black is not white");
     98         DISTRHO_ASSERT_EQUAL(white.isNotEqual(halfTransparentWhite), true, "white is not half-transparent white");
     99 
    100         // class functions (inverted)
    101         DISTRHO_ASSERT_EQUAL(black1.isNotEqual(black1), false, "color equals itself");
    102         DISTRHO_ASSERT_EQUAL(black1.isNotEqual(black2), false, "black equals black");
    103         DISTRHO_ASSERT_EQUAL(black1.isEqual(white), false, "black is not white");
    104         DISTRHO_ASSERT_EQUAL(white.isEqual(halfTransparentWhite), false, "white is not half-transparent white");
    105 
    106         // class functions ignoring alpha
    107         DISTRHO_ASSERT_EQUAL(black1.isEqual(black1, false), true, "color equals itself");
    108         DISTRHO_ASSERT_EQUAL(black1.isEqual(black2, false), true, "black equals black");
    109         DISTRHO_ASSERT_EQUAL(black1.isNotEqual(white, false), true, "black is not white");
    110         DISTRHO_ASSERT_EQUAL(white.isEqual(halfTransparentWhite, false), true,
    111                              "white is half-transparent white if we ignore alpha");
    112     }
    113 
    114     // TODO advanced color comparisons
    115     {
    116     }
    117 
    118     // TODO fromHSL
    119     {
    120     }
    121 
    122     // create colors from html strings
    123     {
    124         Color c000 = Color::fromHTML("#000");
    125         DISTRHO_ASSERT_EQUAL(c000.red, 0.0f, "#000 red value is 0");
    126         DISTRHO_ASSERT_EQUAL(c000.green, 0.0f, "#000 green value is 0");
    127         DISTRHO_ASSERT_EQUAL(c000.blue, 0.0f, "#000 blue value is 0");
    128         DISTRHO_ASSERT_EQUAL(c000.alpha, 1.0f, "#000 alpha value is 1");
    129 
    130         Color c000000 = Color::fromHTML("#000000");
    131         DISTRHO_ASSERT_EQUAL(c000000.red, 0.0f, "#000000 red value is 0");
    132         DISTRHO_ASSERT_EQUAL(c000000.green, 0.0f, "#000000 green value is 0");
    133         DISTRHO_ASSERT_EQUAL(c000000.blue, 0.0f, "#000000 blue value is 0");
    134         DISTRHO_ASSERT_EQUAL(c000000.alpha, 1.0f, "#000000 alpha value is 1");
    135 
    136         Color cfff = Color::fromHTML("#fff");
    137         DISTRHO_ASSERT_EQUAL(cfff.red, 1.0f, "#fff red value is 1");
    138         DISTRHO_ASSERT_EQUAL(cfff.green, 1.0f, "#fff green value is 1");
    139         DISTRHO_ASSERT_EQUAL(cfff.blue, 1.0f, "#fff blue value is 1");
    140         DISTRHO_ASSERT_EQUAL(cfff.alpha, 1.0f, "#fff alpha value is 1");
    141 
    142         Color cffffff = Color::fromHTML("#ffffff");
    143         DISTRHO_ASSERT_EQUAL(cffffff.red, 1.0f, "#ffffff red value is 1");
    144         DISTRHO_ASSERT_EQUAL(cffffff.green, 1.0f, "#ffffff green value is 1");
    145         DISTRHO_ASSERT_EQUAL(cffffff.blue, 1.0f, "#ffffff blue value is 1");
    146         DISTRHO_ASSERT_EQUAL(cffffff.alpha, 1.0f, "#ffffff alpha value is 1");
    147 
    148         Color cf00 = Color::fromHTML("#f00");
    149         DISTRHO_ASSERT_EQUAL(cf00.red, 1.0f, "#f00 red value is 1");
    150         DISTRHO_ASSERT_EQUAL(cf00.green, 0.0f, "#f00 green value is 0");
    151         DISTRHO_ASSERT_EQUAL(cf00.blue, 0.0f, "#f00 blue value is 0");
    152 
    153         Color cff0000 = Color::fromHTML("#ff0000");
    154         DISTRHO_ASSERT_EQUAL(cff0000.red, 1.0f, "#ff0000 red value is 1");
    155         DISTRHO_ASSERT_EQUAL(cff0000.green, 0.0f, "#ff0000 green value is 0");
    156         DISTRHO_ASSERT_EQUAL(cff0000.blue, 0.0f, "#ff0000 blue value is 0");
    157 
    158         Color c0f0 = Color::fromHTML("#0f0");
    159         DISTRHO_ASSERT_EQUAL(c0f0.red, 0.0f, "#0f0 red value is 0");
    160         DISTRHO_ASSERT_EQUAL(c0f0.green, 1.0f, "#0f0 green value is 1");
    161         DISTRHO_ASSERT_EQUAL(c0f0.blue, 0.0f, "#0f0 blue value is 0");
    162 
    163         Color c00ff00 = Color::fromHTML("#00ff00");
    164         DISTRHO_ASSERT_EQUAL(c00ff00.red, 0.0f, "#00ff00 red value is 0");
    165         DISTRHO_ASSERT_EQUAL(c00ff00.green, 1.0f, "#00ff00 green value is 1");
    166         DISTRHO_ASSERT_EQUAL(c00ff00.blue, 0.0f, "#00ff00 blue value is 0");
    167 
    168         Color c00f = Color::fromHTML("#00f");
    169         DISTRHO_ASSERT_EQUAL(c00f.red, 0.0f, "#00f red value is 0");
    170         DISTRHO_ASSERT_EQUAL(c00f.green, 0.0f, "#00f green value is 0");
    171         DISTRHO_ASSERT_EQUAL(c00f.blue, 1.0f, "#00f blue value is 1");
    172 
    173         Color c0000ff = Color::fromHTML("#0000ff");
    174         DISTRHO_ASSERT_EQUAL(c0000ff.red, 0.0f, "#0000ff red value is 0");
    175         DISTRHO_ASSERT_EQUAL(c0000ff.green, 0.0f, "#0000ff green value is 0");
    176         DISTRHO_ASSERT_EQUAL(c0000ff.blue, 1.0f, "#0000ff blue value is 1");
    177 
    178         // half point, round to 1 decimal point due to precision loss
    179         Color grey = Color::fromHTML("#7b7b7b");
    180         DISTRHO_ASSERT_SAFE_EQUAL(std::round(grey.red*10)/10, 0.5f, "grey's rounded red value is 0.5");
    181         DISTRHO_ASSERT_SAFE_EQUAL(std::round(grey.green*10)/10, 0.5f, "grey's rounded green value is 0.5");
    182         DISTRHO_ASSERT_SAFE_EQUAL(std::round(grey.blue*10)/10, 0.5f, "grey's rounded blue value is 0.5");
    183     }
    184 
    185     // check bounds
    186     {
    187         Color negativeInteger(-1, -1, -1, -1.0f);
    188         DISTRHO_ASSERT_EQUAL(negativeInteger.red, 0.0f, "red value is 0");
    189         DISTRHO_ASSERT_EQUAL(negativeInteger.green, 0.0f, "green value is 0");
    190         DISTRHO_ASSERT_EQUAL(negativeInteger.blue, 0.0f, "blue value is 0");
    191         DISTRHO_ASSERT_EQUAL(negativeInteger.alpha, 0.0f, "alpha value is 0");
    192 
    193         Color negativeFloat(-1.0f, -1.0f, -1.0f, -1.0f);
    194         DISTRHO_ASSERT_EQUAL(negativeFloat.red, 0.0f, "red value is 0");
    195         DISTRHO_ASSERT_EQUAL(negativeFloat.green, 0.0f, "green value is 0");
    196         DISTRHO_ASSERT_EQUAL(negativeFloat.blue, 0.0f, "blue value is 0");
    197         DISTRHO_ASSERT_EQUAL(negativeFloat.alpha, 0.0f, "alpha value is 0");
    198 
    199         Color overflowInteger(0xfff, 0xfff, 0xfff, 0xfff);
    200         DISTRHO_ASSERT_EQUAL(overflowInteger.red, 1.0f, "red value is 1");
    201         DISTRHO_ASSERT_EQUAL(overflowInteger.green, 1.0f, "green value is 1");
    202         DISTRHO_ASSERT_EQUAL(overflowInteger.blue, 1.0f, "blue value is 1");
    203         DISTRHO_ASSERT_EQUAL(overflowInteger.alpha, 1.0f, "alpha value is 1");
    204 
    205         Color overflowFloat(2.0f, 2.0f, 2.0f, 2.0f);
    206         DISTRHO_ASSERT_EQUAL(overflowFloat.red, 1.0f, "red value is 1");
    207         DISTRHO_ASSERT_EQUAL(overflowFloat.green, 1.0f, "green value is 1");
    208         DISTRHO_ASSERT_EQUAL(overflowFloat.blue, 1.0f, "blue value is 1");
    209         DISTRHO_ASSERT_EQUAL(overflowFloat.alpha, 1.0f, "alpha value is 1");
    210     }
    211 
    212     // TODO interpolation
    213     {
    214     }
    215 
    216     return 0;
    217 }
    218 
    219 // --------------------------------------------------------------------------------------------------------------------