You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdegraphics/kpovmodeler/pmpattern.cpp

1127 lines
34 KiB

/*
**************************************************************************
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 TQString densityFileDefault = TQString( "" );
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 TQString noiseGeneratorDefaultText = TQString( "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( TQDomElement& e, TQDomDocument& ) 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 )
{
TQString 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( );
}
TQString 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 TQString& 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( TQWidget* 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 );
}