summaryrefslogtreecommitdiff
path: root/meshmc/libraries/rainbow
diff options
context:
space:
mode:
Diffstat (limited to 'meshmc/libraries/rainbow')
-rw-r--r--meshmc/libraries/rainbow/CMakeLists.txt22
-rw-r--r--meshmc/libraries/rainbow/COPYING.LIB0
-rw-r--r--meshmc/libraries/rainbow/include/rainbow.h167
-rw-r--r--meshmc/libraries/rainbow/include/rainbow_config.h49
-rw-r--r--meshmc/libraries/rainbow/src/rainbow.cpp320
5 files changed, 558 insertions, 0 deletions
diff --git a/meshmc/libraries/rainbow/CMakeLists.txt b/meshmc/libraries/rainbow/CMakeLists.txt
new file mode 100644
index 0000000000..14e81b2346
--- /dev/null
+++ b/meshmc/libraries/rainbow/CMakeLists.txt
@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.25)
+project(rainbow)
+
+find_package(Qt6Core REQUIRED QUIET)
+find_package(Qt6Gui REQUIRED QUIET)
+
+set(RAINBOW_SOURCES
+src/rainbow.cpp
+)
+
+add_definitions(-DRAINBOW_LIBRARY)
+add_library(MeshMC_rainbow SHARED ${RAINBOW_SOURCES})
+target_include_directories(MeshMC_rainbow PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
+
+target_link_libraries(MeshMC_rainbow Qt6::Core Qt6::Gui)
+
+# Install it
+install(
+ TARGETS MeshMC_rainbow
+ RUNTIME DESTINATION ${LIBRARY_DEST_DIR}
+ LIBRARY DESTINATION ${LIBRARY_DEST_DIR}
+)
diff --git a/meshmc/libraries/rainbow/COPYING.LIB b/meshmc/libraries/rainbow/COPYING.LIB
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/meshmc/libraries/rainbow/COPYING.LIB
diff --git a/meshmc/libraries/rainbow/include/rainbow.h b/meshmc/libraries/rainbow/include/rainbow.h
new file mode 100644
index 0000000000..ab95d107c9
--- /dev/null
+++ b/meshmc/libraries/rainbow/include/rainbow.h
@@ -0,0 +1,167 @@
+/* SPDX-License-Identifier: LGPL-2.0-or-later
+ *
+ * This was part of the KDE project - see KGuiAddons
+ * Copyright (C) 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
+ * Copyright (C) 2007 Olaf Schmidt <ojschmidt@kde.org>
+ * Copyright (C) 2007 Thomas Zander <zander@kde.org>
+ * Copyright (C) 2007 Zack Rusin <zack@kde.org>
+ * Copyright (C) 2015 Petr Mrazek <peterix@gmail.com>
+ * Copyright (C) 2026 Project Tick
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#pragma once
+
+#include "rainbow_config.h"
+
+#include <QPainter>
+class QColor;
+
+/**
+ * A set of methods used to work with colors.
+ */
+namespace Rainbow
+{
+ /**
+ * Calculate the luma of a color. Luma is weighted sum of gamma-adjusted
+ * R'G'B' components of a color. The result is similar to qGray. The range
+ * is from 0.0 (black) to 1.0 (white).
+ *
+ * Rainbow::darken(), Rainbow::lighten() and Rainbow::shade()
+ * operate on the luma of a color.
+ *
+ * @see http://en.wikipedia.org/wiki/Luma_(video)
+ */
+ RAINBOW_EXPORT qreal luma(const QColor&);
+
+ /**
+ * Calculate hue, chroma and luma of a color in one call.
+ * @since 5.0
+ */
+ RAINBOW_EXPORT void getHcy(const QColor&, qreal* hue, qreal* chroma,
+ qreal* luma, qreal* alpha = 0);
+
+ /**
+ * Calculate the contrast ratio between two colors, according to the
+ * W3C/WCAG2.0 algorithm, (Lmax + 0.05)/(Lmin + 0.05), where Lmax and Lmin
+ * are the luma values of the lighter color and the darker color,
+ * respectively.
+ *
+ * A contrast ration of 5:1 (result == 5.0) is the minimum for "normal"
+ * text to be considered readable (large text can go as low as 3:1). The
+ * ratio ranges from 1:1 (result == 1.0) to 21:1 (result == 21.0).
+ *
+ * @see Rainbow::luma
+ */
+ RAINBOW_EXPORT qreal contrastRatio(const QColor&, const QColor&);
+
+ /**
+ * Adjust the luma of a color by changing its distance from white.
+ *
+ * @li amount == 1.0 gives white
+ * @li amount == 0.5 results in a color whose luma is halfway between 1.0
+ * and that of the original color
+ * @li amount == 0.0 gives the original color
+ * @li amount == -1.0 gives a color that is 'twice as far from white' as
+ * the original color, that is luma(result) == 1.0 - 2*(1.0 - luma(color))
+ *
+ * @param amount factor by which to adjust the luma component of the color
+ * @param chromaInverseGain (optional) factor by which to adjust the chroma
+ * component of the color; 1.0 means no change, 0.0 maximizes chroma
+ * @see Rainbow::shade
+ */
+ RAINBOW_EXPORT QColor lighten(const QColor&, qreal amount = 0.5,
+ qreal chromaInverseGain = 1.0);
+
+ /**
+ * Adjust the luma of a color by changing its distance from black.
+ *
+ * @li amount == 1.0 gives black
+ * @li amount == 0.5 results in a color whose luma is halfway between 0.0
+ * and that of the original color
+ * @li amount == 0.0 gives the original color
+ * @li amount == -1.0 gives a color that is 'twice as far from black' as
+ * the original color, that is luma(result) == 2*luma(color)
+ *
+ * @param amount factor by which to adjust the luma component of the color
+ * @param chromaGain (optional) factor by which to adjust the chroma
+ * component of the color; 1.0 means no change, 0.0 minimizes chroma
+ * @see Rainbow::shade
+ */
+ RAINBOW_EXPORT QColor darken(const QColor&, qreal amount = 0.5,
+ qreal chromaGain = 1.0);
+
+ /**
+ * Adjust the luma and chroma components of a color. The amount is added
+ * to the corresponding component.
+ *
+ * @param lumaAmount amount by which to adjust the luma component of the
+ * color; 0.0 results in no change, -1.0 turns anything black, 1.0 turns
+ * anything white
+ * @param chromaAmount (optional) amount by which to adjust the chroma
+ * component of the color; 0.0 results in no change, -1.0 minimizes chroma,
+ * 1.0 maximizes chroma
+ * @see Rainbow::luma
+ */
+ RAINBOW_EXPORT QColor shade(const QColor&, qreal lumaAmount,
+ qreal chromaAmount = 0.0);
+
+ /**
+ * Create a new color by tinting one color with another. This function is
+ * meant for creating additional colors withings the same class (background,
+ * foreground) from colors in a different class. Therefore when @p amount
+ * is low, the luma of @p base is mostly preserved, while the hue and
+ * chroma of @p color is mostly inherited.
+ *
+ * @param base color to be tinted
+ * @param color color with which to tint
+ * @param amount how strongly to tint the base; 0.0 gives @p base,
+ * 1.0 gives @p color
+ */
+ RAINBOW_EXPORT QColor tint(const QColor& base, const QColor& color,
+ qreal amount = 0.3);
+
+ /**
+ * Blend two colors into a new color by linear combination.
+ * @code
+ QColor lighter = Rainbow::mix(myColor, Qt::white)
+ * @endcode
+ * @param c1 first color.
+ * @param c2 second color.
+ * @param bias weight to be used for the mix. @p bias <= 0 gives @p c1,
+ * @p bias >= 1 gives @p c2. @p bias == 0.5 gives a 50% blend of @p c1
+ * and @p c2.
+ */
+ RAINBOW_EXPORT QColor mix(const QColor& c1, const QColor& c2,
+ qreal bias = 0.5);
+
+ /**
+ * Blend two colors into a new color by painting the second color over the
+ * first using the specified composition mode.
+ * @code
+ QColor white(Qt::white);
+ white.setAlphaF(0.5);
+ QColor lighter = Rainbow::overlayColors(myColor, white);
+ @endcode
+ * @param base the base color (alpha channel is ignored).
+ * @param paint the color to be overlayed onto the base color.
+ * @param comp the CompositionMode used to do the blending.
+ */
+ RAINBOW_EXPORT QColor overlayColors(
+ const QColor& base, const QColor& paint,
+ QPainter::CompositionMode comp = QPainter::CompositionMode_SourceOver);
+} // namespace Rainbow
diff --git a/meshmc/libraries/rainbow/include/rainbow_config.h b/meshmc/libraries/rainbow/include/rainbow_config.h
new file mode 100644
index 0000000000..e5f8860dc9
--- /dev/null
+++ b/meshmc/libraries/rainbow/include/rainbow_config.h
@@ -0,0 +1,49 @@
+/* SPDX-FileCopyrightText: 2026 Project Tick
+ * SPDX-FileContributor: Project Tick
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * MeshMC - A Custom Launcher for Minecraft
+ * Copyright (C) 2026 Project Tick
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ * Copyright 2013-2021 MultiMC Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <QtCore/QtGlobal>
+
+#ifdef RAINBOW_STATIC
+#define RAINBOW_EXPORT
+#else
+#ifdef RAINBOW_LIBRARY
+#define RAINBOW_EXPORT Q_DECL_EXPORT
+#else
+#define RAINBOW_EXPORT Q_DECL_IMPORT
+#endif
+#endif \ No newline at end of file
diff --git a/meshmc/libraries/rainbow/src/rainbow.cpp b/meshmc/libraries/rainbow/src/rainbow.cpp
new file mode 100644
index 0000000000..ebe65b3a80
--- /dev/null
+++ b/meshmc/libraries/rainbow/src/rainbow.cpp
@@ -0,0 +1,320 @@
+/* SPDX-License-Identifier: LGPL-2.0-or-later
+ *
+ * This was part of the KDE project - see KGuiAddons
+ * Copyright (C) 2007 Matthew Woehlke <mw_triad@users.sourceforge.net>
+ * Copyright (C) 2007 Olaf Schmidt <ojschmidt@kde.org>
+ * Copyright (C) 2007 Thomas Zander <zander@kde.org>
+ * Copyright (C) 2007 Zack Rusin <zack@kde.org>
+ * Copyright (C) 2015 Petr Mrazek <peterix@gmail.com>
+ * Copyright (C) 2026 Project Tick
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "../include/rainbow.h"
+
+#include <QColor>
+#include <QImage>
+#include <QtNumeric> // qIsNaN
+
+#include <math.h>
+
+// BEGIN internal helper functions
+
+static inline qreal wrap(qreal a, qreal d = 1.0)
+{
+ qreal r = fmod(a, d);
+ return (r < 0.0 ? d + r : (r > 0.0 ? r : 0.0));
+}
+
+// normalize: like qBound(a, 0.0, 1.0) but without needing the args and with
+// "safer" behavior on NaN (isnan(a) -> return 0.0)
+static inline qreal normalize(qreal a)
+{
+ return (a < 1.0 ? (a > 0.0 ? a : 0.0) : 1.0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// HCY color space
+
+#define HCY_REC 709 // use 709 for now
+#if HCY_REC == 601
+static const qreal yc[3] = {0.299, 0.587, 0.114};
+#elif HCY_REC == 709
+static const qreal yc[3] = {0.2126, 0.7152, 0.0722};
+#else // use Qt values
+static const qreal yc[3] = {0.34375, 0.5, 0.15625};
+#endif
+
+class KHCY
+{
+ public:
+ explicit KHCY(const QColor& color)
+ {
+ qreal r = gamma(color.redF());
+ qreal g = gamma(color.greenF());
+ qreal b = gamma(color.blueF());
+ a = color.alphaF();
+
+ // luma component
+ y = lumag(r, g, b);
+
+ // hue component
+ qreal p = qMax(qMax(r, g), b);
+ qreal n = qMin(qMin(r, g), b);
+ qreal d = 6.0 * (p - n);
+ if (n == p) {
+ h = 0.0;
+ } else if (r == p) {
+ h = ((g - b) / d);
+ } else if (g == p) {
+ h = ((b - r) / d) + (1.0 / 3.0);
+ } else {
+ h = ((r - g) / d) + (2.0 / 3.0);
+ }
+
+ // chroma component
+ if (r == g && g == b) {
+ c = 0.0;
+ } else {
+ c = qMax((y - n) / y, (p - y) / (1 - y));
+ }
+ }
+ explicit KHCY(qreal h_, qreal c_, qreal y_, qreal a_ = 1.0)
+ {
+ h = h_;
+ c = c_;
+ y = y_;
+ a = a_;
+ }
+
+ QColor qColor() const
+ {
+ // start with sane component values
+ qreal _h = wrap(h);
+ qreal _c = normalize(c);
+ qreal _y = normalize(y);
+
+ // calculate some needed variables
+ qreal _hs = _h * 6.0, th, tm;
+ if (_hs < 1.0) {
+ th = _hs;
+ tm = yc[0] + yc[1] * th;
+ } else if (_hs < 2.0) {
+ th = 2.0 - _hs;
+ tm = yc[1] + yc[0] * th;
+ } else if (_hs < 3.0) {
+ th = _hs - 2.0;
+ tm = yc[1] + yc[2] * th;
+ } else if (_hs < 4.0) {
+ th = 4.0 - _hs;
+ tm = yc[2] + yc[1] * th;
+ } else if (_hs < 5.0) {
+ th = _hs - 4.0;
+ tm = yc[2] + yc[0] * th;
+ } else {
+ th = 6.0 - _hs;
+ tm = yc[0] + yc[2] * th;
+ }
+
+ // calculate RGB channels in sorted order
+ qreal tn, to, tp;
+ if (tm >= _y) {
+ tp = _y + _y * _c * (1.0 - tm) / tm;
+ to = _y + _y * _c * (th - tm) / tm;
+ tn = _y - (_y * _c);
+ } else {
+ tp = _y + (1.0 - _y) * _c;
+ to = _y + (1.0 - _y) * _c * (th - tm) / (1.0 - tm);
+ tn = _y - (1.0 - _y) * _c * tm / (1.0 - tm);
+ }
+
+ // return RGB channels in appropriate order
+ if (_hs < 1.0) {
+ return QColor::fromRgbF(igamma(tp), igamma(to), igamma(tn), a);
+ } else if (_hs < 2.0) {
+ return QColor::fromRgbF(igamma(to), igamma(tp), igamma(tn), a);
+ } else if (_hs < 3.0) {
+ return QColor::fromRgbF(igamma(tn), igamma(tp), igamma(to), a);
+ } else if (_hs < 4.0) {
+ return QColor::fromRgbF(igamma(tn), igamma(to), igamma(tp), a);
+ } else if (_hs < 5.0) {
+ return QColor::fromRgbF(igamma(to), igamma(tn), igamma(tp), a);
+ } else {
+ return QColor::fromRgbF(igamma(tp), igamma(tn), igamma(to), a);
+ }
+ }
+
+ qreal h, c, y, a;
+ static qreal luma(const QColor& color)
+ {
+ return lumag(gamma(color.redF()), gamma(color.greenF()),
+ gamma(color.blueF()));
+ }
+
+ private:
+ static qreal gamma(qreal n)
+ {
+ return pow(normalize(n), 2.2);
+ }
+ static qreal igamma(qreal n)
+ {
+ return pow(normalize(n), 1.0 / 2.2);
+ }
+ static qreal lumag(qreal r, qreal g, qreal b)
+ {
+ return r * yc[0] + g * yc[1] + b * yc[2];
+ }
+};
+
+static inline qreal mixQreal(qreal a, qreal b, qreal bias)
+{
+ return a + (b - a) * bias;
+}
+// END internal helper functions
+
+qreal Rainbow::luma(const QColor& color)
+{
+ return KHCY::luma(color);
+}
+
+void Rainbow::getHcy(const QColor& color, qreal* h, qreal* c, qreal* y,
+ qreal* a)
+{
+ if (!c || !h || !y) {
+ return;
+ }
+ KHCY khcy(color);
+ *c = khcy.c;
+ *h = khcy.h;
+ *y = khcy.y;
+ if (a) {
+ *a = khcy.a;
+ }
+}
+
+static qreal contrastRatioForLuma(qreal y1, qreal y2)
+{
+ if (y1 > y2) {
+ return (y1 + 0.05) / (y2 + 0.05);
+ } else {
+ return (y2 + 0.05) / (y1 + 0.05);
+ }
+}
+
+qreal Rainbow::contrastRatio(const QColor& c1, const QColor& c2)
+{
+ return contrastRatioForLuma(luma(c1), luma(c2));
+}
+
+QColor Rainbow::lighten(const QColor& color, qreal ky, qreal kc)
+{
+ KHCY c(color);
+ c.y = 1.0 - normalize((1.0 - c.y) * (1.0 - ky));
+ c.c = 1.0 - normalize((1.0 - c.c) * kc);
+ return c.qColor();
+}
+
+QColor Rainbow::darken(const QColor& color, qreal ky, qreal kc)
+{
+ KHCY c(color);
+ c.y = normalize(c.y * (1.0 - ky));
+ c.c = normalize(c.c * kc);
+ return c.qColor();
+}
+
+QColor Rainbow::shade(const QColor& color, qreal ky, qreal kc)
+{
+ KHCY c(color);
+ c.y = normalize(c.y + ky);
+ c.c = normalize(c.c + kc);
+ return c.qColor();
+}
+
+static QColor tintHelper(const QColor& base, qreal baseLuma,
+ const QColor& color, qreal amount)
+{
+ KHCY result(Rainbow::mix(base, color, pow(amount, 0.3)));
+ result.y = mixQreal(baseLuma, result.y, amount);
+
+ return result.qColor();
+}
+
+QColor Rainbow::tint(const QColor& base, const QColor& color, qreal amount)
+{
+ if (amount <= 0.0) {
+ return base;
+ }
+ if (amount >= 1.0) {
+ return color;
+ }
+ if (qIsNaN(amount)) {
+ return base;
+ }
+
+ qreal baseLuma = luma(base); // cache value because luma call is expensive
+ double ri = contrastRatioForLuma(baseLuma, luma(color));
+ double rg = 1.0 + ((ri + 1.0) * amount * amount * amount);
+ double u = 1.0, l = 0.0;
+ QColor result;
+ for (int i = 12; i; --i) {
+ double a = 0.5 * (l + u);
+ result = tintHelper(base, baseLuma, color, a);
+ double ra = contrastRatioForLuma(baseLuma, luma(result));
+ if (ra > rg) {
+ u = a;
+ } else {
+ l = a;
+ }
+ }
+ return result;
+}
+
+QColor Rainbow::mix(const QColor& c1, const QColor& c2, qreal bias)
+{
+ if (bias <= 0.0) {
+ return c1;
+ }
+ if (bias >= 1.0) {
+ return c2;
+ }
+ if (qIsNaN(bias)) {
+ return c1;
+ }
+
+ qreal r = mixQreal(c1.redF(), c2.redF(), bias);
+ qreal g = mixQreal(c1.greenF(), c2.greenF(), bias);
+ qreal b = mixQreal(c1.blueF(), c2.blueF(), bias);
+ qreal a = mixQreal(c1.alphaF(), c2.alphaF(), bias);
+
+ return QColor::fromRgbF(r, g, b, a);
+}
+
+QColor Rainbow::overlayColors(const QColor& base, const QColor& paint,
+ QPainter::CompositionMode comp)
+{
+ // This isn't the fastest way, but should be "fast enough".
+ // It's also the only safe way to use QPainter::CompositionMode
+ QImage img(1, 1, QImage::Format_ARGB32_Premultiplied);
+ QPainter p(&img);
+ QColor start = base;
+ start.setAlpha(255); // opaque
+ p.fillRect(0, 0, 1, 1, start);
+ p.setCompositionMode(comp);
+ p.fillRect(0, 0, 1, 1, paint);
+ p.end();
+ return img.pixel(0, 0);
+}
generated by cgit 0.0.5-2-1-g0f52 (git 2.46.0) at 2026-04-05 18:23:43 +0000