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.
549 lines
16 KiB
549 lines
16 KiB
/*
|
|
**************************************************************************
|
|
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 <tdelocale.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( )
|
|
{
|
|
}
|
|
|
|
TQString PMWarp::description( ) const
|
|
{
|
|
return i18n( "warp" );
|
|
}
|
|
|
|
void PMWarp::serialize( TQDomElement& e, TQDomDocument& /*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;
|
|
TQString 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( TQWidget* 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 );
|
|
}
|