--Code changes

-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.

Builds/MSVC/VS2013/Ember.vcxproj

@@ -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">

Builds/MSVC/VS2013/Ember.vcxproj.filters

@@ -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" />

Builds/QtCreator/Ember/Ember.pro

@@ -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()

Source/Ember/Affine2D.h

@@ -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
 }

Source/Ember/Ember.cpp

@@ -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 class varName##Variation<T>; \
-	template EMBER_API class Pre##varName##Variation<T>; \
+	template class Pre##varName##Variation<T>; \
-	template EMBER_API class Post##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"; \

Source/Ember/Ember.h

@@ -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.

Source/Ember/Interpolate.h

@@ -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>();
+								if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_RECTANGLES))
-								var->SetParamVal("rectangles_x", 0);
+								{
-								var->SetParamVal("rectangles_y", 0);
+									var->SetParamVal("rectangles_x", 0);
-								destXform->AddVariation(var);
+									var->SetParamVal("rectangles_y", 0);
+									destXform->AddVariation(var);
+								}
+
 								found++;
 							}
 
 							if (destOtherXform->GetVariationById(eVariationId::VAR_RINGS2))
 							{
-								Rings2Variation<T>* var = new Rings2Variation<T>();
+								if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_RINGS2))
-								var->SetParamVal("rings2_val", 0);
+								{
-								destXform->AddVariation(var);
+									var->SetParamVal("rings2_val", 0);
+									destXform->AddVariation(var);
+								}
+
 								found++;
 							}
 
 							if (destOtherXform->GetVariationById(eVariationId::VAR_FAN2))
 							{
-								Fan2Variation<T>* var = new Fan2Variation<T>();
+								destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_FAN2));
-								destXform->AddVariation(var);
 								found++;
 							}
 
 							if (destOtherXform->GetVariationById(eVariationId::VAR_BLOB))
 							{
-								BlobVariation<T>* var = new BlobVariation<T>();
+								if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_BLOB))
-								var->SetParamVal("blob_low", 1);
+								{
-								destXform->AddVariation(var);
+									var->SetParamVal("blob_low", 1);
+									destXform->AddVariation(var);
+								}
+
 								found++;
 							}
 
 							if (destOtherXform->GetVariationById(eVariationId::VAR_PERSPECTIVE))
 							{
-								PerspectiveVariation<T>* var = new PerspectiveVariation<T>();
+								destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_PERSPECTIVE));
-								destXform->AddVariation(var);
 								found++;
 							}
 
 							if (destOtherXform->GetVariationById(eVariationId::VAR_CURL))
 							{
-								CurlVariation<T>* var = new CurlVariation<T>();
+								if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_CURL))
-								var->SetParamVal("curl_c1", 0);
+								{
-								destXform->AddVariation(var);
+									var->SetParamVal("curl_c1", 0);
+									destXform->AddVariation(var);
+								}
+
 								found++;
 							}
 
 							if (destOtherXform->GetVariationById(eVariationId::VAR_SUPER_SHAPE))
 							{
-								SuperShapeVariation<T>* var = new SuperShapeVariation<T>();
+								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_n1", 2);
-								var->SetParamVal("super_shape_n3", 2);
+									var->SetParamVal("super_shape_n2", 2);
-								destXform->AddVariation(var);
+									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.

Source/Ember/Renderer.cpp

@@ -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>

Source/Ember/SheepTools.h

@@ -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>());
+		xform1.AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR));
-		xform2.AddVariation(new LinearVariation<T>());
+		xform2.AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR));
-		xform3.AddVariation(new LinearVariation<T>());
+		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;
 };
 }

Source/Ember/VariationList.cpp

@@ -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
+}

Source/Ember/VariationList.h

@@ -1,13 +1,6 @@
 #pragma once
 
