summaryrefslogtreecommitdiffstats
path: root/kpovmodeler/pmwarp.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kpovmodeler/pmwarp.cpp')
-rw-r--r--kpovmodeler/pmwarp.cpp548
1 files changed, 548 insertions, 0 deletions
diff --git a/kpovmodeler/pmwarp.cpp b/kpovmodeler/pmwarp.cpp
new file mode 100644
index 00000000..76d58cf3
--- /dev/null
+++ b/kpovmodeler/pmwarp.cpp
@@ -0,0 +1,548 @@
+/*
+**************************************************************************
+ description
+ --------------------
+ copyright : (C) 2000-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 "pmxmlhelper.h"
+#include "pmvector.h"
+#include "pmwarp.h"
+#include "pmwarpedit.h"
+#include "pmmemento.h"
+#include "pmenumproperty.h"
+
+#include <klocale.h>
+
+const PMVector directionDefault = PMVector( 1.0, 0.0, 0.0 );
+const PMVector offsetDefault = PMVector( 0.0, 0.0, 0.0 );
+const PMVector flipDefault = PMVector( 0.0, 0.0, 0.0 );
+const PMVector locationDefault = PMVector( 0.0, 0.0, 0.0 );
+const double radiusDefault = 0;
+const double strengthDefault = 0;
+const double falloffDefault = 0;
+const bool inverseDefault = false;
+const PMVector repeatDefault = PMVector( 0.0, 0.0, 0.0 );
+const PMVector turbulenceDefault = PMVector( 0.0, 0.0, 0.0 );
+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 PMVector orientationDefault = PMVector( 0.0, 0.0, 1.0 );
+const double distExpDefault = 0.0;
+const double majorRadiusDefault = 1.0;
+
+PMDefinePropertyClass( PMWarp, PMWarpProperty );
+PMDefineEnumPropertyClass( PMWarp, PMWarp::PMWarpType, PMWarpTypeProperty );
+
+PMMetaObject* PMWarp::s_pMetaObject = 0;
+PMObject* createNewWarp( PMPart* part )
+{
+ return new PMWarp( part );
+}
+
+PMWarp::PMWarp( PMPart* part )
+ : Base( part )
+{
+ m_warpType = PMWarp::Repeat;
+ m_direction = directionDefault;
+ m_offset = offsetDefault;
+ m_flip = flipDefault;
+ m_location = locationDefault;
+ m_radius = radiusDefault;
+ m_strength = strengthDefault;
+ m_falloff = falloffDefault;
+ m_inverse = inverseDefault;
+ m_repeat = repeatDefault;
+ m_turbulence = turbulenceDefault;
+ m_valueVector = valueVectorDefault;
+ m_octaves = octavesDefault;
+ m_omega = omegaDefault;
+ m_lambda = lambdaDefault;
+ m_orientation = orientationDefault;
+ m_distExp = distExpDefault;
+ m_majorRadius = majorRadiusDefault;
+}
+
+PMWarp::PMWarp( const PMWarp& w )
+ : Base( w )
+{
+ m_warpType = w.m_warpType;
+ m_direction = w.m_direction;
+ m_offset = w.m_offset;
+ m_flip = w.m_flip;
+ m_location = w.m_location;
+ m_radius = w.m_radius;
+ m_strength = w.m_strength;
+ m_falloff = w.m_falloff;
+ m_inverse = w.m_inverse;
+ m_repeat = w.m_repeat;
+ m_turbulence = w.m_turbulence;
+ m_valueVector = w.m_valueVector;
+ m_octaves = w.m_octaves;
+ m_omega = w.m_omega;
+ m_lambda = w.m_lambda;
+ m_orientation = w.m_orientation;
+ m_distExp = w.m_distExp;
+ m_majorRadius = w.m_majorRadius;
+}
+
+PMWarp::~PMWarp( )
+{
+}
+
+QString PMWarp::description( ) const
+{
+ return i18n( "warp" );
+}
+
+void PMWarp::serialize( QDomElement& e, QDomDocument& /*doc*/ ) const
+{
+ bool mapping = false;
+
+ switch( m_warpType )
+ {
+ case PMWarp::Repeat:
+ e.setAttribute( "warp_type", "repeat");
+ e.setAttribute( "direction", m_direction.serializeXML( ) );
+ e.setAttribute( "offset", m_offset.serializeXML( ) );
+ e.setAttribute( "flip", m_flip.serializeXML( ) );
+ break;
+ case PMWarp::BlackHole:
+ e.setAttribute( "warp_type", "black hole");
+ e.setAttribute( "location", m_location.serializeXML( ) );
+ e.setAttribute( "radius", m_radius );
+ e.setAttribute( "strength", m_strength );
+ e.setAttribute( "falloff", m_falloff );
+ e.setAttribute( "inverse", m_inverse );
+ e.setAttribute( "repeat", m_repeat.serializeXML( ) );
+ e.setAttribute( "turbulence", m_turbulence.serializeXML( ) );
+ break;
+ case PMWarp::Turbulence:
+ e.setAttribute( "warp_type", "turbulence");
+ e.setAttribute( "turbulence", m_valueVector.serializeXML( ) );
+ e.setAttribute( "octaves", m_octaves );
+ e.setAttribute( "omega", m_omega );
+ e.setAttribute( "lambda", m_lambda );
+ break;
+ case PMWarp::Cylindrical:
+ mapping = true;
+ e.setAttribute( "warp_type", "cylindrical" );
+ break;
+ case PMWarp::Spherical:
+ mapping = true;
+ e.setAttribute( "warp_type", "spherical" );
+ break;
+ case PMWarp::Toroidal:
+ mapping = true;
+ e.setAttribute( "warp_type", "toroidal" );
+ e.setAttribute( "major_radius", m_majorRadius );
+ break;
+ case PMWarp::Planar:
+ mapping = true;
+ e.setAttribute( "warp_type", "planar" );
+ break;
+ }
+
+ if ( mapping )
+ {
+ e.setAttribute( "orientation", m_orientation.serializeXML( ) );
+ e.setAttribute( "dist_exp", m_distExp );
+ }
+}
+
+void PMWarp::readAttributes( const PMXMLHelper& h )
+{
+ bool mapping = false;
+ QString str = h.stringAttribute( "warp_type", "repeat" );
+
+ if( str == "repeat" )
+ {
+ m_warpType = PMWarp::Repeat;
+ m_direction = h.vectorAttribute( "direction", directionDefault );
+ m_offset = h.vectorAttribute( "offset", offsetDefault );
+ m_flip = h.vectorAttribute( "flip", flipDefault );
+ }
+ else if( str == "black hole" )
+ {
+ m_warpType = PMWarp::BlackHole;
+ m_location = h.vectorAttribute( "location", locationDefault );
+ m_radius = h.doubleAttribute( "radius", radiusDefault );
+ m_strength = h.doubleAttribute( "strength", strengthDefault );
+ m_falloff = h.doubleAttribute( "falloff", falloffDefault );
+ m_inverse = h.boolAttribute( "inverse", inverseDefault );
+ m_repeat = h.vectorAttribute( "repeat", repeatDefault );
+ m_turbulence = h.vectorAttribute( "turbulence", turbulenceDefault );
+ }
+ else if( str == "turbulence" )
+ {
+ m_warpType = PMWarp::Turbulence;
+ m_valueVector = h.vectorAttribute( "turbulence", valueVectorDefault );
+ m_octaves = h.intAttribute( "octaves", octavesDefault );
+ m_omega = h.doubleAttribute( "omega", omegaDefault );
+ m_lambda = h.doubleAttribute( "lambda", lambdaDefault );
+ }
+ else if( str == "cylindrical" )
+ {
+ mapping = true;
+ m_warpType = PMWarp::Cylindrical;
+ }
+ else if( str == "spherical" )
+ {
+ mapping = true;
+ m_warpType = PMWarp::Spherical;
+ }
+ else if( str == "toroidal" )
+ {
+ mapping = true;
+ m_warpType = PMWarp::Toroidal;
+ m_majorRadius = h.doubleAttribute( "major_radius", majorRadiusDefault );
+ }
+ else if( str == "planar" )
+ {
+ mapping = true;
+ m_warpType = PMWarp::Planar;
+ }
+
+ if( mapping )
+ {
+ m_orientation = h.vectorAttribute( "orientation", orientationDefault );
+ m_distExp = h.doubleAttribute( "dist_exp", distExpDefault );
+ }
+}
+
+PMMetaObject* PMWarp::metaObject( ) const
+{
+ if( !s_pMetaObject )
+ {
+ s_pMetaObject = new PMMetaObject( "Warp", Base::metaObject( ),
+ createNewWarp );
+
+ PMWarpTypeProperty* p = new PMWarpTypeProperty(
+ "warpType", &PMWarp::setWarpType, &PMWarp::warpType );
+ p->addEnumValue( "Repeat", Repeat );
+ p->addEnumValue( "BlackHole", BlackHole );
+ p->addEnumValue( "Turbulence", Turbulence );
+ p->addEnumValue( "Cylindrical", Cylindrical );
+ p->addEnumValue( "Spherical", Spherical );
+ p->addEnumValue( "Toroidal", Toroidal );
+ p->addEnumValue( "Planar", Planar );
+ s_pMetaObject->addProperty( p );
+
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "direction", &PMWarp::setDirection, &PMWarp::direction ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "offset", &PMWarp::setOffset, &PMWarp::offset ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "flip", &PMWarp::setFlip, &PMWarp::flip ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "location", &PMWarp::setLocation, &PMWarp::location ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "radius", &PMWarp::setRadius, &PMWarp::radius ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "strength", &PMWarp::setStrength, &PMWarp::strength ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "falloff", &PMWarp::setFalloff, &PMWarp::falloff ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "inverse", &PMWarp::setInverse, &PMWarp::inverse ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "repeat", &PMWarp::setRepeat, &PMWarp::repeat ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "turbulence", &PMWarp::setTurbulence, &PMWarp::turbulence ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "valueVector", &PMWarp::setValueVector, &PMWarp::valueVector ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "octaves", &PMWarp::setOctaves, &PMWarp::octaves ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "omega", &PMWarp::setOmega, &PMWarp::omega ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "lambda", &PMWarp::setLambda, &PMWarp::lambda ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "orientation", &PMWarp::setOrientation, &PMWarp::orientation ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "dist_exp", &PMWarp::setDistExp, &PMWarp::distExp ) );
+ s_pMetaObject->addProperty(
+ new PMWarpProperty( "major_radius", &PMWarp::setMajorRadius, &PMWarp::majorRadius ) );
+ }
+ return s_pMetaObject;
+}
+
+void PMWarp::cleanUp( ) const
+{
+ if( s_pMetaObject )
+ {
+ delete s_pMetaObject;
+ s_pMetaObject = 0;
+ }
+ Base::cleanUp( );
+}
+
+void PMWarp::setWarpType( PMWarpType c )
+{
+ if( c != m_warpType )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMWarpTypeID, m_warpType );
+ m_warpType = c;
+ }
+}
+
+void PMWarp::setDirection( const PMVector& c )
+{
+ if( c != m_direction )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMDirectionID, m_direction );
+ m_direction = c;
+ }
+}
+
+void PMWarp::setOffset( const PMVector& c )
+{
+ if( c != m_offset )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMOffsetID, m_offset );
+ m_offset = c;
+ }
+}
+
+void PMWarp::setFlip( const PMVector& c )
+{
+ if( c != m_flip )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMFlipID, m_flip );
+ m_flip = c;
+ }
+}
+
+void PMWarp::setLocation( const PMVector& c )
+{
+ if( c != m_location )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMLocationID, m_location );
+ m_location = c;
+ }
+}
+
+void PMWarp::setRadius( const double c )
+{
+ if( c != m_radius )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMRadiusID, m_radius );
+ m_radius = c;
+ }
+}
+
+void PMWarp::setStrength( const double c )
+{
+ if( c != m_strength )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMStrengthID, m_strength );
+ m_strength = c;
+ }
+}
+
+void PMWarp::setFalloff( const double c )
+{
+ if( c != m_falloff )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMFalloffID, m_falloff );
+ m_falloff = c;
+ }
+}
+
+void PMWarp::setInverse( const bool c )
+{
+ if( c != m_inverse )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMInverseID, m_inverse );
+ m_inverse = c;
+ }
+}
+
+void PMWarp::setRepeat( const PMVector& c )
+{
+ if( c != m_repeat )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMRepeatID, m_repeat );
+ m_repeat = c;
+ }
+}
+
+void PMWarp::setTurbulence( const PMVector& c )
+{
+ if( c != m_turbulence )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMTurbulenceID, m_turbulence );
+ m_turbulence = c;
+ }
+}
+
+void PMWarp::setValueVector( const PMVector& c )
+{
+ if( c != m_valueVector )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMValueVectorID, m_valueVector );
+ m_valueVector = c;
+ }
+}
+
+void PMWarp::setOctaves( const int c )
+{
+ if( c != m_octaves )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMOctavesID, m_octaves );
+ m_octaves = c;
+ }
+}
+
+void PMWarp::setOmega( const double c )
+{
+ if( c != m_omega )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMOmegaID, m_omega );
+ m_omega = c;
+ }
+}
+
+void PMWarp::setLambda( const double c )
+{
+ if( c != m_lambda )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMLambdaID, m_lambda );
+ m_lambda = c;
+ }
+}
+
+void PMWarp::setOrientation( const PMVector& v )
+{
+ if ( v != m_orientation )
+ {
+ if ( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMOrientationID, m_orientation );
+ m_orientation = v;
+ }
+}
+
+void PMWarp::setDistExp( const double c )
+{
+ if ( c != m_distExp )
+ {
+ if ( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMDistExpID, m_distExp );
+ m_distExp = c;
+ }
+}
+
+void PMWarp::setMajorRadius( const double c )
+{
+ if ( c != m_majorRadius )
+ {
+ if ( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMMajorRadiusID, m_majorRadius );
+ m_majorRadius = c;
+ }
+}
+
+PMDialogEditBase* PMWarp::editWidget( QWidget* parent ) const
+{
+ return new PMWarpEdit( parent );
+}
+
+void PMWarp::restoreMemento( PMMemento* s )
+{
+ PMMementoDataIterator it( s );
+ PMMementoData* data;
+
+ for( ; it.current( ); ++it )
+ {
+ data = it.current( );
+ if( data->objectType( ) == s_pMetaObject )
+ {
+ switch( data->valueID( ) )
+ {
+ case PMWarpTypeID:
+ setWarpType( ( PMWarpType )data->intData( ) );
+ break;
+ case PMDirectionID:
+ setDirection( data->vectorData( ) );
+ break;
+ case PMOffsetID:
+ setOffset( data->vectorData( ) );
+ break;
+ case PMFlipID:
+ setFlip( data->vectorData( ) );
+ break;
+ case PMLocationID:
+ setLocation( data->vectorData( ) );
+ break;
+ case PMRadiusID:
+ setRadius( data->doubleData( ) );
+ break;
+ case PMStrengthID:
+ setStrength( data->doubleData( ) );
+ break;
+ case PMFalloffID:
+ setFalloff( data->doubleData( ) );
+ break;
+ case PMInverseID:
+ setInverse( data->boolData( ) );
+ break;
+ case PMRepeatID:
+ setRepeat( data->vectorData( ) );
+ break;
+ case PMTurbulenceID:
+ setTurbulence( data->vectorData( ) );
+ 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 PMOrientationID:
+ setOrientation( data->vectorData( ) );
+ break;
+ case PMDistExpID:
+ setDistExp( data->doubleData( ) );
+ break;
+ case PMMajorRadiusID:
+ setMajorRadius( data->doubleData( ) );
+ break;
+ default:
+ kdError( PMArea ) << "Wrong ID in PMWarp::restoreMemento\n";
+ break;
+ }
+ }
+ }
+ Base::restoreMemento( s );
+}