diff options
Diffstat (limited to 'kpovmodeler/pmwarp.cpp')
| -rw-r--r-- | kpovmodeler/pmwarp.cpp | 548 |
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 ); +} |