diff --git a/docs/images/yup_audio_scope.png b/docs/images/yup_audio_scope.png
index fe6abb723..c9bb2de31 100644
Binary files a/docs/images/yup_audio_scope.png and b/docs/images/yup_audio_scope.png differ
diff --git a/docs/images/yup_color_picker.png b/docs/images/yup_color_picker.png
new file mode 100644
index 000000000..69c6f5297
Binary files /dev/null and b/docs/images/yup_color_picker.png differ
diff --git a/docs/images/yup_gradient_editor.png b/docs/images/yup_gradient_editor.png
new file mode 100644
index 000000000..52983bda5
Binary files /dev/null and b/docs/images/yup_gradient_editor.png differ
diff --git a/examples/graphics/source/examples/Artboard.h b/examples/graphics/source/examples/Artboard.h
index f1f6506a1..7c051363b 100644
--- a/examples/graphics/source/examples/Artboard.h
+++ b/examples/graphics/source/examples/Artboard.h
@@ -29,6 +29,7 @@ class ArtboardDemo : public yup::Component
ArtboardDemo()
{
setWantsKeyboardFocus (true);
+ setupControls();
}
bool loadArtboard()
@@ -64,6 +65,8 @@ class ArtboardDemo : public yup::Component
addAndMakeVisible (art);
art->setFile (artboardFile.getValue());
+ art->setLayout (getSelectedLayout());
+ art->setAlignment (getSelectedAlignment());
art->advanceAndApply (i * art->durationSeconds());
}
@@ -85,6 +88,21 @@ class ArtboardDemo : public yup::Component
return;
auto bounds = getLocalBounds().reduced (10, 20);
+ auto controls = bounds.removeFromTop (30);
+
+ auto labelHeight = 20;
+ auto comboHeight = 24;
+ auto labelWidth = 70;
+ auto comboWidth = 170;
+ auto spacing = 12;
+
+ fitLabel.setBounds (controls.removeFromLeft (labelWidth).withHeight (labelHeight));
+ fitCombo.setBounds (controls.removeFromLeft (comboWidth).withHeight (comboHeight));
+ controls.removeFromLeft (spacing);
+ alignmentLabel.setBounds (controls.removeFromLeft (labelWidth).withHeight (labelHeight));
+ alignmentCombo.setBounds (controls.removeFromLeft (comboWidth).withHeight (comboHeight));
+
+ bounds.removeFromTop (10);
auto width = bounds.getWidth() / totalColumns;
auto height = bounds.getHeight() / totalRows;
@@ -106,7 +124,119 @@ class ArtboardDemo : public yup::Component
}
private:
+ void setupControls()
+ {
+ auto labelFont = yup::ApplicationTheme::getGlobalTheme()->getDefaultFont().withHeight (12.0f);
+
+ fitLabel.setText ("Fit", yup::dontSendNotification);
+ fitLabel.setFont (labelFont);
+ addAndMakeVisible (fitLabel);
+
+ fitCombo.addItem ("Fill", 1);
+ fitCombo.addItem ("Contain", 2);
+ fitCombo.addItem ("Cover", 3);
+ fitCombo.addItem ("Fit Width", 4);
+ fitCombo.addItem ("Fit Height", 5);
+ fitCombo.addItem ("None", 6);
+ fitCombo.addItem ("Scale Down", 7);
+ fitCombo.addItem ("Layout", 8);
+ fitCombo.setSelectedId (2);
+ fitCombo.onSelectedItemChanged = [this]
+ {
+ updateArtboardsLayout();
+ };
+ addAndMakeVisible (fitCombo);
+
+ alignmentLabel.setText ("Align", yup::dontSendNotification);
+ alignmentLabel.setFont (labelFont);
+ addAndMakeVisible (alignmentLabel);
+
+ alignmentCombo.addItem ("Top Left", 1);
+ alignmentCombo.addItem ("Top Center", 2);
+ alignmentCombo.addItem ("Top Right", 3);
+ alignmentCombo.addItem ("Center Left", 4);
+ alignmentCombo.addItem ("Center", 5);
+ alignmentCombo.addItem ("Center Right", 6);
+ alignmentCombo.addItem ("Bottom Left", 7);
+ alignmentCombo.addItem ("Bottom Center", 8);
+ alignmentCombo.addItem ("Bottom Right", 9);
+ alignmentCombo.setSelectedId (5);
+ alignmentCombo.onSelectedItemChanged = [this]
+ {
+ updateArtboardsLayout();
+ };
+ addAndMakeVisible (alignmentCombo);
+ }
+
+ yup::Artboard::Layout getSelectedLayout() const
+ {
+ switch (fitCombo.getSelectedId())
+ {
+ case 1:
+ return yup::Artboard::Layout::fill;
+ case 2:
+ return yup::Artboard::Layout::contain;
+ case 3:
+ return yup::Artboard::Layout::cover;
+ case 4:
+ return yup::Artboard::Layout::fitWidth;
+ case 5:
+ return yup::Artboard::Layout::fitHeight;
+ case 6:
+ return yup::Artboard::Layout::none;
+ case 7:
+ return yup::Artboard::Layout::scaleDown;
+ case 8:
+ return yup::Artboard::Layout::layout;
+ }
+
+ return yup::Artboard::Layout::contain;
+ }
+
+ yup::Artboard::Alignment getSelectedAlignment() const
+ {
+ switch (alignmentCombo.getSelectedId())
+ {
+ case 1:
+ return yup::Artboard::Alignment::topLeft;
+ case 2:
+ return yup::Artboard::Alignment::topCenter;
+ case 3:
+ return yup::Artboard::Alignment::topRight;
+ case 4:
+ return yup::Artboard::Alignment::centerLeft;
+ case 5:
+ return yup::Artboard::Alignment::center;
+ case 6:
+ return yup::Artboard::Alignment::centerRight;
+ case 7:
+ return yup::Artboard::Alignment::bottomLeft;
+ case 8:
+ return yup::Artboard::Alignment::bottomCenter;
+ case 9:
+ return yup::Artboard::Alignment::bottomRight;
+ }
+
+ return yup::Artboard::Alignment::center;
+ }
+
+ void updateArtboardsLayout()
+ {
+ auto newLayout = getSelectedLayout();
+ auto newAlignment = getSelectedAlignment();
+
+ for (auto* artboard : artboards)
+ {
+ artboard->setLayout (newLayout);
+ artboard->setAlignment (newAlignment);
+ }
+ }
+
yup::OwnedArray
artboards;
+ yup::Label fitLabel;
+ yup::ComboBox fitCombo;
+ yup::Label alignmentLabel;
+ yup::ComboBox alignmentCombo;
int totalRows = 1;
int totalColumns = 1;
};
diff --git a/examples/graphics/source/examples/ColorLab.h b/examples/graphics/source/examples/ColorLab.h
new file mode 100644
index 000000000..dbe4d04ce
--- /dev/null
+++ b/examples/graphics/source/examples/ColorLab.h
@@ -0,0 +1,1358 @@
+/*
+ ==============================================================================
+
+ This file is part of the YUP library.
+ Copyright (c) 2025 - kunitoki@gmail.com
+
+ YUP is an open source library subject to open-source licensing.
+
+ The code included in this file is provided under the terms of the ISC license
+ http://www.isc.org/downloads/software-support-policy/isc-license. Permission
+ to use, copy, modify, and/or distribute this software for any purpose with or
+ without fee is hereby granted provided that the above copyright notice and
+ this permission notice appear in all copies.
+
+ YUP IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
+ EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
+ DISCLAIMED.
+
+ ==============================================================================
+*/
+
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+
+//==============================================================================
+
+class ColorLabDemo : public yup::Component
+{
+public:
+ ColorLabDemo()
+ : yup::Component ("ColorLabDemo")
+ {
+ modeCombo = std::make_unique ("colorLabMode");
+ modeCombo->addItem ("Blend Spaces", static_cast (Mode::BlendSpaces));
+ modeCombo->addItem ("Gradient Editor", static_cast (Mode::GradientEditor));
+ modeCombo->addItem ("Color Picker", static_cast (Mode::Picker));
+ modeCombo->setSelectedId (static_cast (Mode::BlendSpaces));
+ modeCombo->onSelectedItemChanged = [this]
+ {
+ setMode (static_cast (modeCombo->getSelectedId()));
+ };
+ addAndMakeVisible (modeCombo.get());
+
+ gradientTypeCombo = std::make_unique ("gradientType");
+ gradientTypeCombo->addItem ("Linear", 1);
+ gradientTypeCombo->addItem ("Radial", 2);
+ gradientTypeCombo->setSelectedId (1);
+ gradientTypeCombo->onSelectedItemChanged = [this]
+ {
+ isGradientRadial = gradientTypeCombo->getSelectedId() == 2;
+ repaint();
+ };
+ addAndMakeVisible (gradientTypeCombo.get());
+
+ pickerSpaceCombo = std::make_unique ("pickerSpace");
+ pickerSpaceCombo->addItem ("RGBA", static_cast (PickerSpace::Rgba));
+ pickerSpaceCombo->addItem ("HSL", static_cast (PickerSpace::Hsl));
+ pickerSpaceCombo->addItem ("HSV", static_cast (PickerSpace::Hsv));
+ pickerSpaceCombo->addItem ("HSLuv", static_cast (PickerSpace::Hsluv));
+ pickerSpaceCombo->setSelectedId (static_cast (PickerSpace::Hsluv));
+ pickerSpaceCombo->onSelectedItemChanged = [this]
+ {
+ pickerSpace = static_cast (pickerSpaceCombo->getSelectedId());
+ updatePickerSlidersFromColor();
+ updateChannelLabels();
+ repaint();
+ };
+ addAndMakeVisible (pickerSpaceCombo.get());
+
+ for (size_t i = 0; i < channelSliders.size(); ++i)
+ {
+ channelSliders[i] = std::make_unique (yup::Slider::LinearHorizontal);
+ channelSliders[i]->setRange (0.0, 1.0, 0.001);
+ channelSliders[i]->setValue (0.5);
+ channelSliders[i]->onValueChanged = [this, index = i] (double value)
+ {
+ handleChannelSliderChange (index, static_cast (value));
+ };
+ addAndMakeVisible (channelSliders[i].get());
+
+ channelLabels[i] = std::make_unique ("channelLabel");
+ channelLabels[i]->setText ("", yup::dontSendNotification);
+ addAndMakeVisible (channelLabels[i].get());
+ }
+
+ for (size_t i = 0; i < blendStartSliders.size(); ++i)
+ {
+ blendStartSliders[i] = std::make_unique (yup::Slider::LinearHorizontal);
+ blendStartSliders[i]->setRange (0.0, 1.0, 0.001);
+ blendStartSliders[i]->onValueChanged = [this, index = i] (double value)
+ {
+ blendStartValues[index] = static_cast (value);
+ updateBlendColorsFromSliders();
+ };
+ addAndMakeVisible (blendStartSliders[i].get());
+
+ blendStartLabels[i] = std::make_unique ("blendStartLabel");
+ addAndMakeVisible (blendStartLabels[i].get());
+ }
+
+ for (size_t i = 0; i < blendEndSliders.size(); ++i)
+ {
+ blendEndSliders[i] = std::make_unique (yup::Slider::LinearHorizontal);
+ blendEndSliders[i]->setRange (0.0, 1.0, 0.001);
+ blendEndSliders[i]->onValueChanged = [this, index = i] (double value)
+ {
+ blendEndValues[index] = static_cast (value);
+ updateBlendColorsFromSliders();
+ };
+ addAndMakeVisible (blendEndSliders[i].get());
+
+ blendEndLabels[i] = std::make_unique ("blendEndLabel");
+ addAndMakeVisible (blendEndLabels[i].get());
+ }
+
+ addStopButton = std::make_unique ("+");
+ addStopButton->onClick = [this]
+ {
+ addGradientStop();
+ };
+ addAndMakeVisible (addStopButton.get());
+
+ removeStopButton = std::make_unique ("-");
+ removeStopButton->onClick = [this]
+ {
+ removeSelectedStop();
+ };
+ addAndMakeVisible (removeStopButton.get());
+
+ for (size_t i = 0; i < stopColorSliders.size(); ++i)
+ {
+ stopColorSliders[i] = std::make_unique (yup::Slider::LinearHorizontal);
+ stopColorSliders[i]->setRange (0.0, 1.0, 0.001);
+ stopColorSliders[i]->onValueChanged = [this, index = i] (double value)
+ {
+ stopColorValues[index] = static_cast (value);
+ updateSelectedStopColor();
+ };
+ addAndMakeVisible (stopColorSliders[i].get());
+
+ stopColorLabels[i] = std::make_unique ("stopColorLabel");
+ addAndMakeVisible (stopColorLabels[i].get());
+ }
+
+ pickerColor = yup::Color::fromHSLuv (0.1f, 0.8f, 0.55f);
+ updatePickerSlidersFromColor();
+ updateChannelLabels();
+
+ gradientStops.push_back ({ 0.0f, gradientStartColor });
+ gradientStops.push_back ({ 1.0f, gradientEndColor });
+ selectedStopIndex = 0;
+ updateGradientStopSlidersFromSelection();
+ updateBlendSlidersFromColors();
+ updateControlVisibility();
+ }
+
+ void resized() override
+ {
+ auto bounds = getLocalBounds().to();
+ headerArea = bounds.removeFromTop (80.0f);
+ contentArea = bounds.reduced (20.0f);
+
+ auto comboArea = headerArea;
+ comboArea = comboArea.removeFromRight (180.0f).reduced (10.0f);
+ modeCombo->setBounds (comboArea.removeFromTop (26.0f));
+
+ comboArea.removeFromTop (6.0f);
+ auto secondComboArea = comboArea.removeFromTop (26.0f);
+ gradientTypeCombo->setBounds (secondComboArea);
+ pickerSpaceCombo->setBounds (secondComboArea);
+
+ {
+ auto blendArea = getBlendControlsArea();
+ layoutColorSliders (blendArea.removeFromTop (blendArea.getHeight() * 0.5f),
+ blendStartLabels,
+ blendStartSliders);
+ blendArea.removeFromTop (12.0f);
+ layoutColorSliders (blendArea, blendEndLabels, blendEndSliders);
+ }
+
+ {
+ auto stopArea = getGradientControlsArea();
+ auto buttonRow = stopArea.removeFromTop (26.0f);
+ addStopButton->setBounds (buttonRow.removeFromLeft (50.0f));
+ buttonRow.removeFromLeft (10.0f);
+ removeStopButton->setBounds (buttonRow.removeFromLeft (50.0f));
+ stopArea.removeFromTop (12.0f);
+ layoutColorSliders (stopArea, stopColorLabels, stopColorSliders);
+ }
+
+ auto sliderArea = getPickerControlsArea();
+ layoutColorSliders (sliderArea, channelLabels, channelSliders);
+ }
+
+ void paint (yup::Graphics& g) override
+ {
+ drawBackground (g, getLocalBounds().to());
+
+ auto titleArea = headerArea;
+ titleArea.removeFromRight (200.0f);
+ drawHeader (g, titleArea.reduced (8.0f, 10.0f));
+
+ switch (currentMode)
+ {
+ case Mode::BlendSpaces:
+ drawBlendSpaces (g, contentArea);
+ break;
+ case Mode::GradientEditor:
+ drawGradientEditor (g, contentArea);
+ break;
+ case Mode::Picker:
+ drawPicker (g, contentArea);
+ break;
+ }
+ }
+
+ void mouseDown (const yup::MouseEvent& event) override
+ {
+ handlePointer (event.getPosition(), event.getModifiers(), true);
+ }
+
+ void mouseDrag (const yup::MouseEvent& event) override
+ {
+ handlePointer (event.getPosition(), event.getModifiers(), false);
+ }
+
+ void mouseUp (const yup::MouseEvent&) override
+ {
+ dragHandle = DragHandle::None;
+ draggingStopIndex = invalidStopIndex;
+ }
+
+private:
+ enum class Mode
+ {
+ BlendSpaces = 1,
+ GradientEditor,
+ Picker
+ };
+
+ enum class PickerSpace
+ {
+ Rgba = 1,
+ Hsl,
+ Hsv,
+ Hsluv
+ };
+
+ enum class DragHandle
+ {
+ None,
+ Start,
+ End,
+ Stop
+ };
+
+ struct GradientStopData
+ {
+ float t = 0.0f;
+ yup::Color color;
+ yup::Point customPositionNorm;
+ bool hasCustomPosition = false;
+ };
+
+ enum class BlendMode
+ {
+ Srgb,
+ Linear,
+ Spectral
+ };
+
+ void setMode (Mode mode)
+ {
+ if (currentMode == mode)
+ return;
+
+ currentMode = mode;
+ updateControlVisibility();
+ repaint();
+ }
+
+ void updateControlVisibility()
+ {
+ const bool gradientMode = currentMode == Mode::GradientEditor;
+ const bool pickerMode = currentMode == Mode::Picker;
+ const bool blendMode = currentMode == Mode::BlendSpaces;
+
+ gradientTypeCombo->setVisible (gradientMode);
+ pickerSpaceCombo->setVisible (pickerMode);
+
+ for (size_t i = 0; i < blendStartSliders.size(); ++i)
+ {
+ blendStartSliders[i]->setVisible (blendMode);
+ blendStartLabels[i]->setVisible (blendMode);
+ blendEndSliders[i]->setVisible (blendMode);
+ blendEndLabels[i]->setVisible (blendMode);
+ }
+
+ addStopButton->setVisible (gradientMode);
+ removeStopButton->setVisible (gradientMode);
+ for (size_t i = 0; i < stopColorSliders.size(); ++i)
+ {
+ stopColorSliders[i]->setVisible (gradientMode);
+ stopColorLabels[i]->setVisible (gradientMode);
+ }
+
+ for (size_t i = 0; i < channelSliders.size(); ++i)
+ {
+ channelSliders[i]->setVisible (pickerMode);
+ channelLabels[i]->setVisible (pickerMode);
+ }
+ }
+
+ yup::Rectangle getPickerControlsArea() const
+ {
+ auto area = contentArea;
+ area.removeFromLeft (area.getWidth() * 0.55f);
+ return area.reduced (12.0f);
+ }
+
+ yup::Rectangle getBlendControlsArea() const
+ {
+ auto area = contentArea;
+ area.removeFromLeft (area.getWidth() * 0.55f);
+ return area.reduced (12.0f);
+ }
+
+ yup::Rectangle getGradientControlsArea() const
+ {
+ auto area = contentArea;
+ area.removeFromLeft (area.getWidth() * 0.6f);
+ return area.reduced (12.0f);
+ }
+
+ template
+ void layoutColorSliders (yup::Rectangle area, LabelArray& labels, SliderArray& sliders)
+ {
+ const float labelWidth = 96.0f;
+ const float rowHeight = 26.0f;
+ const auto labelFont = yup::ApplicationTheme::getGlobalTheme()->getDefaultFont().withHeight (12.0f);
+ for (size_t i = 0; i < sliders.size(); ++i)
+ {
+ auto row = area.removeFromTop (rowHeight);
+ labels[i]->setFont (labelFont);
+ labels[i]->setJustification (yup::Justification::left);
+ labels[i]->setBounds (row.removeFromLeft (labelWidth));
+ sliders[i]->setBounds (row);
+ area.removeFromTop (6.0f);
+ }
+ }
+
+ static double toLinear (double value)
+ {
+ if (value <= 0.04045)
+ return value / 12.92;
+
+ return std::pow ((value + 0.055) / 1.055, 2.4);
+ }
+
+ static double fromLinear (double value)
+ {
+ if (value <= 0.0031308)
+ return 12.92 * value;
+
+ return 1.055 * std::pow (value, 1.0 / 2.4) - 0.055;
+ }
+
+ static yup::uint8 toByte (double value)
+ {
+ return static_cast (yup::roundToInt (yup::jlimit (0.0, 1.0, value) * 255.0));
+ }
+
+ static yup::Color colorFromNormalized (double r, double g, double b, double a)
+ {
+ return yup::Color (toByte (a), toByte (r), toByte (g), toByte (b));
+ }
+
+ void drawBackground (yup::Graphics& g, const yup::Rectangle& area)
+ {
+ g.setFillColor (yup::Color::fromHSLuv (0.62f, 0.35f, 0.12f));
+ g.fillAll();
+ }
+
+ void drawHeader (yup::Graphics& g, yup::Rectangle area)
+ {
+ const auto titleFont = yup::ApplicationTheme::getGlobalTheme()->getDefaultFont().withHeight (26.0f);
+ const auto subtitleFont = yup::ApplicationTheme::getGlobalTheme()->getDefaultFont().withHeight (13.0f);
+
+ yup::StyledText title;
+ {
+ auto modifier = title.startUpdate();
+ modifier.setMaxSize (area.getSize());
+ modifier.setHorizontalAlign (yup::StyledText::left);
+ modifier.setWrap (yup::StyledText::noWrap);
+ modifier.appendText ("Color Lab", titleFont);
+ }
+
+ yup::StyledText subtitle;
+ {
+ auto modifier = subtitle.startUpdate();
+ modifier.setMaxSize (area.getSize());
+ modifier.setHorizontalAlign (yup::StyledText::left);
+ modifier.setWrap (yup::StyledText::noWrap);
+ modifier.appendText ("Perceptual spaces, spectral mixing, editable gradients, and live picking.", subtitleFont);
+ }
+
+ g.setFillColor (yup::Colors::white.withAlpha (0.9f));
+ g.fillFittedText (title, area.removeFromTop (34.0f));
+ g.setFillColor (yup::Colors::white.withAlpha (0.6f));
+ g.fillFittedText (subtitle, area.removeFromTop (18.0f));
+ }
+
+ void drawPanel (yup::Graphics& g, const yup::Rectangle& area)
+ {
+ const auto panelBase = yup::Color::fromHSLuv (0.63f, 0.15f, 0.16f).withAlpha (0.92f);
+ const auto panelEdge = yup::Color::fromHSLuv (0.63f, 0.25f, 0.1f).withAlpha (0.92f);
+ yup::ColorGradient panel (panelBase, area.getX(), area.getY(), panelEdge, area.getRight(), area.getBottom(), yup::ColorGradient::Linear);
+
+ g.setFillColorGradient (panel);
+ g.fillRoundedRect (area, 16.0f);
+ g.setStrokeColor (yup::Colors::white.withAlpha (0.08f));
+ g.setStrokeWidth (1.0f);
+ g.strokeRoundedRect (area, 16.0f);
+ }
+
+ void drawSectionTitle (yup::Graphics& g, const yup::String& title, yup::Rectangle area)
+ {
+ yup::StyledText text;
+ {
+ auto modifier = text.startUpdate();
+ modifier.setMaxSize (area.getSize());
+ modifier.setHorizontalAlign (yup::StyledText::left);
+ modifier.appendText (title, yup::ApplicationTheme::getGlobalTheme()->getDefaultFont().withHeight (14.0f));
+ }
+
+ g.setFillColor (yup::Colors::white.withAlpha (0.75f));
+ g.fillFittedText (text, area.removeFromTop (18.0f));
+ }
+
+ void drawBlendSpaces (yup::Graphics& g, yup::Rectangle area)
+ {
+ auto leftArea = area.withTrimmedRight (area.getWidth() * 0.45f).reduced (8.0f);
+ auto rightArea = area.removeFromRight (area.getWidth() * 0.45f).reduced (8.0f);
+
+ drawPanel (g, leftArea);
+ drawPanel (g, rightArea);
+
+ auto content = leftArea.reduced (24.0f);
+ drawSectionTitle (g, "Normal vs Linear vs Spectral", content);
+ content.removeFromTop (28.0f);
+
+ auto rowHeight = (content.getHeight() - 20.0f) / 3.0f;
+ auto row1 = content.removeFromTop (rowHeight);
+ auto row2 = content.removeFromTop (rowHeight);
+ auto row3 = content.removeFromTop (rowHeight);
+
+ drawBlendRamp (g, row1, "sRGB Blend", BlendMode::Srgb);
+ drawBlendRamp (g, row2, "Linear RGB", BlendMode::Linear);
+ drawBlendRamp (g, row3, "Spectral Mix", BlendMode::Spectral);
+ }
+
+ void drawGradientEditor (yup::Graphics& g, yup::Rectangle area)
+ {
+ auto leftArea = area.withTrimmedRight (area.getWidth() * 0.4f).reduced (8.0f);
+ auto rightArea = area.removeFromRight (area.getWidth() * 0.4f).reduced (8.0f);
+
+ drawPanel (g, leftArea);
+ drawPanel (g, rightArea);
+
+ auto content = leftArea.reduced (24.0f);
+ drawSectionTitle (g, "Gradient Editor", content);
+ content.removeFromTop (28.0f);
+
+ gradientEditorArea = content.withTrimmedBottom (28.0f);
+
+ const auto start = pointFromNormalized (gradientEditorArea, gradientStartNorm);
+ const auto end = pointFromNormalized (gradientEditorArea, gradientEndNorm);
+ const auto stops = buildGradientStops (gradientEditorArea, start, end);
+ auto gradient = yup::ColorGradient (isGradientRadial ? yup::ColorGradient::Radial : yup::ColorGradient::Linear, stops);
+ g.setFillColorGradient (gradient);
+ g.fillRoundedRect (gradientEditorArea, 16.0f);
+
+ g.setStrokeColor (yup::Colors::white.withAlpha (0.2f));
+ g.setStrokeWidth (1.0f);
+ g.strokeRoundedRect (gradientEditorArea, 16.0f);
+
+ if (isGradientRadial)
+ {
+ const float radius = start.distanceTo (end);
+ g.setStrokeColor (yup::Colors::white.withAlpha (0.35f));
+ g.setStrokeWidth (1.0f);
+ g.strokeEllipse (yup::Rectangle (start.getX() - radius, start.getY() - radius, radius * 2.0f, radius * 2.0f));
+ }
+ else
+ {
+ g.setStrokeColor (yup::Colors::white.withAlpha (0.35f));
+ g.setStrokeWidth (1.0f);
+ g.strokeLine (start, end);
+ }
+
+ drawHandle (g, start, "A");
+ drawHandle (g, end, "B");
+ drawStopHandles (g, gradientEditorArea, start, end);
+
+ auto hintArea = content.removeFromBottom (22.0f);
+ g.setFillColor (yup::Colors::white.withAlpha (0.6f));
+ const auto infoFont = yup::ApplicationTheme::getGlobalTheme()->getDefaultFont().withHeight (12.0f);
+ g.fillFittedText ("Drag points; hold Shift to constrain stops to the line.", infoFont, hintArea, yup::Justification::left);
+ }
+
+ void drawPicker (yup::Graphics& g, yup::Rectangle area)
+ {
+ drawPanel (g, area.reduced (8.0f));
+ auto content = area.reduced (24.0f);
+ drawSectionTitle (g, "Color Picker", content);
+ content.removeFromTop (12.0f);
+
+ auto pickerArea = content;
+ pickerArea.removeFromRight (content.getWidth() * 0.36f);
+ pickerArea = pickerArea.reduced (10.0f);
+ const float wheelSize = yup::jmin (pickerArea.getWidth(), pickerArea.getHeight());
+ pickerWheelArea = pickerArea.withSize (wheelSize, wheelSize).withCenter (pickerArea.getCenterX(), pickerArea.getCenterY());
+
+ drawPickerWheel (g, pickerWheelArea);
+ drawPickerDetails (g, content.removeFromRight (content.getWidth() * 0.36f).reduced (12.0f));
+ }
+
+ void drawPickerWheel (yup::Graphics& g, const yup::Rectangle& area)
+ {
+ const auto center = yup::Point (area.getCenterX(), area.getCenterY());
+ const float radius = area.getWidth() * 0.5f;
+ const auto arcBounds = yup::Rectangle (center.getX() - radius, center.getY() - radius, radius * 2.0f, radius * 2.0f);
+
+ const int segments = 180;
+ const float step = 1.0f / static_cast (segments);
+ const float overlap = step * 0.35f;
+
+ for (int i = 0; i < segments; ++i)
+ {
+ const float hue = static_cast (i) * step;
+ const float hueMid = hue + step * 0.5f;
+ const float angle1 = (hue - overlap) * 2.0f * yup::MathConstants::pi;
+ const float angle2 = (hue + step + overlap) * 2.0f * yup::MathConstants::pi;
+
+ const auto edgePoint = yup::Point (center.getX() + std::cos (angle2) * radius,
+ center.getY() + std::sin (angle2) * radius);
+
+ const auto centerColor = yup::Color::fromHSV (hueMid, 0.0f, pickerLuminance).withAlpha (pickerAlpha);
+ const auto edgeColor = yup::Color::fromHSV (hueMid, 1.0f, pickerLuminance).withAlpha (pickerAlpha);
+
+ yup::ColorGradient radial (centerColor, center.getX(), center.getY(), edgeColor, edgePoint.getX(), edgePoint.getY(), yup::ColorGradient::Radial);
+ g.setFillColorGradient (radial);
+
+ yup::Path wedge;
+ wedge.moveTo (center);
+ wedge.lineTo (center.getX() + std::cos (angle1) * radius, center.getY() + std::sin (angle1) * radius);
+ wedge.addArc (arcBounds, angle1, angle2, false);
+ wedge.close();
+ g.fillPath (wedge);
+ }
+
+ g.setStrokeColor (yup::Colors::white.withAlpha (0.25f));
+ g.setStrokeWidth (1.0f);
+ g.strokeEllipse (area);
+
+ const auto marker = wheelMarkerPosition (area);
+ g.setFillColor (yup::Colors::white);
+ g.fillEllipse (yup::Rectangle (marker.getX() - 4.5f, marker.getY() - 4.5f, 9.0f, 9.0f));
+ g.setStrokeColor (yup::Colors::black.withAlpha (0.4f));
+ g.setStrokeWidth (1.0f);
+ g.strokeEllipse (yup::Rectangle (marker.getX() - 4.5f, marker.getY() - 4.5f, 9.0f, 9.0f));
+ }
+
+ void drawPickerDetails (yup::Graphics& g, yup::Rectangle area)
+ {
+ area.removeFromTop (100.0f);
+
+ auto swatch = area.removeFromTop (50.0f);
+ g.setFillColor (pickerColor);
+ g.fillRoundedRect (swatch, 14.0f);
+ g.setStrokeColor (yup::Colors::white.withAlpha (0.2f));
+ g.setStrokeWidth (1.0f);
+ g.strokeRoundedRect (swatch, 14.0f);
+
+ area.removeFromTop (12.0f);
+ g.setFillColor (yup::Colors::white.withAlpha (0.65f));
+ const auto infoFont = yup::ApplicationTheme::getGlobalTheme()->getDefaultFont().withHeight (12.0f);
+ g.fillFittedText ("Space: " + pickerSpaceCombo->getText(), infoFont, area.removeFromTop (18.0f), yup::Justification::left);
+ }
+
+ std::vector buildGradientStops (const yup::Rectangle& area,
+ const yup::Point& start,
+ const yup::Point& end) const
+ {
+ std::vector stops;
+ stops.reserve (gradientStops.size());
+
+ const auto line = yup::Line (start, end);
+ for (size_t i = 0; i < gradientStops.size(); ++i)
+ {
+ const auto point = stopPositionForIndex (i, area, line);
+ stops.emplace_back (gradientStops[i].color, point, gradientStops[i].t);
+ }
+
+ std::sort (stops.begin(), stops.end(), [] (const auto& a, const auto& b)
+ {
+ return a.delta < b.delta;
+ });
+
+ return stops;
+ }
+
+ void drawStopHandles (yup::Graphics& g,
+ const yup::Rectangle& area,
+ const yup::Point& start,
+ const yup::Point& end)
+ {
+ if (gradientStops.empty())
+ return;
+
+ const auto line = yup::Line (start, end);
+ for (size_t i = 0; i < gradientStops.size(); ++i)
+ {
+ const auto point = stopPositionForIndex (i, area, line);
+ const bool isSelected = i == selectedStopIndex;
+ const float radius = isSelected ? 7.0f : 5.0f;
+ g.setFillColor (gradientStops[i].color.withAlpha (1.0f));
+ g.fillEllipse (yup::Rectangle (point.getX() - radius, point.getY() - radius, radius * 2.0f, radius * 2.0f));
+ g.setStrokeColor (isSelected ? yup::Colors::white : yup::Colors::black.withAlpha (0.4f));
+ g.setStrokeWidth (1.0f);
+ g.strokeEllipse (yup::Rectangle (point.getX() - radius, point.getY() - radius, radius * 2.0f, radius * 2.0f));
+
+ if (isSelected)
+ {
+ const auto labelFont = yup::ApplicationTheme::getGlobalTheme()->getDefaultFont().withHeight (11.0f);
+ const auto label = formatValue (gradientStops[i].t, 2);
+ const auto labelArea = yup::Rectangle (point.getX() + 16.0f, point.getY() - 10.0f, 48.0f, 18.0f);
+ g.setFillColor (yup::Colors::white.withAlpha (0.8f));
+ g.fillFittedText (label, labelFont, labelArea, yup::Justification::left);
+ }
+ }
+ }
+
+ void drawBlendRamp (yup::Graphics& g, yup::Rectangle area, const yup::String& label, BlendMode mode)
+ {
+ auto labelArea = area.removeFromTop (18.0f);
+ g.setFillColor (yup::Colors::white.withAlpha (0.7f));
+ const auto labelFont = yup::ApplicationTheme::getGlobalTheme()->getDefaultFont().withHeight (12.0f);
+ g.fillFittedText (label, labelFont, labelArea, yup::Justification::left);
+
+ const auto& colorA = blendStartColor;
+ const auto& colorB = blendEndColor;
+
+ const auto start = yup::Point (area.getX(), area.getCenterY());
+ const auto end = yup::Point (area.getRight(), area.getCenterY());
+ const auto colorSpace = mode == BlendMode::Spectral
+ ? yup::ColorSpace::Spectral
+ : (mode == BlendMode::Srgb ? yup::ColorSpace::SRGB : yup::ColorSpace::RGB);
+ const size_t steps = colorSpace == yup::ColorSpace::RGB ? 2 : (colorSpace == yup::ColorSpace::SRGB ? 24 : 48);
+ auto gradient = yup::ColorGradient::fromLinearColors (colorA, start, colorB, end, steps, yup::ColorGradient::Type::Linear, colorSpace);
+ g.setFillColorGradient (gradient);
+ g.fillRoundedRect (area, 8.0f);
+ g.setStrokeColor (yup::Colors::white.withAlpha (0.2f));
+ g.setStrokeWidth (1.0f);
+ g.strokeRoundedRect (area, 8.0f);
+ }
+
+ void drawHsluvPalette (yup::Graphics& g, yup::Rectangle area)
+ {
+ drawSectionTitle (g, "HSLuv Palette", area);
+ area.removeFromTop (10.0f);
+
+ const int columns = 6;
+ const int rows = 2;
+ const float gap = 8.0f;
+ const float swatchWidth = (area.getWidth() - gap * (columns - 1)) / static_cast (columns);
+ const float swatchHeight = (area.getHeight() - gap * (rows - 1)) / static_cast (rows);
+
+ for (int row = 0; row < rows; ++row)
+ {
+ const float luminance = row == 0 ? 0.58f : 0.35f;
+ for (int col = 0; col < columns; ++col)
+ {
+ const int index = row * columns + col;
+ const float hue = static_cast (index) / static_cast (columns * rows);
+ const float saturation = row == 0 ? 0.85f : 0.6f;
+
+ auto swatch = yup::Rectangle (
+ area.getX() + col * (swatchWidth + gap),
+ area.getY() + row * (swatchHeight + gap),
+ swatchWidth,
+ swatchHeight);
+
+ g.setFillColor (yup::Color::fromHSLuv (hue, saturation, luminance));
+ g.fillRoundedRect (swatch, 10.0f);
+ g.setStrokeColor (yup::Colors::black.withAlpha (0.2f));
+ g.setStrokeWidth (1.0f);
+ g.strokeRoundedRect (swatch, 10.0f);
+ }
+ }
+ }
+
+ void drawSpectralMix (yup::Graphics& g, yup::Rectangle area)
+ {
+ drawSectionTitle (g, "Spectral Mixing Ramp", area);
+ area.removeFromTop (10.0f);
+
+ const auto leftColor = yup::Color::fromHSLuv (0.03f, 0.92f, 0.58f);
+ const auto rightColor = yup::Color::fromHSLuv (0.65f, 0.85f, 0.55f);
+ const int steps = 9;
+ const float gap = 8.0f;
+ const float swatchWidth = (area.getWidth() - gap * (steps - 1)) / static_cast (steps);
+ const float swatchHeight = area.getHeight() * 0.55f;
+
+ for (int i = 0; i < steps; ++i)
+ {
+ const float t = static_cast (i) / static_cast (steps - 1);
+ auto swatch = yup::Rectangle (area.getX() + i * (swatchWidth + gap), area.getY(), swatchWidth, swatchHeight);
+ g.setFillColor (leftColor.mixedWith (rightColor, t));
+ g.fillRoundedRect (swatch, 9.0f);
+ }
+
+ auto bar = area.withTrimmedTop (swatchHeight + 14.0f);
+ auto gradient = yup::ColorGradient::fromLinearColors (leftColor, bar.getX(), bar.getY(), rightColor, bar.getRight(), bar.getY(), 7);
+ g.setFillColorGradient (gradient);
+ g.fillRoundedRect (bar, 8.0f);
+ g.setStrokeColor (yup::Colors::white.withAlpha (0.15f));
+ g.setStrokeWidth (1.0f);
+ g.strokeRoundedRect (bar, 8.0f);
+ }
+
+ void drawGradientGallery (yup::Graphics& g, yup::Rectangle area)
+ {
+ drawSectionTitle (g, "Linear + Radial Gradients", area);
+ area.removeFromTop (10.0f);
+
+ auto top = area.removeFromTop (area.getHeight() * 0.5f);
+ auto bottom = area;
+
+ auto linear = yup::ColorGradient::fromLinearColors (
+ yup::Color::fromHSLuv (0.88f, 0.7f, 0.62f),
+ top.getX(),
+ top.getY(),
+ yup::Color::fromHSLuv (0.2f, 0.9f, 0.55f),
+ top.getRight(),
+ top.getBottom(),
+ 6);
+ g.setFillColorGradient (linear);
+ g.fillRoundedRect (top, 12.0f);
+
+ auto radial = yup::ColorGradient::fromLinearColors (
+ yup::Color::fromHSLuv (0.55f, 0.7f, 0.58f),
+ bottom.getX(),
+ bottom.getY(),
+ yup::Color::fromHSLuv (0.95f, 0.2f, 0.2f),
+ bottom.getRight(),
+ bottom.getBottom(),
+ 5,
+ yup::ColorGradient::Radial);
+ g.setFillColorGradient (radial);
+ g.fillRoundedRect (bottom, 12.0f);
+ }
+
+ yup::Color blendColors (yup::Color a, yup::Color b, float t, BlendMode mode) const
+ {
+ if (mode == BlendMode::Spectral)
+ return a.mixedWith (b, t);
+
+ const double ra = a.getRedFloat();
+ const double ga = a.getGreenFloat();
+ const double ba = a.getBlueFloat();
+ const double rb = b.getRedFloat();
+ const double gb = b.getGreenFloat();
+ const double bb = b.getBlueFloat();
+
+ if (mode == BlendMode::Srgb)
+ {
+ const double r = ra + (rb - ra) * t;
+ const double g = ga + (gb - ga) * t;
+ const double bl = ba + (bb - ba) * t;
+ const double alpha = a.getAlphaFloat() + (b.getAlphaFloat() - a.getAlphaFloat()) * t;
+ return colorFromNormalized (r, g, bl, alpha);
+ }
+
+ const double r = fromLinear (toLinear (ra) + (toLinear (rb) - toLinear (ra)) * t);
+ const double g = fromLinear (toLinear (ga) + (toLinear (gb) - toLinear (ga)) * t);
+ const double bl = fromLinear (toLinear (ba) + (toLinear (bb) - toLinear (ba)) * t);
+ const double alpha = a.getAlphaFloat() + (b.getAlphaFloat() - a.getAlphaFloat()) * t;
+ return colorFromNormalized (r, g, bl, alpha);
+ }
+
+ yup::Point pointFromNormalized (const yup::Rectangle& area, const yup::Point& norm) const
+ {
+ return { area.getX() + norm.getX() * area.getWidth(), area.getY() + norm.getY() * area.getHeight() };
+ }
+
+ yup::Point normalizedFromPoint (const yup::Rectangle& area, const yup::Point& point) const
+ {
+ const float x = yup::jlimit (0.0f, 1.0f, (point.getX() - area.getX()) / area.getWidth());
+ const float y = yup::jlimit (0.0f, 1.0f, (point.getY() - area.getY()) / area.getHeight());
+ return { x, y };
+ }
+
+ void drawHandle (yup::Graphics& g, const yup::Point& point, const yup::String& label)
+ {
+ g.setFillColor (yup::Colors::white.withAlpha (0.85f));
+ g.fillEllipse (yup::Rectangle (point.getX() - 6.0f, point.getY() - 6.0f, 12.0f, 12.0f));
+ g.setStrokeColor (yup::Colors::black.withAlpha (0.4f));
+ g.setStrokeWidth (1.0f);
+ g.strokeEllipse (yup::Rectangle (point.getX() - 6.0f, point.getY() - 6.0f, 12.0f, 12.0f));
+ g.setFillColor (yup::Colors::black.withAlpha (0.6f));
+
+ const auto labelFont = yup::ApplicationTheme::getGlobalTheme()->getDefaultFont().withHeight (11.0f);
+ g.fillFittedText (label, labelFont, yup::Rectangle (point.getX() + 8.0f, point.getY() - 10.0f, 18.0f, 18.0f), yup::Justification::left);
+ }
+
+ yup::Point wheelMarkerPosition (const yup::Rectangle& area) const
+ {
+ const float angle = pickerHue * 2.0f * yup::MathConstants::pi;
+ const float radius = pickerSaturation * area.getWidth() * 0.5f;
+ const float cx = area.getCenterX() + std::cos (angle) * radius;
+ const float cy = area.getCenterY() + std::sin (angle) * radius;
+ return { cx, cy };
+ }
+
+ size_t hitTestStop (const yup::Point& position,
+ const yup::Rectangle& area,
+ const yup::Point& start,
+ const yup::Point& end) const
+ {
+ if (gradientStops.empty())
+ return invalidStopIndex;
+
+ const auto line = yup::Line (start, end);
+ for (size_t i = 0; i < gradientStops.size(); ++i)
+ {
+ const auto point = stopPositionForIndex (i, area, line);
+ if (position.distanceTo (point) < 12.0f)
+ return i;
+ }
+
+ return invalidStopIndex;
+ }
+
+ yup::Point stopPositionForIndex (size_t index,
+ const yup::Rectangle& area,
+ const yup::Line& line) const
+ {
+ if (index >= gradientStops.size())
+ return line.getStart();
+
+ const auto& stop = gradientStops[index];
+ if (stop.hasCustomPosition)
+ return pointFromNormalized (area, stop.customPositionNorm);
+
+ return line.pointAlong (stop.t);
+ }
+
+ float projectPositionToT (const yup::Point& position,
+ const yup::Point& start,
+ const yup::Point& end) const
+ {
+ const float dx = end.getX() - start.getX();
+ const float dy = end.getY() - start.getY();
+ const float lenSquared = dx * dx + dy * dy;
+ if (lenSquared <= 0.000001f)
+ return 0.0f;
+
+ const float t = ((position.getX() - start.getX()) * dx + (position.getY() - start.getY()) * dy) / lenSquared;
+ return yup::jlimit (0.0f, 1.0f, t);
+ }
+
+ yup::String formatValue (float value, int decimals = 2) const
+ {
+ return yup::String (value, decimals);
+ }
+
+ void updateCustomStopDeltas()
+ {
+ if (gradientStops.size() < 3)
+ return;
+
+ const auto start = pointFromNormalized (gradientEditorArea, gradientStartNorm);
+ const auto end = pointFromNormalized (gradientEditorArea, gradientEndNorm);
+
+ for (size_t i = 1; i + 1 < gradientStops.size(); ++i)
+ {
+ if (! gradientStops[i].hasCustomPosition)
+ continue;
+
+ const auto position = pointFromNormalized (gradientEditorArea, gradientStops[i].customPositionNorm);
+ const float minT = gradientStops[i - 1].t + 0.001f;
+ const float maxT = gradientStops[i + 1].t - 0.001f;
+ gradientStops[i].t = yup::jlimit (minT, maxT, projectPositionToT (position, start, end));
+ }
+ }
+
+ void selectStop (size_t index)
+ {
+ if (index >= gradientStops.size())
+ return;
+
+ selectedStopIndex = index;
+ updateGradientStopSlidersFromSelection();
+ repaint();
+ }
+
+ void handlePointer (const yup::Point& position, const yup::KeyModifiers& modifiers, bool isDown)
+ {
+ if (currentMode == Mode::GradientEditor)
+ {
+ if (! gradientEditorArea.contains (position))
+ return;
+
+ if (isDown)
+ {
+ const auto start = pointFromNormalized (gradientEditorArea, gradientStartNorm);
+ const auto end = pointFromNormalized (gradientEditorArea, gradientEndNorm);
+ const auto hitIndex = hitTestStop (position, gradientEditorArea, start, end);
+
+ if (position.distanceTo (start) < 14.0f)
+ {
+ dragHandle = DragHandle::Start;
+ selectStop (0);
+ draggingStopIndex = invalidStopIndex;
+ }
+ else if (position.distanceTo (end) < 14.0f)
+ {
+ dragHandle = DragHandle::End;
+ selectStop (gradientStops.size() - 1);
+ draggingStopIndex = invalidStopIndex;
+ }
+ else if (hitIndex != invalidStopIndex)
+ {
+ dragHandle = DragHandle::Stop;
+ draggingStopIndex = hitIndex;
+ selectStop (hitIndex);
+ }
+ else
+ {
+ dragHandle = DragHandle::None;
+ draggingStopIndex = invalidStopIndex;
+ }
+ }
+
+ if (dragHandle != DragHandle::None)
+ {
+ if (dragHandle == DragHandle::Start)
+ {
+ gradientStartNorm = normalizedFromPoint (gradientEditorArea, position);
+ updateCustomStopDeltas();
+ }
+ else if (dragHandle == DragHandle::End)
+ {
+ gradientEndNorm = normalizedFromPoint (gradientEditorArea, position);
+ updateCustomStopDeltas();
+ }
+ else if (dragHandle == DragHandle::Stop && draggingStopIndex != invalidStopIndex)
+ {
+ if (draggingStopIndex > 0 && draggingStopIndex + 1 < gradientStops.size())
+ {
+ const auto start = pointFromNormalized (gradientEditorArea, gradientStartNorm);
+ const auto end = pointFromNormalized (gradientEditorArea, gradientEndNorm);
+ const auto normalized = normalizedFromPoint (gradientEditorArea, position);
+ const auto clampedPosition = pointFromNormalized (gradientEditorArea, normalized);
+ const bool constrainToLine = modifiers.isShiftDown();
+
+ auto& stop = gradientStops[draggingStopIndex];
+ if (constrainToLine)
+ {
+ stop.hasCustomPosition = false;
+ }
+ else
+ {
+ stop.customPositionNorm = normalized;
+ stop.hasCustomPosition = true;
+ }
+
+ const float minT = gradientStops[draggingStopIndex - 1].t + 0.001f;
+ const float maxT = gradientStops[draggingStopIndex + 1].t - 0.001f;
+ stop.t = yup::jlimit (minT, maxT, projectPositionToT (clampedPosition, start, end));
+ }
+ }
+
+ repaint();
+ }
+ }
+ else if (currentMode == Mode::Picker)
+ {
+ if (! pickerWheelArea.contains (position))
+ return;
+
+ const auto center = yup::Point (pickerWheelArea.getCenterX(), pickerWheelArea.getCenterY());
+ const float dx = position.getX() - center.getX();
+ const float dy = position.getY() - center.getY();
+ const float radius = pickerWheelArea.getWidth() * 0.5f;
+ const float distance = std::sqrt (dx * dx + dy * dy);
+ pickerSaturation = yup::jlimit (0.0f, 1.0f, distance / radius);
+ pickerHue = std::fmod ((std::atan2 (dy, dx) / (2.0f * yup::MathConstants::pi) + 1.0f), 1.0f);
+ pickerColor = yup::Color::fromHSV (pickerHue, pickerSaturation, pickerLuminance).withAlpha (pickerAlpha);
+ updatePickerSlidersFromColor();
+ repaint();
+ }
+ }
+
+ void handleChannelSliderChange (size_t index, float value)
+ {
+ if (updatingSliders)
+ return;
+
+ channelValues[index] = value;
+ updateColorFromPickerSliders();
+ }
+
+ void updateColorFromPickerSliders()
+ {
+ updatingSliders = true;
+
+ switch (pickerSpace)
+ {
+ case PickerSpace::Rgba:
+ pickerColor = colorFromNormalized (channelValues[0], channelValues[1], channelValues[2], channelValues[3]);
+ break;
+ case PickerSpace::Hsl:
+ pickerColor = yup::Color::fromHSL (channelValues[0], channelValues[1], channelValues[2], channelValues[3]);
+ break;
+ case PickerSpace::Hsv:
+ pickerColor = yup::Color::fromHSV (channelValues[0], channelValues[1], channelValues[2], channelValues[3]);
+ break;
+ case PickerSpace::Hsluv:
+ pickerColor = yup::Color::fromHSLuv (channelValues[0], channelValues[1], channelValues[2], channelValues[3]);
+ break;
+ }
+
+ updatePickerDerivedValues();
+ updateChannelLabels();
+ updatingSliders = false;
+ repaint();
+ }
+
+ void updatePickerDerivedValues()
+ {
+ const auto hsv = pickerColor.toHSV();
+ pickerHue = std::get<0> (hsv);
+ pickerSaturation = std::get<1> (hsv);
+ pickerLuminance = std::get<2> (hsv);
+ pickerAlpha = pickerColor.getAlphaFloat();
+ }
+
+ void updatePickerSlidersFromColor()
+ {
+ updatingSliders = true;
+
+ updatePickerDerivedValues();
+
+ switch (pickerSpace)
+ {
+ case PickerSpace::Rgba:
+ channelValues = { pickerColor.getRedFloat(), pickerColor.getGreenFloat(), pickerColor.getBlueFloat(), pickerColor.getAlphaFloat() };
+ break;
+ case PickerSpace::Hsl:
+ {
+ const auto hsl = pickerColor.toHSL();
+ channelValues = { std::get<0> (hsl), std::get<1> (hsl), std::get<2> (hsl), pickerColor.getAlphaFloat() };
+ break;
+ }
+ case PickerSpace::Hsv:
+ {
+ const auto hsv = pickerColor.toHSV();
+ channelValues = { std::get<0> (hsv), std::get<1> (hsv), std::get<2> (hsv), pickerColor.getAlphaFloat() };
+ break;
+ }
+ case PickerSpace::Hsluv:
+ {
+ const auto hsluv = pickerColor.toHSLuv();
+ channelValues = { std::get<0> (hsluv), std::get<1> (hsluv), std::get<2> (hsluv), pickerColor.getAlphaFloat() };
+ break;
+ }
+ }
+
+ for (size_t i = 0; i < channelSliders.size(); ++i)
+ channelSliders[i]->setValue (channelValues[i]);
+
+ updateChannelLabels();
+ updatingSliders = false;
+ }
+
+ void updateChannelLabels()
+ {
+ switch (pickerSpace)
+ {
+ case PickerSpace::Rgba:
+ channelLabels[0]->setText ("R " + yup::String (yup::roundToInt (channelValues[0] * 255.0f)), yup::dontSendNotification);
+ channelLabels[1]->setText ("G " + yup::String (yup::roundToInt (channelValues[1] * 255.0f)), yup::dontSendNotification);
+ channelLabels[2]->setText ("B " + yup::String (yup::roundToInt (channelValues[2] * 255.0f)), yup::dontSendNotification);
+ channelLabels[3]->setText ("A " + formatValue (channelValues[3]), yup::dontSendNotification);
+ break;
+ case PickerSpace::Hsl:
+ channelLabels[0]->setText ("H " + formatValue (channelValues[0]), yup::dontSendNotification);
+ channelLabels[1]->setText ("S " + formatValue (channelValues[1]), yup::dontSendNotification);
+ channelLabels[2]->setText ("L " + formatValue (channelValues[2]), yup::dontSendNotification);
+ channelLabels[3]->setText ("A " + formatValue (channelValues[3]), yup::dontSendNotification);
+ break;
+ case PickerSpace::Hsv:
+ channelLabels[0]->setText ("H " + formatValue (channelValues[0]), yup::dontSendNotification);
+ channelLabels[1]->setText ("S " + formatValue (channelValues[1]), yup::dontSendNotification);
+ channelLabels[2]->setText ("V " + formatValue (channelValues[2]), yup::dontSendNotification);
+ channelLabels[3]->setText ("A " + formatValue (channelValues[3]), yup::dontSendNotification);
+ break;
+ case PickerSpace::Hsluv:
+ channelLabels[0]->setText ("H " + formatValue (channelValues[0]), yup::dontSendNotification);
+ channelLabels[1]->setText ("S " + formatValue (channelValues[1]), yup::dontSendNotification);
+ channelLabels[2]->setText ("L " + formatValue (channelValues[2]), yup::dontSendNotification);
+ channelLabels[3]->setText ("A " + formatValue (channelValues[3]), yup::dontSendNotification);
+ break;
+ }
+ }
+
+ void updateBlendSlidersFromColors()
+ {
+ updatingBlendSliders = true;
+ blendStartValues = { blendStartColor.getRedFloat(), blendStartColor.getGreenFloat(), blendStartColor.getBlueFloat(), blendStartColor.getAlphaFloat() };
+ blendEndValues = { blendEndColor.getRedFloat(), blendEndColor.getGreenFloat(), blendEndColor.getBlueFloat(), blendEndColor.getAlphaFloat() };
+
+ for (size_t i = 0; i < blendStartSliders.size(); ++i)
+ {
+ blendStartSliders[i]->setValue (blendStartValues[i]);
+ blendEndSliders[i]->setValue (blendEndValues[i]);
+ }
+
+ updateBlendLabels();
+ updatingBlendSliders = false;
+ }
+
+ void updateBlendColorsFromSliders()
+ {
+ if (updatingBlendSliders)
+ return;
+
+ blendStartColor = colorFromNormalized (blendStartValues[0], blendStartValues[1], blendStartValues[2], blendStartValues[3]);
+ blendEndColor = colorFromNormalized (blendEndValues[0], blendEndValues[1], blendEndValues[2], blendEndValues[3]);
+ updateBlendLabels();
+ repaint();
+ }
+
+ void updateBlendLabels()
+ {
+ for (size_t i = 0; i < blendStartLabels.size(); ++i)
+ {
+ const yup::String startPrefix = i == 0 ? "Start R " : i == 1 ? "Start G "
+ : i == 2 ? "Start B "
+ : "Start A ";
+ const yup::String endPrefix = i == 0 ? "End R " : i == 1 ? "End G "
+ : i == 2 ? "End B "
+ : "End A ";
+
+ if (i < 3)
+ {
+ blendStartLabels[i]->setText (startPrefix + yup::String (yup::roundToInt (blendStartValues[i] * 255.0f)), yup::dontSendNotification);
+ blendEndLabels[i]->setText (endPrefix + yup::String (yup::roundToInt (blendEndValues[i] * 255.0f)), yup::dontSendNotification);
+ }
+ else
+ {
+ blendStartLabels[i]->setText (startPrefix + yup::String (blendStartValues[i], 2), yup::dontSendNotification);
+ blendEndLabels[i]->setText (endPrefix + yup::String (blendEndValues[i], 2), yup::dontSendNotification);
+ }
+ }
+ }
+
+ void updateGradientStopSlidersFromSelection()
+ {
+ if (gradientStops.empty())
+ return;
+
+ if (selectedStopIndex >= gradientStops.size())
+ selectedStopIndex = gradientStops.size() - 1;
+
+ if (removeStopButton)
+ removeStopButton->setEnabled (gradientStops.size() > 2);
+
+ updatingStopSliders = true;
+ const auto& color = gradientStops[selectedStopIndex].color;
+ stopColorValues = { color.getRedFloat(), color.getGreenFloat(), color.getBlueFloat(), color.getAlphaFloat() };
+
+ for (size_t i = 0; i < stopColorSliders.size(); ++i)
+ stopColorSliders[i]->setValue (stopColorValues[i]);
+
+ updateStopLabels();
+ updatingStopSliders = false;
+ }
+
+ void updateSelectedStopColor()
+ {
+ if (updatingStopSliders || gradientStops.empty())
+ return;
+
+ gradientStops[selectedStopIndex].color = colorFromNormalized (stopColorValues[0], stopColorValues[1], stopColorValues[2], stopColorValues[3]);
+ updateGradientEndpointsFromStops();
+ updateStopLabels();
+ repaint();
+ }
+
+ void updateStopLabels()
+ {
+ for (size_t i = 0; i < stopColorLabels.size(); ++i)
+ {
+ const yup::String prefix = i == 0 ? "Stop R " : i == 1 ? "Stop G "
+ : i == 2 ? "Stop B "
+ : "Stop A ";
+ if (i < 3)
+ stopColorLabels[i]->setText (prefix + yup::String (yup::roundToInt (stopColorValues[i] * 255.0f)), yup::dontSendNotification);
+ else
+ stopColorLabels[i]->setText (prefix + yup::String (stopColorValues[i], 2), yup::dontSendNotification);
+ }
+ }
+
+ void updateGradientEndpointsFromStops()
+ {
+ if (gradientStops.size() < 2)
+ return;
+
+ gradientStartColor = gradientStops.front().color;
+ gradientEndColor = gradientStops.back().color;
+ }
+
+ void addGradientStop()
+ {
+ if (gradientStops.empty())
+ return;
+
+ size_t insertIndex = 0;
+ float t = 0.5f;
+ const auto size = gradientStops.size();
+
+ if (selectedStopIndex < size - 1)
+ {
+ const auto& a = gradientStops[selectedStopIndex];
+ const auto& b = gradientStops[selectedStopIndex + 1];
+ t = (a.t + b.t) * 0.5f;
+ insertIndex = selectedStopIndex + 1;
+ }
+ else if (selectedStopIndex > 0)
+ {
+ const auto& a = gradientStops[selectedStopIndex - 1];
+ const auto& b = gradientStops[selectedStopIndex];
+ t = (a.t + b.t) * 0.5f;
+ insertIndex = selectedStopIndex;
+ }
+
+ GradientStopData newStop;
+ newStop.t = t;
+ newStop.color = gradientStops[selectedStopIndex].color;
+
+ gradientStops.insert (gradientStops.begin() + static_cast (insertIndex), newStop);
+ sortGradientStops();
+ selectedStopIndex = findStopIndexByT (t);
+ updateGradientStopSlidersFromSelection();
+ repaint();
+ }
+
+ void removeSelectedStop()
+ {
+ if (gradientStops.size() <= 2 || selectedStopIndex >= gradientStops.size())
+ return;
+
+ gradientStops.erase (gradientStops.begin() + static_cast (selectedStopIndex));
+ if (selectedStopIndex >= gradientStops.size())
+ selectedStopIndex = gradientStops.size() - 1;
+
+ updateGradientEndpointsFromStops();
+ updateGradientStopSlidersFromSelection();
+ repaint();
+ }
+
+ void sortGradientStops()
+ {
+ std::sort (gradientStops.begin(), gradientStops.end(), [] (const auto& a, const auto& b)
+ {
+ return a.t < b.t;
+ });
+
+ if (! gradientStops.empty())
+ {
+ gradientStops.front().t = 0.0f;
+ gradientStops.front().hasCustomPosition = false;
+ gradientStops.back().t = 1.0f;
+ gradientStops.back().hasCustomPosition = false;
+ }
+
+ updateGradientEndpointsFromStops();
+ }
+
+ size_t findStopIndexByT (float t) const
+ {
+ for (size_t i = 0; i < gradientStops.size(); ++i)
+ {
+ if (std::abs (gradientStops[i].t - t) < 0.0001f)
+ return i;
+ }
+
+ return gradientStops.empty() ? 0 : gradientStops.size() - 1;
+ }
+
+ static constexpr size_t invalidStopIndex = std::numeric_limits::max();
+
+ Mode currentMode = Mode::BlendSpaces;
+ PickerSpace pickerSpace = PickerSpace::Hsluv;
+ DragHandle dragHandle = DragHandle::None;
+ size_t draggingStopIndex = invalidStopIndex;
+
+ yup::Rectangle headerArea;
+ yup::Rectangle contentArea;
+ yup::Rectangle gradientEditorArea;
+ yup::Rectangle pickerWheelArea;
+
+ std::unique_ptr modeCombo;
+ std::unique_ptr gradientTypeCombo;
+ std::unique_ptr pickerSpaceCombo;
+ std::array, 4> channelSliders;
+ std::array, 4> channelLabels;
+ std::array, 4> blendStartSliders;
+ std::array, 4> blendStartLabels;
+ std::array, 4> blendEndSliders;
+ std::array, 4> blendEndLabels;
+ std::unique_ptr addStopButton;
+ std::unique_ptr removeStopButton;
+ std::array, 4> stopColorSliders;
+ std::array, 4> stopColorLabels;
+
+ bool updatingSliders = false;
+ std::array channelValues { 0.5f, 0.5f, 0.5f, 1.0f };
+ bool updatingBlendSliders = false;
+ std::array blendStartValues { 1.0f, 0.2f, 0.2f, 1.0f };
+ std::array blendEndValues { 0.2f, 0.4f, 1.0f, 1.0f };
+ bool updatingStopSliders = false;
+ std::array stopColorValues { 1.0f, 0.2f, 0.2f, 1.0f };
+
+ yup::Color pickerColor;
+ float pickerHue = 0.1f;
+ float pickerSaturation = 0.8f;
+ float pickerLuminance = 0.55f;
+ float pickerAlpha = 1.0f;
+
+ yup::Color blendStartColor = yup::Color::fromHSLuv (0.08f, 0.85f, 0.6f);
+ yup::Color blendEndColor = yup::Color::fromHSLuv (0.7f, 0.8f, 0.45f);
+ yup::Color gradientStartColor = blendStartColor;
+ yup::Color gradientEndColor = blendEndColor;
+ bool isGradientRadial = false;
+ yup::Point gradientStartNorm { 0.2f, 0.3f };
+ yup::Point gradientEndNorm { 0.8f, 0.7f };
+ std::vector gradientStops;
+ size_t selectedStopIndex = 0;
+};
diff --git a/examples/graphics/source/main.cpp b/examples/graphics/source/main.cpp
index f2424a422..fbce909d9 100644
--- a/examples/graphics/source/main.cpp
+++ b/examples/graphics/source/main.cpp
@@ -42,6 +42,7 @@
#include "examples/AudioFileDemo.h"
#include "examples/CrossoverDemo.h"
#include "examples/ConvolutionDemo.h"
+#include "examples/ColorLab.h"
#include "examples/FilterDemo.h"
#include "examples/LayoutFonts.h"
#include "examples/FileChooser.h"
@@ -111,6 +112,7 @@ class CustomWindow
registerDemo ("Filter Demo", counter++);
registerDemo ("Crossover Demo", counter++);
registerDemo ("Convolution Demo", counter++);
+ registerDemo ("Color Lab", counter++);
registerDemo ("Layout Fonts", counter++);
registerDemo ("Variable Fonts", counter++);
registerDemo ("Paths", counter++);
diff --git a/modules/yup_graphics/graphics/yup_Color.cpp b/modules/yup_graphics/graphics/yup_Color.cpp
index 82f9ac89d..023b0ef36 100644
--- a/modules/yup_graphics/graphics/yup_Color.cpp
+++ b/modules/yup_graphics/graphics/yup_Color.cpp
@@ -22,10 +22,11 @@
namespace yup
{
-//==============================================================================
-
namespace
{
+
+//==============================================================================
+
int hexCharToInt (yup_wchar c) noexcept
{
return CharacterFunctions::getHexDigitValue (c);
@@ -195,10 +196,721 @@ Color parseNamedColor (const String& name)
return Colors::transparentBlack;
}
+
+//==============================================================================
+
+using DoubleRgb = std::array;
+using IntRgb = std::array;
+
+struct HsluvBounds
+{
+ double a;
+ double b;
+};
+
+constexpr double hsluvRefU = 0.19783000664283680764;
+constexpr double hsluvRefV = 0.46831999493879100370;
+constexpr double hsluvKappa = 903.29629629629629629630;
+constexpr double hsluvEpsilon = 0.00885645167903563082;
+constexpr double hsluvZero = 0.00000001;
+
+const std::array hsluvMatrixRgb = { { { 3.24096994190452134377, -1.53738317757009345794, -0.49861076029300328366 },
+ { -0.96924363628087982613, 1.87596750150772066772, 0.04155505740717561247 },
+ { 0.05563007969699360846, -0.20397695888897656435, 1.05697151424287856072 } } };
+
+const std::array hsluvMatrixXyz = { { { 0.41239079926595948129, 0.35758433938387796373, 0.18048078840183428751 },
+ { 0.21263900587151035754, 0.71516867876775592746, 0.07219231536073371500 },
+ { 0.01933081871559185069, 0.11919477979462598791, 0.95053215224966058086 } } };
+
+double hsluvDotProduct (const DoubleRgb& t1, const DoubleRgb& t2) noexcept
+{
+ return (t1[0] * t2[0] + t1[1] * t2[1] + t1[2] * t2[2]);
+}
+
+double hsluvFromLinear (double value) noexcept
+{
+ if (value <= 0.0031308)
+ return 12.92 * value;
+
+ return 1.055 * std::pow (value, 1.0 / 2.4) - 0.055;
+}
+
+double hsluvToLinear (double value) noexcept
+{
+ if (value > 0.04045)
+ return std::pow ((value + 0.055) / 1.055, 2.4);
+
+ return value / 12.92;
+}
+
+void hsluvXyzToRgb (DoubleRgb& value) noexcept
+{
+ const double r = hsluvFromLinear (hsluvDotProduct (hsluvMatrixRgb[0], value));
+ const double g = hsluvFromLinear (hsluvDotProduct (hsluvMatrixRgb[1], value));
+ const double b = hsluvFromLinear (hsluvDotProduct (hsluvMatrixRgb[2], value));
+
+ value[0] = r;
+ value[1] = g;
+ value[2] = b;
+}
+
+void hsluvRgbToXyz (DoubleRgb& value) noexcept
+{
+ const DoubleRgb linear = { hsluvToLinear (value[0]), hsluvToLinear (value[1]), hsluvToLinear (value[2]) };
+
+ value[0] = hsluvDotProduct (hsluvMatrixXyz[0], linear);
+ value[1] = hsluvDotProduct (hsluvMatrixXyz[1], linear);
+ value[2] = hsluvDotProduct (hsluvMatrixXyz[2], linear);
+}
+
+double hsluvYToL (double value) noexcept
+{
+ if (value <= hsluvEpsilon)
+ return value * hsluvKappa;
+
+ return 116.0 * std::cbrt (value) - 16.0;
+}
+
+double hsluvLToY (double value) noexcept
+{
+ if (value <= 8.0)
+ return value / hsluvKappa;
+
+ const double x = (value + 16.0) / 116.0;
+ return x * x * x;
+}
+
+void hsluvXyzToLuv (DoubleRgb& value) noexcept
+{
+ const double varU = (4.0 * value[0]) / (value[0] + (15.0 * value[1]) + (3.0 * value[2]));
+ const double varV = (9.0 * value[1]) / (value[0] + (15.0 * value[1]) + (3.0 * value[2]));
+ const double l = hsluvYToL (value[1]);
+ const double u = 13.0 * l * (varU - hsluvRefU);
+ const double v = 13.0 * l * (varV - hsluvRefV);
+
+ value[0] = l;
+ if (l < hsluvZero)
+ {
+ value[1] = 0.0;
+ value[2] = 0.0;
+ }
+ else
+ {
+ value[1] = u;
+ value[2] = v;
+ }
+}
+
+void hsluvLuvToXyz (DoubleRgb& value) noexcept
+{
+ if (value[0] <= hsluvZero)
+ {
+ value[0] = 0.0;
+ value[1] = 0.0;
+ value[2] = 0.0;
+ return;
+ }
+
+ const double varU = value[1] / (13.0 * value[0]) + hsluvRefU;
+ const double varV = value[2] / (13.0 * value[0]) + hsluvRefV;
+ const double y = hsluvLToY (value[0]);
+ const double x = -(9.0 * y * varU) / ((varU - 4.0) * varV - varU * varV);
+ const double z = (9.0 * y - (15.0 * varV * y) - (varV * x)) / (3.0 * varV);
+
+ value[0] = x;
+ value[1] = y;
+ value[2] = z;
+}
+
+void hsluvLuvToLch (DoubleRgb& value) noexcept
+{
+ const double l = value[0];
+ const double u = value[1];
+ const double v = value[2];
+ const double c = std::sqrt (u * u + v * v);
+
+ double h = 0.0;
+ if (c >= hsluvZero)
+ {
+ h = std::atan2 (v, u) * 57.29577951308232087680;
+ if (h < 0.0)
+ h += 360.0;
+ }
+
+ value[0] = l;
+ value[1] = c;
+ value[2] = h;
+}
+
+void hsluvLchToLuv (DoubleRgb& value) noexcept
+{
+ const double hrad = value[2] * 0.01745329251994329577;
+ const double u = std::cos (hrad) * value[1];
+ const double v = std::sin (hrad) * value[1];
+
+ value[1] = u;
+ value[2] = v;
+}
+
+void hsluvGetBounds (double l, std::array& bounds) noexcept
+{
+ const double tl = l + 16.0;
+ const double sub1 = (tl * tl * tl) / 1560896.0;
+ const double sub2 = sub1 > hsluvEpsilon ? sub1 : (l / hsluvKappa);
+
+ for (int channel = 0; channel < 3; ++channel)
+ {
+ const auto& matrix = hsluvMatrixRgb[channel];
+
+ const double m1 = matrix[0];
+ const double m2 = matrix[1];
+ const double m3 = matrix[2];
+
+ for (int t = 0; t < 2; ++t)
+ {
+ const double top1 = (284517.0 * m1 - 94839.0 * m3) * sub2;
+ const double top2 = (838422.0 * m3 + 769860.0 * m2 + 731718.0 * m1) * l * sub2 - 769860.0 * t * l;
+ const double bottom = (632260.0 * m3 - 126452.0 * m2) * sub2 + 126452.0 * t;
+
+ bounds[channel * 2 + t] = { top1 / bottom, top2 / bottom };
+ }
+ }
+}
+
+double hsluvRayLengthUntilIntersect (double theta, const HsluvBounds& line) noexcept
+{
+ return line.b / (std::sin (theta) - line.a * std::cos (theta));
+}
+
+double hsluvMaxChromaForLH (double l, double h) noexcept
+{
+ double minLen = std::numeric_limits::max();
+ const double hrad = h * 0.01745329251994329577;
+ std::array bounds;
+
+ hsluvGetBounds (l, bounds);
+ for (const auto& bound : bounds)
+ {
+ const double len = hsluvRayLengthUntilIntersect (hrad, bound);
+
+ if (len >= 0.0 && len < minLen)
+ minLen = len;
+ }
+
+ return minLen;
+}
+
+void hsluvToLch (DoubleRgb& value) noexcept
+{
+ double h = value[0];
+ const double s = value[1];
+ const double l = value[2];
+ double c = 0.0;
+
+ if (l > 99.9999999 || l < hsluvZero)
+ c = 0.0;
+ else
+ c = hsluvMaxChromaForLH (l, h) / 100.0 * s;
+
+ if (s < hsluvZero)
+ h = 0.0;
+
+ value[0] = l;
+ value[1] = c;
+ value[2] = h;
+}
+
+void hsluvFromLch (DoubleRgb& value) noexcept
+{
+ const double l = value[0];
+ const double c = value[1];
+ double h = value[2];
+ double s = 0.0;
+
+ if (l > 99.9999999 || l < hsluvZero)
+ s = 0.0;
+ else
+ s = c / hsluvMaxChromaForLH (l, h) * 100.0;
+
+ if (c < hsluvZero)
+ h = 0.0;
+
+ value[0] = h;
+ value[1] = s;
+ value[2] = l;
+}
+
+DoubleRgb hsluvToRgb (double h, double s, double l) noexcept
+{
+ DoubleRgb tmp = { h, s, l };
+
+ hsluvToLch (tmp);
+ hsluvLchToLuv (tmp);
+ hsluvLuvToXyz (tmp);
+ hsluvXyzToRgb (tmp);
+
+ tmp[0] = jlimit (0.0, 1.0, tmp[0]);
+ tmp[1] = jlimit (0.0, 1.0, tmp[1]);
+ tmp[2] = jlimit (0.0, 1.0, tmp[2]);
+
+ return tmp;
+}
+
+DoubleRgb hsluvFromRgb (double r, double g, double b) noexcept
+{
+ DoubleRgb tmp = { r, g, b };
+
+ hsluvRgbToXyz (tmp);
+ hsluvXyzToLuv (tmp);
+ hsluvLuvToLch (tmp);
+ hsluvFromLch (tmp);
+
+ tmp[0] = jlimit (0.0, 360.0, tmp[0]);
+ tmp[1] = jlimit (0.0, 100.0, tmp[1]);
+ tmp[2] = jlimit (0.0, 100.0, tmp[2]);
+
+ return tmp;
+}
+
+//==============================================================================
+
+constexpr int spectralSampleCount = 38;
+constexpr double spectralGamma = 2.4;
+constexpr double spectralEpsilon = 0.00000001;
+
+using SpectralSamples = std::array;
+
+constexpr SpectralSamples spdC = { 0.96853629, 0.96855103, 0.96859338, 0.96877345, 0.96942204, 0.97143709, 0.97541862, 0.98074186, 0.98580992, 0.98971194, 0.99238027, 0.99409844, 0.995172, 0.99576545, 0.99593552, 0.99564041, 0.99464769, 0.99229579, 0.98638762, 0.96829712, 0.89228016, 0.53740239, 0.15360445, 0.05705719, 0.03126539, 0.02205445, 0.01802271, 0.0161346, 0.01520947, 0.01475977, 0.01454263, 0.01444459, 0.01439897, 0.0143762, 0.01436343, 0.01435687, 0.0143537, 0.01435408 };
+constexpr SpectralSamples spdM = { 0.51567122, 0.5401552, 0.62645502, 0.75595012, 0.92826996, 0.97223624, 0.98616174, 0.98955255, 0.98676237, 0.97312575, 0.91944277, 0.32564851, 0.13820628, 0.05015143, 0.02912336, 0.02421691, 0.02660696, 0.03407586, 0.04835936, 0.0001172, 0.00008554, 0.85267882, 0.93188793, 0.94810268, 0.94200977, 0.91478045, 0.87065445, 0.78827548, 0.65738359, 0.59909403, 0.56817268, 0.54031997, 0.52110241, 0.51041094, 0.50526577, 0.5025508, 0.50126452, 0.50083021 };
+constexpr SpectralSamples spdY = { 0.02055257, 0.02059936, 0.02062723, 0.02073387, 0.02114202, 0.02233154, 0.02556857, 0.03330189, 0.05185294, 0.10087639, 0.24000413, 0.53589066, 0.79874659, 0.91186529, 0.95399623, 0.97137099, 0.97939505, 0.98345207, 0.98553736, 0.98648905, 0.98674535, 0.98657555, 0.98611877, 0.98559942, 0.98507063, 0.98460039, 0.98425301, 0.98403909, 0.98388535, 0.98376116, 0.98368246, 0.98365023, 0.98361309, 0.98357259, 0.98353856, 0.98351247, 0.98350101, 0.98350852 };
+constexpr SpectralSamples spdR = { 0.03147571, 0.03146636, 0.03140624, 0.03119611, 0.03053888, 0.02856855, 0.02459485, 0.0192952, 0.01423112, 0.01033111, 0.00765876, 0.00593693, 0.00485616, 0.00426186, 0.00409039, 0.00438375, 0.00537525, 0.00772962, 0.0136612, 0.03181352, 0.10791525, 0.46249516, 0.84604333, 0.94275572, 0.96860996, 0.97783966, 0.98187757, 0.98377315, 0.98470202, 0.98515481, 0.98537114, 0.98546685, 0.98550011, 0.98551031, 0.98550741, 0.98551323, 0.98551563, 0.98551547 };
+constexpr SpectralSamples spdG = { 0.49108579, 0.46944057, 0.4016578, 0.2449042, 0.0682688, 0.02732883, 0.013606, 0.01000187, 0.01284127, 0.02636635, 0.07058713, 0.70421692, 0.85473994, 0.95081565, 0.9717037, 0.97651888, 0.97429245, 0.97012917, 0.9425863, 0.99989207, 0.99989891, 0.13823139, 0.06968113, 0.05628787, 0.06111561, 0.08987709, 0.13656016, 0.22169624, 0.32176956, 0.36157329, 0.4836192, 0.46488579, 0.47440306, 0.4857699, 0.49267971, 0.49625685, 0.49807754, 0.49889859 };
+constexpr SpectralSamples spdB = { 0.97901834, 0.97901649, 0.97901118, 0.97892146, 0.97858555, 0.97743705, 0.97428075, 0.96663223, 0.94822893, 0.89937713, 0.76070164, 0.4642044, 0.20123039, 0.08808402, 0.04592894, 0.02860373, 0.02060067, 0.01656701, 0.01451549, 0.01357964, 0.01331243, 0.01347661, 0.01387181, 0.01435472, 0.01479836, 0.0151525, 0.01540513, 0.01557233, 0.0156571, 0.01571025, 0.01571916, 0.01572133, 0.01572502, 0.01571717, 0.01571905, 0.01571059, 0.01569728, 0.0157002 };
+constexpr SpectralSamples cieCmfX = { 0.00006469, 0.00021941, 0.00112057, 0.00376661, 0.01188055, 0.02328644, 0.03455942, 0.03722379, 0.03241838, 0.02123321, 0.01049099, 0.00329584, 0.00050704, 0.00094867, 0.00627372, 0.01686462, 0.02868965, 0.04267481, 0.05625475, 0.0694704, 0.08305315, 0.0861261, 0.09046614, 0.08500387, 0.07090667, 0.05062889, 0.03547396, 0.02146821, 0.01251646, 0.00680458, 0.00346457, 0.00149761, 0.0007697, 0.00040737, 0.00016901, 0.00009522, 0.00004903, 0.00002 };
+constexpr SpectralSamples cieCmfY = { 0.00000184, 0.00000621, 0.00003101, 0.00010475, 0.00035364, 0.00095147, 0.00228226, 0.00420733, 0.0066888, 0.0098884, 0.01524945, 0.02141831, 0.03342293, 0.05131001, 0.07040208, 0.08783871, 0.09424905, 0.09795667, 0.09415219, 0.08678102, 0.07885653, 0.0635267, 0.05374142, 0.04264606, 0.03161735, 0.02088521, 0.01386011, 0.00810264, 0.0046301, 0.00249138, 0.0012593, 0.00054165, 0.00027795, 0.00014711, 0.00006103, 0.00003439, 0.00001771, 0.00000722 };
+constexpr SpectralSamples cieCmfZ = { 0.00030502, 0.00103681, 0.00531314, 0.01795439, 0.05707758, 0.11365162, 0.17335873, 0.19620658, 0.18608237, 0.13995048, 0.08917453, 0.04789621, 0.02814563, 0.01613766, 0.0077591, 0.00429615, 0.00200551, 0.00086147, 0.00036904, 0.00019143, 0.00014956, 0.00009231, 0.00006813, 0.00002883, 0.00001577, 0.00000394, 0.00000158, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+constexpr std::array xyzRgb = { { { 3.24306333, -1.53837619, -0.49893282 }, { -0.96896309, 1.87542451, 0.04154303 }, { 0.05568392, -0.20417438, 1.05799454 } } };
+
+double dotProduct (const SpectralSamples& a, const SpectralSamples& b) noexcept
+{
+ return std::inner_product (a.begin(), a.end(), b.begin(), 0.0);
+}
+
+double dotProduct (const DoubleRgb& a, const DoubleRgb& b) noexcept
+{
+ return std::inner_product (a.begin(), a.end(), b.begin(), 0.0);
+}
+
+double compand (double value) noexcept
+{
+ if (value < 0.0031308)
+ return value * 12.92;
+
+ return 1.055 * std::pow (value, 1.0 / spectralGamma) - 0.055;
+}
+
+double uncompand (double value) noexcept
+{
+ if (value < 0.04045)
+ return value / 12.92;
+
+ return std::pow ((value + 0.055) / 1.055, spectralGamma);
+}
+
+IntRgb linearToSrgb (const DoubleRgb& lrgb) noexcept
+{
+ const double r = compand (lrgb[0]);
+ const double g = compand (lrgb[1]);
+ const double b = compand (lrgb[2]);
+
+ return {
+ static_cast (jlimit (0.0, 1.0, r) * 255.0),
+ static_cast (jlimit (0.0, 1.0, g) * 255.0),
+ static_cast (jlimit (0.0, 1.0, b) * 255.0)
+ };
+}
+
+IntRgb xyzToSrgb (const DoubleRgb& xyz) noexcept
+{
+ const double r = dotProduct (xyzRgb[0], xyz);
+ const double g = dotProduct (xyzRgb[1], xyz);
+ const double b = dotProduct (xyzRgb[2], xyz);
+
+ return linearToSrgb ({ r, g, b });
+}
+
+DoubleRgb reflectanceToXyz (const SpectralSamples& reflectance) noexcept
+{
+ return {
+ dotProduct (reflectance, cieCmfX),
+ dotProduct (reflectance, cieCmfY),
+ dotProduct (reflectance, cieCmfZ)
+ };
+}
+
+std::array spectralUpsampling (const DoubleRgb& lrgb) noexcept
+{
+ double w = jmin (lrgb[0], lrgb[1], lrgb[2]);
+
+ const DoubleRgb normalized = { lrgb[0] - w, lrgb[1] - w, lrgb[2] - w };
+
+ const double c = jmin (normalized[1], normalized[2]);
+ const double m = jmin (normalized[0], normalized[2]);
+ const double y = jmin (normalized[0], normalized[1]);
+ const double r = jmax (0.0, jmin (normalized[0] - normalized[2], normalized[0] - normalized[1]));
+ const double g = jmax (0.0, jmin (normalized[1] - normalized[2], normalized[1] - normalized[0]));
+ const double b = jmax (0.0, jmin (normalized[2] - normalized[1], normalized[2] - normalized[0]));
+
+ return { w, c, m, y, r, g, b };
+}
+
+SpectralSamples linearToReflectance (const DoubleRgb& lrgb) noexcept
+{
+ const auto weights = spectralUpsampling (lrgb);
+ SpectralSamples reflectance = {};
+
+ for (int i = 0; i < spectralSampleCount; ++i)
+ {
+ reflectance[i] = jmax (
+ spectralEpsilon,
+ weights[0] + weights[1] * spdC[i] + weights[2] * spdM[i] + weights[3] * spdY[i] + weights[4] * spdR[i] + weights[5] * spdG[i] + weights[6] * spdB[i]);
+ }
+
+ return reflectance;
+}
+
+DoubleRgb srgbToLinear (Color color) noexcept
+{
+ const double r = uncompand (color.getRedFloat());
+ const double g = uncompand (color.getGreenFloat());
+ const double b = uncompand (color.getBlueFloat());
+
+ return { r, g, b };
+}
+
+double linearToConcentration (double l1, double l2, double t) noexcept
+{
+ const double t1 = l1 * std::pow (1.0 - t, 2.0);
+ const double t2 = l2 * std::pow (t, 2.0);
+
+ return t2 / (t1 + t2);
+}
+
+IntRgb spectralMix (const DoubleRgb& lrgb1, const DoubleRgb& lrgb2, double t) noexcept
+{
+ const SpectralSamples reflectance1 = linearToReflectance (lrgb1);
+ const SpectralSamples reflectance2 = linearToReflectance (lrgb2);
+
+ const double l1 = dotProduct (reflectance1, cieCmfY);
+ const double l2 = dotProduct (reflectance2, cieCmfY);
+
+ t = linearToConcentration (l1, l2, t);
+
+ SpectralSamples reflectance = {};
+
+ for (int i = 0; i < spectralSampleCount; ++i)
+ {
+ const double ks1 = (1.0 - t) * (std::pow (1.0 - reflectance1[i], 2.0) / (2.0 * reflectance1[i]));
+ const double ks2 = t * (std::pow (1.0 - reflectance2[i], 2.0) / (2.0 * reflectance2[i]));
+ const double ks = ks1 + ks2;
+ const double km = 1.0 + ks - std::sqrt (std::pow (ks, 2.0) + 2.0 * ks);
+
+ reflectance[i] = km;
+ }
+
+ return xyzToSrgb (reflectanceToXyz (reflectance));
+}
+
+//==============================================================================
+
+struct DoubleHsl
+{
+ double h = 0.0;
+ double s = 0.0;
+ double l = 0.0;
+};
+
+DoubleHsl rgbToHsl (const DoubleRgb& rgb) noexcept
+{
+ const double maxValue = jmax (rgb[0], rgb[1], rgb[2]);
+ const double minValue = jmin (rgb[0], rgb[1], rgb[2]);
+ const double l = (maxValue + minValue) * 0.5;
+
+ if (maxValue == minValue)
+ return { 0.0, 0.0, l };
+
+ const double d = maxValue - minValue;
+ const double s = l > 0.5 ? d / (2.0 - maxValue - minValue) : d / (maxValue + minValue);
+ double h = 0.0;
+
+ if (maxValue == rgb[0])
+ h = (rgb[1] - rgb[2]) / d + (rgb[1] < rgb[2] ? 6.0 : 0.0);
+ else if (maxValue == rgb[1])
+ h = (rgb[2] - rgb[0]) / d + 2.0;
+ else
+ h = (rgb[0] - rgb[1]) / d + 4.0;
+
+ h /= 6.0;
+ return { h, s, l };
+}
+
+DoubleRgb hslToRgb (const DoubleHsl& hsl) noexcept
+{
+ auto hueToRgb = [] (double p, double q, double t)
+ {
+ if (t < 0.0)
+ t += 1.0;
+ if (t > 1.0)
+ t -= 1.0;
+ if (t < 1.0 / 6.0)
+ return p + (q - p) * 6.0 * t;
+ if (t < 1.0 / 2.0)
+ return q;
+ if (t < 2.0 / 3.0)
+ return p + (q - p) * (2.0 / 3.0 - t) * 6.0;
+ return p;
+ };
+
+ double r = hsl.l;
+ double g = hsl.l;
+ double b = hsl.l;
+
+ if (hsl.s != 0.0)
+ {
+ const double q = hsl.l < 0.5 ? hsl.l * (1.0 + hsl.s) : hsl.l + hsl.s - hsl.l * hsl.s;
+ const double p = 2.0 * hsl.l - q;
+ r = hueToRgb (p, q, hsl.h + 1.0 / 3.0);
+ g = hueToRgb (p, q, hsl.h);
+ b = hueToRgb (p, q, hsl.h - 1.0 / 3.0);
+ }
+
+ return { r, g, b };
+}
+
+double blendChannel (BlendMode mode, double backdrop, double source) noexcept
+{
+ switch (mode)
+ {
+ case BlendMode::SrcOver:
+ return source;
+ case BlendMode::Screen:
+ return 1.0 - (1.0 - backdrop) * (1.0 - source);
+ case BlendMode::Overlay:
+ return backdrop <= 0.5 ? 2.0 * backdrop * source : 1.0 - 2.0 * (1.0 - backdrop) * (1.0 - source);
+ case BlendMode::Darken:
+ return jmin (backdrop, source);
+ case BlendMode::Lighten:
+ return jmax (backdrop, source);
+ case BlendMode::ColorDodge:
+ return source >= 1.0 ? 1.0 : jmin (1.0, backdrop / (1.0 - source));
+ case BlendMode::ColorBurn:
+ return source <= 0.0 ? 0.0 : 1.0 - jmin (1.0, (1.0 - backdrop) / source);
+ case BlendMode::HardLight:
+ return source <= 0.5 ? 2.0 * backdrop * source : 1.0 - 2.0 * (1.0 - backdrop) * (1.0 - source);
+ case BlendMode::SoftLight:
+ {
+ if (source <= 0.5)
+ return backdrop - (1.0 - 2.0 * source) * backdrop * (1.0 - backdrop);
+
+ const double d = backdrop <= 0.25 ? ((16.0 * backdrop - 12.0) * backdrop + 4.0) * backdrop : std::sqrt (backdrop);
+ return backdrop + (2.0 * source - 1.0) * (d - backdrop);
+ }
+ case BlendMode::Difference:
+ return std::abs (backdrop - source);
+ case BlendMode::Exclusion:
+ return backdrop + source - 2.0 * backdrop * source;
+ case BlendMode::Multiply:
+ return backdrop * source;
+ case BlendMode::Hue:
+ case BlendMode::Saturation:
+ case BlendMode::Color:
+ case BlendMode::Luminosity:
+ return source;
+ default:
+ return source;
+ }
+}
+
+DoubleRgb blendRgb (BlendMode mode, const DoubleRgb& backdrop, const DoubleRgb& source) noexcept
+{
+ if (mode == BlendMode::Hue || mode == BlendMode::Saturation || mode == BlendMode::Color || mode == BlendMode::Luminosity)
+ {
+ const auto hslBackdrop = rgbToHsl (backdrop);
+ const auto hslSource = rgbToHsl (source);
+ DoubleHsl blended = hslBackdrop;
+
+ if (mode == BlendMode::Hue)
+ blended.h = hslSource.h;
+ else if (mode == BlendMode::Saturation)
+ blended.s = hslSource.s;
+ else if (mode == BlendMode::Color)
+ {
+ blended.h = hslSource.h;
+ blended.s = hslSource.s;
+ }
+ else if (mode == BlendMode::Luminosity)
+ blended.l = hslSource.l;
+
+ return hslToRgb (blended);
+ }
+
+ return {
+ blendChannel (mode, backdrop[0], source[0]),
+ blendChannel (mode, backdrop[1], source[1]),
+ blendChannel (mode, backdrop[2], source[2])
+ };
+}
} // namespace
//==============================================================================
+Color& Color::mixWith (Color other, float amount, ColorSpace space) noexcept
+{
+ const float clamped = jlimit (0.0f, 1.0f, amount);
+
+ if (space == ColorSpace::RGB)
+ {
+ if (clamped <= 0.0f)
+ return *this;
+
+ if (clamped >= 1.0f)
+ {
+ *this = other;
+ return *this;
+ }
+
+ return blendWith (other.withMultipliedAlpha (clamped), BlendMode::SrcOver);
+ }
+
+ if (space == ColorSpace::SRGB)
+ {
+ const double ra = getRedFloat();
+ const double ga = getGreenFloat();
+ const double ba = getBlueFloat();
+ const double rb = other.getRedFloat();
+ const double gb = other.getGreenFloat();
+ const double bb = other.getBlueFloat();
+
+ const float outA = getAlphaFloat() + (other.getAlphaFloat() - getAlphaFloat()) * clamped;
+ const float outR = static_cast (ra + (rb - ra) * clamped);
+ const float outG = static_cast (ga + (gb - ga) * clamped);
+ const float outB = static_cast (ba + (bb - ba) * clamped);
+
+ a = normalizedToComponent (outA);
+ r = normalizedToComponent (outR);
+ g = normalizedToComponent (outG);
+ b = normalizedToComponent (outB);
+ return *this;
+ }
+
+ const auto mixed = spectralMix (srgbToLinear (*this), srgbToLinear (other), static_cast (clamped));
+ const float alpha = getAlphaFloat() + (other.getAlphaFloat() - getAlphaFloat()) * clamped;
+
+ a = normalizedToComponent (alpha);
+ r = static_cast (mixed[0]);
+ g = static_cast (mixed[1]);
+ b = static_cast (mixed[2]);
+ return *this;
+}
+
+Color Color::mixedWith (Color other, float amount, ColorSpace space) const noexcept
+{
+ Color result (*this);
+ result.mixWith (other, amount, space);
+ return result;
+}
+
+//==============================================================================
+
+Color& Color::blendWith (Color src, BlendMode mode, float opacity) noexcept
+{
+ const float clampedOpacity = jlimit (0.0f, 1.0f, opacity);
+ if (clampedOpacity <= 0.0f)
+ return *this;
+
+ src = src.withMultipliedAlpha (clampedOpacity);
+
+ const double srcAlpha = src.getAlphaFloat();
+ const double destAlpha = getAlphaFloat();
+
+ if (destAlpha <= 0.0)
+ {
+ *this = src;
+ return *this;
+ }
+
+ if (srcAlpha <= 0.0)
+ return *this;
+
+ const DoubleRgb dest = { getRedFloat(), getGreenFloat(), getBlueFloat() };
+ const DoubleRgb source = { src.getRedFloat(), src.getGreenFloat(), src.getBlueFloat() };
+ const DoubleRgb blended = blendRgb (mode, dest, source);
+
+ const double outAlpha = srcAlpha + destAlpha - srcAlpha * destAlpha;
+ if (outAlpha <= 0.0)
+ {
+ a = 0;
+ r = 0;
+ g = 0;
+ b = 0;
+ return *this;
+ }
+
+ auto compositeChannel = [srcAlpha, destAlpha, outAlpha] (double cb, double cs, double bb)
+ {
+ const double co = (1.0 - srcAlpha) * cb * destAlpha
+ + (1.0 - destAlpha) * cs * srcAlpha
+ + destAlpha * srcAlpha * bb;
+ return jlimit (0.0, 1.0, co / outAlpha);
+ };
+
+ const float outR = static_cast (compositeChannel (dest[0], source[0], blended[0]));
+ const float outG = static_cast (compositeChannel (dest[1], source[1], blended[1]));
+ const float outB = static_cast (compositeChannel (dest[2], source[2], blended[2]));
+ const float outA = static_cast (jlimit (0.0, 1.0, outAlpha));
+
+ r = normalizedToComponent (outR);
+ g = normalizedToComponent (outG);
+ b = normalizedToComponent (outB);
+ a = normalizedToComponent (outA);
+ return *this;
+}
+
+Color Color::blendedWith (Color src, BlendMode mode, float opacity) const noexcept
+{
+ Color result (*this);
+ result.blendWith (src, mode, opacity);
+ return result;
+}
+
+//==============================================================================
+
+std::tuple Color::toHSLuv() const noexcept
+{
+ const auto hsluv = hsluvFromRgb (getRedFloat(), getGreenFloat(), getBlueFloat());
+ const float h = static_cast (modulo (hsluv[0] / 360.0, 1.0));
+ const float s = static_cast (jlimit (0.0, 1.0, hsluv[1] / 100.0));
+ const float l = static_cast (jlimit (0.0, 1.0, hsluv[2] / 100.0));
+ return std::make_tuple (h, s, l);
+}
+
+Color Color::fromHSLuv (float h, float s, float l, float a) noexcept
+{
+ const float normalizedHue = modulo (h, 1.0f);
+ const float normalizedSaturation = jlimit (0.0f, 1.0f, s);
+ const float normalizedLuminance = jlimit (0.0f, 1.0f, l);
+ const auto rgb = hsluvToRgb (normalizedHue * 360.0, normalizedSaturation * 100.0, normalizedLuminance * 100.0);
+
+ return {
+ normalizedToComponent (jlimit (0.0f, 1.0f, a)),
+ normalizedToComponent (static_cast (rgb[0])),
+ normalizedToComponent (static_cast (rgb[1])),
+ normalizedToComponent (static_cast (rgb[2]))
+ };
+}
+
+//==============================================================================
+
String Color::toString() const
{
String result;
diff --git a/modules/yup_graphics/graphics/yup_Color.h b/modules/yup_graphics/graphics/yup_Color.h
index 943abdc4e..e9d243855 100644
--- a/modules/yup_graphics/graphics/yup_Color.h
+++ b/modules/yup_graphics/graphics/yup_Color.h
@@ -22,6 +22,15 @@
namespace yup
{
+//==============================================================================
+/** Enumeration for color spaces. */
+enum class ColorSpace : unsigned int
+{
+ RGB, ///< Standard RGB color space.
+ SRGB, ///< Standard sRGB color space with gamma correction.
+ Spectral ///< Spectral color space for accurate color representation based on light spectra.
+};
+
//==============================================================================
/** Represents an RGBA color for graphical use.
@@ -46,12 +55,12 @@ class YUP_API Color
/** Constructs a color from a 32-bit integer.
This constructor initializes the color from a 32-bit integer, assuming a format
- where the highest byte is alpha, followed by red, green, and blue.
+ where the highest byte is alpha, followed by red, green, and blue (ARGB).
- @param color The 32-bit integer representing the color.
+ @param colorARGB The 32-bit integer representing the color.
*/
- constexpr Color (uint32 color) noexcept
- : data (color)
+ constexpr Color (uint32 colorARGB) noexcept
+ : data (colorARGB)
{
}
@@ -91,6 +100,19 @@ class YUP_API Color
constexpr Color& operator= (const Color& other) noexcept = default;
constexpr Color& operator= (Color&& other) noexcept = default;
+ //==============================================================================
+ /** Equality operator. */
+ constexpr bool operator== (const Color& other) const noexcept
+ {
+ return data == other.data;
+ }
+
+ /** Spaceship operator. */
+ constexpr auto operator<=> (const Color& other) const noexcept
+ {
+ return data <=> other.data;
+ }
+
//==============================================================================
/** Returns the color as a 32-bit integer in ARGB format.
@@ -101,13 +123,13 @@ class YUP_API Color
return data;
}
- /** Implicit conversion to a 32-bit integer.
+ /** Explicit conversion to a 32-bit integer.
Allows the color to be used wherever a 32-bit integer color is expected.
@return The color as a 32-bit integer.
*/
- constexpr operator uint32() const noexcept
+ constexpr explicit operator uint32() const noexcept
{
return data;
}
@@ -187,24 +209,91 @@ class YUP_API Color
return { alpha, r, g, b };
}
- // TODO - doxygen
+ /** Returns a new color with the specified alpha value.
+
+ This method creates a new color with the same red, green, and blue values but a different alpha.
+
+ @param alpha The new alpha value, normalized to the range [0, 1].
+
+ @return A new color with the specified alpha value.
+ */
constexpr Color withAlpha (float alpha) const noexcept
{
return { normalizedToComponent (alpha), r, g, b };
}
- // TODO - doxygen
+ /** Returns a new color with the alpha value multiplied by the specified amount.
+
+ This method creates a new color with the same red, green, and blue values but with the alpha value multiplied by the given amount.
+
+ @param alpha The amount to multiply the alpha value by, as an 8-bit integer.
+
+ @return A new color with the multiplied alpha value.
+ */
constexpr Color withMultipliedAlpha (uint8 alpha) const noexcept
{
return { normalizedToComponent (componentToNormalized (a) * componentToNormalized (alpha)), r, g, b };
}
- // TODO - doxygen
+ /** Returns a new color with the alpha value multiplied by the specified amount.
+
+ This method creates a new color with the same red, green, and blue values but with the alpha value multiplied by the given amount.
+
+ @param alpha The amount to multiply the alpha value by, as a floating point value.
+
+ @return A new color with the multiplied alpha value.
+ */
constexpr Color withMultipliedAlpha (float alpha) const noexcept
{
return { normalizedToComponent (componentToNormalized (a) * alpha), r, g, b };
}
+ //==============================================================================
+ /** Premultiply alpha in this color. */
+ constexpr Color& premultiply() noexcept
+ {
+ const float alpha = getAlphaFloat();
+ r = normalizedToComponent (getRedFloat() * alpha);
+ g = normalizedToComponent (getGreenFloat() * alpha);
+ b = normalizedToComponent (getBlueFloat() * alpha);
+ return *this;
+ }
+
+ /** Returns a premultiplied alpha version of this color. */
+ constexpr Color premultiplied() const noexcept
+ {
+ Color result (*this);
+ result.premultiply();
+ return result;
+ }
+
+ /** Unpremultiply alpha in this color. */
+ constexpr Color& unpremultiply() noexcept
+ {
+ const float alpha = getAlphaFloat();
+ if (alpha <= 0.0f)
+ {
+ a = 0;
+ r = 0;
+ g = 0;
+ b = 0;
+ return *this;
+ }
+
+ r = normalizedToComponent (getRedFloat() / alpha);
+ g = normalizedToComponent (getGreenFloat() / alpha);
+ b = normalizedToComponent (getBlueFloat() / alpha);
+ return *this;
+ }
+
+ /** Returns an unpremultiplied alpha version of this color. */
+ constexpr Color unpremultiplied() const noexcept
+ {
+ Color result (*this);
+ result.unpremultiply();
+ return result;
+ }
+
//==============================================================================
/** Returns the red component of the color.
@@ -261,7 +350,14 @@ class YUP_API Color
return { a, red, g, b };
}
- // TODO - doxygen
+ /** Returns a new color with the specified red value.
+
+ This method creates a new color with the same green, blue, and alpha values but a different red.
+
+ @param red The new red value, normalized to the range [0, 1].
+
+ @return A new color with the specified red value.
+ */
constexpr Color withRed (float red) const noexcept
{
return { a, normalizedToComponent (red), g, b };
@@ -323,7 +419,14 @@ class YUP_API Color
return { a, r, green, b };
}
- // TODO - doxygen
+ /** Returns a new color with the specified green value.
+
+ This method creates a new color with the same red, blue, and alpha values but a different green.
+
+ @param green The new green value, normalized to the range [0, 1].
+
+ @return A new color with the specified green value.
+ */
constexpr Color withGreen (float green) const noexcept
{
return { a, r, normalizedToComponent (green), b };
@@ -385,7 +488,14 @@ class YUP_API Color
return { a, r, g, blue };
}
- // TODO - doxygen
+ /** Returns a new color with the specified blue value.
+
+ This method creates a new color with the same red, green, and alpha values but a different blue.
+
+ @param blue The new blue value, normalized to the range [0, 1].
+
+ @return A new color with the specified blue value.
+ */
constexpr Color withBlue (float blue) const noexcept
{
return { a, r, g, normalizedToComponent (blue) };
@@ -469,6 +579,172 @@ class YUP_API Color
return (max + min) / 2.0f;
}
+ //==============================================================================
+ /** Returns a contrasting color.
+
+ This method calculates a color that contrasts with the current color based on its luminance.
+ It is particularly useful for ensuring text or UI elements are readable when placed on backgrounds of varying colors.
+
+ @return A new Color object that contrasts with the current color.
+ */
+ constexpr Color contrasting() const noexcept
+ {
+ return contrasting (0.5f);
+ }
+
+ /** Returns a contrasting color adjusted by a specified amount.
+
+ This method provides finer control over the contrast calculation by allowing adjustment of the hue shift used in
+ determining the contrasting color. The luminance and saturation of the original color are maintained.
+
+ @param amount The amount to adjust the hue by, normalized to the range [0, 1].
+
+ @return A new Color object that contrasts with the current color.
+ */
+ constexpr Color contrasting (float amount) const noexcept
+ {
+ const auto [h, s, l] = inverted().toHSL();
+
+ return fromHSL (modulo (h + jlimit (0.0f, 1.0f, amount), 1.0f), s, l).withAlpha (a);
+ }
+
+ //==============================================================================
+ /** Makes the color brighter by a specified amount.
+
+ This method increases the RGB components of the color by the given amount, capped at 1.0 to maintain valid color values.
+ It is useful for creating lighter variations of the color without altering the hue and saturation significantly.
+
+ @param amount The amount by which to increase the RGB components, normalized to the range [0, 1].
+
+ @return A new Color object that is brighter than the original.
+ */
+ constexpr Color brighter (float amount) const noexcept
+ {
+ const float finalAmount = jlimit (-1.0f, 1.0f, amount);
+
+ return {
+ a,
+ normalizedToComponent (getRedFloat() + finalAmount),
+ normalizedToComponent (getGreenFloat() + finalAmount),
+ normalizedToComponent (getBlueFloat() + finalAmount)
+ };
+ }
+
+ /** Makes the color darker by a specified amount.
+
+ This method decreases the RGB components of the color by the given amount, capped at 0 to maintain valid color values.
+ It is useful for creating darker variations of the color without altering the hue and saturation significantly.
+
+ @param amount The amount by which to decrease the RGB components, normalized to the range [0, 1].
+
+ @return A new Color object that is darker than the original.
+ */
+ constexpr Color darker (float amount) const noexcept
+ {
+ return brighter (-amount);
+ }
+
+ //==============================================================================
+ /** Inverts the color components (RGB) of the current color.
+
+ This method changes each RGB component to its complementary value, which is useful for creating negative effects or for visual highlights.
+
+ @return A reference to this Color object, now with inverted RGB values.
+ */
+ constexpr Color& invert() noexcept
+ {
+ r = 255 - r;
+ g = 255 - g;
+ b = 255 - b;
+ return *this;
+ }
+
+ /** Returns a new color that is the inverse of the current color.
+
+ This method creates a new Color object with each RGB component set to its complementary value, effectively providing the negative of the color.
+
+ @return A new Color object with inverted RGB values.
+ */
+ constexpr Color inverted() const noexcept
+ {
+ Color result (*this);
+ result.invert();
+ return result;
+ }
+
+ //==============================================================================
+ /** Inverts the alpha component of the current color.
+
+ This method changes the alpha component to its complementary value, which is useful for reversing transparency effects.
+
+ @return A reference to this Color object, now with an inverted alpha value.
+ */
+ constexpr Color& invertAlpha() noexcept
+ {
+ a = 255 - a;
+ return *this;
+ }
+
+ /** Returns a new color that is the inverse of the current color in terms of alpha transparency.
+
+ This method creates a new Color object with the alpha component set to its complementary value, effectively reversing the transparency of the color.
+
+ @return A new Color object with an inverted alpha value.
+ */
+ constexpr Color invertedAlpha() const noexcept
+ {
+ Color result (*this);
+ result.invertAlpha();
+ return result;
+ }
+
+ //==============================================================================
+ /** Mixes this color with another using a selectable color space.
+
+ This method can perform spectral upsampling of the two colors, mix their reflectances using a
+ Kubelka-Munk model, and convert the result back to sRGB. The result usually produces more
+ natural, pigment-like blends than a linear RGB interpolation. Alpha is interpolated linearly.
+ RGB uses alpha compositing, SRGB uses a direct sRGB interpolation, and Spectral uses the
+ reflectance model.
+
+ @param other The color to mix with this color.
+ @param amount The mix factor in the range [0, 1], where 0 returns this color and 1 returns the other.
+ @param space The color space used for mixing.
+
+ @return A new Color object representing the mixed result.
+ */
+ Color mixedWith (Color other, float amount, ColorSpace space = ColorSpace::Spectral) const noexcept;
+
+ /** Mixes this color with another, updating the current object.
+
+ @param other The color to mix with this color.
+ @param amount The mix factor in the range [0, 1], where 0 returns this color and 1 returns the other.
+ @param space The color space used for mixing.
+
+ @return A reference to this color object.
+ */
+ Color& mixWith (Color other, float amount, ColorSpace space = ColorSpace::Spectral) noexcept;
+
+ /** Blends this color with another using a blend mode.
+
+ @param src The source color to composite over this color.
+ @param mode The blend mode to use.
+ @param opacity The opacity applied to the source color.
+
+ @return A reference to this color object.
+ */
+ Color& blendWith (Color src, BlendMode mode = BlendMode::SrcOver, float opacity = 1.0f) noexcept;
+
+ /** Blends this color with another using a blend mode.
+
+ @param src The source color to composite over this color.
+ @param mode The blend mode to use.
+ @param opacity The opacity applied to the source color.
+
+ @return A new Color object containing the blended result.
+ */
+ Color blendedWith (Color src, BlendMode mode = BlendMode::SrcOver, float opacity = 1.0f) const noexcept;
+
//==============================================================================
/** Converts the color to its HSL (Hue, Saturation, Luminance) components.
@@ -557,6 +833,32 @@ class YUP_API Color
};
}
+ //==============================================================================
+ /** Converts the color to its HSLuv (Hue, Saturation, Luminance) components.
+
+ HSLuv is a perceptually uniform HSL space based on CIELUV, intended to provide more consistent
+ perceived saturation across hues. The returned tuple contains the hue, saturation, and luminance
+ components normalized to the range [0, 1].
+
+ @return A tuple consisting of hue, saturation, and luminance in HSLuv space.
+ */
+ std::tuple toHSLuv() const noexcept;
+
+ /** Constructs a color from HSLuv values.
+
+ This static method allows for the creation of a color from its HSLuv representation.
+ Hue, saturation, and luminance are normalized to [0, 1], with hue mapped to a 0-360 degree range
+ and saturation/luminance mapped to 0-100 internally.
+
+ @param h The hue component, normalized to [0, 1].
+ @param s The saturation component, normalized to [0, 1].
+ @param l The luminance component, normalized to [0, 1].
+ @param a The alpha component, normalized to [0, 1].
+
+ @return A Color object corresponding to the given HSLuv values.
+ */
+ static Color fromHSLuv (float h, float s, float l, float a = 1.0f) noexcept;
+
//==============================================================================
/** Converts the color to its HSV (Hue, Saturation, Value) components.
@@ -661,143 +963,78 @@ class YUP_API Color
}
//==============================================================================
- /** Makes the color brighter by a specified amount.
+ /** Creates a Color object from RGB components.
- This method increases the RGB components of the color by the given amount, capped at 1.0 to maintain valid color values.
- It is useful for creating lighter variations of the color without altering the hue and saturation significantly.
+ This static method constructs a Color object using the specified red, green, and blue components.
+ The alpha component is set to fully opaque (255).
- @param amount The amount by which to increase the RGB components, normalized to the range [0, 1].
+ @param r The red component, from 0 to 255.
+ @param g The green component, from 0 to 255.
+ @param b The blue component, from 0 to 255.
- @return A new Color object that is brighter than the original.
+ @return A Color object with the specified RGB values and full opacity.
*/
- constexpr Color brighter (float amount) const noexcept
+ static Color fromRGB (uint8 r, uint8 g, uint8 b) noexcept
{
- return {
- a,
- normalizedToComponent (getRedFloat() + amount),
- normalizedToComponent (getGreenFloat() + amount),
- normalizedToComponent (getBlueFloat() + amount)
- };
+ return { 255, r, g, b };
}
- /** Makes the color darker by a specified amount.
+ /** Creates a Color object from RGBA components.
- This method decreases the RGB components of the color by the given amount, capped at 0 to maintain valid color values.
- It is useful for creating darker variations of the color without altering the hue and saturation significantly.
-
- @param amount The amount by which to decrease the RGB components, normalized to the range [0, 1].
-
- @return A new Color object that is darker than the original.
- */
- constexpr Color darker (float amount) const noexcept
- {
- return brighter (-amount);
- }
+ This static method constructs a Color object using the specified red, green, blue, and alpha components.
- //==============================================================================
- /** Returns a contrasting color.
-
- This method calculates a color that contrasts with the current color based on its luminance.
- It is particularly useful for ensuring text or UI elements are readable when placed on backgrounds of varying colors.
+ @param r The red component, from 0 to 255.
+ @param g The green component, from 0 to 255.
+ @param b The blue component, from 0 to 255.
+ @param a The alpha component, from 0 (transparent) to 255 (opaque).
- @return A new Color object that contrasts with the current color.
+ @return A Color object with the specified RGBA values.
*/
- constexpr Color contrasting() const noexcept
+ static Color fromRGBA (uint8 r, uint8 g, uint8 b, uint8 a) noexcept
{
- return contrasting (0.5f);
+ return { a, r, g, b };
}
- /** Returns a contrasting color adjusted by a specified amount.
+ /** Creates a Color object from ARGB components.
- This method provides finer control over the contrast calculation by allowing adjustment of the hue shift used in
- determining the contrasting color. The luminance and saturation of the original color are maintained.
+ This static method constructs a Color object using the specified alpha, red, green, and blue components.
- @param amount The amount to adjust the hue by, normalized to the range [0, 1].
+ @param a The alpha component, from 0 (transparent) to 255 (opaque).
+ @param r The red component, from 0 to 255.
+ @param g The green component, from 0 to 255.
+ @param b The blue component, from 0 to 255.
- @return A new Color object that contrasts with the current color.
+ @return A Color object with the specified ARGB values.
*/
- constexpr Color contrasting (float amount) const noexcept
+ static Color fromARGB (uint8 a, uint8 r, uint8 g, uint8 b) noexcept
{
- const auto [h, s, l] = inverted().toHSL();
-
- return fromHSL (modulo (h + jlimit (0.0f, 1.0f, amount), 1.0f), s, l).withAlpha (a);
+ return { a, r, g, b };
}
- //==============================================================================
- /** Inverts the color components (RGB) of the current color.
+ /** Creates a Color object from BGRA components.
- This method changes each RGB component to its complementary value, which is useful for creating negative effects or for visual highlights.
+ This static method constructs a Color object using the specified blue, green, red, and alpha components.
- @return A reference to this Color object, now with inverted RGB values.
- */
- constexpr Color& invert() noexcept
- {
- r = 255 - r;
- g = 255 - g;
- b = 255 - b;
- return *this;
- }
-
- /** Returns a new color that is the inverse of the current color.
-
- This method creates a new Color object with each RGB component set to its complementary value, effectively providing the negative of the color.
+ @param b The blue component, from 0 to 255.
+ @param g The green component, from 0 to 255.
+ @param r The red component, from 0 to 255.
+ @param a The alpha component, from 0 (transparent) to 255 (opaque).
- @return A new Color object with inverted RGB values.
+ @return A Color object with the specified BGRA values.
*/
- constexpr Color inverted() const noexcept
+ static Color fromBGRA (uint8 b, uint8 g, uint8 r, uint8 a) noexcept
{
- Color result (*this);
- result.invert();
- return result;
+ return { a, r, g, b };
}
//==============================================================================
- /** Inverts the alpha component of the current color.
+ /** Generates a random opaque color.
- This method changes the alpha component to its complementary value, which is useful for reversing transparency effects.
+ This static method creates a color with random red, green, and blue components,
+ while the alpha component is set to fully opaque (255).
- @return A reference to this Color object, now with an inverted alpha value.
+ @return A Color object with random RGB values and full opacity.
*/
- constexpr Color& invertAlpha() noexcept
- {
- a = 255 - a;
- return *this;
- }
-
- /** Returns a new color that is the inverse of the current color in terms of alpha transparency.
-
- This method creates a new Color object with the alpha component set to its complementary value, effectively reversing the transparency of the color.
-
- @return A new Color object with an inverted alpha value.
- */
- constexpr Color invertedAlpha() const noexcept
- {
- Color result (*this);
- result.invertAlpha();
- return result;
- }
-
- //==============================================================================
- constexpr Color overlaidWith (Color src) const noexcept
- {
- auto destAlpha = getAlpha();
- if (destAlpha <= 0)
- return src;
-
- auto invA = 0xff - static_cast (src.getAlpha());
- auto resA = 0xff - (((0xff - destAlpha) * invA) >> 8);
- if (resA <= 0)
- return *this;
-
- auto da = (invA * destAlpha) / resA;
- return Color ((uint8) resA,
- (uint8) (src.getRed() + ((((int) getRed() - src.getRed()) * da) >> 8)),
- (uint8) (src.getGreen() + ((((int) getGreen() - src.getGreen()) * da) >> 8)),
- (uint8) (src.getBlue() + ((((int) getBlue() - src.getBlue()) * da) >> 8)));
- }
-
- //==============================================================================
- // TODO - doxygen
static Color opaqueRandom() noexcept
{
auto random = Random();
@@ -812,35 +1049,36 @@ class YUP_API Color
}
//==============================================================================
+ /** Converts the color to a string representation.
- static Color fromRGB (uint8 r, uint8 g, uint8 b) noexcept
- {
- return { 255, r, g, b };
- }
+ This method generates a string that represents the color in a human-readable format.
+ The exact format of the string is implementation-defined but typically includes the
+ RGBA components.
- static Color fromRGBA (uint8 r, uint8 g, uint8 b, uint8 a) noexcept
- {
- return { a, r, g, b };
- }
+ @return A string representation of the color.
+ */
+ String toString() const;
- static Color fromARGB (uint8 a, uint8 r, uint8 g, uint8 b) noexcept
- {
- return { a, r, g, b };
- }
+ /** Converts the color to a string representation in RGB format.
- static Color fromBGRA (uint8 b, uint8 g, uint8 r, uint8 a) noexcept
- {
- return { a, r, g, b };
- }
+ This method generates a string that represents the color in RGB format.
+ If `withAlpha` is true, the alpha component is included in the string representation.
- //==============================================================================
- // TODO - doxygen
- String toString() const;
+ @param withAlpha If true, includes the alpha component in the string.
- // TODO - doxygen
+ @return A string representation of the color in RGB format.
+ */
String toStringRGB (bool withAlpha) const;
- // TODO - doxygen
+ /** Creates a Color object from a string representation.
+
+ This static method parses a string to create a Color object.
+ The exact format of the string is implementation-defined.
+
+ @param colourString The string representation of the color.
+
+ @return A Color object parsed from the string.
+ */
static Color fromString (const String& colourString);
private:
diff --git a/modules/yup_graphics/graphics/yup_ColorGradient.h b/modules/yup_graphics/graphics/yup_ColorGradient.h
index af29c6727..c1a4aa23c 100644
--- a/modules/yup_graphics/graphics/yup_ColorGradient.h
+++ b/modules/yup_graphics/graphics/yup_ColorGradient.h
@@ -103,6 +103,14 @@ class YUP_API ColorGradient
radius = std::sqrt (square (x2 - x1) + square (y2 - y1));
}
+ /** Constructs a gradient with specified attributes.
+
+ @param color1 The starting color of the gradient.
+ @param p1 The pointof the starting color.
+ @param color2 The ending color of the gradient.
+ @param p2 The point of the ending color.
+ @param type The type of gradient (Linear or Radial).
+ */
ColorGradient (Color color1, const Point& p1, Color color2, const Point& p2, Type type = Type::Linear) noexcept
: ColorGradient (color1, p1.getX(), p1.getY(), color2, p2.getX(), p2.getY(), type)
{
@@ -113,9 +121,26 @@ class YUP_API ColorGradient
@param type The type of gradient (Linear or Radial).
@param colorStops Vector of ColorStop objects defining the gradient.
*/
- ColorGradient (Type type, const std::vector& colorStops) noexcept
+ ColorGradient (Type type, std::vector colorStops) noexcept
: type (type)
- , stops (colorStops)
+ , stops (std::move (colorStops))
+ {
+ if (type == Radial && stops.size() >= 2)
+ {
+ const auto& first = stops.front();
+ const auto& last = stops.back();
+ radius = std::sqrt (square (last.x - first.x) + square (last.y - first.y));
+ }
+ }
+
+ /** Constructs a gradient with multiple color stops.
+
+ @param type The type of gradient (Linear or Radial).
+ @param colorStops Initializer list of ColorStop objects defining the gradient.
+ */
+ ColorGradient (Type type, std::initializer_list colorStops) noexcept
+ : type (type)
+ , stops (std::move (colorStops))
{
if (type == Radial && stops.size() >= 2)
{
@@ -246,6 +271,77 @@ class YUP_API ColorGradient
return stops;
}
+ /** Returns the interpolated color at the given gradient position (0.0-1.0). */
+ Color getColorAt (float t) const noexcept
+ {
+ if (stops.empty())
+ return {};
+
+ if (stops.size() == 1)
+ return stops.front().color;
+
+ if (t <= stops.front().delta)
+ return stops.front().color;
+
+ if (t >= stops.back().delta)
+ return stops.back().color;
+
+ for (size_t i = 1; i < stops.size(); ++i)
+ {
+ if (t <= stops[i].delta)
+ {
+ const auto& a = stops[i - 1];
+ const auto& b = stops[i];
+ const float denom = b.delta - a.delta;
+ if (denom <= 0.0f)
+ return b.color;
+
+ const float localT = (t - a.delta) / denom;
+ return a.color.mixedWith (b.color, localT, ColorSpace::SRGB);
+ }
+ }
+
+ return stops.back().color;
+ }
+
+ /** Returns the interpolated color at a given point in gradient space. */
+ Color getColorAt (float x, float y) const noexcept
+ {
+ if (stops.empty())
+ return {};
+
+ const auto start = Point (stops.front().x, stops.front().y);
+ const auto end = Point (stops.back().x, stops.back().y);
+
+ if (type == Type::Radial)
+ {
+ float radiusValue = radius;
+ if (radiusValue <= 0.0f)
+ radiusValue = start.distanceTo (end);
+
+ if (radiusValue <= 0.0f)
+ return stops.front().color;
+
+ const float t = start.distanceTo ({ x, y }) / radiusValue;
+ return getColorAt (jlimit (0.0f, 1.0f, t));
+ }
+
+ const float dx = end.getX() - start.getX();
+ const float dy = end.getY() - start.getY();
+ const float lenSquared = dx * dx + dy * dy;
+ if (lenSquared <= 0.0f)
+ return stops.front().color;
+
+ const float t = ((x - start.getX()) * dx + (y - start.getY()) * dy) / lenSquared;
+ return getColorAt (jlimit (0.0f, 1.0f, t));
+ }
+
+ /** Returns the interpolated color at a given point in gradient space. */
+ Color getColorAt (const Point& p) const noexcept
+ {
+ return getColorAt (p.getX(), p.getY());
+ }
+
/** Adds a color stop to the gradient.
@param color The color of the new stop.
@@ -255,18 +351,30 @@ class YUP_API ColorGradient
*/
void addColorStop (Color color, float x, float y, float delta)
{
- stops.emplace_back (color, x, y, delta);
+ stops.emplace_back (color, x, y, jlimit (0.0f, 1.0f, delta));
+
std::sort (stops.begin(), stops.end(), [] (const ColorStop& a, const ColorStop& b)
{
return a.delta < b.delta;
});
}
+ /** Adds a color stop to the gradient.
+
+ @param color The color of the new stop.
+ @param p The point of the stop.
+ @param delta The relative position of the stop (0.0-1.0).
+ */
void addColorStop (Color color, const Point& p, float delta)
{
addColorStop (color, p.getX(), p.getY(), delta);
}
+ /** Adds a color stop to the gradient.
+
+ @param color The color of the new stop.
+ @param delta The relative position of the stop (0.0-1.0).
+ */
void addColorStop (Color color, float delta)
{
if (stops.size() <= 1)
@@ -374,6 +482,88 @@ class YUP_API ColorGradient
return result;
}
+ //==============================================================================
+ /** Constructs a gradient with evenly spaced color stops generated from two colors.
+
+ This helper creates a gradient containing a specified number of stops in linear position space.
+ Colors are generated using Color::mixedWith for sRGB and spectral spaces, while RGB produces only
+ the start/end stops. The stops are placed along the line between the start and end positions.
+
+ @param color1 The starting color of the gradient.
+ @param x1 The x-coordinate of the starting color.
+ @param y1 The y-coordinate of the starting color.
+ @param color2 The ending color of the gradient.
+ @param x2 The x-coordinate of the ending color.
+ @param y2 The y-coordinate of the ending color.
+ @param numColors The number of color stops to generate (including start and end).
+ @param type The type of gradient (Linear or Radial).
+ @param colorSpace The color space used for mixing.
+
+ @return A ColorGradient with evenly spaced stops between the given colors.
+ */
+ static ColorGradient fromLinearColors (Color color1,
+ float x1,
+ float y1,
+ Color color2,
+ float x2,
+ float y2,
+ size_t numColors,
+ Type type = Type::Linear,
+ ColorSpace colorSpace = ColorSpace::Spectral) noexcept
+ {
+ if (numColors == 0)
+ return ColorGradient (type, {});
+
+ if (numColors == 1)
+ return ColorGradient (type, { ColorStop (color1, x1, y1, 0.0f) });
+
+ if (colorSpace == ColorSpace::RGB)
+ {
+ return ColorGradient (type, { ColorStop (color1, x1, y1, 0.0f), ColorStop (color2, x2, y2, 1.0f) });
+ }
+
+ std::vector colorStops;
+ colorStops.reserve (numColors);
+
+ const Line line (x1, y1, x2, y2);
+ const float step = 1.0f / static_cast (numColors - 1);
+
+ for (size_t i = 0; i < numColors; ++i)
+ {
+ const float t = static_cast (i) * step;
+ colorStops.emplace_back (color1.mixedWith (color2, t, colorSpace), line.pointAlong (t), t);
+ }
+
+ return ColorGradient (type, std::move (colorStops));
+ }
+
+ /** Constructs a gradient with evenly spaced color stops generated from two colors.
+
+ This helper creates a gradient containing a specified number of stops in linear position space.
+ Colors are generated using Color::mixedWith for sRGB and spectral spaces, while RGB produces only
+ the start/end stops. The stops are placed along the line between the start and end positions.
+
+ @param color1 The starting color of the gradient.
+ @param p1 The point of the starting color.
+ @param color2 The ending color of the gradient.
+ @param p2 The point of the ending color.
+ @param numColors The number of color stops to generate (including start and end).
+ @param type The type of gradient (Linear or Radial).
+ @param colorSpace The color space used for mixing.
+
+ @return A ColorGradient with evenly spaced stops between the given colors.
+ */
+ static ColorGradient fromLinearColors (Color color1,
+ const Point& p1,
+ Color color2,
+ const Point& p2,
+ size_t numColors,
+ Type type = Type::Linear,
+ ColorSpace colorSpace = ColorSpace::Spectral) noexcept
+ {
+ return fromLinearColors (color1, p1.getX(), p1.getY(), color2, p2.getX(), p2.getY(), numColors, type, colorSpace);
+ }
+
private:
Type type = Type::Linear;
std::vector stops;
diff --git a/modules/yup_graphics/graphics/yup_Graphics.cpp b/modules/yup_graphics/graphics/yup_Graphics.cpp
index bd062551a..5ca297936 100644
--- a/modules/yup_graphics/graphics/yup_Graphics.cpp
+++ b/modules/yup_graphics/graphics/yup_Graphics.cpp
@@ -130,13 +130,13 @@ rive::rcp toColorGradient (rive::Factory& factory, const Col
// Handle single color stop as solid color
if (colorStops.size() == 1)
{
- uint32 color = colorStops[0].color;
float stops[] = { 0.0f };
+ auto color = (rive::ColorInt) colorStops[0].color;
return factory.makeLinearGradient (0.0f, 0.0f, 1.0f, 0.0f, &color, stops, 1);
}
// Create dynamic arrays for colors and stops
- std::vector colors;
+ std::vector colors;
std::vector stops;
colors.reserve (colorStops.size());
@@ -144,7 +144,7 @@ rive::rcp toColorGradient (rive::Factory& factory, const Col
for (const auto& stop : colorStops)
{
- colors.push_back (stop.color);
+ colors.push_back ((rive::ColorInt) stop.color);
stops.push_back (stop.delta);
}
@@ -644,7 +644,7 @@ void Graphics::renderStrokePath (const Path& path, const RenderOptions& options,
paint.cap (toStrokeCap (options.cap));
if (options.isStrokeColor())
- paint.color (options.getStrokeColor());
+ paint.color ((rive::ColorInt) options.getStrokeColor());
else
paint.shader (toColorGradient (factory, options.getStrokeColorGradient(), transform));
@@ -662,7 +662,7 @@ void Graphics::renderFillPath (const Path& path, const RenderOptions& options, c
paint.feather (options.feather);
if (options.isFillColor())
- paint.color (options.getFillColor());
+ paint.color ((rive::ColorInt) options.getFillColor());
else
paint.shader (toColorGradient (factory, options.getFillColorGradient(), transform));
@@ -719,7 +719,7 @@ void Graphics::fillFittedText (const StyledText& text, const Rectangle& r
paint.feather (options.feather);
if (options.isFillColor())
- paint.color (options.getFillColor());
+ paint.color ((rive::ColorInt) options.getFillColor());
else
paint.shader (toColorGradient (factory, options.getFillColorGradient(), options.getTransform()));
@@ -756,7 +756,7 @@ void Graphics::strokeFittedText (const StyledText& text, const Rectangle&
paint.cap (toStrokeCap (options.cap));
if (options.isStrokeColor())
- paint.color (options.getStrokeColor());
+ paint.color ((rive::ColorInt) options.getStrokeColor());
else
paint.shader (toColorGradient (factory, options.getStrokeColorGradient(), options.getTransform()));
diff --git a/modules/yup_graphics/yup_graphics.h b/modules/yup_graphics/yup_graphics.h
index d7f30e997..c25cbcd89 100644
--- a/modules/yup_graphics/yup_graphics.h
+++ b/modules/yup_graphics/yup_graphics.h
@@ -61,6 +61,7 @@ YUP_END_IGNORE_WARNINGS_GCC_LIKE
//==============================================================================
+#include
#include
//==============================================================================
@@ -77,10 +78,10 @@ YUP_END_IGNORE_WARNINGS_GCC_LIKE
#include "fonts/yup_Font.h"
#include "fonts/yup_StyledText.h"
#include "imaging/yup_Image.h"
+#include "graphics/yup_BlendMode.h"
#include "graphics/yup_Color.h"
#include "graphics/yup_ColorGradient.h"
#include "graphics/yup_Colors.h"
-#include "graphics/yup_BlendMode.h"
#include "graphics/yup_StrokeJoin.h"
#include "graphics/yup_StrokeCap.h"
#include "graphics/yup_StrokeType.h"
diff --git a/modules/yup_gui/artboard/yup_Artboard.cpp b/modules/yup_gui/artboard/yup_Artboard.cpp
index cc6c395d6..baaccd0b6 100644
--- a/modules/yup_gui/artboard/yup_Artboard.cpp
+++ b/modules/yup_gui/artboard/yup_Artboard.cpp
@@ -22,6 +22,62 @@
namespace yup
{
+//==============================================================================
+namespace
+{
+rive::Fit toRiveFit (Artboard::Layout layout)
+{
+ switch (layout)
+ {
+ case Artboard::Layout::fill:
+ return rive::Fit::fill;
+ case Artboard::Layout::contain:
+ return rive::Fit::contain;
+ case Artboard::Layout::cover:
+ return rive::Fit::cover;
+ case Artboard::Layout::fitWidth:
+ return rive::Fit::fitWidth;
+ case Artboard::Layout::fitHeight:
+ return rive::Fit::fitHeight;
+ case Artboard::Layout::none:
+ return rive::Fit::none;
+ case Artboard::Layout::scaleDown:
+ return rive::Fit::scaleDown;
+ case Artboard::Layout::layout:
+ return rive::Fit::layout;
+ }
+
+ return rive::Fit::contain;
+}
+
+rive::Alignment toRiveAlignment (Artboard::Alignment alignment)
+{
+ switch (alignment)
+ {
+ case Artboard::Alignment::topLeft:
+ return rive::Alignment::topLeft;
+ case Artboard::Alignment::topCenter:
+ return rive::Alignment::topCenter;
+ case Artboard::Alignment::topRight:
+ return rive::Alignment::topRight;
+ case Artboard::Alignment::centerLeft:
+ return rive::Alignment::centerLeft;
+ case Artboard::Alignment::center:
+ return rive::Alignment::center;
+ case Artboard::Alignment::centerRight:
+ return rive::Alignment::centerRight;
+ case Artboard::Alignment::bottomLeft:
+ return rive::Alignment::bottomLeft;
+ case Artboard::Alignment::bottomCenter:
+ return rive::Alignment::bottomCenter;
+ case Artboard::Alignment::bottomRight:
+ return rive::Alignment::bottomRight;
+ }
+
+ return rive::Alignment::center;
+}
+} // namespace
+
//==============================================================================
Artboard::Artboard (StringRef componentID)
@@ -59,6 +115,39 @@ void Artboard::clear()
stateMachine = nullptr;
eventProperties.clear();
+ viewTransform = rive::Mat2D();
+}
+
+//==============================================================================
+
+void Artboard::setLayout (Layout newLayout)
+{
+ if (layout == newLayout)
+ return;
+
+ layout = newLayout;
+ updateViewTransform();
+ repaint();
+}
+
+Artboard::Layout Artboard::getLayout() const
+{
+ return layout;
+}
+
+void Artboard::setAlignment (Alignment newAlignment)
+{
+ if (alignment == newAlignment)
+ return;
+
+ alignment = newAlignment;
+ updateViewTransform();
+ repaint();
+}
+
+Artboard::Alignment Artboard::getAlignment() const
+{
+ return alignment;
}
//==============================================================================
@@ -265,12 +354,15 @@ void Artboard::paint (Graphics& g)
auto* renderer = g.getRenderer();
- renderer->save();
+ auto transform = g.getTransform()
+ .translated (g.getDrawingArea().getX(), g.getDrawingArea().getY())
+ .scaled (g.getContextScale());
+ renderer->save();
+ renderer->transform (transform.toMat2D());
renderer->transform (viewTransform);
scene->draw (renderer);
-
renderer->restore();
}
@@ -278,19 +370,7 @@ void Artboard::paint (Graphics& g)
void Artboard::resized()
{
- auto scaleDpi = getScaleDpi();
- auto scaledBounds = getBounds() * scaleDpi;
- auto frameBounds = scaledBounds.toAABB();
-
- rive::AABB artboardBounds;
- if (artboard != nullptr)
- artboardBounds = artboard->bounds();
-
- viewTransform = rive::computeAlignment (
- rive::Fit::contain,
- rive::Alignment::center,
- frameBounds,
- artboardBounds);
+ updateViewTransform();
}
//==============================================================================
@@ -416,6 +496,9 @@ void Artboard::updateSceneFromFile()
scene = std::move (currentScene);
stateMachine = currentStateMachine;
+
+ updateViewTransform();
+ repaint();
}
//==============================================================================
@@ -466,10 +549,25 @@ void Artboard::pullEventsFromStateMachines()
Point Artboard::transformPoint (Point point) const
{
- point *= getScaleDpi();
-
const auto xy = viewTransform.invertOrIdentity() * rive::Vec2D (point.getX(), point.getY());
return { xy.x, xy.y };
}
+//==============================================================================
+
+void Artboard::updateViewTransform()
+{
+ if (artboard == nullptr)
+ {
+ viewTransform = rive::Mat2D();
+ return;
+ }
+
+ viewTransform = rive::computeAlignment (
+ toRiveFit (layout),
+ toRiveAlignment (alignment),
+ getLocalBounds().toAABB(),
+ artboard->bounds());
+}
+
} // namespace yup
diff --git a/modules/yup_gui/artboard/yup_Artboard.h b/modules/yup_gui/artboard/yup_Artboard.h
index b6e6dca94..e6ecca12c 100644
--- a/modules/yup_gui/artboard/yup_Artboard.h
+++ b/modules/yup_gui/artboard/yup_Artboard.h
@@ -30,6 +30,42 @@ namespace yup
class YUP_API Artboard : public Component
{
public:
+ //==============================================================================
+ /** Describes how the artboard is fitted inside the component bounds. */
+ enum class Layout
+ {
+ /** Scale independently in X and Y to fill the bounds. */
+ fill,
+ /** Uniform scale to fit inside bounds while preserving aspect ratio. */
+ contain,
+ /** Uniform scale to cover bounds while preserving aspect ratio. */
+ cover,
+ /** Uniform scale so the content width matches the bounds. */
+ fitWidth,
+ /** Uniform scale so the content height matches the bounds. */
+ fitHeight,
+ /** No scaling or alignment. */
+ none,
+ /** Like contain, but never scale above 1.0. */
+ scaleDown,
+ /** Use the artboard's own layout constraints. */
+ layout
+ };
+
+ /** Describes the alignment used to position the artboard inside the bounds. */
+ enum class Alignment
+ {
+ topLeft,
+ topCenter,
+ topRight,
+ centerLeft,
+ center,
+ centerRight,
+ bottomLeft,
+ bottomCenter,
+ bottomRight
+ };
+
//==============================================================================
/** Creates a new Rive artboard.
@@ -55,6 +91,27 @@ class YUP_API Artboard : public Component
/** Clears the Rive artboard. */
void clear();
+ //==============================================================================
+ /** Sets how the artboard is fitted into the component bounds.
+
+ This affects the view transform used for rendering and input handling.
+
+ @param newLayout The new layout mode.
+ */
+ void setLayout (Layout newLayout);
+
+ /** Returns the current layout mode. */
+ Layout getLayout() const;
+
+ /** Sets the alignment used when positioning the artboard in the bounds.
+
+ @param newAlignment The new alignment value.
+ */
+ void setAlignment (Alignment newAlignment);
+
+ /** Returns the current alignment. */
+ Alignment getAlignment() const;
+
//==============================================================================
/** Returns true if the Rive artboard is paused. */
bool isPaused() const;
@@ -172,6 +229,7 @@ class YUP_API Artboard : public Component
private:
void updateSceneFromFile();
void pullEventsFromStateMachines();
+ void updateViewTransform();
Point transformPoint (Point point) const;
std::shared_ptr artboardFile;
@@ -183,6 +241,8 @@ class YUP_API Artboard : public Component
HashMap 
+ 
+