mirror-github-bspeice/fractorium
1
0
Fork 0
mirror of https://bitbucket.org/mfeemster/fractorium.git synced 2025-02-01 18:40:12 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

--Code changes

Browse Source 
-Split VariationList into .h/cpp files.
  --Make VariationList.cpp the only place where the variations files are included from. This speeds up the build, but variations can no longer be directly instantiated.
  --Variations are no longer exported.
This commit is contained in:
mfeemster 2016-02-18 18:58:24 -08:00
parent d92a600ced
commit c09457d5fe
28 changed files with 1060 additions and 1069 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Builds/MSVC/VS2013/Ember.vcxproj
View File

@ -320,6 +320,7 @@
</ClCompile>
<ClCompile Include="..\..\..\Source\Ember\Renderer.cpp" />
<ClCompile Include="..\..\..\Source\Ember\RendererBase.cpp" />
<ClCompile Include="..\..\..\Source\Ember\VariationList.cpp" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\..\..\libxml2\win32\VC10\libxml2.vcxproj">

3
Builds/MSVC/VS2013/Ember.vcxproj.filters
View File

@ -145,6 +145,9 @@
<ClCompile Include="..\..\..\Source\Ember\RendererBase.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\..\Source\Ember\VariationList.cpp">
<Filter>Header Files\Variations</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="Ember.rc" />

3
Builds/QtCreator/Ember/Ember.pro
View File

@ -23,7 +23,8 @@ SOURCES += \
$$PRJ_DIR/Ember.cpp \
$$PRJ_DIR/EmberPch.cpp \
$$PRJ_DIR/RendererBase.cpp \
$$PRJ_DIR/Renderer.cpp
$$PRJ_DIR/Renderer.cpp \
$$PRJ_DIR/VariationList.cpp
include(deployment.pri)
qtcAddDeployment()

9
Source/Ember/Affine2D.h
View File

@ -121,13 +121,4 @@ public:
m23T m_Mat;
};
//This class had to be implemented in a cpp file because the compiler was breaking.
//So the explicit instantiation must be declared here rather than in Ember.cpp where
//all of the other classes are done.
//template EMBER_API class Affine2D<float>;
//#ifdef DO_DOUBLE
// template EMBER_API class Affine2D<double>;
//#endif
}

6
Source/Ember/Ember.cpp
View File

@ -51,9 +51,9 @@ bool Timing::m_TimingInit = false;
uint Timing::m_ProcessorCount;
#define EXPORTPREPOSTREGVAR(varName, T) \
template EMBER_API class varName##Variation<T>; \
template EMBER_API class Pre##varName##Variation<T>; \
template EMBER_API class Post##varName##Variation<T>;
template class varName##Variation<T>; \
template class Pre##varName##Variation<T>; \
template class Post##varName##Variation<T>;
#define EXPORT_SINGLE_TYPE_EMBER(T) \
template<> const char* PaletteList<T>::m_DefaultFilename = "flam3-palettes.xml"; \

18
Source/Ember/Ember.h
View File

@ -13,6 +13,8 @@
namespace EmberNs
{
template <typename T> class Interpolater;
/// <summary>
/// Bit position specifying the presence of each type of 3D parameter.
/// One, none, some or all of these can be present.
@ -42,6 +44,7 @@ public:
/// Default constructor which calls Init() to set default values.
/// </summary>
Ember()
: m_VariationList(VariationList<T>::Instance())
{
Init();
}
@ -51,7 +54,8 @@ public:
/// </summary>
/// <param name="ember">The Ember object to copy</param>
Ember(const Ember<T>& ember)
: m_Edits(nullptr)
: m_VariationList(VariationList<T>::Instance()),
m_Edits(nullptr)
{
Ember<T>::operator=<T>(ember);
}
@ -62,7 +66,8 @@ public:
/// <param name="ember">The Ember object to copy</param>
template <typename U>
Ember(const Ember<U>& ember)
: m_Edits(nullptr)
: m_VariationList(VariationList<T>::Instance()),
m_Edits(nullptr)
{
Ember<T>::operator=<U>(ember);
}
@ -299,7 +304,7 @@ public:
ember.m_FinalXform.m_ColorSpeed = 0;
ember.m_FinalXform.m_Motion.clear();
ember.m_FinalXform.ClearAndDeleteVariations();
ember.m_FinalXform.AddVariation(new LinearVariation<T>(0));//Do this so it doesn't appear empty.
ember.m_FinalXform.AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR, 0));//Do this so it doesn't appear empty.
}
}
@ -1096,7 +1101,7 @@ public:
m_Xforms[i].m_Affine.D(0);
m_Xforms[i].m_Affine.E(1);
m_Xforms[i].m_Affine.F(0);
m_Xforms[i].AddVariation(new LinearVariation<T>());
m_Xforms[i].AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR));
result++;
sym = -sym;
}
@ -1118,7 +1123,7 @@ public:
m_Xforms[i].m_Affine.E(m_Xforms[i].m_Affine.A());
m_Xforms[i].m_Affine.C(0);
m_Xforms[i].m_Affine.F(0);
m_Xforms[i].AddVariation(new LinearVariation<T>());
m_Xforms[i].AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR));
result++;
}
@ -1747,6 +1752,9 @@ private:
//Xml field: "finalxform".
Xform<T> m_FinalXform;
//Single global reference to create variations with.
VariationList<T>& m_VariationList;
/// <summary>
/// Interpolation function that takes the address of a member variable of type T as a template parameter.
/// This is an alternative to using macros.

167
Source/Ember/Interpolate.h
View File

@ -1,6 +1,7 @@
#pragma once
#include "Ember.h"
#include "VariationList.h"
/// <summary>
/// Interpolater class.
@ -12,6 +13,7 @@ namespace EmberNs
/// g++ needs a forward declaration here.
/// </summary>
template <typename T> class Ember;
template <typename T> class VariationList;
/// <summary>
/// Contains many static functions for handling interpolation and other miscellaneous operations on
@ -42,6 +44,7 @@ public:
bool currentFinal, final = sourceEmbers[0].UseFinalXform();
size_t i, xf, currentCount, maxCount = sourceEmbers[0].XformCount();
Xform<T>* destOtherXform;
VariationList<T>& variationList(VariationList<T>::Instance());
//Determine the max number of xforms present in sourceEmbers.
//Also check if final xforms are used in any of them.
@ -135,7 +138,7 @@ public:
destOtherXform->GetVariationById(eVariationId::VAR_WEDGE_SPH) ||
destOtherXform->GetVariationById(eVariationId::VAR_WEDGE_JULIA))
{
destXform->AddVariation(new LinearVariation<T>(-1));
destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_LINEAR, -1));
//Set the coefs appropriately.
destXform->m_Affine.A(-1);
destXform->m_Affine.D(0);
@ -164,58 +167,71 @@ public:
if (destOtherXform->GetVariationById(eVariationId::VAR_RECTANGLES))
{
RectanglesVariation<T>* var = new RectanglesVariation<T>();
var->SetParamVal("rectangles_x", 0);
var->SetParamVal("rectangles_y", 0);
destXform->AddVariation(var);
if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_RECTANGLES))
{
var->SetParamVal("rectangles_x", 0);
var->SetParamVal("rectangles_y", 0);
destXform->AddVariation(var);
}
found++;
}
if (destOtherXform->GetVariationById(eVariationId::VAR_RINGS2))
{
Rings2Variation<T>* var = new Rings2Variation<T>();
var->SetParamVal("rings2_val", 0);
destXform->AddVariation(var);
if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_RINGS2))
{
var->SetParamVal("rings2_val", 0);
destXform->AddVariation(var);
}
found++;
}
if (destOtherXform->GetVariationById(eVariationId::VAR_FAN2))
{
Fan2Variation<T>* var = new Fan2Variation<T>();
destXform->AddVariation(var);
destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_FAN2));
found++;
}
if (destOtherXform->GetVariationById(eVariationId::VAR_BLOB))
{
BlobVariation<T>* var = new BlobVariation<T>();
var->SetParamVal("blob_low", 1);
destXform->AddVariation(var);
if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_BLOB))
{
var->SetParamVal("blob_low", 1);
destXform->AddVariation(var);
}
found++;
}
if (destOtherXform->GetVariationById(eVariationId::VAR_PERSPECTIVE))
{
PerspectiveVariation<T>* var = new PerspectiveVariation<T>();
destXform->AddVariation(var);
destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_PERSPECTIVE));
found++;
}
if (destOtherXform->GetVariationById(eVariationId::VAR_CURL))
{
CurlVariation<T>* var = new CurlVariation<T>();
var->SetParamVal("curl_c1", 0);
destXform->AddVariation(var);
if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_CURL))
{
var->SetParamVal("curl_c1", 0);
destXform->AddVariation(var);
}
found++;
}
if (destOtherXform->GetVariationById(eVariationId::VAR_SUPER_SHAPE))
{
SuperShapeVariation<T>* var = new SuperShapeVariation<T>();
var->SetParamVal("super_shape_n1", 2);
var->SetParamVal("super_shape_n2", 2);
var->SetParamVal("super_shape_n3", 2);
destXform->AddVariation(var);
if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_SUPER_SHAPE))
{
var->SetParamVal("super_shape_n1", 2);
var->SetParamVal("super_shape_n2", 2);
var->SetParamVal("super_shape_n3", 2);
destXform->AddVariation(var);
}
found++;
}
}
@ -238,13 +254,13 @@ public:
if (destOtherXform->GetVariationById(eVariationId::VAR_FAN))
{
destXform->AddVariation(new FanVariation<T>());
destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_FAN));
found++;
}
if (destOtherXform->GetVariationById(eVariationId::VAR_RINGS))
{
destXform->AddVariation(new RingsVariation<T>());
destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_RINGS));
found++;
}
}
@ -264,7 +280,7 @@ public:
//If there still are no matches, switch back to linear.
if (found == 0)
{
destXform->AddVariation(new LinearVariation<T>());
destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_LINEAR));
}
else if (found > 0)
{
@ -892,105 +908,6 @@ public:
}
}
/*
//Will need to alter this to handle 2D palettes.
static bool InterpMissingColors(vector<glm::detail::tvec4<T>>& palette)
{
//Check for a non-full palette.
int minIndex, maxIndex;
int colorli, colorri;
int wrapMin, wrapMax;
int intl, intr;
int str, enr;
int i, j, k;
double prcr;
if (palette.size() != 256)
return false;
for (i = 0; i < 256; i++)
{
if (palette[i].m_Index >= 0)
{
minIndex = i;
break;
}
}
if (i == 256)
{
//No colors. Set all indices properly.
for (i = 0; i < 256; i++)
palette[i].m_Index = (T)i;
return false;
}
wrapMin = minIndex + 256;
for (i = 255; i >= 0; i--)//Moving backwards, ouch!
{
if (palette[i].m_Index >= 0)
{
maxIndex = i;
break;
}
}
wrapMax = maxIndex - 256;
//Loop over the indices looking for negs,
i = 0;
while (i < 256)
{
if (palette[i].m_Index < 0)
{
//Start of a range of negs.
str = i;
intl = i - 1;
colorli = intl;
while (palette[i].m_Index < 0 && i < 256)
{
enr = i;
intr = i + 1;
colorri = intr;
i++;
}
if (intl == -1)
{
intl = wrapMax;
colorli = maxIndex;
}
if (intr == 256)
{
intr = wrapMin;
colorri = minIndex;
}
for (j = str; j <= enr; j++)
{
prcr = (j - intl) / T(intr - intl);
for (k = 0; k <= 3; k++)
palette[j].Channels[k] = T(palette[colorli].Channels[k] * (1 - prcr) + palette[colorri].Channels[k] * prcr);
palette[j].m_Index = T(j);
}
i = colorri + 1;
}
else
i++;
}
return true;
}
*/
/// <summary>
/// Compare xforms for sorting based first on color speed and second on determinants if
/// color speeds are equal.

1
Source/Ember/Renderer.cpp
View File

@ -107,7 +107,6 @@ void Renderer<T, bucketT>::ComputeBounds()
/// <summary>
/// Compute the scale based on the zoom, then the quality based on the computed scale.
/// This sets up the bounds of the cartesian plane that the raster bounds correspond to.
/// This must be called before ComputeCamera() which will use scale.
/// </summary>
template <typename T, typename bucketT>

9
Source/Ember/SheepTools.h
View File

@ -62,6 +62,7 @@ public:
/// <param name="palettePath">The full path and filename of the palette file</param>
/// <param name="renderer">A pre-constructed renderer to use. The caller should not delete this.</param>
SheepTools(const string& palettePath, Renderer<T, bucketT>* renderer)
: m_VariationList(VariationList<T>::Instance())
{
Timing t;
m_Smooth = true;
@ -87,9 +88,9 @@ public:
Xform<T> xform1(T(0.25), T(1), T(0.5), T(1), T(0.5), T(0), T(0), T(0.5), T(0.5), T(0.25));
Xform<T> xform2(T(0.25), T(0.66), T(0.5), T(1), T(0.5), T(0), T(0), T(0.5), T(-0.5), T(0.25));
Xform<T> xform3(T(0.25), T(0.33), T(0.5), T(1), T(0.5), T(0), T(0), T(0.5), T(0.0), T(-0.5));
xform1.AddVariation(new LinearVariation<T>());
xform2.AddVariation(new LinearVariation<T>());
xform3.AddVariation(new LinearVariation<T>());
xform1.AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR));
xform2.AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR));
xform3.AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR));
ember.AddXform(xform1);
ember.AddXform(xform2);
ember.AddXform(xform3);
@ -1349,6 +1350,6 @@ private:
unique_ptr<Renderer<T, bucketT>> m_Renderer;
QTIsaac<ISAAC_SIZE, ISAAC_INT> m_Rand;
PaletteList<T> m_PaletteList;
VariationList<T> m_VariationList;
VariationList<T>& m_VariationList;
};
}

589
Source/Ember/VariationList.cpp Normal file
View File

