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

1 files changed, 428 insertions, 0 deletions

diff --git a/kpovmodeler/pmradiosity.cpp b/kpovmodeler/pmradiosity.cpp
new file mode 100644
index 00000000..d5446b25
--- /dev/null
+++ b/kpovmodeler/pmradiosity.cpp
@@ -0,0 +1,428 @@
+/*
+**************************************************************************
+                                 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 "pmradiosity.h"
+#include "pmxmlhelper.h"
+#include "pmmemento.h"
+#include "pmradiosityedit.h"
+
+#include <klocale.h>
+
+const double adcBailoutDefault = 0.01;
+const double brightnessDefault = 1.0;
+const int countDefault = 35;
+const double errorBoundDefault = 1.8;
+const double grayThresholdDefault = 0.0;
+const double lowErrorFactorDefault = 0.5;
+const double maxSampleDefault = -1.0;
+const double minimumReuseDefault = 0.015;
+const int nearestCountDefault = 5;
+const double pretraceStartDefault = 0.08;
+const double pretraceEndDefault = 0.04;
+const int recursionLimitDefault = 2;
+
+PMDefinePropertyClass( PMRadiosity, PMRadiosityProperty );
+PMMetaObject* PMRadiosity::s_pMetaObject = 0;
+PMObject* createNewRadiosity( PMPart* part )
+{
+   return new PMRadiosity( part );
+}
+
+PMRadiosity::PMRadiosity( PMPart* part ) : Base( part )
+{
+  m_adcBailout = adcBailoutDefault;
+  m_alwaysSample = true;
+  m_brightness = brightnessDefault;
+  m_count = countDefault;
+  m_errorBound = errorBoundDefault;
+  m_grayThreshold = grayThresholdDefault;
+  m_lowErrorFactor = lowErrorFactorDefault;
+  m_maxSample = maxSampleDefault;
+  m_media = false;
+  m_minimumReuse = minimumReuseDefault;
+  m_nearestCount = nearestCountDefault;
+  m_normal = false;
+  m_pretraceStart = pretraceStartDefault;
+  m_pretraceEnd = pretraceEndDefault;
+  m_recursionLimit = recursionLimitDefault;
+}
+
+PMRadiosity::PMRadiosity( const PMRadiosity& r )
+      : Base( r )
+{
+  m_adcBailout = r.m_adcBailout;
+  m_alwaysSample = r.m_alwaysSample;
+  m_brightness = r.m_brightness;
+  m_count = r.m_count;
+  m_errorBound = r.m_errorBound;
+  m_grayThreshold = r.m_grayThreshold;
+  m_lowErrorFactor = r.m_lowErrorFactor;
+  m_maxSample = r.m_maxSample;
+  m_media = r.m_media;
+  m_minimumReuse = r.m_minimumReuse;
+  m_nearestCount = r.m_nearestCount;
+  m_normal = r.m_normal;
+  m_pretraceStart = r.m_pretraceStart;
+  m_pretraceEnd = r.m_pretraceEnd;
+  m_recursionLimit = r.m_recursionLimit;
+}
+
+PMRadiosity::~PMRadiosity( )
+{
+}
+
+PMMetaObject* PMRadiosity::metaObject( ) const
+{
+   if( !s_pMetaObject )
+   {
+      s_pMetaObject = new PMMetaObject( "Radiosity", Base::metaObject( ),
+                                        createNewRadiosity );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "adcBailout", &PMRadiosity::setAdcBailout, &PMRadiosity::adcBailout ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "alwaysSample", &PMRadiosity::setAlwaysSample, &PMRadiosity::alwaysSample ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "brightness", &PMRadiosity::setBrightness, &PMRadiosity::brightness ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "count", &PMRadiosity::setCount, &PMRadiosity::count ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "errorBound", &PMRadiosity::setErrorBound, &PMRadiosity::errorBound ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "grayThreshold", &PMRadiosity::setGrayThreshold, &PMRadiosity::grayThreshold ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "lowErrorFactor", &PMRadiosity::setLowErrorFactor, &PMRadiosity::lowErrorFactor ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "maxSample", &PMRadiosity::setMaxSample, &PMRadiosity::maxSample ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "media", &PMRadiosity::setMedia, &PMRadiosity::media ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "minimumReuse", &PMRadiosity::setMinimumReuse, &PMRadiosity::minimumReuse ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "nearestCount", &PMRadiosity::setNearestCount, &PMRadiosity::nearestCount ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "normal", &PMRadiosity::setNormal, &PMRadiosity::normal ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "pretraceStart", &PMRadiosity::setPretraceStart, &PMRadiosity::pretraceStart ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "pretraceEnd", &PMRadiosity::setPretraceEnd, &PMRadiosity::pretraceEnd ) );
+      s_pMetaObject->addProperty(
+         new PMRadiosityProperty( "recursionLimit", &PMRadiosity::setRecursionLimit, &PMRadiosity::recursionLimit ) );
+   }
+   return s_pMetaObject;
+}
+
+void PMRadiosity::cleanUp( ) const
+{
+   if( s_pMetaObject )
+   {
+      delete s_pMetaObject;
+      s_pMetaObject = 0;
+   }
+   Base::cleanUp( );
+}
+
+QString PMRadiosity::description( ) const
+{
+   return i18n( "radiosity" );
+}
+
+void PMRadiosity::serialize( QDomElement& e, QDomDocument& ) const
+{
+   e.setAttribute( "adc_bailout", m_adcBailout );
+
+   if ( m_alwaysSample )
+      e.setAttribute( "always_sample", "1" );
+   else
+      e.setAttribute( "always_sample", "0" );
+
+   e.setAttribute( "brightness", m_brightness );
+   e.setAttribute( "count", m_count );
+   e.setAttribute( "error_bound", m_errorBound );
+   e.setAttribute( "gray_threshold", m_grayThreshold );
+   e.setAttribute( "low_error_factor", m_lowErrorFactor );
+   e.setAttribute( "max_sample", m_maxSample );
+
+   if ( m_media )
+      e.setAttribute( "media", "1" );
+   else
+      e.setAttribute( "media", "0" );
+
+   e.setAttribute( "minimum_reuse", m_minimumReuse );
+   e.setAttribute( "nearest_count", m_nearestCount );
+
+   if ( m_normal )
+      e.setAttribute( "normal", "1" );
+   else
+      e.setAttribute( "normal", "0" );
+
+   e.setAttribute( "pretrace_start", m_pretraceStart );
+   e.setAttribute( "pretrace_end", m_pretraceEnd );
+   e.setAttribute( "recursion_limit", m_recursionLimit );
+}
+
+void PMRadiosity::readAttributes( const PMXMLHelper& h )
+{
+   m_adcBailout = h.doubleAttribute( "adc_bailout", adcBailoutDefault );
+   m_alwaysSample = h.boolAttribute( "always_sample", true );
+   m_brightness = h.doubleAttribute( "brightness", brightnessDefault );
+   m_count = h.intAttribute( "count", countDefault );
+   m_errorBound = h.doubleAttribute( "error_bound", errorBoundDefault );
+   m_grayThreshold = h.doubleAttribute( "gray_threshold", grayThresholdDefault );
+   m_lowErrorFactor = h.doubleAttribute( "low_error_factor", lowErrorFactorDefault );
+   m_maxSample = h.doubleAttribute( "max_sample", maxSampleDefault );
+   m_media = h.boolAttribute( "media", false );
+   m_minimumReuse = h.doubleAttribute( "minimum_reuse", minimumReuseDefault );
+   m_nearestCount = h.intAttribute( "nearest_count", nearestCountDefault );
+   m_normal = h.boolAttribute( "normal", false );
+   m_pretraceStart = h.doubleAttribute( "pretrace_start", pretraceStartDefault );
+   m_pretraceEnd = h.doubleAttribute( "pretrace_end", pretraceEndDefault );
+   m_recursionLimit = h.intAttribute( "recursion_limit", recursionLimitDefault );
+}
+
+void PMRadiosity::setAdcBailout( double ab )
+{
+   if( ab != m_adcBailout )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMAdcBailoutID, m_adcBailout );
+      m_adcBailout = ab;
+   }
+}
+
+void PMRadiosity::setAlwaysSample( bool as )
+{
+   if( as != m_alwaysSample )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMAlwaysSampleID, m_alwaysSample );
+      m_alwaysSample = as;
+   }
+}
+
+void PMRadiosity::setBrightness( double b )
+{
+   if( b != m_brightness )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMBrightnessID, m_brightness );
+      m_brightness = b;
+   }
+}
+
+void PMRadiosity::setCount( int c )
+{
+   if( c != m_count )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMCountID, m_count );
+      m_count = c;
+   }
+}
+
+void PMRadiosity::setErrorBound( double eb )
+{
+   if( eb != m_errorBound )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMErrorBoundID, m_errorBound );
+      m_errorBound = eb;
+   }
+}
+
+void PMRadiosity::setGrayThreshold( double gt )
+{
+   if( gt != m_grayThreshold )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMGrayThresholdID, m_grayThreshold );
+      m_grayThreshold = gt;
+   }
+}
+
+void PMRadiosity::setLowErrorFactor( double lew )
+{
+   if( lew != m_lowErrorFactor )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMLowErrorFactorID, m_lowErrorFactor );
+      m_lowErrorFactor = lew;
+   }
+}
+
+void PMRadiosity::setMaxSample( double ms )
+{
+   if( ms != m_maxSample )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMMaxSampleID, m_maxSample );
+      m_maxSample = ms;
+   }
+}
+
+void PMRadiosity::setMedia( bool m )
+{
+   if( m != m_media )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMMediaID, m_media );
+      m_media = m;
+   }
+}
+
+void PMRadiosity::setMinimumReuse( double c )
+{
+   if( c != m_minimumReuse )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMMinimumReuseID, m_minimumReuse );
+      m_minimumReuse = c;
+   }
+}
+
+void PMRadiosity::setNearestCount( int c )
+{
+   if( c != m_nearestCount )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMNearestCountID, m_nearestCount );
+      m_nearestCount = c;
+   }
+}
+
+void PMRadiosity::setNormal( bool n )
+{
+   if( n != m_normal )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMNormalID, m_normal );
+      m_normal = n;
+   }
+}
+
+void PMRadiosity::setPretraceStart( double ps )
+{
+   if ( ps < m_pretraceEnd )
+   {
+      kdError( PMArea ) << "Pretrace Start < Pretrace End in PMRadiosity::setPretraceStart\n";
+      ps = m_pretraceEnd;
+   }
+
+   if( ps != m_pretraceStart )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMPretraceStartID, m_pretraceStart );
+      m_pretraceStart = ps;
+   }
+}
+
+void PMRadiosity::setPretraceEnd( double pe )
+{
+   if ( pe > m_pretraceStart )
+   {
+      kdError( PMArea ) << "Pretrace End > Pretrace Start in PMRadiosity::setPretraceEnd\n";
+      pe = m_pretraceStart;
+   }
+
+   if( pe != m_pretraceEnd )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMPretraceEndID, m_pretraceEnd );
+      m_pretraceEnd = pe;
+   }
+}
+
+void PMRadiosity::setRecursionLimit( int c )
+{
+   if( c != m_recursionLimit )
+   {
+      if( m_pMemento )
+         m_pMemento->addData( s_pMetaObject, PMRecursionLimitID, m_recursionLimit );
+      m_recursionLimit = c;
+   }
+}
+
+PMDialogEditBase* PMRadiosity::editWidget( QWidget* parent ) const
+{
+   return new PMRadiosityEdit( parent );
+}
+
+void PMRadiosity::restoreMemento( PMMemento* s )
+{
+   PMMementoDataIterator it( s );
+   PMMementoData* data;
+
+   for( ; it.current( ); ++it )
+   {
+      data = it.current( );
+      if( data->objectType( ) == s_pMetaObject )
+      {
+         switch( data->valueID( ) )
+         {
+            case PMAdcBailoutID:
+               setAdcBailout( data->doubleData( ) );
+               break;
+            case PMAlwaysSampleID:
+               setAlwaysSample( data->boolData( ) );
+               break;
+            case PMBrightnessID:
+               setBrightness( data->doubleData( ) );
+               break;
+            case PMCountID:
+               setCount( data->intData( ) );
+               break;
+            case PMErrorBoundID:
+               setErrorBound( data->doubleData( ) );
+               break;
+            case PMGrayThresholdID:
+               setGrayThreshold( data->doubleData( ) );
+               break;
+            case PMLowErrorFactorID:
+               setLowErrorFactor( data->doubleData( ) );
+               break;
+            case PMMaxSampleID:
+               setMaxSample( data->doubleData( ) );
+               break;
+            case PMMediaID:
+               setMedia( data->boolData( ) );
+               break;
+            case PMMinimumReuseID:
+               setMinimumReuse( data->doubleData( ) );
+               break;
+            case PMNearestCountID:
+               setNearestCount( data->intData( ) );
+               break;
+            case PMNormalID:
+               setNormal( data->boolData( ) );
+               break;
+            case PMPretraceStartID:
+               setPretraceStart( data->doubleData( ) );
+               break;
+            case PMPretraceEndID:
+               setPretraceEnd( data->doubleData( ) );
+               break;
+            case PMRecursionLimitID:
+               setRecursionLimit( data->intData( ) );
+               break;
+            default:
+               kdError( PMArea ) << "Wrong ID in PMRadiosity::restoreMemento\n";
+               break;
+         }
+      }
+   }
+   Base::restoreMemento( s );
+}