mirror of
https://bitbucket.org/mfeemster/fractorium.git
synced 2025-01-22 05:30:06 -05:00
07592c9d78
Add Curves.h, and CurvesGraphicsView.h/cpp to support bezier color curves. Add Curves member to Ember. Add curves capability to EmberCL. Remove some unused variables in the kernel created in RendererCL::CreateFinalAccumKernelString(). Use glm namespace for vec classes if GLM_VERSION >= 96, else use glm::detail. As a result of using glm namespace, all instances of min and max had to be qualified with std:: Split ComputeCamera into that and ComputeQuality(). Reduce the amount of ComputeCamera() and MakeDmap() calls on each incremental iter that doesn't use temporal samples. Fix clamping bug with DE filter widths. Provide functions to return the kernels from RendererCL to assist with diagnostics and debugging. Prevent extra newline in EmberRender when only rendering a single image. Add the ability to delete an ember at a given index in EmberFile. Allow deleting/focusing ember in library tab with delete and enter keys. Reorder some code in Fractorium.h to match the tabs order. Add and call ClearFinalImages() to clear buffers in controller to fix bug where previous CPU render would be shown for a split second when switching from OpenCL back to CPU. Refactor ember library pointer syncing to a function SyncPointers(). Add the ability to save ember Xmls to an unique automatically generated name after the first time the user has specified a name.
580 lines
21 KiB
C++
580 lines
21 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.
|
|
/// 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_Name = "-";
|
|
m_Index = -1;
|
|
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, uint size, v4T* xmlPaletteEntries)
|
|
{
|
|
m_Name = name;
|
|
m_Index = index;
|
|
m_Entries.resize(size);
|
|
|
|
if (xmlPaletteEntries)
|
|
{
|
|
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.
|
|
byte 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 (uint i = 0; i < size; i++)
|
|
{
|
|
m_Entries[i].a = T(palette15[i * 4 + 0]);
|
|
m_Entries[i].r = T(palette15[i * 4 + 1]);
|
|
m_Entries[i].g = T(palette15[i * 4 + 2]);
|
|
m_Entries[i].b = T(palette15[i * 4 + 3]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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>
|
|
/// Empty destructor.
|
|
/// Needed to eliminate warnings about inlining.
|
|
/// </summary>
|
|
~Palette()
|
|
{
|
|
}
|
|
|
|
/// <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;
|
|
CopyVec(m_Entries, palette.m_Entries);
|
|
|
|
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 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[0];
|
|
}
|
|
|
|
/// <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>
|
|
/// 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_Entries.resize(Size());
|
|
|
|
for (uint i = 0; i < Size(); i++)
|
|
{
|
|
size_t ii = (i * 256) / COLORMAP_LENGTH;
|
|
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];
|
|
|
|
if (freq > 1)
|
|
{
|
|
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;
|
|
}
|
|
else
|
|
{
|
|
palette = *this;
|
|
}
|
|
|
|
for (size_t i = 0; i < Size(); i++)
|
|
{
|
|
size_t ii = (i * 256) / COLORMAP_LENGTH;
|
|
|
|
rgb[0] = palette[(COLORMAP_LENGTH + ii - rot) % COLORMAP_LENGTH].r;//Rotation.
|
|
rgb[1] = palette[(COLORMAP_LENGTH + ii - rot) % COLORMAP_LENGTH].g;
|
|
rgb[2] = palette[(COLORMAP_LENGTH + ii - rot) % COLORMAP_LENGTH].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)
|
|
{
|
|
Palette<T> blurPal = palette;
|
|
|
|
for (int i = 0; i < 256; 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++;
|
|
int k = (256 + j) % 256;
|
|
|
|
if (k != i)
|
|
{
|
|
rgb[0] = rgb[0] + blurPal[k].r;
|
|
rgb[1] = rgb[1] + blurPal[k].g;
|
|
rgb[2] = rgb[2] + blurPal[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;
|
|
|
|
if (palette.Size() != Size())
|
|
palette.m_Entries.resize(Size());
|
|
|
|
for (uint 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<byte> MakeRgbPaletteBlock(uint height)
|
|
{
|
|
size_t width = Size();
|
|
vector<byte> v(height * width * 3);
|
|
|
|
if (v.size() == (height * Size() * 3))
|
|
{
|
|
for (uint i = 0; i < height; i++)
|
|
{
|
|
for (uint j = 0; j < width; j++)
|
|
{
|
|
v[(width * 3 * i) + (j * 3)] = byte(m_Entries[j][0] * 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] = byte(m_Entries[j][1] * T(255));
|
|
v[(width * 3 * i) + (j * 3) + 2] = byte(m_Entries[j][2] * T(255));
|
|
}
|
|
}
|
|
}
|
|
|
|
return v;
|
|
}
|
|
|
|
/// <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(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)
|
|
{
|
|
int 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 = pow(linrange, gamma);
|
|
|
|
if (density > 0)
|
|
{
|
|
if (density < linrange)
|
|
{
|
|
frac = density / linrange;
|
|
alpha = (T(1.0) - frac) * density * (funcval / linrange) + frac * pow(density, gamma);
|
|
}
|
|
else
|
|
alpha = 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)
|
|
{
|
|
int rgbi;
|
|
T newls, lsratio;
|
|
bucketT newhsv[3];
|
|
T maxa, maxc;
|
|
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;
|
|
|
|
//If a channel is saturated and highlight power is non-negative
|
|
//modify the color to prevent hue shift.
|
|
if (maxa > 255 && highPow >= 0)
|
|
{
|
|
newls = T(255.0) / maxc;
|
|
lsratio = pow(newls / ls, highPow);
|
|
|
|
//Calculate the max-value color (ranged 0 - 1).
|
|
for (rgbi = 0; rgbi < 3; rgbi++)
|
|
newRgb[rgbi] = bucketT(newls) * cBuf[rgbi] / bucketT(255.0);
|
|
|
|
//Reduce saturation by the lsratio.
|
|
Palette<bucketT>::RgbToHsv(newRgb, newhsv);
|
|
newhsv[1] *= bucketT(lsratio);
|
|
Palette<bucketT>::HsvToRgb(newhsv, newRgb);
|
|
|
|
for (rgbi = 0; rgbi < 3; rgbi++)
|
|
newRgb[rgbi] *= T(255.0);
|
|
}
|
|
else
|
|
{
|
|
newls = T(255.0) / maxc;
|
|
adjustedHighlight = -highPow;
|
|
|
|
if (adjustedHighlight > 1)
|
|
adjustedHighlight = 1;
|
|
|
|
if (maxa <= 255)
|
|
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;//Index in the xml palette file of this palette, use -1 for random.
|
|
string m_Name;//Name of this palette.
|
|
vector<v4T> m_Entries;//Storage for the color values.
|
|
};
|
|
}
|