in dev/ColorPicker/ColorSpectrum.cpp [1466:1679]
void ColorSpectrum::UpdateBitmapSources()
{
auto&& spectrumOverlayRectangle = m_spectrumOverlayRectangle.get();
auto&& spectrumOverlayEllipse = m_spectrumOverlayEllipse.get();
if (!spectrumOverlayRectangle ||
!spectrumOverlayEllipse)
{
return;
}
auto&& spectrumRectangle = m_spectrumRectangle.get();
auto&& spectrumEllipse = m_spectrumEllipse.get();
const winrt::float4 hsvColor = HsvColor();
const winrt::ColorSpectrumComponents components = Components();
// We'll set the base image and the overlay image based on which component is our third dimension.
// If it's saturation or luminosity, then the base image is that dimension at its minimum value,
// while the overlay image is that dimension at its maximum value.
// If it's hue, then we'll figure out where in the color wheel we are, and then use the two
// colors on either side of our position as our base image and overlay image.
// For example, if our hue is orange, then the base image would be red and the overlay image yellow.
switch (components)
{
case winrt::ColorSpectrumComponents::HueValue:
case winrt::ColorSpectrumComponents::ValueHue:
if (SharedHelpers::IsRS2OrHigher())
{
if (!m_saturationMinimumSurface ||
!m_saturationMaximumSurface)
{
return;
}
winrt::SpectrumBrush spectrumBrush{ winrt::make<SpectrumBrush>() };
spectrumBrush.MinSurface(m_saturationMinimumSurface);
spectrumBrush.MaxSurface(m_saturationMaximumSurface);
spectrumBrush.MaxSurfaceOpacity(hsv::GetSaturation(hsvColor));
spectrumRectangle.Fill(spectrumBrush);
spectrumEllipse.Fill(spectrumBrush);
}
else
{
if (!m_saturationMinimumBitmap ||
!m_saturationMaximumBitmap)
{
return;
}
winrt::ImageBrush spectrumBrush;
winrt::ImageBrush spectrumOverlayBrush;
spectrumBrush.ImageSource(m_saturationMinimumBitmap);
spectrumOverlayBrush.ImageSource(m_saturationMaximumBitmap);
spectrumOverlayRectangle.Opacity(hsv::GetSaturation(hsvColor));
spectrumOverlayEllipse.Opacity(hsv::GetSaturation(hsvColor));
spectrumRectangle.Fill(spectrumBrush);
spectrumEllipse.Fill(spectrumBrush);
spectrumOverlayRectangle.Fill(spectrumOverlayBrush);
spectrumOverlayRectangle.Fill(spectrumOverlayBrush);
}
break;
case winrt::ColorSpectrumComponents::HueSaturation:
case winrt::ColorSpectrumComponents::SaturationHue:
if (SharedHelpers::IsRS2OrHigher())
{
if (!m_valueSurface)
{
return;
}
winrt::SpectrumBrush spectrumBrush{ winrt::make<SpectrumBrush>() };
spectrumBrush.MinSurface(m_valueSurface);
spectrumBrush.MaxSurface(m_valueSurface);
spectrumBrush.MaxSurfaceOpacity(1);
spectrumRectangle.Fill(spectrumBrush);
spectrumEllipse.Fill(spectrumBrush);
}
else
{
if (!m_valueBitmap)
{
return;
}
winrt::ImageBrush spectrumBrush;
winrt::ImageBrush spectrumOverlayBrush;
spectrumBrush.ImageSource(m_valueBitmap);
spectrumOverlayBrush.ImageSource(m_valueBitmap);
spectrumOverlayRectangle.Opacity(1);
spectrumOverlayEllipse.Opacity(1);
spectrumRectangle.Fill(spectrumBrush);
spectrumEllipse.Fill(spectrumBrush);
spectrumOverlayRectangle.Fill(spectrumOverlayBrush);
spectrumOverlayRectangle.Fill(spectrumOverlayBrush);
}
break;
case winrt::ColorSpectrumComponents::ValueSaturation:
case winrt::ColorSpectrumComponents::SaturationValue:
if (SharedHelpers::IsRS2OrHigher())
{
if (!m_hueRedSurface ||
!m_hueYellowSurface ||
!m_hueGreenSurface ||
!m_hueCyanSurface ||
!m_hueBlueSurface ||
!m_huePurpleSurface)
{
return;
}
winrt::SpectrumBrush spectrumBrush{ winrt::make<SpectrumBrush>() };
const double sextant = hsv::GetHue(hsvColor) / 60.0;
if (sextant < 1)
{
spectrumBrush.MinSurface(m_hueRedSurface);
spectrumBrush.MaxSurface(m_hueYellowSurface);
}
else if (sextant >= 1 && sextant < 2)
{
spectrumBrush.MinSurface(m_hueYellowSurface);
spectrumBrush.MaxSurface(m_hueGreenSurface);
}
else if (sextant >= 2 && sextant < 3)
{
spectrumBrush.MinSurface(m_hueGreenSurface);
spectrumBrush.MaxSurface(m_hueCyanSurface);
}
else if (sextant >= 3 && sextant < 4)
{
spectrumBrush.MinSurface(m_hueCyanSurface);
spectrumBrush.MaxSurface(m_hueBlueSurface);
}
else if (sextant >= 4 && sextant < 5)
{
spectrumBrush.MinSurface(m_hueBlueSurface);
spectrumBrush.MaxSurface(m_huePurpleSurface);
}
else
{
spectrumBrush.MinSurface(m_huePurpleSurface);
spectrumBrush.MaxSurface(m_hueRedSurface);
}
spectrumBrush.MaxSurfaceOpacity(sextant - static_cast<int>(sextant));
spectrumRectangle.Fill(spectrumBrush);
spectrumEllipse.Fill(spectrumBrush);
}
else
{
if (!m_hueRedBitmap ||
!m_hueYellowBitmap ||
!m_hueGreenBitmap ||
!m_hueCyanBitmap ||
!m_hueBlueBitmap ||
!m_huePurpleBitmap)
{
return;
}
winrt::ImageBrush spectrumBrush;
winrt::ImageBrush spectrumOverlayBrush;
const double sextant = hsv::GetHue(hsvColor) / 60.0;
if (sextant < 1)
{
spectrumBrush.ImageSource(m_hueRedBitmap);
spectrumOverlayBrush.ImageSource(m_hueYellowBitmap);
}
else if (sextant >= 1 && sextant < 2)
{
spectrumBrush.ImageSource(m_hueYellowBitmap);
spectrumOverlayBrush.ImageSource(m_hueGreenBitmap);
}
else if (sextant >= 2 && sextant < 3)
{
spectrumBrush.ImageSource(m_hueGreenBitmap);
spectrumOverlayBrush.ImageSource(m_hueCyanBitmap);
}
else if (sextant >= 3 && sextant < 4)
{
spectrumBrush.ImageSource(m_hueCyanBitmap);
spectrumOverlayBrush.ImageSource(m_hueBlueBitmap);
}
else if (sextant >= 4 && sextant < 5)
{
spectrumBrush.ImageSource(m_hueBlueBitmap);
spectrumOverlayBrush.ImageSource(m_huePurpleBitmap);
}
else
{
spectrumBrush.ImageSource(m_huePurpleBitmap);
spectrumOverlayBrush.ImageSource(m_hueRedBitmap);
}
spectrumOverlayRectangle.Opacity(sextant - static_cast<int>(sextant));
spectrumOverlayEllipse.Opacity(sextant - static_cast<int>(sextant));
spectrumRectangle.Fill(spectrumBrush);
spectrumEllipse.Fill(spectrumBrush);
spectrumOverlayRectangle.Fill(spectrumOverlayBrush);
spectrumOverlayRectangle.Fill(spectrumOverlayBrush);
}
break;
}
}