-#include "Variations01.h"
+#include "Variation.h"
-#include "Variations02.h"
-#include "Variations03.h"
-#include "Variations04.h"
-#include "Variations05.h"
-#include "Variations06.h"
-#include "Variations07.h"
-#include "VariationsDC.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>
+	static VariationList<T>& Instance();
-	/// Constructor which initializes all of the variation objects and stores them in the list.
+	~VariationList();
-	/// </summary>
+	VariationList<T>(const VariationList<T>& varList) = delete;
-	VariationList()
+	VariationList<T>& operator = (const VariationList<T>& varList) = delete;
-	{
+	const Variation<T>* GetVariation(size_t index) const;
-		m_Variations.reserve(size_t(eVariationId::LAST_VAR));
+	const Variation<T>* GetVariation(size_t index, eVariationType varType) const;
-		ADDPREPOSTREGVAR(Linear)
+	Variation<T>* GetVariationCopy(size_t index, T weight = 1) const;
-		ADDPREPOSTREGVAR(Sinusoidal)
+	Variation<T>* GetVariationCopy(size_t index, eVariationType varType, T weight = 1) const;
-		ADDPREPOSTREGVAR(Spherical)
+	const Variation<T>* GetVariation(eVariationId id) const;
-		ADDPREPOSTREGVAR(Swirl)
+	Variation<T>* GetVariationCopy(eVariationId id, T weight = 1) const;
-		ADDPREPOSTREGVAR(Horseshoe)
+	const Variation<T>* GetVariation(const string& name) const;
-		ADDPREPOSTREGVAR(Polar)
+	Variation<T>* GetVariationCopy(const string& name, T weight = 1) const;
-		ADDPREPOSTREGVAR(Handkerchief)
+	const ParametricVariation<T>* GetParametricVariation(size_t index) const;
-		ADDPREPOSTREGVAR(Heart)
+	const ParametricVariation<T>* GetParametricVariation(const string& name) const;
-		ADDPREPOSTREGVAR(Disc)
+	ParametricVariation<T>* GetParametricVariationCopy(eVariationId id, T weight = 1) const;
-		ADDPREPOSTREGVAR(Spiral)
+	int GetVariationIndex(const string& name) const;
-		ADDPREPOSTREGVAR(Hyperbolic)
+	size_t Size() const;
-		ADDPREPOSTREGVAR(Diamond)
+	size_t RegSize() const;
-		ADDPREPOSTREGVAR(Ex)
+	size_t PreSize() const;
-		ADDPREPOSTREGVAR(Julia)
+	size_t PostSize() const;
-		ADDPREPOSTREGVAR(Bent)
+	size_t ParametricSize() const;
-		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();
+	const vector<Variation<T>*>& AllVars()  const;
-
+	const vector<Variation<T>*>& RegVars()  const;
-		std::sort(m_Variations.begin(), m_Variations.end(), [&](const Variation<T>* var1, const Variation<T>* var2) { return var1->VariationId() < var2->VariationId(); });
+	const vector<Variation<T>*>& PreVars()  const;
-		m_RegVariations.reserve(m_Variations.size()  / 3);
+	const vector<Variation<T>*>& PostVars() const;
-		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; }
 
 private:
-	/// <summary>
+	VariationList();
-	/// Make a dyncamically allocated copy of a variation and assign it a specified weight.
+	Variation<T>* MakeCopyWithWeight(const Variation<T>* var, T weight) const;
-	/// 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;
-	}
 
 	vector<Variation<T>*> m_Variations;//A list of pointers to dynamically allocated variation objects.
 	vector<Variation<T>*> m_RegVariations;

Source/Ember/Variations01.h

@@ -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)

Source/Ember/Variations02.h

@@ -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)

Source/Ember/Variations03.h

@@ -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)

Source/Ember/Variations04.h

@@ -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) { }

Source/Ember/Variations05.h

@@ -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)

Source/Ember/Variations06.h

@@ -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)

Source/Ember/Variations07.h

@@ -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)

Source/Ember/VariationsDC.h

@@ -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)

Source/Ember/Xform.h

@@ -10,8 +10,8 @@
 namespace EmberNs
 {
 /// <summary>
-/// Xform and Variation need each other, but each can't include the other.
+/// Xform and Ember need each other, but each can't include the other.
-/// So Xform includes this file, and Ember is declared as a forward declaration here.
+/// 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))
 				{

Source/Ember/XmlToEmber.h

@@ -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;
 };
 }

Source/EmberGenome/EmberGenome.cpp

@@ -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>());

Source/EmberTester/EmberTester.cpp

@@ -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();

Source/Fractorium/FractoriumEmberController.cpp

@@ -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;

Source/Fractorium/FractoriumEmberController.h

@@ -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;

Source/Fractorium/FractoriumXforms.cpp

@@ -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);

Source/Fractorium/VariationsDialog.cpp

@@ -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;

Source/Fractorium/VariationsDialog.h

@@ -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;