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

522 lines
17 KiB

/*
**************************************************************************
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::tqmetaObject( ) const
{
if( !s_pMetaObject )
{
s_pMetaObject = new PMMetaObject( "GlobalPhotons", Base::tqmetaObject( ),
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( );
}
TQString PMGlobalPhotons::description( ) const
{
return i18n( "global photons" );
}
void PMGlobalPhotons::serialize( TQDomElement& e, TQDomDocument& ) 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 )
{
TQString 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( TQWidget* 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 );
}