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/pmpattern.h

450 lines
12 KiB

//-*-C++-*-
/*
**************************************************************************
description
--------------------
copyright : (C) 2001-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. *
* *
**************************************************************************/
#ifndef PMPATTERN_H
#define PMPATTERN_H
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "pmobject.h"
#include "pmvector.h"
#include "pmcolor.h"
#include <tqvaluelist.h>
#include <tqvaluestack.h>
/**
* Class for povray patterns.
*/
class PMPattern : public PMObject
{
typedef PMObject Base;
public:
/**
* The type of the pattern
*/
enum PMPatternType { PatternAgate, PatternAverage, PatternBoxed,
PatternBozo, PatternBumps, PatternCells,
PatternCrackle, PatternCylindrical, PatternDensity,
PatternDents, PatternGradient, PatternGranite,
PatternJulia, PatternLeopard, PatternMandel,
PatternMarble, PatternOnion, PatternPlanar,
PatternQuilted, PatternRadial, PatternRipples,
PatternSlope, PatternSpherical, PatternSpiral1,
PatternSpiral2, PatternSpotted, PatternWaves,
PatternWood, PatternWrinkles };
/**
* The noise generators
*/
enum PMNoiseType { GlobalSetting, Original, RangeCorrected, Perlin };
/**
* Creates a PMPattern
*/
PMPattern( PMPart* part );
/**
* Copy constructor
*/
PMPattern( const PMPattern& p );
/**
* deletes the PMPattern
*/
virtual ~PMPattern( );
/** */
virtual PMObject* copy( ) const { return new PMPattern( *this ); }
/** */
virtual TQString description( ) const;
/** */
virtual TQString pixmap( ) const { return TQString( "pmpattern" ); }
/** */
virtual PMMetaObject* tqmetaObject( ) const;
/** */
virtual void cleanUp( ) const;
/** */
virtual void serialize( TQDomElement& e, TQDomDocument& doc ) const;
/** */
virtual void readAttributes( const PMXMLHelper& h );
/**
* Returns a new @ref PMPatternEdit
*/
virtual PMDialogEditBase* editWidget( TQWidget* parent ) const;
/**
* Gets the pattern type
*/
PMPatternType patternType( ) const { return m_patternType; }
/**
* Gets the agate Turbulence*/
double agateTurbulence( ) const { return m_agateTurbulence; }
/**
* Gets the crackle form
*/
PMVector crackleForm( ) const { return m_crackleForm; }
/**
* Gets the crackle metric
*/
int crackleMetric( ) const { return m_crackleMetric; }
/**
* Gets the crackle offset
*/
double crackleOffset( ) const { return m_crackleOffset; }
/**
* Gets the crackle solid flag
*/
bool crackleSolid( ) const { return m_crackleSolid; }
/**
* Gets the desity file name
*/
TQString densityFile( ) const { return m_densityFile; }
/**
* Gets the density interpolation
*/
int densityInterpolate( ) const { return m_densityInterpolate; }
/**
* Gets the gradint vector
*/
PMVector gradient( ) const { return m_gradient; }
/**
* Returns the Complex number for Julia Fractals
*/
PMVector juliaComplex( ) const { return m_juliaComplex; }
/**
* Returns true if where using tha magnet types of fractals
*/
bool fractalMagnet( ) const { return m_fractalMagnet; }
/**
* Returns the magnet type of a fractal
*/
int fractalMagnetType( ) const { return m_fractalMagnetType; }
/**
* Gets the number of Iterations for fractals
*/
int maxIterations( ) const { return m_maxIterations; }
/**
* Returns the exponent of a fractal
*/
int fractalExponent( ) const { return m_fractalExponent; }
/**
* Returns the exterior type of a fractal
*/
int fractalExtType( ) const { return m_fractalExtType; }
/**
* Return the exterior factor of a fractal
*/
double fractalExtFactor( ) const { return m_fractalExtFactor; }
/**
* Returns the interior type of a fractal
*/
int fractalIntType( ) const { return m_fractalIntType; }
/**
* Returns the interior factor of a fractal
*/
double fractalIntFactor( ) const { return m_fractalIntFactor; }
/**
* Gets control0 for Quilt
*/
double quiltControl0( ) const { return m_quiltControl0; }
/**
* Gets control1 for Quilt
*/
double quiltControl1( ) const { return m_quiltControl1; }
/**
* Returns the slope direction
*/
PMVector slopeDirection( ) const { return m_slopeDirection; }
/**
* Returns the low slope value
*/
double slopeLoSlope( ) const { return m_slopeLoSlope; }
/**
* Returns the high slope value
*/
double slopeHiSlope( ) const { return m_slopeHiSlope; }
/**
* Returns the slopes altitude flag
*/
bool slopeAltFlag( ) const { return m_slopeAltFlag; }
/**
* Returns the altitude for the slope
*/
PMVector slopeAltitude( ) const { return m_slopeAltitude; }
/**
* Returns the low altitude for slope
*/
double slopeLoAltitude( ) const { return m_slopeLoAlt; }
/**
* Returns the high altitude for slope
*/
double slopeHiAltitude( ) const { return m_slopeHiAlt; }
/**
* Gets the number of arms in spiral types 1 and 2
*/
int spiralNumberArms( ) const { return m_spiralNumberArms; }
/**
* Returns the noise generator
*/
PMNoiseType noiseGenerator( ) const { return m_noiseGenerator; };
/**
* Returns whether turbulence is enabled
*/
bool isTurbulenceEnabled( ) const { return m_enableTurbulence; }
/**
* Gets the Turbulence vector
*/
PMVector valueVector( ) const { return m_valueVector; }
/**
* Gets the turbulence octaves
*/
int octaves( ) const { return m_octaves; }
/**
* Gets the turbulence omega
*/
double omega( ) const { return m_omega; }
/**
* Gets the turbulence lambda
*/
double lambda( ) const { return m_lambda; }
/**
* Returns depth (only has meaning inside a normal)
*/
double depth( ) const { return m_depth; }
/**
* Sets the pattern type
*/
void setPatternType( PMPatternType l );
/**
* Sets agate turbulence
*/
void setAgateTurbulence( double c );
/**
* Sets the crackle form
*/
void setCrackleForm( const PMVector& v );
/**
* Sets the crackle metric
*/
void setCrackleMetric( int c );
/**
* Sets the crackle offset
*/
void setCrackleOffset( double c );
/**
* Sets the crackle solid flag
*/
void setCrackleSolid( bool c );
/**
* Sets the Density File Name
*/
void setDensityFile( const TQString& v );
/**
* Sets the density interpolation
*/
void setDensityInterpolate( int c );
/**
* sets gradient vector
*/
void setGradient( const PMVector& v );
/**
* Sets the complex number for Julia
*/
void setJuliaComplex( const PMVector& v );
/**
* Sets if where using magnet types of fractals
*/
void setFractalMagnet( bool c );
/**
* Sets the magnet type of a fractal
*/
void setFractalMagnetType( int c );
/**
* Sets the maximum iterations for fractals
*/
void setMaxIterations( int c );
/**
* Sets the exponent for fractals
*/
void setFractalExponent( int c );
/**
* Sets the exterior type of fractals
*/
void setFractalExtType( int c );
/**
* Sets the exterior factor of fractals
*/
void setFractalExtFactor( double c );
/**
* Sets the interior type of fractals
*/
void setFractalIntType( int c );
/**
* Sets the interior factor of fractals
*/
void setFractalIntFactor( double c );
/**
* Sets quilt control 0
*/
void setQuiltControl0( double c );
/**
* Sets quite control 1
*/
void setQuiltControl1( double c );
/**
* Sets the slope direction
*/
void setSlopeDirection( const PMVector& v );
/**
* Sets the low slope value
*/
void setSlopeLoSlope( double c );
/**
* Sets the high slope value
*/
void setSlopeHiSlope( double c );
/**
* Sets the slopes altitude flag
*/
void setSlopeAltFlag( bool c );
/**
* Sets the slopes alititude direction
*/
void setSlopeAltitude( const PMVector& v );
/**
* Sets the slopes low altitude
*/
void setSlopeLoAlt( double c );
/**
* Sets the slopes high altitude
*/
void setSlopeHiAlt( double c );
/**
* Sets the number of spiral arms
*/
void setSpiralNumberArms( int c );
/**
* Sets noise generator
*/
void setNoiseGenerator( PMNoiseType c );
/**
* Enables turbulence
*/
void enableTurbulence( bool c );
/**
* sets the turbulence vector
*/
void setValueVector( const PMVector& v );
/**
* Sets the turbulence octaves
*/
void setOctaves( int c );
/**
* Sets the turblence omega
*/
void setOmega( double c );
/**
* Sets the turbulence Lambda
*/
void setLambda( double c );
/**
* Sets the depth value (only inside normals)
*/
void setDepth( double c );
/** */
virtual void restoreMemento( PMMemento* s );
private:
/**
* IDs for @ref PMMementoData
*/
enum PMPatternMementoID { PMPatternTypeID, PMAgateTurbulenceID, PMCrackleFormID,
PMCrackleMetricID, PMCrackleOffsetID, PMCrackleSolidID,
PMDensityFileID, PMDensityInterpolateID, PMGradientID,
PMJuliaComplexID, PMFractalMagnetID, PMFractalMagnetTypeID,
PMMaxIterationsID, PMFractalExponentID, PMFractalExtTypeID,
PMFractalExtFactorID, PMFractalIntTypeID, PMFractalIntFactorID,
PMQuiltControl0ID, PMQuiltControl1ID, PMSlopeDirectionID,
PMSlopeLoSlopeID, PMSlopeHiSlopeID, PMSlopeAltFlagID,
PMSlopeAltitudeID, PMSlopeLoAltID, PMSlopeHiAltID,
PMSpiralNumberArmsID, PMNoiseGeneratorID, PMEnableTurbulenceID,
PMValueVectorID, PMOctavesID, PMOmegaID, PMLambdaID, PMDepthID };
/**
* Pattern type
*/
PMPatternType m_patternType;
// Extra values for Individual Patterns
// Agate
double m_agateTurbulence;
// crackle
PMVector m_crackleForm;
int m_crackleMetric;
double m_crackleOffset;
bool m_crackleSolid;
// density
TQString m_densityFile;
int m_densityInterpolate;
// gradient
PMVector m_gradient;
// Julia
PMVector m_juliaComplex;
// Fractal patterns Mandel and Julia
bool m_fractalMagnet;
int m_fractalMagnetType;
int m_maxIterations;
int m_fractalExponent;
int m_fractalExtType;
double m_fractalExtFactor;
int m_fractalIntType;
double m_fractalIntFactor;
// quilt
double m_quiltControl0;
double m_quiltControl1;
// slope
PMVector m_slopeDirection;
double m_slopeLoSlope;
double m_slopeHiSlope;
bool m_slopeAltFlag;
PMVector m_slopeAltitude;
double m_slopeLoAlt;
double m_slopeHiAlt;
// Spiral
int m_spiralNumberArms;
// noise generator type for Bozo, Bumps, Granite and Wrinkles.
PMNoiseType m_noiseGenerator;
// Turbulence available for all patterns
bool m_enableTurbulence;
PMVector m_valueVector;
int m_octaves;
double m_omega;
double m_lambda;
// depth when used with Normal
double m_depth;
static PMMetaObject* s_pMetaObject;
};
#endif