summaryrefslogtreecommitdiffstats
path: root/kpovmodeler/pmpattern.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kpovmodeler/pmpattern.cpp')
-rw-r--r--kpovmodeler/pmpattern.cpp1126
1 files changed, 1126 insertions, 0 deletions
diff --git a/kpovmodeler/pmpattern.cpp b/kpovmodeler/pmpattern.cpp
new file mode 100644
index 00000000..c9377f84
--- /dev/null
+++ b/kpovmodeler/pmpattern.cpp
@@ -0,0 +1,1126 @@
+/*
+**************************************************************************
+ description
+ --------------------
+ copyright : (C) 2001-2002 by Luis Carvalho
+ email : lpassos@mail.telepac.pt
+**************************************************************************
+
+**************************************************************************
+* *
+* This program is free software; you can redistribute it and/or modify *
+* it under the terms of the GNU General Public License as published by *
+* the Free Software Foundation; either version 2 of the License, or *
+* (at your option) any later version. *
+* *
+**************************************************************************/
+
+
+#include "pmpatternedit.h"
+#include "pmpattern.h"
+
+#include "pmxmlhelper.h"
+#include "pmlistpatternedit.h"
+#include "pmcompositeobject.h"
+#include "pmmemento.h"
+#include "pmenumproperty.h"
+
+#include <klocale.h>
+
+const PMPattern::PMPatternType patternTypeDefault = PMPattern::PatternAgate;
+const double agateTurbulenceDefault = 0.5;
+const PMVector crackleFormDefault = PMVector( -1.0, 1.0, 0.0 );
+const int crackleMetricDefault = 2;
+const double crackleOffsetDefault = 0.0;
+const bool crackleSolidDefault = false;
+const QString densityFileDefault = QString( "" );
+const int densityInterpolateDefault = 0;
+const PMVector gradientDefault = PMVector( 1.0, 1.0, 1.0 );
+const PMVector juliaComplexDefault = PMVector( 0.353, 0.288 );
+const bool fractalMagnetDefault = false;
+const int fractalMagnetTypeDefault = 1;
+const int maxIterationsDefault = 10;
+const int fractalExponentDefault = 2;
+const int fractalExtTypeDefault = 1;
+const double fractalExtFactorDefault = 1.0;
+const int fractalIntTypeDefault = 0;
+const double fractalIntFactorDefault = 1.0;
+const double quiltControl0Default = 1.0;
+const double quiltControl1Default = 1.0;
+const PMVector slopeDirectionDefault = PMVector( 0.0, -1.0, 0.0 );
+const double slopeLoSlopeDefault = 0.0;
+const double slopeHiSlopeDefault = 1.0;
+const bool slopeAltFlagDefault = false;
+const PMVector slopeAltitudeDefault = PMVector( 0.0, 1.0, 0.0 );
+const double slopeLoAltDefault = 0.0;
+const double slopeHiAltDefault = 1.0;
+const int spiralNumberArmsDefault = 0;
+const PMPattern::PMNoiseType noiseGeneratorDefault = PMPattern::GlobalSetting;
+const QString noiseGeneratorDefaultText = QString( "global_setting" );
+const bool turbulenceDefault = false;
+const PMVector valueVectorDefault = PMVector( 0.0, 0.0, 0.0 );
+const int octavesDefault = 6;
+const double omegaDefault = 0.5;
+const double lambdaDefault = 2.0;
+const double depthDefault = 0.0;
+
+PMDefinePropertyClass( PMPattern, PMPatternProperty );
+PMDefineEnumPropertyClass( PMPattern, PMPattern::PMPatternType,
+ PMPatternTypeProperty );
+PMDefineEnumPropertyClass( PMPattern, PMPattern::PMNoiseType,
+ PMNoiseProperty );
+
+PMMetaObject* PMPattern::s_pMetaObject = 0;
+PMObject* createNewPattern( PMPart* part )
+{
+ return new PMPattern( part );
+}
+
+PMPattern::PMPattern( PMPart* part )
+ : Base( part )
+{
+ m_patternType = patternTypeDefault;
+
+ m_agateTurbulence = agateTurbulenceDefault;
+
+ m_crackleForm = crackleFormDefault;
+ m_crackleMetric = crackleMetricDefault;
+ m_crackleOffset = crackleOffsetDefault;
+ m_crackleSolid = crackleSolidDefault;
+
+ m_densityFile = densityFileDefault;
+ m_densityInterpolate = densityInterpolateDefault;
+
+ m_gradient = gradientDefault;
+
+ m_juliaComplex = juliaComplexDefault;
+ m_fractalMagnet = fractalMagnetDefault;
+ m_fractalMagnetType = fractalMagnetTypeDefault;
+ m_maxIterations = maxIterationsDefault;
+ m_fractalExponent = fractalExponentDefault;
+ m_fractalExtType = fractalExtTypeDefault;
+ m_fractalExtFactor = fractalExtFactorDefault;
+ m_fractalIntType = fractalIntTypeDefault;
+ m_fractalIntFactor = fractalIntFactorDefault;
+
+ m_quiltControl0 = quiltControl0Default;
+ m_quiltControl1 = quiltControl1Default;
+
+ m_slopeDirection = slopeDirectionDefault;
+ m_slopeLoSlope = slopeLoSlopeDefault;
+ m_slopeHiSlope = slopeHiSlopeDefault;
+ m_slopeAltFlag = slopeAltFlagDefault;
+ m_slopeAltitude = slopeAltitudeDefault;
+ m_slopeLoAlt = slopeLoAltDefault;
+ m_slopeHiAlt = slopeHiAltDefault;
+
+ m_spiralNumberArms = spiralNumberArmsDefault;
+
+ m_noiseGenerator = noiseGeneratorDefault;
+
+ m_enableTurbulence = turbulenceDefault;
+ m_valueVector = valueVectorDefault;
+ m_octaves = octavesDefault;
+ m_omega = omegaDefault;
+ m_lambda = lambdaDefault;
+
+ m_depth = depthDefault;
+}
+
+PMPattern::PMPattern( const PMPattern& p )
+ : Base( p )
+{
+ m_patternType = p.m_patternType;
+
+ m_agateTurbulence = p.m_agateTurbulence;
+
+ m_crackleForm = p.m_crackleForm;
+ m_crackleMetric = p.m_crackleMetric;
+ m_crackleOffset = p.m_crackleOffset;
+ m_crackleSolid = p.m_crackleSolid;
+
+ m_densityFile = p.m_densityFile;
+ m_densityInterpolate = p.m_densityInterpolate;
+
+ m_gradient = p.m_gradient;
+
+ m_juliaComplex = p.m_juliaComplex;
+ m_fractalMagnet = p.m_fractalMagnet;
+ m_fractalMagnetType = p.m_fractalMagnetType;
+ m_maxIterations = p.m_maxIterations;
+ m_fractalExponent = p.m_fractalExponent;
+ m_fractalExtType = p.m_fractalExtType;
+ m_fractalExtFactor = p.m_fractalExtFactor;
+ m_fractalIntType = p.m_fractalIntType;
+ m_fractalIntFactor = p.m_fractalIntFactor;
+
+ m_quiltControl0 = p.m_quiltControl0;
+ m_quiltControl1 = p.m_quiltControl1;
+
+ m_slopeDirection = p.m_slopeDirection;
+ m_slopeLoSlope = p.m_slopeLoSlope;
+ m_slopeHiSlope = p.m_slopeHiSlope;
+ m_slopeAltFlag = p.m_slopeAltFlag;
+ m_slopeAltitude = p.m_slopeAltitude;
+ m_slopeLoAlt = p.m_slopeLoAlt;
+ m_slopeHiAlt = p.m_slopeHiAlt;
+
+ m_spiralNumberArms = p.m_spiralNumberArms;
+
+ m_noiseGenerator = p.m_noiseGenerator;
+
+ m_enableTurbulence = p.m_enableTurbulence;
+ m_valueVector = p.m_valueVector;
+ m_octaves = p.m_octaves;
+ m_omega = p.m_omega;
+ m_lambda = p.m_lambda;
+
+ m_depth = p.m_depth;
+}
+
+PMPattern::~PMPattern( )
+{
+}
+
+void PMPattern::serialize( QDomElement& e, QDomDocument& ) const
+{
+ switch( m_patternType )
+ {
+ case PatternAgate:
+ e.setAttribute( "patterntype", "agate" );
+ break;
+ case PatternAverage:
+ e.setAttribute( "patterntype", "average" );
+ break;
+ case PatternBoxed:
+ e.setAttribute( "patterntype", "boxed" );
+ break;
+ case PatternBozo:
+ e.setAttribute( "patterntype", "bozo" );
+ break;
+ case PatternBumps:
+ e.setAttribute( "patterntype", "bumps" );
+ break;
+ case PatternCells:
+ e.setAttribute( "patterntype", "cells" );
+ break;
+ case PatternCrackle:
+ e.setAttribute( "patterntype", "crackle" );
+ break;
+ case PatternCylindrical:
+ e.setAttribute( "patterntype", "cylindrical" );
+ break;
+ case PatternDensity:
+ e.setAttribute( "patterntype", "density" );
+ break;
+ case PatternDents:
+ e.setAttribute( "patterntype", "dents" );
+ break;
+ case PatternGradient:
+ e.setAttribute( "patterntype", "gradient" );
+ break;
+ case PatternGranite:
+ e.setAttribute( "patterntype", "granite" );
+ break;
+ case PatternJulia:
+ e.setAttribute( "patterntype", "julia" );
+ break;
+ case PatternLeopard:
+ e.setAttribute( "patterntype", "leopard" );
+ break;
+ case PatternMandel:
+ e.setAttribute( "patterntype", "mandel" );
+ break;
+ case PatternMarble:
+ e.setAttribute( "patterntype", "marble" );
+ break;
+ case PatternOnion:
+ e.setAttribute( "patterntype", "onion" );
+ break;
+ case PatternPlanar:
+ e.setAttribute( "patterntype", "planar" );
+ break;
+ case PatternQuilted:
+ e.setAttribute( "patterntype", "quilted" );
+ break;
+ case PatternRadial:
+ e.setAttribute( "patterntype", "radial" );
+ break;
+ case PatternRipples:
+ e.setAttribute( "patterntype", "ripples" );
+ break;
+ case PatternSlope:
+ e.setAttribute( "patterntype", "slope" );
+ break;
+ case PatternSpherical:
+ e.setAttribute( "patterntype", "spherical" );
+ break;
+ case PatternSpiral1:
+ e.setAttribute( "patterntype", "spiral1" );
+ break;
+ case PatternSpiral2:
+ e.setAttribute( "patterntype", "spiral2" );
+ break;
+ case PatternSpotted:
+ e.setAttribute( "patterntype", "spotted" );
+ break;
+ case PatternWaves:
+ e.setAttribute( "patterntype", "waves" );
+ break;
+ case PatternWood:
+ e.setAttribute( "patterntype", "wood" );
+ break;
+ case PatternWrinkles:
+ e.setAttribute( "patterntype", "wrinkles" );
+ break;
+ }
+
+ e.setAttribute( "agateturbulence", m_agateTurbulence );
+
+ e.setAttribute( "crackleform", m_crackleForm.serializeXML( ) );
+ e.setAttribute( "cracklemetric", m_crackleMetric );
+ e.setAttribute( "crackleoffset", m_crackleOffset );
+ e.setAttribute( "cracklesolid", m_crackleSolid );
+
+ e.setAttribute( "densityinterpolate", m_densityInterpolate );
+ e.setAttribute( "densityfile", m_densityFile );
+
+ e.setAttribute( "gradient", m_gradient.serializeXML( ) );
+
+ e.setAttribute( "juliacomplex", m_juliaComplex.serializeXML( ) );
+ e.setAttribute( "fractalmagnet", m_fractalMagnet );
+ e.setAttribute( "fractalmagnettype", m_fractalMagnetType );
+ e.setAttribute( "maxiterations", m_maxIterations );
+ e.setAttribute( "fractalexponent", m_fractalExponent );
+ e.setAttribute( "fractalexttype", m_fractalExtType );
+ e.setAttribute( "fractalextfactor", m_fractalExtFactor );
+ e.setAttribute( "fractalinttype", m_fractalIntType );
+ e.setAttribute( "fractalintfactor", m_fractalIntFactor );
+
+ e.setAttribute( "quiltcontrol0", m_quiltControl0 );
+ e.setAttribute( "quiltcontrol1", m_quiltControl1 );
+
+ e.setAttribute( "slopedirection", m_slopeDirection.serializeXML( ) );
+ e.setAttribute( "slopeloslope", m_slopeLoSlope );
+ e.setAttribute( "slopehislope", m_slopeHiSlope );
+ e.setAttribute( "slopealtflag", m_slopeAltFlag );
+ e.setAttribute( "slopealtitude", m_slopeAltitude.serializeXML( ) );
+ e.setAttribute( "slopeloalt", m_slopeLoAlt );
+ e.setAttribute( "slopehialt", m_slopeHiAlt );
+
+ e.setAttribute( "spiralnumberarms", m_spiralNumberArms );
+ switch ( m_noiseGenerator )
+ {
+ case GlobalSetting:
+ e.setAttribute( "noise_generator", "global_setting" );
+ break;
+ case Original:
+ e.setAttribute( "noise_generator", "original" );
+ break;
+ case RangeCorrected:
+ e.setAttribute( "noise_generator", "range_corrected" );
+ break;
+ case Perlin:
+ e.setAttribute( "noise_generator", "perlin" );
+ break;
+ }
+
+ e.setAttribute( "enable_turbulence", m_enableTurbulence );
+ e.setAttribute( "turbulence", m_valueVector.serializeXML( ) );
+ e.setAttribute( "octaves", m_octaves );
+ e.setAttribute( "omega", m_omega );
+ e.setAttribute( "lambda", m_lambda );
+
+ e.setAttribute( "depth", m_depth );
+}
+
+void PMPattern::readAttributes( const PMXMLHelper& h )
+{
+ QString str = h.stringAttribute( "patterntype", "agate" );
+
+ if( str == "agate" )
+ m_patternType = PatternAgate;
+ else if( str == "average" )
+ m_patternType = PatternAverage;
+ else if( str == "boxed" )
+ m_patternType = PatternBoxed;
+ else if( str == "bozo" )
+ m_patternType = PatternBozo;
+ else if( str == "bumps" )
+ m_patternType = PatternBumps;
+ else if( str == "cells" )
+ m_patternType = PatternCells;
+ else if( str == "crackle" )
+ m_patternType = PatternCrackle;
+ else if( str == "cylindrical" )
+ m_patternType = PatternCylindrical;
+ else if( str == "density" )
+ m_patternType = PatternDensity;
+ else if( str == "dents" )
+ m_patternType = PatternDents;
+ else if( str == "gradient" )
+ m_patternType = PatternGradient;
+ else if( str == "granite" )
+ m_patternType = PatternGranite;
+ else if( str == "julia" )
+ m_patternType = PatternJulia;
+ else if( str == "leopard" )
+ m_patternType = PatternLeopard;
+ else if( str == "mandel" )
+ m_patternType = PatternMandel;
+ else if( str == "marble" )
+ m_patternType = PatternMarble;
+ else if( str == "onion" )
+ m_patternType = PatternOnion;
+ else if( str == "planar" )
+ m_patternType = PatternPlanar;
+ else if( str == "quilted" )
+ m_patternType = PatternQuilted;
+ else if( str == "radial" )
+ m_patternType = PatternRadial;
+ else if( str == "ripples" )
+ m_patternType = PatternRipples;
+ else if( str == "slope" )
+ m_patternType = PatternSlope;
+ else if( str == "spherical" )
+ m_patternType = PatternSpherical;
+ else if( str == "spiral1" )
+ m_patternType = PatternSpiral1;
+ else if( str == "spiral2" )
+ m_patternType = PatternSpiral2;
+ else if( str == "spotted" )
+ m_patternType = PatternSpotted;
+ else if( str == "waves" )
+ m_patternType = PatternWaves;
+ else if( str == "wood" )
+ m_patternType = PatternWood;
+ else if( str == "wrinkles" )
+ m_patternType = PatternWrinkles;
+
+ m_agateTurbulence = h.doubleAttribute( "agateturbulence", agateTurbulenceDefault );
+
+ m_crackleForm = h.vectorAttribute( "crackleform", crackleFormDefault );
+ m_crackleMetric = h.intAttribute( "cracklemetric", crackleMetricDefault );
+ m_crackleOffset = h.doubleAttribute( "crackleoffset", crackleOffsetDefault );
+ m_crackleSolid = h.boolAttribute( "cracklesolid", crackleSolidDefault );
+
+ m_densityInterpolate = h.intAttribute( "densityinterpolate", densityInterpolateDefault );
+ m_densityFile = h.stringAttribute( "densityfile", densityFileDefault );
+
+ m_gradient = h.vectorAttribute( "gradient", gradientDefault );
+
+ m_juliaComplex = h.vectorAttribute( "juliacomplex", juliaComplexDefault );
+ m_fractalMagnet = h.boolAttribute( "fractalmagnet", fractalMagnetDefault );
+ m_fractalMagnetType = h.intAttribute( "fractalmagnettype", fractalMagnetTypeDefault );
+ m_maxIterations = h.intAttribute( "maxiterations", maxIterationsDefault );
+ m_fractalExponent = h.intAttribute( "fractalexponent", fractalExponentDefault );
+ m_fractalExtType = h.intAttribute( "fractalexttype", fractalExtTypeDefault );
+ m_fractalExtFactor = h.doubleAttribute( "fractalextfactor", fractalExtFactorDefault );
+ m_fractalIntType = h.intAttribute( "fractalinttype", fractalIntTypeDefault );
+ m_fractalIntFactor = h.doubleAttribute( "fractalintfactor", fractalIntFactorDefault );
+
+ m_quiltControl0 = h.doubleAttribute( "quiltcontrol0", quiltControl0Default );
+ m_quiltControl1 = h.doubleAttribute( "quiltcontrol1", quiltControl1Default );
+
+ m_slopeDirection = h.vectorAttribute( "slopedirection", slopeDirectionDefault );
+ m_slopeLoSlope = h.doubleAttribute( "slopeloslope", slopeLoSlopeDefault );
+ m_slopeHiSlope = h.doubleAttribute( "slopehislope", slopeHiSlopeDefault );
+ m_slopeAltFlag = h.boolAttribute( "slopealtflag", slopeAltFlagDefault );
+ m_slopeAltitude = h.vectorAttribute( "slopealtitude", slopeAltitudeDefault );
+ m_slopeLoAlt = h.doubleAttribute( "slopeloalt", slopeLoAltDefault );
+ m_slopeHiAlt = h.doubleAttribute( "slopehialt", slopeHiAltDefault );
+
+ m_spiralNumberArms = h.intAttribute( "spiralnumberarms", spiralNumberArmsDefault );
+
+ str = h.stringAttribute( "noise_generator", noiseGeneratorDefaultText );
+ if ( str == "original" )
+ m_noiseGenerator = Original;
+ else if ( str == "range_corrected" )
+ m_noiseGenerator = RangeCorrected;
+ else if ( str == "perlin" )
+ m_noiseGenerator = Perlin;
+ else
+ m_noiseGenerator = GlobalSetting;
+
+ m_enableTurbulence = h.boolAttribute( "enable_turbulence" , false );
+ m_valueVector = h.vectorAttribute( "turbulence", valueVectorDefault );
+ m_octaves = h.intAttribute( "octaves", octavesDefault );
+ m_omega = h.doubleAttribute( "omega", omegaDefault );
+ m_lambda = h.doubleAttribute( "lambda", lambdaDefault );
+
+ m_depth = h.doubleAttribute( "depth", depthDefault );
+
+ Base::readAttributes( h );
+}
+
+PMMetaObject* PMPattern::metaObject( ) const
+{
+ if( !s_pMetaObject )
+ {
+ s_pMetaObject = new PMMetaObject( "Pattern", Base::metaObject( ),
+ createNewPattern );
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "agateTurbulence", &PMPattern::setAgateTurbulence, &PMPattern::agateTurbulence ) );
+
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "densityFile", &PMPattern::setDensityFile, &PMPattern::densityFile ) );
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "densityInterpolate", &PMPattern::setDensityInterpolate, &PMPattern::densityInterpolate ) );
+
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "gradient", &PMPattern::setGradient, &PMPattern::gradient ) );
+
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "maxIterations", &PMPattern::setMaxIterations, &PMPattern::maxIterations ) );
+
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "quiltControl0", &PMPattern::setQuiltControl0, &PMPattern::quiltControl0 ) );
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "quiltControl1", &PMPattern::setQuiltControl1, &PMPattern::quiltControl1 ) );
+
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "spiralNumberArms", &PMPattern::setSpiralNumberArms, &PMPattern::spiralNumberArms ) );
+
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "turbulence", &PMPattern::enableTurbulence, &PMPattern::isTurbulenceEnabled ) );
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "valueVector", &PMPattern::setValueVector, &PMPattern::valueVector ) );
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "octaves", &PMPattern::setOctaves, &PMPattern::octaves ) );
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "omega", &PMPattern::setOmega, &PMPattern::omega ) );
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "lambda", &PMPattern::setLambda, &PMPattern::lambda ) );
+
+ s_pMetaObject->addProperty(
+ new PMPatternProperty( "depth", &PMPattern::setDepth, &PMPattern::depth ) );
+
+ PMPatternTypeProperty* p = new PMPatternTypeProperty(
+ "patternType", &PMPattern::setPatternType, &PMPattern::patternType );
+ p->addEnumValue( "Agate", PatternAgate );
+ p->addEnumValue( "Average", PatternAverage );
+ p->addEnumValue( "Boxed", PatternBoxed );
+ p->addEnumValue( "Bozo", PatternBozo );
+ p->addEnumValue( "Bumps", PatternBumps );
+ p->addEnumValue( "Cells", PatternCells );
+ p->addEnumValue( "Crackle", PatternCrackle );
+ p->addEnumValue( "Cylindrical", PatternCylindrical );
+ p->addEnumValue( "Density", PatternDensity );
+ p->addEnumValue( "Dents", PatternDents );
+ p->addEnumValue( "Gradient", PatternGradient );
+ p->addEnumValue( "Granite", PatternGranite );
+ p->addEnumValue( "Julia", PatternJulia );
+ p->addEnumValue( "Leopard", PatternLeopard );
+ p->addEnumValue( "Mandel", PatternMandel );
+ p->addEnumValue( "Marble", PatternMarble );
+ p->addEnumValue( "Onion", PatternOnion );
+ p->addEnumValue( "Planar", PatternPlanar );
+ p->addEnumValue( "Quilted", PatternQuilted );
+ p->addEnumValue( "Radial", PatternRadial );
+ p->addEnumValue( "Ripples", PatternRipples );
+ p->addEnumValue( "Slope", PatternSlope );
+ p->addEnumValue( "Spherical", PatternSpherical );
+ p->addEnumValue( "Spiral1", PatternSpiral1 );
+ p->addEnumValue( "Spiral2", PatternSpiral2 );
+ p->addEnumValue( "Spotted", PatternSpotted );
+ p->addEnumValue( "Waves", PatternWaves );
+ p->addEnumValue( "Wood", PatternWood );
+ p->addEnumValue( "Wrinkles", PatternWrinkles );
+ s_pMetaObject->addProperty( p );
+
+ PMNoiseProperty* p2 = new PMNoiseProperty(
+ "noiseGenerator", &PMPattern::setNoiseGenerator, &PMPattern::noiseGenerator );
+ p2->addEnumValue( "GlobalSetting", GlobalSetting );
+ p2->addEnumValue( "Original", Original );
+ p2->addEnumValue( "RangeCorrected", RangeCorrected );
+ p2->addEnumValue( "Perlin", Perlin );
+ s_pMetaObject->addProperty( p2 );
+ }
+ return s_pMetaObject;
+}
+
+void PMPattern::cleanUp( ) const
+{
+ if( s_pMetaObject )
+ {
+ delete s_pMetaObject;
+ s_pMetaObject = 0;
+ }
+ Base::cleanUp( );
+}
+
+QString PMPattern::description( ) const
+{
+ return i18n( "pattern" );
+}
+
+void PMPattern::setPatternType( PMPatternType c )
+{
+ if( c != m_patternType )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMPatternTypeID, m_patternType );
+ m_patternType = c;
+ }
+}
+
+void PMPattern::setAgateTurbulence( double c )
+{
+ if( c != m_agateTurbulence )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMAgateTurbulenceID, m_agateTurbulence );
+ m_agateTurbulence = c;
+ }
+}
+
+void PMPattern::setCrackleForm( const PMVector& v )
+{
+ if ( v != m_crackleForm )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMCrackleFormID, m_crackleForm );
+ m_crackleForm = v;
+ }
+}
+
+void PMPattern::setCrackleMetric( int c )
+{
+ if ( c < 1 )
+ {
+ kdError( PMArea ) << "new metric is < 1 in PMPattern::setCrackleMetric\n";
+ c = 1;
+ }
+
+ if ( c != m_crackleMetric )
+ {
+ if ( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMCrackleMetricID, m_crackleMetric );
+ m_crackleMetric = c;
+ }
+}
+
+void PMPattern::setCrackleOffset( double c )
+{
+ if ( c != m_crackleOffset )
+ {
+ if ( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMCrackleOffsetID, m_crackleOffset );
+ m_crackleOffset = c;
+ }
+}
+
+void PMPattern::setCrackleSolid( bool c )
+{
+ if ( c != m_crackleSolid )
+ {
+ if ( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMCrackleSolidID, m_crackleSolid );
+ m_crackleSolid = c;
+ }
+}
+
+void PMPattern::setDensityInterpolate( int c )
+{
+ if( c != m_densityInterpolate )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMDensityInterpolateID, m_densityInterpolate );
+ m_densityInterpolate = c;
+ }
+}
+
+void PMPattern::setDensityFile( const QString& s )
+{
+ if( s != m_densityFile )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMDensityFileID, m_densityFile );
+ m_densityFile = s;
+ }
+}
+
+void PMPattern::setGradient( const PMVector& v )
+{
+ if( v != m_gradient )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMGradientID, m_gradient );
+ m_gradient = v;
+ }
+}
+
+void PMPattern::setJuliaComplex( const PMVector& v )
+{
+ if ( v != m_juliaComplex )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMJuliaComplexID, m_juliaComplex );
+ m_juliaComplex = v;
+ }
+}
+
+void PMPattern::setFractalMagnet( bool c )
+{
+ if ( c != m_fractalMagnet )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMFractalMagnetID, m_fractalMagnet );
+ m_fractalMagnet = c;
+ }
+}
+
+void PMPattern::setFractalMagnetType( int c )
+{
+ if ( c < 1 )
+ {
+ kdError( PMArea ) << "Magnet type < 1 in PMPattern::setFractalMagnetType\n";
+ c = 1;
+ }
+
+ if ( c > 2 )
+ {
+ kdError( PMArea ) << "Magnet type > 2 in PMPattern::setFractalMagnetType\n";
+ c = 2;
+ }
+
+ if ( c != m_fractalMagnetType )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMFractalMagnetTypeID, m_fractalMagnetType );
+ m_fractalMagnetType = c;
+ }
+}
+
+void PMPattern::setMaxIterations( int c )
+{
+ if( c != m_maxIterations )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMMaxIterationsID, m_maxIterations );
+ m_maxIterations = c;
+ }
+}
+
+void PMPattern::setFractalExponent( int c )
+{
+ if ( c < 2 )
+ {
+ kdError( PMArea ) << "Exponent < 2 in PMPattern::setFractalExponent\n";
+ c = 2;
+ }
+
+ if ( c > 33 )
+ {
+ kdError( PMArea ) << "Exponent > 33 in PMPattern::setFractalExponent\n";
+ c = 33;
+ }
+
+ if ( c != m_fractalExponent )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMFractalExponentID, m_fractalExponent );
+ m_fractalExponent = c;
+ }
+}
+
+void PMPattern::setFractalExtType( int c )
+{
+ if ( c < 0 )
+ {
+ kdError( PMArea ) << "Exterior Type < 0 in PMPattern::setFractalExtType\n";
+ c = 0;
+ }
+
+ if ( c > 6 )
+ {
+ kdError( PMArea ) << "Exterior Type > 6 in PMPattern::setFractalExtType\n";
+ c = 6;
+ }
+
+ if ( c != m_fractalExtType )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMFractalExtTypeID, m_fractalExtType );
+ m_fractalExtType = c;
+ }
+}
+
+void PMPattern::setFractalExtFactor( double c )
+{
+ if ( c != m_fractalExtFactor )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMFractalExtFactorID, m_fractalExtFactor );
+ m_fractalExtFactor = c;
+ }
+}
+
+void PMPattern::setFractalIntType( int c )
+{
+ if ( c < 0 )
+ {
+ kdError( PMArea ) << "Interior Type < 0 in PMPattern::setFractalIntType\n";
+ c = 0;
+ }
+
+ if ( c > 6 )
+ {
+ kdError( PMArea ) << "Interior Type > 6 in PMPattern::setFractalIntType\n";
+ c = 6;
+ }
+
+ if ( c != m_fractalIntType )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMFractalIntTypeID, m_fractalIntType );
+ m_fractalIntType = c;
+ }
+}
+
+void PMPattern::setFractalIntFactor( double c )
+{
+ if ( c != m_fractalIntFactor )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMFractalIntFactorID, m_fractalIntFactor );
+ m_fractalIntFactor = c;
+ }
+}
+
+void PMPattern::setQuiltControl0( double c )
+{
+ if( c != m_quiltControl0 )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMQuiltControl0ID, m_quiltControl0 );
+ m_quiltControl0 = c;
+ }
+}
+
+void PMPattern::setQuiltControl1( double c )
+{
+ if( c != m_quiltControl1 )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMQuiltControl1ID, m_quiltControl1 );
+ m_quiltControl1 = c;
+ }
+}
+
+void PMPattern::setSlopeDirection( const PMVector& v )
+{
+ if ( v != m_slopeDirection )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMSlopeDirectionID, m_slopeDirection );
+ m_slopeDirection = v;
+ }
+}
+
+void PMPattern::setSlopeLoSlope( double c )
+{
+ if ( c < 0.0 )
+ {
+ kdError( PMArea ) << "Low slope < 0.0 in PMPattern::setSlopeLoSlope\n";
+ c = 0.0;
+ }
+
+ if ( c > 1.0 )
+ {
+ kdError( PMArea ) << "Low slope > 1.0 in PMPattern::setSlopeLoSlope\n";
+ c = 1.0;
+ }
+
+ if ( c != m_slopeLoSlope )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMSlopeLoSlopeID, m_slopeLoSlope );
+ m_slopeLoSlope = c;
+ }
+}
+
+void PMPattern::setSlopeHiSlope( double c )
+{
+ if ( c < 0.0 )
+ {
+ kdError( PMArea ) << "High slope < 0.0 in PMPattern::setSlopeHiSlope\n";
+ c = 0.0;
+ }
+
+ if ( c > 1.0 )
+ {
+ kdError( PMArea ) << "High slope > 1.0 in PMPattern::setSlopeHiSlope\n";
+ c = 1.0;
+ }
+
+ if ( c != m_slopeHiSlope )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMSlopeHiSlopeID, m_slopeHiSlope );
+ m_slopeHiSlope = c;
+ }
+}
+
+void PMPattern::setSlopeAltFlag( bool c )
+{
+ if ( c != m_slopeAltFlag )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMSlopeAltFlagID, m_slopeAltFlag );
+ m_slopeAltFlag = c;
+ }
+}
+
+void PMPattern::setSlopeAltitude( const PMVector& v )
+{
+ if ( v != m_slopeAltitude )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMSlopeAltitudeID, m_slopeAltitude );
+ m_slopeAltitude = v;
+ }
+}
+
+void PMPattern::setSlopeLoAlt( double c )
+{
+ if ( c != m_slopeLoAlt )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMSlopeLoAltID, m_slopeLoAlt );
+ m_slopeLoAlt = c;
+ }
+}
+
+void PMPattern::setSlopeHiAlt( double c )
+{
+ if ( c != m_slopeHiAlt )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMSlopeHiAltID, m_slopeHiAlt );
+ m_slopeHiAlt = c;
+ }
+}
+
+void PMPattern::setSpiralNumberArms( int c )
+{
+ if( c != m_spiralNumberArms )
+ {
+ if(m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMSpiralNumberArmsID, m_spiralNumberArms );
+ m_spiralNumberArms = c;
+ }
+}
+
+void PMPattern::setNoiseGenerator( PMNoiseType c )
+{
+ if( c != m_noiseGenerator )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMNoiseGeneratorID, m_noiseGenerator );
+ m_noiseGenerator = c;
+ }
+}
+
+void PMPattern::enableTurbulence( bool c )
+{
+ if( c != m_enableTurbulence )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMEnableTurbulenceID, m_enableTurbulence );
+ m_enableTurbulence = c;
+ }
+}
+
+void PMPattern::setValueVector( const PMVector& c )
+{
+ if( c != m_valueVector )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMValueVectorID, m_valueVector );
+ m_valueVector = c;
+ }
+}
+
+void PMPattern::setOctaves( const int c )
+{
+ if( c != m_octaves )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMOctavesID, m_octaves );
+ m_octaves = c;
+ }
+}
+
+void PMPattern::setOmega( const double c )
+{
+ if( c != m_omega )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMOmegaID, m_omega );
+ m_omega = c;
+ }
+}
+
+void PMPattern::setLambda( const double c )
+{
+ if( c != m_lambda )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMLambdaID, m_lambda );
+ m_lambda = c;
+ }
+}
+
+void PMPattern::setDepth( const double c )
+{
+ if( c != m_depth )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMDepthID, m_depth );
+ m_depth = c;
+ }
+}
+
+PMDialogEditBase* PMPattern::editWidget( QWidget* parent ) const
+{
+ return new PMPatternEdit( parent );
+}
+
+void PMPattern::restoreMemento( PMMemento* s )
+{
+ PMMementoDataIterator it( s );
+ PMMementoData* data;
+
+ for( ; it.current( ); ++it )
+ {
+ data = it.current( );
+ if( data->objectType( ) == s_pMetaObject )
+ {
+ switch( data->valueID( ) )
+ {
+ case PMPatternTypeID:
+ setPatternType( ( PMPatternType )data->intData( ) );
+ break;
+
+ case PMAgateTurbulenceID:
+ setAgateTurbulence( data->doubleData( ) );
+ break;
+
+ case PMCrackleFormID:
+ setCrackleForm( data->vectorData( ) );
+ break;
+ case PMCrackleMetricID:
+ setCrackleMetric( data->intData( ) );
+ break;
+ case PMCrackleOffsetID:
+ setCrackleOffset( data->doubleData( ) );
+ break;
+ case PMCrackleSolidID:
+ setCrackleSolid( data->boolData( ) );
+ break;
+
+ case PMDensityInterpolateID:
+ setDensityInterpolate( data->intData( ) );
+ break;
+ case PMDensityFileID:
+ setDensityFile( data->stringData( ) );
+ break;
+
+ case PMGradientID:
+ setGradient( data->vectorData( ) );
+ break;
+
+ case PMJuliaComplexID:
+ setJuliaComplex( data->vectorData( ) );
+ break;
+ case PMFractalMagnetID:
+ setFractalMagnet( data->boolData( ) );
+ break;
+ case PMFractalMagnetTypeID:
+ setFractalMagnetType( data->intData( ) );
+ break;
+ case PMMaxIterationsID:
+ setMaxIterations( data->intData( ) );
+ break;
+ case PMFractalExponentID:
+ setFractalExponent( data->intData( ) );
+ break;
+ case PMFractalExtTypeID:
+ setFractalExtType( data->intData( ) );
+ break;
+ case PMFractalExtFactorID:
+ setFractalExtFactor( data->doubleData( ) );
+ break;
+ case PMFractalIntTypeID:
+ setFractalIntType( data->intData( ) );
+ break;
+ case PMFractalIntFactorID:
+ setFractalIntFactor( data->doubleData( ) );
+ break;
+
+ case PMQuiltControl0ID:
+ setQuiltControl0( data->doubleData( ) );
+ break;
+ case PMQuiltControl1ID:
+ setQuiltControl1( data->doubleData( ) );
+ break;
+
+ case PMSlopeDirectionID:
+ setSlopeDirection( data->vectorData( ) );
+ break;
+ case PMSlopeLoSlopeID:
+ setSlopeLoSlope( data->doubleData( ) );
+ break;
+ case PMSlopeHiSlopeID:
+ setSlopeHiSlope( data->doubleData( ) );
+ break;
+ case PMSlopeAltFlagID:
+ setSlopeAltFlag( data->boolData( ) );
+ break;
+ case PMSlopeAltitudeID:
+ setSlopeAltitude( data->boolData( ) );
+ break;
+ case PMSlopeLoAltID:
+ setSlopeLoAlt( data->intData( ) );
+ break;
+ case PMSlopeHiAltID:
+ setSlopeHiAlt( data->intData( ) );
+ break;
+
+ case PMSpiralNumberArmsID:
+ setSpiralNumberArms( data->intData( ) );
+ break;
+
+ case PMNoiseGeneratorID:
+ setNoiseGenerator( ( PMNoiseType ) ( data->intData( ) ) );
+ break;
+
+ case PMEnableTurbulenceID:
+ enableTurbulence( data->boolData( ) );
+ break;
+ case PMValueVectorID:
+ setValueVector( data->vectorData( ) );
+ break;
+ case PMOctavesID:
+ setOctaves( data->intData( ) );
+ break;
+ case PMOmegaID:
+ setOmega( data->doubleData( ) );
+ break;
+ case PMLambdaID:
+ setLambda( data->doubleData( ) );
+ break;
+
+ case PMDepthID:
+ setDepth( data->doubleData( ) );
+ break;
+ default:
+ kdError( PMArea ) << "Wrong ID in PMPattern::restoreMemento\n";
+ break;
+ }
+ }
+ }
+ Base::restoreMemento( s );
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-18 05:13:21 +0000