@ -0,0 +1,589 @@
#include "EmberPch.h"
#include "VariationList.h"
#include "Variations01.h"
#include "Variations02.h"
#include "Variations03.h"
#include "Variations04.h"
#include "Variations05.h"
#include "Variations06.h"
#include "Variations07.h"
#include "VariationsDC.h"
namespace EmberNs
{
#define ADDPREPOSTREGVAR(varName) \
m_Variations.push_back(new varName##Variation<T>()); \
m_Variations.push_back(new Pre##varName##Variation<T>()); \
m_Variations.push_back(new Post##varName##Variation<T>());
/// <summary>
/// Singleton pattern, return a reference to the only instance of this object in existence.
/// </summary>
template <typename T>
VariationList<T>& VariationList<T>::Instance()
{
static VariationList<T> v;
return v;
}
/// <summary>
/// Constructor which initializes all of the variation objects and stores them in the list.
/// </summary>
template <typename T>
VariationList<T>::VariationList()
{
m_Variations.reserve(size_t(eVariationId::LAST_VAR));
ADDPREPOSTREGVAR(Linear)
ADDPREPOSTREGVAR(Sinusoidal)
ADDPREPOSTREGVAR(Spherical)
ADDPREPOSTREGVAR(Swirl)
ADDPREPOSTREGVAR(Horseshoe)
ADDPREPOSTREGVAR(Polar)
ADDPREPOSTREGVAR(Handkerchief)
ADDPREPOSTREGVAR(Heart)
ADDPREPOSTREGVAR(Disc)
ADDPREPOSTREGVAR(Spiral)
ADDPREPOSTREGVAR(Hyperbolic)
ADDPREPOSTREGVAR(Diamond)
ADDPREPOSTREGVAR(Ex)
ADDPREPOSTREGVAR(Julia)
ADDPREPOSTREGVAR(Bent)
ADDPREPOSTREGVAR(Waves)
ADDPREPOSTREGVAR(Fisheye)
ADDPREPOSTREGVAR(Popcorn)
ADDPREPOSTREGVAR(Exponential)
ADDPREPOSTREGVAR(Power)
ADDPREPOSTREGVAR(Cosine)
ADDPREPOSTREGVAR(Rings)
ADDPREPOSTREGVAR(Fan)
ADDPREPOSTREGVAR(Blob)
ADDPREPOSTREGVAR(Pdj)
ADDPREPOSTREGVAR(Fan2)
ADDPREPOSTREGVAR(Rings2)
ADDPREPOSTREGVAR(Eyefish)
ADDPREPOSTREGVAR(Bubble)
ADDPREPOSTREGVAR(Cylinder)
ADDPREPOSTREGVAR(Perspective)
ADDPREPOSTREGVAR(Noise)
ADDPREPOSTREGVAR(JuliaNGeneric)
ADDPREPOSTREGVAR(JuliaScope)
ADDPREPOSTREGVAR(Blur)
ADDPREPOSTREGVAR(GaussianBlur)
ADDPREPOSTREGVAR(RadialBlur)
ADDPREPOSTREGVAR(Pie)
ADDPREPOSTREGVAR(Ngon)
ADDPREPOSTREGVAR(Curl)
ADDPREPOSTREGVAR(Rectangles)
ADDPREPOSTREGVAR(Arch)
ADDPREPOSTREGVAR(Tangent)
ADDPREPOSTREGVAR(Square)
ADDPREPOSTREGVAR(Rays)
ADDPREPOSTREGVAR(Blade)
ADDPREPOSTREGVAR(Secant2)
ADDPREPOSTREGVAR(TwinTrian)
ADDPREPOSTREGVAR(Cross)
ADDPREPOSTREGVAR(Disc2)
ADDPREPOSTREGVAR(SuperShape)
ADDPREPOSTREGVAR(Flower)
ADDPREPOSTREGVAR(Conic)
ADDPREPOSTREGVAR(Parabola)
ADDPREPOSTREGVAR(Bent2)
ADDPREPOSTREGVAR(Bipolar)
ADDPREPOSTREGVAR(Boarders)
ADDPREPOSTREGVAR(Butterfly)
ADDPREPOSTREGVAR(Cell)
ADDPREPOSTREGVAR(Cpow)
ADDPREPOSTREGVAR(Curve)
ADDPREPOSTREGVAR(Edisc)
ADDPREPOSTREGVAR(Elliptic)
ADDPREPOSTREGVAR(Escher)
ADDPREPOSTREGVAR(Foci)
ADDPREPOSTREGVAR(LazySusan)
ADDPREPOSTREGVAR(Loonie)
ADDPREPOSTREGVAR(Modulus)
ADDPREPOSTREGVAR(Oscilloscope)
ADDPREPOSTREGVAR(Polar2)
ADDPREPOSTREGVAR(Popcorn2)
ADDPREPOSTREGVAR(Scry)
ADDPREPOSTREGVAR(Separation)
ADDPREPOSTREGVAR(Split)
ADDPREPOSTREGVAR(Splits)
ADDPREPOSTREGVAR(Stripes)
ADDPREPOSTREGVAR(Wedge)
ADDPREPOSTREGVAR(WedgeJulia)
ADDPREPOSTREGVAR(WedgeSph)
ADDPREPOSTREGVAR(Whorl)
ADDPREPOSTREGVAR(Waves2)
ADDPREPOSTREGVAR(Exp)
ADDPREPOSTREGVAR(Log)
ADDPREPOSTREGVAR(Sin)
ADDPREPOSTREGVAR(Cos)
ADDPREPOSTREGVAR(Tan)
ADDPREPOSTREGVAR(Sec)
ADDPREPOSTREGVAR(Csc)
ADDPREPOSTREGVAR(Cot)
ADDPREPOSTREGVAR(Sinh)
ADDPREPOSTREGVAR(Cosh)
ADDPREPOSTREGVAR(Tanh)
ADDPREPOSTREGVAR(Sech)
ADDPREPOSTREGVAR(Csch)
ADDPREPOSTREGVAR(Coth)
ADDPREPOSTREGVAR(Auger)
ADDPREPOSTREGVAR(Flux)
ADDPREPOSTREGVAR(Hemisphere)
ADDPREPOSTREGVAR(Epispiral)
ADDPREPOSTREGVAR(Bwraps)
ADDPREPOSTREGVAR(BlurCircle)
ADDPREPOSTREGVAR(BlurZoom)
ADDPREPOSTREGVAR(BlurPixelize)
ADDPREPOSTREGVAR(Crop)
ADDPREPOSTREGVAR(BCircle)
ADDPREPOSTREGVAR(BlurLinear)
ADDPREPOSTREGVAR(BlurSquare)
ADDPREPOSTREGVAR(Boarders2)
ADDPREPOSTREGVAR(Cardioid)
ADDPREPOSTREGVAR(Checks)
ADDPREPOSTREGVAR(Circlize)
ADDPREPOSTREGVAR(Circlize2)
ADDPREPOSTREGVAR(CosWrap)
ADDPREPOSTREGVAR(DeltaA)
ADDPREPOSTREGVAR(Expo)
ADDPREPOSTREGVAR(Extrude)
ADDPREPOSTREGVAR(FDisc)
ADDPREPOSTREGVAR(Fibonacci)
ADDPREPOSTREGVAR(Fibonacci2)
ADDPREPOSTREGVAR(Glynnia)
ADDPREPOSTREGVAR(GridOut)
ADDPREPOSTREGVAR(Hole)
ADDPREPOSTREGVAR(Hypertile)
ADDPREPOSTREGVAR(Hypertile1)
ADDPREPOSTREGVAR(Hypertile2)
ADDPREPOSTREGVAR(Hypertile3D)
ADDPREPOSTREGVAR(Hypertile3D1)
ADDPREPOSTREGVAR(Hypertile3D2)
ADDPREPOSTREGVAR(IDisc)
ADDPREPOSTREGVAR(Julian2)
ADDPREPOSTREGVAR(JuliaQ)
ADDPREPOSTREGVAR(Murl)
ADDPREPOSTREGVAR(Murl2)
ADDPREPOSTREGVAR(NPolar)
ADDPREPOSTREGVAR(Ortho)
ADDPREPOSTREGVAR(Poincare)
ADDPREPOSTREGVAR(Poincare3D)
ADDPREPOSTREGVAR(Polynomial)
ADDPREPOSTREGVAR(PSphere)
ADDPREPOSTREGVAR(Rational3)
ADDPREPOSTREGVAR(Ripple)
ADDPREPOSTREGVAR(Sigmoid)
ADDPREPOSTREGVAR(SinusGrid)
ADDPREPOSTREGVAR(Stwin)
ADDPREPOSTREGVAR(TwoFace)
ADDPREPOSTREGVAR(Unpolar)
ADDPREPOSTREGVAR(WavesN)
ADDPREPOSTREGVAR(XHeart)
ADDPREPOSTREGVAR(Barycentroid)
ADDPREPOSTREGVAR(BiSplit)
ADDPREPOSTREGVAR(Crescents)
ADDPREPOSTREGVAR(Mask)
ADDPREPOSTREGVAR(Cpow2)
ADDPREPOSTREGVAR(Curl3D)
ADDPREPOSTREGVAR(Disc3D)
ADDPREPOSTREGVAR(Funnel)
ADDPREPOSTREGVAR(Linear3D)
ADDPREPOSTREGVAR(PowBlock)
ADDPREPOSTREGVAR(Squirrel)
ADDPREPOSTREGVAR(Ennepers)
ADDPREPOSTREGVAR(SphericalN)
ADDPREPOSTREGVAR(Kaleidoscope)
ADDPREPOSTREGVAR(GlynnSim1)
ADDPREPOSTREGVAR(GlynnSim2)
ADDPREPOSTREGVAR(GlynnSim3)
ADDPREPOSTREGVAR(Starblur)
ADDPREPOSTREGVAR(Sineblur)
ADDPREPOSTREGVAR(Circleblur)
ADDPREPOSTREGVAR(CropN)
ADDPREPOSTREGVAR(ShredRad)
ADDPREPOSTREGVAR(Blob2)
ADDPREPOSTREGVAR(Julia3D)
ADDPREPOSTREGVAR(Julia3Dz)
ADDPREPOSTREGVAR(LinearT)
ADDPREPOSTREGVAR(LinearT3D)
ADDPREPOSTREGVAR(Ovoid)
ADDPREPOSTREGVAR(Ovoid3D)
ADDPREPOSTREGVAR(Spirograph)
ADDPREPOSTREGVAR(Petal)
ADDPREPOSTREGVAR(RoundSpher)
ADDPREPOSTREGVAR(RoundSpher3D)
ADDPREPOSTREGVAR(SpiralWing)
ADDPREPOSTREGVAR(Squarize)
ADDPREPOSTREGVAR(Sschecks)
ADDPREPOSTREGVAR(PhoenixJulia)
ADDPREPOSTREGVAR(Mobius)
ADDPREPOSTREGVAR(MobiusN)
ADDPREPOSTREGVAR(MobiusStrip)
ADDPREPOSTREGVAR(Lissajous)
ADDPREPOSTREGVAR(Svf)
ADDPREPOSTREGVAR(Target)
ADDPREPOSTREGVAR(Taurus)
ADDPREPOSTREGVAR(Collideoscope)
ADDPREPOSTREGVAR(BMod)
ADDPREPOSTREGVAR(BSwirl)
ADDPREPOSTREGVAR(BTransform)
ADDPREPOSTREGVAR(BCollide)
ADDPREPOSTREGVAR(Eclipse)
ADDPREPOSTREGVAR(FlipCircle)
ADDPREPOSTREGVAR(FlipY)
ADDPREPOSTREGVAR(ECollide)
ADDPREPOSTREGVAR(EJulia)
ADDPREPOSTREGVAR(EMod)
ADDPREPOSTREGVAR(EMotion)
ADDPREPOSTREGVAR(EPush)
ADDPREPOSTREGVAR(ERotate)
ADDPREPOSTREGVAR(EScale)
ADDPREPOSTREGVAR(ESwirl)
ADDPREPOSTREGVAR(LazyTravis)
ADDPREPOSTREGVAR(Squish)
ADDPREPOSTREGVAR(Circus)
ADDPREPOSTREGVAR(Tancos)
ADDPREPOSTREGVAR(Rippled)
ADDPREPOSTREGVAR(RotateX)
ADDPREPOSTREGVAR(RotateY)
ADDPREPOSTREGVAR(RotateZ)
ADDPREPOSTREGVAR(Flatten)
ADDPREPOSTREGVAR(Zblur)
ADDPREPOSTREGVAR(Blur3D)
ADDPREPOSTREGVAR(ZScale)
ADDPREPOSTREGVAR(ZTranslate)
ADDPREPOSTREGVAR(ZCone)
ADDPREPOSTREGVAR(MirrorX)
ADDPREPOSTREGVAR(MirrorY)
ADDPREPOSTREGVAR(MirrorZ)
ADDPREPOSTREGVAR(Depth)
ADDPREPOSTREGVAR(Spherical3D)
ADDPREPOSTREGVAR(RBlur)
ADDPREPOSTREGVAR(JuliaNab)
ADDPREPOSTREGVAR(Sintrange)
ADDPREPOSTREGVAR(Voron)
ADDPREPOSTREGVAR(Waffle)
ADDPREPOSTREGVAR(Square3D)
ADDPREPOSTREGVAR(SuperShape3D)
ADDPREPOSTREGVAR(Sphyp3D)
ADDPREPOSTREGVAR(Circlecrop)
ADDPREPOSTREGVAR(Julian3Dx)
ADDPREPOSTREGVAR(Fourth)
ADDPREPOSTREGVAR(Mobiq)
ADDPREPOSTREGVAR(Spherivoid)
ADDPREPOSTREGVAR(Farblur)
ADDPREPOSTREGVAR(CurlSP)
ADDPREPOSTREGVAR(Heat)
ADDPREPOSTREGVAR(Interference2)
ADDPREPOSTREGVAR(Sinq)
ADDPREPOSTREGVAR(Sinhq)
ADDPREPOSTREGVAR(Secq)
ADDPREPOSTREGVAR(Sechq)
ADDPREPOSTREGVAR(Tanq)
ADDPREPOSTREGVAR(Tanhq)
ADDPREPOSTREGVAR(Cosq)
ADDPREPOSTREGVAR(Coshq)
ADDPREPOSTREGVAR(Cotq)
ADDPREPOSTREGVAR(Cothq)
ADDPREPOSTREGVAR(Cscq)
ADDPREPOSTREGVAR(Cschq)
ADDPREPOSTREGVAR(Estiq)
ADDPREPOSTREGVAR(Loq)
ADDPREPOSTREGVAR(Curvature)
ADDPREPOSTREGVAR(Qode)
ADDPREPOSTREGVAR(BlurHeart)
ADDPREPOSTREGVAR(Truchet)
ADDPREPOSTREGVAR(Gdoffs)
ADDPREPOSTREGVAR(Octagon)
ADDPREPOSTREGVAR(Trade)
ADDPREPOSTREGVAR(Juliac)
ADDPREPOSTREGVAR(Blade3D)
ADDPREPOSTREGVAR(Blob3D)
ADDPREPOSTREGVAR(Blocky)
ADDPREPOSTREGVAR(Bubble2)
ADDPREPOSTREGVAR(CircleLinear)
ADDPREPOSTREGVAR(CircleRand)
ADDPREPOSTREGVAR(CircleTrans1)
ADDPREPOSTREGVAR(Cubic3D)
ADDPREPOSTREGVAR(CubicLattice3D)
ADDPREPOSTREGVAR(Foci3D)
ADDPREPOSTREGVAR(Ho)
ADDPREPOSTREGVAR(Julia3Dq)
ADDPREPOSTREGVAR(Line)
ADDPREPOSTREGVAR(Loonie2)
ADDPREPOSTREGVAR(Loonie3)
ADDPREPOSTREGVAR(Loonie3D)
ADDPREPOSTREGVAR(Mcarpet)
ADDPREPOSTREGVAR(Waves23D)
ADDPREPOSTREGVAR(Pie3D)
ADDPREPOSTREGVAR(Popcorn23D)
ADDPREPOSTREGVAR(Sinusoidal3D)
ADDPREPOSTREGVAR(Scry3D)
ADDPREPOSTREGVAR(Shredlin)
ADDPREPOSTREGVAR(SplitBrdr)
ADDPREPOSTREGVAR(Wdisc)
ADDPREPOSTREGVAR(Falloff)
ADDPREPOSTREGVAR(Falloff2)
ADDPREPOSTREGVAR(Falloff3)
ADDPREPOSTREGVAR(Xtrb)
ADDPREPOSTREGVAR(Hexaplay3D)
ADDPREPOSTREGVAR(Hexnix3D)
ADDPREPOSTREGVAR(Hexcrop)
ADDPREPOSTREGVAR(Hexes)
ADDPREPOSTREGVAR(Nblur)
ADDPREPOSTREGVAR(Octapol)
ADDPREPOSTREGVAR(Crob)
ADDPREPOSTREGVAR(BubbleT3D)
ADDPREPOSTREGVAR(Synth)
ADDPREPOSTREGVAR(Crackle)
m_Variations.push_back(new PostSmartcropVariation<T>());//Post only
ADDPREPOSTREGVAR(Xerf)
ADDPREPOSTREGVAR(Erf)
ADDPREPOSTREGVAR(W)
ADDPREPOSTREGVAR(X)
ADDPREPOSTREGVAR(Y)
ADDPREPOSTREGVAR(Z)
ADDPREPOSTREGVAR(Splits3D)
ADDPREPOSTREGVAR(Waves2B)
ADDPREPOSTREGVAR(JacCn)
ADDPREPOSTREGVAR(JacDn)
ADDPREPOSTREGVAR(JacSn)
ADDPREPOSTREGVAR(PressureWave)
ADDPREPOSTREGVAR(Gamma)
ADDPREPOSTREGVAR(PRose3D)
ADDPREPOSTREGVAR(LogDB)
//ADDPREPOSTREGVAR(LinearXZ)
//ADDPREPOSTREGVAR(LinearYZ)
//DC are special.
ADDPREPOSTREGVAR(DCBubble)
ADDPREPOSTREGVAR(DCCarpet)
ADDPREPOSTREGVAR(DCCube)
ADDPREPOSTREGVAR(DCCylinder)
ADDPREPOSTREGVAR(DCGridOut)
ADDPREPOSTREGVAR(DCLinear)
ADDPREPOSTREGVAR(DCPerlin)
ADDPREPOSTREGVAR(DCTriangle)
ADDPREPOSTREGVAR(DCZTransl)
for (auto var : m_Variations) var->Precalc();
std::sort(m_Variations.begin(), m_Variations.end(), [&](const Variation<T>* var1, const Variation<T>* var2) { return var1->VariationId() < var2->VariationId(); });
m_RegVariations.reserve(m_Variations.size() / 3);
m_PreVariations.reserve(m_Variations.size() / 3);
m_PostVariations.reserve(m_Variations.size() / 3);
m_ParametricVariations.reserve(size_t(m_Variations.size() * .90));//This is a rough guess at how many are parametric.
//Place pointers to variations in vectors specific to their type.
//Many of the elements in m_ParametricVariations will be present in the reg, pre and post vectors.
//Note that these are not new copies, rather just pointers to the original instances in m_Variations.
for (auto var : m_Variations)
{
if (var->VarType() == eVariationType::VARTYPE_REG)
m_RegVariations.push_back(var);
else if (var->VarType() == eVariationType::VARTYPE_PRE)
m_PreVariations.push_back(var);
else if (var->VarType() == eVariationType::VARTYPE_POST)
m_PostVariations.push_back(var);
if (auto parVar = dynamic_cast<ParametricVariation<T>*>(var))
m_ParametricVariations.push_back(parVar);
}
}
/// <summary>
/// Delete each element of the list.
/// </summary>
template <typename T>
VariationList<T>::~VariationList()
{
ClearVec(m_Variations);//No need to delete parametric because they point to the entries in original vector.
}
/// <summary>
/// Get a pointer to the variation at the specified index.
/// </summary>
/// <param name="index">The index in the list to retrieve</param>
/// <returns>A pointer to the variation at the index if in range, else nullptr.</returns>
template <typename T>
const Variation<T>* VariationList<T>::GetVariation(size_t index) const { return index < m_Variations.size() ? m_Variations[index] : nullptr; }
/// <summary>
/// Get a pointer to the variation of a specified type at the specified index.
/// </summary>
/// <param name="index">The index in the list to retrieve</param>
/// <param name="varType">The type of variation to retrieve</param>
/// <returns>A pointer to the variation of the specified type at the index if in range, else nullptr.</returns>
template <typename T>
const Variation<T>* VariationList<T>::GetVariation(size_t index, eVariationType varType) const
{
switch (varType)
{
case eVariationType::VARTYPE_REG:
return index < m_RegVariations.size() ? m_RegVariations[index] : nullptr;
break;
case eVariationType::VARTYPE_PRE:
return index < m_PreVariations.size() ? m_PreVariations[index] : nullptr;
break;
case eVariationType::VARTYPE_POST:
return index < m_PostVariations.size() ? m_PostVariations[index] : nullptr;
break;
default:
return nullptr;
break;
}
}
/// <summary>
/// Gets a pointer to a copy of the variation at the specified index.
/// Optionally specify a weight to assign the new copy.
/// </summary>
/// <param name="index">The index in the list to make a copy of</param>
/// <param name="weight">The weight to assign the new copy. Default: 1</param>
/// <returns>A pointer to the variation at the index if in range, else nullptr.</returns>
template <typename T>
Variation<T>* VariationList<T>::GetVariationCopy(size_t index, T weight = 1) const { return MakeCopyWithWeight(GetVariation(index), weight); }
template <typename T>
Variation<T>* VariationList<T>::GetVariationCopy(size_t index, eVariationType varType, T weight = 1) const { return MakeCopyWithWeight(GetVariation(index, varType), weight); }
/// <summary>
/// Get a pointer to the variation with the specified ID.
/// </summary>
/// <param name="id">The ID to search for</param>
/// <returns>A pointer to the variation if found, else nullptr.</returns>
template <typename T>
const Variation<T>* VariationList<T>::GetVariation(eVariationId id) const
{
for (auto var : m_Variations)
if (var && id == var->VariationId())
return var;
return nullptr;
}
/// <summary>
/// Gets a pointer to a copy of the variation with the specified ID.
/// Optionally specify a weight to assign the new copy.
/// </summary>
/// <param name="id">The id of the variation in the list to make a copy of</param>
/// <param name="weight">The weight to assign the new copy. Default: 1</param>
/// <returns>A pointer to the variation with a matching ID, else nullptr.</returns>
template <typename T>
Variation<T>* VariationList<T>::GetVariationCopy(eVariationId id, T weight = 1) const { return MakeCopyWithWeight(GetVariation(id), weight); }
/// <summary>
/// Get a pointer to the variation with the specified name.
/// </summary>
/// <param name="name">The name to search for</param>
/// <returns>A pointer to the variation if found, else nullptr.</returns>
template <typename T>
const Variation<T>* VariationList<T>::GetVariation(const string& name) const
{
for (auto var : m_Variations)
if (var && !_stricmp(name.c_str(), var->Name().c_str()))
return var;
return nullptr;
}
/// <summary>
/// Gets a pointer to a copy of the variation with the specified name.
/// Optionally specify a weight to assign the new copy.
/// </summary>
/// <param name="name">The name of the variation in the list to make a copy of</param>
/// <param name="weight">The weight to assign the new copy. Default: 1</param>
/// <returns>A pointer to the variation with a matching name, else nullptr.</returns>
template <typename T>
Variation<T>* VariationList<T>::GetVariationCopy(const string& name, T weight = 1) const { return MakeCopyWithWeight(GetVariation(name), weight); }
/// <summary>
/// Get a parametric variation at the specified index.
/// Note this is the index in the parametric variations list, not in the master list.
/// </summary>
/// <param name="index">The index in the parametric variations list to retrieve</param>
/// <returns>The parametric variation at the index specified if in range, else nullptr.</returns>
template <typename T>
const ParametricVariation<T>* VariationList<T>::GetParametricVariation(size_t index) const { return index < m_ParametricVariations.size() ? m_ParametricVariations[index] : nullptr; }
/// <summary>
/// Get a parametric variation with the specified name.
/// </summary>
/// <param name="name">The name of the variation in the parametric variations list to retrieve</param>
/// <returns>The parametric variation with a matching name, else nullptr.</returns>
template <typename T>
const ParametricVariation<T>* VariationList<T>::GetParametricVariation(const string& name) const
{
for (auto var : m_ParametricVariations)
if (var && !_stricmp(name.c_str(), var->Name().c_str()))
return var;
return nullptr;
}
template <typename T>
ParametricVariation<T>* VariationList<T>::GetParametricVariationCopy(eVariationId id, T weight) const
{
return dynamic_cast<ParametricVariation<T>*>(MakeCopyWithWeight(GetVariation(id), weight));
}
/// <summary>
/// Get the index of the variation with the specified name.
/// </summary>
/// <param name="name">The name of the variation whose index is returned</param>
/// <returns>The index of the variation with the matching name, else -1</returns>
template <typename T>
int VariationList<T>::GetVariationIndex(const string& name) const
{
for (size_t i = 0; i < m_Variations.size() && m_Variations[i]; i++)
if (!_stricmp(name.c_str(), m_Variations[i]->Name().c_str()))
return int(i);
return -1;
}
/// <summary>
/// Accessors.
/// </summary>
template <typename T> size_t VariationList<T>::Size() const { return m_Variations.size(); }
template <typename T> size_t VariationList<T>::RegSize() const { return m_RegVariations.size(); }
template <typename T> size_t VariationList<T>::PreSize() const { return m_PreVariations.size(); }
template <typename T> size_t VariationList<T>::PostSize() const { return m_PostVariations.size(); }
template <typename T> size_t VariationList<T>::ParametricSize() const { return m_ParametricVariations.size(); }
template <typename T> const vector<Variation<T>*>& VariationList<T>::AllVars() const { return m_Variations; }
template <typename T> const vector<Variation<T>*>& VariationList<T>::RegVars() const { return m_RegVariations; }
template <typename T> const vector<Variation<T>*>& VariationList<T>::PreVars() const { return m_PreVariations; }
template <typename T> const vector<Variation<T>*>& VariationList<T>::PostVars() const { return m_PostVariations; }
/// <summary>
/// Make a dyncamically allocated copy of a variation and assign it a specified weight.
/// Return a pointer to the new copy.
/// </summary>
/// <param name="var">The variation to copy</param>
/// <param name="weight">The weight to assign it</param>
/// <returns>A pointer to the new variation copy if success, else nullptr.</returns>
template <typename T>
Variation<T>* VariationList<T>::MakeCopyWithWeight(const Variation<T>* var, T weight) const
{
if (var)
{
auto var2 = var->Copy();
var2->m_Weight = weight;
return var2;
}
return nullptr;
}
//This class was implemented in a cpp file to avoid exposing so many variation classes.
//So the explicit instantiation must be declared here rather than in Ember.cpp where
//all of the other classes are done.
template EMBER_API class VariationList<float>;
#ifdef DO_DOUBLE
template EMBER_API class VariationList<double>;
#endif
}

583
Source/Ember/VariationList.h
View File

@ -1,13 +1,6 @@
#pragma once
#include "Variations01.h"
#include "Variations02.h"
#include "Variations03.h"
#include "Variations04.h"
#include "Variations05.h"
#include "Variations06.h"
#include "Variations07.h"
#include "VariationsDC.h"
#include "Variation.h"
/// <summary>
/// VariationList class.
@ -20,562 +13,44 @@ namespace EmberNs
/// of specific ones. This class holds a list of pointers to variation objects for every
/// variation available. Similar to the PaletteList class, a caller can look up a variation
/// by name or ID and retrieve a copy of it.
/// This class follows the singleton pattern.
/// All variations are deleted upon destruction.
/// Template argument expected to be float or double.
/// </summary>
template <typename T>
class EMBER_API VariationList
{
#define ADDPREPOSTREGVAR(varName) \
m_Variations.push_back(new varName##Variation<T>()); \
m_Variations.push_back(new Pre##varName##Variation<T>()); \
m_Variations.push_back(new Post##varName##Variation<T>());
public:
/// <summary>
/// Constructor which initializes all of the variation objects and stores them in the list.
/// </summary>
VariationList()
{
m_Variations.reserve(size_t(eVariationId::LAST_VAR));
ADDPREPOSTREGVAR(Linear)
ADDPREPOSTREGVAR(Sinusoidal)
ADDPREPOSTREGVAR(Spherical)
ADDPREPOSTREGVAR(Swirl)
ADDPREPOSTREGVAR(Horseshoe)
ADDPREPOSTREGVAR(Polar)
ADDPREPOSTREGVAR(Handkerchief)
ADDPREPOSTREGVAR(Heart)
ADDPREPOSTREGVAR(Disc)
ADDPREPOSTREGVAR(Spiral)
ADDPREPOSTREGVAR(Hyperbolic)
ADDPREPOSTREGVAR(Diamond)
ADDPREPOSTREGVAR(Ex)
ADDPREPOSTREGVAR(Julia)
ADDPREPOSTREGVAR(Bent)
ADDPREPOSTREGVAR(Waves)
ADDPREPOSTREGVAR(Fisheye)
ADDPREPOSTREGVAR(Popcorn)
ADDPREPOSTREGVAR(Exponential)
ADDPREPOSTREGVAR(Power)
ADDPREPOSTREGVAR(Cosine)
ADDPREPOSTREGVAR(Rings)
ADDPREPOSTREGVAR(Fan)
ADDPREPOSTREGVAR(Blob)
ADDPREPOSTREGVAR(Pdj)
ADDPREPOSTREGVAR(Fan2)
ADDPREPOSTREGVAR(Rings2)
ADDPREPOSTREGVAR(Eyefish)
ADDPREPOSTREGVAR(Bubble)
ADDPREPOSTREGVAR(Cylinder)
ADDPREPOSTREGVAR(Perspective)
ADDPREPOSTREGVAR(Noise)
ADDPREPOSTREGVAR(JuliaNGeneric)
ADDPREPOSTREGVAR(JuliaScope)
ADDPREPOSTREGVAR(Blur)
ADDPREPOSTREGVAR(GaussianBlur)
ADDPREPOSTREGVAR(RadialBlur)
ADDPREPOSTREGVAR(Pie)
ADDPREPOSTREGVAR(Ngon)
ADDPREPOSTREGVAR(Curl)
ADDPREPOSTREGVAR(Rectangles)
ADDPREPOSTREGVAR(Arch)
ADDPREPOSTREGVAR(Tangent)
ADDPREPOSTREGVAR(Square)
ADDPREPOSTREGVAR(Rays)
ADDPREPOSTREGVAR(Blade)
ADDPREPOSTREGVAR(Secant2)
ADDPREPOSTREGVAR(TwinTrian)
ADDPREPOSTREGVAR(Cross)
ADDPREPOSTREGVAR(Disc2)
ADDPREPOSTREGVAR(SuperShape)
ADDPREPOSTREGVAR(Flower)
ADDPREPOSTREGVAR(Conic)
ADDPREPOSTREGVAR(Parabola)
ADDPREPOSTREGVAR(Bent2)
ADDPREPOSTREGVAR(Bipolar)
ADDPREPOSTREGVAR(Boarders)
ADDPREPOSTREGVAR(Butterfly)
ADDPREPOSTREGVAR(Cell)
ADDPREPOSTREGVAR(Cpow)
ADDPREPOSTREGVAR(Curve)
ADDPREPOSTREGVAR(Edisc)
ADDPREPOSTREGVAR(Elliptic)
ADDPREPOSTREGVAR(Escher)
ADDPREPOSTREGVAR(Foci)
ADDPREPOSTREGVAR(LazySusan)
ADDPREPOSTREGVAR(Loonie)
ADDPREPOSTREGVAR(Modulus)
ADDPREPOSTREGVAR(Oscilloscope)
ADDPREPOSTREGVAR(Polar2)
ADDPREPOSTREGVAR(Popcorn2)
ADDPREPOSTREGVAR(Scry)
ADDPREPOSTREGVAR(Separation)
ADDPREPOSTREGVAR(Split)
ADDPREPOSTREGVAR(Splits)
ADDPREPOSTREGVAR(Stripes)
ADDPREPOSTREGVAR(Wedge)
ADDPREPOSTREGVAR(WedgeJulia)
ADDPREPOSTREGVAR(WedgeSph)
ADDPREPOSTREGVAR(Whorl)
ADDPREPOSTREGVAR(Waves2)
ADDPREPOSTREGVAR(Exp)
ADDPREPOSTREGVAR(Log)
ADDPREPOSTREGVAR(Sin)
ADDPREPOSTREGVAR(Cos)
ADDPREPOSTREGVAR(Tan)
ADDPREPOSTREGVAR(Sec)
ADDPREPOSTREGVAR(Csc)
ADDPREPOSTREGVAR(Cot)
ADDPREPOSTREGVAR(Sinh)
ADDPREPOSTREGVAR(Cosh)
ADDPREPOSTREGVAR(Tanh)
ADDPREPOSTREGVAR(Sech)
ADDPREPOSTREGVAR(Csch)
ADDPREPOSTREGVAR(Coth)
ADDPREPOSTREGVAR(Auger)
ADDPREPOSTREGVAR(Flux)
ADDPREPOSTREGVAR(Hemisphere)
ADDPREPOSTREGVAR(Epispiral)
ADDPREPOSTREGVAR(Bwraps)
ADDPREPOSTREGVAR(BlurCircle)
ADDPREPOSTREGVAR(BlurZoom)
ADDPREPOSTREGVAR(BlurPixelize)
ADDPREPOSTREGVAR(Crop)
ADDPREPOSTREGVAR(BCircle)
ADDPREPOSTREGVAR(BlurLinear)
ADDPREPOSTREGVAR(BlurSquare)
ADDPREPOSTREGVAR(Boarders2)
ADDPREPOSTREGVAR(Cardioid)
ADDPREPOSTREGVAR(Checks)
ADDPREPOSTREGVAR(Circlize)
ADDPREPOSTREGVAR(Circlize2)
ADDPREPOSTREGVAR(CosWrap)
ADDPREPOSTREGVAR(DeltaA)
ADDPREPOSTREGVAR(Expo)
ADDPREPOSTREGVAR(Extrude)
ADDPREPOSTREGVAR(FDisc)
ADDPREPOSTREGVAR(Fibonacci)
ADDPREPOSTREGVAR(Fibonacci2)
ADDPREPOSTREGVAR(Glynnia)
ADDPREPOSTREGVAR(GridOut)
ADDPREPOSTREGVAR(Hole)
ADDPREPOSTREGVAR(Hypertile)
ADDPREPOSTREGVAR(Hypertile1)
ADDPREPOSTREGVAR(Hypertile2)
ADDPREPOSTREGVAR(Hypertile3D)
ADDPREPOSTREGVAR(Hypertile3D1)
ADDPREPOSTREGVAR(Hypertile3D2)
ADDPREPOSTREGVAR(IDisc)
ADDPREPOSTREGVAR(Julian2)
ADDPREPOSTREGVAR(JuliaQ)
ADDPREPOSTREGVAR(Murl)
ADDPREPOSTREGVAR(Murl2)
ADDPREPOSTREGVAR(NPolar)
ADDPREPOSTREGVAR(Ortho)
ADDPREPOSTREGVAR(Poincare)
ADDPREPOSTREGVAR(Poincare3D)
ADDPREPOSTREGVAR(Polynomial)
ADDPREPOSTREGVAR(PSphere)
ADDPREPOSTREGVAR(Rational3)
ADDPREPOSTREGVAR(Ripple)
ADDPREPOSTREGVAR(Sigmoid)
ADDPREPOSTREGVAR(SinusGrid)
ADDPREPOSTREGVAR(Stwin)
ADDPREPOSTREGVAR(TwoFace)
ADDPREPOSTREGVAR(Unpolar)
ADDPREPOSTREGVAR(WavesN)
ADDPREPOSTREGVAR(XHeart)
ADDPREPOSTREGVAR(Barycentroid)
ADDPREPOSTREGVAR(BiSplit)
ADDPREPOSTREGVAR(Crescents)
ADDPREPOSTREGVAR(Mask)
ADDPREPOSTREGVAR(Cpow2)
ADDPREPOSTREGVAR(Curl3D)
ADDPREPOSTREGVAR(Disc3D)
ADDPREPOSTREGVAR(Funnel)
ADDPREPOSTREGVAR(Linear3D)
ADDPREPOSTREGVAR(PowBlock)
ADDPREPOSTREGVAR(Squirrel)
ADDPREPOSTREGVAR(Ennepers)
ADDPREPOSTREGVAR(SphericalN)
ADDPREPOSTREGVAR(Kaleidoscope)
ADDPREPOSTREGVAR(GlynnSim1)
ADDPREPOSTREGVAR(GlynnSim2)
ADDPREPOSTREGVAR(GlynnSim3)
ADDPREPOSTREGVAR(Starblur)
ADDPREPOSTREGVAR(Sineblur)
ADDPREPOSTREGVAR(Circleblur)
ADDPREPOSTREGVAR(CropN)
ADDPREPOSTREGVAR(ShredRad)
ADDPREPOSTREGVAR(Blob2)
ADDPREPOSTREGVAR(Julia3D)
ADDPREPOSTREGVAR(Julia3Dz)
ADDPREPOSTREGVAR(LinearT)
ADDPREPOSTREGVAR(LinearT3D)
ADDPREPOSTREGVAR(Ovoid)
ADDPREPOSTREGVAR(Ovoid3D)
ADDPREPOSTREGVAR(Spirograph)
ADDPREPOSTREGVAR(Petal)
ADDPREPOSTREGVAR(RoundSpher)
ADDPREPOSTREGVAR(RoundSpher3D)
ADDPREPOSTREGVAR(SpiralWing)
ADDPREPOSTREGVAR(Squarize)
ADDPREPOSTREGVAR(Sschecks)
ADDPREPOSTREGVAR(PhoenixJulia)
ADDPREPOSTREGVAR(Mobius)
ADDPREPOSTREGVAR(MobiusN)
ADDPREPOSTREGVAR(MobiusStrip)
ADDPREPOSTREGVAR(Lissajous)
ADDPREPOSTREGVAR(Svf)
ADDPREPOSTREGVAR(Target)
ADDPREPOSTREGVAR(Taurus)
ADDPREPOSTREGVAR(Collideoscope)
ADDPREPOSTREGVAR(BMod)
ADDPREPOSTREGVAR(BSwirl)
ADDPREPOSTREGVAR(BTransform)
ADDPREPOSTREGVAR(BCollide)
ADDPREPOSTREGVAR(Eclipse)
ADDPREPOSTREGVAR(FlipCircle)
ADDPREPOSTREGVAR(FlipY)
ADDPREPOSTREGVAR(ECollide)
ADDPREPOSTREGVAR(EJulia)
ADDPREPOSTREGVAR(EMod)
ADDPREPOSTREGVAR(EMotion)
ADDPREPOSTREGVAR(EPush)
ADDPREPOSTREGVAR(ERotate)
ADDPREPOSTREGVAR(EScale)
ADDPREPOSTREGVAR(ESwirl)
ADDPREPOSTREGVAR(LazyTravis)
ADDPREPOSTREGVAR(Squish)
ADDPREPOSTREGVAR(Circus)
ADDPREPOSTREGVAR(Tancos)
ADDPREPOSTREGVAR(Rippled)
ADDPREPOSTREGVAR(RotateX)
ADDPREPOSTREGVAR(RotateY)
ADDPREPOSTREGVAR(RotateZ)
ADDPREPOSTREGVAR(Flatten)
ADDPREPOSTREGVAR(Zblur)
ADDPREPOSTREGVAR(Blur3D)
ADDPREPOSTREGVAR(ZScale)
ADDPREPOSTREGVAR(ZTranslate)
ADDPREPOSTREGVAR(ZCone)
ADDPREPOSTREGVAR(MirrorX)
ADDPREPOSTREGVAR(MirrorY)
ADDPREPOSTREGVAR(MirrorZ)
ADDPREPOSTREGVAR(Depth)
ADDPREPOSTREGVAR(Spherical3D)
ADDPREPOSTREGVAR(RBlur)
ADDPREPOSTREGVAR(JuliaNab)
ADDPREPOSTREGVAR(Sintrange)
ADDPREPOSTREGVAR(Voron)
ADDPREPOSTREGVAR(Waffle)
ADDPREPOSTREGVAR(Square3D)
ADDPREPOSTREGVAR(SuperShape3D)
ADDPREPOSTREGVAR(Sphyp3D)
ADDPREPOSTREGVAR(Circlecrop)
ADDPREPOSTREGVAR(Julian3Dx)
ADDPREPOSTREGVAR(Fourth)
ADDPREPOSTREGVAR(Mobiq)
ADDPREPOSTREGVAR(Spherivoid)
ADDPREPOSTREGVAR(Farblur)
ADDPREPOSTREGVAR(CurlSP)
ADDPREPOSTREGVAR(Heat)
ADDPREPOSTREGVAR(Interference2)
ADDPREPOSTREGVAR(Sinq)
ADDPREPOSTREGVAR(Sinhq)
ADDPREPOSTREGVAR(Secq)
ADDPREPOSTREGVAR(Sechq)
ADDPREPOSTREGVAR(Tanq)
ADDPREPOSTREGVAR(Tanhq)
ADDPREPOSTREGVAR(Cosq)
ADDPREPOSTREGVAR(Coshq)
ADDPREPOSTREGVAR(Cotq)
ADDPREPOSTREGVAR(Cothq)
ADDPREPOSTREGVAR(Cscq)
ADDPREPOSTREGVAR(Cschq)
ADDPREPOSTREGVAR(Estiq)
ADDPREPOSTREGVAR(Loq)
ADDPREPOSTREGVAR(Curvature)
ADDPREPOSTREGVAR(Qode)
ADDPREPOSTREGVAR(BlurHeart)
ADDPREPOSTREGVAR(Truchet)
ADDPREPOSTREGVAR(Gdoffs)
ADDPREPOSTREGVAR(Octagon)
ADDPREPOSTREGVAR(Trade)
ADDPREPOSTREGVAR(Juliac)
ADDPREPOSTREGVAR(Blade3D)
ADDPREPOSTREGVAR(Blob3D)
ADDPREPOSTREGVAR(Blocky)
ADDPREPOSTREGVAR(Bubble2)
ADDPREPOSTREGVAR(CircleLinear)
ADDPREPOSTREGVAR(CircleRand)
ADDPREPOSTREGVAR(CircleTrans1)
ADDPREPOSTREGVAR(Cubic3D)
ADDPREPOSTREGVAR(CubicLattice3D)
ADDPREPOSTREGVAR(Foci3D)
ADDPREPOSTREGVAR(Ho)
ADDPREPOSTREGVAR(Julia3Dq)
ADDPREPOSTREGVAR(Line)
ADDPREPOSTREGVAR(Loonie2)
ADDPREPOSTREGVAR(Loonie3)
ADDPREPOSTREGVAR(Loonie3D)
ADDPREPOSTREGVAR(Mcarpet)
ADDPREPOSTREGVAR(Waves23D)
ADDPREPOSTREGVAR(Pie3D)
ADDPREPOSTREGVAR(Popcorn23D)
ADDPREPOSTREGVAR(Sinusoidal3D)
ADDPREPOSTREGVAR(Scry3D)
ADDPREPOSTREGVAR(Shredlin)
ADDPREPOSTREGVAR(SplitBrdr)
ADDPREPOSTREGVAR(Wdisc)
ADDPREPOSTREGVAR(Falloff)
ADDPREPOSTREGVAR(Falloff2)
ADDPREPOSTREGVAR(Falloff3)
ADDPREPOSTREGVAR(Xtrb)
ADDPREPOSTREGVAR(Hexaplay3D)
ADDPREPOSTREGVAR(Hexnix3D)
ADDPREPOSTREGVAR(Hexcrop)
ADDPREPOSTREGVAR(Hexes)
ADDPREPOSTREGVAR(Nblur)
ADDPREPOSTREGVAR(Octapol)
ADDPREPOSTREGVAR(Crob)
ADDPREPOSTREGVAR(BubbleT3D)
ADDPREPOSTREGVAR(Synth)
ADDPREPOSTREGVAR(Crackle)
m_Variations.push_back(new PostSmartcropVariation<T>());//Post only
ADDPREPOSTREGVAR(Xerf)
ADDPREPOSTREGVAR(Erf)
ADDPREPOSTREGVAR(W)
ADDPREPOSTREGVAR(X)
ADDPREPOSTREGVAR(Y)
ADDPREPOSTREGVAR(Z)
ADDPREPOSTREGVAR(Splits3D)
ADDPREPOSTREGVAR(Waves2B)
ADDPREPOSTREGVAR(JacCn)
ADDPREPOSTREGVAR(JacDn)
ADDPREPOSTREGVAR(JacSn)
ADDPREPOSTREGVAR(PressureWave)
ADDPREPOSTREGVAR(Gamma)
ADDPREPOSTREGVAR(PRose3D)
ADDPREPOSTREGVAR(LogDB)
//ADDPREPOSTREGVAR(LinearXZ)
//ADDPREPOSTREGVAR(LinearYZ)
//DC are special.
ADDPREPOSTREGVAR(DCBubble)
ADDPREPOSTREGVAR(DCCarpet)
ADDPREPOSTREGVAR(DCCube)
ADDPREPOSTREGVAR(DCCylinder)
ADDPREPOSTREGVAR(DCGridOut)
ADDPREPOSTREGVAR(DCLinear)
ADDPREPOSTREGVAR(DCPerlin)
ADDPREPOSTREGVAR(DCTriangle)
ADDPREPOSTREGVAR(DCZTransl)
static VariationList<T>& Instance();
~VariationList();
VariationList<T>(const VariationList<T>& varList) = delete;
VariationList<T>& operator = (const VariationList<T>& varList) = delete;
const Variation<T>* GetVariation(size_t index) const;
const Variation<T>* GetVariation(size_t index, eVariationType varType) const;
Variation<T>* GetVariationCopy(size_t index, T weight = 1) const;
Variation<T>* GetVariationCopy(size_t index, eVariationType varType, T weight = 1) const;
const Variation<T>* GetVariation(eVariationId id) const;
Variation<T>* GetVariationCopy(eVariationId id, T weight = 1) const;
const Variation<T>* GetVariation(const string& name) const;
Variation<T>* GetVariationCopy(const string& name, T weight = 1) const;
const ParametricVariation<T>* GetParametricVariation(size_t index) const;
const ParametricVariation<T>* GetParametricVariation(const string& name) const;
ParametricVariation<T>* GetParametricVariationCopy(eVariationId id, T weight = 1) const;
int GetVariationIndex(const string& name) const;
size_t Size() const;
size_t RegSize() const;
size_t PreSize() const;
size_t PostSize() const;
size_t ParametricSize() const;
for (auto var : m_Variations) var->Precalc();
std::sort(m_Variations.begin(), m_Variations.end(), [&](const Variation<T>* var1, const Variation<T>* var2) { return var1->VariationId() < var2->VariationId(); });
m_RegVariations.reserve(m_Variations.size() / 3);
m_PreVariations.reserve(m_Variations.size() / 3);
m_PostVariations.reserve(m_Variations.size() / 3);
m_ParametricVariations.reserve(size_t(m_Variations.size() * .90));//This is a rough guess at how many are parametric.
//Place pointers to variations in vectors specific to their type.
//Many of the elements in m_ParametricVariations will be present in the reg, pre and post vectors.
//Note that these are not new copies, rather just pointers to the original instances in m_Variations.
for (auto var : m_Variations)
{
if (var->VarType() == eVariationType::VARTYPE_REG)
m_RegVariations.push_back(var);
else if (var->VarType() == eVariationType::VARTYPE_PRE)
m_PreVariations.push_back(var);
else if (var->VarType() == eVariationType::VARTYPE_POST)
m_PostVariations.push_back(var);
if (auto parVar = dynamic_cast<ParametricVariation<T>*>(var))
m_ParametricVariations.push_back(parVar);
}
}
/// <summary>
/// Delete each element of the list.
/// </summary>
~VariationList()
{
ClearVec(m_Variations);//No need to delete parametric because they point to the entries in original vector.
}
/// <summary>
/// Get a pointer to the variation at the specified index.
/// </summary>
/// <param name="index">The index in the list to retrieve</param>
/// <returns>A pointer to the variation at the index if in range, else nullptr.</returns>
const Variation<T>* GetVariation(size_t index) const { return index < m_Variations.size() ? m_Variations[index] : nullptr; }
/// <summary>
/// Get a pointer to the variation of a specified type at the specified index.
/// </summary>
/// <param name="index">The index in the list to retrieve</param>
/// <param name="varType">The type of variation to retrieve</param>
/// <returns>A pointer to the variation of the specified type at the index if in range, else nullptr.</returns>
const Variation<T>* GetVariation(size_t index, eVariationType varType) const
{
switch (varType)
{
case eVariationType::VARTYPE_REG:
return index < m_RegVariations.size() ? m_RegVariations[index] : nullptr;
break;
case eVariationType::VARTYPE_PRE:
return index < m_PreVariations.size() ? m_PreVariations[index] : nullptr;
break;
case eVariationType::VARTYPE_POST:
return index < m_PostVariations.size() ? m_PostVariations[index] : nullptr;
break;
default:
return nullptr;
break;
}
}
/// <summary>
/// Gets a pointer to a copy of the variation at the specified index.
/// Optionally specify a weight to assign the new copy.
/// </summary>
/// <param name="index">The index in the list to make a copy of</param>
/// <param name="weight">The weight to assign the new copy. Default: 1</param>
/// <returns>A pointer to the variation at the index if in range, else nullptr.</returns>
Variation<T>* GetVariationCopy(size_t index, T weight = 1) const { return MakeCopyWithWeight(GetVariation(index), weight); }
Variation<T>* GetVariationCopy(size_t index, eVariationType varType, T weight = 1) const { return MakeCopyWithWeight(GetVariation(index, varType), weight); }
/// <summary>
/// Get a pointer to the variation with the specified ID.
/// </summary>
/// <param name="id">The ID to search for</param>
/// <returns>A pointer to the variation if found, else nullptr.</returns>
const Variation<T>* GetVariation(eVariationId id) const
{
for (auto var : m_Variations)
if (var && id == var->VariationId())
return var;
return nullptr;
}
/// <summary>
/// Gets a pointer to a copy of the variation with the specified ID.
/// Optionally specify a weight to assign the new copy.
/// </summary>
/// <param name="id">The id of the variation in the list to make a copy of</param>
/// <param name="weight">The weight to assign the new copy. Default: 1</param>
/// <returns>A pointer to the variation with a matching ID, else nullptr.</returns>
Variation<T>* GetVariationCopy(eVariationId id, T weight = 1) const { return MakeCopyWithWeight(GetVariation(id), weight); }
/// <summary>
/// Get a pointer to the variation with the specified name.
/// </summary>
/// <param name="name">The name to search for</param>
/// <returns>A pointer to the variation if found, else nullptr.</returns>
const Variation<T>* GetVariation(const string& name) const
{
for (auto var : m_Variations)
if (var && !_stricmp(name.c_str(), var->Name().c_str()))
return var;
return nullptr;
}
/// <summary>
/// Gets a pointer to a copy of the variation with the specified name.
/// Optionally specify a weight to assign the new copy.
/// </summary>
/// <param name="name">The name of the variation in the list to make a copy of</param>
/// <param name="weight">The weight to assign the new copy. Default: 1</param>
/// <returns>A pointer to the variation with a matching name, else nullptr.</returns>
Variation<T>* GetVariationCopy(const string& name, T weight = 1) const { return MakeCopyWithWeight(GetVariation(name), weight); }
/// <summary>
/// Get a parametric variation at the specified index.
/// Note this is the index in the parametric variations list, not in the master list.
/// </summary>
/// <param name="index">The index in the parametric variations list to retrieve</param>
/// <returns>The parametric variation at the index specified if in range, else nullptr.</returns>
const ParametricVariation<T>* GetParametricVariation(size_t index) const { return index < m_ParametricVariations.size() ? m_ParametricVariations[index] : nullptr; }
/// <summary>
/// Get a parametric variation with the specified name.
/// </summary>
/// <param name="name">The name of the variation in the parametric variations list to retrieve</param>
/// <returns>The parametric variation with a matching name, else nullptr.</returns>
const ParametricVariation<T>* GetParametricVariation(const string& name) const
{
for (auto var : m_ParametricVariations)
if (var && !_stricmp(name.c_str(), var->Name().c_str()))
return var;
return nullptr;
}
/// <summary>
/// Get the index of the variation with the specified name.
/// </summary>
/// <param name="name">The name of the variation whose index is returned</param>
/// <returns>The index of the variation with the matching name, else -1</returns>
int GetVariationIndex(const string& name)
{
for (size_t i = 0; i < m_Variations.size() && m_Variations[i]; i++)
if (!_stricmp(name.c_str(), m_Variations[i]->Name().c_str()))
return int(i);
return -1;
}
/// <summary>
/// Accessors.
/// </summary>
size_t Size() const { return m_Variations.size(); }
size_t RegSize() const { return m_RegVariations.size(); }
size_t PreSize() const { return m_PreVariations.size(); }
size_t PostSize() const { return m_PostVariations.size(); }
size_t ParametricSize() const { return m_ParametricVariations.size(); }
const vector<Variation<T>*>& AllVars() const { return m_Variations; }
const vector<Variation<T>*>& RegVars() const { return m_RegVariations; }
const vector<Variation<T>*>& PreVars() const { return m_PreVariations; }
const vector<Variation<T>*>& PostVars() const { return m_PostVariations; }
const vector<Variation<T>*>& AllVars() const;
const vector<Variation<T>*>& RegVars() const;
const vector<Variation<T>*>& PreVars() const;
const vector<Variation<T>*>& PostVars() const;
private:
/// <summary>
/// Make a dyncamically allocated copy of a variation and assign it a specified weight.
/// Return a pointer to the new copy.
/// </summary>
/// <param name="var">The variation to copy</param>
/// <param name="weight">The weight to assign it</param>
/// <returns>A pointer to the new variation copy if success, else nullptr.</returns>
Variation<T>* MakeCopyWithWeight(const Variation<T>* var, T weight) const
{
if (var)
{
auto var2 = var->Copy();
var2->m_Weight = weight;
return var2;
}
return nullptr;
}
/// <summary>
/// Assignment operator which does nothing since these are non-copyable.
/// Do not provide a copy constructor and ensure the assignment operator does nothing.
/// </summary>
/// <param name="varList">The VariationList object which won't be copied</param>
/// <returns>Reference to unchanged self</returns>
VariationList<T>& operator = (const VariationList<T>& varList)
{
return *this;
}
VariationList();
Variation<T>* MakeCopyWithWeight(const Variation<T>* var, T weight) const;
vector<Variation<T>*> m_Variations;//A list of pointers to dynamically allocated variation objects.
vector<Variation<T>*> m_RegVariations;

197
Source/Ember/Variations01.h
View File

@ -1,9 +1,12 @@
#pragma once
#include "Variation.h"
#include "Xform.h"
namespace EmberNs
{
//template <typename T> class Xform;
/// <summary>
/// Linear:
/// nx = tx;
@ -12,7 +15,7 @@ namespace EmberNs
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API LinearVariation : public Variation<T>
class LinearVariation : public Variation<T>
{
public:
LinearVariation(T weight = 1.0) : Variation<T>("linear", eVariationId::VAR_LINEAR, weight) { }
@ -47,7 +50,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API SinusoidalVariation : public Variation<T>
class SinusoidalVariation : public Variation<T>
{
public:
SinusoidalVariation(T weight = 1.0) : Variation<T>("sinusoidal", eVariationId::VAR_SINUSOIDAL, weight) { }
@ -83,7 +86,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <class T>
class EMBER_API SphericalVariation : public Variation<T>
class SphericalVariation : public Variation<T>
{
public:
SphericalVariation(T weight = 1.0) : Variation<T>("spherical", eVariationId::VAR_SPHERICAL, weight, true) { }
@ -129,7 +132,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API SwirlVariation : public Variation<T>
class SwirlVariation : public Variation<T>
{
public:
SwirlVariation(T weight = 1.0) : Variation<T>("swirl", eVariationId::VAR_SWIRL, weight, true) { }
@ -172,7 +175,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API HorseshoeVariation : public Variation<T>
class HorseshoeVariation : public Variation<T>
{
public:
HorseshoeVariation(T weight = 1.0) : Variation<T>("horseshoe", eVariationId::VAR_HORSESHOE, weight, true, true) { }
@ -215,7 +218,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API PolarVariation : public Variation<T>
class PolarVariation : public Variation<T>
{
public:
PolarVariation(T weight = 1.0) : Variation<T>("polar", eVariationId::VAR_POLAR, weight, true, true, false, true, false) { }
@ -250,7 +253,7 @@ public:
/// p[1] += weight * cos(a - r) * r;
/// </summary>
template <typename T>
class EMBER_API HandkerchiefVariation : public Variation<T>
class HandkerchiefVariation : public Variation<T>
{
public:
HandkerchiefVariation(T weight = 1.0) : Variation<T>("handkerchief", eVariationId::VAR_HANDKERCHIEF, weight, true, true, false, true) { }
@ -286,7 +289,7 @@ public:
/// p[1] += weight * cos(a) * -r;
/// </summary>
template <typename T>
class EMBER_API HeartVariation : public Variation<T>
class HeartVariation : public Variation<T>
{
public:
HeartVariation(T weight = 1.0) : Variation<T>("heart", eVariationId::VAR_HEART, weight, true, true, false, true) { }
@ -328,7 +331,7 @@ public:
/// p[1] += weight * cos(r) * a / M_PI;
/// </summary>
template <typename T>
class EMBER_API DiscVariation : public ParametricVariation<T>
class DiscVariation : public ParametricVariation<T>
{
public:
DiscVariation(T weight = 1.0) : ParametricVariation<T>("disc", eVariationId::VAR_DISC, weight, true, true, false, true)
@ -390,7 +393,7 @@ private:
/// p[1] += weight * (sin(a) - cos(r)) / r;
/// </summary>
template <typename T>
class EMBER_API SpiralVariation : public Variation<T>
class SpiralVariation : public Variation<T>
{
public:
SpiralVariation(T weight = 1.0) : Variation<T>("spiral", eVariationId::VAR_SPIRAL, weight, true, true, true) { }
@ -435,7 +438,7 @@ public:
/// p[1] += weight * cos(a) * r;
/// </summary>
template <typename T>
class EMBER_API HyperbolicVariation : public Variation<T>
class HyperbolicVariation : public Variation<T>
{
public:
HyperbolicVariation(T weight = 1.0) : Variation<T>("hyperbolic", eVariationId::VAR_HYPERBOLIC, weight, true, true, true) { }
@ -478,7 +481,7 @@ public:
/// p[1] += weight * cos(a) * sin(r);
/// </summary>
template <typename T>
class EMBER_API DiamondVariation : public Variation<T>
class DiamondVariation : public Variation<T>
{
public:
DiamondVariation(T weight = 1.0) : Variation<T>("diamond", eVariationId::VAR_DIAMOND, weight, true, true, true) { }
@ -517,7 +520,7 @@ public:
/// p[1] += weight * (m0 - m1);
/// </summary>
template <typename T>
class EMBER_API ExVariation : public Variation<T>
class ExVariation : public Variation<T>
{
public:
ExVariation(T weight = 1.0) : Variation<T>("ex", eVariationId::VAR_EX, weight, true, true, false, true) { }
@ -568,7 +571,7 @@ public:
/// p[1] += v * ny;
/// </summary>
template <typename T>
class EMBER_API JuliaVariation : public Variation<T>
class JuliaVariation : public Variation<T>
{
public:
JuliaVariation(T weight = 1.0) : Variation<T>("julia", eVariationId::VAR_JULIA, weight, true, true, false, true) { }
@ -617,7 +620,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API BentVariation : public Variation<T>
class BentVariation : public Variation<T>
{
public:
BentVariation(T weight = 1.0) : Variation<T>("bent", eVariationId::VAR_BENT, weight) { }
@ -660,7 +663,7 @@ public:
/// Special case here, use parametric for precalcs, but no regular params.
/// </summary>
template <typename T>
class EMBER_API WavesVariation : public ParametricVariation<T>
class WavesVariation : public ParametricVariation<T>
{
public:
WavesVariation(T weight = 1.0) : ParametricVariation<T>("waves", eVariationId::VAR_WAVES, weight)
@ -738,7 +741,7 @@ private:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API FisheyeVariation : public Variation<T>
class FisheyeVariation : public Variation<T>
{
public:
FisheyeVariation(T weight = 1.0) : Variation<T>("fisheye", eVariationId::VAR_FISHEYE, weight, true, true) { }
@ -778,7 +781,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API PopcornVariation : public Variation<T>
class PopcornVariation : public Variation<T>
{
public:
PopcornVariation(T weight = 1.0) : Variation<T>("popcorn", eVariationId::VAR_POPCORN, weight) { }
@ -824,7 +827,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API ExponentialVariation : public Variation<T>
class ExponentialVariation : public Variation<T>
{
public:
ExponentialVariation(T weight = 1.0) : Variation<T>("exponential", eVariationId::VAR_EXPONENTIAL, weight) { }
@ -868,7 +871,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API PowerVariation : public Variation<T>
class PowerVariation : public Variation<T>
{
public:
PowerVariation(T weight = 1.0) : Variation<T>("power", eVariationId::VAR_POWER, weight, true, true, true) { }
@ -906,7 +909,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API CosineVariation : public Variation<T>
class CosineVariation : public Variation<T>
{
public:
CosineVariation(T weight = 1.0) : Variation<T>("cosine", eVariationId::VAR_COSINE, weight) { }
@ -953,7 +956,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API RingsVariation : public Variation<T>
class RingsVariation : public Variation<T>
{
public:
RingsVariation(T weight = 1.0) : Variation<T>("rings", eVariationId::VAR_RINGS, weight, true, true, true) { }
@ -1007,7 +1010,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API FanVariation : public Variation<T>
class FanVariation : public Variation<T>
{
public:
FanVariation(T weight = 1.0) : Variation<T>("fan", eVariationId::VAR_FAN, weight, true, true, false, true) { }
@ -1063,7 +1066,7 @@ public:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API BlobVariation : public ParametricVariation<T>
class BlobVariation : public ParametricVariation<T>
{
public:
BlobVariation(T weight = 1.0) : ParametricVariation<T>("blob", eVariationId::VAR_BLOB, weight, true, true, true, true)
@ -1142,7 +1145,7 @@ private:
/// p[1] += weight * (nx2 - ny2);
/// </summary>
template <typename T>
class EMBER_API PdjVariation : public ParametricVariation<T>
class PdjVariation : public ParametricVariation<T>
{
public:
PdjVariation(T weight = 1.0) : ParametricVariation<T>("pdj", eVariationId::VAR_PDJ, weight)
@ -1235,7 +1238,7 @@ private:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API Fan2Variation : public ParametricVariation<T>
class Fan2Variation : public ParametricVariation<T>
{
public:
Fan2Variation(T weight = 1.0) : ParametricVariation<T>("fan2", eVariationId::VAR_FAN2, weight, true, true, false, true)
@ -1329,7 +1332,7 @@ private:
/// p[1] += weight * ny;
/// </summary>
template <typename T>
class EMBER_API Rings2Variation : public ParametricVariation<T>
class Rings2Variation : public ParametricVariation<T>
{
public:
Rings2Variation(T weight = 1.0) : ParametricVariation<T>("rings2", eVariationId::VAR_RINGS2, weight, true, true, true)
@ -1398,7 +1401,7 @@ private:
/// p[1] += r * ty;
/// </summary>
template <typename T>
class EMBER_API EyefishVariation : public Variation<T>
class EyefishVariation : public Variation<T>
{
public:
EyefishVariation(T weight = 1.0) : Variation<T>("eyefish", eVariationId::VAR_EYEFISH, weight, true, true) { }
@ -1432,7 +1435,7 @@ public:
/// Bubble.
/// </summary>
template <typename T>
class EMBER_API BubbleVariation : public Variation<T>
class BubbleVariation : public Variation<T>
{
public:
BubbleVariation(T weight = 1.0) : Variation<T>("bubble", eVariationId::VAR_BUBBLE, weight, true) { }
@ -1473,7 +1476,7 @@ public:
/// Cylinder.
/// </summary>
template <typename T>
class EMBER_API CylinderVariation : public Variation<T>
class CylinderVariation : public Variation<T>
{
public:
CylinderVariation(T weight = 1.0) : Variation<T>("cylinder", eVariationId::VAR_CYLINDER, weight) { }
@ -1504,7 +1507,7 @@ public:
/// Perspective.
/// </summary>
template <typename T>
class EMBER_API PerspectiveVariation : public ParametricVariation<T>
class PerspectiveVariation : public ParametricVariation<T>
{
public:
PerspectiveVariation(T weight = 1.0) : ParametricVariation<T>("perspective", eVariationId::VAR_PERSPECTIVE, weight)
@ -1584,7 +1587,7 @@ private:
/// Noise.
/// </summary>
template <typename T>
class EMBER_API NoiseVariation : public Variation<T>
class NoiseVariation : public Variation<T>
{
public:
NoiseVariation(T weight = 1.0) : Variation<T>("noise", eVariationId::VAR_NOISE, weight) { }
@ -1620,7 +1623,7 @@ public:
/// JuliaN.
/// </summary>
template <typename T>
class EMBER_API JuliaNGenericVariation : public ParametricVariation<T>
class JuliaNGenericVariation : public ParametricVariation<T>
{
public:
JuliaNGenericVariation(T weight = 1.0) : ParametricVariation<T>("julian", eVariationId::VAR_JULIAN, weight, true, false, false, false, true)
@ -1696,7 +1699,7 @@ private:
/// JuliaScope.
/// </summary>
template <typename T>
class EMBER_API JuliaScopeVariation : public ParametricVariation<T>
class JuliaScopeVariation : public ParametricVariation<T>
{
public:
JuliaScopeVariation(T weight = 1.0) : ParametricVariation<T>("juliascope", eVariationId::VAR_JULIASCOPE, weight, true, false, false, false, true)
@ -1810,7 +1813,7 @@ private:
/// If the original pre_blur functionality is needed, use pre_gaussian_blur.
/// </summary>
template <typename T>
class EMBER_API BlurVariation : public Variation<T>
class BlurVariation : public Variation<T>
{
public:
BlurVariation(T weight = 1.0) : Variation<T>("blur", eVariationId::VAR_BLUR, weight) { }
@ -1846,7 +1849,7 @@ public:
/// Gaussian blur.
/// </summary>
template <typename T>
class EMBER_API GaussianBlurVariation : public Variation<T>
class GaussianBlurVariation : public Variation<T>
{
public:
GaussianBlurVariation(T weight = 1.0) : Variation<T>("gaussian_blur", eVariationId::VAR_GAUSSIAN_BLUR, weight) { }
@ -1882,7 +1885,7 @@ public:
/// Radial blur.
/// </summary>
template <typename T>
class EMBER_API RadialBlurVariation : public ParametricVariation<T>
class RadialBlurVariation : public ParametricVariation<T>
{
public:
RadialBlurVariation(T weight = 1.0) : ParametricVariation<T>("radial_blur", eVariationId::VAR_RADIAL_BLUR, weight, true, true, false, false, true)
@ -1958,7 +1961,7 @@ private:
/// Pie.
/// </summary>
template <typename T>
class EMBER_API PieVariation : public ParametricVariation<T>
class PieVariation : public ParametricVariation<T>
{
public:
PieVariation(T weight = 1.0) : ParametricVariation<T>("pie", eVariationId::VAR_PIE, weight)
@ -2034,7 +2037,7 @@ private:
/// Ngon.
/// </summary>
template <typename T>
class EMBER_API NgonVariation : public ParametricVariation<T>
class NgonVariation : public ParametricVariation<T>
{
public:
NgonVariation(T weight = 1.0) : ParametricVariation<T>("ngon", eVariationId::VAR_NGON, weight, true, false, false, false, true)
@ -2145,7 +2148,7 @@ private:
/// curl code.
/// </summary>
template <typename T>
class EMBER_API CurlVariation : public ParametricVariation<T>
class CurlVariation : public ParametricVariation<T>
{
public:
CurlVariation(T weight = 1.0) : ParametricVariation<T>("curl", eVariationId::VAR_CURL, weight)
@ -2222,7 +2225,7 @@ private:
/// Rectangles.
/// </summary>
template <typename T>
class EMBER_API RectanglesVariation : public ParametricVariation<T>
class RectanglesVariation : public ParametricVariation<T>
{
public:
RectanglesVariation(T weight = 1.0) : ParametricVariation<T>("rectangles", eVariationId::VAR_RECTANGLES, weight)
@ -2295,7 +2298,7 @@ private:
/// Arch.
/// </summary>
template <typename T>
class EMBER_API ArchVariation : public Variation<T>
class ArchVariation : public Variation<T>
{
public:
ArchVariation(T weight = 1.0) : Variation<T>("arch", eVariationId::VAR_ARCH, weight) { }
@ -2333,7 +2336,7 @@ public:
/// Tangent.
/// </summary>
template <typename T>
class EMBER_API TangentVariation : public Variation<T>
class TangentVariation : public Variation<T>
{
public:
TangentVariation(T weight = 1.0) : Variation<T>("tangent", eVariationId::VAR_TANGENT, weight) { }
@ -2364,7 +2367,7 @@ public:
/// Square.
/// </summary>
template <typename T>
class EMBER_API SquareVariation : public Variation<T>
class SquareVariation : public Variation<T>
{
public:
SquareVariation(T weight = 1.0) : Variation<T>("square", eVariationId::VAR_SQUARE, weight) { }
@ -2395,7 +2398,7 @@ public:
/// Rays.
/// </summary>
template <typename T>
class EMBER_API RaysVariation : public Variation<T>
class RaysVariation : public Variation<T>
{
public:
RaysVariation(T weight = 1.0) : Variation<T>("rays", eVariationId::VAR_RAYS, weight, true) { }
@ -2438,7 +2441,7 @@ public:
/// Blade.
/// </summary>
template <typename T>
class EMBER_API BladeVariation : public Variation<T>
class BladeVariation : public Variation<T>
{
public:
BladeVariation(T weight = 1.0) : Variation<T>("blade", eVariationId::VAR_BLADE, weight, true, true) { }
@ -2476,7 +2479,7 @@ public:
/// Secant2.
/// </summary>
template <typename T>
class EMBER_API Secant2Variation : public Variation<T>
class Secant2Variation : public Variation<T>
{
public:
Secant2Variation(T weight = 1.0) : Variation<T>("secant2", eVariationId::VAR_SECANT2, weight, true, true) { }
@ -2524,7 +2527,7 @@ public:
/// TwinTrian.
/// </summary>
template <typename T>
class EMBER_API TwinTrianVariation : public Variation<T>
class TwinTrianVariation : public Variation<T>
{
public:
TwinTrianVariation(T weight = 1.0) : Variation<T>("TwinTrian", eVariationId::VAR_TWINTRIAN, weight, true, true) { }
@ -2571,7 +2574,7 @@ public:
/// Cross.
/// </summary>
template <typename T>
class EMBER_API CrossVariation : public Variation<T>
class CrossVariation : public Variation<T>
{
public:
CrossVariation(T weight = 1.0) : Variation<T>("cross", eVariationId::VAR_CROSS, weight) { }
@ -2610,7 +2613,7 @@ public:
/// Disc2.
/// </summary>
template <typename T>
class EMBER_API Disc2Variation : public ParametricVariation<T>
class Disc2Variation : public ParametricVariation<T>
{
public:
Disc2Variation(T weight = 1.0) : ParametricVariation<T>("disc2", eVariationId::VAR_DISC2, weight, false, false, false, true)
@ -2707,7 +2710,7 @@ private:
/// SuperShape.
/// </summary>
template <typename T>
class EMBER_API SuperShapeVariation : public ParametricVariation<T>
class SuperShapeVariation : public ParametricVariation<T>
{
public:
SuperShapeVariation(T weight = 1.0) : ParametricVariation<T>("super_shape", eVariationId::VAR_SUPER_SHAPE, weight, true, true, false, false, true)
@ -2806,7 +2809,7 @@ private:
/// Flower.
/// </summary>
template <typename T>
class EMBER_API FlowerVariation : public ParametricVariation<T>
class FlowerVariation : public ParametricVariation<T>
{
public:
FlowerVariation(T weight = 1.0) : ParametricVariation<T>("flower", eVariationId::VAR_FLOWER, weight, true, true, false, false, true)
@ -2868,7 +2871,7 @@ private:
/// Conic.
/// </summary>
template <typename T>
class EMBER_API ConicVariation : public ParametricVariation<T>
class ConicVariation : public ParametricVariation<T>
{
public:
ConicVariation(T weight = 1.0) : ParametricVariation<T>("conic", eVariationId::VAR_CONIC, weight, true, true)
@ -2931,7 +2934,7 @@ private:
/// Parabola.
/// </summary>
template <typename T>
class EMBER_API ParabolaVariation : public ParametricVariation<T>
class ParabolaVariation : public ParametricVariation<T>
{
public:
ParabolaVariation(T weight = 1.0) : ParametricVariation<T>("parabola", eVariationId::VAR_PARABOLA, weight, true, true)
@ -2993,7 +2996,7 @@ private:
/// Bent2.
/// </summary>
template <typename T>
class EMBER_API Bent2Variation : public ParametricVariation<T>
class Bent2Variation : public ParametricVariation<T>
{
public:
Bent2Variation(T weight = 1.0) : ParametricVariation<T>("bent2", eVariationId::VAR_BENT2, weight)
@ -3078,7 +3081,7 @@ private:
/// Bipolar.
/// </summary>
template <typename T>
class EMBER_API BipolarVariation : public ParametricVariation<T>
class BipolarVariation : public ParametricVariation<T>
{
public:
BipolarVariation(T weight = 1.0) : ParametricVariation<T>("bipolar", eVariationId::VAR_BIPOLAR, weight, true)
@ -3228,7 +3231,7 @@ private:
/// Boarders.
/// </summary>
template <typename T>
class EMBER_API BoardersVariation : public Variation<T>
class BoardersVariation : public Variation<T>
{
public:
BoardersVariation(T weight = 1.0) : Variation<T>("boarders", eVariationId::VAR_BOARDERS, weight) { }
@ -3335,7 +3338,7 @@ public:
/// Butterfly.
/// </summary>
template <typename T>
class EMBER_API ButterflyVariation : public Variation<T>
class ButterflyVariation : public Variation<T>
{
public:
ButterflyVariation(T weight = 1.0) : Variation<T>("butterfly", eVariationId::VAR_BUTTERFLY, weight) { }
@ -3378,7 +3381,7 @@ public:
/// Cell.
/// </summary>
template <typename T>
class EMBER_API CellVariation : public ParametricVariation<T>
class CellVariation : public ParametricVariation<T>
{
public:
CellVariation(T weight = 1.0) : ParametricVariation<T>("cell", eVariationId::VAR_CELL, weight)
@ -3509,7 +3512,7 @@ private:
/// Cpow.
/// </summary>
template <typename T>
class EMBER_API CpowVariation : public ParametricVariation<T>
class CpowVariation : public ParametricVariation<T>
{
public:
CpowVariation(T weight = 1.0) : ParametricVariation<T>("cpow", eVariationId::VAR_CPOW, weight, true, false, false, false, true)
@ -3595,7 +3598,7 @@ private:
/// Curve.
/// </summary>
template <typename T>
class EMBER_API CurveVariation : public ParametricVariation<T>
class CurveVariation : public ParametricVariation<T>
{
public:
CurveVariation(T weight = 1.0) : ParametricVariation<T>("curve", eVariationId::VAR_CURVE, weight)
@ -3680,7 +3683,7 @@ private:
/// Edisc.
/// </summary>
template <typename T>
class EMBER_API EdiscVariation : public Variation<T>
class EdiscVariation : public Variation<T>
{
public:
EdiscVariation(T weight = 1.0) : Variation<T>("edisc", eVariationId::VAR_EDISC, weight, true) { }
@ -3741,7 +3744,7 @@ public:
/// Elliptic.
/// </summary>
template <typename T>
class EMBER_API EllipticVariation : public ParametricVariation<T>
class EllipticVariation : public ParametricVariation<T>
{
public:
EllipticVariation(T weight = 1.0) : ParametricVariation<T>("elliptic", eVariationId::VAR_ELLIPTIC, weight, true)
@ -3840,7 +3843,7 @@ private:
/// Escher.
/// </summary>
template <typename T>
class EMBER_API EscherVariation : public ParametricVariation<T>
class EscherVariation : public ParametricVariation<T>
{
public:
EscherVariation(T weight = 1.0) : ParametricVariation<T>("escher", eVariationId::VAR_ESCHER, weight, true, false, false, false, true)
@ -3927,7 +3930,7 @@ private:
/// Foci.
/// </summary>
template <typename T>
class EMBER_API FociVariation : public Variation<T>
class FociVariation : public Variation<T>
{
public:
FociVariation(T weight = 1.0) : Variation<T>("foci", eVariationId::VAR_FOCI, weight) { }
@ -3976,7 +3979,7 @@ public:
/// LazySusan.
/// </summary>
template <typename T>
class EMBER_API LazySusanVariation : public ParametricVariation<T>
class LazySusanVariation : public ParametricVariation<T>
{
public:
LazySusanVariation(T weight = 1.0) : ParametricVariation<T>("lazysusan", eVariationId::VAR_LAZYSUSAN, weight)
@ -4094,7 +4097,7 @@ private:
/// Loonie.
/// </summary>
template <typename T>
class EMBER_API LoonieVariation : public ParametricVariation<T>
class LoonieVariation : public ParametricVariation<T>
{
public:
LoonieVariation(T weight = 1.0) : ParametricVariation<T>("loonie", eVariationId::VAR_LOONIE, weight, true)
@ -4167,7 +4170,7 @@ private:
/// Modulus.
/// </summary>
template <typename T>
class EMBER_API ModulusVariation : public ParametricVariation<T>
class ModulusVariation : public ParametricVariation<T>
{
public:
ModulusVariation(T weight = 1.0) : ParametricVariation<T>("modulus", eVariationId::VAR_MODULUS, weight)
@ -4260,7 +4263,7 @@ private:
/// Oscilloscope.
/// </summary>
template <typename T>
class EMBER_API OscilloscopeVariation : public ParametricVariation<T>
class OscilloscopeVariation : public ParametricVariation<T>
{
public:
OscilloscopeVariation(T weight = 1.0) : ParametricVariation<T>("oscilloscope", eVariationId::VAR_OSCILLOSCOPE, weight)
@ -4365,7 +4368,7 @@ private:
/// Polar2.
/// </summary>
template <typename T>
class EMBER_API Polar2Variation : public ParametricVariation<T>
class Polar2Variation : public ParametricVariation<T>
{
public:
Polar2Variation(T weight = 1.0) : ParametricVariation<T>("polar2", eVariationId::VAR_POLAR2, weight, true, false, false, true)
@ -4422,7 +4425,7 @@ private:
/// Popcorn2.
/// </summary>
template <typename T>
class EMBER_API Popcorn2Variation : public ParametricVariation<T>
class Popcorn2Variation : public ParametricVariation<T>
{
public:
Popcorn2Variation(T weight = 1.0) : ParametricVariation<T>("popcorn2", eVariationId::VAR_POPCORN2, weight)
@ -4486,7 +4489,7 @@ private:
/// should be ok.
/// </summary>
template <typename T>
class EMBER_API ScryVariation : public ParametricVariation<T>
class ScryVariation : public ParametricVariation<T>
{
public:
ScryVariation(T weight = 1.0) : ParametricVariation<T>("scry", eVariationId::VAR_SCRY, weight, true, true)
@ -4549,7 +4552,7 @@ private:
/// Separation.
/// </summary>
template <typename T>
class EMBER_API SeparationVariation : public ParametricVariation<T>
class SeparationVariation : public ParametricVariation<T>
{
public:
SeparationVariation(T weight = 1.0) : ParametricVariation<T>("separation", eVariationId::VAR_SEPARATION, weight)
@ -4642,7 +4645,7 @@ private:
/// Split.
/// </summary>
template <typename T>
class EMBER_API SplitVariation : public ParametricVariation<T>
class SplitVariation : public ParametricVariation<T>
{
public:
SplitVariation(T weight = 1.0) : ParametricVariation<T>("split", eVariationId::VAR_SPLIT, weight)
@ -4727,7 +4730,7 @@ private:
/// Splits.
/// </summary>
template <typename T>
class EMBER_API SplitsVariation : public ParametricVariation<T>
class SplitsVariation : public ParametricVariation<T>
{
public:
SplitsVariation(T weight = 1.0) : ParametricVariation<T>("splits", eVariationId::VAR_SPLITS, weight)
@ -4800,7 +4803,7 @@ private:
/// Stripes.
/// </summary>
template <typename T>
class EMBER_API StripesVariation : public ParametricVariation<T>
class StripesVariation : public ParametricVariation<T>
{
public:
StripesVariation(T weight = 1.0) : ParametricVariation<T>("stripes", eVariationId::VAR_STRIPES, weight)
@ -4862,7 +4865,7 @@ private:
/// Wedge.
/// </summary>
template <typename T>
class EMBER_API WedgeVariation : public ParametricVariation<T>
class WedgeVariation : public ParametricVariation<T>
{
public:
WedgeVariation(T weight = 1.0) : ParametricVariation<T>("wedge", eVariationId::VAR_WEDGE, weight, true, true, false, false, true)
@ -4946,7 +4949,7 @@ private:
/// Wedge julia.
/// </summary>
template <typename T>
class EMBER_API WedgeJuliaVariation : public ParametricVariation<T>
class WedgeJuliaVariation : public ParametricVariation<T>
{
public:
WedgeJuliaVariation(T weight = 1.0) : ParametricVariation<T>("wedge_julia", eVariationId::VAR_WEDGE_JULIA, weight, true, false, false, false, true)
@ -5038,7 +5041,7 @@ private:
/// Wedge sph.
/// </summary>
template <typename T>
class EMBER_API WedgeSphVariation : public ParametricVariation<T>
class WedgeSphVariation : public ParametricVariation<T>
{
public:
WedgeSphVariation(T weight = 1.0) : ParametricVariation<T>("wedge_sph", eVariationId::VAR_WEDGE_SPH, weight, true, true, false, false, true)
@ -5131,7 +5134,7 @@ private:
/// Whorl.
/// </summary>
template <typename T>
class EMBER_API WhorlVariation : public ParametricVariation<T>
class WhorlVariation : public ParametricVariation<T>
{
public:
WhorlVariation(T weight = 1.0) : ParametricVariation<T>("whorl", eVariationId::VAR_WHORL, weight, true, true, false, false, true)
@ -5203,7 +5206,7 @@ private:
/// Waves.
/// </summary>
template <typename T>
class EMBER_API Waves2Variation : public ParametricVariation<T>
class Waves2Variation : public ParametricVariation<T>
{
public:
Waves2Variation(T weight = 1.0) : ParametricVariation<T>("waves2", eVariationId::VAR_WAVES2, weight, true, true)
@ -5276,7 +5279,7 @@ private:
/// Exp.
/// </summary>
template <typename T>
class EMBER_API ExpVariation : public Variation<T>
class ExpVariation : public Variation<T>
{
public:
ExpVariation(T weight = 1.0) : Variation<T>("exp", eVariationId::VAR_EXP, weight) { }
@ -5310,7 +5313,7 @@ public:
/// Log.
/// </summary>
template <typename T>
class EMBER_API LogVariation : public ParametricVariation<T>
class LogVariation : public ParametricVariation<T>
{
public:
LogVariation(T weight = 1.0) : ParametricVariation<T>("log", eVariationId::VAR_LOG, weight, true, false, false, false, true)
@ -5366,7 +5369,7 @@ private:
/// Sine.
/// </summary>
template <typename T>
class EMBER_API SinVariation : public Variation<T>
class SinVariation : public Variation<T>
{
public:
SinVariation(T weight = 1.0) : Variation<T>("sin", eVariationId::VAR_SIN, weight) { }
@ -5397,7 +5400,7 @@ public:
/// Cosine.
/// </summary>
template <typename T>
class EMBER_API CosVariation : public Variation<T>
class CosVariation : public Variation<T>
{
public:
CosVariation(T weight = 1.0) : Variation<T>("cos", eVariationId::VAR_COS, weight) { }
@ -5429,7 +5432,7 @@ public:
/// Tangent.
/// </summary>
template <typename T>
class EMBER_API TanVariation : public Variation<T>
class TanVariation : public Variation<T>
{
public:
TanVariation(T weight = 1.0) : Variation<T>("tan", eVariationId::VAR_TAN, weight) { }
@ -5471,7 +5474,7 @@ public:
/// Sec.
/// </summary>
template <typename T>
class EMBER_API SecVariation : public Variation<T>
class SecVariation : public Variation<T>
{
public:
SecVariation(T weight = 1.0) : Variation<T>("sec", eVariationId::VAR_SEC, weight) { }
@ -5513,7 +5516,7 @@ public:
/// Cosecant.
/// </summary>
template <typename T>
class EMBER_API CscVariation : public Variation<T>
class CscVariation : public Variation<T>
{
public:
CscVariation(T weight = 1.0) : Variation<T>("csc", eVariationId::VAR_CSC, weight) { }
@ -5555,7 +5558,7 @@ public:
/// Cotangent.
/// </summary>
template <typename T>
class EMBER_API CotVariation : public Variation<T>
class CotVariation : public Variation<T>
{
public:
CotVariation(T weight = 1.0) : Variation<T>("cot", eVariationId::VAR_COT, weight) { }
@ -5597,7 +5600,7 @@ public:
/// Sinh.
/// </summary>
template <typename T>
class EMBER_API SinhVariation : public Variation<T>
class SinhVariation : public Variation<T>
{
public:
SinhVariation(T weight = 1.0) : Variation<T>("sinh", eVariationId::VAR_SINH, weight) { }
@ -5637,7 +5640,7 @@ public:
/// Cosh.
/// </summary>
template <typename T>
class EMBER_API CoshVariation : public Variation<T>
class CoshVariation : public Variation<T>
{
public:
CoshVariation(T weight = 1.0) : Variation<T>("cosh", eVariationId::VAR_COSH, weight) { }
@ -5677,7 +5680,7 @@ public:
/// Tanh.
/// </summary>
template <typename T>
class EMBER_API TanhVariation : public Variation<T>
class TanhVariation : public Variation<T>
{
public:
TanhVariation(T weight = 1.0) : Variation<T>("tanh", eVariationId::VAR_TANH, weight) { }
@ -5719,7 +5722,7 @@ public:
/// Sech
/// </summary>
template <typename T>
class EMBER_API SechVariation : public Variation<T>
class SechVariation : public Variation<T>
{
public:
SechVariation(T weight = 1.0) : Variation<T>("sech", eVariationId::VAR_SECH, weight) { }
@ -5761,7 +5764,7 @@ public:
/// Csch.
/// </summary>
template <typename T>
class EMBER_API CschVariation : public Variation<T>
class CschVariation : public Variation<T>
{
public:
CschVariation(T weight = 1.0) : Variation<T>("csch", eVariationId::VAR_CSCH, weight) { }
@ -5803,7 +5806,7 @@ public:
/// Coth.
/// </summary>
template <typename T>
class EMBER_API CothVariation : public Variation<T>
class CothVariation : public Variation<T>
{
public:
CothVariation(T weight = 1.0) : Variation<T>("coth", eVariationId::VAR_COTH, weight) { }
@ -5845,7 +5848,7 @@ public:
/// Auger.
/// </summary>
template <typename T>
class EMBER_API AugerVariation : public ParametricVariation<T>
class AugerVariation : public ParametricVariation<T>
{
public:
AugerVariation(T weight = 1.0) : ParametricVariation<T>("auger", eVariationId::VAR_AUGER, weight)
@ -5919,7 +5922,7 @@ private:
/// Flux.
/// </summary>
template <typename T>
class EMBER_API FluxVariation : public ParametricVariation<T>
class FluxVariation : public ParametricVariation<T>
{
public:
FluxVariation(T weight = 1.0) : ParametricVariation<T>("flux", eVariationId::VAR_FLUX, weight)

130
Source/Ember/Variations02.h
View File

@ -8,7 +8,7 @@ namespace EmberNs
/// Hemisphere.
/// </summary>
template <typename T>
class EMBER_API HemisphereVariation : public Variation<T>
class HemisphereVariation : public Variation<T>
{
public:
HemisphereVariation(T weight = 1.0) : Variation<T>("hemisphere", eVariationId::VAR_HEMISPHERE, weight, true) { }
@ -42,7 +42,7 @@ public:
/// Epispiral.
/// </summary>
template <typename T>
class EMBER_API EpispiralVariation : public ParametricVariation<T>
class EpispiralVariation : public ParametricVariation<T>
{
public:
EpispiralVariation(T weight = 1.0) : ParametricVariation<T>("epispiral", eVariationId::VAR_EPISPIRAL, weight, false, false, false, false, true)
@ -120,7 +120,7 @@ private:
/// Note, this is the same as bwraps2.
/// </summary>
template <typename T>
class EMBER_API BwrapsVariation : public ParametricVariation<T>
class BwrapsVariation : public ParametricVariation<T>
{
public:
BwrapsVariation(T weight = 1.0) : ParametricVariation<T>("bwraps", eVariationId::VAR_BWRAPS, weight)
@ -279,7 +279,7 @@ private:
/// BlurCircle.
/// </summary>
template <typename T>
class EMBER_API BlurCircleVariation : public Variation<T>
class BlurCircleVariation : public Variation<T>
{
public:
BlurCircleVariation(T weight = 1.0) : Variation<T>("blur_circle", eVariationId::VAR_BLUR_CIRCLE, weight) { }
@ -383,7 +383,7 @@ public:
/// BlurZoom.
/// </summary>
template <typename T>
class EMBER_API BlurZoomVariation : public ParametricVariation<T>
class BlurZoomVariation : public ParametricVariation<T>
{
public:
BlurZoomVariation(T weight = 1.0) : ParametricVariation<T>("blur_zoom", eVariationId::VAR_BLUR_ZOOM, weight)
@ -440,7 +440,7 @@ private:
/// BlurPixelize.
/// </summary>
template <typename T>
class EMBER_API BlurPixelizeVariation : public ParametricVariation<T>
class BlurPixelizeVariation : public ParametricVariation<T>
{
public:
BlurPixelizeVariation(T weight = 1.0) : ParametricVariation<T>("blur_pixelize", eVariationId::VAR_BLUR_PIXELIZE, weight)
@ -508,7 +508,7 @@ private:
/// Crop.
/// </summary>
template <typename T>
class EMBER_API CropVariation : public ParametricVariation<T>
class CropVariation : public ParametricVariation<T>
{
public:
CropVariation(T weight = 1.0) : ParametricVariation<T>("crop", eVariationId::VAR_CROP, weight)
@ -659,7 +659,7 @@ private:
/// BCircle.
/// </summary>
template <typename T>
class EMBER_API BCircleVariation : public ParametricVariation<T>
class BCircleVariation : public ParametricVariation<T>
{
public:
BCircleVariation(T weight = 1.0) : ParametricVariation<T>("bcircle", eVariationId::VAR_BCIRCLE, weight)
@ -765,7 +765,7 @@ private:
/// BlurLinear.
/// </summary>
template <typename T>
class EMBER_API BlurLinearVariation : public ParametricVariation<T>
class BlurLinearVariation : public ParametricVariation<T>
{
public:
BlurLinearVariation(T weight = 1.0) : ParametricVariation<T>("blur_linear", eVariationId::VAR_BLUR_LINEAR, weight)
@ -830,7 +830,7 @@ private:
/// BlurSquare.
/// </summary>
template <typename T>
class EMBER_API BlurSquareVariation : public ParametricVariation<T>
class BlurSquareVariation : public ParametricVariation<T>
{
public:
BlurSquareVariation(T weight = 1.0) : ParametricVariation<T>("blur_square", eVariationId::VAR_BLUR_SQUARE, weight)
@ -884,7 +884,7 @@ private:
/// This uses in/out in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API FlattenVariation : public Variation<T>
class FlattenVariation : public Variation<T>
{
public:
FlattenVariation(T weight = 1.0) : Variation<T>("flatten", eVariationId::VAR_FLATTEN, weight) { }
@ -937,7 +937,7 @@ public:
/// This uses in/out in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API ZblurVariation : public Variation<T>
class ZblurVariation : public Variation<T>
{
public:
ZblurVariation(T weight = 1.0) : Variation<T>("zblur", eVariationId::VAR_ZBLUR, weight) { }
@ -967,7 +967,7 @@ public:
/// This uses in/out in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API ZScaleVariation : public Variation<T>
class ZScaleVariation : public Variation<T>
{
public:
ZScaleVariation(T weight = 1.0) : Variation<T>("zscale", eVariationId::VAR_ZSCALE, weight) { }
@ -997,7 +997,7 @@ public:
/// This uses in/out in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API ZTranslateVariation : public Variation<T>
class ZTranslateVariation : public Variation<T>
{
public:
ZTranslateVariation(T weight = 1.0) : Variation<T>("ztranslate", eVariationId::VAR_ZTRANSLATE, weight) { }
@ -1027,7 +1027,7 @@ public:
/// This uses in/out in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API ZConeVariation : public Variation<T>
class ZConeVariation : public Variation<T>
{
public:
ZConeVariation(T weight = 1.0) : Variation<T>("zcone", eVariationId::VAR_ZCONE, weight, true, true) { }
@ -1075,7 +1075,7 @@ public:
/// Blur3D.
/// </summary>
template <typename T>
class EMBER_API Blur3DVariation : public Variation<T>
class Blur3DVariation : public Variation<T>
{
public:
Blur3DVariation(T weight = 1.0) : Variation<T>("blur3D", eVariationId::VAR_BLUR3D, weight) { }
@ -1121,7 +1121,7 @@ public:
/// Spherical3D.
/// </summary>
template <typename T>
class EMBER_API Spherical3DVariation : public Variation<T>
class Spherical3DVariation : public Variation<T>
{
public:
Spherical3DVariation(T weight = 1.0) : Variation<T>("Spherical3D", eVariationId::VAR_SPHERICAL3D, weight, true) { }
@ -1160,7 +1160,7 @@ public:
/// Curl3D.
/// </summary>
template <typename T>
class EMBER_API Curl3DVariation : public ParametricVariation<T>
class Curl3DVariation : public ParametricVariation<T>
{
public:
Curl3DVariation(T weight = 1.0) : ParametricVariation<T>("curl3D", eVariationId::VAR_CURL3D, weight, true)
@ -1244,7 +1244,7 @@ private:
/// Disc3D.
/// </summary>
template <typename T>
class EMBER_API Disc3DVariation : public ParametricVariation<T>
class Disc3DVariation : public ParametricVariation<T>
{
public:
Disc3DVariation(T weight = 1.0) : ParametricVariation<T>("disc3d", eVariationId::VAR_DISC3D, weight, true, true, false, true, false)
@ -1308,7 +1308,7 @@ private:
/// Boarders2.
/// </summary>
template <typename T>
class EMBER_API Boarders2Variation : public ParametricVariation<T>
class Boarders2Variation : public ParametricVariation<T>
{
public:
Boarders2Variation(T weight = 1.0) : ParametricVariation<T>("boarders2", eVariationId::VAR_BOARDERS2, weight)
@ -1457,7 +1457,7 @@ private:
/// Cardioid.
/// </summary>
template <typename T>
class EMBER_API CardioidVariation : public ParametricVariation<T>
class CardioidVariation : public ParametricVariation<T>
{
public:
CardioidVariation(T weight = 1.0) : ParametricVariation<T>("cardioid", eVariationId::VAR_CARDIOID, weight, true, true, true, false, true)
@ -1508,7 +1508,7 @@ private:
/// Checks.
/// </summary>
template <typename T>
class EMBER_API ChecksVariation : public ParametricVariation<T>
class ChecksVariation : public ParametricVariation<T>
{
public:
ChecksVariation(T weight = 1.0) : ParametricVariation<T>("checks", eVariationId::VAR_CHECKS, weight)
@ -1627,7 +1627,7 @@ private:
/// Circlize.
/// </summary>
template <typename T>
class EMBER_API CirclizeVariation : public ParametricVariation<T>
class CirclizeVariation : public ParametricVariation<T>
{
public:
CirclizeVariation(T weight = 1.0) : ParametricVariation<T>("circlize", eVariationId::VAR_CIRCLIZE, weight)
@ -1737,7 +1737,7 @@ private:
/// Circlize2.
/// </summary>
template <typename T>
class EMBER_API Circlize2Variation : public ParametricVariation<T>
class Circlize2Variation : public ParametricVariation<T>
{
public:
Circlize2Variation(T weight = 1.0) : ParametricVariation<T>("circlize2", eVariationId::VAR_CIRCLIZE2, weight)
@ -1838,7 +1838,7 @@ private:
/// CosWrap.
/// </summary>
template <typename T>
class EMBER_API CosWrapVariation : public ParametricVariation<T>
class CosWrapVariation : public ParametricVariation<T>
{
public:
CosWrapVariation(T weight = 1.0) : ParametricVariation<T>("coswrap", eVariationId::VAR_COS_WRAP, weight)
@ -1947,7 +1947,7 @@ private:
/// that precalc variable omitted.
/// </summary>
template <typename T>
class EMBER_API DeltaAVariation : public Variation<T>
class DeltaAVariation : public Variation<T>
{
public:
DeltaAVariation(T weight = 1.0) : Variation<T>("deltaa", eVariationId::VAR_DELTA_A, weight) { }
@ -1987,7 +1987,7 @@ public:
/// Expo.
/// </summary>
template <typename T>
class EMBER_API ExpoVariation : public ParametricVariation<T>
class ExpoVariation : public ParametricVariation<T>
{
public:
ExpoVariation(T weight = 1.0) : ParametricVariation<T>("expo", eVariationId::VAR_EXPO, weight)
@ -2059,7 +2059,7 @@ private:
/// Extrude.
/// </summary>
template <typename T>
class EMBER_API ExtrudeVariation : public ParametricVariation<T>
class ExtrudeVariation : public ParametricVariation<T>
{
public:
ExtrudeVariation(T weight = 1.0) : ParametricVariation<T>("extrude", eVariationId::VAR_EXTRUDE, weight)
@ -2143,7 +2143,7 @@ private:
/// fdisc.
/// </summary>
template <typename T>
class EMBER_API FDiscVariation : public Variation<T>
class FDiscVariation : public Variation<T>
{
public:
FDiscVariation(T weight = 1.0) : Variation<T>("fdisc", eVariationId::VAR_FDISC, weight, true, true, false, false, true) { }
@ -2183,7 +2183,7 @@ public:
/// Fibonacci.
/// </summary>
template <typename T>
class EMBER_API FibonacciVariation : public ParametricVariation<T>
class FibonacciVariation : public ParametricVariation<T>
{
public:
FibonacciVariation(T weight = 1.0) : ParametricVariation<T>("fibonacci", eVariationId::VAR_FIBONACCI, weight)
@ -2256,7 +2256,7 @@ private:
/// Fibonacci2.
/// </summary>
template <typename T>
class EMBER_API Fibonacci2Variation : public ParametricVariation<T>
class Fibonacci2Variation : public ParametricVariation<T>
{
public:
Fibonacci2Variation(T weight = 1.0) : ParametricVariation<T>("fibonacci2", eVariationId::VAR_FIBONACCI2, weight)
@ -2335,7 +2335,7 @@ private:
/// Glynnia.
/// </summary>
template <typename T>
class EMBER_API GlynniaVariation : public ParametricVariation<T>
class GlynniaVariation : public ParametricVariation<T>
{
public:
GlynniaVariation(T weight = 1.0) : ParametricVariation<T>("glynnia", eVariationId::VAR_GLYNNIA, weight, true, true)
@ -2454,7 +2454,7 @@ private:
/// GridOut.
/// </summary>
template <typename T>
class EMBER_API GridOutVariation : public Variation<T>
class GridOutVariation : public Variation<T>
{
public:
GridOutVariation(T weight = 1.0) : Variation<T>("gridout", eVariationId::VAR_GRIDOUT, weight) { }
@ -2610,7 +2610,7 @@ public:
/// Hole.
/// </summary>
template <typename T>
class EMBER_API HoleVariation : public ParametricVariation<T>
class HoleVariation : public ParametricVariation<T>
{
public:
HoleVariation(T weight = 1.0) : ParametricVariation<T>("hole", eVariationId::VAR_HOLE, weight, true, true, true, false, true)
@ -2675,7 +2675,7 @@ private:
/// Hypertile.
/// </summary>
template <typename T>
class EMBER_API HypertileVariation : public ParametricVariation<T>
class HypertileVariation : public ParametricVariation<T>
{
public:
HypertileVariation(T weight = 1.0) : ParametricVariation<T>("hypertile", eVariationId::VAR_HYPERTILE, weight)
@ -2762,7 +2762,7 @@ private:
/// Hypertile1.
/// </summary>
template <typename T>
class EMBER_API Hypertile1Variation : public ParametricVariation<T>
class Hypertile1Variation : public ParametricVariation<T>
{
public:
Hypertile1Variation(T weight = 1.0) : ParametricVariation<T>("hypertile1", eVariationId::VAR_HYPERTILE1, weight)
@ -2853,7 +2853,7 @@ private:
/// Hypertile2.
/// </summary>
template <typename T>
class EMBER_API Hypertile2Variation : public ParametricVariation<T>
class Hypertile2Variation : public ParametricVariation<T>
{
public:
Hypertile2Variation(T weight = 1.0) : ParametricVariation<T>("hypertile2", eVariationId::VAR_HYPERTILE2, weight)
@ -2944,7 +2944,7 @@ private:
/// Hypertile3D.
/// </summary>
template <typename T>
class EMBER_API Hypertile3DVariation : public ParametricVariation<T>
class Hypertile3DVariation : public ParametricVariation<T>
{
public:
Hypertile3DVariation(T weight = 1.0) : ParametricVariation<T>("hypertile3D", eVariationId::VAR_HYPERTILE3D, weight, true)
@ -3059,7 +3059,7 @@ private:
/// Hypertile3D1.
/// </summary>
template <typename T>
class EMBER_API Hypertile3D1Variation : public ParametricVariation<T>
class Hypertile3D1Variation : public ParametricVariation<T>
{
public:
Hypertile3D1Variation(T weight = 1.0) : ParametricVariation<T>("hypertile3D1", eVariationId::VAR_HYPERTILE3D1, weight, true)
@ -3158,7 +3158,7 @@ private:
/// Hypertile3D2.
/// </summary>
template <typename T>
class EMBER_API Hypertile3D2Variation : public ParametricVariation<T>
class Hypertile3D2Variation : public ParametricVariation<T>
{
public:
Hypertile3D2Variation(T weight = 1.0) : ParametricVariation<T>("hypertile3D2", eVariationId::VAR_HYPERTILE3D2, weight, true)
@ -3267,7 +3267,7 @@ private:
/// IDisc.
/// </summary>
template <typename T>
class EMBER_API IDiscVariation : public ParametricVariation<T>
class IDiscVariation : public ParametricVariation<T>
{
public:
IDiscVariation(T weight = 1.0) : ParametricVariation<T>("idisc", eVariationId::VAR_IDISC, weight, true, true, false, false, true)
@ -3329,7 +3329,7 @@ private:
/// Julian2.
/// </summary>
template <typename T>
class EMBER_API Julian2Variation : public ParametricVariation<T>
class Julian2Variation : public ParametricVariation<T>
{
public:
Julian2Variation(T weight = 1.0) : ParametricVariation<T>("julian2", eVariationId::VAR_JULIAN2, weight)
@ -3426,7 +3426,7 @@ private:
/// JuliaQ.
/// </summary>
template <typename T>
class EMBER_API JuliaQVariation : public ParametricVariation<T>
class JuliaQVariation : public ParametricVariation<T>
{
public:
JuliaQVariation(T weight = 1.0) : ParametricVariation<T>("juliaq", eVariationId::VAR_JULIAQ, weight, true, false, false, false, true)
@ -3502,7 +3502,7 @@ private:
/// Murl.
/// </summary>
template <typename T>
class EMBER_API MurlVariation : public ParametricVariation<T>
class MurlVariation : public ParametricVariation<T>
{
public:
MurlVariation(T weight = 1.0) : ParametricVariation<T>("murl", eVariationId::VAR_MURL, weight, true, false, false, false, true)
@ -3588,7 +3588,7 @@ private:
/// Murl2.
/// </summary>
template <typename T>
class EMBER_API Murl2Variation : public ParametricVariation<T>
class Murl2Variation : public ParametricVariation<T>
{
public:
Murl2Variation(T weight = 1.0) : ParametricVariation<T>("murl2", eVariationId::VAR_MURL2, weight, true, false, false, false, true)
@ -3692,7 +3692,7 @@ private:
/// NPolar.
/// </summary>
template <typename T>
class EMBER_API NPolarVariation : public ParametricVariation<T>
class NPolarVariation : public ParametricVariation<T>
{
public:
NPolarVariation(T weight = 1.0) : ParametricVariation<T>("npolar", eVariationId::VAR_NPOLAR, weight, true, false, false, true, false)
@ -3788,7 +3788,7 @@ private:
/// Ortho.
/// </summary>
template <typename T>
class EMBER_API OrthoVariation : public ParametricVariation<T>
class OrthoVariation : public ParametricVariation<T>
{
public:
OrthoVariation(T weight = 1.0) : ParametricVariation<T>("ortho", eVariationId::VAR_ORTHO, weight, true, false, false, false, true)
@ -3990,7 +3990,7 @@ private:
/// Poincare.
/// </summary>
template <typename T>
class EMBER_API PoincareVariation : public ParametricVariation<T>
class PoincareVariation : public ParametricVariation<T>
{
public:
PoincareVariation(T weight = 1.0) : ParametricVariation<T>("poincare", eVariationId::VAR_POINCARE, weight)
@ -4080,7 +4080,7 @@ private:
/// Poincare3D.
/// </summary>
template <typename T>
class EMBER_API Poincare3DVariation : public ParametricVariation<T>
class Poincare3DVariation : public ParametricVariation<T>
{
public:
Poincare3DVariation(T weight = 1.0) : ParametricVariation<T>("poincare3D", eVariationId::VAR_POINCARE3D, weight, true)
@ -4196,7 +4196,7 @@ private:
/// Polynomial.
/// </summary>
template <typename T>
class EMBER_API PolynomialVariation : public ParametricVariation<T>
class PolynomialVariation : public ParametricVariation<T>
{
public:
PolynomialVariation(T weight = 1.0) : ParametricVariation<T>("polynomial", eVariationId::VAR_POLYNOMIAL, weight)
@ -4270,7 +4270,7 @@ private:
/// PSphere.
/// </summary>
template <typename T>
class EMBER_API PSphereVariation : public ParametricVariation<T>
class PSphereVariation : public ParametricVariation<T>
{
public:
PSphereVariation(T weight = 1.0) : ParametricVariation<T>("psphere", eVariationId::VAR_PSPHERE, weight)
@ -4339,7 +4339,7 @@ private:
/// Rational3.
/// </summary>
template <typename T>
class EMBER_API Rational3Variation : public ParametricVariation<T>
class Rational3Variation : public ParametricVariation<T>
{
public:
Rational3Variation(T weight = 1.0) : ParametricVariation<T>("rational3", eVariationId::VAR_RATIONAL3, weight)
@ -4430,7 +4430,7 @@ private:
/// Ripple.
/// </summary>
template <typename T>
class EMBER_API RippleVariation : public ParametricVariation<T>
class RippleVariation : public ParametricVariation<T>
{
public:
RippleVariation(T weight = 1.0) : ParametricVariation<T>("ripple", eVariationId::VAR_RIPPLE, weight)
@ -4577,7 +4577,7 @@ private:
/// Sigmoid.
/// </summary>
template <typename T>
class EMBER_API SigmoidVariation : public ParametricVariation<T>
class SigmoidVariation : public ParametricVariation<T>
{
public:
SigmoidVariation(T weight = 1.0) : ParametricVariation<T>("sigmoid", eVariationId::VAR_SIGMOID, weight)
@ -4692,7 +4692,7 @@ private:
/// SinusGrid.
/// </summary>
template <typename T>
class EMBER_API SinusGridVariation : public ParametricVariation<T>
class SinusGridVariation : public ParametricVariation<T>
{
public:
SinusGridVariation(T weight = 1.0) : ParametricVariation<T>("sinusgrid", eVariationId::VAR_SINUS_GRID, weight)
@ -4788,7 +4788,7 @@ private:
/// Stwin.
/// </summary>
template <typename T>
class EMBER_API StwinVariation : public ParametricVariation<T>
class StwinVariation : public ParametricVariation<T>
{
public:
StwinVariation(T weight = 1.0) : ParametricVariation<T>("stwin", eVariationId::VAR_STWIN, weight)
@ -4866,7 +4866,7 @@ private:
/// TwoFace.
/// </summary>
template <typename T>
class EMBER_API TwoFaceVariation : public Variation<T>
class TwoFaceVariation : public Variation<T>
{
public:
TwoFaceVariation(T weight = 1.0) : Variation<T>("twoface", eVariationId::VAR_TWO_FACE, weight, true) { }
@ -4907,7 +4907,7 @@ public:
/// Unpolar.
/// </summary>
template <typename T>
class EMBER_API UnpolarVariation : public ParametricVariation<T>
class UnpolarVariation : public ParametricVariation<T>
{
public:
UnpolarVariation(T weight = 1.0) : ParametricVariation<T>("unpolar", eVariationId::VAR_UNPOLAR, weight)
@ -4967,7 +4967,7 @@ private:
/// WavesN.
/// </summary>
template <typename T>
class EMBER_API WavesNVariation : public ParametricVariation<T>
class WavesNVariation : public ParametricVariation<T>
{
public:
WavesNVariation(T weight = 1.0) : ParametricVariation<T>("wavesn", eVariationId::VAR_WAVESN, weight, true, false, false, false, true)
@ -5069,7 +5069,7 @@ private:
/// XHeart.
/// </summary>
template <typename T>
class EMBER_API XHeartVariation : public ParametricVariation<T>
class XHeartVariation : public ParametricVariation<T>
{
public:
XHeartVariation(T weight = 1.0) : ParametricVariation<T>("xheart", eVariationId::VAR_XHEART, weight, true)
@ -5174,7 +5174,7 @@ private:
/// Barycentroid.
/// </summary>
template <typename T>
class EMBER_API BarycentroidVariation : public ParametricVariation<T>
class BarycentroidVariation : public ParametricVariation<T>
{
public:
BarycentroidVariation(T weight = 1.0) : ParametricVariation<T>("barycentroid", eVariationId::VAR_BARYCENTROID, weight)
@ -5262,7 +5262,7 @@ private:
/// BiSplit.
/// </summary>
template <typename T>
class EMBER_API BiSplitVariation : public ParametricVariation<T>
class BiSplitVariation : public ParametricVariation<T>
{
public:
BiSplitVariation(T weight = 1.0) : ParametricVariation<T>("bisplit", eVariationId::VAR_BISPLIT, weight)
@ -5315,7 +5315,7 @@ private:
/// Crescents.
/// </summary>
template <typename T>
class EMBER_API CrescentsVariation : public Variation<T>
class CrescentsVariation : public Variation<T>
{
public:
CrescentsVariation(T weight = 1.0) : Variation<T>("crescents", eVariationId::VAR_CRESCENTS, weight) { }
@ -5360,7 +5360,7 @@ public:
/// Mask.
/// </summary>
template <typename T>
class EMBER_API MaskVariation : public Variation<T>
class MaskVariation : public Variation<T>
{
public:
MaskVariation(T weight = 1.0) : Variation<T>("mask", eVariationId::VAR_MASK, weight, true) { }
@ -5407,7 +5407,7 @@ public:
/// Cpow2.
/// </summary>
template <typename T>
class EMBER_API Cpow2Variation : public ParametricVariation<T>
class Cpow2Variation : public ParametricVariation<T>
{
public:
Cpow2Variation(T weight = 1.0) : ParametricVariation<T>("cpow2", eVariationId::VAR_CPOW2, weight, true, false, false, false, true)

106
Source/Ember/Variations03.h
View File

@ -8,7 +8,7 @@ namespace EmberNs
/// Funnel.
/// </summary>
template <typename T>
class EMBER_API FunnelVariation : public ParametricVariation<T>
class FunnelVariation : public ParametricVariation<T>
{
public:
FunnelVariation(T weight = 1.0) : ParametricVariation<T>("funnel", eVariationId::VAR_FUNNEL, weight)
@ -64,7 +64,7 @@ private:
/// Linear3D.
/// </summary>
template <typename T>
class EMBER_API Linear3DVariation : public Variation<T>
class Linear3DVariation : public Variation<T>
{
public:
Linear3DVariation(T weight = 1.0) : Variation<T>("linear3D", eVariationId::VAR_LINEAR3D, weight) { }
@ -95,7 +95,7 @@ public:
/// PowBlock.
/// </summary>
template <typename T>
class EMBER_API PowBlockVariation : public ParametricVariation<T>
class PowBlockVariation : public ParametricVariation<T>
{
public:
PowBlockVariation(T weight = 1.0) : ParametricVariation<T>("pow_block", eVariationId::VAR_POW_BLOCK, weight, true, false, false, false, true)
@ -173,7 +173,7 @@ private:
/// Squirrel.
/// </summary>
template <typename T>
class EMBER_API SquirrelVariation : public ParametricVariation<T>
class SquirrelVariation : public ParametricVariation<T>
{
public:
SquirrelVariation(T weight = 1.0) : ParametricVariation<T>("squirrel", eVariationId::VAR_SQUIRREL, weight)
@ -232,7 +232,7 @@ private:
/// Ennepers.
/// </summary>
template <typename T>
class EMBER_API EnnepersVariation : public Variation<T>
class EnnepersVariation : public Variation<T>
{
public:
EnnepersVariation(T weight = 1.0) : Variation<T>("ennepers", eVariationId::VAR_ENNEPERS, weight) { }
@ -263,7 +263,7 @@ public:
/// SphericalN.
/// </summary>
template <typename T>
class EMBER_API SphericalNVariation : public ParametricVariation<T>
class SphericalNVariation : public ParametricVariation<T>
{
public:
SphericalNVariation(T weight = 1.0) : ParametricVariation<T>("SphericalN", eVariationId::VAR_SPHERICALN, weight, true, true, false, false, true)
@ -330,7 +330,7 @@ private:
/// Kaleidoscope.
/// </summary>
template <typename T>
class EMBER_API KaleidoscopeVariation : public ParametricVariation<T>
class KaleidoscopeVariation : public ParametricVariation<T>
{
public:
KaleidoscopeVariation(T weight = 1.0) : ParametricVariation<T>("Kaleidoscope", eVariationId::VAR_KALEIDOSCOPE, weight)
@ -406,7 +406,7 @@ private:
/// GlynnSim1.
/// </summary>
template <typename T>
class EMBER_API GlynnSim1Variation : public ParametricVariation<T>
class GlynnSim1Variation : public ParametricVariation<T>
{
public:
GlynnSim1Variation(T weight = 1.0) : ParametricVariation<T>("GlynnSim1", eVariationId::VAR_GLYNNSIM1, weight, true, true)
@ -588,7 +588,7 @@ private:
/// GlynnSim2.
/// </summary>
template <typename T>
class EMBER_API GlynnSim2Variation : public ParametricVariation<T>
class GlynnSim2Variation : public ParametricVariation<T>
{
public:
GlynnSim2Variation(T weight = 1.0) : ParametricVariation<T>("GlynnSim2", eVariationId::VAR_GLYNNSIM2, weight, true, true)
@ -747,7 +747,7 @@ private:
/// GlynnSim3.
/// </summary>
template <typename T>
class EMBER_API GlynnSim3Variation : public ParametricVariation<T>
class GlynnSim3Variation : public ParametricVariation<T>
{
public:
GlynnSim3Variation(T weight = 1.0) : ParametricVariation<T>("GlynnSim3", eVariationId::VAR_GLYNNSIM3, weight, true, true)
@ -909,7 +909,7 @@ private:
/// Starblur.
/// </summary>
template <typename T>
class EMBER_API StarblurVariation : public ParametricVariation<T>
class StarblurVariation : public ParametricVariation<T>
{
public:
StarblurVariation(T weight = 1.0) : ParametricVariation<T>("starblur", eVariationId::VAR_STARBLUR, weight)
@ -1003,7 +1003,7 @@ private:
/// Sineblur.
/// </summary>
template <typename T>
class EMBER_API SineblurVariation : public ParametricVariation<T>
class SineblurVariation : public ParametricVariation<T>
{
public:
SineblurVariation(T weight = 1.0) : ParametricVariation<T>("sineblur", eVariationId::VAR_SINEBLUR, weight)
@ -1060,7 +1060,7 @@ private:
/// Circleblur.
/// </summary>
template <typename T>
class EMBER_API CircleblurVariation : public Variation<T>
class CircleblurVariation : public Variation<T>
{
public:
CircleblurVariation(T weight = 1.0) : Variation<T>("circleblur", eVariationId::VAR_CIRCLEBLUR, weight) { }
@ -1096,7 +1096,7 @@ public:
/// Depth.
/// </summary>
template <typename T>
class EMBER_API DepthVariation : public ParametricVariation<T>
class DepthVariation : public ParametricVariation<T>
{
public:
DepthVariation(T weight = 1.0) : ParametricVariation<T>("depth", eVariationId::VAR_DEPTH, weight)
@ -1154,7 +1154,7 @@ private:
/// CropN.
/// </summary>
template <typename T>
class EMBER_API CropNVariation : public ParametricVariation<T>
class CropNVariation : public ParametricVariation<T>
{
public:
CropNVariation(T weight = 1.0) : ParametricVariation<T>("cropn", eVariationId::VAR_CROPN, weight, true, true, false, false, true)
@ -1272,7 +1272,7 @@ private:
/// ShredRad.
/// </summary>
template <typename T>
class EMBER_API ShredRadVariation : public ParametricVariation<T>
class ShredRadVariation : public ParametricVariation<T>
{
public:
ShredRadVariation(T weight = 1.0) : ParametricVariation<T>("shredrad", eVariationId::VAR_SHRED_RAD, weight, true, true, false, false, true)
@ -1336,7 +1336,7 @@ private:
/// Blob2.
/// </summary>
template <typename T>
class EMBER_API Blob2Variation : public ParametricVariation<T>
class Blob2Variation : public ParametricVariation<T>
{
public:
Blob2Variation(T weight = 1.0) : ParametricVariation<T>("blob2", eVariationId::VAR_BLOB2, weight, true, true, false, false, true)
@ -1447,7 +1447,7 @@ private:
/// Julia3D.
/// </summary>
template <typename T>
class EMBER_API Julia3DVariation : public ParametricVariation<T>
class Julia3DVariation : public ParametricVariation<T>
{
public:
Julia3DVariation(T weight = 1.0) : ParametricVariation<T>("julia3D", eVariationId::VAR_JULIA3D, weight, true, true, false, false, true)
@ -1524,7 +1524,7 @@ private:
/// Julia3Dz.
/// </summary>
template <typename T>
class EMBER_API Julia3DzVariation : public ParametricVariation<T>
class Julia3DzVariation : public ParametricVariation<T>
{
public:
Julia3DzVariation(T weight = 1.0) : ParametricVariation<T>("julia3Dz", eVariationId::VAR_JULIA3DZ, weight, true, true, false, false, true)
@ -1597,7 +1597,7 @@ private:
/// LinearT.
/// </summary>
template <typename T>
class EMBER_API LinearTVariation : public ParametricVariation<T>
class LinearTVariation : public ParametricVariation<T>
{
public:
LinearTVariation(T weight = 1.0) : ParametricVariation<T>("linearT", eVariationId::VAR_LINEAR_T, weight)
@ -1653,7 +1653,7 @@ private:
/// LinearT3D.
/// </summary>
template <typename T>
class EMBER_API LinearT3DVariation : public ParametricVariation<T>
class LinearT3DVariation : public ParametricVariation<T>
{
public:
LinearT3DVariation(T weight = 1.0) : ParametricVariation<T>("linearT3D", eVariationId::VAR_LINEAR_T3D, weight)
@ -1707,7 +1707,7 @@ private:
/// Ovoid.
/// </summary>
template <typename T>
class EMBER_API OvoidVariation : public ParametricVariation<T>
class OvoidVariation : public ParametricVariation<T>
{
public:
OvoidVariation(T weight = 1.0) : ParametricVariation<T>("ovoid", eVariationId::VAR_OVOID, weight, true)
@ -1766,7 +1766,7 @@ private:
/// Ovoid3D.
/// </summary>
template <typename T>
class EMBER_API Ovoid3DVariation : public ParametricVariation<T>
class Ovoid3DVariation : public ParametricVariation<T>
{
public:
Ovoid3DVariation(T weight = 1.0) : ParametricVariation<T>("ovoid3d", eVariationId::VAR_OVOID3D, weight, true)
@ -1828,7 +1828,7 @@ private:
/// Spirograph.
/// </summary>
template <typename T>
class EMBER_API SpirographVariation : public ParametricVariation<T>
class SpirographVariation : public ParametricVariation<T>
{
public:
SpirographVariation(T weight = 1.0) : ParametricVariation<T>("Spirograph", eVariationId::VAR_SPIROGRAPH, weight)
@ -1909,7 +1909,7 @@ private:
/// Petal.
/// </summary>
template <typename T>
class EMBER_API PetalVariation : public Variation<T>
class PetalVariation : public Variation<T>
{
public:
PetalVariation(T weight = 1.0) : Variation<T>("petal", eVariationId::VAR_PETAL, weight) { }
@ -1957,7 +1957,7 @@ public:
/// RoundSpher.
/// </summary>
template <typename T>
class EMBER_API RoundSpherVariation : public Variation<T>
class RoundSpherVariation : public Variation<T>
{
public:
RoundSpherVariation(T weight = 1.0) : Variation<T>("roundspher", eVariationId::VAR_ROUNDSPHER, weight, true) { }
@ -1991,7 +1991,7 @@ public:
/// roundSpher3D.
/// </summary>
template <typename T>
class EMBER_API RoundSpher3DVariation : public Variation<T>
class RoundSpher3DVariation : public Variation<T>
{
public:
RoundSpher3DVariation(T weight = 1.0) : Variation<T>("roundspher3D", eVariationId::VAR_ROUNDSPHER3D, weight, true, true) { }
@ -2110,7 +2110,7 @@ public:
/// SpiralWing.
/// </summary>
template <typename T>
class EMBER_API SpiralWingVariation : public Variation<T>
class SpiralWingVariation : public Variation<T>
{
public:
SpiralWingVariation(T weight = 1.0) : Variation<T>("spiralwing", eVariationId::VAR_SPIRAL_WING, weight, true) { }
@ -2153,7 +2153,7 @@ public:
/// Squarize.
/// </summary>
template <typename T>
class EMBER_API SquarizeVariation : public Variation<T>
class SquarizeVariation : public Variation<T>
{
public:
SquarizeVariation(T weight = 1.0) : Variation<T>("squarize", eVariationId::VAR_SQUARIZE, weight, true, true, false, false, true) { }
@ -2246,7 +2246,7 @@ public:
/// Sschecks.
/// </summary>
template <typename T>
class EMBER_API SschecksVariation : public ParametricVariation<T>
class SschecksVariation : public ParametricVariation<T>
{
public:
SschecksVariation(T weight = 1.0) : ParametricVariation<T>("sschecks", eVariationId::VAR_SSCHECKS, weight, true)
@ -2344,7 +2344,7 @@ private:
/// PhoenixJulia.
/// </summary>
template <typename T>
class EMBER_API PhoenixJuliaVariation : public ParametricVariation<T>
class PhoenixJuliaVariation : public ParametricVariation<T>
{
public:
PhoenixJuliaVariation(T weight = 1.0) : ParametricVariation<T>("phoenix_julia", eVariationId::VAR_PHOENIX_JULIA, weight, true)
@ -2426,7 +2426,7 @@ private:
/// Mobius.
/// </summary>
template <typename T>
class EMBER_API MobiusVariation : public ParametricVariation<T>
class MobiusVariation : public ParametricVariation<T>
{
public:
MobiusVariation(T weight = 1.0) : ParametricVariation<T>("Mobius", eVariationId::VAR_MOBIUS, weight)
@ -2511,7 +2511,7 @@ private:
/// MobiusN.
/// </summary>
template <typename T>
class EMBER_API MobiusNVariation : public ParametricVariation<T>
class MobiusNVariation : public ParametricVariation<T>
{
public:
MobiusNVariation(T weight = 1.0) : ParametricVariation<T>("MobiusN", eVariationId::VAR_MOBIUSN, weight, true, true, false, false, true)
@ -2632,7 +2632,7 @@ private:
/// Rename this mobius_strip for deconfliction, which breaks backward compatibility.
/// </summary>
template <typename T>
class EMBER_API MobiusStripVariation : public ParametricVariation<T>
class MobiusStripVariation : public ParametricVariation<T>
{
public:
MobiusStripVariation(T weight = 1.0) : ParametricVariation<T>("mobius_strip", eVariationId::VAR_MOBIUS_STRIP, weight)
@ -2799,7 +2799,7 @@ private:
/// Lissajous.
/// </summary>
template <typename T>
class EMBER_API LissajousVariation : public ParametricVariation<T>
class LissajousVariation : public ParametricVariation<T>
{
public:
LissajousVariation(T weight = 1.0) : ParametricVariation<T>("Lissajous", eVariationId::VAR_LISSAJOUS, weight)
@ -2874,7 +2874,7 @@ private:
/// svf.
/// </summary>
template <typename T>
class EMBER_API SvfVariation : public ParametricVariation<T>
class SvfVariation : public ParametricVariation<T>
{
public:
SvfVariation(T weight = 1.0) : ParametricVariation<T>("svf", eVariationId::VAR_SVF, weight)
@ -2933,7 +2933,7 @@ private:
/// target.
/// </summary>
template <typename T>
class EMBER_API TargetVariation : public ParametricVariation<T>
class TargetVariation : public ParametricVariation<T>
{
public:
TargetVariation(T weight = 1.0) : ParametricVariation<T>("target", eVariationId::VAR_TARGET, weight, true, true, false, false, true)
@ -3021,7 +3021,7 @@ private:
/// taurus.
/// </summary>
template <typename T>
class EMBER_API TaurusVariation : public ParametricVariation<T>
class TaurusVariation : public ParametricVariation<T>
{
public:
TaurusVariation(T weight = 1.0) : ParametricVariation<T>("taurus", eVariationId::VAR_TAURUS, weight)
@ -3105,7 +3105,7 @@ private:
/// collideoscope.
/// </summary>
template <typename T>
class EMBER_API CollideoscopeVariation : public ParametricVariation<T>
class CollideoscopeVariation : public ParametricVariation<T>
{
public:
CollideoscopeVariation(T weight = 1.0) : ParametricVariation<T>("collideoscope", eVariationId::VAR_COLLIDEOSCOPE, weight, true, true, false, false, true)
@ -3223,7 +3223,7 @@ private:
/// bMod.
/// </summary>
template <typename T>
class EMBER_API BModVariation : public ParametricVariation<T>
class BModVariation : public ParametricVariation<T>
{
public:
BModVariation(T weight = 1.0) : ParametricVariation<T>("bMod", eVariationId::VAR_BMOD, weight)
@ -3294,7 +3294,7 @@ private:
/// bSwirl.
/// </summary>
template <typename T>
class EMBER_API BSwirlVariation : public ParametricVariation<T>
class BSwirlVariation : public ParametricVariation<T>
{
public:
BSwirlVariation(T weight = 1.0) : ParametricVariation<T>("bSwirl", eVariationId::VAR_BSWIRL, weight)
@ -3361,7 +3361,7 @@ private:
/// bTransform.
/// </summary>
template <typename T>
class EMBER_API BTransformVariation : public ParametricVariation<T>
class BTransformVariation : public ParametricVariation<T>
{
public:
BTransformVariation(T weight = 1.0) : ParametricVariation<T>("bTransform", eVariationId::VAR_BTRANSFORM, weight)
@ -3445,7 +3445,7 @@ private:
/// bCollide.
/// </summary>
template <typename T>
class EMBER_API BCollideVariation : public ParametricVariation<T>
class BCollideVariation : public ParametricVariation<T>
{
public:
BCollideVariation(T weight = 1.0) : ParametricVariation<T>("bCollide", eVariationId::VAR_BCOLLIDE, weight)
@ -3542,7 +3542,7 @@ private:
/// eclipse.
/// </summary>
template <typename T>
class EMBER_API EclipseVariation : public ParametricVariation<T>
class EclipseVariation : public ParametricVariation<T>
{
public:
EclipseVariation(T weight = 1.0) : ParametricVariation<T>("eclipse", eVariationId::VAR_ECLIPSE, weight)
@ -3642,7 +3642,7 @@ private:
/// flipcircle.
/// </summary>
template <typename T>
class EMBER_API FlipCircleVariation : public ParametricVariation<T>
class FlipCircleVariation : public ParametricVariation<T>
{
public:
FlipCircleVariation(T weight = 1.0) : ParametricVariation<T>("flipcircle", eVariationId::VAR_FLIP_CIRCLE, weight, true)
@ -3705,7 +3705,7 @@ private:
/// flipy.
/// </summary>
template <typename T>
class EMBER_API FlipYVariation : public Variation<T>
class FlipYVariation : public Variation<T>
{
public:
FlipYVariation(T weight = 1.0) : Variation<T>("flipy", eVariationId::VAR_FLIP_Y, weight) { }
@ -3746,7 +3746,7 @@ public:
/// eCollide.
/// </summary>
template <typename T>
class EMBER_API ECollideVariation : public ParametricVariation<T>
class ECollideVariation : public ParametricVariation<T>
{
public:
ECollideVariation(T weight = 1.0) : ParametricVariation<T>("eCollide", eVariationId::VAR_ECOLLIDE, weight, true)
@ -3884,7 +3884,7 @@ private:
/// eJulia.
/// </summary>
template <typename T>
class EMBER_API EJuliaVariation : public ParametricVariation<T>
class EJuliaVariation : public ParametricVariation<T>
{
public:
EJuliaVariation(T weight = 1.0) : ParametricVariation<T>("eJulia", eVariationId::VAR_EJULIA, weight, true)
@ -4000,7 +4000,7 @@ private:
/// eMod.
/// </summary>
template <typename T>
class EMBER_API EModVariation : public ParametricVariation<T>
class EModVariation : public ParametricVariation<T>
{
public:
EModVariation(T weight = 1.0) : ParametricVariation<T>("eMod", eVariationId::VAR_EMOD, weight, true)
@ -4095,7 +4095,7 @@ private:
/// eMotion.
/// </summary>
template <typename T>
class EMBER_API EMotionVariation : public ParametricVariation<T>
class EMotionVariation : public ParametricVariation<T>
{
public:
EMotionVariation(T weight = 1.0) : ParametricVariation<T>("eMotion", eVariationId::VAR_EMOTION, weight, true)
@ -4199,7 +4199,7 @@ private:
/// ePush.
/// </summary>
template <typename T>
class EMBER_API EPushVariation : public ParametricVariation<T>
class EPushVariation : public ParametricVariation<T>
{
public:
EPushVariation(T weight = 1.0) : ParametricVariation<T>("ePush", eVariationId::VAR_EPUSH, weight, true)
@ -4288,7 +4288,7 @@ private:
/// eRotate.
/// </summary>
template <typename T>
class EMBER_API ERotateVariation : public ParametricVariation<T>
class ERotateVariation : public ParametricVariation<T>
{
public:
ERotateVariation(T weight = 1.0) : ParametricVariation<T>("eRotate", eVariationId::VAR_EROTATE, weight, true)
@ -4368,7 +4368,7 @@ private:
/// eScale.
/// </summary>
template <typename T>
class EMBER_API EScaleVariation : public ParametricVariation<T>
class EScaleVariation : public ParametricVariation<T>
{
public:
EScaleVariation(T weight = 1.0) : ParametricVariation<T>("eScale", eVariationId::VAR_ESCALE, weight, true)

112
Source/Ember/Variations04.h
View File

@ -8,7 +8,7 @@ namespace EmberNs
/// eSwirl.
/// </summary>
template <typename T>
class EMBER_API ESwirlVariation : public ParametricVariation<T>
class ESwirlVariation : public ParametricVariation<T>
{
public:
ESwirlVariation(T weight = 1.0) : ParametricVariation<T>("eSwirl", eVariationId::VAR_ESWIRL, weight, true)
@ -90,7 +90,7 @@ private:
/// lazyTravis.
/// </summary>
template <typename T>
class EMBER_API LazyTravisVariation : public ParametricVariation<T>
class LazyTravisVariation : public ParametricVariation<T>
{
public:
LazyTravisVariation(T weight = 1.0) : ParametricVariation<T>("lazyTravis", eVariationId::VAR_LAZY_TRAVIS, weight)
@ -356,7 +356,7 @@ private:
/// squish.
/// </summary>
template <typename T>
class EMBER_API SquishVariation : public ParametricVariation<T>
class SquishVariation : public ParametricVariation<T>
{
public:
SquishVariation(T weight = 1.0) : ParametricVariation<T>("squish", eVariationId::VAR_SQUISH, weight)
@ -512,7 +512,7 @@ private:
/// circus.
/// </summary>
template <typename T>
class EMBER_API CircusVariation : public ParametricVariation<T>
class CircusVariation : public ParametricVariation<T>
{
public:
CircusVariation(T weight = 1.0) : ParametricVariation<T>("circus", eVariationId::VAR_CIRCUS, weight, true, true, true)
@ -582,7 +582,7 @@ private:
/// tancos.
/// </summary>
template <typename T>
class EMBER_API TancosVariation : public Variation<T>
class TancosVariation : public Variation<T>
{
public:
TancosVariation(T weight = 1.0) : Variation<T>("tancos", eVariationId::VAR_TANCOS, weight, true) { }
@ -621,7 +621,7 @@ public:
/// rippled.
/// </summary>
template <typename T>
class EMBER_API RippledVariation : public Variation<T>
class RippledVariation : public Variation<T>
{
public:
RippledVariation(T weight = 1.0) : Variation<T>("rippled", eVariationId::VAR_RIPPLED, weight, true) { }
@ -661,7 +661,7 @@ public:
/// This uses in/out in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API RotateXVariation : public ParametricVariation<T>
class RotateXVariation : public ParametricVariation<T>
{
public:
RotateXVariation(T weight = 1.0) : ParametricVariation<T>("rotate_x", eVariationId::VAR_ROTATE_X, weight)
@ -744,7 +744,7 @@ private:
/// This uses in/out in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API RotateYVariation : public ParametricVariation<T>
class RotateYVariation : public ParametricVariation<T>
{
public:
RotateYVariation(T weight = 1.0) : ParametricVariation<T>("rotate_y", eVariationId::VAR_ROTATE_Y, weight)
@ -824,7 +824,7 @@ private:
/// This was originally pre and post spin_z, consolidated here to be consistent with the other rotate variations.
/// </summary>
template <typename T>
class EMBER_API RotateZVariation : public ParametricVariation<T>
class RotateZVariation : public ParametricVariation<T>
{
public:
RotateZVariation(T weight = 1.0) : ParametricVariation<T>("rotate_z", eVariationId::VAR_ROTATE_Z, weight)
@ -903,7 +903,7 @@ private:
/// This uses in/out in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API MirrorXVariation : public Variation<T>
class MirrorXVariation : public Variation<T>
{
public:
MirrorXVariation(T weight = 1.0) : Variation<T>("mirror_x", eVariationId::VAR_MIRROR_X, weight) { }
@ -974,7 +974,7 @@ public:
/// This uses in/out in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API MirrorYVariation : public Variation<T>
class MirrorYVariation : public Variation<T>
{
public:
MirrorYVariation(T weight = 1.0) : Variation<T>("mirror_y", eVariationId::VAR_MIRROR_Y, weight) { }
@ -1045,7 +1045,7 @@ public:
/// This uses in/out in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API MirrorZVariation : public Variation<T>
class MirrorZVariation : public Variation<T>
{
public:
MirrorZVariation(T weight = 1.0) : Variation<T>("mirror_z", eVariationId::VAR_MIRROR_Z, weight) { }
@ -1115,7 +1115,7 @@ public:
/// RBlur.
/// </summary>
template <typename T>
class EMBER_API RBlurVariation : public ParametricVariation<T>
class RBlurVariation : public ParametricVariation<T>
{
public:
RBlurVariation(T weight = 1.0) : ParametricVariation<T>("rblur", eVariationId::VAR_RBLUR, weight)
@ -1192,7 +1192,7 @@ private:
/// JuliaNab.
/// </summary>
template <typename T>
class EMBER_API JuliaNabVariation : public ParametricVariation<T>
class JuliaNabVariation : public ParametricVariation<T>
{
public:
JuliaNabVariation(T weight = 1.0) : ParametricVariation<T>("juliaNab", eVariationId::VAR_JULIANAB, weight, true)
@ -1283,7 +1283,7 @@ private:
/// Sintrange.
/// </summary>
template <typename T>
class EMBER_API SintrangeVariation : public ParametricVariation<T>
class SintrangeVariation : public ParametricVariation<T>
{
public:
SintrangeVariation(T weight = 1.0) : ParametricVariation<T>("sintrange", eVariationId::VAR_SINTRANGE, weight)
@ -1338,7 +1338,7 @@ private:
/// Voron.
/// </summary>
template <typename T>
class EMBER_API VoronVariation : public ParametricVariation<T>
class VoronVariation : public ParametricVariation<T>
{
public:
VoronVariation(T weight = 1.0) : ParametricVariation<T>("Voron", eVariationId::VAR_VORON, weight)
@ -1490,7 +1490,7 @@ private:
/// Waffle.
/// </summary>
template <typename T>
class EMBER_API WaffleVariation : public ParametricVariation<T>
class WaffleVariation : public ParametricVariation<T>
{
public:
WaffleVariation(T weight = 1.0) : ParametricVariation<T>("waffle", eVariationId::VAR_WAFFLE, weight)
@ -1616,7 +1616,7 @@ private:
/// Square3D.
/// </summary>
template <typename T>
class EMBER_API Square3DVariation : public Variation<T>
class Square3DVariation : public Variation<T>
{
public:
Square3DVariation(T weight = 1.0) : Variation<T>("square3D", eVariationId::VAR_SQUARE3D, weight) { }
@ -1647,7 +1647,7 @@ public:
/// SuperShape3D.
/// </summary>
template <typename T>
class EMBER_API SuperShape3DVariation : public ParametricVariation<T>
class SuperShape3DVariation : public ParametricVariation<T>
{
public:
SuperShape3DVariation(T weight = 1.0) : ParametricVariation<T>("SuperShape3D", eVariationId::VAR_SUPER_SHAPE3D, weight)
@ -1851,7 +1851,7 @@ private:
/// sphyp3D.
/// </summary>
template <typename T>
class EMBER_API Sphyp3DVariation : public ParametricVariation<T>
class Sphyp3DVariation : public ParametricVariation<T>
{
public:
Sphyp3DVariation(T weight = 1.0) : ParametricVariation<T>("sphyp3D", eVariationId::VAR_SPHYP3D, weight, true)
@ -1935,7 +1935,7 @@ private:
/// circlecrop.
/// </summary>
template <typename T>
class EMBER_API CirclecropVariation : public ParametricVariation<T>
class CirclecropVariation : public ParametricVariation<T>
{
public:
CirclecropVariation(T weight = 1.0) : ParametricVariation<T>("circlecrop", eVariationId::VAR_CIRCLECROP, weight)
@ -2092,7 +2092,7 @@ private:
/// julian3Dx.
/// </summary>
template <typename T>
class EMBER_API Julian3DxVariation : public ParametricVariation<T>
class Julian3DxVariation : public ParametricVariation<T>
{
public:
Julian3DxVariation(T weight = 1.0) : ParametricVariation<T>("julian3Dx", eVariationId::VAR_JULIAN3DX, weight, true, true)
@ -2188,7 +2188,7 @@ private:
/// fourth.
/// </summary>
template <typename T>
class EMBER_API FourthVariation : public ParametricVariation<T>
class FourthVariation : public ParametricVariation<T>
{
public:
FourthVariation(T weight = 1.0) : ParametricVariation<T>("fourth", eVariationId::VAR_FOURTH, weight, true, true, false, false, true)
@ -2356,7 +2356,7 @@ private:
/// mobiq.
/// </summary>
template <typename T>
class EMBER_API MobiqVariation : public ParametricVariation<T>
class MobiqVariation : public ParametricVariation<T>
{
public:
MobiqVariation(T weight = 1.0) : ParametricVariation<T>("mobiq", eVariationId::VAR_MOBIQ, weight)
@ -2507,7 +2507,7 @@ private:
/// spherivoid.
/// </summary>
template <typename T>
class EMBER_API SpherivoidVariation : public ParametricVariation<T>
class SpherivoidVariation : public ParametricVariation<T>
{
public:
SpherivoidVariation(T weight = 1.0) : ParametricVariation<T>("spherivoid", eVariationId::VAR_SPHERIVOID, weight, true, true, false, false, true)
@ -2569,7 +2569,7 @@ private:
/// farblur.
/// </summary>
template <typename T>
class EMBER_API FarblurVariation : public ParametricVariation<T>
class FarblurVariation : public ParametricVariation<T>
{
public:
FarblurVariation(T weight = 1.0) : ParametricVariation<T>("farblur", eVariationId::VAR_FARBLUR, weight)
@ -2658,7 +2658,7 @@ private:
/// curl_sp.
/// </summary>
template <typename T>
class EMBER_API CurlSPVariation : public ParametricVariation<T>
class CurlSPVariation : public ParametricVariation<T>
{
public:
CurlSPVariation(T weight = 1.0) : ParametricVariation<T>("curl_sp", eVariationId::VAR_CURL_SP, weight)
@ -2763,7 +2763,7 @@ private:
/// heat.
/// </summary>
template <typename T>
class EMBER_API HeatVariation : public ParametricVariation<T>
class HeatVariation : public ParametricVariation<T>
{
public:
HeatVariation(T weight = 1.0) : ParametricVariation<T>("heat", eVariationId::VAR_HEAT, weight, true, false, false, false, true)
@ -2906,7 +2906,7 @@ private:
/// interference2.
/// </summary>
template <typename T>
class EMBER_API Interference2Variation : public ParametricVariation<T>
class Interference2Variation : public ParametricVariation<T>
{
public:
Interference2Variation(T weight = 1.0) : ParametricVariation<T>("interference2", eVariationId::VAR_INTERFERENCE2, weight)
@ -3112,7 +3112,7 @@ private:
/// sinq.
/// </summary>
template <typename T>
class EMBER_API SinqVariation : public Variation<T>
class SinqVariation : public Variation<T>
{
public:
SinqVariation(T weight = 1.0) : Variation<T>("sinq", eVariationId::VAR_SINQ, weight) { }
@ -3161,7 +3161,7 @@ public:
/// sinhq.
/// </summary>
template <typename T>
class EMBER_API SinhqVariation : public Variation<T>
class SinhqVariation : public Variation<T>
{
public:
SinhqVariation(T weight = 1.0) : Variation<T>("sinhq", eVariationId::VAR_SINHQ, weight) { }
@ -3210,7 +3210,7 @@ public:
/// secq.
/// </summary>
template <typename T>
class EMBER_API SecqVariation : public Variation<T>
class SecqVariation : public Variation<T>
{
public:
SecqVariation(T weight = 1.0) : Variation<T>("secq", eVariationId::VAR_SECQ, weight, true) { }
@ -3261,7 +3261,7 @@ public:
/// sechq.
/// </summary>
template <typename T>
class EMBER_API SechqVariation : public Variation<T>
class SechqVariation : public Variation<T>
{
public:
SechqVariation(T weight = 1.0) : Variation<T>("sechq", eVariationId::VAR_SECHQ, weight, true) { }
@ -3312,7 +3312,7 @@ public:
/// tanq.
/// </summary>
template <typename T>
class EMBER_API TanqVariation : public Variation<T>
class TanqVariation : public Variation<T>
{
public:
TanqVariation(T weight = 1.0) : Variation<T>("tanq", eVariationId::VAR_TANQ, weight) { }
@ -3368,7 +3368,7 @@ public:
/// tanhq.
/// </summary>
template <typename T>
class EMBER_API TanhqVariation : public Variation<T>
class TanhqVariation : public Variation<T>
{
public:
TanhqVariation(T weight = 1.0) : Variation<T>("tanhq", eVariationId::VAR_TANHQ, weight) { }
@ -3424,7 +3424,7 @@ public:
/// cosq.
/// </summary>
template <typename T>
class EMBER_API CosqVariation : public Variation<T>
class CosqVariation : public Variation<T>
{
public:
CosqVariation(T weight = 1.0) : Variation<T>("cosq", eVariationId::VAR_COSQ, weight) { }
@ -3473,7 +3473,7 @@ public:
/// coshq.
/// </summary>
template <typename T>
class EMBER_API CoshqVariation : public Variation<T>
class CoshqVariation : public Variation<T>
{
public:
CoshqVariation(T weight = 1.0) : Variation<T>("coshq", eVariationId::VAR_COSHQ, weight) { }
@ -3522,7 +3522,7 @@ public:
/// cotq.
/// </summary>
template <typename T>
class EMBER_API CotqVariation : public Variation<T>
class CotqVariation : public Variation<T>
{
public:
CotqVariation(T weight = 1.0) : Variation<T>("cotq", eVariationId::VAR_COTQ, weight) { }
@ -3578,7 +3578,7 @@ public:
/// cothq.
/// </summary>
template <typename T>
class EMBER_API CothqVariation : public Variation<T>
class CothqVariation : public Variation<T>
{
public:
CothqVariation(T weight = 1.0) : Variation<T>("cothq", eVariationId::VAR_COTHQ, weight) { }
@ -3634,7 +3634,7 @@ public:
/// cscq.
/// </summary>
template <typename T>
class EMBER_API CscqVariation : public Variation<T>
class CscqVariation : public Variation<T>
{
public:
CscqVariation(T weight = 1.0) : Variation<T>("cscq", eVariationId::VAR_CSCQ, weight, true) { }
@ -3685,7 +3685,7 @@ public:
/// cschq.
/// </summary>
template <typename T>
class EMBER_API CschqVariation : public Variation<T>
class CschqVariation : public Variation<T>
{
public:
CschqVariation(T weight = 1.0) : Variation<T>("cschq", eVariationId::VAR_CSCHQ, weight, true) { }
@ -3736,7 +3736,7 @@ public:
/// estiq.
/// </summary>
template <typename T>
class EMBER_API EstiqVariation : public Variation<T>
class EstiqVariation : public Variation<T>
{
public:
EstiqVariation(T weight = 1.0) : Variation<T>("estiq", eVariationId::VAR_ESTIQ, weight) { }
@ -3783,7 +3783,7 @@ public:
/// loq.
/// </summary>
template <typename T>
class EMBER_API LoqVariation : public ParametricVariation<T>
class LoqVariation : public ParametricVariation<T>
{
public:
LoqVariation(T weight = 1.0) : ParametricVariation<T>("loq", eVariationId::VAR_LOQ, weight)
@ -3849,7 +3849,7 @@ private:
/// curvature.
/// </summary>
template <typename T>
class EMBER_API CurvatureVariation : public Variation<T>
class CurvatureVariation : public Variation<T>
{
public:
CurvatureVariation(T weight = 1.0) : Variation<T>("curvature", eVariationId::VAR_CURVATURE, weight, true, true, false, false, true) { }
@ -3885,7 +3885,7 @@ public:
/// q_ode.
/// </summary>
template <typename T>
class EMBER_API QodeVariation : public ParametricVariation<T>
class QodeVariation : public ParametricVariation<T>
{
public:
QodeVariation(T weight = 1.0) : ParametricVariation<T>("q_ode", eVariationId::VAR_Q_ODE, weight)
@ -3977,7 +3977,7 @@ private:
/// blur_heart.
/// </summary>
template <typename T>
class EMBER_API BlurHeartVariation : public ParametricVariation<T>
class BlurHeartVariation : public ParametricVariation<T>
{
public:
BlurHeartVariation(T weight = 1.0) : ParametricVariation<T>("blur_heart", eVariationId::VAR_BLUR_HEART, weight)
@ -4073,7 +4073,7 @@ private:
/// Truchet.
/// </summary>
template <typename T>
class EMBER_API TruchetVariation : public ParametricVariation<T>
class TruchetVariation : public ParametricVariation<T>
{
public:
TruchetVariation(T weight = 1.0) : ParametricVariation<T>("Truchet", eVariationId::VAR_TRUCHET, weight)
@ -4392,7 +4392,7 @@ private:
/// gdoffs.
/// </summary>
template <typename T>
class EMBER_API GdoffsVariation : public ParametricVariation<T>
class GdoffsVariation : public ParametricVariation<T>
{
public:
GdoffsVariation(T weight = 1.0) : ParametricVariation<T>("gdoffs", eVariationId::VAR_GDOFFS, weight)
@ -4549,7 +4549,7 @@ private:
/// octagon.
/// </summary>
template <typename T>
class EMBER_API OctagonVariation : public ParametricVariation<T>
class OctagonVariation : public ParametricVariation<T>
{
public:
OctagonVariation(T weight = 1.0) : ParametricVariation<T>("octagon", eVariationId::VAR_OCTAGON, weight)
@ -4689,7 +4689,7 @@ private:
/// trade.
/// </summary>
template <typename T>
class EMBER_API TradeVariation : public ParametricVariation<T>
class TradeVariation : public ParametricVariation<T>
{
public:
TradeVariation(T weight = 1.0) : ParametricVariation<T>("trade", eVariationId::VAR_TRADE, weight)
@ -4834,7 +4834,7 @@ private:
/// Juliac.
/// </summary>
template <typename T>
class EMBER_API JuliacVariation : public ParametricVariation<T>
class JuliacVariation : public ParametricVariation<T>
{
public:
JuliacVariation(T weight = 1.0) : ParametricVariation<T>("Juliac", eVariationId::VAR_JULIAC, weight, true, false, false, false, true)
@ -4909,7 +4909,7 @@ private:
/// blade3D.
/// </summary>
template <typename T>
class EMBER_API Blade3DVariation : public Variation<T>
class Blade3DVariation : public Variation<T>
{
public:
Blade3DVariation(T weight = 1.0) : Variation<T>("blade3D", eVariationId::VAR_BLADE3D, weight, true, true) { }
@ -4947,7 +4947,7 @@ public:
/// Blob3D.
/// </summary>
template <typename T>
class EMBER_API Blob3DVariation : public ParametricVariation<T>
class Blob3DVariation : public ParametricVariation<T>
{
public:
Blob3DVariation(T weight = 1.0) : ParametricVariation<T>("blob3D", eVariationId::VAR_BLOB3D, weight, true, true, true, true)
@ -5019,7 +5019,7 @@ private:
/// blocky.
/// </summary>
template <typename T>
class EMBER_API BlockyVariation : public ParametricVariation<T>
class BlockyVariation : public ParametricVariation<T>
{
public:
BlockyVariation(T weight = 1.0) : ParametricVariation<T>("blocky", eVariationId::VAR_BLOCKY, weight, true)
@ -5175,7 +5175,7 @@ MAKEPREPOSTPARVAR(Blocky, blocky, BLOCKY)
///// LinearXZ.
///// </summary>
//template <typename T>
//class EMBER_API LinearXZVariation : public Variation<T>
//class LinearXZVariation : public Variation<T>
//{
//public:
// LinearXZVariation(T weight = 1.0) : Variation<T>("linearxz", eVariationId::VAR_LINEAR_XZ, weight) { }
@ -5206,7 +5206,7 @@ MAKEPREPOSTPARVAR(Blocky, blocky, BLOCKY)
///// LinearYZ.
///// </summary>
//template <typename T>
//class EMBER_API LinearYZVariation : public Variation<T>
//class LinearYZVariation : public Variation<T>
//{
//public:
// LinearYZVariation(T weight = 1.0) : Variation<T>("linearyz", eVariationId::VAR_LINEAR_YZ, weight) { }

58
Source/Ember/Variations05.h
View File

@ -8,7 +8,7 @@ namespace EmberNs
/// bubble2.
/// </summary>
template <typename T>
class EMBER_API Bubble2Variation : public ParametricVariation<T>
class Bubble2Variation : public ParametricVariation<T>
{
public:
Bubble2Variation(T weight = 1.0) : ParametricVariation<T>("bubble2", eVariationId::VAR_BUBBLE2, weight, true)
@ -79,7 +79,7 @@ private:
/// CircleLinear.
/// </summary>
template <typename T>
class EMBER_API CircleLinearVariation : public ParametricVariation<T>
class CircleLinearVariation : public ParametricVariation<T>
{
public:
CircleLinearVariation(T weight = 1.0) : ParametricVariation<T>("CircleLinear", eVariationId::VAR_CIRCLELINEAR, weight)
@ -260,7 +260,7 @@ private:
/// The original would loop infinitely as x and y approached zero, so put a check for a max of 10 iters.
/// </summary>
template <typename T>
class EMBER_API CircleRandVariation : public ParametricVariation<T>
class CircleRandVariation : public ParametricVariation<T>
{
public:
CircleRandVariation(T weight = 1.0) : ParametricVariation<T>("CircleRand", eVariationId::VAR_CIRCLERAND, weight)
@ -386,7 +386,7 @@ private:
/// The original would loop infinitely as x and y approached zero, so put a check for a max of 10 iters.
/// </summary>
template <typename T>
class EMBER_API CircleTrans1Variation : public ParametricVariation<T>
class CircleTrans1Variation : public ParametricVariation<T>
{
public:
CircleTrans1Variation(T weight = 1.0) : ParametricVariation<T>("CircleTrans1", eVariationId::VAR_CIRCLETRANS1, weight)
@ -576,7 +576,7 @@ private:
/// cubic3D.
/// </summary>
template <typename T>
class EMBER_API Cubic3DVariation : public ParametricVariation<T>
class Cubic3DVariation : public ParametricVariation<T>
{
public:
Cubic3DVariation(T weight = 1.0) : ParametricVariation<T>("cubic3D", eVariationId::VAR_CUBIC3D, weight)
@ -803,7 +803,7 @@ private:
/// cubicLattice_3D.
/// </summary>
template <typename T>
class EMBER_API CubicLattice3DVariation : public ParametricVariation<T>
class CubicLattice3DVariation : public ParametricVariation<T>
{
public:
CubicLattice3DVariation(T weight = 1.0) : ParametricVariation<T>("cubicLattice_3D", eVariationId::VAR_CUBIC_LATTICE3D, weight)
@ -1021,7 +1021,7 @@ private:
/// foci_3D.
/// </summary>
template <typename T>
class EMBER_API Foci3DVariation : public Variation<T>
class Foci3DVariation : public Variation<T>
{
public:
Foci3DVariation(T weight = 1.0) : Variation<T>("foci_3D", eVariationId::VAR_FOCI3D, weight, false, false, false, false, true) { }
@ -1061,7 +1061,7 @@ public:
/// ho.
/// </summary>
template <typename T>
class EMBER_API HoVariation : public ParametricVariation<T>
class HoVariation : public ParametricVariation<T>
{
public:
HoVariation(T weight = 1.0) : ParametricVariation<T>("ho", eVariationId::VAR_HO, weight)
@ -1144,7 +1144,7 @@ private:
/// Julia3Dq.
/// </summary>
template <typename T>
class EMBER_API Julia3DqVariation : public ParametricVariation<T>
class Julia3DqVariation : public ParametricVariation<T>
{
public:
Julia3DqVariation(T weight = 1.0) : ParametricVariation<T>("julia3Dq", eVariationId::VAR_JULIA3DQ, weight, true, true, false, false, true)
@ -1230,7 +1230,7 @@ private:
/// line.
/// </summary>
template <typename T>
class EMBER_API LineVariation : public ParametricVariation<T>
class LineVariation : public ParametricVariation<T>
{
public:
LineVariation(T weight = 1.0) : ParametricVariation<T>("line", eVariationId::VAR_LINE, weight)
@ -1306,7 +1306,7 @@ private:
/// Loonie2.
/// </summary>
template <typename T>
class EMBER_API Loonie2Variation : public ParametricVariation<T>
class Loonie2Variation : public ParametricVariation<T>
{
public:
Loonie2Variation(T weight = 1.0) : ParametricVariation<T>("loonie2", eVariationId::VAR_LOONIE2, weight, true, true)
@ -1467,7 +1467,7 @@ private:
/// Loonie3.
/// </summary>
template <typename T>
class EMBER_API Loonie3Variation : public ParametricVariation<T>
class Loonie3Variation : public ParametricVariation<T>
{
public:
Loonie3Variation(T weight = 1.0) : ParametricVariation<T>("loonie3", eVariationId::VAR_LOONIE3, weight, true)
@ -1555,7 +1555,7 @@ private:
/// loonie_3D.
/// </summary>
template <typename T>
class EMBER_API Loonie3DVariation : public ParametricVariation<T>
class Loonie3DVariation : public ParametricVariation<T>
{
public:
Loonie3DVariation(T weight = 1.0) : ParametricVariation<T>("loonie_3D", eVariationId::VAR_LOONIE3D, weight, true, false, false, false, true)
@ -1637,7 +1637,7 @@ private:
/// mcarpet.
/// </summary>
template <typename T>
class EMBER_API McarpetVariation : public ParametricVariation<T>
class McarpetVariation : public ParametricVariation<T>
{
public:
McarpetVariation(T weight = 1.0) : ParametricVariation<T>("mcarpet", eVariationId::VAR_MCARPET, weight, true)
@ -1706,7 +1706,7 @@ private:
/// which is slightly slower, but more correct.
/// </summary>
template <typename T>
class EMBER_API Waves23DVariation : public ParametricVariation<T>
class Waves23DVariation : public ParametricVariation<T>
{
public:
Waves23DVariation(T weight = 1.0) : ParametricVariation<T>("waves2_3D", eVariationId::VAR_WAVES23D, weight)
@ -1760,7 +1760,7 @@ private:
/// Pie3D.
/// </summary>
template <typename T>
class EMBER_API Pie3DVariation : public ParametricVariation<T>
class Pie3DVariation : public ParametricVariation<T>
{
public:
Pie3DVariation(T weight = 1.0) : ParametricVariation<T>("pie3D", eVariationId::VAR_PIE3D, weight)
@ -1828,7 +1828,7 @@ private:
/// popcorn2_3D.
/// </summary>
template <typename T>
class EMBER_API Popcorn23DVariation : public ParametricVariation<T>
class Popcorn23DVariation : public ParametricVariation<T>
{
public:
Popcorn23DVariation(T weight = 1.0) : ParametricVariation<T>("popcorn2_3D", eVariationId::VAR_POPCORN23D, weight, false, false, false, false, true)
@ -1940,7 +1940,7 @@ private:
/// sinusoidal3d.
/// </summary>
template <typename T>
class EMBER_API Sinusoidal3DVariation : public Variation<T>
class Sinusoidal3DVariation : public Variation<T>
{
public:
Sinusoidal3DVariation(T weight = 1.0) : Variation<T>("sinusoidal3D", eVariationId::VAR_SINUSOIDAL3D, weight) { }
@ -1971,7 +1971,7 @@ public:
/// scry_3D.
/// </summary>
template <typename T>
class EMBER_API Scry3DVariation : public ParametricVariation<T>
class Scry3DVariation : public ParametricVariation<T>
{
public:
Scry3DVariation(T weight = 1.0) : ParametricVariation<T>("scry_3D", eVariationId::VAR_SCRY3D, weight, true, false, false, false, true)
@ -2031,7 +2031,7 @@ private:
/// shredlin.
/// </summary>
template <typename T>
class EMBER_API ShredlinVariation : public ParametricVariation<T>
class ShredlinVariation : public ParametricVariation<T>
{
public:
ShredlinVariation(T weight = 1.0) : ParametricVariation<T>("shredlin", eVariationId::VAR_SHRED_LIN, weight)
@ -2117,7 +2117,7 @@ private:
/// splitbrdr.
/// </summary>
template <typename T>
class EMBER_API SplitBrdrVariation : public ParametricVariation<T>
class SplitBrdrVariation : public ParametricVariation<T>
{
public:
SplitBrdrVariation(T weight = 1.0) : ParametricVariation<T>("SplitBrdr", eVariationId::VAR_SPLIT_BRDR, weight, true)
@ -2261,7 +2261,7 @@ private:
/// wdisc.
/// </summary>
template <typename T>
class EMBER_API WdiscVariation : public Variation<T>
class WdiscVariation : public Variation<T>
{
public:
WdiscVariation(T weight = 1.0) : Variation<T>("wdisc", eVariationId::VAR_WDISC, weight, true, true, false, false, true) { }
@ -2304,7 +2304,7 @@ public:
/// falloff.
/// </summary>
template <typename T>
class EMBER_API FalloffVariation : public ParametricVariation<T>
class FalloffVariation : public ParametricVariation<T>
{
public:
FalloffVariation(T weight = 1.0) : ParametricVariation<T>("falloff", eVariationId::VAR_FALLOFF, weight, false, false, false, false, true)
@ -2467,7 +2467,7 @@ private:
/// falloff2.
/// </summary>
template <typename T>
class EMBER_API Falloff2Variation : public ParametricVariation<T>
class Falloff2Variation : public ParametricVariation<T>
{
public:
Falloff2Variation(T weight = 1.0) : ParametricVariation<T>("falloff2", eVariationId::VAR_FALLOFF2, weight, true, false, false, false, true)
@ -2667,7 +2667,7 @@ private:
/// falloff3.
/// </summary>
template <typename T>
class EMBER_API Falloff3Variation : public ParametricVariation<T>
class Falloff3Variation : public ParametricVariation<T>
{
public:
Falloff3Variation(T weight = 1.0) : ParametricVariation<T>("falloff3", eVariationId::VAR_FALLOFF3, weight, true, false, false, false, true)
@ -2900,7 +2900,7 @@ private:
/// xtrb.
/// </summary>
template <typename T>
class EMBER_API XtrbVariation : public ParametricVariation<T>
class XtrbVariation : public ParametricVariation<T>
{
public:
XtrbVariation(T weight = 1.0) : ParametricVariation<T>("xtrb", eVariationId::VAR_XTRB, weight)
@ -3438,7 +3438,7 @@ private:
/// This uses state and the OpenCL version looks different and better than the CPU.
/// </summary>
template <typename T>
class EMBER_API Hexaplay3DVariation : public ParametricVariation<T>
class Hexaplay3DVariation : public ParametricVariation<T>
{
public:
Hexaplay3DVariation(T weight = 1.0) : ParametricVariation<T>("hexaplay3D", eVariationId::VAR_HEXAPLAY3D, weight)
@ -3717,7 +3717,7 @@ private:
/// This is because different paths do different things to helper.Out.z
/// </summary>
template <typename T>
class EMBER_API Hexnix3DVariation : public ParametricVariation<T>
class Hexnix3DVariation : public ParametricVariation<T>
{
public:
Hexnix3DVariation(T weight = 1.0) : ParametricVariation<T>("hexnix3D", eVariationId::VAR_HEXNIX3D, weight)
@ -4101,7 +4101,7 @@ private:
/// hexcrop.
/// </summary>
template <typename T>
class EMBER_API HexcropVariation : public ParametricVariation<T>
class HexcropVariation : public ParametricVariation<T>
{
public:
HexcropVariation(T weight = 1.0) : ParametricVariation<T>("hexcrop", eVariationId::VAR_HEXCROP, weight)

28
Source/Ember/Variations06.h
View File

@ -8,7 +8,7 @@ namespace EmberNs
/// hexes.
/// </summary>
template <typename T>
class EMBER_API HexesVariation : public ParametricVariation<T>
class HexesVariation : public ParametricVariation<T>
{
public:
HexesVariation(T weight = 1.0) : ParametricVariation<T>("hexes", eVariationId::VAR_HEXES, weight)
@ -300,7 +300,7 @@ private:
/// nBlur.
/// </summary>
template <typename T>
class EMBER_API NblurVariation : public ParametricVariation<T>
class NblurVariation : public ParametricVariation<T>
{
struct RandXyParams
{
@ -1138,7 +1138,7 @@ private:
/// octapol.
/// </summary>
template <typename T>
class EMBER_API OctapolVariation : public ParametricVariation<T>
class OctapolVariation : public ParametricVariation<T>
{
public:
OctapolVariation(T weight = 1.0) : ParametricVariation<T>("octapol", eVariationId::VAR_OCTAPOL, weight)
@ -1477,7 +1477,7 @@ private:
/// This uses the input point in an extremely rare way since it changes it.
/// </summary>
template <typename T>
class EMBER_API CrobVariation : public ParametricVariation<T>
class CrobVariation : public ParametricVariation<T>
{
public:
CrobVariation(T weight = 1.0) : ParametricVariation<T>("crob", eVariationId::VAR_CROB, weight)
@ -1810,7 +1810,7 @@ private:
/// bubbleT3D.
/// </summary>
template <typename T>
class EMBER_API BubbleT3DVariation : public ParametricVariation<T>
class BubbleT3DVariation : public ParametricVariation<T>
{
public:
BubbleT3DVariation(T weight = 1.0) : ParametricVariation<T>("bubbleT3D", eVariationId::VAR_BUBBLET3D, weight, true)
@ -2361,7 +2361,7 @@ private:
/// synth.
/// </summary>
template <typename T>
class EMBER_API SynthVariation : public ParametricVariation<T>
class SynthVariation : public ParametricVariation<T>
{
public:
SynthVariation(T weight = 1.0) : ParametricVariation<T>("synth", eVariationId::VAR_SYNTH, weight, true, true, false, true)
@ -3694,7 +3694,7 @@ private:
/// crackle.
/// </summary>
template <typename T>
class EMBER_API CrackleVariation : public ParametricVariation<T>
class CrackleVariation : public ParametricVariation<T>
{
public:
CrackleVariation(T weight = 1.0) : ParametricVariation<T>("crackle", eVariationId::VAR_CRACKLE, weight)
@ -3922,7 +3922,7 @@ private:
/// This variation is special in that it only exists as a post_.
/// </summary>
template <typename T>
class EMBER_API PostSmartcropVariation : public ParametricVariation<T>
class PostSmartcropVariation : public ParametricVariation<T>
{
public:
PostSmartcropVariation(T weight = 1.0) : ParametricVariation<T>("post_smartcrop", eVariationId::VAR_POST_SMARTCROP, weight)
@ -4428,7 +4428,7 @@ private:
/// erf.
/// </summary>
template <typename T>
class EMBER_API ErfVariation : public Variation<T>
class ErfVariation : public Variation<T>
{
public:
ErfVariation(T weight = 1.0) : Variation<T>("erf", eVariationId::VAR_ERF, weight) { }
@ -4459,7 +4459,7 @@ public:
/// xerf.
/// </summary>
template <typename T>
class EMBER_API XerfVariation : public Variation<T>
class XerfVariation : public Variation<T>
{
public:
XerfVariation(T weight = 1.0) : Variation<T>("xerf", eVariationId::VAR_XERF, weight, true) { }
@ -4494,7 +4494,7 @@ public:
};
template <typename T>
class EMBER_API WVariation : public ParametricVariation<T>
class WVariation : public ParametricVariation<T>
{
public:
WVariation(T weight = 1.0) : ParametricVariation<T>("w", eVariationId::VAR_W, weight, true, true, false, false, true)
@ -4796,7 +4796,7 @@ private:
};
template <typename T>
class EMBER_API XVariation : public ParametricVariation<T>
class XVariation : public ParametricVariation<T>
{
public:
XVariation(T weight = 1.0) : ParametricVariation<T>("x", eVariationId::VAR_X, weight, true, false, false, false, true)
@ -4993,7 +4993,7 @@ private:
};
template <typename T>
class EMBER_API YVariation : public ParametricVariation<T>
class YVariation : public ParametricVariation<T>
{
public:
YVariation(T weight = 1.0) : ParametricVariation<T>("y", eVariationId::VAR_Y, weight, true, true, false, false, true)
@ -5190,7 +5190,7 @@ private:
};
template <typename T>
class EMBER_API ZVariation : public ParametricVariation<T>
class ZVariation : public ParametricVariation<T>
{
public:
ZVariation(T weight = 1.0) : ParametricVariation<T>("z", eVariationId::VAR_Z, weight, true, true, false, false, true)

18
Source/Ember/Variations07.h
View File

@ -8,7 +8,7 @@ namespace EmberNs
/// splits3D.
/// </summary>
template <typename T>
class EMBER_API Splits3DVariation : public ParametricVariation<T>
class Splits3DVariation : public ParametricVariation<T>
{
public:
Splits3DVariation(T weight = 1.0) : ParametricVariation<T>("splits3D", eVariationId::VAR_SPLITS3D, weight)
@ -93,7 +93,7 @@ private:
/// when running on the GPU. The results might look different.
/// </summary>
template <typename T>
class EMBER_API Waves2BVariation : public ParametricVariation<T>
class Waves2BVariation : public ParametricVariation<T>
{
public:
Waves2BVariation(T weight = 1.0) : ParametricVariation<T>("waves2b", eVariationId::VAR_WAVES2B, weight)
@ -249,7 +249,7 @@ private:
/// jac_cn.
/// </summary>
template <typename T>
class EMBER_API JacCnVariation : public ParametricVariation<T>
class JacCnVariation : public ParametricVariation<T>
{
public:
JacCnVariation(T weight = 1.0) : ParametricVariation<T>("jac_cn", eVariationId::VAR_JAC_CN, weight)
@ -322,7 +322,7 @@ private:
/// jac_dn.
/// </summary>
template <typename T>
class EMBER_API JacDnVariation : public ParametricVariation<T>
class JacDnVariation : public ParametricVariation<T>
{
public:
JacDnVariation(T weight = 1.0) : ParametricVariation<T>("jac_dn", eVariationId::VAR_JAC_DN, weight)
@ -395,7 +395,7 @@ private:
/// jac_sn.
/// </summary>
template <typename T>
class EMBER_API JacSnVariation : public ParametricVariation<T>
class JacSnVariation : public ParametricVariation<T>
{
public:
JacSnVariation(T weight = 1.0) : ParametricVariation<T>("jac_sn", eVariationId::VAR_JAC_SN, weight)
@ -468,7 +468,7 @@ private:
/// pressure_wave.
/// </summary>
template <typename T>
class EMBER_API PressureWaveVariation : public ParametricVariation<T>
class PressureWaveVariation : public ParametricVariation<T>
{
public:
PressureWaveVariation(T weight = 1.0) : ParametricVariation<T>("pressure_wave", eVariationId::VAR_PRESSURE_WAVE, weight)
@ -524,7 +524,7 @@ private:
/// gamma.
/// </summary>
template <typename T>
class EMBER_API GammaVariation : public Variation<T>
class GammaVariation : public Variation<T>
{
public:
GammaVariation(T weight = 1.0) : Variation<T>("gamma", eVariationId::VAR_GAMMA, weight, true, true, false, false, true)
@ -559,7 +559,7 @@ public:
/// prose3D.
/// </summary>
template <typename T>
class EMBER_API PRose3DVariation : public ParametricVariation<T>
class PRose3DVariation : public ParametricVariation<T>
{
public:
PRose3DVariation(T weight = 1.0) : ParametricVariation<T>("pRose3D", eVariationId::VAR_PROSE3D, weight, true, true, false, false, true)
@ -863,7 +863,7 @@ private:
/// http://jwildfire.org/forum/viewtopic.php?f=23&t=1450&p=2692#p2692
/// </summary>
template <typename T>
class EMBER_API LogDBVariation : public ParametricVariation<T>
class LogDBVariation : public ParametricVariation<T>
{
public:
LogDBVariation(T weight = 1.0) : ParametricVariation<T>("log_db", eVariationId::VAR_LOG_DB, weight, true, false, false, false, true)

18
Source/Ember/VariationsDC.h
View File

@ -9,7 +9,7 @@ namespace EmberNs
/// This accesses the summed output point in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API DCBubbleVariation : public ParametricVariation<T>
class DCBubbleVariation : public ParametricVariation<T>
{
public:
DCBubbleVariation(T weight = 1.0) : ParametricVariation<T>("dc_bubble", eVariationId::VAR_DC_BUBBLE, weight, true)
@ -120,7 +120,7 @@ private:
/// DC Carpet.
/// </summary>
template <typename T>
class EMBER_API DCCarpetVariation : public ParametricVariation<T>
class DCCarpetVariation : public ParametricVariation<T>
{
public:
DCCarpetVariation(T weight = 1.0) : ParametricVariation<T>("dc_carpet", eVariationId::VAR_DC_CARPET, weight)
@ -191,7 +191,7 @@ private:
/// DC Cube.
/// </summary>
template <typename T>
class EMBER_API DCCubeVariation : public ParametricVariation<T>
class DCCubeVariation : public ParametricVariation<T>
{
public:
DCCubeVariation(T weight = 1.0) : ParametricVariation<T>("dc_cube", eVariationId::VAR_DC_CUBE, weight)
@ -381,7 +381,7 @@ private:
/// This accesses the summed output point in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API DCCylinderVariation : public ParametricVariation<T>
class DCCylinderVariation : public ParametricVariation<T>
{
public:
DCCylinderVariation(T weight = 1.0) : ParametricVariation<T>("dc_cylinder", eVariationId::VAR_DC_CYLINDER, weight)
@ -508,7 +508,7 @@ private:
/// DC GridOut.
/// </summary>
template <typename T>
class EMBER_API DCGridOutVariation : public Variation<T>
class DCGridOutVariation : public Variation<T>
{
public:
DCGridOutVariation(T weight = 1.0) : Variation<T>("dc_gridout", eVariationId::VAR_DC_GRIDOUT, weight) { }
@ -685,7 +685,7 @@ public:
/// This accesses the summed output point in a rare and different way.
/// </summary>
template <typename T>
class EMBER_API DCLinearVariation : public ParametricVariation<T>
class DCLinearVariation : public ParametricVariation<T>
{
public:
DCLinearVariation(T weight = 1.0) : ParametricVariation<T>("dc_linear", eVariationId::VAR_DC_LINEAR, weight)
@ -795,7 +795,7 @@ private:
/// DC Triangle.
/// </summary>
template <typename T>
class EMBER_API DCTriangleVariation : public ParametricVariation<T>
class DCTriangleVariation : public ParametricVariation<T>
{
public:
DCTriangleVariation(T weight = 1.0) : ParametricVariation<T>("dc_triangle", eVariationId::VAR_DC_TRIANGLE, weight)
@ -1004,7 +1004,7 @@ private:
/// These will follow the same naming convention as all other variations.
/// </summary>
template <typename T>
class EMBER_API DCZTranslVariation : public ParametricVariation<T>
class DCZTranslVariation : public ParametricVariation<T>
{
public:
DCZTranslVariation(T weight = 1.0) : ParametricVariation<T>("dc_ztransl", eVariationId::VAR_DC_ZTRANSL, weight)
@ -1109,7 +1109,7 @@ private:
/// dc_perlin.
/// </summary>
template <typename T>
class EMBER_API DCPerlinVariation : public ParametricVariation <T>
class DCPerlinVariation : public ParametricVariation <T>
{
public:
DCPerlinVariation(T weight = 1.0) : ParametricVariation<T>("dc_perlin", eVariationId::VAR_DC_PERLIN, weight)

7
Source/Ember/Xform.h
View File

@ -10,8 +10,8 @@
namespace EmberNs
{
/// <summary>
/// Xform and Variation need each other, but each can't include the other.
/// So Xform includes this file, and Ember is declared as a forward declaration here.
/// Xform and Ember need each other, but each can't include the other.
/// So Ember includes this file, and Ember is declared as a forward declaration here.
/// </summary>
template <typename T> class Ember;
@ -879,6 +879,7 @@ public:
bool Flatten(vector<string>& names)
{
bool shouldFlatten = true;
VariationList<T>& vl(VariationList<T>::Instance());
if (GetVariationById(eVariationId::VAR_FLATTEN) == nullptr)
{
@ -914,7 +915,7 @@ public:
if (shouldFlatten)//Flatten was not present and neither was any variation name or parameter in the list.
{
Variation<T>* var = new FlattenVariation<T>();
auto var = vl.GetVariationCopy(eVariationId::VAR_FLATTEN);
if (AddVariation(var))
{

3
Source/Ember/XmlToEmber.h
View File

@ -74,6 +74,7 @@ public:
/// Constructor that initializes the random context.
/// </summary>
XmlToEmber()
: m_VariationList(VariationList<T>::Instance())
{
Timing t;
@ -1535,7 +1536,7 @@ private:
static bool m_Init;
static unordered_map<string, string> m_BadParamNames;
static vector<pair<pair<string, string>, vector<string>>> m_BadVariationNames;
VariationList<T> m_VariationList;//The variation list used to make copies of variations to populate the embers with.
VariationList<T>& m_VariationList;//The variation list used to make copies of variations to populate the embers with.
PaletteList<T> m_PaletteList;
};
}

13
Source/EmberGenome/EmberGenome.cpp
View File

@ -64,13 +64,13 @@ bool EmberGenome(EmberOptions& opt)
return true;
}
VariationList<T>& varList(VariationList<T>::Instance());
if (opt.AllVars() || opt.RegVars() || opt.PreVars() || opt.PostVars())
{
VariationList<T> vl;
if (opt.AllVars())
{
auto& vars = vl.AllVars();
auto& vars = varList.AllVars();
for (auto& v : vars)
cout << v->Name() << "\n";
@ -82,13 +82,13 @@ bool EmberGenome(EmberOptions& opt)
vector<Variation<T>*> vars;
if (opt.RegVars())
vars.insert(vars.end(), vl.RegVars().begin(), vl.RegVars().end());
vars.insert(vars.end(), varList.RegVars().begin(), varList.RegVars().end());
if (opt.PreVars())
vars.insert(vars.end(), vl.PreVars().begin(), vl.PreVars().end());
vars.insert(vars.end(), varList.PreVars().begin(), varList.PreVars().end());
if (opt.PostVars())
vars.insert(vars.end(), vl.PostVars().begin(), vl.PostVars().end());
vars.insert(vars.end(), varList.PostVars().begin(), varList.PostVars().end());
for (auto& v : vars)
cout << v->Name() << "\n";
@ -116,7 +116,6 @@ bool EmberGenome(EmberOptions& opt)
Ember<T>* aselp0, *aselp1, *pTemplate = nullptr;
XmlToEmber<T> parser;
EmberToXml<T> emberToXml;
VariationList<T> varList;
EmberReport emberReport, emberReport2;
const vector<pair<size_t, size_t>> devices = Devices(opt.Devices());
unique_ptr<RenderProgress<T>> progress(new RenderProgress<T>());

38
Source/EmberTester/EmberTester.cpp
View File

@ -89,7 +89,7 @@ void MakeTestAllVarsRegPrePost(vector<Ember<T>>& embers)
{
uint index = 0;
ostringstream ss;
VariationList<T> varList;
VariationList<T>& varList(VariationList<T>::Instance());
PaletteList<T> paletteList;
QTIsaac<ISAAC_SIZE, ISAAC_INT> rand;
paletteList.Add("flam3-palettes.xml");
@ -337,7 +337,7 @@ template <typename T>
static vector<Variation<T>*> FindVarsWith(vector<string>& stringVec, bool findAll = true)
{
int index = 0;
VariationList<T> vl;
VariationList<T>& vl(VariationList<T>::Instance());
vector<Variation<T>*> vec;
while (index < vl.RegSize())
@ -360,9 +360,9 @@ static vector<Variation<T>*> FindVarsWith(vector<string>& stringVec, bool findAl
bool TestVarCounts()
{
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
#ifdef DO_DOUBLE
VariationList<double> vld;
VariationList<double>& vld(VariationList<double>::Instance());
bool success((vlf.Size() == vld.Size()) && (vlf.Size() == size_t(eVariationId::LAST_VAR)));
#else
bool success = true;
@ -392,7 +392,7 @@ template <typename T>
bool TestVarUnique()
{
bool success = true;
VariationList<T> vl;
VariationList<T>& vl(VariationList<T>::Instance());
vector<eVariationId> ids;
vector<string> names;
ids.reserve(vl.Size());
@ -580,7 +580,7 @@ bool TestVarEqual(const Variation<sT>* var1, const Variation<dT>* var2)
bool TestVarPrePostNames()
{
bool success = true;
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
for (size_t i = 0; i < vlf.Size(); i++)
{
@ -646,7 +646,7 @@ template <typename sT, typename dT>
bool TestVarCopy()
{
bool success = true;
VariationList<sT> vlf;
VariationList<sT>& vlf(VariationList<sT>::Instance());
for (size_t i = 0; i < vlf.Size(); i++)
{
@ -676,7 +676,7 @@ bool TestVarCopy()
bool TestParVars()
{
bool success = true;
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
for (size_t i = 0; i < vlf.ParametricSize(); i++)
{
@ -730,7 +730,7 @@ bool TestParVars()
bool TestVarRegPrePost()
{
bool success = true;
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
for (size_t i = 0; i < vlf.RegSize(); i++)
{
@ -782,7 +782,7 @@ bool TestVarRegPrePost()
bool TestVarPrecalcUsedCL()
{
bool success = true;
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
for (size_t i = 0; i < vlf.Size(); i++)
{
@ -951,7 +951,7 @@ bool TestVarPrecalcUsedCL()
bool TestVarAssignTypes()
{
bool success = true;
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
vector<string> vset, vsum;
vset.push_back("vIn.x");
vset.push_back("vIn.y");
@ -1009,7 +1009,7 @@ bool TestVarAssignTypes()
bool TestVarAssignVals()
{
bool success = true;
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
vector<string> xout, yout, zout;
xout.push_back("vOut.x =");
xout.push_back("vOut.x +=");
@ -1056,7 +1056,7 @@ bool TestVarAssignVals()
bool TestZepsFloor()
{
bool success = true;
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
vector<string> zeps;
zeps.push_back("Zeps(floor");
@ -1077,7 +1077,7 @@ bool TestZepsFloor()
bool TestConstants()
{
bool success = true;
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
vector<string> stringVec;
stringVec.push_back("2 * M_PI");
stringVec.push_back("2*M_PI");
@ -1101,7 +1101,7 @@ bool TestConstants()
bool TestGlobalFuncs()
{
bool success = true;
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
vector<string> funcs;
FunctionMapper mapper;
@ -1130,7 +1130,7 @@ bool TestGlobalFuncs()
void PrintAllVars()
{
uint i = 0;
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
while (auto var = vlf.GetVariation(i++))
cout << var->Name() << endl;
@ -1139,7 +1139,7 @@ void PrintAllVars()
void TestXformsInOutPoints()
{
uint index = 0;
VariationList<float> varList;
VariationList<float>& varList(VariationList<float>::Instance());
PaletteList<float> paletteList;
QTIsaac<ISAAC_SIZE, ISAAC_INT> rand;
paletteList.Add("flam3-palettes.xml");
@ -2111,12 +2111,12 @@ int _tmain(int argc, _TCHAR* argv[])
TestCasting();
t.Toc("TestCasting()");
t.Tic();
VariationList<float> vlf;
VariationList<float>& vlf(VariationList<float>::Instance());
t.Toc("Creating VariationList<float>");
cout << "There are " << vlf.Size() << " variations present." << endl;
#ifdef DO_DOUBLE
t.Tic();
VariationList<double> vld;
VariationList<double>& vld(VariationList<double>::Instance());
t.Toc("Creating VariationList<double>");
#endif
t.Tic();

3
Source/Fractorium/FractoriumEmberController.cpp
View File

@ -48,7 +48,8 @@ FractoriumEmberControllerBase::~FractoriumEmberControllerBase()
/// <param name="fractorium">Pointer to the main window.</param>
template <typename T>
FractoriumEmberController<T>::FractoriumEmberController(Fractorium* fractorium)
: FractoriumEmberControllerBase(fractorium)
: FractoriumEmberControllerBase(fractorium),
m_VariationList(VariationList<T>::Instance())
{
bool b = false;
m_PreviewRun = false;

2
Source/Fractorium/FractoriumEmberController.h
View File

@ -499,7 +499,7 @@ private:
Xform<T> m_CopiedFinalXform;
Palette<T> m_TempPalette;
PaletteList<T> m_PaletteList;
VariationList<T> m_VariationList;
VariationList<T>& m_VariationList;
unique_ptr<SheepTools<T, float>> m_SheepTools;
unique_ptr<GLEmberController<T>> m_GLController;
unique_ptr<EmberNs::Renderer<T, float>> m_PreviewRenderer;

2
Source/Fractorium/FractoriumXforms.cpp
View File

@ -282,7 +282,7 @@ void FractoriumEmberController<T>::AddFinalXform()
{
Xform<T> final;
auto combo = m_Fractorium->ui.CurrentXformCombo;
final.AddVariation(new LinearVariation<T>());//Just a placeholder so other parts of the code don't see it as being empty.
final.AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR));//Just a placeholder so other parts of the code don't see it as being empty.
m_Ember.SetFinalXform(final);
int index = int(m_Ember.TotalXformCount() - 1);//Set index to the last item.
FillXforms(index);

3
Source/Fractorium/VariationsDialog.cpp
View File

@ -10,7 +10,8 @@
/// <param name="f">The window flags. Default: 0.</param>
FractoriumVariationsDialog::FractoriumVariationsDialog(FractoriumSettings* settings, QWidget* p, Qt::WindowFlags f)
: QDialog(p, f),
m_Settings(settings)
m_Settings(settings),
m_VariationList(VariationList<float>::Instance())
{
ui.setupUi(this);
auto table = ui.VariationsTable;

2
Source/Fractorium/VariationsDialog.h
View File

@ -41,7 +41,7 @@ private:
void GuiToData();
void Populate();
void SetCheckFromMap(QTableWidgetItem* cb, const Variation<float>* var);
VariationList<float> m_VariationList;
VariationList<float>& m_VariationList;
QMap<QString, QVariant> m_Vars;
FractoriumSettings* m_Settings;
Ui::VariationsDialog ui;