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/pmwarp.cpp

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 <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( )
{
}
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 );
}