summaryrefslogtreecommitdiffstats
path: root/kpovmodeler/pmglobalphotons.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit47d455dd55be855e4cc691c32f687f723d9247ee (patch)
tree52e236aaa2576bdb3840ebede26619692fed6d7d /kpovmodeler/pmglobalphotons.cpp
downloadtdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.tar.gz
tdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kpovmodeler/pmglobalphotons.cpp')
-rw-r--r--kpovmodeler/pmglobalphotons.cpp521
1 files changed, 521 insertions, 0 deletions
diff --git a/kpovmodeler/pmglobalphotons.cpp b/kpovmodeler/pmglobalphotons.cpp
new file mode 100644
index 00000000..4a24855f
--- /dev/null
+++ b/kpovmodeler/pmglobalphotons.cpp
@@ -0,0 +1,521 @@
+/*
+**************************************************************************
+ description
+ --------------------
+ copyright : (C) 2003 by Leon Pennington
+ email : leon@leonscape.co.uk
+**************************************************************************
+
+**************************************************************************
+* *
+* 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 "pmglobalphotons.h"
+#include "pmxmlhelper.h"
+#include "pmmemento.h"
+#include "pmenumproperty.h"
+#include "pmglobalphotonsedit.h"
+
+#include <klocale.h>
+
+const double spacingDefault = 0.01;
+const int countDefault = 20000;
+const int gatherMinDefault = 20;
+const int gatherMaxDefault = 100;
+const int mediaMaxStepsDefault = 0;
+const double mediaFactorDefault = 1.0;
+const double jitterDefault = 0.4;
+const int maxTraceLevelDefault = 0;
+const double adcBailoutDefault = 0.01;
+const double autostopDefault = 0.0;
+const double expandIncreaseDefault = 0.2;
+const int expandMinDefault = 40;
+const double radiusGatherDefault = 0.0;
+const double radiusGatherMultiDefault = 1.0;
+const double radiusMediaDefault = 0.0;
+const double radiusMediaMultiDefault = 1.0;
+
+PMDefinePropertyClass( PMGlobalPhotons, PMGlobalPhotonsProperty );
+PMDefineEnumPropertyClass( PMGlobalPhotons, PMGlobalPhotons::PMNumberType, PMNumberProperty );
+
+PMMetaObject* PMGlobalPhotons::s_pMetaObject = 0;
+PMObject* createNewGlobalPhotons( PMPart* part )
+{
+ return new PMGlobalPhotons( part );
+}
+
+PMGlobalPhotons::PMGlobalPhotons( PMPart* part ) : Base( part )
+{
+ m_numberType = Spacing;
+ m_spacing = spacingDefault;
+ m_count = countDefault;
+ m_gatherMin = gatherMinDefault;
+ m_gatherMax = gatherMaxDefault;
+ m_mediaMaxSteps = mediaMaxStepsDefault;
+ m_mediaFactor = mediaFactorDefault;
+ m_jitter = jitterDefault;
+ m_maxTraceLevelGlobal = true;
+ m_maxTraceLevel = maxTraceLevelDefault;
+ m_adcBailoutGlobal = true;
+ m_adcBailout = adcBailoutDefault;
+ m_autostop = autostopDefault;
+ m_expandIncrease = expandIncreaseDefault;
+ m_expandMin = expandMinDefault;
+ m_radiusGather = radiusGatherDefault;
+ m_radiusGatherMulti = radiusGatherMultiDefault;
+ m_radiusMedia = radiusMediaDefault;
+ m_radiusMediaMulti = radiusMediaMultiDefault;
+}
+
+PMGlobalPhotons::PMGlobalPhotons( const PMGlobalPhotons& p )
+ : Base( p )
+{
+ m_numberType = p.m_numberType;
+ m_spacing = p.m_spacing;
+ m_count = p.m_count;
+ m_gatherMin = p.m_gatherMin;
+ m_gatherMax = p.m_gatherMax;
+ m_mediaMaxSteps = p.m_mediaMaxSteps;
+ m_mediaFactor = p.m_mediaFactor;
+ m_jitter = p.m_jitter;
+ m_maxTraceLevelGlobal = p.m_maxTraceLevelGlobal;
+ m_maxTraceLevel = p.m_maxTraceLevel;
+ m_adcBailoutGlobal = p.m_adcBailoutGlobal;
+ m_adcBailout = p.m_adcBailout;
+ m_autostop = p.m_autostop;
+ m_expandIncrease = p.m_expandIncrease;
+ m_expandMin = p.m_expandMin;
+ m_radiusGather = p.m_radiusGather;
+ m_radiusGatherMulti = p.m_radiusGatherMulti;
+ m_radiusMedia = p.m_radiusMedia;
+ m_radiusMediaMulti = p.m_radiusMediaMulti;
+}
+
+PMGlobalPhotons::~PMGlobalPhotons( )
+{
+}
+
+PMMetaObject* PMGlobalPhotons::metaObject( ) const
+{
+ if( !s_pMetaObject )
+ {
+ s_pMetaObject = new PMMetaObject( "GlobalPhotons", Base::metaObject( ),
+ createNewGlobalPhotons );
+
+ PMNumberProperty* p1 = new PMNumberProperty( "numberType",
+ &PMGlobalPhotons::setNumberType, &PMGlobalPhotons::numberType );
+ p1->addEnumValue( "Spacing", Spacing );
+ p1->addEnumValue( "Count", Count );
+ s_pMetaObject->addProperty( p1 );
+
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "spacing",
+ &PMGlobalPhotons::setSpacing, &PMGlobalPhotons::spacing ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "count",
+ &PMGlobalPhotons::setCount, &PMGlobalPhotons::count ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "gatherMin",
+ &PMGlobalPhotons::setGatherMin, &PMGlobalPhotons::gatherMin ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "gatherMax",
+ &PMGlobalPhotons::setGatherMax, &PMGlobalPhotons::gatherMax ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "mediaMaxSteps",
+ &PMGlobalPhotons::setMediaMaxSteps, &PMGlobalPhotons::mediaMaxSteps ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "mediaFactor",
+ &PMGlobalPhotons::setMediaFactor, &PMGlobalPhotons::mediaFactor ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "jitter",
+ &PMGlobalPhotons::setJitter, &PMGlobalPhotons::jitter ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "maxTraceLevelGlobal",
+ &PMGlobalPhotons::setMaxTraceLevelGlobal, &PMGlobalPhotons::maxTraceLevelGlobal ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "maxTraceLevel",
+ &PMGlobalPhotons::setMaxTraceLevel, &PMGlobalPhotons::maxTraceLevel ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "adcBailoutGlobal",
+ &PMGlobalPhotons::setAdcBailoutGlobal, &PMGlobalPhotons::adcBailoutGlobal ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "adcBailout",
+ &PMGlobalPhotons::setAdcBailout, &PMGlobalPhotons::adcBailout ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "autostop",
+ &PMGlobalPhotons::setAutostop, &PMGlobalPhotons::autostop ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "expandIncrease",
+ &PMGlobalPhotons::setExpandIncrease, &PMGlobalPhotons::expandIncrease ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "expandMin",
+ &PMGlobalPhotons::setExpandMin, &PMGlobalPhotons::expandMin ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "radiusGather",
+ &PMGlobalPhotons::setRadiusGather, &PMGlobalPhotons::radiusGather ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "radiusGatherMulti",
+ &PMGlobalPhotons::setRadiusGatherMulti, &PMGlobalPhotons::radiusGatherMulti ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "radiusMedia",
+ &PMGlobalPhotons::setRadiusMedia, &PMGlobalPhotons::radiusMedia ) );
+ s_pMetaObject->addProperty( new PMGlobalPhotonsProperty( "radiusMediaMulti",
+ &PMGlobalPhotons::setRadiusMediaMulti, &PMGlobalPhotons::radiusMediaMulti ) );
+ }
+ return s_pMetaObject;
+}
+
+void PMGlobalPhotons::cleanUp( ) const
+{
+ if( s_pMetaObject )
+ {
+ delete s_pMetaObject;
+ s_pMetaObject = 0;
+ }
+ Base::cleanUp( );
+}
+
+QString PMGlobalPhotons::description( ) const
+{
+ return i18n( "global photons" );
+}
+
+void PMGlobalPhotons::serialize( QDomElement& e, QDomDocument& ) const
+{
+ if( m_numberType == Spacing )
+ {
+ e.setAttribute( "number_type", "spacing" );
+ e.setAttribute( "spacing", m_spacing );
+ }
+ else
+ {
+ e.setAttribute( "number_type", "count" );
+ e.setAttribute( "count", m_count );
+ }
+
+ e.setAttribute( "gather_min", m_gatherMin );
+ e.setAttribute( "gather_max", m_gatherMax );
+ e.setAttribute( "media_max_steps", m_mediaMaxSteps );
+ e.setAttribute( "media_factor", m_mediaFactor );
+ e.setAttribute( "jitter", m_jitter );
+ e.setAttribute( "max_trace_level_global", m_maxTraceLevelGlobal );
+ e.setAttribute( "max_trace_level", m_maxTraceLevel );
+ e.setAttribute( "adc_bailout_global", m_adcBailoutGlobal );
+ e.setAttribute( "adc_bailout", m_adcBailout );
+ e.setAttribute( "autostop", m_autostop );
+ e.setAttribute( "expand_increase", m_expandIncrease );
+ e.setAttribute( "expand_min", m_expandMin );
+ e.setAttribute( "radius_gather", m_radiusGather );
+ e.setAttribute( "radius_gather_multi", m_radiusGatherMulti );
+ e.setAttribute( "radius_media", m_radiusMedia );
+ e.setAttribute( "radius_media_multi", m_radiusMediaMulti );
+}
+
+void PMGlobalPhotons::readAttributes( const PMXMLHelper& h )
+{
+ QString str;
+
+ str = h.stringAttribute( "number_type", "spacing" );
+ if( str == "count" )
+ m_numberType = Count;
+ else
+ m_numberType = Spacing;
+
+ m_spacing = h.doubleAttribute( "spacing", spacingDefault );
+ m_count = h.intAttribute( "count", countDefault );
+ m_gatherMin = h.intAttribute( "gather_min", gatherMinDefault );
+ m_gatherMax = h.intAttribute( "gather_max", gatherMaxDefault );
+ m_mediaMaxSteps = h.intAttribute( "media_max_steps", mediaMaxStepsDefault );
+ m_mediaFactor = h.doubleAttribute( "media_factor", mediaFactorDefault );
+ m_jitter = h.doubleAttribute( "jitter", jitterDefault );
+ m_maxTraceLevelGlobal = h.boolAttribute( "max_trace_level_global", true );
+ m_maxTraceLevel = h.intAttribute( "max_trace_level", maxTraceLevelDefault );
+ m_adcBailoutGlobal = h.boolAttribute( "adc_bailout_global", true );
+ m_adcBailout = h.doubleAttribute( "adc_bailout", adcBailoutDefault );
+ m_autostop = h.doubleAttribute( "autostop", autostopDefault );
+ m_expandIncrease = h.doubleAttribute( "expand_increase", expandIncreaseDefault );
+ m_expandMin = h.intAttribute( "expand_min", expandMinDefault );
+ m_radiusGather = h.doubleAttribute( "radius_gather", radiusGatherDefault );
+ m_radiusGatherMulti = h.doubleAttribute( "radius_gather_multi",
+ radiusGatherMultiDefault );
+
+ m_radiusMedia = h.doubleAttribute( "radius_media", radiusMediaDefault );
+ m_radiusMediaMulti = h.doubleAttribute( "radius_media_multi",
+ radiusMediaMultiDefault );
+}
+
+void PMGlobalPhotons::setNumberType( PMNumberType nt )
+{
+ if( nt != m_numberType )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMNumberTypeID, m_numberType );
+ m_numberType = nt;
+ }
+}
+
+void PMGlobalPhotons::setSpacing( double s )
+{
+ if( s != m_spacing )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMSpacingID, m_spacing );
+ m_spacing = s;
+ }
+}
+
+void PMGlobalPhotons::setCount( int c )
+{
+ if( c != m_count )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMCountID, m_count );
+ m_count = c;
+ }
+}
+
+void PMGlobalPhotons::setGatherMin( int gm )
+{
+ if( gm > m_gatherMax )
+ {
+ kdError( PMArea ) << "Gather Minimum > Gather Maximum in PMGlobalPhotons::setGatherMin\n";
+ gm = m_gatherMax;
+ }
+
+ if( gm != m_gatherMin )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMGatherMinID, m_gatherMin );
+ m_gatherMin = gm;
+ }
+}
+
+void PMGlobalPhotons::setGatherMax( int gm )
+{
+ if( gm < m_gatherMin )
+ {
+ kdError( PMArea ) << "Gather Maximum < Gather Minimum in PMGlobalPhotons::setGatherMax\n";
+ gm = m_gatherMin;
+ }
+
+ if( gm != m_gatherMax )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMGatherMaxID, m_gatherMax );
+ m_gatherMax = gm;
+ }
+}
+
+void PMGlobalPhotons::setMediaMaxSteps( int mms )
+{
+ if( mms != m_mediaMaxSteps )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMMediaMaxStepsID, m_mediaMaxSteps );
+ m_mediaMaxSteps = mms;
+ }
+}
+
+void PMGlobalPhotons::setMediaFactor( double mf )
+{
+ if( mf != m_mediaFactor )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMMediaFactorID, m_mediaFactor );
+ m_mediaFactor = mf;
+ }
+}
+
+void PMGlobalPhotons::setJitter( double j )
+{
+ if( j != m_jitter )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMJitterID, m_jitter );
+ m_jitter = j;
+ }
+}
+
+void PMGlobalPhotons::setMaxTraceLevelGlobal( bool mtlg )
+{
+ if( mtlg != m_maxTraceLevelGlobal )
+ {
+ if( m_pMemento )
+ m_pMemento->addData(
+ s_pMetaObject, PMMaxTraceLevelGlobalID, m_maxTraceLevelGlobal );
+ m_maxTraceLevelGlobal = mtlg;
+ }
+}
+
+void PMGlobalPhotons::setMaxTraceLevel( int mtl )
+{
+ if( mtl != m_maxTraceLevel )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMMaxTraceLevelID, m_maxTraceLevel );
+ m_maxTraceLevel = mtl;
+ }
+}
+
+void PMGlobalPhotons::setAdcBailoutGlobal( bool abg )
+{
+ if( abg != m_adcBailoutGlobal )
+ {
+ if( m_pMemento )
+ m_pMemento->addData(
+ s_pMetaObject, PMAdcBailoutGlobalID, m_adcBailoutGlobal );
+ m_adcBailoutGlobal = abg;
+ }
+}
+
+void PMGlobalPhotons::setAdcBailout( double ab )
+{
+ if( ab != m_adcBailout )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMAdcBailoutID, m_adcBailout );
+ m_adcBailout = ab;
+ }
+}
+
+void PMGlobalPhotons::setAutostop( double a )
+{
+ if( a != m_autostop )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMAutostopID, m_autostop );
+ m_autostop = a;
+ }
+}
+
+void PMGlobalPhotons::setExpandIncrease( double ei )
+{
+ if( ei != m_expandIncrease )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMExpandIncreaseID, m_expandIncrease );
+ m_expandIncrease = ei;
+ }
+}
+
+void PMGlobalPhotons::setExpandMin( int em )
+{
+ if(em != m_expandMin )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMExpandMinID, m_expandMin );
+ m_expandMin = em;
+ }
+}
+
+void PMGlobalPhotons::setRadiusGather( double rg )
+{
+ if ( rg != m_radiusGather )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMRadiusGatherID, m_radiusGather );
+ m_radiusGather = rg;
+ }
+}
+
+void PMGlobalPhotons::setRadiusGatherMulti( double rgm )
+{
+ if ( rgm != m_radiusGatherMulti )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMRadiusGatherID, m_radiusGatherMulti );
+ m_radiusGatherMulti = rgm;
+ }
+}
+
+void PMGlobalPhotons::setRadiusMedia( double rm )
+{
+ if ( rm != m_radiusMedia )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMRadiusGatherID, m_radiusMedia );
+ m_radiusMedia = rm;
+ }
+}
+
+void PMGlobalPhotons::setRadiusMediaMulti( double rmm )
+{
+ if ( rmm != m_radiusMediaMulti )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMRadiusGatherID, m_radiusMediaMulti );
+ m_radiusMediaMulti = rmm;
+ }
+}
+
+PMDialogEditBase* PMGlobalPhotons::editWidget( QWidget* parent ) const
+{
+ return new PMGlobalPhotonsEdit( parent );
+}
+
+void PMGlobalPhotons::restoreMemento( PMMemento* s )
+{
+ PMMementoDataIterator it( s );
+ PMMementoData* data;
+
+ for( ; it.current( ); ++it )
+ {
+ data = it.current( );
+ if( data->objectType( ) == s_pMetaObject )
+ {
+ switch( data->valueID( ) )
+ {
+ case PMNumberTypeID:
+ setNumberType( ( PMNumberType ) ( data->intData( ) ) );
+ break;
+ case PMSpacingID:
+ setSpacing( data->doubleData( ) );
+ break;
+ case PMCountID:
+ setCount( data->intData( ) );
+ break;
+ case PMGatherMinID:
+ setGatherMin( data->intData( ) );
+ break;
+ case PMGatherMaxID:
+ setGatherMax( data->intData( ) );
+ break;
+ case PMMediaMaxStepsID:
+ setMediaMaxSteps( data->intData( ) );
+ break;
+ case PMMediaFactorID:
+ setMediaFactor( data->doubleData( ) );
+ break;
+ case PMJitterID:
+ setJitter( data->doubleData( ) );
+ break;
+ case PMMaxTraceLevelGlobalID:
+ setMaxTraceLevelGlobal( data->boolData( ) );
+ break;
+ case PMMaxTraceLevelID:
+ setMaxTraceLevel( data->intData( ) );
+ break;
+ case PMAdcBailoutGlobalID:
+ setAdcBailoutGlobal( data->boolData( ) );
+ break;
+ case PMAdcBailoutID:
+ setAdcBailout( data->doubleData( ) );
+ break;
+ case PMAutostopID:
+ setAutostop( data->doubleData( ) );
+ break;
+ case PMExpandIncreaseID:
+ setExpandIncrease( data->doubleData( ) );
+ break;
+ case PMExpandMinID:
+ setExpandMin( data->intData( ) );
+ break;
+ case PMRadiusGatherID:
+ setRadiusGather( data->doubleData( ) );
+ break;
+ case PMRadiusGatherMultiID:
+ setRadiusGatherMulti( data->doubleData( ) );
+ break;
+ case PMRadiusMediaID:
+ setRadiusMedia( data->doubleData( ) );
+ break;
+ case PMRadiusMediaMultiID:
+ setRadiusMediaMulti( data->doubleData( ) );
+ break;
+ default:
+ kdError( PMArea ) << "Wrong ID in PMRadiosity::restoreMemento\n";
+ break;
+ }
+ }
+ }
+ Base::restoreMemento( s );
+}