diff --git a/Builds/MSVC/VS2013/Ember.vcxproj b/Builds/MSVC/VS2013/Ember.vcxproj index 0688dec..36a660c 100644 --- a/Builds/MSVC/VS2013/Ember.vcxproj +++ b/Builds/MSVC/VS2013/Ember.vcxproj @@ -320,6 +320,7 @@ + diff --git a/Builds/MSVC/VS2013/Ember.vcxproj.filters b/Builds/MSVC/VS2013/Ember.vcxproj.filters index c5bda1e..62849b1 100644 --- a/Builds/MSVC/VS2013/Ember.vcxproj.filters +++ b/Builds/MSVC/VS2013/Ember.vcxproj.filters @@ -145,6 +145,9 @@ Source Files + + Header Files\Variations + diff --git a/Builds/QtCreator/Ember/Ember.pro b/Builds/QtCreator/Ember/Ember.pro index 9f0ea05..45e613b 100644 --- a/Builds/QtCreator/Ember/Ember.pro +++ b/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() diff --git a/Source/Ember/Affine2D.h b/Source/Ember/Affine2D.h index e30110e..b2c4353 100644 --- a/Source/Ember/Affine2D.h +++ b/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; - -//#ifdef DO_DOUBLE -// template EMBER_API class Affine2D; -//#endif } diff --git a/Source/Ember/Ember.cpp b/Source/Ember/Ember.cpp index eb6bd76..4e878fd 100644 --- a/Source/Ember/Ember.cpp +++ b/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; \ - template EMBER_API class Pre##varName##Variation; \ - template EMBER_API class Post##varName##Variation; + template class varName##Variation; \ + template class Pre##varName##Variation; \ + template class Post##varName##Variation; #define EXPORT_SINGLE_TYPE_EMBER(T) \ template<> const char* PaletteList::m_DefaultFilename = "flam3-palettes.xml"; \ diff --git a/Source/Ember/Ember.h b/Source/Ember/Ember.h index 856b6c9..e294ce8 100644 --- a/Source/Ember/Ember.h +++ b/Source/Ember/Ember.h @@ -13,6 +13,8 @@ namespace EmberNs { +template class Interpolater; + /// /// 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. /// Ember() + : m_VariationList(VariationList::Instance()) { Init(); } @@ -51,7 +54,8 @@ public: /// /// The Ember object to copy Ember(const Ember& ember) - : m_Edits(nullptr) + : m_VariationList(VariationList::Instance()), + m_Edits(nullptr) { Ember::operator=(ember); } @@ -62,7 +66,8 @@ public: /// The Ember object to copy template Ember(const Ember& ember) - : m_Edits(nullptr) + : m_VariationList(VariationList::Instance()), + m_Edits(nullptr) { Ember::operator=(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(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()); + 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()); + m_Xforms[i].AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR)); result++; } @@ -1747,6 +1752,9 @@ private: //Xml field: "finalxform". Xform m_FinalXform; + //Single global reference to create variations with. + VariationList& m_VariationList; + /// /// Interpolation function that takes the address of a member variable of type T as a template parameter. /// This is an alternative to using macros. diff --git a/Source/Ember/Interpolate.h b/Source/Ember/Interpolate.h index dcfa744..7d56def 100644 --- a/Source/Ember/Interpolate.h +++ b/Source/Ember/Interpolate.h @@ -1,6 +1,7 @@ #pragma once #include "Ember.h" +#include "VariationList.h" /// /// Interpolater class. @@ -12,6 +13,7 @@ namespace EmberNs /// g++ needs a forward declaration here. /// template class Ember; +template class VariationList; /// /// 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* destOtherXform; + VariationList& variationList(VariationList::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(-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* var = new RectanglesVariation(); - var->SetParamVal("rectangles_x", 0); - var->SetParamVal("rectangles_y", 0); - destXform->AddVariation(var); + if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_RECTANGLES)) + { + var->SetParamVal("rectangles_x", 0); + var->SetParamVal("rectangles_y", 0); + destXform->AddVariation(var); + } + found++; } if (destOtherXform->GetVariationById(eVariationId::VAR_RINGS2)) { - Rings2Variation* var = new Rings2Variation(); - var->SetParamVal("rings2_val", 0); - destXform->AddVariation(var); + if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_RINGS2)) + { + var->SetParamVal("rings2_val", 0); + destXform->AddVariation(var); + } + found++; } if (destOtherXform->GetVariationById(eVariationId::VAR_FAN2)) { - Fan2Variation* var = new Fan2Variation(); - destXform->AddVariation(var); + destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_FAN2)); found++; } if (destOtherXform->GetVariationById(eVariationId::VAR_BLOB)) { - BlobVariation* var = new BlobVariation(); - var->SetParamVal("blob_low", 1); - destXform->AddVariation(var); + if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_BLOB)) + { + var->SetParamVal("blob_low", 1); + destXform->AddVariation(var); + } + found++; } if (destOtherXform->GetVariationById(eVariationId::VAR_PERSPECTIVE)) { - PerspectiveVariation* var = new PerspectiveVariation(); - destXform->AddVariation(var); + destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_PERSPECTIVE)); found++; } if (destOtherXform->GetVariationById(eVariationId::VAR_CURL)) { - CurlVariation* var = new CurlVariation(); - var->SetParamVal("curl_c1", 0); - destXform->AddVariation(var); + if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_CURL)) + { + var->SetParamVal("curl_c1", 0); + destXform->AddVariation(var); + } + found++; } if (destOtherXform->GetVariationById(eVariationId::VAR_SUPER_SHAPE)) { - SuperShapeVariation* var = new SuperShapeVariation(); - var->SetParamVal("super_shape_n1", 2); - var->SetParamVal("super_shape_n2", 2); - var->SetParamVal("super_shape_n3", 2); - destXform->AddVariation(var); + if (auto var = variationList.GetParametricVariationCopy(eVariationId::VAR_SUPER_SHAPE)) + { + var->SetParamVal("super_shape_n1", 2); + var->SetParamVal("super_shape_n2", 2); + var->SetParamVal("super_shape_n3", 2); + destXform->AddVariation(var); + } + found++; } } @@ -238,13 +254,13 @@ public: if (destOtherXform->GetVariationById(eVariationId::VAR_FAN)) { - destXform->AddVariation(new FanVariation()); + destXform->AddVariation(variationList.GetVariationCopy(eVariationId::VAR_FAN)); found++; } if (destOtherXform->GetVariationById(eVariationId::VAR_RINGS)) { - destXform->AddVariation(new RingsVariation()); + 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()); + 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>& 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; - } - */ - /// /// Compare xforms for sorting based first on color speed and second on determinants if /// color speeds are equal. diff --git a/Source/Ember/Renderer.cpp b/Source/Ember/Renderer.cpp index 8b974a8..7ea4173 100644 --- a/Source/Ember/Renderer.cpp +++ b/Source/Ember/Renderer.cpp @@ -107,7 +107,6 @@ void Renderer::ComputeBounds() /// /// 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. /// template diff --git a/Source/Ember/SheepTools.h b/Source/Ember/SheepTools.h index 121ff17..87853c3 100644 --- a/Source/Ember/SheepTools.h +++ b/Source/Ember/SheepTools.h @@ -62,6 +62,7 @@ public: /// The full path and filename of the palette file /// A pre-constructed renderer to use. The caller should not delete this. SheepTools(const string& palettePath, Renderer* renderer) + : m_VariationList(VariationList::Instance()) { Timing t; m_Smooth = true; @@ -87,9 +88,9 @@ public: Xform 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 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 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()); - xform2.AddVariation(new LinearVariation()); - xform3.AddVariation(new LinearVariation()); + xform1.AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR)); + xform2.AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR)); + xform3.AddVariation(m_VariationList.GetVariationCopy(eVariationId::VAR_LINEAR)); ember.AddXform(xform1); ember.AddXform(xform2); ember.AddXform(xform3); @@ -1349,6 +1350,6 @@ private: unique_ptr> m_Renderer; QTIsaac m_Rand; PaletteList m_PaletteList; - VariationList m_VariationList; + VariationList& m_VariationList; }; } diff --git a/Source/Ember/VariationList.cpp b/Source/Ember/VariationList.cpp new file mode 100644 index 0000000..e3ff9ae --- /dev/null +++ b/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()); \ + m_Variations.push_back(new Pre##varName##Variation()); \ + m_Variations.push_back(new Post##varName##Variation()); + +/// +/// Singleton pattern, return a reference to the only instance of this object in existence. +/// +template +VariationList& VariationList::Instance() +{ + static VariationList v; + return v; +} + +/// +/// Constructor which initializes all of the variation objects and stores them in the list. +/// +template +VariationList::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());//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* var1, const Variation* 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*>(var)) + m_ParametricVariations.push_back(parVar); + } +} + +/// +/// Delete each element of the list. +/// +template +VariationList::~VariationList() +{ + ClearVec(m_Variations);//No need to delete parametric because they point to the entries in original vector. +} + +/// +/// Get a pointer to the variation at the specified index. +/// +/// The index in the list to retrieve +/// A pointer to the variation at the index if in range, else nullptr. +template +const Variation* VariationList::GetVariation(size_t index) const { return index < m_Variations.size() ? m_Variations[index] : nullptr; } + +/// +/// Get a pointer to the variation of a specified type at the specified index. +/// +/// The index in the list to retrieve +/// The type of variation to retrieve +/// A pointer to the variation of the specified type at the index if in range, else nullptr. +template +const Variation* VariationList::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; + } +} + +/// +/// Gets a pointer to a copy of the variation at the specified index. +/// Optionally specify a weight to assign the new copy. +/// +/// The index in the list to make a copy of +/// The weight to assign the new copy. Default: 1 +/// A pointer to the variation at the index if in range, else nullptr. +template +Variation* VariationList::GetVariationCopy(size_t index, T weight = 1) const { return MakeCopyWithWeight(GetVariation(index), weight); } +template +Variation* VariationList::GetVariationCopy(size_t index, eVariationType varType, T weight = 1) const { return MakeCopyWithWeight(GetVariation(index, varType), weight); } + +/// +/// Get a pointer to the variation with the specified ID. +/// +/// The ID to search for +/// A pointer to the variation if found, else nullptr. +template +const Variation* VariationList::GetVariation(eVariationId id) const +{ + for (auto var : m_Variations) + if (var && id == var->VariationId()) + return var; + + return nullptr; +} + +/// +/// Gets a pointer to a copy of the variation with the specified ID. +/// Optionally specify a weight to assign the new copy. +/// +/// The id of the variation in the list to make a copy of +/// The weight to assign the new copy. Default: 1 +/// A pointer to the variation with a matching ID, else nullptr. +template +Variation* VariationList::GetVariationCopy(eVariationId id, T weight = 1) const { return MakeCopyWithWeight(GetVariation(id), weight); } + +/// +/// Get a pointer to the variation with the specified name. +/// +/// The name to search for +/// A pointer to the variation if found, else nullptr. +template +const Variation* VariationList::GetVariation(const string& name) const +{ + for (auto var : m_Variations) + if (var && !_stricmp(name.c_str(), var->Name().c_str())) + return var; + + return nullptr; +} + +/// +/// Gets a pointer to a copy of the variation with the specified name. +/// Optionally specify a weight to assign the new copy. +/// +/// The name of the variation in the list to make a copy of +/// The weight to assign the new copy. Default: 1 +/// A pointer to the variation with a matching name, else nullptr. +template +Variation* VariationList::GetVariationCopy(const string& name, T weight = 1) const { return MakeCopyWithWeight(GetVariation(name), weight); } + +/// +/// Get a parametric variation at the specified index. +/// Note this is the index in the parametric variations list, not in the master list. +/// +/// The index in the parametric variations list to retrieve +/// The parametric variation at the index specified if in range, else nullptr. +template +const ParametricVariation* VariationList::GetParametricVariation(size_t index) const { return index < m_ParametricVariations.size() ? m_ParametricVariations[index] : nullptr; } + +/// +/// Get a parametric variation with the specified name. +/// +/// The name of the variation in the parametric variations list to retrieve +/// The parametric variation with a matching name, else nullptr. +template +const ParametricVariation* VariationList::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 +ParametricVariation* VariationList::GetParametricVariationCopy(eVariationId id, T weight) const +{ + return dynamic_cast*>(MakeCopyWithWeight(GetVariation(id), weight)); +} + +/// +/// Get the index of the variation with the specified name. +/// +/// The name of the variation whose index is returned +/// The index of the variation with the matching name, else -1 +template +int VariationList::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; +} + +/// +/// Accessors. +/// +template size_t VariationList::Size() const { return m_Variations.size(); } +template size_t VariationList::RegSize() const { return m_RegVariations.size(); } +template size_t VariationList::PreSize() const { return m_PreVariations.size(); } +template size_t VariationList::PostSize() const { return m_PostVariations.size(); } +template size_t VariationList::ParametricSize() const { return m_ParametricVariations.size(); } +template const vector*>& VariationList::AllVars() const { return m_Variations; } +template const vector*>& VariationList::RegVars() const { return m_RegVariations; } +template const vector*>& VariationList::PreVars() const { return m_PreVariations; } +template const vector*>& VariationList::PostVars() const { return m_PostVariations; } + +/// +/// Make a dyncamically allocated copy of a variation and assign it a specified weight. +/// Return a pointer to the new copy. +/// +/// The variation to copy +/// The weight to assign it +/// A pointer to the new variation copy if success, else nullptr. +template +Variation* VariationList::MakeCopyWithWeight(const Variation* 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; + +#ifdef DO_DOUBLE + template EMBER_API class VariationList; +#endif +} \ No newline at end of file diff --git a/Source/Ember/VariationList.h b/Source/Ember/VariationList.h index 0e2d71e..cf31970 100644 --- a/Source/Ember/VariationList.h +++ b/Source/Ember/VariationList.h @@ -1,13 +1,6 @@ #pragma once -#include "Variations01.h" -#include "Variations02.h" -#include "Variations03.h" -#include "Variations04.h" -#include "Variations05.h" -#include "Variations06.h" -#include "Variations07.h" -#include "VariationsDC.h" +#include "Variation.h" /// /// 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. /// template class EMBER_API VariationList { -#define ADDPREPOSTREGVAR(varName) \ - m_Variations.push_back(new varName##Variation()); \ - m_Variations.push_back(new Pre##varName##Variation()); \ - m_Variations.push_back(new Post##varName##Variation()); - public: - /// - /// Constructor which initializes all of the variation objects and stores them in the list. - /// - 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());//Post only - ADDPREPOSTREGVAR(Xerf) - ADDPREPOSTREGVAR(Erf) - ADDPREPOSTREGVAR(W) - ADDPREPOSTREGVAR(X) - ADDPREPOSTREGVAR(Y) - ADDPREPOSTREGVAR(Z) - ADDPREPOSTREGVAR(Splits3D) - ADDPREPOSTREGVAR(Waves2B) - ADDPREPOSTREGVAR(JacCn) - ADDPREPOSTREGVAR(JacDn) - ADDPREPOSTREGVAR(JacSn) - ADDPREPOSTREGVAR(PressureWave) - ADDPREPOSTREGVAR(Gamma) - ADDPREPOSTREGVAR(PRose3D) - ADDPREPOSTREGVAR(LogDB) - //ADDPREPOSTREGVAR(LinearXZ) - //ADDPREPOSTREGVAR(LinearYZ) - //DC are special. - ADDPREPOSTREGVAR(DCBubble) - ADDPREPOSTREGVAR(DCCarpet) - ADDPREPOSTREGVAR(DCCube) - ADDPREPOSTREGVAR(DCCylinder) - ADDPREPOSTREGVAR(DCGridOut) - ADDPREPOSTREGVAR(DCLinear) - ADDPREPOSTREGVAR(DCPerlin) - ADDPREPOSTREGVAR(DCTriangle) - ADDPREPOSTREGVAR(DCZTransl) + static VariationList& Instance(); + ~VariationList(); + VariationList(const VariationList& varList) = delete; + VariationList& operator = (const VariationList& varList) = delete; + const Variation* GetVariation(size_t index) const; + const Variation* GetVariation(size_t index, eVariationType varType) const; + Variation* GetVariationCopy(size_t index, T weight = 1) const; + Variation* GetVariationCopy(size_t index, eVariationType varType, T weight = 1) const; + const Variation* GetVariation(eVariationId id) const; + Variation* GetVariationCopy(eVariationId id, T weight = 1) const; + const Variation* GetVariation(const string& name) const; + Variation* GetVariationCopy(const string& name, T weight = 1) const; + const ParametricVariation* GetParametricVariation(size_t index) const; + const ParametricVariation* GetParametricVariation(const string& name) const; + ParametricVariation* GetParametricVariationCopy(eVariationId id, T weight = 1) const; + int GetVariationIndex(const string& name) const; + size_t Size() const; + size_t RegSize() const; + size_t PreSize() const; + size_t PostSize() const; + size_t ParametricSize() const; - for (auto var : m_Variations) var->Precalc(); - - std::sort(m_Variations.begin(), m_Variations.end(), [&](const Variation* var1, const Variation* 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*>(var)) - m_ParametricVariations.push_back(parVar); - } - } - - /// - /// Delete each element of the list. - /// - ~VariationList() - { - ClearVec(m_Variations);//No need to delete parametric because they point to the entries in original vector. - } - - /// - /// Get a pointer to the variation at the specified index. - /// - /// The index in the list to retrieve - /// A pointer to the variation at the index if in range, else nullptr. - const Variation* GetVariation(size_t index) const { return index < m_Variations.size() ? m_Variations[index] : nullptr; } - - /// - /// Get a pointer to the variation of a specified type at the specified index. - /// - /// The index in the list to retrieve - /// The type of variation to retrieve - /// A pointer to the variation of the specified type at the index if in range, else nullptr. - const Variation* 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; - } - } - - /// - /// Gets a pointer to a copy of the variation at the specified index. - /// Optionally specify a weight to assign the new copy. - /// - /// The index in the list to make a copy of - /// The weight to assign the new copy. Default: 1 - /// A pointer to the variation at the index if in range, else nullptr. - Variation* GetVariationCopy(size_t index, T weight = 1) const { return MakeCopyWithWeight(GetVariation(index), weight); } - Variation* GetVariationCopy(size_t index, eVariationType varType, T weight = 1) const { return MakeCopyWithWeight(GetVariation(index, varType), weight); } - - /// - /// Get a pointer to the variation with the specified ID. - /// - /// The ID to search for - /// A pointer to the variation if found, else nullptr. - const Variation* GetVariation(eVariationId id) const - { - for (auto var : m_Variations) - if (var && id == var->VariationId()) - return var; - - return nullptr; - } - - /// - /// Gets a pointer to a copy of the variation with the specified ID. - /// Optionally specify a weight to assign the new copy. - /// - /// The id of the variation in the list to make a copy of - /// The weight to assign the new copy. Default: 1 - /// A pointer to the variation with a matching ID, else nullptr. - Variation* GetVariationCopy(eVariationId id, T weight = 1) const { return MakeCopyWithWeight(GetVariation(id), weight); } - - /// - /// Get a pointer to the variation with the specified name. - /// - /// The name to search for - /// A pointer to the variation if found, else nullptr. - const Variation* GetVariation(const string& name) const - { - for (auto var : m_Variations) - if (var && !_stricmp(name.c_str(), var->Name().c_str())) - return var; - - return nullptr; - } - - /// - /// Gets a pointer to a copy of the variation with the specified name. - /// Optionally specify a weight to assign the new copy. - /// - /// The name of the variation in the list to make a copy of - /// The weight to assign the new copy. Default: 1 - /// A pointer to the variation with a matching name, else nullptr. - Variation* GetVariationCopy(const string& name, T weight = 1) const { return MakeCopyWithWeight(GetVariation(name), weight); } - - /// - /// Get a parametric variation at the specified index. - /// Note this is the index in the parametric variations list, not in the master list. - /// - /// The index in the parametric variations list to retrieve - /// The parametric variation at the index specified if in range, else nullptr. - const ParametricVariation* GetParametricVariation(size_t index) const { return index < m_ParametricVariations.size() ? m_ParametricVariations[index] : nullptr; } - - /// - /// Get a parametric variation with the specified name. - /// - /// The name of the variation in the parametric variations list to retrieve - /// The parametric variation with a matching name, else nullptr. - const ParametricVariation* GetParametricVariation(const string& name) const - { - for (auto var : m_ParametricVariations) - if (var && !_stricmp(name.c_str(), var->Name().c_str())) - return var; - - return nullptr; - } - - /// - /// Get the index of the variation with the specified name. - /// - /// The name of the variation whose index is returned - /// The index of the variation with the matching name, else -1 - 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; - } - - /// - /// Accessors. - /// - 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*>& AllVars() const { return m_Variations; } - const vector*>& RegVars() const { return m_RegVariations; } - const vector*>& PreVars() const { return m_PreVariations; } - const vector*>& PostVars() const { return m_PostVariations; } + const vector*>& AllVars() const; + const vector*>& RegVars() const; + const vector*>& PreVars() const; + const vector*>& PostVars() const; private: - /// - /// Make a dyncamically allocated copy of a variation and assign it a specified weight. - /// Return a pointer to the new copy. - /// - /// The variation to copy - /// The weight to assign it - /// A pointer to the new variation copy if success, else nullptr. - Variation* MakeCopyWithWeight(const Variation* var, T weight) const - { - if (var) - { - auto var2 = var->Copy(); - var2->m_Weight = weight; - return var2; - } - - return nullptr; - } - - /// - /// Assignment operator which does nothing since these are non-copyable. - /// Do not provide a copy constructor and ensure the assignment operator does nothing. - /// - /// The VariationList object which won't be copied - /// Reference to unchanged self - VariationList& operator = (const VariationList& varList) - { - return *this; - } + VariationList(); + Variation* MakeCopyWithWeight(const Variation* var, T weight) const; vector*> m_Variations;//A list of pointers to dynamically allocated variation objects. vector*> m_RegVariations; diff --git a/Source/Ember/Variations01.h b/Source/Ember/Variations01.h index 5447a4a..b1de7d7 100644 --- a/Source/Ember/Variations01.h +++ b/Source/Ember/Variations01.h @@ -1,9 +1,12 @@ #pragma once #include "Variation.h" +#include "Xform.h" namespace EmberNs { +//template class Xform; + /// /// Linear: /// nx = tx; @@ -12,7 +15,7 @@ namespace EmberNs /// p[1] += weight * ny; /// template -class EMBER_API LinearVariation : public Variation +class LinearVariation : public Variation { public: LinearVariation(T weight = 1.0) : Variation("linear", eVariationId::VAR_LINEAR, weight) { } @@ -47,7 +50,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API SinusoidalVariation : public Variation +class SinusoidalVariation : public Variation { public: SinusoidalVariation(T weight = 1.0) : Variation("sinusoidal", eVariationId::VAR_SINUSOIDAL, weight) { } @@ -83,7 +86,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API SphericalVariation : public Variation +class SphericalVariation : public Variation { public: SphericalVariation(T weight = 1.0) : Variation("spherical", eVariationId::VAR_SPHERICAL, weight, true) { } @@ -129,7 +132,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API SwirlVariation : public Variation +class SwirlVariation : public Variation { public: SwirlVariation(T weight = 1.0) : Variation("swirl", eVariationId::VAR_SWIRL, weight, true) { } @@ -172,7 +175,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API HorseshoeVariation : public Variation +class HorseshoeVariation : public Variation { public: HorseshoeVariation(T weight = 1.0) : Variation("horseshoe", eVariationId::VAR_HORSESHOE, weight, true, true) { } @@ -215,7 +218,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API PolarVariation : public Variation +class PolarVariation : public Variation { public: PolarVariation(T weight = 1.0) : Variation("polar", eVariationId::VAR_POLAR, weight, true, true, false, true, false) { } @@ -250,7 +253,7 @@ public: /// p[1] += weight * cos(a - r) * r; /// template -class EMBER_API HandkerchiefVariation : public Variation +class HandkerchiefVariation : public Variation { public: HandkerchiefVariation(T weight = 1.0) : Variation("handkerchief", eVariationId::VAR_HANDKERCHIEF, weight, true, true, false, true) { } @@ -286,7 +289,7 @@ public: /// p[1] += weight * cos(a) * -r; /// template -class EMBER_API HeartVariation : public Variation +class HeartVariation : public Variation { public: HeartVariation(T weight = 1.0) : Variation("heart", eVariationId::VAR_HEART, weight, true, true, false, true) { } @@ -328,7 +331,7 @@ public: /// p[1] += weight * cos(r) * a / M_PI; /// template -class EMBER_API DiscVariation : public ParametricVariation +class DiscVariation : public ParametricVariation { public: DiscVariation(T weight = 1.0) : ParametricVariation("disc", eVariationId::VAR_DISC, weight, true, true, false, true) @@ -390,7 +393,7 @@ private: /// p[1] += weight * (sin(a) - cos(r)) / r; /// template -class EMBER_API SpiralVariation : public Variation +class SpiralVariation : public Variation { public: SpiralVariation(T weight = 1.0) : Variation("spiral", eVariationId::VAR_SPIRAL, weight, true, true, true) { } @@ -435,7 +438,7 @@ public: /// p[1] += weight * cos(a) * r; /// template -class EMBER_API HyperbolicVariation : public Variation +class HyperbolicVariation : public Variation { public: HyperbolicVariation(T weight = 1.0) : Variation("hyperbolic", eVariationId::VAR_HYPERBOLIC, weight, true, true, true) { } @@ -478,7 +481,7 @@ public: /// p[1] += weight * cos(a) * sin(r); /// template -class EMBER_API DiamondVariation : public Variation +class DiamondVariation : public Variation { public: DiamondVariation(T weight = 1.0) : Variation("diamond", eVariationId::VAR_DIAMOND, weight, true, true, true) { } @@ -517,7 +520,7 @@ public: /// p[1] += weight * (m0 - m1); /// template -class EMBER_API ExVariation : public Variation +class ExVariation : public Variation { public: ExVariation(T weight = 1.0) : Variation("ex", eVariationId::VAR_EX, weight, true, true, false, true) { } @@ -568,7 +571,7 @@ public: /// p[1] += v * ny; /// template -class EMBER_API JuliaVariation : public Variation +class JuliaVariation : public Variation { public: JuliaVariation(T weight = 1.0) : Variation("julia", eVariationId::VAR_JULIA, weight, true, true, false, true) { } @@ -617,7 +620,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API BentVariation : public Variation +class BentVariation : public Variation { public: BentVariation(T weight = 1.0) : Variation("bent", eVariationId::VAR_BENT, weight) { } @@ -660,7 +663,7 @@ public: /// Special case here, use parametric for precalcs, but no regular params. /// template -class EMBER_API WavesVariation : public ParametricVariation +class WavesVariation : public ParametricVariation { public: WavesVariation(T weight = 1.0) : ParametricVariation("waves", eVariationId::VAR_WAVES, weight) @@ -738,7 +741,7 @@ private: /// p[1] += weight * ny; /// template -class EMBER_API FisheyeVariation : public Variation +class FisheyeVariation : public Variation { public: FisheyeVariation(T weight = 1.0) : Variation("fisheye", eVariationId::VAR_FISHEYE, weight, true, true) { } @@ -778,7 +781,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API PopcornVariation : public Variation +class PopcornVariation : public Variation { public: PopcornVariation(T weight = 1.0) : Variation("popcorn", eVariationId::VAR_POPCORN, weight) { } @@ -824,7 +827,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API ExponentialVariation : public Variation +class ExponentialVariation : public Variation { public: ExponentialVariation(T weight = 1.0) : Variation("exponential", eVariationId::VAR_EXPONENTIAL, weight) { } @@ -868,7 +871,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API PowerVariation : public Variation +class PowerVariation : public Variation { public: PowerVariation(T weight = 1.0) : Variation("power", eVariationId::VAR_POWER, weight, true, true, true) { } @@ -906,7 +909,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API CosineVariation : public Variation +class CosineVariation : public Variation { public: CosineVariation(T weight = 1.0) : Variation("cosine", eVariationId::VAR_COSINE, weight) { } @@ -953,7 +956,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API RingsVariation : public Variation +class RingsVariation : public Variation { public: RingsVariation(T weight = 1.0) : Variation("rings", eVariationId::VAR_RINGS, weight, true, true, true) { } @@ -1007,7 +1010,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API FanVariation : public Variation +class FanVariation : public Variation { public: FanVariation(T weight = 1.0) : Variation("fan", eVariationId::VAR_FAN, weight, true, true, false, true) { } @@ -1063,7 +1066,7 @@ public: /// p[1] += weight * ny; /// template -class EMBER_API BlobVariation : public ParametricVariation +class BlobVariation : public ParametricVariation { public: BlobVariation(T weight = 1.0) : ParametricVariation("blob", eVariationId::VAR_BLOB, weight, true, true, true, true) @@ -1142,7 +1145,7 @@ private: /// p[1] += weight * (nx2 - ny2); /// template -class EMBER_API PdjVariation : public ParametricVariation +class PdjVariation : public ParametricVariation { public: PdjVariation(T weight = 1.0) : ParametricVariation("pdj", eVariationId::VAR_PDJ, weight) @@ -1235,7 +1238,7 @@ private: /// p[1] += weight * ny; /// template -class EMBER_API Fan2Variation : public ParametricVariation +class Fan2Variation : public ParametricVariation { public: Fan2Variation(T weight = 1.0) : ParametricVariation("fan2", eVariationId::VAR_FAN2, weight, true, true, false, true) @@ -1329,7 +1332,7 @@ private: /// p[1] += weight * ny; /// template -class EMBER_API Rings2Variation : public ParametricVariation +class Rings2Variation : public ParametricVariation { public: Rings2Variation(T weight = 1.0) : ParametricVariation("rings2", eVariationId::VAR_RINGS2, weight, true, true, true) @@ -1398,7 +1401,7 @@ private: /// p[1] += r * ty; /// template -class EMBER_API EyefishVariation : public Variation +class EyefishVariation : public Variation { public: EyefishVariation(T weight = 1.0) : Variation("eyefish", eVariationId::VAR_EYEFISH, weight, true, true) { } @@ -1432,7 +1435,7 @@ public: /// Bubble. /// template -class EMBER_API BubbleVariation : public Variation +class BubbleVariation : public Variation { public: BubbleVariation(T weight = 1.0) : Variation("bubble", eVariationId::VAR_BUBBLE, weight, true) { } @@ -1473,7 +1476,7 @@ public: /// Cylinder. /// template -class EMBER_API CylinderVariation : public Variation +class CylinderVariation : public Variation { public: CylinderVariation(T weight = 1.0) : Variation("cylinder", eVariationId::VAR_CYLINDER, weight) { } @@ -1504,7 +1507,7 @@ public: /// Perspective. /// template -class EMBER_API PerspectiveVariation : public ParametricVariation +class PerspectiveVariation : public ParametricVariation { public: PerspectiveVariation(T weight = 1.0) : ParametricVariation("perspective", eVariationId::VAR_PERSPECTIVE, weight) @@ -1584,7 +1587,7 @@ private: /// Noise. /// template -class EMBER_API NoiseVariation : public Variation +class NoiseVariation : public Variation { public: NoiseVariation(T weight = 1.0) : Variation("noise", eVariationId::VAR_NOISE, weight) { } @@ -1620,7 +1623,7 @@ public: /// JuliaN. /// template -class EMBER_API JuliaNGenericVariation : public ParametricVariation +class JuliaNGenericVariation : public ParametricVariation { public: JuliaNGenericVariation(T weight = 1.0) : ParametricVariation("julian", eVariationId::VAR_JULIAN, weight, true, false, false, false, true) @@ -1696,7 +1699,7 @@ private: /// JuliaScope. /// template -class EMBER_API JuliaScopeVariation : public ParametricVariation +class JuliaScopeVariation : public ParametricVariation { public: JuliaScopeVariation(T weight = 1.0) : ParametricVariation("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. /// template -class EMBER_API BlurVariation : public Variation +class BlurVariation : public Variation { public: BlurVariation(T weight = 1.0) : Variation("blur", eVariationId::VAR_BLUR, weight) { } @@ -1846,7 +1849,7 @@ public: /// Gaussian blur. /// template -class EMBER_API GaussianBlurVariation : public Variation +class GaussianBlurVariation : public Variation { public: GaussianBlurVariation(T weight = 1.0) : Variation("gaussian_blur", eVariationId::VAR_GAUSSIAN_BLUR, weight) { } @@ -1882,7 +1885,7 @@ public: /// Radial blur. /// template -class EMBER_API RadialBlurVariation : public ParametricVariation +class RadialBlurVariation : public ParametricVariation { public: RadialBlurVariation(T weight = 1.0) : ParametricVariation("radial_blur", eVariationId::VAR_RADIAL_BLUR, weight, true, true, false, false, true) @@ -1958,7 +1961,7 @@ private: /// Pie. /// template -class EMBER_API PieVariation : public ParametricVariation +class PieVariation : public ParametricVariation { public: PieVariation(T weight = 1.0) : ParametricVariation("pie", eVariationId::VAR_PIE, weight) @@ -2034,7 +2037,7 @@ private: /// Ngon. /// template -class EMBER_API NgonVariation : public ParametricVariation +class NgonVariation : public ParametricVariation { public: NgonVariation(T weight = 1.0) : ParametricVariation("ngon", eVariationId::VAR_NGON, weight, true, false, false, false, true) @@ -2145,7 +2148,7 @@ private: /// curl code. /// template -class EMBER_API CurlVariation : public ParametricVariation +class CurlVariation : public ParametricVariation { public: CurlVariation(T weight = 1.0) : ParametricVariation("curl", eVariationId::VAR_CURL, weight) @@ -2222,7 +2225,7 @@ private: /// Rectangles. /// template -class EMBER_API RectanglesVariation : public ParametricVariation +class RectanglesVariation : public ParametricVariation { public: RectanglesVariation(T weight = 1.0) : ParametricVariation("rectangles", eVariationId::VAR_RECTANGLES, weight) @@ -2295,7 +2298,7 @@ private: /// Arch. /// template -class EMBER_API ArchVariation : public Variation +class ArchVariation : public Variation { public: ArchVariation(T weight = 1.0) : Variation("arch", eVariationId::VAR_ARCH, weight) { } @@ -2333,7 +2336,7 @@ public: /// Tangent. /// template -class EMBER_API TangentVariation : public Variation +class TangentVariation : public Variation { public: TangentVariation(T weight = 1.0) : Variation("tangent", eVariationId::VAR_TANGENT, weight) { } @@ -2364,7 +2367,7 @@ public: /// Square. /// template -class EMBER_API SquareVariation : public Variation +class SquareVariation : public Variation { public: SquareVariation(T weight = 1.0) : Variation("square", eVariationId::VAR_SQUARE, weight) { } @@ -2395,7 +2398,7 @@ public: /// Rays. /// template -class EMBER_API RaysVariation : public Variation +class RaysVariation : public Variation { public: RaysVariation(T weight = 1.0) : Variation("rays", eVariationId::VAR_RAYS, weight, true) { } @@ -2438,7 +2441,7 @@ public: /// Blade. /// template -class EMBER_API BladeVariation : public Variation +class BladeVariation : public Variation { public: BladeVariation(T weight = 1.0) : Variation("blade", eVariationId::VAR_BLADE, weight, true, true) { } @@ -2476,7 +2479,7 @@ public: /// Secant2. /// template -class EMBER_API Secant2Variation : public Variation +class Secant2Variation : public Variation { public: Secant2Variation(T weight = 1.0) : Variation("secant2", eVariationId::VAR_SECANT2, weight, true, true) { } @@ -2524,7 +2527,7 @@ public: /// TwinTrian. /// template -class EMBER_API TwinTrianVariation : public Variation +class TwinTrianVariation : public Variation { public: TwinTrianVariation(T weight = 1.0) : Variation("TwinTrian", eVariationId::VAR_TWINTRIAN, weight, true, true) { } @@ -2571,7 +2574,7 @@ public: /// Cross. /// template -class EMBER_API CrossVariation : public Variation +class CrossVariation : public Variation { public: CrossVariation(T weight = 1.0) : Variation("cross", eVariationId::VAR_CROSS, weight) { } @@ -2610,7 +2613,7 @@ public: /// Disc2. /// template -class EMBER_API Disc2Variation : public ParametricVariation +class Disc2Variation : public ParametricVariation { public: Disc2Variation(T weight = 1.0) : ParametricVariation("disc2", eVariationId::VAR_DISC2, weight, false, false, false, true) @@ -2707,7 +2710,7 @@ private: /// SuperShape. /// template -class EMBER_API SuperShapeVariation : public ParametricVariation +class SuperShapeVariation : public ParametricVariation { public: SuperShapeVariation(T weight = 1.0) : ParametricVariation("super_shape", eVariationId::VAR_SUPER_SHAPE, weight, true, true, false, false, true) @@ -2806,7 +2809,7 @@ private: /// Flower. /// template -class EMBER_API FlowerVariation : public ParametricVariation +class FlowerVariation : public ParametricVariation { public: FlowerVariation(T weight = 1.0) : ParametricVariation("flower", eVariationId::VAR_FLOWER, weight, true, true, false, false, true) @@ -2868,7 +2871,7 @@ private: /// Conic. /// template -class EMBER_API ConicVariation : public ParametricVariation +class ConicVariation : public ParametricVariation { public: ConicVariation(T weight = 1.0) : ParametricVariation("conic", eVariationId::VAR_CONIC, weight, true, true) @@ -2931,7 +2934,7 @@ private: /// Parabola. /// template -class EMBER_API ParabolaVariation : public ParametricVariation +class ParabolaVariation : public ParametricVariation { public: ParabolaVariation(T weight = 1.0) : ParametricVariation("parabola", eVariationId::VAR_PARABOLA, weight, true, true) @@ -2993,7 +2996,7 @@ private: /// Bent2. /// template -class EMBER_API Bent2Variation : public ParametricVariation +class Bent2Variation : public ParametricVariation { public: Bent2Variation(T weight = 1.0) : ParametricVariation("bent2", eVariationId::VAR_BENT2, weight) @@ -3078,7 +3081,7 @@ private: /// Bipolar. /// template -class EMBER_API BipolarVariation : public ParametricVariation +class BipolarVariation : public ParametricVariation { public: BipolarVariation(T weight = 1.0) : ParametricVariation("bipolar", eVariationId::VAR_BIPOLAR, weight, true) @@ -3228,7 +3231,7 @@ private: /// Boarders. /// template -class EMBER_API BoardersVariation : public Variation +class BoardersVariation : public Variation { public: BoardersVariation(T weight = 1.0) : Variation("boarders", eVariationId::VAR_BOARDERS, weight) { } @@ -3335,7 +3338,7 @@ public: /// Butterfly. /// template -class EMBER_API ButterflyVariation : public Variation +class ButterflyVariation : public Variation { public: ButterflyVariation(T weight = 1.0) : Variation("butterfly", eVariationId::VAR_BUTTERFLY, weight) { } @@ -3378,7 +3381,7 @@ public: /// Cell. /// template -class EMBER_API CellVariation : public ParametricVariation +class CellVariation : public ParametricVariation { public: CellVariation(T weight = 1.0) : ParametricVariation("cell", eVariationId::VAR_CELL, weight) @@ -3509,7 +3512,7 @@ private: /// Cpow. /// template -class EMBER_API CpowVariation : public ParametricVariation +class CpowVariation : public ParametricVariation { public: CpowVariation(T weight = 1.0) : ParametricVariation("cpow", eVariationId::VAR_CPOW, weight, true, false, false, false, true) @@ -3595,7 +3598,7 @@ private: /// Curve. /// template -class EMBER_API CurveVariation : public ParametricVariation +class CurveVariation : public ParametricVariation { public: CurveVariation(T weight = 1.0) : ParametricVariation("curve", eVariationId::VAR_CURVE, weight) @@ -3680,7 +3683,7 @@ private: /// Edisc. /// template -class EMBER_API EdiscVariation : public Variation +class EdiscVariation : public Variation { public: EdiscVariation(T weight = 1.0) : Variation("edisc", eVariationId::VAR_EDISC, weight, true) { } @@ -3741,7 +3744,7 @@ public: /// Elliptic. /// template -class EMBER_API EllipticVariation : public ParametricVariation +class EllipticVariation : public ParametricVariation { public: EllipticVariation(T weight = 1.0) : ParametricVariation("elliptic", eVariationId::VAR_ELLIPTIC, weight, true) @@ -3840,7 +3843,7 @@ private: /// Escher. /// template -class EMBER_API EscherVariation : public ParametricVariation +class EscherVariation : public ParametricVariation { public: EscherVariation(T weight = 1.0) : ParametricVariation("escher", eVariationId::VAR_ESCHER, weight, true, false, false, false, true) @@ -3927,7 +3930,7 @@ private: /// Foci. /// template -class EMBER_API FociVariation : public Variation +class FociVariation : public Variation { public: FociVariation(T weight = 1.0) : Variation("foci", eVariationId::VAR_FOCI, weight) { } @@ -3976,7 +3979,7 @@ public: /// LazySusan. /// template -class EMBER_API LazySusanVariation : public ParametricVariation +class LazySusanVariation : public ParametricVariation { public: LazySusanVariation(T weight = 1.0) : ParametricVariation("lazysusan", eVariationId::VAR_LAZYSUSAN, weight) @@ -4094,7 +4097,7 @@ private: /// Loonie. /// template -class EMBER_API LoonieVariation : public ParametricVariation +class LoonieVariation : public ParametricVariation { public: LoonieVariation(T weight = 1.0) : ParametricVariation("loonie", eVariationId::VAR_LOONIE, weight, true) @@ -4167,7 +4170,7 @@ private: /// Modulus. /// template -class EMBER_API ModulusVariation : public ParametricVariation +class ModulusVariation : public ParametricVariation { public: ModulusVariation(T weight = 1.0) : ParametricVariation("modulus", eVariationId::VAR_MODULUS, weight) @@ -4260,7 +4263,7 @@ private: /// Oscilloscope. /// template -class EMBER_API OscilloscopeVariation : public ParametricVariation +class OscilloscopeVariation : public ParametricVariation { public: OscilloscopeVariation(T weight = 1.0) : ParametricVariation("oscilloscope", eVariationId::VAR_OSCILLOSCOPE, weight) @@ -4365,7 +4368,7 @@ private: /// Polar2. /// template -class EMBER_API Polar2Variation : public ParametricVariation +class Polar2Variation : public ParametricVariation { public: Polar2Variation(T weight = 1.0) : ParametricVariation("polar2", eVariationId::VAR_POLAR2, weight, true, false, false, true) @@ -4422,7 +4425,7 @@ private: /// Popcorn2. /// template -class EMBER_API Popcorn2Variation : public ParametricVariation +class Popcorn2Variation : public ParametricVariation { public: Popcorn2Variation(T weight = 1.0) : ParametricVariation("popcorn2", eVariationId::VAR_POPCORN2, weight) @@ -4486,7 +4489,7 @@ private: /// should be ok. /// template -class EMBER_API ScryVariation : public ParametricVariation +class ScryVariation : public ParametricVariation { public: ScryVariation(T weight = 1.0) : ParametricVariation("scry", eVariationId::VAR_SCRY, weight, true, true) @@ -4549,7 +4552,7 @@ private: /// Separation. /// template -class EMBER_API SeparationVariation : public ParametricVariation +class SeparationVariation : public ParametricVariation { public: SeparationVariation(T weight = 1.0) : ParametricVariation("separation", eVariationId::VAR_SEPARATION, weight) @@ -4642,7 +4645,7 @@ private: /// Split. /// template -class EMBER_API SplitVariation : public ParametricVariation +class SplitVariation : public ParametricVariation { public: SplitVariation(T weight = 1.0) : ParametricVariation("split", eVariationId::VAR_SPLIT, weight) @@ -4727,7 +4730,7 @@ private: /// Splits. /// template -class EMBER_API SplitsVariation : public ParametricVariation +class SplitsVariation : public ParametricVariation { public: SplitsVariation(T weight = 1.0) : ParametricVariation("splits", eVariationId::VAR_SPLITS, weight) @@ -4800,7 +4803,7 @@ private: /// Stripes. /// template -class EMBER_API StripesVariation : public ParametricVariation +class StripesVariation : public ParametricVariation { public: StripesVariation(T weight = 1.0) : ParametricVariation("stripes", eVariationId::VAR_STRIPES, weight) @@ -4862,7 +4865,7 @@ private: /// Wedge. /// template -class EMBER_API WedgeVariation : public ParametricVariation +class WedgeVariation : public ParametricVariation { public: WedgeVariation(T weight = 1.0) : ParametricVariation("wedge", eVariationId::VAR_WEDGE, weight, true, true, false, false, true) @@ -4946,7 +4949,7 @@ private: /// Wedge julia. /// template -class EMBER_API WedgeJuliaVariation : public ParametricVariation +class WedgeJuliaVariation : public ParametricVariation { public: WedgeJuliaVariation(T weight = 1.0) : ParametricVariation("wedge_julia", eVariationId::VAR_WEDGE_JULIA, weight, true, false, false, false, true) @@ -5038,7 +5041,7 @@ private: /// Wedge sph. /// template -class EMBER_API WedgeSphVariation : public ParametricVariation +class WedgeSphVariation : public ParametricVariation { public: WedgeSphVariation(T weight = 1.0) : ParametricVariation("wedge_sph", eVariationId::VAR_WEDGE_SPH, weight, true, true, false, false, true) @@ -5131,7 +5134,7 @@ private: /// Whorl. /// template -class EMBER_API WhorlVariation : public ParametricVariation +class WhorlVariation : public ParametricVariation { public: WhorlVariation(T weight = 1.0) : ParametricVariation("whorl", eVariationId::VAR_WHORL, weight, true, true, false, false, true) @@ -5203,7 +5206,7 @@ private: /// Waves. /// template -class EMBER_API Waves2Variation : public ParametricVariation +class Waves2Variation : public ParametricVariation { public: Waves2Variation(T weight = 1.0) : ParametricVariation("waves2", eVariationId::VAR_WAVES2, weight, true, true) @@ -5276,7 +5279,7 @@ private: /// Exp. /// template -class EMBER_API ExpVariation : public Variation +class ExpVariation : public Variation { public: ExpVariation(T weight = 1.0) : Variation("exp", eVariationId::VAR_EXP, weight) { } @@ -5310,7 +5313,7 @@ public: /// Log. /// template -class EMBER_API LogVariation : public ParametricVariation +class LogVariation : public ParametricVariation { public: LogVariation(T weight = 1.0) : ParametricVariation("log", eVariationId::VAR_LOG, weight, true, false, false, false, true) @@ -5366,7 +5369,7 @@ private: /// Sine. /// template -class EMBER_API SinVariation : public Variation +class SinVariation : public Variation { public: SinVariation(T weight = 1.0) : Variation("sin", eVariationId::VAR_SIN, weight) { } @@ -5397,7 +5400,7 @@ public: /// Cosine. /// template -class EMBER_API CosVariation : public Variation +class CosVariation : public Variation { public: CosVariation(T weight = 1.0) : Variation("cos", eVariationId::VAR_COS, weight) { } @@ -5429,7 +5432,7 @@ public: /// Tangent. /// template -class EMBER_API TanVariation : public Variation +class TanVariation : public Variation { public: TanVariation(T weight = 1.0) : Variation("tan", eVariationId::VAR_TAN, weight) { } @@ -5471,7 +5474,7 @@ public: /// Sec. /// template -class EMBER_API SecVariation : public Variation +class SecVariation : public Variation { public: SecVariation(T weight = 1.0) : Variation("sec", eVariationId::VAR_SEC, weight) { } @@ -5513,7 +5516,7 @@ public: /// Cosecant. /// template -class EMBER_API CscVariation : public Variation +class CscVariation : public Variation { public: CscVariation(T weight = 1.0) : Variation("csc", eVariationId::VAR_CSC, weight) { } @@ -5555,7 +5558,7 @@ public: /// Cotangent. /// template -class EMBER_API CotVariation : public Variation +class CotVariation : public Variation { public: CotVariation(T weight = 1.0) : Variation("cot", eVariationId::VAR_COT, weight) { } @@ -5597,7 +5600,7 @@ public: /// Sinh. /// template -class EMBER_API SinhVariation : public Variation +class SinhVariation : public Variation { public: SinhVariation(T weight = 1.0) : Variation("sinh", eVariationId::VAR_SINH, weight) { } @@ -5637,7 +5640,7 @@ public: /// Cosh. /// template -class EMBER_API CoshVariation : public Variation +class CoshVariation : public Variation { public: CoshVariation(T weight = 1.0) : Variation("cosh", eVariationId::VAR_COSH, weight) { } @@ -5677,7 +5680,7 @@ public: /// Tanh. /// template -class EMBER_API TanhVariation : public Variation +class TanhVariation : public Variation { public: TanhVariation(T weight = 1.0) : Variation("tanh", eVariationId::VAR_TANH, weight) { } @@ -5719,7 +5722,7 @@ public: /// Sech /// template -class EMBER_API SechVariation : public Variation +class SechVariation : public Variation { public: SechVariation(T weight = 1.0) : Variation("sech", eVariationId::VAR_SECH, weight) { } @@ -5761,7 +5764,7 @@ public: /// Csch. /// template -class EMBER_API CschVariation : public Variation +class CschVariation : public Variation { public: CschVariation(T weight = 1.0) : Variation("csch", eVariationId::VAR_CSCH, weight) { } @@ -5803,7 +5806,7 @@ public: /// Coth. /// template -class EMBER_API CothVariation : public Variation +class CothVariation : public Variation { public: CothVariation(T weight = 1.0) : Variation("coth", eVariationId::VAR_COTH, weight) { } @@ -5845,7 +5848,7 @@ public: /// Auger. /// template -class EMBER_API AugerVariation : public ParametricVariation +class AugerVariation : public ParametricVariation { public: AugerVariation(T weight = 1.0) : ParametricVariation("auger", eVariationId::VAR_AUGER, weight) @@ -5919,7 +5922,7 @@ private: /// Flux. /// template -class EMBER_API FluxVariation : public ParametricVariation +class FluxVariation : public ParametricVariation { public: FluxVariation(T weight = 1.0) : ParametricVariation("flux", eVariationId::VAR_FLUX, weight) diff --git a/Source/Ember/Variations02.h b/Source/Ember/Variations02.h index 149880e..314cce1 100644 --- a/Source/Ember/Variations02.h +++ b/Source/Ember/Variations02.h @@ -8,7 +8,7 @@ namespace EmberNs /// Hemisphere. /// template -class EMBER_API HemisphereVariation : public Variation +class HemisphereVariation : public Variation { public: HemisphereVariation(T weight = 1.0) : Variation("hemisphere", eVariationId::VAR_HEMISPHERE, weight, true) { } @@ -42,7 +42,7 @@ public: /// Epispiral. /// template -class EMBER_API EpispiralVariation : public ParametricVariation +class EpispiralVariation : public ParametricVariation { public: EpispiralVariation(T weight = 1.0) : ParametricVariation("epispiral", eVariationId::VAR_EPISPIRAL, weight, false, false, false, false, true) @@ -120,7 +120,7 @@ private: /// Note, this is the same as bwraps2. /// template -class EMBER_API BwrapsVariation : public ParametricVariation +class BwrapsVariation : public ParametricVariation { public: BwrapsVariation(T weight = 1.0) : ParametricVariation("bwraps", eVariationId::VAR_BWRAPS, weight) @@ -279,7 +279,7 @@ private: /// BlurCircle. /// template -class EMBER_API BlurCircleVariation : public Variation +class BlurCircleVariation : public Variation { public: BlurCircleVariation(T weight = 1.0) : Variation("blur_circle", eVariationId::VAR_BLUR_CIRCLE, weight) { } @@ -383,7 +383,7 @@ public: /// BlurZoom. /// template -class EMBER_API BlurZoomVariation : public ParametricVariation +class BlurZoomVariation : public ParametricVariation { public: BlurZoomVariation(T weight = 1.0) : ParametricVariation("blur_zoom", eVariationId::VAR_BLUR_ZOOM, weight) @@ -440,7 +440,7 @@ private: /// BlurPixelize. /// template -class EMBER_API BlurPixelizeVariation : public ParametricVariation +class BlurPixelizeVariation : public ParametricVariation { public: BlurPixelizeVariation(T weight = 1.0) : ParametricVariation("blur_pixelize", eVariationId::VAR_BLUR_PIXELIZE, weight) @@ -508,7 +508,7 @@ private: /// Crop. /// template -class EMBER_API CropVariation : public ParametricVariation +class CropVariation : public ParametricVariation { public: CropVariation(T weight = 1.0) : ParametricVariation("crop", eVariationId::VAR_CROP, weight) @@ -659,7 +659,7 @@ private: /// BCircle. /// template -class EMBER_API BCircleVariation : public ParametricVariation +class BCircleVariation : public ParametricVariation { public: BCircleVariation(T weight = 1.0) : ParametricVariation("bcircle", eVariationId::VAR_BCIRCLE, weight) @@ -765,7 +765,7 @@ private: /// BlurLinear. /// template -class EMBER_API BlurLinearVariation : public ParametricVariation +class BlurLinearVariation : public ParametricVariation { public: BlurLinearVariation(T weight = 1.0) : ParametricVariation("blur_linear", eVariationId::VAR_BLUR_LINEAR, weight) @@ -830,7 +830,7 @@ private: /// BlurSquare. /// template -class EMBER_API BlurSquareVariation : public ParametricVariation +class BlurSquareVariation : public ParametricVariation { public: BlurSquareVariation(T weight = 1.0) : ParametricVariation("blur_square", eVariationId::VAR_BLUR_SQUARE, weight) @@ -884,7 +884,7 @@ private: /// This uses in/out in a rare and different way. /// template -class EMBER_API FlattenVariation : public Variation +class FlattenVariation : public Variation { public: FlattenVariation(T weight = 1.0) : Variation("flatten", eVariationId::VAR_FLATTEN, weight) { } @@ -937,7 +937,7 @@ public: /// This uses in/out in a rare and different way. /// template -class EMBER_API ZblurVariation : public Variation +class ZblurVariation : public Variation { public: ZblurVariation(T weight = 1.0) : Variation("zblur", eVariationId::VAR_ZBLUR, weight) { } @@ -967,7 +967,7 @@ public: /// This uses in/out in a rare and different way. /// template -class EMBER_API ZScaleVariation : public Variation +class ZScaleVariation : public Variation { public: ZScaleVariation(T weight = 1.0) : Variation("zscale", eVariationId::VAR_ZSCALE, weight) { } @@ -997,7 +997,7 @@ public: /// This uses in/out in a rare and different way. /// template -class EMBER_API ZTranslateVariation : public Variation +class ZTranslateVariation : public Variation { public: ZTranslateVariation(T weight = 1.0) : Variation("ztranslate", eVariationId::VAR_ZTRANSLATE, weight) { } @@ -1027,7 +1027,7 @@ public: /// This uses in/out in a rare and different way. /// template -class EMBER_API ZConeVariation : public Variation +class ZConeVariation : public Variation { public: ZConeVariation(T weight = 1.0) : Variation("zcone", eVariationId::VAR_ZCONE, weight, true, true) { } @@ -1075,7 +1075,7 @@ public: /// Blur3D. /// template -class EMBER_API Blur3DVariation : public Variation +class Blur3DVariation : public Variation { public: Blur3DVariation(T weight = 1.0) : Variation("blur3D", eVariationId::VAR_BLUR3D, weight) { } @@ -1121,7 +1121,7 @@ public: /// Spherical3D. /// template -class EMBER_API Spherical3DVariation : public Variation +class Spherical3DVariation : public Variation { public: Spherical3DVariation(T weight = 1.0) : Variation("Spherical3D", eVariationId::VAR_SPHERICAL3D, weight, true) { } @@ -1160,7 +1160,7 @@ public: /// Curl3D. /// template -class EMBER_API Curl3DVariation : public ParametricVariation +class Curl3DVariation : public ParametricVariation { public: Curl3DVariation(T weight = 1.0) : ParametricVariation("curl3D", eVariationId::VAR_CURL3D, weight, true) @@ -1244,7 +1244,7 @@ private: /// Disc3D. /// template -class EMBER_API Disc3DVariation : public ParametricVariation +class Disc3DVariation : public ParametricVariation { public: Disc3DVariation(T weight = 1.0) : ParametricVariation("disc3d", eVariationId::VAR_DISC3D, weight, true, true, false, true, false) @@ -1308,7 +1308,7 @@ private: /// Boarders2. /// template -class EMBER_API Boarders2Variation : public ParametricVariation +class Boarders2Variation : public ParametricVariation { public: Boarders2Variation(T weight = 1.0) : ParametricVariation("boarders2", eVariationId::VAR_BOARDERS2, weight) @@ -1457,7 +1457,7 @@ private: /// Cardioid. /// template -class EMBER_API CardioidVariation : public ParametricVariation +class CardioidVariation : public ParametricVariation { public: CardioidVariation(T weight = 1.0) : ParametricVariation("cardioid", eVariationId::VAR_CARDIOID, weight, true, true, true, false, true) @@ -1508,7 +1508,7 @@ private: /// Checks. /// template -class EMBER_API ChecksVariation : public ParametricVariation +class ChecksVariation : public ParametricVariation { public: ChecksVariation(T weight = 1.0) : ParametricVariation("checks", eVariationId::VAR_CHECKS, weight) @@ -1627,7 +1627,7 @@ private: /// Circlize. /// template -class EMBER_API CirclizeVariation : public ParametricVariation +class CirclizeVariation : public ParametricVariation { public: CirclizeVariation(T weight = 1.0) : ParametricVariation("circlize", eVariationId::VAR_CIRCLIZE, weight) @@ -1737,7 +1737,7 @@ private: /// Circlize2. /// template -class EMBER_API Circlize2Variation : public ParametricVariation +class Circlize2Variation : public ParametricVariation { public: Circlize2Variation(T weight = 1.0) : ParametricVariation("circlize2", eVariationId::VAR_CIRCLIZE2, weight) @@ -1838,7 +1838,7 @@ private: /// CosWrap. /// template -class EMBER_API CosWrapVariation : public ParametricVariation +class CosWrapVariation : public ParametricVariation { public: CosWrapVariation(T weight = 1.0) : ParametricVariation("coswrap", eVariationId::VAR_COS_WRAP, weight) @@ -1947,7 +1947,7 @@ private: /// that precalc variable omitted. /// template -class EMBER_API DeltaAVariation : public Variation +class DeltaAVariation : public Variation { public: DeltaAVariation(T weight = 1.0) : Variation("deltaa", eVariationId::VAR_DELTA_A, weight) { } @@ -1987,7 +1987,7 @@ public: /// Expo. /// template -class EMBER_API ExpoVariation : public ParametricVariation +class ExpoVariation : public ParametricVariation { public: ExpoVariation(T weight = 1.0) : ParametricVariation("expo", eVariationId::VAR_EXPO, weight) @@ -2059,7 +2059,7 @@ private: /// Extrude. /// template -class EMBER_API ExtrudeVariation : public ParametricVariation +class ExtrudeVariation : public ParametricVariation { public: ExtrudeVariation(T weight = 1.0) : ParametricVariation("extrude", eVariationId::VAR_EXTRUDE, weight) @@ -2143,7 +2143,7 @@ private: /// fdisc. /// template -class EMBER_API FDiscVariation : public Variation +class FDiscVariation : public Variation { public: FDiscVariation(T weight = 1.0) : Variation("fdisc", eVariationId::VAR_FDISC, weight, true, true, false, false, true) { } @@ -2183,7 +2183,7 @@ public: /// Fibonacci. /// template -class EMBER_API FibonacciVariation : public ParametricVariation +class FibonacciVariation : public ParametricVariation { public: FibonacciVariation(T weight = 1.0) : ParametricVariation("fibonacci", eVariationId::VAR_FIBONACCI, weight) @@ -2256,7 +2256,7 @@ private: /// Fibonacci2. /// template -class EMBER_API Fibonacci2Variation : public ParametricVariation +class Fibonacci2Variation : public ParametricVariation { public: Fibonacci2Variation(T weight = 1.0) : ParametricVariation("fibonacci2", eVariationId::VAR_FIBONACCI2, weight) @@ -2335,7 +2335,7 @@ private: /// Glynnia. /// template -class EMBER_API GlynniaVariation : public ParametricVariation +class GlynniaVariation : public ParametricVariation { public: GlynniaVariation(T weight = 1.0) : ParametricVariation("glynnia", eVariationId::VAR_GLYNNIA, weight, true, true) @@ -2454,7 +2454,7 @@ private: /// GridOut. /// template -class EMBER_API GridOutVariation : public Variation +class GridOutVariation : public Variation { public: GridOutVariation(T weight = 1.0) : Variation("gridout", eVariationId::VAR_GRIDOUT, weight) { } @@ -2610,7 +2610,7 @@ public: /// Hole. /// template -class EMBER_API HoleVariation : public ParametricVariation +class HoleVariation : public ParametricVariation { public: HoleVariation(T weight = 1.0) : ParametricVariation("hole", eVariationId::VAR_HOLE, weight, true, true, true, false, true) @@ -2675,7 +2675,7 @@ private: /// Hypertile. /// template -class EMBER_API HypertileVariation : public ParametricVariation +class HypertileVariation : public ParametricVariation { public: HypertileVariation(T weight = 1.0) : ParametricVariation("hypertile", eVariationId::VAR_HYPERTILE, weight) @@ -2762,7 +2762,7 @@ private: /// Hypertile1. /// template -class EMBER_API Hypertile1Variation : public ParametricVariation +class Hypertile1Variation : public ParametricVariation { public: Hypertile1Variation(T weight = 1.0) : ParametricVariation("hypertile1", eVariationId::VAR_HYPERTILE1, weight) @@ -2853,7 +2853,7 @@ private: /// Hypertile2. /// template -class EMBER_API Hypertile2Variation : public ParametricVariation +class Hypertile2Variation : public ParametricVariation { public: Hypertile2Variation(T weight = 1.0) : ParametricVariation("hypertile2", eVariationId::VAR_HYPERTILE2, weight) @@ -2944,7 +2944,7 @@ private: /// Hypertile3D. /// template -class EMBER_API Hypertile3DVariation : public ParametricVariation +class Hypertile3DVariation : public ParametricVariation { public: Hypertile3DVariation(T weight = 1.0) : ParametricVariation("hypertile3D", eVariationId::VAR_HYPERTILE3D, weight, true) @@ -3059,7 +3059,7 @@ private: /// Hypertile3D1. /// template -class EMBER_API Hypertile3D1Variation : public ParametricVariation +class Hypertile3D1Variation : public ParametricVariation { public: Hypertile3D1Variation(T weight = 1.0) : ParametricVariation("hypertile3D1", eVariationId::VAR_HYPERTILE3D1, weight, true) @@ -3158,7 +3158,7 @@ private: /// Hypertile3D2. /// template -class EMBER_API Hypertile3D2Variation : public ParametricVariation +class Hypertile3D2Variation : public ParametricVariation { public: Hypertile3D2Variation(T weight = 1.0) : ParametricVariation("hypertile3D2", eVariationId::VAR_HYPERTILE3D2, weight, true) @@ -3267,7 +3267,7 @@ private: /// IDisc. /// template -class EMBER_API IDiscVariation : public ParametricVariation +class IDiscVariation : public ParametricVariation { public: IDiscVariation(T weight = 1.0) : ParametricVariation("idisc", eVariationId::VAR_IDISC, weight, true, true, false, false, true) @@ -3329,7 +3329,7 @@ private: /// Julian2. /// template -class EMBER_API Julian2Variation : public ParametricVariation +class Julian2Variation : public ParametricVariation { public: Julian2Variation(T weight = 1.0) : ParametricVariation("julian2", eVariationId::VAR_JULIAN2, weight) @@ -3426,7 +3426,7 @@ private: /// JuliaQ. /// template -class EMBER_API JuliaQVariation : public ParametricVariation +class JuliaQVariation : public ParametricVariation { public: JuliaQVariation(T weight = 1.0) : ParametricVariation("juliaq", eVariationId::VAR_JULIAQ, weight, true, false, false, false, true) @@ -3502,7 +3502,7 @@ private: /// Murl. /// template -class EMBER_API MurlVariation : public ParametricVariation +class MurlVariation : public ParametricVariation { public: MurlVariation(T weight = 1.0) : ParametricVariation("murl", eVariationId::VAR_MURL, weight, true, false, false, false, true) @@ -3588,7 +3588,7 @@ private: /// Murl2. /// template -class EMBER_API Murl2Variation : public ParametricVariation +class Murl2Variation : public ParametricVariation { public: Murl2Variation(T weight = 1.0) : ParametricVariation("murl2", eVariationId::VAR_MURL2, weight, true, false, false, false, true) @@ -3692,7 +3692,7 @@ private: /// NPolar. /// template -class EMBER_API NPolarVariation : public ParametricVariation +class NPolarVariation : public ParametricVariation { public: NPolarVariation(T weight = 1.0) : ParametricVariation("npolar", eVariationId::VAR_NPOLAR, weight, true, false, false, true, false) @@ -3788,7 +3788,7 @@ private: /// Ortho. /// template -class EMBER_API OrthoVariation : public ParametricVariation +class OrthoVariation : public ParametricVariation { public: OrthoVariation(T weight = 1.0) : ParametricVariation("ortho", eVariationId::VAR_ORTHO, weight, true, false, false, false, true) @@ -3990,7 +3990,7 @@ private: /// Poincare. /// template -class EMBER_API PoincareVariation : public ParametricVariation +class PoincareVariation : public ParametricVariation { public: PoincareVariation(T weight = 1.0) : ParametricVariation("poincare", eVariationId::VAR_POINCARE, weight) @@ -4080,7 +4080,7 @@ private: /// Poincare3D. /// template -class EMBER_API Poincare3DVariation : public ParametricVariation +class Poincare3DVariation : public ParametricVariation { public: Poincare3DVariation(T weight = 1.0) : ParametricVariation("poincare3D", eVariationId::VAR_POINCARE3D, weight, true) @@ -4196,7 +4196,7 @@ private: /// Polynomial. /// template -class EMBER_API PolynomialVariation : public ParametricVariation +class PolynomialVariation : public ParametricVariation { public: PolynomialVariation(T weight = 1.0) : ParametricVariation("polynomial", eVariationId::VAR_POLYNOMIAL, weight) @@ -4270,7 +4270,7 @@ private: /// PSphere. /// template -class EMBER_API PSphereVariation : public ParametricVariation +class PSphereVariation : public ParametricVariation { public: PSphereVariation(T weight = 1.0) : ParametricVariation("psphere", eVariationId::VAR_PSPHERE, weight) @@ -4339,7 +4339,7 @@ private: /// Rational3. /// template -class EMBER_API Rational3Variation : public ParametricVariation +class Rational3Variation : public ParametricVariation { public: Rational3Variation(T weight = 1.0) : ParametricVariation("rational3", eVariationId::VAR_RATIONAL3, weight) @@ -4430,7 +4430,7 @@ private: /// Ripple. /// template -class EMBER_API RippleVariation : public ParametricVariation +class RippleVariation : public ParametricVariation { public: RippleVariation(T weight = 1.0) : ParametricVariation("ripple", eVariationId::VAR_RIPPLE, weight) @@ -4577,7 +4577,7 @@ private: /// Sigmoid. /// template -class EMBER_API SigmoidVariation : public ParametricVariation +class SigmoidVariation : public ParametricVariation { public: SigmoidVariation(T weight = 1.0) : ParametricVariation("sigmoid", eVariationId::VAR_SIGMOID, weight) @@ -4692,7 +4692,7 @@ private: /// SinusGrid. /// template -class EMBER_API SinusGridVariation : public ParametricVariation +class SinusGridVariation : public ParametricVariation { public: SinusGridVariation(T weight = 1.0) : ParametricVariation("sinusgrid", eVariationId::VAR_SINUS_GRID, weight) @@ -4788,7 +4788,7 @@ private: /// Stwin. /// template -class EMBER_API StwinVariation : public ParametricVariation +class StwinVariation : public ParametricVariation { public: StwinVariation(T weight = 1.0) : ParametricVariation("stwin", eVariationId::VAR_STWIN, weight) @@ -4866,7 +4866,7 @@ private: /// TwoFace. /// template -class EMBER_API TwoFaceVariation : public Variation +class TwoFaceVariation : public Variation { public: TwoFaceVariation(T weight = 1.0) : Variation("twoface", eVariationId::VAR_TWO_FACE, weight, true) { } @@ -4907,7 +4907,7 @@ public: /// Unpolar. /// template -class EMBER_API UnpolarVariation : public ParametricVariation +class UnpolarVariation : public ParametricVariation { public: UnpolarVariation(T weight = 1.0) : ParametricVariation("unpolar", eVariationId::VAR_UNPOLAR, weight) @@ -4967,7 +4967,7 @@ private: /// WavesN. /// template -class EMBER_API WavesNVariation : public ParametricVariation +class WavesNVariation : public ParametricVariation { public: WavesNVariation(T weight = 1.0) : ParametricVariation("wavesn", eVariationId::VAR_WAVESN, weight, true, false, false, false, true) @@ -5069,7 +5069,7 @@ private: /// XHeart. /// template -class EMBER_API XHeartVariation : public ParametricVariation +class XHeartVariation : public ParametricVariation { public: XHeartVariation(T weight = 1.0) : ParametricVariation("xheart", eVariationId::VAR_XHEART, weight, true) @@ -5174,7 +5174,7 @@ private: /// Barycentroid. /// template -class EMBER_API BarycentroidVariation : public ParametricVariation +class BarycentroidVariation : public ParametricVariation { public: BarycentroidVariation(T weight = 1.0) : ParametricVariation("barycentroid", eVariationId::VAR_BARYCENTROID, weight) @@ -5262,7 +5262,7 @@ private: /// BiSplit. /// template -class EMBER_API BiSplitVariation : public ParametricVariation +class BiSplitVariation : public ParametricVariation { public: BiSplitVariation(T weight = 1.0) : ParametricVariation("bisplit", eVariationId::VAR_BISPLIT, weight) @@ -5315,7 +5315,7 @@ private: /// Crescents. /// template -class EMBER_API CrescentsVariation : public Variation +class CrescentsVariation : public Variation { public: CrescentsVariation(T weight = 1.0) : Variation("crescents", eVariationId::VAR_CRESCENTS, weight) { } @@ -5360,7 +5360,7 @@ public: /// Mask. /// template -class EMBER_API MaskVariation : public Variation +class MaskVariation : public Variation { public: MaskVariation(T weight = 1.0) : Variation("mask", eVariationId::VAR_MASK, weight, true) { } @@ -5407,7 +5407,7 @@ public: /// Cpow2. /// template -class EMBER_API Cpow2Variation : public ParametricVariation +class Cpow2Variation : public ParametricVariation { public: Cpow2Variation(T weight = 1.0) : ParametricVariation("cpow2", eVariationId::VAR_CPOW2, weight, true, false, false, false, true) diff --git a/Source/Ember/Variations03.h b/Source/Ember/Variations03.h index 535a255..cbafb9d 100644 --- a/Source/Ember/Variations03.h +++ b/Source/Ember/Variations03.h @@ -8,7 +8,7 @@ namespace EmberNs /// Funnel. /// template -class EMBER_API FunnelVariation : public ParametricVariation +class FunnelVariation : public ParametricVariation { public: FunnelVariation(T weight = 1.0) : ParametricVariation("funnel", eVariationId::VAR_FUNNEL, weight) @@ -64,7 +64,7 @@ private: /// Linear3D. /// template -class EMBER_API Linear3DVariation : public Variation +class Linear3DVariation : public Variation { public: Linear3DVariation(T weight = 1.0) : Variation("linear3D", eVariationId::VAR_LINEAR3D, weight) { } @@ -95,7 +95,7 @@ public: /// PowBlock. /// template -class EMBER_API PowBlockVariation : public ParametricVariation +class PowBlockVariation : public ParametricVariation { public: PowBlockVariation(T weight = 1.0) : ParametricVariation("pow_block", eVariationId::VAR_POW_BLOCK, weight, true, false, false, false, true) @@ -173,7 +173,7 @@ private: /// Squirrel. /// template -class EMBER_API SquirrelVariation : public ParametricVariation +class SquirrelVariation : public ParametricVariation { public: SquirrelVariation(T weight = 1.0) : ParametricVariation("squirrel", eVariationId::VAR_SQUIRREL, weight) @@ -232,7 +232,7 @@ private: /// Ennepers. /// template -class EMBER_API EnnepersVariation : public Variation +class EnnepersVariation : public Variation { public: EnnepersVariation(T weight = 1.0) : Variation("ennepers", eVariationId::VAR_ENNEPERS, weight) { } @@ -263,7 +263,7 @@ public: /// SphericalN. /// template -class EMBER_API SphericalNVariation : public ParametricVariation +class SphericalNVariation : public ParametricVariation { public: SphericalNVariation(T weight = 1.0) : ParametricVariation("SphericalN", eVariationId::VAR_SPHERICALN, weight, true, true, false, false, true) @@ -330,7 +330,7 @@ private: /// Kaleidoscope. /// template -class EMBER_API KaleidoscopeVariation : public ParametricVariation +class KaleidoscopeVariation : public ParametricVariation { public: KaleidoscopeVariation(T weight = 1.0) : ParametricVariation("Kaleidoscope", eVariationId::VAR_KALEIDOSCOPE, weight) @@ -406,7 +406,7 @@ private: /// GlynnSim1. /// template -class EMBER_API GlynnSim1Variation : public ParametricVariation +class GlynnSim1Variation : public ParametricVariation { public: GlynnSim1Variation(T weight = 1.0) : ParametricVariation("GlynnSim1", eVariationId::VAR_GLYNNSIM1, weight, true, true) @@ -588,7 +588,7 @@ private: /// GlynnSim2. /// template -class EMBER_API GlynnSim2Variation : public ParametricVariation +class GlynnSim2Variation : public ParametricVariation { public: GlynnSim2Variation(T weight = 1.0) : ParametricVariation("GlynnSim2", eVariationId::VAR_GLYNNSIM2, weight, true, true) @@ -747,7 +747,7 @@ private: /// GlynnSim3. /// template -class EMBER_API GlynnSim3Variation : public ParametricVariation +class GlynnSim3Variation : public ParametricVariation { public: GlynnSim3Variation(T weight = 1.0) : ParametricVariation("GlynnSim3", eVariationId::VAR_GLYNNSIM3, weight, true, true) @@ -909,7 +909,7 @@ private: /// Starblur. /// template -class EMBER_API StarblurVariation : public ParametricVariation +class StarblurVariation : public ParametricVariation { public: StarblurVariation(T weight = 1.0) : ParametricVariation("starblur", eVariationId::VAR_STARBLUR, weight) @@ -1003,7 +1003,7 @@ private: /// Sineblur. /// template -class EMBER_API SineblurVariation : public ParametricVariation +class SineblurVariation : public ParametricVariation { public: SineblurVariation(T weight = 1.0) : ParametricVariation("sineblur", eVariationId::VAR_SINEBLUR, weight) @@ -1060,7 +1060,7 @@ private: /// Circleblur. /// template -class EMBER_API CircleblurVariation : public Variation +class CircleblurVariation : public Variation { public: CircleblurVariation(T weight = 1.0) : Variation("circleblur", eVariationId::VAR_CIRCLEBLUR, weight) { } @@ -1096,7 +1096,7 @@ public: /// Depth. /// template -class EMBER_API DepthVariation : public ParametricVariation +class DepthVariation : public ParametricVariation { public: DepthVariation(T weight = 1.0) : ParametricVariation("depth", eVariationId::VAR_DEPTH, weight) @@ -1154,7 +1154,7 @@ private: /// CropN. /// template -class EMBER_API CropNVariation : public ParametricVariation +class CropNVariation : public ParametricVariation { public: CropNVariation(T weight = 1.0) : ParametricVariation("cropn", eVariationId::VAR_CROPN, weight, true, true, false, false, true) @@ -1272,7 +1272,7 @@ private: /// ShredRad. /// template -class EMBER_API ShredRadVariation : public ParametricVariation +class ShredRadVariation : public ParametricVariation { public: ShredRadVariation(T weight = 1.0) : ParametricVariation("shredrad", eVariationId::VAR_SHRED_RAD, weight, true, true, false, false, true) @@ -1336,7 +1336,7 @@ private: /// Blob2. /// template -class EMBER_API Blob2Variation : public ParametricVariation +class Blob2Variation : public ParametricVariation { public: Blob2Variation(T weight = 1.0) : ParametricVariation("blob2", eVariationId::VAR_BLOB2, weight, true, true, false, false, true) @@ -1447,7 +1447,7 @@ private: /// Julia3D. /// template -class EMBER_API Julia3DVariation : public ParametricVariation +class Julia3DVariation : public ParametricVariation { public: Julia3DVariation(T weight = 1.0) : ParametricVariation("julia3D", eVariationId::VAR_JULIA3D, weight, true, true, false, false, true) @@ -1524,7 +1524,7 @@ private: /// Julia3Dz. /// template -class EMBER_API Julia3DzVariation : public ParametricVariation +class Julia3DzVariation : public ParametricVariation { public: Julia3DzVariation(T weight = 1.0) : ParametricVariation("julia3Dz", eVariationId::VAR_JULIA3DZ, weight, true, true, false, false, true) @@ -1597,7 +1597,7 @@ private: /// LinearT. /// template -class EMBER_API LinearTVariation : public ParametricVariation +class LinearTVariation : public ParametricVariation { public: LinearTVariation(T weight = 1.0) : ParametricVariation("linearT", eVariationId::VAR_LINEAR_T, weight) @@ -1653,7 +1653,7 @@ private: /// LinearT3D. /// template -class EMBER_API LinearT3DVariation : public ParametricVariation +class LinearT3DVariation : public ParametricVariation { public: LinearT3DVariation(T weight = 1.0) : ParametricVariation("linearT3D", eVariationId::VAR_LINEAR_T3D, weight) @@ -1707,7 +1707,7 @@ private: /// Ovoid. /// template -class EMBER_API OvoidVariation : public ParametricVariation +class OvoidVariation : public ParametricVariation { public: OvoidVariation(T weight = 1.0) : ParametricVariation("ovoid", eVariationId::VAR_OVOID, weight, true) @@ -1766,7 +1766,7 @@ private: /// Ovoid3D. /// template -class EMBER_API Ovoid3DVariation : public ParametricVariation +class Ovoid3DVariation : public ParametricVariation { public: Ovoid3DVariation(T weight = 1.0) : ParametricVariation("ovoid3d", eVariationId::VAR_OVOID3D, weight, true) @@ -1828,7 +1828,7 @@ private: /// Spirograph. /// template -class EMBER_API SpirographVariation : public ParametricVariation +class SpirographVariation : public ParametricVariation { public: SpirographVariation(T weight = 1.0) : ParametricVariation("Spirograph", eVariationId::VAR_SPIROGRAPH, weight) @@ -1909,7 +1909,7 @@ private: /// Petal. /// template -class EMBER_API PetalVariation : public Variation +class PetalVariation : public Variation { public: PetalVariation(T weight = 1.0) : Variation("petal", eVariationId::VAR_PETAL, weight) { } @@ -1957,7 +1957,7 @@ public: /// RoundSpher. /// template -class EMBER_API RoundSpherVariation : public Variation +class RoundSpherVariation : public Variation { public: RoundSpherVariation(T weight = 1.0) : Variation("roundspher", eVariationId::VAR_ROUNDSPHER, weight, true) { } @@ -1991,7 +1991,7 @@ public: /// roundSpher3D. /// template -class EMBER_API RoundSpher3DVariation : public Variation +class RoundSpher3DVariation : public Variation { public: RoundSpher3DVariation(T weight = 1.0) : Variation("roundspher3D", eVariationId::VAR_ROUNDSPHER3D, weight, true, true) { } @@ -2110,7 +2110,7 @@ public: /// SpiralWing. /// template -class EMBER_API SpiralWingVariation : public Variation +class SpiralWingVariation : public Variation { public: SpiralWingVariation(T weight = 1.0) : Variation("spiralwing", eVariationId::VAR_SPIRAL_WING, weight, true) { } @@ -2153,7 +2153,7 @@ public: /// Squarize. /// template -class EMBER_API SquarizeVariation : public Variation +class SquarizeVariation : public Variation { public: SquarizeVariation(T weight = 1.0) : Variation("squarize", eVariationId::VAR_SQUARIZE, weight, true, true, false, false, true) { } @@ -2246,7 +2246,7 @@ public: /// Sschecks. /// template -class EMBER_API SschecksVariation : public ParametricVariation +class SschecksVariation : public ParametricVariation { public: SschecksVariation(T weight = 1.0) : ParametricVariation("sschecks", eVariationId::VAR_SSCHECKS, weight, true) @@ -2344,7 +2344,7 @@ private: /// PhoenixJulia. /// template -class EMBER_API PhoenixJuliaVariation : public ParametricVariation +class PhoenixJuliaVariation : public ParametricVariation { public: PhoenixJuliaVariation(T weight = 1.0) : ParametricVariation("phoenix_julia", eVariationId::VAR_PHOENIX_JULIA, weight, true) @@ -2426,7 +2426,7 @@ private: /// Mobius. /// template -class EMBER_API MobiusVariation : public ParametricVariation +class MobiusVariation : public ParametricVariation { public: MobiusVariation(T weight = 1.0) : ParametricVariation("Mobius", eVariationId::VAR_MOBIUS, weight) @@ -2511,7 +2511,7 @@ private: /// MobiusN. /// template -class EMBER_API MobiusNVariation : public ParametricVariation +class MobiusNVariation : public ParametricVariation { public: MobiusNVariation(T weight = 1.0) : ParametricVariation("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. /// template -class EMBER_API MobiusStripVariation : public ParametricVariation +class MobiusStripVariation : public ParametricVariation { public: MobiusStripVariation(T weight = 1.0) : ParametricVariation("mobius_strip", eVariationId::VAR_MOBIUS_STRIP, weight) @@ -2799,7 +2799,7 @@ private: /// Lissajous. /// template -class EMBER_API LissajousVariation : public ParametricVariation +class LissajousVariation : public ParametricVariation { public: LissajousVariation(T weight = 1.0) : ParametricVariation("Lissajous", eVariationId::VAR_LISSAJOUS, weight) @@ -2874,7 +2874,7 @@ private: /// svf. /// template -class EMBER_API SvfVariation : public ParametricVariation +class SvfVariation : public ParametricVariation { public: SvfVariation(T weight = 1.0) : ParametricVariation("svf", eVariationId::VAR_SVF, weight) @@ -2933,7 +2933,7 @@ private: /// target. /// template -class EMBER_API TargetVariation : public ParametricVariation +class TargetVariation : public ParametricVariation { public: TargetVariation(T weight = 1.0) : ParametricVariation("target", eVariationId::VAR_TARGET, weight, true, true, false, false, true) @@ -3021,7 +3021,7 @@ private: /// taurus. /// template -class EMBER_API TaurusVariation : public ParametricVariation +class TaurusVariation : public ParametricVariation { public: TaurusVariation(T weight = 1.0) : ParametricVariation("taurus", eVariationId::VAR_TAURUS, weight) @@ -3105,7 +3105,7 @@ private: /// collideoscope. /// template -class EMBER_API CollideoscopeVariation : public ParametricVariation +class CollideoscopeVariation : public ParametricVariation { public: CollideoscopeVariation(T weight = 1.0) : ParametricVariation("collideoscope", eVariationId::VAR_COLLIDEOSCOPE, weight, true, true, false, false, true) @@ -3223,7 +3223,7 @@ private: /// bMod. /// template -class EMBER_API BModVariation : public ParametricVariation +class BModVariation : public ParametricVariation { public: BModVariation(T weight = 1.0) : ParametricVariation("bMod", eVariationId::VAR_BMOD, weight) @@ -3294,7 +3294,7 @@ private: /// bSwirl. /// template -class EMBER_API BSwirlVariation : public ParametricVariation +class BSwirlVariation : public ParametricVariation { public: BSwirlVariation(T weight = 1.0) : ParametricVariation("bSwirl", eVariationId::VAR_BSWIRL, weight) @@ -3361,7 +3361,7 @@ private: /// bTransform. /// template -class EMBER_API BTransformVariation : public ParametricVariation +class BTransformVariation : public ParametricVariation { public: BTransformVariation(T weight = 1.0) : ParametricVariation("bTransform", eVariationId::VAR_BTRANSFORM, weight) @@ -3445,7 +3445,7 @@ private: /// bCollide. /// template -class EMBER_API BCollideVariation : public ParametricVariation +class BCollideVariation : public ParametricVariation { public: BCollideVariation(T weight = 1.0) : ParametricVariation("bCollide", eVariationId::VAR_BCOLLIDE, weight) @@ -3542,7 +3542,7 @@ private: /// eclipse. /// template -class EMBER_API EclipseVariation : public ParametricVariation +class EclipseVariation : public ParametricVariation { public: EclipseVariation(T weight = 1.0) : ParametricVariation("eclipse", eVariationId::VAR_ECLIPSE, weight) @@ -3642,7 +3642,7 @@ private: /// flipcircle. /// template -class EMBER_API FlipCircleVariation : public ParametricVariation +class FlipCircleVariation : public ParametricVariation { public: FlipCircleVariation(T weight = 1.0) : ParametricVariation("flipcircle", eVariationId::VAR_FLIP_CIRCLE, weight, true) @@ -3705,7 +3705,7 @@ private: /// flipy. /// template -class EMBER_API FlipYVariation : public Variation +class FlipYVariation : public Variation { public: FlipYVariation(T weight = 1.0) : Variation("flipy", eVariationId::VAR_FLIP_Y, weight) { } @@ -3746,7 +3746,7 @@ public: /// eCollide. /// template -class EMBER_API ECollideVariation : public ParametricVariation +class ECollideVariation : public ParametricVariation { public: ECollideVariation(T weight = 1.0) : ParametricVariation("eCollide", eVariationId::VAR_ECOLLIDE, weight, true) @@ -3884,7 +3884,7 @@ private: /// eJulia. /// template -class EMBER_API EJuliaVariation : public ParametricVariation +class EJuliaVariation : public ParametricVariation { public: EJuliaVariation(T weight = 1.0) : ParametricVariation("eJulia", eVariationId::VAR_EJULIA, weight, true) @@ -4000,7 +4000,7 @@ private: /// eMod. /// template -class EMBER_API EModVariation : public ParametricVariation +class EModVariation : public ParametricVariation { public: EModVariation(T weight = 1.0) : ParametricVariation("eMod", eVariationId::VAR_EMOD, weight, true) @@ -4095,7 +4095,7 @@ private: /// eMotion. /// template -class EMBER_API EMotionVariation : public ParametricVariation +class EMotionVariation : public ParametricVariation { public: EMotionVariation(T weight = 1.0) : ParametricVariation("eMotion", eVariationId::VAR_EMOTION, weight, true) @@ -4199,7 +4199,7 @@ private: /// ePush. /// template -class EMBER_API EPushVariation : public ParametricVariation +class EPushVariation : public ParametricVariation { public: EPushVariation(T weight = 1.0) : ParametricVariation("ePush", eVariationId::VAR_EPUSH, weight, true) @@ -4288,7 +4288,7 @@ private: /// eRotate. /// template -class EMBER_API ERotateVariation : public ParametricVariation +class ERotateVariation : public ParametricVariation { public: ERotateVariation(T weight = 1.0) : ParametricVariation("eRotate", eVariationId::VAR_EROTATE, weight, true) @@ -4368,7 +4368,7 @@ private: /// eScale. /// template -class EMBER_API EScaleVariation : public ParametricVariation +class EScaleVariation : public ParametricVariation { public: EScaleVariation(T weight = 1.0) : ParametricVariation("eScale", eVariationId::VAR_ESCALE, weight, true) diff --git a/Source/Ember/Variations04.h b/Source/Ember/Variations04.h index 6fc82c2..bc7b829 100644 --- a/Source/Ember/Variations04.h +++ b/Source/Ember/Variations04.h @@ -8,7 +8,7 @@ namespace EmberNs /// eSwirl. /// template -class EMBER_API ESwirlVariation : public ParametricVariation +class ESwirlVariation : public ParametricVariation { public: ESwirlVariation(T weight = 1.0) : ParametricVariation("eSwirl", eVariationId::VAR_ESWIRL, weight, true) @@ -90,7 +90,7 @@ private: /// lazyTravis. /// template -class EMBER_API LazyTravisVariation : public ParametricVariation +class LazyTravisVariation : public ParametricVariation { public: LazyTravisVariation(T weight = 1.0) : ParametricVariation("lazyTravis", eVariationId::VAR_LAZY_TRAVIS, weight) @@ -356,7 +356,7 @@ private: /// squish. /// template -class EMBER_API SquishVariation : public ParametricVariation +class SquishVariation : public ParametricVariation { public: SquishVariation(T weight = 1.0) : ParametricVariation("squish", eVariationId::VAR_SQUISH, weight) @@ -512,7 +512,7 @@ private: /// circus. /// template -class EMBER_API CircusVariation : public ParametricVariation +class CircusVariation : public ParametricVariation { public: CircusVariation(T weight = 1.0) : ParametricVariation("circus", eVariationId::VAR_CIRCUS, weight, true, true, true) @@ -582,7 +582,7 @@ private: /// tancos. /// template -class EMBER_API TancosVariation : public Variation +class TancosVariation : public Variation { public: TancosVariation(T weight = 1.0) : Variation("tancos", eVariationId::VAR_TANCOS, weight, true) { } @@ -621,7 +621,7 @@ public: /// rippled. /// template -class EMBER_API RippledVariation : public Variation +class RippledVariation : public Variation { public: RippledVariation(T weight = 1.0) : Variation("rippled", eVariationId::VAR_RIPPLED, weight, true) { } @@ -661,7 +661,7 @@ public: /// This uses in/out in a rare and different way. /// template -class EMBER_API RotateXVariation : public ParametricVariation +class RotateXVariation : public ParametricVariation { public: RotateXVariation(T weight = 1.0) : ParametricVariation("rotate_x", eVariationId::VAR_ROTATE_X, weight) @@ -744,7 +744,7 @@ private: /// This uses in/out in a rare and different way. /// template -class EMBER_API RotateYVariation : public ParametricVariation +class RotateYVariation : public ParametricVariation { public: RotateYVariation(T weight = 1.0) : ParametricVariation("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. /// template -class EMBER_API RotateZVariation : public ParametricVariation +class RotateZVariation : public ParametricVariation { public: RotateZVariation(T weight = 1.0) : ParametricVariation("rotate_z", eVariationId::VAR_ROTATE_Z, weight) @@ -903,7 +903,7 @@ private: /// This uses in/out in a rare and different way. /// template -class EMBER_API MirrorXVariation : public Variation +class MirrorXVariation : public Variation { public: MirrorXVariation(T weight = 1.0) : Variation("mirror_x", eVariationId::VAR_MIRROR_X, weight) { } @@ -974,7 +974,7 @@ public: /// This uses in/out in a rare and different way. /// template -class EMBER_API MirrorYVariation : public Variation +class MirrorYVariation : public Variation { public: MirrorYVariation(T weight = 1.0) : Variation("mirror_y", eVariationId::VAR_MIRROR_Y, weight) { } @@ -1045,7 +1045,7 @@ public: /// This uses in/out in a rare and different way. /// template -class EMBER_API MirrorZVariation : public Variation +class MirrorZVariation : public Variation { public: MirrorZVariation(T weight = 1.0) : Variation("mirror_z", eVariationId::VAR_MIRROR_Z, weight) { } @@ -1115,7 +1115,7 @@ public: /// RBlur. /// template -class EMBER_API RBlurVariation : public ParametricVariation +class RBlurVariation : public ParametricVariation { public: RBlurVariation(T weight = 1.0) : ParametricVariation("rblur", eVariationId::VAR_RBLUR, weight) @@ -1192,7 +1192,7 @@ private: /// JuliaNab. /// template -class EMBER_API JuliaNabVariation : public ParametricVariation +class JuliaNabVariation : public ParametricVariation { public: JuliaNabVariation(T weight = 1.0) : ParametricVariation("juliaNab", eVariationId::VAR_JULIANAB, weight, true) @@ -1283,7 +1283,7 @@ private: /// Sintrange. /// template -class EMBER_API SintrangeVariation : public ParametricVariation +class SintrangeVariation : public ParametricVariation { public: SintrangeVariation(T weight = 1.0) : ParametricVariation("sintrange", eVariationId::VAR_SINTRANGE, weight) @@ -1338,7 +1338,7 @@ private: /// Voron. /// template -class EMBER_API VoronVariation : public ParametricVariation +class VoronVariation : public ParametricVariation { public: VoronVariation(T weight = 1.0) : ParametricVariation("Voron", eVariationId::VAR_VORON, weight) @@ -1490,7 +1490,7 @@ private: /// Waffle. /// template -class EMBER_API WaffleVariation : public ParametricVariation +class WaffleVariation : public ParametricVariation { public: WaffleVariation(T weight = 1.0) : ParametricVariation("waffle", eVariationId::VAR_WAFFLE, weight) @@ -1616,7 +1616,7 @@ private: /// Square3D. /// template -class EMBER_API Square3DVariation : public Variation +class Square3DVariation : public Variation { public: Square3DVariation(T weight = 1.0) : Variation("square3D", eVariationId::VAR_SQUARE3D, weight) { } @@ -1647,7 +1647,7 @@ public: /// SuperShape3D. /// template -class EMBER_API SuperShape3DVariation : public ParametricVariation +class SuperShape3DVariation : public ParametricVariation { public: SuperShape3DVariation(T weight = 1.0) : ParametricVariation("SuperShape3D", eVariationId::VAR_SUPER_SHAPE3D, weight) @@ -1851,7 +1851,7 @@ private: /// sphyp3D. /// template -class EMBER_API Sphyp3DVariation : public ParametricVariation +class Sphyp3DVariation : public ParametricVariation { public: Sphyp3DVariation(T weight = 1.0) : ParametricVariation("sphyp3D", eVariationId::VAR_SPHYP3D, weight, true) @@ -1935,7 +1935,7 @@ private: /// circlecrop. /// template -class EMBER_API CirclecropVariation : public ParametricVariation +class CirclecropVariation : public ParametricVariation { public: CirclecropVariation(T weight = 1.0) : ParametricVariation("circlecrop", eVariationId::VAR_CIRCLECROP, weight) @@ -2092,7 +2092,7 @@ private: /// julian3Dx. /// template -class EMBER_API Julian3DxVariation : public ParametricVariation +class Julian3DxVariation : public ParametricVariation { public: Julian3DxVariation(T weight = 1.0) : ParametricVariation("julian3Dx", eVariationId::VAR_JULIAN3DX, weight, true, true) @@ -2188,7 +2188,7 @@ private: /// fourth. /// template -class EMBER_API FourthVariation : public ParametricVariation +class FourthVariation : public ParametricVariation { public: FourthVariation(T weight = 1.0) : ParametricVariation("fourth", eVariationId::VAR_FOURTH, weight, true, true, false, false, true) @@ -2356,7 +2356,7 @@ private: /// mobiq. /// template -class EMBER_API MobiqVariation : public ParametricVariation +class MobiqVariation : public ParametricVariation { public: MobiqVariation(T weight = 1.0) : ParametricVariation("mobiq", eVariationId::VAR_MOBIQ, weight) @@ -2507,7 +2507,7 @@ private: /// spherivoid. /// template -class EMBER_API SpherivoidVariation : public ParametricVariation +class SpherivoidVariation : public ParametricVariation { public: SpherivoidVariation(T weight = 1.0) : ParametricVariation("spherivoid", eVariationId::VAR_SPHERIVOID, weight, true, true, false, false, true) @@ -2569,7 +2569,7 @@ private: /// farblur. /// template -class EMBER_API FarblurVariation : public ParametricVariation +class FarblurVariation : public ParametricVariation { public: FarblurVariation(T weight = 1.0) : ParametricVariation("farblur", eVariationId::VAR_FARBLUR, weight) @@ -2658,7 +2658,7 @@ private: /// curl_sp. /// template -class EMBER_API CurlSPVariation : public ParametricVariation +class CurlSPVariation : public ParametricVariation { public: CurlSPVariation(T weight = 1.0) : ParametricVariation("curl_sp", eVariationId::VAR_CURL_SP, weight) @@ -2763,7 +2763,7 @@ private: /// heat. /// template -class EMBER_API HeatVariation : public ParametricVariation +class HeatVariation : public ParametricVariation { public: HeatVariation(T weight = 1.0) : ParametricVariation("heat", eVariationId::VAR_HEAT, weight, true, false, false, false, true) @@ -2906,7 +2906,7 @@ private: /// interference2. /// template -class EMBER_API Interference2Variation : public ParametricVariation +class Interference2Variation : public ParametricVariation { public: Interference2Variation(T weight = 1.0) : ParametricVariation("interference2", eVariationId::VAR_INTERFERENCE2, weight) @@ -3112,7 +3112,7 @@ private: /// sinq. /// template -class EMBER_API SinqVariation : public Variation +class SinqVariation : public Variation { public: SinqVariation(T weight = 1.0) : Variation("sinq", eVariationId::VAR_SINQ, weight) { } @@ -3161,7 +3161,7 @@ public: /// sinhq. /// template -class EMBER_API SinhqVariation : public Variation +class SinhqVariation : public Variation { public: SinhqVariation(T weight = 1.0) : Variation("sinhq", eVariationId::VAR_SINHQ, weight) { } @@ -3210,7 +3210,7 @@ public: /// secq. /// template -class EMBER_API SecqVariation : public Variation +class SecqVariation : public Variation { public: SecqVariation(T weight = 1.0) : Variation("secq", eVariationId::VAR_SECQ, weight, true) { } @@ -3261,7 +3261,7 @@ public: /// sechq. /// template -class EMBER_API SechqVariation : public Variation +class SechqVariation : public Variation { public: SechqVariation(T weight = 1.0) : Variation("sechq", eVariationId::VAR_SECHQ, weight, true) { } @@ -3312,7 +3312,7 @@ public: /// tanq. /// template -class EMBER_API TanqVariation : public Variation +class TanqVariation : public Variation { public: TanqVariation(T weight = 1.0) : Variation("tanq", eVariationId::VAR_TANQ, weight) { } @@ -3368,7 +3368,7 @@ public: /// tanhq. /// template -class EMBER_API TanhqVariation : public Variation +class TanhqVariation : public Variation { public: TanhqVariation(T weight = 1.0) : Variation("tanhq", eVariationId::VAR_TANHQ, weight) { } @@ -3424,7 +3424,7 @@ public: /// cosq. /// template -class EMBER_API CosqVariation : public Variation +class CosqVariation : public Variation { public: CosqVariation(T weight = 1.0) : Variation("cosq", eVariationId::VAR_COSQ, weight) { } @@ -3473,7 +3473,7 @@ public: /// coshq. /// template -class EMBER_API CoshqVariation : public Variation +class CoshqVariation : public Variation { public: CoshqVariation(T weight = 1.0) : Variation("coshq", eVariationId::VAR_COSHQ, weight) { } @@ -3522,7 +3522,7 @@ public: /// cotq. /// template -class EMBER_API CotqVariation : public Variation +class CotqVariation : public Variation { public: CotqVariation(T weight = 1.0) : Variation("cotq", eVariationId::VAR_COTQ, weight) { } @@ -3578,7 +3578,7 @@ public: /// cothq. /// template -class EMBER_API CothqVariation : public Variation +class CothqVariation : public Variation { public: CothqVariation(T weight = 1.0) : Variation("cothq", eVariationId::VAR_COTHQ, weight) { } @@ -3634,7 +3634,7 @@ public: /// cscq. /// template -class EMBER_API CscqVariation : public Variation +class CscqVariation : public Variation { public: CscqVariation(T weight = 1.0) : Variation("cscq", eVariationId::VAR_CSCQ, weight, true) { } @@ -3685,7 +3685,7 @@ public: /// cschq. /// template -class EMBER_API CschqVariation : public Variation +class CschqVariation : public Variation { public: CschqVariation(T weight = 1.0) : Variation("cschq", eVariationId::VAR_CSCHQ, weight, true) { } @@ -3736,7 +3736,7 @@ public: /// estiq. /// template -class EMBER_API EstiqVariation : public Variation +class EstiqVariation : public Variation { public: EstiqVariation(T weight = 1.0) : Variation("estiq", eVariationId::VAR_ESTIQ, weight) { } @@ -3783,7 +3783,7 @@ public: /// loq. /// template -class EMBER_API LoqVariation : public ParametricVariation +class LoqVariation : public ParametricVariation { public: LoqVariation(T weight = 1.0) : ParametricVariation("loq", eVariationId::VAR_LOQ, weight) @@ -3849,7 +3849,7 @@ private: /// curvature. /// template -class EMBER_API CurvatureVariation : public Variation +class CurvatureVariation : public Variation { public: CurvatureVariation(T weight = 1.0) : Variation("curvature", eVariationId::VAR_CURVATURE, weight, true, true, false, false, true) { } @@ -3885,7 +3885,7 @@ public: /// q_ode. /// template -class EMBER_API QodeVariation : public ParametricVariation +class QodeVariation : public ParametricVariation { public: QodeVariation(T weight = 1.0) : ParametricVariation("q_ode", eVariationId::VAR_Q_ODE, weight) @@ -3977,7 +3977,7 @@ private: /// blur_heart. /// template -class EMBER_API BlurHeartVariation : public ParametricVariation +class BlurHeartVariation : public ParametricVariation { public: BlurHeartVariation(T weight = 1.0) : ParametricVariation("blur_heart", eVariationId::VAR_BLUR_HEART, weight) @@ -4073,7 +4073,7 @@ private: /// Truchet. /// template -class EMBER_API TruchetVariation : public ParametricVariation +class TruchetVariation : public ParametricVariation { public: TruchetVariation(T weight = 1.0) : ParametricVariation("Truchet", eVariationId::VAR_TRUCHET, weight) @@ -4392,7 +4392,7 @@ private: /// gdoffs. /// template -class EMBER_API GdoffsVariation : public ParametricVariation +class GdoffsVariation : public ParametricVariation { public: GdoffsVariation(T weight = 1.0) : ParametricVariation("gdoffs", eVariationId::VAR_GDOFFS, weight) @@ -4549,7 +4549,7 @@ private: /// octagon. /// template -class EMBER_API OctagonVariation : public ParametricVariation +class OctagonVariation : public ParametricVariation { public: OctagonVariation(T weight = 1.0) : ParametricVariation("octagon", eVariationId::VAR_OCTAGON, weight) @@ -4689,7 +4689,7 @@ private: /// trade. /// template -class EMBER_API TradeVariation : public ParametricVariation +class TradeVariation : public ParametricVariation { public: TradeVariation(T weight = 1.0) : ParametricVariation("trade", eVariationId::VAR_TRADE, weight) @@ -4834,7 +4834,7 @@ private: /// Juliac. /// template -class EMBER_API JuliacVariation : public ParametricVariation +class JuliacVariation : public ParametricVariation { public: JuliacVariation(T weight = 1.0) : ParametricVariation("Juliac", eVariationId::VAR_JULIAC, weight, true, false, false, false, true) @@ -4909,7 +4909,7 @@ private: /// blade3D. /// template -class EMBER_API Blade3DVariation : public Variation +class Blade3DVariation : public Variation { public: Blade3DVariation(T weight = 1.0) : Variation("blade3D", eVariationId::VAR_BLADE3D, weight, true, true) { } @@ -4947,7 +4947,7 @@ public: /// Blob3D. /// template -class EMBER_API Blob3DVariation : public ParametricVariation +class Blob3DVariation : public ParametricVariation { public: Blob3DVariation(T weight = 1.0) : ParametricVariation("blob3D", eVariationId::VAR_BLOB3D, weight, true, true, true, true) @@ -5019,7 +5019,7 @@ private: /// blocky. /// template -class EMBER_API BlockyVariation : public ParametricVariation +class BlockyVariation : public ParametricVariation { public: BlockyVariation(T weight = 1.0) : ParametricVariation("blocky", eVariationId::VAR_BLOCKY, weight, true) @@ -5175,7 +5175,7 @@ MAKEPREPOSTPARVAR(Blocky, blocky, BLOCKY) ///// LinearXZ. ///// //template -//class EMBER_API LinearXZVariation : public Variation +//class LinearXZVariation : public Variation //{ //public: // LinearXZVariation(T weight = 1.0) : Variation("linearxz", eVariationId::VAR_LINEAR_XZ, weight) { } @@ -5206,7 +5206,7 @@ MAKEPREPOSTPARVAR(Blocky, blocky, BLOCKY) ///// LinearYZ. ///// //template -//class EMBER_API LinearYZVariation : public Variation +//class LinearYZVariation : public Variation //{ //public: // LinearYZVariation(T weight = 1.0) : Variation("linearyz", eVariationId::VAR_LINEAR_YZ, weight) { } diff --git a/Source/Ember/Variations05.h b/Source/Ember/Variations05.h index 64a825d..1948f6e 100644 --- a/Source/Ember/Variations05.h +++ b/Source/Ember/Variations05.h @@ -8,7 +8,7 @@ namespace EmberNs /// bubble2. /// template -class EMBER_API Bubble2Variation : public ParametricVariation +class Bubble2Variation : public ParametricVariation { public: Bubble2Variation(T weight = 1.0) : ParametricVariation("bubble2", eVariationId::VAR_BUBBLE2, weight, true) @@ -79,7 +79,7 @@ private: /// CircleLinear. /// template -class EMBER_API CircleLinearVariation : public ParametricVariation +class CircleLinearVariation : public ParametricVariation { public: CircleLinearVariation(T weight = 1.0) : ParametricVariation("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. /// template -class EMBER_API CircleRandVariation : public ParametricVariation +class CircleRandVariation : public ParametricVariation { public: CircleRandVariation(T weight = 1.0) : ParametricVariation("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. /// template -class EMBER_API CircleTrans1Variation : public ParametricVariation +class CircleTrans1Variation : public ParametricVariation { public: CircleTrans1Variation(T weight = 1.0) : ParametricVariation("CircleTrans1", eVariationId::VAR_CIRCLETRANS1, weight) @@ -576,7 +576,7 @@ private: /// cubic3D. /// template -class EMBER_API Cubic3DVariation : public ParametricVariation +class Cubic3DVariation : public ParametricVariation { public: Cubic3DVariation(T weight = 1.0) : ParametricVariation("cubic3D", eVariationId::VAR_CUBIC3D, weight) @@ -803,7 +803,7 @@ private: /// cubicLattice_3D. /// template -class EMBER_API CubicLattice3DVariation : public ParametricVariation +class CubicLattice3DVariation : public ParametricVariation { public: CubicLattice3DVariation(T weight = 1.0) : ParametricVariation("cubicLattice_3D", eVariationId::VAR_CUBIC_LATTICE3D, weight) @@ -1021,7 +1021,7 @@ private: /// foci_3D. /// template -class EMBER_API Foci3DVariation : public Variation +class Foci3DVariation : public Variation { public: Foci3DVariation(T weight = 1.0) : Variation("foci_3D", eVariationId::VAR_FOCI3D, weight, false, false, false, false, true) { } @@ -1061,7 +1061,7 @@ public: /// ho. /// template -class EMBER_API HoVariation : public ParametricVariation +class HoVariation : public ParametricVariation { public: HoVariation(T weight = 1.0) : ParametricVariation("ho", eVariationId::VAR_HO, weight) @@ -1144,7 +1144,7 @@ private: /// Julia3Dq. /// template -class EMBER_API Julia3DqVariation : public ParametricVariation +class Julia3DqVariation : public ParametricVariation { public: Julia3DqVariation(T weight = 1.0) : ParametricVariation("julia3Dq", eVariationId::VAR_JULIA3DQ, weight, true, true, false, false, true) @@ -1230,7 +1230,7 @@ private: /// line. /// template -class EMBER_API LineVariation : public ParametricVariation +class LineVariation : public ParametricVariation { public: LineVariation(T weight = 1.0) : ParametricVariation("line", eVariationId::VAR_LINE, weight) @@ -1306,7 +1306,7 @@ private: /// Loonie2. /// template -class EMBER_API Loonie2Variation : public ParametricVariation +class Loonie2Variation : public ParametricVariation { public: Loonie2Variation(T weight = 1.0) : ParametricVariation("loonie2", eVariationId::VAR_LOONIE2, weight, true, true) @@ -1467,7 +1467,7 @@ private: /// Loonie3. /// template -class EMBER_API Loonie3Variation : public ParametricVariation +class Loonie3Variation : public ParametricVariation { public: Loonie3Variation(T weight = 1.0) : ParametricVariation("loonie3", eVariationId::VAR_LOONIE3, weight, true) @@ -1555,7 +1555,7 @@ private: /// loonie_3D. /// template -class EMBER_API Loonie3DVariation : public ParametricVariation +class Loonie3DVariation : public ParametricVariation { public: Loonie3DVariation(T weight = 1.0) : ParametricVariation("loonie_3D", eVariationId::VAR_LOONIE3D, weight, true, false, false, false, true) @@ -1637,7 +1637,7 @@ private: /// mcarpet. /// template -class EMBER_API McarpetVariation : public ParametricVariation +class McarpetVariation : public ParametricVariation { public: McarpetVariation(T weight = 1.0) : ParametricVariation("mcarpet", eVariationId::VAR_MCARPET, weight, true) @@ -1706,7 +1706,7 @@ private: /// which is slightly slower, but more correct. /// template -class EMBER_API Waves23DVariation : public ParametricVariation +class Waves23DVariation : public ParametricVariation { public: Waves23DVariation(T weight = 1.0) : ParametricVariation("waves2_3D", eVariationId::VAR_WAVES23D, weight) @@ -1760,7 +1760,7 @@ private: /// Pie3D. /// template -class EMBER_API Pie3DVariation : public ParametricVariation +class Pie3DVariation : public ParametricVariation { public: Pie3DVariation(T weight = 1.0) : ParametricVariation("pie3D", eVariationId::VAR_PIE3D, weight) @@ -1828,7 +1828,7 @@ private: /// popcorn2_3D. /// template -class EMBER_API Popcorn23DVariation : public ParametricVariation +class Popcorn23DVariation : public ParametricVariation { public: Popcorn23DVariation(T weight = 1.0) : ParametricVariation("popcorn2_3D", eVariationId::VAR_POPCORN23D, weight, false, false, false, false, true) @@ -1940,7 +1940,7 @@ private: /// sinusoidal3d. /// template -class EMBER_API Sinusoidal3DVariation : public Variation +class Sinusoidal3DVariation : public Variation { public: Sinusoidal3DVariation(T weight = 1.0) : Variation("sinusoidal3D", eVariationId::VAR_SINUSOIDAL3D, weight) { } @@ -1971,7 +1971,7 @@ public: /// scry_3D. /// template -class EMBER_API Scry3DVariation : public ParametricVariation +class Scry3DVariation : public ParametricVariation { public: Scry3DVariation(T weight = 1.0) : ParametricVariation("scry_3D", eVariationId::VAR_SCRY3D, weight, true, false, false, false, true) @@ -2031,7 +2031,7 @@ private: /// shredlin. /// template -class EMBER_API ShredlinVariation : public ParametricVariation +class ShredlinVariation : public ParametricVariation { public: ShredlinVariation(T weight = 1.0) : ParametricVariation("shredlin", eVariationId::VAR_SHRED_LIN, weight) @@ -2117,7 +2117,7 @@ private: /// splitbrdr. /// template -class EMBER_API SplitBrdrVariation : public ParametricVariation +class SplitBrdrVariation : public ParametricVariation { public: SplitBrdrVariation(T weight = 1.0) : ParametricVariation("SplitBrdr", eVariationId::VAR_SPLIT_BRDR, weight, true) @@ -2261,7 +2261,7 @@ private: /// wdisc. /// template -class EMBER_API WdiscVariation : public Variation +class WdiscVariation : public Variation { public: WdiscVariation(T weight = 1.0) : Variation("wdisc", eVariationId::VAR_WDISC, weight, true, true, false, false, true) { } @@ -2304,7 +2304,7 @@ public: /// falloff. /// template -class EMBER_API FalloffVariation : public ParametricVariation +class FalloffVariation : public ParametricVariation { public: FalloffVariation(T weight = 1.0) : ParametricVariation("falloff", eVariationId::VAR_FALLOFF, weight, false, false, false, false, true) @@ -2467,7 +2467,7 @@ private: /// falloff2. /// template -class EMBER_API Falloff2Variation : public ParametricVariation +class Falloff2Variation : public ParametricVariation { public: Falloff2Variation(T weight = 1.0) : ParametricVariation("falloff2", eVariationId::VAR_FALLOFF2, weight, true, false, false, false, true) @@ -2667,7 +2667,7 @@ private: /// falloff3. /// template -class EMBER_API Falloff3Variation : public ParametricVariation +class Falloff3Variation : public ParametricVariation { public: Falloff3Variation(T weight = 1.0) : ParametricVariation("falloff3", eVariationId::VAR_FALLOFF3, weight, true, false, false, false, true) @@ -2900,7 +2900,7 @@ private: /// xtrb. /// template -class EMBER_API XtrbVariation : public ParametricVariation +class XtrbVariation : public ParametricVariation { public: XtrbVariation(T weight = 1.0) : ParametricVariation("xtrb", eVariationId::VAR_XTRB, weight) @@ -3438,7 +3438,7 @@ private: /// This uses state and the OpenCL version looks different and better than the CPU. /// template -class EMBER_API Hexaplay3DVariation : public ParametricVariation +class Hexaplay3DVariation : public ParametricVariation { public: Hexaplay3DVariation(T weight = 1.0) : ParametricVariation("hexaplay3D", eVariationId::VAR_HEXAPLAY3D, weight) @@ -3717,7 +3717,7 @@ private: /// This is because different paths do different things to helper.Out.z /// template -class EMBER_API Hexnix3DVariation : public ParametricVariation +class Hexnix3DVariation : public ParametricVariation { public: Hexnix3DVariation(T weight = 1.0) : ParametricVariation("hexnix3D", eVariationId::VAR_HEXNIX3D, weight) @@ -4101,7 +4101,7 @@ private: /// hexcrop. /// template -class EMBER_API HexcropVariation : public ParametricVariation +class HexcropVariation : public ParametricVariation { public: HexcropVariation(T weight = 1.0) : ParametricVariation("hexcrop", eVariationId::VAR_HEXCROP, weight) diff --git a/Source/Ember/Variations06.h b/Source/Ember/Variations06.h index 23313f9..c5696b4 100644 --- a/Source/Ember/Variations06.h +++ b/Source/Ember/Variations06.h @@ -8,7 +8,7 @@ namespace EmberNs /// hexes. /// template -class EMBER_API HexesVariation : public ParametricVariation +class HexesVariation : public ParametricVariation { public: HexesVariation(T weight = 1.0) : ParametricVariation("hexes", eVariationId::VAR_HEXES, weight) @@ -300,7 +300,7 @@ private: /// nBlur. /// template -class EMBER_API NblurVariation : public ParametricVariation +class NblurVariation : public ParametricVariation { struct RandXyParams { @@ -1138,7 +1138,7 @@ private: /// octapol. /// template -class EMBER_API OctapolVariation : public ParametricVariation +class OctapolVariation : public ParametricVariation { public: OctapolVariation(T weight = 1.0) : ParametricVariation("octapol", eVariationId::VAR_OCTAPOL, weight) @@ -1477,7 +1477,7 @@ private: /// This uses the input point in an extremely rare way since it changes it. /// template -class EMBER_API CrobVariation : public ParametricVariation +class CrobVariation : public ParametricVariation { public: CrobVariation(T weight = 1.0) : ParametricVariation("crob", eVariationId::VAR_CROB, weight) @@ -1810,7 +1810,7 @@ private: /// bubbleT3D. /// template -class EMBER_API BubbleT3DVariation : public ParametricVariation +class BubbleT3DVariation : public ParametricVariation { public: BubbleT3DVariation(T weight = 1.0) : ParametricVariation("bubbleT3D", eVariationId::VAR_BUBBLET3D, weight, true) @@ -2361,7 +2361,7 @@ private: /// synth. /// template -class EMBER_API SynthVariation : public ParametricVariation +class SynthVariation : public ParametricVariation { public: SynthVariation(T weight = 1.0) : ParametricVariation("synth", eVariationId::VAR_SYNTH, weight, true, true, false, true) @@ -3694,7 +3694,7 @@ private: /// crackle. /// template -class EMBER_API CrackleVariation : public ParametricVariation +class CrackleVariation : public ParametricVariation { public: CrackleVariation(T weight = 1.0) : ParametricVariation("crackle", eVariationId::VAR_CRACKLE, weight) @@ -3922,7 +3922,7 @@ private: /// This variation is special in that it only exists as a post_. /// template -class EMBER_API PostSmartcropVariation : public ParametricVariation +class PostSmartcropVariation : public ParametricVariation { public: PostSmartcropVariation(T weight = 1.0) : ParametricVariation("post_smartcrop", eVariationId::VAR_POST_SMARTCROP, weight) @@ -4428,7 +4428,7 @@ private: /// erf. /// template -class EMBER_API ErfVariation : public Variation +class ErfVariation : public Variation { public: ErfVariation(T weight = 1.0) : Variation("erf", eVariationId::VAR_ERF, weight) { } @@ -4459,7 +4459,7 @@ public: /// xerf. /// template -class EMBER_API XerfVariation : public Variation +class XerfVariation : public Variation { public: XerfVariation(T weight = 1.0) : Variation("xerf", eVariationId::VAR_XERF, weight, true) { } @@ -4494,7 +4494,7 @@ public: }; template -class EMBER_API WVariation : public ParametricVariation +class WVariation : public ParametricVariation { public: WVariation(T weight = 1.0) : ParametricVariation("w", eVariationId::VAR_W, weight, true, true, false, false, true) @@ -4796,7 +4796,7 @@ private: }; template -class EMBER_API XVariation : public ParametricVariation +class XVariation : public ParametricVariation { public: XVariation(T weight = 1.0) : ParametricVariation("x", eVariationId::VAR_X, weight, true, false, false, false, true) @@ -4993,7 +4993,7 @@ private: }; template -class EMBER_API YVariation : public ParametricVariation +class YVariation : public ParametricVariation { public: YVariation(T weight = 1.0) : ParametricVariation("y", eVariationId::VAR_Y, weight, true, true, false, false, true) @@ -5190,7 +5190,7 @@ private: }; template -class EMBER_API ZVariation : public ParametricVariation +class ZVariation : public ParametricVariation { public: ZVariation(T weight = 1.0) : ParametricVariation("z", eVariationId::VAR_Z, weight, true, true, false, false, true) diff --git a/Source/Ember/Variations07.h b/Source/Ember/Variations07.h index 8c4ce36..a4ea759 100644 --- a/Source/Ember/Variations07.h +++ b/Source/Ember/Variations07.h @@ -8,7 +8,7 @@ namespace EmberNs /// splits3D. /// template -class EMBER_API Splits3DVariation : public ParametricVariation +class Splits3DVariation : public ParametricVariation { public: Splits3DVariation(T weight = 1.0) : ParametricVariation("splits3D", eVariationId::VAR_SPLITS3D, weight) @@ -93,7 +93,7 @@ private: /// when running on the GPU. The results might look different. /// template -class EMBER_API Waves2BVariation : public ParametricVariation +class Waves2BVariation : public ParametricVariation { public: Waves2BVariation(T weight = 1.0) : ParametricVariation("waves2b", eVariationId::VAR_WAVES2B, weight) @@ -249,7 +249,7 @@ private: /// jac_cn. /// template -class EMBER_API JacCnVariation : public ParametricVariation +class JacCnVariation : public ParametricVariation { public: JacCnVariation(T weight = 1.0) : ParametricVariation("jac_cn", eVariationId::VAR_JAC_CN, weight) @@ -322,7 +322,7 @@ private: /// jac_dn. /// template -class EMBER_API JacDnVariation : public ParametricVariation +class JacDnVariation : public ParametricVariation { public: JacDnVariation(T weight = 1.0) : ParametricVariation("jac_dn", eVariationId::VAR_JAC_DN, weight) @@ -395,7 +395,7 @@ private: /// jac_sn. /// template -class EMBER_API JacSnVariation : public ParametricVariation +class JacSnVariation : public ParametricVariation { public: JacSnVariation(T weight = 1.0) : ParametricVariation("jac_sn", eVariationId::VAR_JAC_SN, weight) @@ -468,7 +468,7 @@ private: /// pressure_wave. /// template -class EMBER_API PressureWaveVariation : public ParametricVariation +class PressureWaveVariation : public ParametricVariation { public: PressureWaveVariation(T weight = 1.0) : ParametricVariation("pressure_wave", eVariationId::VAR_PRESSURE_WAVE, weight) @@ -524,7 +524,7 @@ private: /// gamma. /// template -class EMBER_API GammaVariation : public Variation +class GammaVariation : public Variation { public: GammaVariation(T weight = 1.0) : Variation("gamma", eVariationId::VAR_GAMMA, weight, true, true, false, false, true) @@ -559,7 +559,7 @@ public: /// prose3D. /// template -class EMBER_API PRose3DVariation : public ParametricVariation +class PRose3DVariation : public ParametricVariation { public: PRose3DVariation(T weight = 1.0) : ParametricVariation("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 /// template -class EMBER_API LogDBVariation : public ParametricVariation +class LogDBVariation : public ParametricVariation { public: LogDBVariation(T weight = 1.0) : ParametricVariation("log_db", eVariationId::VAR_LOG_DB, weight, true, false, false, false, true) diff --git a/Source/Ember/VariationsDC.h b/Source/Ember/VariationsDC.h index 728635e..4311e51 100644 --- a/Source/Ember/VariationsDC.h +++ b/Source/Ember/VariationsDC.h @@ -9,7 +9,7 @@ namespace EmberNs /// This accesses the summed output point in a rare and different way. /// template -class EMBER_API DCBubbleVariation : public ParametricVariation +class DCBubbleVariation : public ParametricVariation { public: DCBubbleVariation(T weight = 1.0) : ParametricVariation("dc_bubble", eVariationId::VAR_DC_BUBBLE, weight, true) @@ -120,7 +120,7 @@ private: /// DC Carpet. /// template -class EMBER_API DCCarpetVariation : public ParametricVariation +class DCCarpetVariation : public ParametricVariation { public: DCCarpetVariation(T weight = 1.0) : ParametricVariation("dc_carpet", eVariationId::VAR_DC_CARPET, weight) @@ -191,7 +191,7 @@ private: /// DC Cube. /// template -class EMBER_API DCCubeVariation : public ParametricVariation +class DCCubeVariation : public ParametricVariation { public: DCCubeVariation(T weight = 1.0) : ParametricVariation("dc_cube", eVariationId::VAR_DC_CUBE, weight) @@ -381,7 +381,7 @@ private: /// This accesses the summed output point in a rare and different way. /// template -class EMBER_API DCCylinderVariation : public ParametricVariation +class DCCylinderVariation : public ParametricVariation { public: DCCylinderVariation(T weight = 1.0) : ParametricVariation("dc_cylinder", eVariationId::VAR_DC_CYLINDER, weight) @@ -508,7 +508,7 @@ private: /// DC GridOut. /// template -class EMBER_API DCGridOutVariation : public Variation +class DCGridOutVariation : public Variation { public: DCGridOutVariation(T weight = 1.0) : Variation("dc_gridout", eVariationId::VAR_DC_GRIDOUT, weight) { } @@ -685,7 +685,7 @@ public: /// This accesses the summed output point in a rare and different way. /// template -class EMBER_API DCLinearVariation : public ParametricVariation +class DCLinearVariation : public ParametricVariation { public: DCLinearVariation(T weight = 1.0) : ParametricVariation("dc_linear", eVariationId::VAR_DC_LINEAR, weight) @@ -795,7 +795,7 @@ private: /// DC Triangle. /// template -class EMBER_API DCTriangleVariation : public ParametricVariation +class DCTriangleVariation : public ParametricVariation { public: DCTriangleVariation(T weight = 1.0) : ParametricVariation("dc_triangle", eVariationId::VAR_DC_TRIANGLE, weight) @@ -1004,7 +1004,7 @@ private: /// These will follow the same naming convention as all other variations. /// template -class EMBER_API DCZTranslVariation : public ParametricVariation +class DCZTranslVariation : public ParametricVariation { public: DCZTranslVariation(T weight = 1.0) : ParametricVariation("dc_ztransl", eVariationId::VAR_DC_ZTRANSL, weight) @@ -1109,7 +1109,7 @@ private: /// dc_perlin. /// template -class EMBER_API DCPerlinVariation : public ParametricVariation +class DCPerlinVariation : public ParametricVariation { public: DCPerlinVariation(T weight = 1.0) : ParametricVariation("dc_perlin", eVariationId::VAR_DC_PERLIN, weight) diff --git a/Source/Ember/Xform.h b/Source/Ember/Xform.h index 92e86d8..aebc342 100644 --- a/Source/Ember/Xform.h +++ b/Source/Ember/Xform.h @@ -10,8 +10,8 @@ namespace EmberNs { /// -/// Xform and Variation need each other, but each can't include the other. -/// So Xform includes this file, and Ember is declared as a forward declaration here. +/// Xform and Ember need each other, but each can't include the other. +/// So Ember includes this file, and Ember is declared as a forward declaration here. /// template class Ember; @@ -879,6 +879,7 @@ public: bool Flatten(vector& names) { bool shouldFlatten = true; + VariationList& vl(VariationList::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* var = new FlattenVariation(); + auto var = vl.GetVariationCopy(eVariationId::VAR_FLATTEN); if (AddVariation(var)) { diff --git a/Source/Ember/XmlToEmber.h b/Source/Ember/XmlToEmber.h index 1b708ed..aa7fe76 100644 --- a/Source/Ember/XmlToEmber.h +++ b/Source/Ember/XmlToEmber.h @@ -74,6 +74,7 @@ public: /// Constructor that initializes the random context. /// XmlToEmber() + : m_VariationList(VariationList::Instance()) { Timing t; @@ -1535,7 +1536,7 @@ private: static bool m_Init; static unordered_map m_BadParamNames; static vector, vector>> m_BadVariationNames; - VariationList m_VariationList;//The variation list used to make copies of variations to populate the embers with. + VariationList& m_VariationList;//The variation list used to make copies of variations to populate the embers with. PaletteList m_PaletteList; }; } diff --git a/Source/EmberGenome/EmberGenome.cpp b/Source/EmberGenome/EmberGenome.cpp index 25c6191..cfa48b5 100644 --- a/Source/EmberGenome/EmberGenome.cpp +++ b/Source/EmberGenome/EmberGenome.cpp @@ -64,13 +64,13 @@ bool EmberGenome(EmberOptions& opt) return true; } + VariationList& varList(VariationList::Instance()); + if (opt.AllVars() || opt.RegVars() || opt.PreVars() || opt.PostVars()) { - VariationList 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*> 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* aselp0, *aselp1, *pTemplate = nullptr; XmlToEmber parser; EmberToXml emberToXml; - VariationList varList; EmberReport emberReport, emberReport2; const vector> devices = Devices(opt.Devices()); unique_ptr> progress(new RenderProgress()); diff --git a/Source/EmberTester/EmberTester.cpp b/Source/EmberTester/EmberTester.cpp index 8aa2940..76b43d0 100644 --- a/Source/EmberTester/EmberTester.cpp +++ b/Source/EmberTester/EmberTester.cpp @@ -89,7 +89,7 @@ void MakeTestAllVarsRegPrePost(vector>& embers) { uint index = 0; ostringstream ss; - VariationList varList; + VariationList& varList(VariationList::Instance()); PaletteList paletteList; QTIsaac rand; paletteList.Add("flam3-palettes.xml"); @@ -337,7 +337,7 @@ template static vector*> FindVarsWith(vector& stringVec, bool findAll = true) { int index = 0; - VariationList vl; + VariationList& vl(VariationList::Instance()); vector*> vec; while (index < vl.RegSize()) @@ -360,9 +360,9 @@ static vector*> FindVarsWith(vector& stringVec, bool findAl bool TestVarCounts() { - VariationList vlf; + VariationList& vlf(VariationList::Instance()); #ifdef DO_DOUBLE - VariationList vld; + VariationList& vld(VariationList::Instance()); bool success((vlf.Size() == vld.Size()) && (vlf.Size() == size_t(eVariationId::LAST_VAR))); #else bool success = true; @@ -392,7 +392,7 @@ template bool TestVarUnique() { bool success = true; - VariationList vl; + VariationList& vl(VariationList::Instance()); vector ids; vector names; ids.reserve(vl.Size()); @@ -580,7 +580,7 @@ bool TestVarEqual(const Variation* var1, const Variation
* var2) bool TestVarPrePostNames() { bool success = true; - VariationList vlf; + VariationList& vlf(VariationList::Instance()); for (size_t i = 0; i < vlf.Size(); i++) { @@ -646,7 +646,7 @@ template bool TestVarCopy() { bool success = true; - VariationList vlf; + VariationList& vlf(VariationList::Instance()); for (size_t i = 0; i < vlf.Size(); i++) { @@ -676,7 +676,7 @@ bool TestVarCopy() bool TestParVars() { bool success = true; - VariationList vlf; + VariationList& vlf(VariationList::Instance()); for (size_t i = 0; i < vlf.ParametricSize(); i++) { @@ -730,7 +730,7 @@ bool TestParVars() bool TestVarRegPrePost() { bool success = true; - VariationList vlf; + VariationList& vlf(VariationList::Instance()); for (size_t i = 0; i < vlf.RegSize(); i++) { @@ -782,7 +782,7 @@ bool TestVarRegPrePost() bool TestVarPrecalcUsedCL() { bool success = true; - VariationList vlf; + VariationList& vlf(VariationList::Instance()); for (size_t i = 0; i < vlf.Size(); i++) { @@ -951,7 +951,7 @@ bool TestVarPrecalcUsedCL() bool TestVarAssignTypes() { bool success = true; - VariationList vlf; + VariationList& vlf(VariationList::Instance()); vector vset, vsum; vset.push_back("vIn.x"); vset.push_back("vIn.y"); @@ -1009,7 +1009,7 @@ bool TestVarAssignTypes() bool TestVarAssignVals() { bool success = true; - VariationList vlf; + VariationList& vlf(VariationList::Instance()); vector 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 vlf; + VariationList& vlf(VariationList::Instance()); vector zeps; zeps.push_back("Zeps(floor"); @@ -1077,7 +1077,7 @@ bool TestZepsFloor() bool TestConstants() { bool success = true; - VariationList vlf; + VariationList& vlf(VariationList::Instance()); vector 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 vlf; + VariationList& vlf(VariationList::Instance()); vector funcs; FunctionMapper mapper; @@ -1130,7 +1130,7 @@ bool TestGlobalFuncs() void PrintAllVars() { uint i = 0; - VariationList vlf; + VariationList& vlf(VariationList::Instance()); while (auto var = vlf.GetVariation(i++)) cout << var->Name() << endl; @@ -1139,7 +1139,7 @@ void PrintAllVars() void TestXformsInOutPoints() { uint index = 0; - VariationList varList; + VariationList& varList(VariationList::Instance()); PaletteList paletteList; QTIsaac rand; paletteList.Add("flam3-palettes.xml"); @@ -2111,12 +2111,12 @@ int _tmain(int argc, _TCHAR* argv[]) TestCasting(); t.Toc("TestCasting()"); t.Tic(); - VariationList vlf; + VariationList& vlf(VariationList::Instance()); t.Toc("Creating VariationList"); cout << "There are " << vlf.Size() << " variations present." << endl; #ifdef DO_DOUBLE t.Tic(); - VariationList vld; + VariationList& vld(VariationList::Instance()); t.Toc("Creating VariationList"); #endif t.Tic(); diff --git a/Source/Fractorium/FractoriumEmberController.cpp b/Source/Fractorium/FractoriumEmberController.cpp index 8d5bb6c..44f2ec6 100644 --- a/Source/Fractorium/FractoriumEmberController.cpp +++ b/Source/Fractorium/FractoriumEmberController.cpp @@ -48,7 +48,8 @@ FractoriumEmberControllerBase::~FractoriumEmberControllerBase() /// Pointer to the main window. template FractoriumEmberController::FractoriumEmberController(Fractorium* fractorium) - : FractoriumEmberControllerBase(fractorium) + : FractoriumEmberControllerBase(fractorium), + m_VariationList(VariationList::Instance()) { bool b = false; m_PreviewRun = false; diff --git a/Source/Fractorium/FractoriumEmberController.h b/Source/Fractorium/FractoriumEmberController.h index 760fed0..330218a 100644 --- a/Source/Fractorium/FractoriumEmberController.h +++ b/Source/Fractorium/FractoriumEmberController.h @@ -499,7 +499,7 @@ private: Xform m_CopiedFinalXform; Palette m_TempPalette; PaletteList m_PaletteList; - VariationList m_VariationList; + VariationList& m_VariationList; unique_ptr> m_SheepTools; unique_ptr> m_GLController; unique_ptr> m_PreviewRenderer; diff --git a/Source/Fractorium/FractoriumXforms.cpp b/Source/Fractorium/FractoriumXforms.cpp index bb57490..a144fee 100644 --- a/Source/Fractorium/FractoriumXforms.cpp +++ b/Source/Fractorium/FractoriumXforms.cpp @@ -282,7 +282,7 @@ void FractoriumEmberController::AddFinalXform() { Xform final; auto combo = m_Fractorium->ui.CurrentXformCombo; - final.AddVariation(new LinearVariation());//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); diff --git a/Source/Fractorium/VariationsDialog.cpp b/Source/Fractorium/VariationsDialog.cpp index af5bf42..dbc8b58 100644 --- a/Source/Fractorium/VariationsDialog.cpp +++ b/Source/Fractorium/VariationsDialog.cpp @@ -10,7 +10,8 @@ /// The window flags. Default: 0. FractoriumVariationsDialog::FractoriumVariationsDialog(FractoriumSettings* settings, QWidget* p, Qt::WindowFlags f) : QDialog(p, f), - m_Settings(settings) + m_Settings(settings), + m_VariationList(VariationList::Instance()) { ui.setupUi(this); auto table = ui.VariationsTable; diff --git a/Source/Fractorium/VariationsDialog.h b/Source/Fractorium/VariationsDialog.h index 9d58516..3297e79 100644 --- a/Source/Fractorium/VariationsDialog.h +++ b/Source/Fractorium/VariationsDialog.h @@ -41,7 +41,7 @@ private: void GuiToData(); void Populate(); void SetCheckFromMap(QTableWidgetItem* cb, const Variation* var); - VariationList m_VariationList; + VariationList& m_VariationList; QMap m_Vars; FractoriumSettings* m_Settings; Ui::VariationsDialog ui;