mirror of
https://bitbucket.org/mfeemster/fractorium.git
synced 2025-01-21 05:00:06 -05:00
1dfbd4eff2
-Add new preset dimensions to the right click menu of the width and height fields in the editor. -Change QSS stylesheets to properly handle tabs. -Make tabs rectangular by default. For some reason, they had always been triangular. --Bug fixes -Incremental rendering times in the editor were wrong. --Code changes -Migrate to Qt6. There is probably more work to be done here. -Migrate to VS2022. -Migrate to Wix 4 installer. -Change installer to install to program files for all users. -Fix many VS2022 code analysis warnings. -No longer use byte typedef, because std::byte is now a type. Revert all back to unsigned char. -Upgrade OpenCL headers to version 3.0 and keep locally now rather than trying to look for system files. -No longer link to Nvidia or AMD specific OpenCL libraries. Use the generic installer located at OCL_ROOT too. -Add the ability to change OpenCL grid dimensions. This was attempted for investigating possible performance improvments, but made no difference. This has not been verified on Linux or Mac yet.
633 lines
24 KiB
C++
633 lines
24 KiB
C++
#pragma once
|
|
|
|
#include "Utils.h"
|
|
#include "Isaac.h"
|
|
|
|
/// <summary>
|
|
/// Palette class.
|
|
/// </summary>
|
|
|
|
namespace EmberNs
|
|
{
|
|
/// <summary>
|
|
/// The palette stores a set of 256 colors which are what get accumulated to the histogram
|
|
/// for each iteration. The colors come from either the main palette Xml file or directly
|
|
/// from the ember parameter file. Either way, they come in as 0-255 and get normalized to 0-1.
|
|
/// The palette may have also come from a palette editor where the user specifies key colors, then
|
|
/// those are interpolated to make a smooth palette. In that case, the m_SourceColors map will
|
|
/// be populated.
|
|
/// In the future, 2D palette support might be added in which case this class will have to be modified.
|
|
/// Template argument expected to be float or double.
|
|
/// </summary>
|
|
template <typename T>
|
|
class EMBER_API Palette
|
|
{
|
|
public:
|
|
/// <summary>
|
|
/// Constructor which sets the palette index to random and allocates space to hold the color entries.
|
|
/// </summary>
|
|
Palette()
|
|
{
|
|
m_Entries.resize(COLORMAP_LENGTH);
|
|
Clear();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructor that takes a name various parameters. If no color buffer is specified, a default is used.
|
|
/// This is a safety fallback, and it's highly recommended to always supply a buffer of color entries.
|
|
/// </summary>
|
|
/// <param name="name">The name of the palette</param>
|
|
/// <param name="index">The index in the palette file</param>
|
|
/// <param name="size">The size of the palette which should be 256</param>
|
|
/// <param name="xmlPaletteEntries">A pointer to 256 color entries</param>
|
|
Palette(const string& name, int index, size_t size, v4T* xmlPaletteEntries)
|
|
{
|
|
m_Name = name;
|
|
m_Index = index;
|
|
m_Entries.resize(size);
|
|
|
|
if (xmlPaletteEntries)
|
|
{
|
|
memcpy(m_Entries.data(), xmlPaletteEntries, SizeOf(m_Entries));
|
|
//memcpy(&m_Entries[0], xmlPaletteEntries, Size() * sizeof(m_Entries[0]));
|
|
}
|
|
else//They passed in null, so just fill with hard coded values so they at least have something.
|
|
{
|
|
//Palette 15 used in the test ember file.
|
|
unsigned char palette15[COLORMAP_LENGTH * 4] =
|
|
{
|
|
0x00, 0xda, 0xde, 0xbc, 0x00, 0xee, 0xe6, 0xc5, 0x00, 0xee, 0xf2, 0xce, 0x00, 0xee, 0xf2, 0xcf, 0x00, 0xe6, 0xee, 0xe1, 0x00, 0xea, 0xee, 0xd8, 0x00, 0xf2, 0xf1, 0xeb, 0x00, 0xf2, 0xf5, 0xd8,
|
|
0x00, 0xe6, 0xf2, 0xce, 0x00, 0xde, 0xea, 0xc5, 0x00, 0xd6, 0xda, 0xc6, 0x00, 0xce, 0xd2, 0xbc, 0x00, 0xc2, 0xca, 0xa9, 0x00, 0xbe, 0xca, 0xa0, 0x00, 0xce, 0xd6, 0xaa, 0x00, 0xde, 0xe2, 0xc5,
|
|
0x00, 0xea, 0xed, 0xce, 0x00, 0xea, 0xf2, 0xc5, 0x00, 0xde, 0xe2, 0xc5, 0x00, 0xc2, 0xca, 0xaa, 0x00, 0xae, 0xbe, 0xaa, 0x00, 0xa5, 0xb2, 0x96, 0x00, 0xa2, 0xa9, 0x8d, 0x00, 0x96, 0xa2, 0x84,
|
|
0x00, 0x8d, 0x8d, 0x7a, 0x00, 0x85, 0x89, 0x71, 0x00, 0x85, 0x8d, 0x71, 0x00, 0x85, 0x85, 0x67, 0x00, 0x79, 0x7d, 0x67, 0x00, 0x79, 0x7d, 0x67, 0x00, 0x71, 0x79, 0x5e, 0x00, 0x65, 0x6d, 0x55,
|
|
0x00, 0x4d, 0x5d, 0x42, 0x00, 0x34, 0x40, 0x25, 0x00, 0x30, 0x40, 0x25, 0x00, 0x30, 0x38, 0x1c, 0x00, 0x2c, 0x3c, 0x1c, 0x00, 0x2c, 0x34, 0x1c, 0x00, 0x24, 0x2c, 0x12, 0x00, 0x24, 0x24, 0x00,
|
|
0x00, 0x24, 0x2c, 0x09, 0x00, 0x28, 0x34, 0x09, 0x00, 0x38, 0x40, 0x12, 0x00, 0x30, 0x40, 0x1c, 0x00, 0x40, 0x50, 0x2f, 0x00, 0x55, 0x69, 0x42, 0x00, 0x65, 0x75, 0x55, 0x00, 0x6c, 0x7d, 0x5e,
|
|
0x00, 0x74, 0x8d, 0x71, 0x00, 0x74, 0x89, 0x84, 0x00, 0x74, 0x8d, 0x84, 0x00, 0x78, 0x8d, 0x84, 0x00, 0x79, 0x89, 0x7a, 0x00, 0x79, 0x85, 0x71, 0x00, 0x75, 0x7d, 0x67, 0x00, 0x71, 0x79, 0x5e,
|
|
0x00, 0x6c, 0x71, 0x5e, 0x00, 0x6d, 0x70, 0x5e, 0x00, 0x6c, 0x79, 0x5e, 0x00, 0x68, 0x75, 0x5e, 0x00, 0x69, 0x71, 0x55, 0x00, 0x6d, 0x75, 0x55, 0x00, 0x6d, 0x75, 0x55, 0x00, 0x69, 0x71, 0x55,
|
|
0x00, 0x65, 0x71, 0x55, 0x00, 0x69, 0x6d, 0x55, 0x00, 0x64, 0x71, 0x5e, 0x00, 0x68, 0x70, 0x67, 0x00, 0x68, 0x70, 0x67, 0x00, 0x68, 0x6c, 0x67, 0x00, 0x6c, 0x6c, 0x5e, 0x00, 0x71, 0x71, 0x5e,
|
|
0x00, 0x79, 0x79, 0x67, 0x00, 0x81, 0x85, 0x71, 0x00, 0x7d, 0x91, 0x71, 0x00, 0x85, 0x92, 0x7a, 0x00, 0x85, 0x92, 0x7a, 0x00, 0x7d, 0x92, 0x84, 0x00, 0x79, 0x92, 0x84, 0x00, 0x78, 0x92, 0x8d,
|
|
0x00, 0x78, 0x8d, 0x8d, 0x00, 0x74, 0x8d, 0x84, 0x00, 0x74, 0x92, 0x84, 0x00, 0x75, 0x92, 0x7a, 0x00, 0x6c, 0x85, 0x67, 0x00, 0x64, 0x79, 0x5e, 0x00, 0x59, 0x69, 0x4b, 0x00, 0xaa, 0x57, 0x00,
|
|
0x00, 0x38, 0x44, 0x1c, 0x00, 0x30, 0x3c, 0x1c, 0x00, 0x2c, 0x3c, 0x1c, 0x00, 0x34, 0x40, 0x25, 0x00, 0x50, 0x61, 0x4b, 0x00, 0x5d, 0x6d, 0x5e, 0x00, 0x64, 0x71, 0x5e, 0x00, 0x60, 0x71, 0x5e,
|
|
0x00, 0x60, 0x75, 0x5e, 0x00, 0x68, 0x75, 0x5e, 0x00, 0x6c, 0x79, 0x5e, 0x00, 0x6c, 0x79, 0x5e, 0x00, 0x71, 0x79, 0x67, 0x00, 0x70, 0x79, 0x67, 0x00, 0x6c, 0x7d, 0x67, 0x00, 0x68, 0x79, 0x67,
|
|
0x00, 0x6c, 0x79, 0x67, 0x00, 0x6c, 0x75, 0x67, 0x00, 0x71, 0x75, 0x5e, 0x00, 0x71, 0x75, 0x5e, 0x00, 0x75, 0x79, 0x5e, 0x00, 0x75, 0x7d, 0x5e, 0x00, 0x81, 0x8d, 0x5e, 0x00, 0x8d, 0x92, 0x5e,
|
|
0x00, 0x8d, 0x92, 0x67, 0x00, 0x9a, 0x9a, 0x71, 0x00, 0x9a, 0xa2, 0x7a, 0x00, 0x9a, 0xa2, 0x7a, 0x00, 0x9a, 0xa1, 0x7a, 0x00, 0x92, 0x9a, 0x71, 0x00, 0x89, 0x92, 0x67, 0x00, 0x81, 0x85, 0x5e,
|
|
0x00, 0x7d, 0x7d, 0x55, 0x00, 0x69, 0x79, 0x4b, 0x00, 0x61, 0x6d, 0x42, 0x00, 0x44, 0x4c, 0x25, 0x00, 0x38, 0x44, 0x1c, 0x00, 0x40, 0x51, 0x25, 0x00, 0x45, 0x4d, 0x25, 0x00, 0x71, 0x6d, 0x42,
|
|
0x00, 0x79, 0x7d, 0x4b, 0x00, 0x81, 0x7d, 0x55, 0x00, 0x79, 0x79, 0x55, 0x00, 0x6d, 0x75, 0x55, 0x00, 0x69, 0x7d, 0x55, 0x00, 0x6c, 0x79, 0x5e, 0x00, 0x65, 0x79, 0x54, 0x00, 0x68, 0x79, 0x5e,
|
|
0x00, 0x64, 0x79, 0x67, 0x00, 0x64, 0x79, 0x67, 0x00, 0x68, 0x75, 0x5e, 0x00, 0x64, 0x71, 0x5e, 0x00, 0x64, 0x6c, 0x5e, 0x00, 0x65, 0x6d, 0x55, 0x00, 0x4d, 0x58, 0x42, 0x00, 0x34, 0x40, 0x25,
|
|
0x00, 0x2c, 0x38, 0x1c, 0x00, 0x20, 0x28, 0x1c, 0x00, 0x1c, 0x14, 0x09, 0x00, 0x18, 0x18, 0x00, 0x00, 0x04, 0x14, 0x00, 0x00, 0x08, 0x10, 0x00, 0x00, 0x0c, 0x18, 0x00, 0x00, 0x1c, 0x28, 0x09,
|
|
0x00, 0x24, 0x30, 0x12, 0x00, 0x3c, 0x44, 0x25, 0x00, 0x5d, 0x65, 0x55, 0x00, 0x75, 0x79, 0x55, 0x00, 0x85, 0x89, 0x5e, 0x00, 0x89, 0x91, 0x71, 0x00, 0x96, 0xa2, 0x71, 0x00, 0x9a, 0xa2, 0x7a,
|
|
0x00, 0x9e, 0xaa, 0x7a, 0x00, 0x9e, 0xaa, 0x7a, 0x00, 0xaa, 0xae, 0x71, 0x00, 0xa6, 0xaa, 0x7a, 0x00, 0xa2, 0xaa, 0x7a, 0x00, 0xa1, 0xa5, 0x7a, 0x00, 0x96, 0x9e, 0x7a, 0x00, 0x85, 0x96, 0x7a,
|
|
0x00, 0x81, 0x92, 0x7a, 0x00, 0x78, 0x92, 0x7a, 0x00, 0x75, 0x92, 0x7a, 0x00, 0x75, 0x8d, 0x7a, 0x00, 0x70, 0x81, 0x67, 0x00, 0x7d, 0x7d, 0x67, 0x00, 0x89, 0x89, 0x67, 0x00, 0x92, 0x9a, 0x71,
|
|
0x00, 0x9e, 0xaa, 0x7a, 0x00, 0xaa, 0xb6, 0x84, 0x00, 0xb2, 0xb6, 0x8d, 0x00, 0xb6, 0xba, 0x97, 0x00, 0xc2, 0xca, 0x97, 0x00, 0xb2, 0xbe, 0x8d, 0x00, 0xb2, 0xb6, 0x8d, 0x00, 0xaa, 0xb2, 0x8d,
|
|
0x00, 0xa2, 0xae, 0x84, 0x00, 0x9a, 0xa6, 0x7a, 0x00, 0x92, 0x9e, 0x7a, 0x00, 0x85, 0x9a, 0x7a, 0x00, 0x7d, 0x96, 0x7a, 0x00, 0x7d, 0x92, 0x7a, 0x00, 0x7d, 0x92, 0x84, 0x00, 0x7d, 0x92, 0x84,
|
|
0x00, 0x81, 0x96, 0x84, 0x00, 0x85, 0x96, 0x84, 0x00, 0x85, 0x96, 0x84, 0x00, 0x81, 0x92, 0x84, 0x00, 0x85, 0x9a, 0x84, 0x00, 0x85, 0x9a, 0x84, 0x00, 0x8d, 0x9a, 0x84, 0x00, 0x92, 0x96, 0x84,
|
|
0x00, 0x9e, 0xa9, 0x84, 0x00, 0xae, 0xb2, 0x84, 0x00, 0xaa, 0xba, 0x84, 0x00, 0xb2, 0xbe, 0x8d, 0x00, 0xb6, 0xc2, 0xa0, 0x00, 0xc6, 0xca, 0xa0, 0x00, 0xc6, 0xce, 0xaa, 0x00, 0xd6, 0xda, 0xb3,
|
|
0x00, 0xda, 0xe2, 0xc5, 0x00, 0xd2, 0xd6, 0xbc, 0x00, 0xbe, 0xc2, 0xa0, 0x00, 0xaa, 0xb6, 0x8d, 0x00, 0x9e, 0xa6, 0x7a, 0x00, 0x92, 0x9a, 0x71, 0x00, 0x89, 0x89, 0x71, 0x00, 0x81, 0x7d, 0x67,
|
|
0x00, 0x7d, 0x7d, 0x67, 0x00, 0x81, 0x78, 0x67, 0x00, 0x7d, 0x7d, 0x5e, 0x00, 0x79, 0x79, 0x5e, 0x00, 0x79, 0x81, 0x5e, 0x00, 0x81, 0x7d, 0x67, 0x00, 0x81, 0x7d, 0x67, 0x00, 0x81, 0x81, 0x67,
|
|
0x00, 0x81, 0x89, 0x71, 0x00, 0x85, 0x91, 0x7a, 0x00, 0x89, 0x92, 0x7a, 0x00, 0x96, 0x9d, 0x7a, 0x00, 0x96, 0x9e, 0x7a, 0x00, 0x92, 0x96, 0x84, 0x00, 0x96, 0x9a, 0x8d, 0x00, 0x92, 0x92, 0x84,
|
|
0x00, 0x89, 0x91, 0x84, 0x00, 0x81, 0x92, 0x84, 0x00, 0x7d, 0x92, 0x8d, 0x00, 0x78, 0x92, 0x8d, 0x00, 0x74, 0x92, 0x8d, 0x00, 0x78, 0x92, 0x8d, 0x00, 0x78, 0x96, 0x97, 0x00, 0x81, 0x96, 0x8d,
|
|
0x00, 0x81, 0x96, 0x8d, 0x00, 0x81, 0x9a, 0x8d, 0x00, 0x85, 0x9a, 0x8d, 0x00, 0x89, 0x9e, 0x8d, 0x00, 0x89, 0x9e, 0x8d, 0x00, 0x8d, 0xa2, 0x97, 0x00, 0x95, 0xa2, 0x97, 0x00, 0x8d, 0xa2, 0x97,
|
|
0x00, 0x96, 0xa6, 0x8d, 0x00, 0x9a, 0xa1, 0x8d, 0x00, 0x9e, 0xa9, 0x84, 0x00, 0x9e, 0xa6, 0x7a, 0x00, 0xa2, 0xa5, 0x71, 0x00, 0x9e, 0xa6, 0x71, 0x00, 0x9a, 0xa6, 0x71, 0x00, 0x95, 0x9d, 0x71
|
|
};
|
|
|
|
for (size_t i = 0; i < size; i++)
|
|
{
|
|
m_Entries[i].a = T(palette15[i * 4 + 0]);
|
|
m_Entries[i].r = T(palette15[i * 4 + 1]) / T(255);
|
|
m_Entries[i].g = T(palette15[i * 4 + 2]) / T(255);
|
|
m_Entries[i].b = T(palette15[i * 4 + 3]) / T(255);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructor which takes the vector of colors as well as the source colors which were
|
|
/// used to create it in a palette editor. The burden is on the user to not let the two get out of sync.
|
|
/// </summary>
|
|
/// <param name="name">The name of the palette</param>
|
|
/// <param name="entries">A vector of color entries</param>
|
|
/// <param name="sourceColors">A map of colors which was used to create entries in a palette editor</param>
|
|
Palette(const string& name, vector<v4T>& entries, map<T, v4T>& sourceColors)
|
|
{
|
|
m_Name = name;
|
|
m_Entries = entries;
|
|
m_SourceColors = sourceColors;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Default copy constructor.
|
|
/// </summary>
|
|
/// <param name="palette">The Palette object to copy</param>
|
|
Palette(const Palette<T>& palette)
|
|
{
|
|
Palette<T>::operator=<T>(palette);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copy constructor to copy a Palette object of type U.
|
|
/// </summary>
|
|
/// <param name="palette">The Palette object to copy</param>
|
|
template <typename U>
|
|
Palette(const Palette<U>& palette)
|
|
{
|
|
Palette<T>::operator=<U>(palette);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Needed to eliminate warnings about inlining.
|
|
/// </summary>
|
|
~Palette() = default;
|
|
|
|
/// <summary>
|
|
/// Default assignment operator.
|
|
/// </summary>
|
|
/// <param name="palette">The Palette object to copy</param>
|
|
Palette<T>& operator = (const Palette<T>& palette)
|
|
{
|
|
if (this != &palette)
|
|
Palette<T>::operator=<T>(palette);
|
|
|
|
return *this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Assignment operator to assign a Palette object of type U.
|
|
/// </summary>
|
|
/// <param name="palette">The Palette object to copy</param>
|
|
/// <returns>Reference to updated self</returns>
|
|
template <typename U>
|
|
Palette<T>& operator = (const Palette<U>& palette)
|
|
{
|
|
m_Index = palette.m_Index;
|
|
m_Name = palette.m_Name;
|
|
m_Filename = palette.m_Filename;
|
|
CopyCont(m_Entries, palette.m_Entries);
|
|
m_SourceColors.clear();
|
|
|
|
for (auto& kv : palette.m_SourceColors)
|
|
m_SourceColors[T(kv.first)] = v4T(kv.second);
|
|
|
|
return *this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convenience [] operator to index into the color entries vector.
|
|
/// </summary>
|
|
/// <param name="i">The index to get</param>
|
|
/// <returns>The color value at the specified index</returns>
|
|
v4T& operator[] (size_t i)
|
|
{
|
|
return m_Entries[i];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convenience [] operator to index into the color entries vector in a const context.
|
|
/// </summary>
|
|
/// <param name="i">The index to get</param>
|
|
/// <returns>The color value at the specified index</returns>
|
|
const v4T& operator[] (size_t i) const
|
|
{
|
|
return m_Entries[i];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convenience * operator to get a pointer to the beginning of the color entries vector.
|
|
/// </summary>
|
|
/// <returns>The address of the first element in the color entries vector</returns>
|
|
inline v4T* operator() (void)
|
|
{
|
|
return m_Entries.data();
|
|
}
|
|
|
|
/// <summary>
|
|
/// The size of the color entries vector.
|
|
/// </summary>
|
|
/// <returns>The size of the color entries vector</returns>
|
|
size_t Size() { return m_Entries.size(); }
|
|
|
|
/// <summary>
|
|
/// The size of the source color entries vector which was used to create the palette.
|
|
/// Note this will only be non-zero if this palette was created in the palette editor.
|
|
/// </summary>
|
|
/// <returns>The size of the source colors map</returns>
|
|
size_t SourceColorSize() { return m_SourceColors.size(); }
|
|
|
|
/// <summary>
|
|
/// Set all colors to either black or white, including the alpha channel.
|
|
/// </summary>
|
|
/// <param name="black">Set all colors to black if true, else white</param>
|
|
void Clear(bool black = true)
|
|
{
|
|
for (glm::length_t i = 0; i < Size(); i++)
|
|
{
|
|
for (glm::length_t j = 0; j < 4; j++)
|
|
{
|
|
if (black)
|
|
m_Entries[i][j] = 0;
|
|
else
|
|
m_Entries[i][j] = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Make a copy of this palette, adjust for hue and store in the passed in palette.
|
|
/// This is used because one way an ember Xml can specify color is with an index in the
|
|
/// palette Xml file and a hue rotation value.
|
|
/// </summary>
|
|
/// <param name="palette">The palette to store the results in</param>
|
|
/// <param name="hue">The hue rotation to apply</param>
|
|
void MakeHueAdjustedPalette(Palette<T>& palette, T hue)
|
|
{
|
|
palette.m_Index = m_Index;
|
|
palette.m_Name = m_Name;
|
|
palette.m_Filename = m_Filename;
|
|
palette.m_Entries.resize(Size());
|
|
|
|
for (size_t i = 0; i < Size(); i++)
|
|
{
|
|
size_t ii = (i * Size()) / Size();
|
|
T rgb[3], hsv[3];
|
|
rgb[0] = m_Entries[ii].r;
|
|
rgb[1] = m_Entries[ii].g;
|
|
rgb[2] = m_Entries[ii].b;
|
|
RgbToHsv(rgb, hsv);
|
|
hsv[0] += hue * T(6.0);
|
|
HsvToRgb(hsv, rgb);
|
|
//Alpha serves as merely a hit counter that gets incremented by 1 each time, see Renderer::Accumulate() for its usage.
|
|
//Removing it saves no memory since it's 16 byte aligned. This also means alpha is not used.
|
|
palette[i].r = rgb[0];
|
|
palette[i].g = rgb[1];
|
|
palette[i].b = rgb[2];
|
|
palette[i].a = 1;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// More advanced adjustment than MakeHueAdjustedPalette() provides.
|
|
/// Adjustments are applied in the order:
|
|
/// Frequency, index rotation, hue rotation, saturation, brightness, contrast, blur.
|
|
/// </summary>
|
|
/// <param name="palette">The palette to store the result in</param>
|
|
/// <param name="rot">Index rotation.</param>
|
|
/// <param name="hue">Hue rotation -5 - 5</param>
|
|
/// <param name="sat">Saturation 0 - 1</param>
|
|
/// <param name="bright">Brightness 0 - 1</param>
|
|
/// <param name="cont">Contrast -1 - 2</param>
|
|
/// <param name="blur">Blur 0 - 127</param>
|
|
/// <param name="freq">Frequency 1 - 10</param>
|
|
void MakeAdjustedPalette(Palette<T>& palette, int rot, T hue, T sat, T bright, T cont, uint blur, uint freq)
|
|
{
|
|
T rgb[3] {}, hsv[3] {};
|
|
palette.m_Entries.resize(Size());
|
|
|
|
if (freq > 1)
|
|
{
|
|
const size_t n = Size() / freq;
|
|
|
|
for (size_t j = 0; j <= freq; j++)
|
|
{
|
|
for (size_t i = 0; i <= n; i++)
|
|
{
|
|
if ((i + j * n) < Size())
|
|
{
|
|
palette[i + j * n].r = m_Entries[i * freq].r;
|
|
palette[i + j * n].g = m_Entries[i * freq].g;
|
|
palette[i + j * n].b = m_Entries[i * freq].b;
|
|
}
|
|
}
|
|
}
|
|
|
|
palette.m_Name = m_Name;
|
|
palette.m_Filename = m_Filename;
|
|
}
|
|
else
|
|
{
|
|
palette = *this;
|
|
}
|
|
|
|
auto tempPal = palette;
|
|
intmax_t iSize = intmax_t(Size());
|
|
|
|
for (intmax_t i = 0; i < iSize; i++)
|
|
{
|
|
rgb[0] = tempPal[std::abs(iSize + i - rot) % iSize].r;//Rotation.
|
|
rgb[1] = tempPal[std::abs(iSize + i - rot) % iSize].g;
|
|
rgb[2] = tempPal[std::abs(iSize + i - rot) % iSize].b;
|
|
RgbToHsv(rgb, hsv);
|
|
hsv[0] += hue * T(6.0);//Hue.
|
|
hsv[1] = Clamp<T>(hsv[1] + sat, 0, 1);//Saturation.
|
|
HsvToRgb(hsv, rgb);
|
|
rgb[0] = Clamp<T>(rgb[0] + bright, 0, 1);//Brightness.
|
|
rgb[1] = Clamp<T>(rgb[1] + bright, 0, 1);
|
|
rgb[2] = Clamp<T>(rgb[2] + bright, 0, 1);
|
|
rgb[0] = Clamp<T>(((rgb[0] - T(0.5)) * (cont + T(1.0))) + T(0.5), 0, 1);//Contrast.
|
|
rgb[1] = Clamp<T>(((rgb[1] - T(0.5)) * (cont + T(1.0))) + T(0.5), 0, 1);
|
|
rgb[2] = Clamp<T>(((rgb[2] - T(0.5)) * (cont + T(1.0))) + T(0.5), 0, 1);
|
|
//Alpha serves as merely a hit counter that gets incremented by 1 each time, see Renderer::Accumulate() for its usage.
|
|
//Removing it saves no memory since it's 16 byte aligned.
|
|
palette[i].r = rgb[0];
|
|
palette[i].g = rgb[1];
|
|
palette[i].b = rgb[2];
|
|
palette[i].a = 1;
|
|
}
|
|
|
|
if (blur > 0)
|
|
{
|
|
tempPal = palette;
|
|
|
|
for (int i = 0; i < iSize; i++)
|
|
{
|
|
int n = -1;
|
|
rgb[0] = 0;
|
|
rgb[1] = 0;
|
|
rgb[2] = 0;
|
|
|
|
for (int j = i - int(blur); j <= i + int(blur); j++)
|
|
{
|
|
n++;
|
|
auto k = (iSize + j) % iSize;
|
|
|
|
if (k != i)
|
|
{
|
|
rgb[0] = rgb[0] + tempPal[k].r;
|
|
rgb[1] = rgb[1] + tempPal[k].g;
|
|
rgb[2] = rgb[2] + tempPal[k].b;
|
|
}
|
|
}
|
|
|
|
if (n != 0)
|
|
{
|
|
palette[i].r = rgb[0] / n;
|
|
palette[i].g = rgb[1] / n;
|
|
palette[i].b = rgb[2] / n;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Make a copy of this palette and multiply all RGB values by a scalar.
|
|
/// </summary>
|
|
/// <param name="palette">The palette to store the result in</param>
|
|
/// <param name="colorScalar">The color scalar to multiply each RGB value by</param>
|
|
template<typename bucketT>
|
|
void MakeDmap(Palette<bucketT>& palette, T colorScalar = 1)
|
|
{
|
|
palette.m_Index = m_Index;
|
|
palette.m_Name = m_Name;
|
|
palette.m_Filename = m_Filename;
|
|
|
|
if (palette.Size() != Size())
|
|
palette.m_Entries.resize(Size());
|
|
|
|
for (size_t j = 0; j < palette.Size(); j++)
|
|
{
|
|
palette.m_Entries[j] = m_Entries[j] * colorScalar;
|
|
palette.m_Entries[j].a = 1;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Make a buffer with the color values of this palette scaled to 255
|
|
/// and repeated for a number of rows.
|
|
/// Convenience function for displaying this palette on a GUI.
|
|
/// </summary>
|
|
/// <param name="height">The height of the output block</param>
|
|
/// <returns>A vector holding the color values</returns>
|
|
vector<unsigned char> MakeRgbPaletteBlock(size_t height)
|
|
{
|
|
const auto width = Size();
|
|
vector<unsigned char> v(height * width * 3);
|
|
|
|
if (v.size() == (height * Size() * 3))
|
|
{
|
|
for (size_t i = 0; i < height; i++)
|
|
{
|
|
for (size_t j = 0; j < width; j++)
|
|
{
|
|
v[(width * 3 * i) + (j * 3)] = static_cast<unsigned char>(m_Entries[j][0] * static_cast<T>(255));//Palettes are as [0..1], so convert to [0..255] here since it's for GUI display.
|
|
v[(width * 3 * i) + (j * 3) + 1] = static_cast<unsigned char>(m_Entries[j][1] * static_cast<T>(255));
|
|
v[(width * 3 * i) + (j * 3) + 2] = static_cast<unsigned char>(m_Entries[j][2] * static_cast<T>(255));
|
|
}
|
|
}
|
|
}
|
|
|
|
return v;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Determine if a palette is all black.
|
|
/// </summary>
|
|
/// <returns>True if all colors are black, else false if at least one component of one color is non zero.</returns>
|
|
bool IsEmpty()
|
|
{
|
|
for (glm::length_t i = 0; i < Size(); i++)
|
|
for (glm::length_t j = 0; j < 3; j++)
|
|
if (m_Entries[i][j] != 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert RGB to HSV.
|
|
/// </summary>
|
|
/// <param name="r">Red 0 - 1</param>
|
|
/// <param name="g">Green 0 - 1</param>
|
|
/// <param name="b">Blue 0 - 1</param>
|
|
/// <param name="h">Hue 0 - 6</param>
|
|
/// <param name="s">Saturation 0 - 1</param>
|
|
/// <param name="v">Value 0 - 1</param>
|
|
static void RgbToHsv(T r, T g, T b, T& h, T& s, T& v)
|
|
{
|
|
T max, min, del, rc, gc, bc;
|
|
max = std::max(std::max(r, g), b);//Compute maximum of r, g, b.
|
|
min = std::min(std::min(r, g), b);//Compute minimum of r, g, b.
|
|
del = max - min;
|
|
v = max;
|
|
s = (max != 0) ? (del / max) : 0;
|
|
h = 0;
|
|
|
|
if (s != 0)
|
|
{
|
|
rc = (max - r) / del;
|
|
gc = (max - g) / del;
|
|
bc = (max - b) / del;
|
|
|
|
if (r == max)
|
|
h = bc - gc;
|
|
else if (g == max)
|
|
h = 2 + rc - bc;
|
|
else if (b == max)
|
|
h = 4 + gc - rc;
|
|
|
|
if (h < 0)
|
|
h += 6;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wrapper around RgbToHsv() which takes buffers as parameters instead of individual components.
|
|
/// </summary>
|
|
/// <param name="rgb">The RGB buffer</param>
|
|
/// <param name="hsv">The HSV buffer</param>
|
|
static void RgbToHsv(const T* rgb, T* hsv)
|
|
{
|
|
RgbToHsv(rgb[0], rgb[1], rgb[2], hsv[0], hsv[1], hsv[2]);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert HSV to RGB.
|
|
/// </summary>
|
|
/// <param name="h">Hue 0 - 6</param>
|
|
/// <param name="s">Saturation 0 - 1</param>
|
|
/// <param name="v">Value 0 - 1</param>
|
|
/// <param name="r">Red 0 - 1</param>
|
|
/// <param name="g">Green 0 - 1</param>
|
|
/// <param name="b">Blue 0 - 1</param>
|
|
static void HsvToRgb(T h, T s, T v, T& r, T& g, T& b)
|
|
{
|
|
intmax_t j;
|
|
T f, p, q, t;
|
|
|
|
while (h >= 6)
|
|
h -= 6;
|
|
|
|
while (h < 0)
|
|
h += 6;
|
|
|
|
j = Floor<T>(h);
|
|
f = h - j;
|
|
p = v * (1 - s);
|
|
q = v * (1 - (s * f));
|
|
t = v * (1 - (s * (1 - f)));
|
|
|
|
switch (j)
|
|
{
|
|
case 0: r = v; g = t; b = p; break;
|
|
|
|
case 1: r = q; g = v; b = p; break;
|
|
|
|
case 2: r = p; g = v; b = t; break;
|
|
|
|
case 3: r = p; g = q; b = v; break;
|
|
|
|
case 4: r = t; g = p; b = v; break;
|
|
|
|
case 5: r = v; g = p; b = q; break;
|
|
|
|
default: r = v; g = t; b = p; break;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wrapper around HsvToRgb() which takes buffers as parameters instead of individual components.
|
|
/// </summary>
|
|
/// <param name="hsv">The HSV buffer</param>
|
|
/// <param name="rgb">The RGB buffer</param>
|
|
static void HsvToRgb(T* hsv, T* rgb)
|
|
{
|
|
HsvToRgb(hsv[0], hsv[1], hsv[2], rgb[0], rgb[1], rgb[2]);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the alpha.
|
|
/// Used for gamma correction in final accumulation.
|
|
/// Not the slightest clue what this is doing.
|
|
/// </summary>
|
|
/// <param name="density">Density</param>
|
|
/// <param name="gamma">Gamma</param>
|
|
/// <param name="linrange">Linear range</param>
|
|
/// <returns>Alpha</returns>
|
|
static T CalcAlpha(T density, T gamma, T linrange)
|
|
{
|
|
T frac, alpha;
|
|
T funcval = std::pow(linrange, gamma);
|
|
|
|
if (density > 0)
|
|
{
|
|
if (density < linrange)
|
|
{
|
|
frac = density / linrange;
|
|
alpha = (T(1.0) - frac) * density * (funcval / linrange) + frac * std::pow(density, gamma);
|
|
}
|
|
else
|
|
alpha = std::pow(density, gamma);
|
|
}
|
|
else
|
|
alpha = 0;
|
|
|
|
return alpha;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the new RGB and stores in the supplied buffer.
|
|
/// Used for gamma correction in final accumulation.
|
|
/// Not the slightest clue what this is doing.
|
|
/// </summary>
|
|
/// <param name="cBuf">The input RGB color buffer 0 - 1</param>
|
|
/// <param name="ls">Log scaling</param>
|
|
/// <param name="highPow">Highlight power, -1 - 1</param>
|
|
/// <param name="newRgb">Newly computed RGB value</param>
|
|
template<typename bucketT>
|
|
static void CalcNewRgb(bucketT* cBuf, T ls, T highPow, bucketT* newRgb)
|
|
{
|
|
size_t rgbi;
|
|
T lsratio;
|
|
bucketT newhsv[3];
|
|
T maxa, maxc, newls;
|
|
T adjustedHighlight;
|
|
|
|
if (ls == 0 || (cBuf[0] == 0 && cBuf[1] == 0 && cBuf[2] == 0))
|
|
{
|
|
newRgb[0] = 0;
|
|
newRgb[1] = 0;
|
|
newRgb[2] = 0;
|
|
return;
|
|
}
|
|
|
|
//Identify the most saturated channel.
|
|
maxc = std::max(std::max(cBuf[0], cBuf[1]), cBuf[2]);
|
|
maxa = ls * maxc;
|
|
newls = 1 / maxc;
|
|
|
|
//If a channel is saturated and highlight power is non-negative
|
|
//modify the color to prevent hue shift.
|
|
if (maxa > 1 && highPow >= 0)
|
|
{
|
|
lsratio = std::pow(newls / ls, highPow);
|
|
|
|
//Calculate the max-value color (ranged 0 - 1).
|
|
for (rgbi = 0; rgbi < 3; rgbi++)
|
|
newRgb[rgbi] = bucketT(newls) * cBuf[rgbi];
|
|
|
|
//Reduce saturation by the lsratio.
|
|
Palette<bucketT>::RgbToHsv(newRgb, newhsv);
|
|
newhsv[1] *= bucketT(lsratio);
|
|
Palette<bucketT>::HsvToRgb(newhsv, newRgb);
|
|
}
|
|
else
|
|
{
|
|
adjustedHighlight = -highPow;
|
|
|
|
if (adjustedHighlight > 1)
|
|
adjustedHighlight = 1;
|
|
|
|
if (maxa <= 1)
|
|
adjustedHighlight = 1;
|
|
|
|
//Calculate the max-value color (ranged 0 - 1) interpolated with the old behavior.
|
|
for (rgbi = 0; rgbi < 3; rgbi++)
|
|
newRgb[rgbi] = bucketT((T(1.0) - adjustedHighlight) * newls + adjustedHighlight * ls) * cBuf[rgbi];
|
|
}
|
|
}
|
|
|
|
int m_Index = -1;//Index in the xml palette file of this palette, use -1 for random.
|
|
string m_Name = "-";//Name of this palette.
|
|
shared_ptr<string> m_Filename;//Name of the parent file this palette came from, can be empty.
|
|
vector<v4T> m_Entries;
|
|
map<T, v4T> m_SourceColors;
|
|
};
|
|
}
|