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

7214 lines
191 KiB

/*
**************************************************************************
description
--------------------
copyright : (C) 2000-2003 by Andreas Zehender
email : zehender@kde.org
**************************************************************************
**************************************************************************
* *
* 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 "pmpovrayparser.h"
#include <klocale.h>
#include <tqvaluelist.h>
#include "pmpart.h"
#include "pmscanner.h"
#include "pmtokens.h"
#include "pmcolor.h"
#include "pmallobjects.h"
#include "pmprototypemanager.h"
#include "pmxmlhelper.h"
PMPovrayParser::PMPovrayParser( PMPart* part, TQIODevice* dev )
: PMParser( part, dev )
{
init( );
}
PMPovrayParser::PMPovrayParser( PMPart* part, const TQByteArray& array )
: PMParser( part, array )
{
init( );
}
PMPovrayParser::~PMPovrayParser( )
{
if( m_pScanner )
delete m_pScanner;
}
void PMPovrayParser::init( )
{
m_pScanner = new PMScanner( m_pDevice );
m_consumedTokens = 0;
m_skippedComments.setAutoDelete( true );
m_bLastPMCommentEmpty = true;
}
void PMPovrayParser::nextToken( )
{
m_token = m_pScanner->nextToken( );
m_consumedTokens++;
setCurrentLine( m_pScanner->currentLine( ) );
if( ( m_token == SCANNER_ERROR_TOK ) || ( m_token == COMMENT_TOK )
|| ( m_token == LINE_COMMENT_TOK ) || ( m_token == PMNAME_TOK ) )
{
// create the objects (string) only if necessary
PMComment* c;
int lastCommentLine = -2;
TQString commentText;
while( ( m_token == SCANNER_ERROR_TOK ) || ( m_token == COMMENT_TOK )
|| ( m_token == LINE_COMMENT_TOK ) || ( m_token == PMNAME_TOK ) )
{
switch( m_token )
{
case SCANNER_ERROR_TOK:
printError( m_pScanner->error( ) );
lastCommentLine = -2;
break;
case LINE_COMMENT_TOK:
commentText = m_pScanner->sValue( );
if( lastCommentLine == ( m_pScanner->currentLine( ) - 1 ) )
{
c = m_skippedComments.last( );
if( c )
c->setText( c->text( ) + '\n' + commentText );
else
{
c = new PMComment( m_pPart, commentText );
m_skippedComments.append( c );
}
}
else
{
c = new PMComment( m_pPart, m_pScanner->sValue( ) );
m_skippedComments.append( c );
}
lastCommentLine = m_pScanner->currentLine( );
break;
case COMMENT_TOK:
c = new PMComment( m_pPart, m_pScanner->sValue( ) );
m_skippedComments.append( c );
lastCommentLine = -2;
break;
case PMNAME_TOK:
// Special comment
m_lastPMComment = m_pScanner->sValue( );
m_bLastPMCommentEmpty = false;
lastCommentLine = -2;
break;
default:
lastCommentLine = -2;
break;
}
m_token = m_pScanner->nextToken( );
m_consumedTokens++;
}
}
}
bool PMPovrayParser::isTrue( ) const
{
if( ( m_token == ON_TOK ) || ( m_token == TRUE_TOK ) || ( m_token == YES_TOK ) )
return true;
return false;
}
bool PMPovrayParser::isFalse( ) const
{
if( ( m_token == OFF_TOK ) || ( m_token == FALSE_TOK ) || ( m_token == NO_TOK ) )
return true;
return false;
}
void PMPovrayParser::topParse( )
{
nextToken( );
do
{
if( !parseChildObjects( 0 ) )
m_token = EOF_TOK;
if( m_token != EOF_TOK )
{
printUnexpected( m_pScanner->sValue( ) );
nextToken( );
}
}
while( m_token != EOF_TOK );
if( errors( ) || warnings( ) )
printMessage( PMMSpecialRawComment );
}
bool PMPovrayParser::parseBool( )
{
if( isFalse( ) )
{
nextToken( );
return false;
}
if( isTrue( ) )
{
nextToken( );
return true;
}
PMValue v;
if( parseNumericExpression( v, true ) )
{
switch( v.type( ) )
{
case PMVFloat:
return v.floatValue( ) > 0.0;
break;
case PMVVector:
return ( v.vector( ) )[0] > 0.0;
break;
default:
printError( i18n( "Boolean expression expected" ) );
break;
}
}
return true;
}
bool PMPovrayParser::parseChildObjects( PMCompositeObject* parent,
int max /* = -1 */ )
{
PMObject* child = 0;
bool finished = false;
bool error = false;
bool noChild = false;
int numParsed = 0;
do
{
if( !m_bLastPMCommentEmpty && parent )
{
if( parent->isA( "NamedObject" ) )
( ( PMNamedObject* ) parent )->setName( m_lastPMComment );
m_bLastPMCommentEmpty = true;
}
if( m_skippedComments.count( ) > 0 )
child = m_skippedComments.take( 0 );
else
{
child = 0;
noChild = false;
// some objects
switch( m_token )
{
case UNION_TOK:
case DIFFERENCE_TOK:
case INTERSECTION_TOK:
case MERGE_TOK:
child = new PMCSG( m_pPart );
error = !parseCSG( ( PMCSG* ) child );
break;
case BOX_TOK:
child = new PMBox( m_pPart );
error = !parseBox( ( PMBox* ) child );
break;
case SPHERE_TOK:
if( ( parent && ( parent->type( ) == "Blob" ) )
|| ( !parent && m_pTopParent
&& ( m_pTopParent->type( ) == "Blob" ) ) )
{
child = new PMBlobSphere( m_pPart );
error = !parseBlobSphere( ( PMBlobSphere* ) child );
}
else
{
child = new PMSphere( m_pPart );
error = !parseSphere( ( PMSphere* ) child );
}
break;
case CYLINDER_TOK:
if( ( parent && ( parent->type( ) == "Blob" ) )
|| ( !parent && m_pTopParent
&& ( m_pTopParent->type( ) == "Blob" ) ) )
{
child = new PMBlobCylinder( m_pPart );
error = !parseBlobCylinder( ( PMBlobCylinder* ) child );
}
else
{
child = new PMCylinder( m_pPart );
error = !parseCylinder( ( PMCylinder* ) child );
}
break;
case CONE_TOK:
child = new PMCone( m_pPart );
error = !parseCone( ( PMCone* ) child );
break;
case TORUS_TOK:
child = new PMTorus( m_pPart );
error = !parseTorus( ( PMTorus* ) child );
break;
case BLOB_TOK:
child = new PMBlob( m_pPart );
error = !parseBlob( ( PMBlob* ) child );
break;
case COMPONENT_TOK:
child = new PMBlobSphere( m_pPart );
error = !parseBlobComponent( ( PMBlobSphere* ) child );
break;
case HEIGHT_FIELD_TOK:
child = new PMHeightField( m_pPart );
error = !parseHeightField( ( PMHeightField* ) child );
break;
case TEXT_TOK:
child = new PMText( m_pPart );
error = !parseText( ( PMText* ) child );
break;
case JULIA_FRACTAL_TOK:
child = new PMJuliaFractal( m_pPart );
error = !parseJuliaFractal( ( PMJuliaFractal* ) child );
break;
case PLANE_TOK:
child = new PMPlane( m_pPart );
error = !parsePlane( ( PMPlane* ) child );
break;
case TQUADRIC_TOK:
case CUBIC_TOK:
case TQUARTIC_TOK:
case POLY_TOK:
child = new PMPolynom( m_pPart );
error = !parsePolynom( ( PMPolynom* ) child );
break;
case BICUBIC_PATCH_TOK:
child = new PMBicubicPatch( m_pPart );
error = !parseBicubicPatch( ( PMBicubicPatch* ) child );
break;
case DISC_TOK:
child = new PMDisc( m_pPart );
error = !parseDisc( ( PMDisc* ) child );
break;
case TRIANGLE_TOK:
case SMOOTH_TRIANGLE_TOK:
child = new PMTriangle( m_pPart );
error = !parseTriangle( ( PMTriangle* ) child );
break;
case LATHE_TOK:
child = new PMLathe( m_pPart );
error = !parseLathe( ( PMLathe* ) child );
break;
case PRISM_TOK:
child = new PMPrism( m_pPart );
error = !parsePrism( ( PMPrism* ) child );
break;
case SOR_TOK:
child = new PMSurfaceOfRevolution( m_pPart );
error = !parseSor( ( PMSurfaceOfRevolution* ) child );
break;
case SUPERELLIPSOID_TOK:
child = new PMSuperquadricEllipsoid( m_pPart );
error = !parseSqe( ( PMSuperquadricEllipsoid* ) child );
break;
case CAMERA_TOK:
child = new PMCamera( m_pPart );
error = !parseCamera( ( PMCamera* ) child );
break;
case LIGHT_SOURCE_TOK:
child = new PMLight( m_pPart );
error = !parseLight( ( PMLight* ) child );
break;
case LOOKS_LIKE_TOK:
child = new PMLooksLike( m_pPart );
error = !parseLooksLike( ( PMLooksLike* ) child );
break;
case PROJECTED_THROUGH_TOK:
child = new PMProjectedThrough( m_pPart );
error = !parseProjectedThrough( ( PMProjectedThrough* ) child );
break;
case TEXTURE_TOK:
child = new PMTexture( m_pPart );
error = !parseTexture( ( PMTexture* ) child );
break;
case AGATE_TOK:
case AVERAGE_TOK:
case BOXED_TOK:
case BOZO_TOK:
case BUMPS_TOK:
case CELLS_TOK:
case CRACKLE_TOK:
case CYLINDRICAL_TOK:
case DENTS_TOK:
case DENSITY_FILE_TOK:
case GRADIENT_TOK:
case GRANITE_TOK:
case JULIA_TOK:
case LEOPARD_TOK:
case MAGNET_TOK:
case MANDEL_TOK:
case MARBLE_TOK:
case ONION_TOK:
case PLANAR_TOK:
case TQUILTED_TOK:
case RADIAL_TOK:
case RIPPLES_TOK:
case SLOPE_TOK:
case SPHERICAL_TOK:
case SPIRAL1_TOK:
case SPIRAL2_TOK:
case SPOTTED_TOK:
case WOOD_TOK:
case WAVES_TOK:
case WRINKLES_TOK:
child = new PMPattern( m_pPart );
{
bool normal = true;
if( parent && ( parent->type( ) != "Normal" ) )
normal = false;
error = !parsePattern( ( PMPattern* ) child, normal );
}
break;
case TURBULENCE_TOK:
// Search for a PMPattern in the object's tqchildren
child = parent->firstChild( );
while( child && !child->isA( "Pattern" ) )
child = child->nextSibling( );
if( child )
{
error = !parsePattern( ( PMPattern* ) child );
child = 0;
noChild = true;
}
else
{
printError( i18n( "Found turbulence without a pattern." ) );
error = true;
}
break;
case FREQUENCY_TOK:
case PHASE_TOK:
case RAMP_WAVE_TOK:
case TRIANGLE_WAVE_TOK:
case SINE_WAVE_TOK:
case SCALLOP_WAVE_TOK:
case CUBIC_WAVE_TOK:
case POLY_WAVE_TOK:
// Search for a PMBlendMapModifiers in the object's tqchildren
child = parent->firstChild( );
while( child && !child->isA( "BlendMapModifiers" ) )
child = child->nextSibling( );
if( child )
{
error = !parseBlendMapModifiers( ( PMBlendMapModifiers* ) child );
child = 0;
noChild = 0;
}
else
{
child = new PMBlendMapModifiers( m_pPart );
error = !parseBlendMapModifiers( ( PMBlendMapModifiers* ) child );
}
break;
case WARP_TOK:
child = new PMWarp( m_pPart );
error = !parseWarp( ( PMWarp* ) child );
break;
case PIGMENT_TOK:
child = new PMPigment( m_pPart );
error = !parsePigment( ( PMPigment* ) child );
break;
case NORMAL_TOK:
child = new PMNormal( m_pPart );
error = !parseNormal( ( PMNormal* ) child );
break;
case NORMAL_MAP_TOK:
child = new PMNormalMap( m_pPart );
error = !parseNormalMap( ( PMNormalMap* ) child );
break;
case BUMP_MAP_TOK:
child = new PMBumpMap( m_pPart );
error = !parseBumpMap( ( PMBumpMap* ) child );
break;
case SLOPE_MAP_TOK:
child = new PMSlopeMap( m_pPart );
error = !parseSlopeMap( ( PMSlopeMap* ) child );
break;
case DENSITY_MAP_TOK:
child = new PMDensityMap( m_pPart );
error = !parseDensityMap( ( PMDensityMap* ) child );
break;
case TEXTURE_MAP_TOK:
child = new PMTextureMap( m_pPart );
error = !parseTextureMap( ( PMTextureMap* ) child );
break;
case MATERIAL_MAP_TOK:
child = new PMMaterialMap( m_pPart );
error = !parseMaterialMap( ( PMMaterialMap* ) child );
break;
case PIGMENT_MAP_TOK:
child = new PMPigmentMap( m_pPart );
error = !parsePigmentMap( ( PMPigmentMap* ) child );
break;
case COLOR_MAP_TOK:
case COLOUR_MAP_TOK:
child = new PMColorMap( m_pPart );
error = !parseColorMap( ( PMColorMap* ) child );
break;
case CHECKER_TOK:
case HEXAGON_TOK:
case BRICK_TOK:
{
bool normal = false;
double depth = 0.0;
int expect = 0;
PMListPattern::PMListType type = PMListPattern::ListPatternChecker;
if( parent && parent->type( ) == "Normal" )
normal = true;
else if( m_pTopParent && m_pTopParent->type( ) == "Normal" )
normal = true;
switch( m_token )
{
case CHECKER_TOK:
type = PMListPattern::ListPatternChecker;
expect = 2;
break;
case HEXAGON_TOK:
type = PMListPattern::ListPatternHexagon;
expect = 3;
break;
case BRICK_TOK:
type = PMListPattern::ListPatternBrick;
expect = 2;
break;
}
nextToken( );
if( normal )
{
child = new PMNormalList( m_pPart );
if( parseFloat( depth, true ) )
( ( PMNormalList* ) child )->setDepth( depth );
if( m_token == NORMAL_TOK )
error = !parseNormalList( ( PMNormalList* ) child, expect );
}
else
{
switch( m_token )
{
case COLOR_TOK:
case COLOUR_TOK:
case RGB_TOK:
case RGBT_TOK:
case RGBF_TOK:
case RGBFT_TOK:
case RED_TOK:
case GREEN_TOK:
case BLUE_TOK:
case TRANSMIT_TOK:
case FILTER_TOK:
case ID_TOK:
child = new PMColorList( m_pPart );
error = !parseColorList( ( PMColorList* ) child, expect );
break;
case PIGMENT_TOK:
child = new PMPigmentList( m_pPart );
error = !parsePigmentList( ( PMPigmentList* ) child, expect );
break;
case TEXTURE_TOK:
child = new PMTextureList( m_pPart );
error = !parseTextureList( ( PMTextureList* ) child, expect );
break;
case NORMAL_TOK:
child = new PMNormalList( m_pPart );
error = !parseNormalList( ( PMNormalList* ) child, expect );
break;
case DENSITY_TOK:
child = new PMDensityList( m_pPart );
error = !parseDensityList( ( PMDensityList* ) child, expect );
break;
default:
printError( i18n( "Invalid list member." ) );
error = true;
}
}
if( child )
{
( ( PMListPattern* ) child )->setListType( type );
int oldConsumed;
double num = 0;
PMVector vector;
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case MORTAR_TOK:
nextToken( );
if( !parseFloat( num ) )
return false;
( ( PMListPattern* ) child )->setMortar( num );
break;
case BRICK_SIZE_TOK:
nextToken( );
if( !parseVector( vector ) )
return false;
( ( PMListPattern* ) child )->setBrickSize( vector );
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
}
break;
}
case IMAGE_MAP_TOK:
child = new PMImageMap( m_pPart );
error = !parseImageMap( ( PMImageMap* ) child );
break;
case FINISH_TOK:
child = new PMFinish( m_pPart );
error = !parseFinish( ( PMFinish* ) child );
break;
case INTERIOR_TOK:
child = new PMInterior( m_pPart );
error = !parseInterior( ( PMInterior* ) child );
break;
case MEDIA_TOK:
child = new PMMedia( m_pPart );
error = !parseMedia( ( PMMedia* ) child );
break;
case DENSITY_TOK:
child = new PMDensity( m_pPart );
error = !parseDensity( ( PMDensity* ) child );
break;
case MATERIAL_TOK:
child = new PMMaterial( m_pPart );
error = !parseMaterial( ( PMMaterial* ) child );
break;
case SKY_SPHERE_TOK:
child = new PMSkySphere( m_pPart );
error = !parseSkySphere( ( PMSkySphere* ) child );
break;
case RAINBOW_TOK:
child = new PMRainbow( m_pPart );
error = !parseRainbow( ( PMRainbow* ) child );
break;
case FOG_TOK:
child = new PMFog( m_pPart );
error = !parseFog( ( PMFog* ) child );
break;
case GLOBAL_SETTINGS_TOK:
child = new PMGlobalSettings( m_pPart );
error = !parseGlobalSettings( ( PMGlobalSettings* ) child );
break;
case SCALE_TOK:
child = new PMScale( m_pPart );
error = !parseScale( ( PMScale* ) child );
break;
case ROTATE_TOK:
child = new PMRotate( m_pPart );
error = !parseRotate( ( PMRotate* ) child );
break;
case TRANSLATE_TOK:
child = new PMTranslate( m_pPart );
error = !parseTranslate( ( PMTranslate* ) child );
break;
case MATRIX_TOK:
child = new PMPovrayMatrix( m_pPart );
error = !parseMatrix( ( PMPovrayMatrix* ) child );
break;
case BOUNDED_BY_TOK:
if( parent && ( parent->type( ) == "ClippedBy" ) )
finished = true;
else
{
child = new PMBoundedBy( m_pPart );
error = !parseBoundedBy( ( PMBoundedBy* ) child );
}
break;
case CLIPPED_BY_TOK:
if( parent && ( parent->type( ) == "BoundedBy" ) )
finished = true;
else
{
child = new PMClippedBy( m_pPart );
error = !parseClippedBy( ( PMClippedBy* ) child );
}
break;
case ISOSURFACE_TOK:
child = new PMIsoSurface( m_pPart );
error = !parseIsoSurface( ( PMIsoSurface* ) child );
break;
case RADIOSITY_TOK:
child = new PMRadiosity( m_pPart );
error = !parseRadiosity( ( PMRadiosity* ) child );
break;
case PHOTONS_TOK:
if ( parent && ( parent->type( ) == "GlobalSettings" ) )
{
child = new PMGlobalPhotons( m_pPart );
error = !parseGlobalPhotons( ( PMGlobalPhotons* ) child );
}
else
{
child = new PMPhotons( m_pPart );
error =!parsePhotons( ( PMPhotons* ) child );
}
break;
case LIGHT_GROUP_TOK:
child = new PMLightGroup( m_pPart );
error = !parseLightGroup( ( PMLightGroup* ) child );
break;
case INTERIOR_TEXTURE_TOK:
child = new PMInteriorTexture( m_pPart );
error = !parseInteriorTexture( ( PMInteriorTexture* ) child );
break;
case SPHERE_SWEEP_TOK:
child = new PMSphereSweep( m_pPart );
error = !parseSphereSweep( ( PMSphereSweep* ) child );
break;
case MESH_TOK:
child = new PMMesh( m_pPart );
error = !parseMesh( ( PMMesh* ) child );
break;
case DECLARE_TOK:
nextToken( );
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
nextToken( );
if( !parseToken( '=' ) )
error = true;
else
{
PMValue v;
switch( m_token )
{
case OBJECT_TOK:
// finite solid
case BLOB_TOK:
case BOX_TOK:
case CONE_TOK:
case CYLINDER_TOK:
case HEIGHT_FIELD_TOK:
case JULIA_FRACTAL_TOK:
case LATHE_TOK:
case PRISM_TOK:
case SPHERE_TOK:
case SUPERELLIPSOID_TOK:
case SOR_TOK:
case TEXT_TOK:
case TORUS_TOK:
case ISOSURFACE_TOK:
case SPHERE_SWEEP_TOK:
// finite patch
case BICUBIC_PATCH_TOK:
case DISC_TOK:
case MESH_TOK:
case POLYGON_TOK:
case TRIANGLE_TOK:
case SMOOTH_TRIANGLE_TOK:
// infinite solid
case PLANE_TOK:
case TQUADRIC_TOK:
case CUBIC_TOK:
case TQUARTIC_TOK:
case POLY_TOK:
// csg
case UNION_TOK:
case INTERSECTION_TOK:
case DIFFERENCE_TOK:
case MERGE_TOK:
// textures
case TEXTURE_TOK:
case INTERIOR_TEXTURE_TOK:
case PIGMENT_TOK:
case NORMAL_TOK:
case FINISH_TOK:
case TEXTURE_MAP_TOK:
case PIGMENT_MAP_TOK:
case COLOR_MAP_TOK:
case COLOUR_MAP_TOK:
case NORMAL_MAP_TOK:
case SLOPE_MAP_TOK:
case DENSITY_MAP_TOK:
case INTERIOR_TOK:
case MEDIA_TOK:
case DENSITY_TOK:
case MATERIAL_TOK:
case SKY_SPHERE_TOK:
case RAINBOW_TOK:
case FOG_TOK:
// misc
case LIGHT_SOURCE_TOK:
case LIGHT_GROUP_TOK:
child = new PMDeclare( m_pPart );
error = !parseDeclare( ( PMDeclare* ) child );
break;
default:
// constant, vector or color declare?
if( parseNumericExpression( v ) )
{
checkID( id, v );
noChild = true;
}
else
error = true;
break;
}
}
if( child )
if( child->isA( "Declare" ) )
( ( PMDeclare* ) child )->setID( id );
if( m_token == ';' )
nextToken( );
}
else
printExpected( i18n( "identifier" ), m_pScanner->sValue( ) );
break;
case OBJECT_TOK:
error = !parseObject( parent );
noChild = true;
break;
case RAW_POVRAY_TOK:
child = new PMRaw( m_pPart, m_pScanner->sValue( ) );
error = false;
nextToken( );
break;
default:
finished = true;
break;
}
}
if( !finished && !child && !noChild )
error = true;
if( child )
{
if( !insertChild( child, parent ) )
{
delete child;
child = 0;
}
else if( child->isA( "Declare" ) )
checkID( ( PMDeclare* ) child );
numParsed ++;
if( ( max > 0 ) && ( numParsed >= max ) )
finished = true;
}
}
while( !finished && !error );
return finished;
}
bool PMPovrayParser::parseToken( int t, const TQString& tokenName )
{
if( t == ',' )
{
// do not require commas any more.
if( m_token == ',' )
nextToken( );
return true;
}
else if( m_token == t )
{
nextToken( );
return true;
}
if( tokenName.isNull() )
printExpected( ( char ) t, m_pScanner->sValue( ) );
else
printExpected( tokenName, m_pScanner->sValue( ) );
return false;
}
bool PMPovrayParser::parseNumericItem( PMValue& v, bool checkForBool /*=false*/ )
{
bool finishColor = false;
PMVector cv( 0 );
PMVector vec( 0 );
PMValue hv;
PMSymbol* s;
int i;
switch( m_token )
{
case X_TOK:
v.setVector( PMVector( 1.0, 0.0, 0.0 ) );
nextToken( );
break;
case Y_TOK:
v.setVector( PMVector( 0.0, 1.0, 0.0 ) );
nextToken( );
break;
case Z_TOK:
v.setVector( PMVector( 0.0, 0.0, 1.0 ) );
nextToken( );
break;
case T_TOK:
v.setVector( PMVector( 0.0, 0.0, 0.0, 1.0 ) );
nextToken( );
break;
case U_TOK:
v.setVector( PMVector( 1.0, 0.0 ) );
nextToken( );
break;
case V_TOK:
v.setVector( PMVector( 0.0, 1.0 ) );
nextToken( );
break;
case PI_TOK:
v.setFloat( 3.1415926535897932384626 );
nextToken( );
break;
case CLOCK_TOK:
printMessage( PMMClockDefault );
v.setFloat( 0.0 );
break;
case CLOCK_DELTA_TOK:
printMessage( PMMClockDeltaDefault );
v.setFloat( 1.0 );
break;
case FLOAT_TOK:
v.setFloat( m_pScanner->fValue( ) );
nextToken( );
break;
case INTEGER_TOK:
v.setFloat( ( double ) m_pScanner->iValue( ) );
nextToken( );
break;
case ON_TOK:
case TRUE_TOK:
case YES_TOK:
v.setFloat( 1.0 );
nextToken( );
break;
case OFF_TOK:
case FALSE_TOK:
case NO_TOK:
v.setFloat( 0.0 );
nextToken( );
break;
case '(':
nextToken( );
if( !parseNumericExpression( v ) )
return false;
if( !parseToken( ')' ) )
return false;
break;
case '-':
nextToken( );
if( !parseNumericItem( v ) )
return false;
if( v.type( ) == PMVFloat )
v.setFloat( -v.floatValue( ) );
else
v.setVector( -v.vector( ) );
break;
case '+':
nextToken( );
if( !parseNumericItem( v ) )
return false;
break;
case '<':
if( !parseVectorLiteral( vec ) )
return false;
v.setVector( vec );
break;
case COLOR_TOK:
case COLOUR_TOK:
nextToken( );
case RGB_TOK:
case RGBT_TOK:
case RGBF_TOK:
case RGBFT_TOK:
case RED_TOK:
case GREEN_TOK:
case BLUE_TOK:
case TRANSMIT_TOK:
case FILTER_TOK:
cv.resize( 5 );
cv = 0.0;
finishColor = true;
break;
case ID_TOK:
s = getSymbol( m_pScanner->sValue( ) );
if( s )
{
nextToken( );
if( s->type( ) == PMSymbol::Value )
v = s->value( );
else
{
printError( i18n( "Float, color or vector identifier expected." ) );
return false;
}
}
else
{
printError( i18n( "Undefined identifier \"%1\"." )
.tqarg( m_pScanner->sValue( ) ) );
nextToken( );
}
break;
default:
if( !checkForBool )
printUnexpected( m_pScanner->sValue( ) );
return false;
break;
}
if( !finishColor )
{
if( m_token == '.' )
{
int index = -1;
nextToken( );
switch( m_token )
{
case X_TOK:
case RED_TOK:
case U_TOK:
index = 0;
break;
case Y_TOK:
case GREEN_TOK:
case V_TOK:
index = 1;
break;
case Z_TOK:
case BLUE_TOK:
index = 2;
break;
case T_TOK:
case FILTER_TOK:
index = 3;
break;
case TRANSMIT_TOK:
index = 4;
break;
default:
break;
}
if( index >= 0 )
{
nextToken( );
if( v.type( ) == PMVFloat )
{
if( index != 0 )
index = -1;
}
else
{
PMVector vec;
if( v.type( ) == PMVVector )
vec = v.vector( );
else
vec = v.color( );
if( ( ( unsigned ) index ) < vec.size( ) )
v.setFloat( vec[index] );
else
index = -1;
}
}
if( index == -1 )
{
printError( i18n( "Bad operands for period operator." ) );
return false;
}
}
}
while( finishColor )
{
switch( m_token )
{
case RGB_TOK:
nextToken( );
if( !parseNumericExpression( hv ) )
return false;
switch( hv.type( ) )
{
case PMVFloat:
cv[0] = hv.floatValue( );
cv[1] = hv.floatValue( );
cv[2] = hv.floatValue( );
break;
case PMVVector:
vec = hv.vector( );
vec.resize( 3 );
cv[0] = vec[0];
cv[1] = vec[1];
cv[2] = vec[2];
break;
default:
printError( i18n( "Float or vector expression expected" ) );
break;
}
break;
case RGBT_TOK:
nextToken( );
if( !parseNumericExpression( hv ) )
return false;
switch( hv.type( ) )
{
case PMVFloat:
cv[0] = hv.floatValue( );
cv[1] = hv.floatValue( );
cv[2] = hv.floatValue( );
cv[4] = hv.floatValue( );
break;
case PMVVector:
vec = hv.vector( );
vec.resize( 4 );
cv[0] = vec[0];
cv[1] = vec[1];
cv[2] = vec[2];
cv[4] = vec[3];
break;
default:
printError( i18n( "Float or vector expression expected" ) );
break;
}
break;
case RGBF_TOK:
nextToken( );
if( !parseNumericExpression( hv ) )
return false;
switch( hv.type( ) )
{
case PMVFloat:
cv[0] = hv.floatValue( );
cv[1] = hv.floatValue( );
cv[2] = hv.floatValue( );
cv[3] = hv.floatValue( );
break;
case PMVVector:
vec = hv.vector( );
vec.resize( 4 );
cv[0] = vec[0];
cv[1] = vec[1];
cv[2] = vec[2];
cv[3] = vec[3];
break;
default:
printError( i18n( "Float or vector expression expected" ) );
break;
}
break;
case RGBFT_TOK:
nextToken( );
if( !parseNumericExpression( hv ) )
return false;
switch( hv.type( ) )
{
case PMVFloat:
cv = hv.floatValue( );
break;
case PMVVector:
vec = hv.vector( );
vec.resize( 5 );
cv = vec;
break;
default:
printError( i18n( "Float or vector expression expected" ) );
break;
}
break;
case RED_TOK:
nextToken( );
parseNumericExpression( hv );
if( hv.type( ) != PMVFloat )
{
printError( i18n( "Float expression expected" ) );
break;
}
cv[0] = hv.floatValue( );
break;
case GREEN_TOK:
nextToken( );
parseNumericExpression( hv );
if( hv.type( ) != PMVFloat )
{
printError( i18n( "Float expression expected" ) );
break;
}
cv[1] = hv.floatValue( );
break;
case BLUE_TOK:
nextToken( );
parseNumericExpression( hv );
if( hv.type( ) != PMVFloat )
{
printError( i18n( "Float expression expected" ) );
break;
}
cv[2] = hv.floatValue( );
break;
case FILTER_TOK:
case ALPHA_TOK:
nextToken( );
parseNumericExpression( hv );
if( hv.type( ) != PMVFloat )
{
printError( i18n( "Float expression expected" ) );
break;
}
cv[3] = hv.floatValue( );
break;
case TRANSMIT_TOK:
nextToken( );
parseNumericExpression( hv );
if( hv.type( ) != PMVFloat )
{
printError( i18n( "Float expression expected" ) );
break;
}
cv[4] = hv.floatValue( );
break;
case ID_TOK:
if( parseNumericItem( hv ) )
{
if( hv.type( ) == PMVFloat )
{
for( i = 0; i < 5; i++ )
cv[i] = hv.floatValue( );
}
else if( hv.type( ) == PMVVector )
{
cv = hv.vector( );
cv.resize( 5 );
}
else
cv = hv.color( );
}
break;
default:
finishColor = false;
v.setColor( cv );
break;
}
}
return true;
}
bool PMPovrayParser::parseVectorLiteral( PMVector& p )
{
PMValue v;
if( !parseToken( '<' ) )
return false;
if( !parseNumericExpression( v ) )
return false;
if( v.type( ) != PMVFloat )
{
printError( i18n( "Float expression expected" ) );
return false;
}
p.resize( 1 );
p[0] = v.floatValue( );
while( m_token != '>' )
{
// many old scenes do not use a comma between values
if( m_token == ',' )
nextToken( );
// parseToken( ',' );
if( !parseNumericExpression( v ) )
return false;
if( v.type( ) != PMVFloat )
{
printError( i18n( "Float expression expected" ) );
return false;
}
p.resize( p.size( ) + 1 );
p[p.size( ) - 1] = v.floatValue( );
}
/** old code
while( m_token == ',' )
{
nextToken( );
if( !parseNumericExpression( v ) )
return false;
if( v.type( ) != PMVFloat )
{
printError( i18n( "Float expression expected" ) );
return false;
}
p.resize( p.size( ) + 1 );
p[p.size( ) - 1] = v.floatValue( );
}
*/
if( !parseToken( '>' ) )
return false;
return true;
}
bool PMPovrayParser::parseNumericExpression( PMValue& v, bool checkForBool /*=false*/ )
{
bool end = false;
PMValue v2;
PMVector hv( 0 );
if( !parseNumericItem( v, checkForBool ) )
return false;
do
{
switch( m_token )
{
case '*':
nextToken( );
if( !parseNumericItem( v2 ) )
break;
switch( v.type( ) )
{
case PMVFloat:
switch( v2.type( ) )
{
case PMVFloat:
v.setFloat( v.floatValue( ) * v2.floatValue( ) );
break;
case PMVVector:
v.setVector( v2.vector( ) * v.floatValue( ) );
break;
case PMVColor:
v.setColor( v2.color( ) * v.floatValue( ) );
break;
}
break;
case PMVVector:
switch( v2.type( ) )
{
case PMVFloat:
v.setVector( v.vector( ) * v2.floatValue( ) );
break;
case PMVVector:
v.setVector( v.vector( ) * v2.vector( ) );
break;
case PMVColor:
if( v.vector( ).size( ) == 5 )
v.setColor( v.vector( ) * v2.color( ) );
else
printError( i18n( "You can't multiply a vector with a color" ) );
break;
}
break;
case PMVColor:
switch( v2.type( ) )
{
case PMVFloat:
v.setColor( v.color( ) * v2.floatValue( ) );
break;
case PMVVector:
if( v2.vector( ).size( ) == 5 )
v.setColor( v2.vector( ) * v.color( ) );
else
printError( i18n( "You can't multiply a vector with a color" ) );
break;
case PMVColor:
v.setColor( v.color( ) * v2.color( ) );
break;
}
break;
}
break;
case '/':
nextToken( );
if( !parseNumericItem( v2 ) )
break;
switch( v.type( ) )
{
case PMVFloat:
switch( v2.type( ) )
{
case PMVFloat:
v.setFloat( v.floatValue( ) / v2.floatValue( ) );
break;
case PMVVector:
hv.resize( v2.vector( ).size( ) );
hv = v.floatValue( );
v.setVector( hv / v2.vector( ) );
break;
case PMVColor:
hv.resize( 5 );
hv = v.floatValue( );
v.setColor( hv / v.floatValue( ) );
break;
}
break;
case PMVVector:
switch( v2.type( ) )
{
case PMVFloat:
v.setVector( v.vector( ) / v2.floatValue( ) );
break;
case PMVVector:
v.setVector( v.vector( ) / v2.vector( ) );
break;
case PMVColor:
if( v.vector( ).size( ) == 5 )
v.setColor( v.vector( ) / v2.color( ) );
else
printError( i18n( "You can't divide a vector by a color" ) );
break;
}
break;
case PMVColor:
switch( v2.type( ) )
{
case PMVFloat:
v.setColor( v.color( ) / v2.floatValue( ) );
break;
case PMVVector:
if( v2.vector( ).size( ) == 5 )
v.setColor( v2.vector( ) / v.color( ) );
else
printError( i18n( "You can't divide a color by a vector" ) );
break;
case PMVColor:
v.setColor( v.color( ) / v2.color( ) );
break;
}
break;
}
break;
case '+':
nextToken( );
if( !parseNumericExpression( v2 ) )
break;
switch( v.type( ) )
{
case PMVFloat:
switch( v2.type( ) )
{
case PMVFloat:
v.setFloat( v.floatValue( ) + v2.floatValue( ) );
break;
case PMVVector:
v.setVector( v2.vector( ) + v.floatValue( ) );
break;
case PMVColor:
v.setColor( v2.color( ) + v.floatValue( ) );
break;
}
break;
case PMVVector:
switch( v2.type( ) )
{
case PMVFloat:
v.setVector( v.vector( ) + v2.floatValue( ) );
break;
case PMVVector:
v.setVector( v.vector( ) + v2.vector( ) );
break;
case PMVColor:
if( v.vector( ).size( ) == 5 )
v.setColor( v.vector( ) + v2.color( ) );
else
printError( i18n( "You can't add a vector and a color" ) );
break;
}
break;
case PMVColor:
switch( v2.type( ) )
{
case PMVFloat:
v.setColor( v.color( ) + v2.floatValue( ) );
break;
case PMVVector:
if( v2.vector( ).size( ) == 5 )
v.setColor( v2.vector( ) + v.color( ) );
else
printError( i18n( "You can't add a vector with a color" ) );
break;
case PMVColor:
v.setColor( v.color( ) + v2.color( ) );
break;
}
break;
}
break;
case '-':
nextToken( );
if( !parseNumericExpression( v2 ) )
break;
switch( v.type( ) )
{
case PMVFloat:
switch( v2.type( ) )
{
case PMVFloat:
v.setFloat( v.floatValue( ) - v2.floatValue( ) );
break;
case PMVVector:
v.setVector( v2.vector( ) - v.floatValue( ) );
break;
case PMVColor:
v.setColor( v2.color( ) - v.floatValue( ) );
break;
}
break;
case PMVVector:
switch( v2.type( ) )
{
case PMVFloat:
v.setVector( v.vector( ) - v2.floatValue( ) );
break;
case PMVVector:
v.setVector( v.vector( ) - v2.vector( ) );
break;
case PMVColor:
if( v.vector( ).size( ) == 5 )
v.setColor( v.vector( ) - v2.color( ) );
else
printError( i18n( "You can't subtract a vector and a color" ) );
break;
}
break;
case PMVColor:
switch( v2.type( ) )
{
case PMVFloat:
v.setColor( v.color( ) - v2.floatValue( ) );
break;
case PMVVector:
if( v2.vector( ).size( ) == 5 )
v.setColor( v2.vector( ) - v.color( ) );
else
printError( i18n( "You can't subtract a vector and a color" ) );
break;
case PMVColor:
v.setColor( v.color( ) - v2.color( ) );
break;
}
break;
}
break;
default:
end = true;
break;
}
}
while( !end );
return true;
}
bool PMPovrayParser::parseVector( PMVector& vector, unsigned int size )
{
PMValue v;
unsigned int i;
if( !parseNumericExpression( v ) )
return false;
switch( v.type( ) )
{
case PMVFloat:
vector.resize( size );
for( i = 0; i < size; i++ )
vector[i] = v.floatValue( );
break;
case PMVVector:
vector = v.vector( );
vector.resize( size );
break;
default:
printError( i18n( "Float or vector expression expected" ) );
return false;
}
return true;
}
bool PMPovrayParser::parseFloat( double& d, bool suppressError )
{
PMValue v;
if( !parseNumericExpression( v, suppressError ) )
return false;
switch( v.type( ) )
{
case PMVFloat:
d = v.floatValue( );
break;
case PMVVector:
d = ( v.vector( ) )[0];
break;
default:
printError( i18n( "Float expression expected" ) );
return false;
}
return true;
}
bool PMPovrayParser::parseInt( int& i )
{
double d;
if( !parseFloat( d ) )
return false;
i = ( int ) ( d + 0.5 );
return true;
}
bool PMPovrayParser::parseColor( PMColor& c )
{
PMValue v;
if( !parseNumericExpression( v ) )
return false;
if( v.type( ) == PMVColor )
c = PMColor( v.color( ) );
else if( v.type( ) == PMVVector )
{
if( v.vector( ).size( ) == 5 )
c = PMColor( v.vector( ) );
else
{
printError( i18n( "Color expression expected" ) );
return false;
}
}
else if( v.type( ) == PMVFloat )
{
double d = v.floatValue( );
c = PMColor( d, d, d, d, d );
}
else
{
printError( i18n( "Color expression expected" ) );
return false;
}
return true;
}
bool PMPovrayParser::parseObjectModifiers( PMGraphicalObject* o )
{
bool finished = false;
PMSolidObject* so = 0;
if( o->isA( "SolidObject" ) )
so = ( PMSolidObject* ) o;
do
{
finished = true;
switch( m_token )
{
case NO_SHADOW_TOK:
o->setNoShadow( true );
nextToken( );
finished = false;
break;
case NO_IMAGE_TOK:
o->setNoImage( true );
nextToken( );
finished = false;
break;
case NO_REFLECTION_TOK:
o->setNoReflection( true );
nextToken( );
finished = false;
break;
case DOUBLE_ILLUMINATE_TOK:
o->setDoubleIlluminate( true );
nextToken( );
finished = false;
break;
default:
break;
}
if( so )
{
switch( m_token )
{
case HOLLOW_TOK:
so->setHollow( PMTrue );
nextToken( );
if( isTrue( ) )
nextToken( );
else if( isFalse( ) )
{
nextToken( );
so->setHollow( PMFalse );
}
finished = false;
break;
case INVERSE_TOK:
so->setInverse( true );
nextToken( );
finished = false;
break;
default:
break;
}
}
}
while( !finished );
return true;
}
bool PMPovrayParser::parseCSG( PMCSG* pNewCSG )
{
int oldConsumed;
switch( m_token )
{
case UNION_TOK:
pNewCSG->setCSGType( PMCSG::CSGUnion );
break;
case INTERSECTION_TOK:
pNewCSG->setCSGType( PMCSG::CSGIntersection );
break;
case DIFFERENCE_TOK:
pNewCSG->setCSGType( PMCSG::CSGDifference );
break;
case MERGE_TOK:
pNewCSG->setCSGType( PMCSG::CSGMerge );
break;
default:
printUnexpected( m_pScanner->sValue( ) );
return false;
break;
}
nextToken( );
if( !parseToken( '{' ) )
return false;
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewCSG );
parseObjectModifiers( pNewCSG );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseBox( PMBox* pNewBox )
{
PMVector vector;
int oldConsumed;
if( !parseToken( BOX_TOK, "box" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewBox->setCorner1( vector );
if( !parseToken( ',' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewBox->setCorner2( vector );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewBox );
parseObjectModifiers( pNewBox );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseSphere( PMSphere* pNewSphere )
{
PMVector vector;
double radius;
int oldConsumed;
if( !parseToken( SPHERE_TOK, "sphere" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewSphere->setCentre( vector );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( radius ) )
return false;
pNewSphere->setRadius( radius );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewSphere );
parseObjectModifiers( pNewSphere );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseCylinder( PMCylinder* pNewCyl )
{
PMVector vector;
double radius;
int oldConsumed;
if( !parseToken( CYLINDER_TOK, "cylinder" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewCyl->setEnd1( vector );
if( !parseToken( ',' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewCyl->setEnd2( vector );
if( !parseToken( ',' ) )
return false;
if( !parseFloat(radius) )
return false;
pNewCyl->setRadius( radius );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewCyl );
parseObjectModifiers( pNewCyl );
switch( m_token )
{
case OPEN_TOK:
nextToken( );
pNewCyl->setOpen( true );
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseCone( PMCone* pNewCone )
{
PMVector vector;
double radius;
int oldConsumed;
if( !parseToken( CONE_TOK, "cone" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewCone->setEnd1( vector );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( radius ) )
return false;
pNewCone->setRadius1( radius );
if( !parseToken( ',' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewCone->setEnd2( vector );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( radius ) )
return false;
pNewCone->setRadius2( radius );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewCone );
parseObjectModifiers( pNewCone );
switch( m_token )
{
case OPEN_TOK:
nextToken( );
pNewCone->setOpen( true );
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseTorus( PMTorus* pNewTorus )
{
double radius;
int oldConsumed;
if( !parseToken( TORUS_TOK, "torus" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseFloat( radius ) )
return false;
pNewTorus->setMajorRadius( radius );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( radius ) )
return false;
pNewTorus->setMinorRadius( radius );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewTorus );
parseObjectModifiers( pNewTorus );
switch( m_token )
{
case STURM_TOK:
nextToken( );
pNewTorus->setSturm( true );
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseBlob( PMBlob* pNewBlob )
{
PMVector vector;
double threshold;
int oldConsumed;
if( !parseToken( BLOB_TOK, "blob" ) )
return false;
if( !parseToken( '{' ) )
return false;
pNewBlob->setThreshold( 1.0 );
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case STURM_TOK:
nextToken( );
pNewBlob->setSturm( true );
break;
case HIERARCHY_TOK:
pNewBlob->setHierarchy( true );
nextToken( );
if( isTrue( ) )
nextToken( );
else if( isFalse( ) )
{
nextToken( );
pNewBlob->setHierarchy( false );
}
break;
case THRESHOLD_TOK:
nextToken( );
if( parseFloat( threshold ) )
{
if( threshold <= 0 )
printError( i18n( "The threshold value has to be positive" ) );
else
pNewBlob->setThreshold( threshold );
}
break;
}
parseChildObjects( pNewBlob );
parseObjectModifiers( pNewBlob );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseBlobSphere( PMBlobSphere* pNewBlobSphere )
{
PMVector vector;
double radius;
double strength;
int oldConsumed;
if( !parseToken( SPHERE_TOK, "sphere" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewBlobSphere->setCentre( vector );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( radius ) )
return false;
pNewBlobSphere->setRadius( radius );
if( !parseToken( ',' ) )
return false;
if( m_token == STRENGTH_TOK )
nextToken( );
if( !parseFloat( strength ) )
return false;
pNewBlobSphere->setStrength( strength );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewBlobSphere );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseBlobComponent( PMBlobSphere* pNewBlobSphere )
{
PMVector vector;
double radius;
double strength;
if( !parseToken( COMPONENT_TOK, "component" ) )
return false;
if( !parseFloat( strength ) )
return false;
pNewBlobSphere->setStrength( strength );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( radius ) )
return false;
pNewBlobSphere->setRadius( radius );
if( !parseToken( ',' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewBlobSphere->setCentre( vector );
return true;
}
bool PMPovrayParser::parseBlobCylinder( PMBlobCylinder* pNewBlobCylinder )
{
PMVector vector;
double radius;
double strength;
int oldConsumed;
if( !parseToken( CYLINDER_TOK, "cylinder" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewBlobCylinder->setEnd1( vector );
if( !parseToken( ',' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewBlobCylinder->setEnd2( vector );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( radius ) )
return false;
pNewBlobCylinder->setRadius( radius );
if( !parseToken( ',' ) )
return false;
if( m_token == STRENGTH_TOK )
nextToken( );
if( !parseFloat( strength ) )
return false;
pNewBlobCylinder->setStrength( strength );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewBlobCylinder );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseHeightField( PMHeightField* pNewHeightField )
{
int oldConsumed;
double wl;
if( !parseToken( HEIGHT_FIELD_TOK, "height_field" ) )
return false;
if( !parseToken( '{' ) )
return false;
switch( m_token )
{
case GIF_TOK:
pNewHeightField->setHeightFieldType( PMHeightField::HFgif );
nextToken( );
break;
case TGA_TOK:
pNewHeightField->setHeightFieldType( PMHeightField::HFtga );
nextToken( );
break;
case POT_TOK:
pNewHeightField->setHeightFieldType( PMHeightField::HFpot );
nextToken( );
break;
case PNG_TOK:
pNewHeightField->setHeightFieldType( PMHeightField::HFpng );
nextToken( );
break;
case PGM_TOK:
pNewHeightField->setHeightFieldType( PMHeightField::HFpgm );
nextToken( );
break;
case PPM_TOK:
pNewHeightField->setHeightFieldType( PMHeightField::HFppm );
nextToken( );
break;
case SYS_TOK:
pNewHeightField->setHeightFieldType( PMHeightField::HFsys );
nextToken( );
break;
default:
printExpected( i18n( "height field type" ), m_pScanner->sValue( ) );
return false;
}
if( m_token != STRING_TOK )
{
printExpected( i18n( "height field file" ), m_pScanner->sValue( ) );
return false;
}
else
{
pNewHeightField->setFileName( m_pScanner->sValue( ) );
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case SMOOTH_TOK:
nextToken( );
pNewHeightField->setSmooth( true );
if( isTrue( ) )
nextToken( );
else if( isFalse( ) )
{
nextToken( );
pNewHeightField->setSmooth( false );
}
break;
case HIERARCHY_TOK:
pNewHeightField->setHierarchy( true );
nextToken( );
if( isTrue( ) )
nextToken( );
else if( isFalse( ) )
{
nextToken( );
pNewHeightField->setHierarchy( false );
}
break;
case WATER_LEVEL_TOK:
nextToken( );
if( parseFloat( wl ) )
{
if( ( wl < 0.0 ) || ( wl > 1.0 ) )
printError( i18n( "The water level has to be between 0 and 1" ) );
else
pNewHeightField->setWaterLevel( wl );
}
break;
}
parseChildObjects( pNewHeightField );
parseObjectModifiers( pNewHeightField );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseText( PMText* pNewText )
{
int oldConsumed;
double thickness;
PMVector offset;
if( !parseToken( TEXT_TOK, "text" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseToken( TTF_TOK, "ttf" ) )
return false;
if( m_token != STRING_TOK )
{
printExpected( i18n( "font file name" ), m_pScanner->sValue( ) );
return false;
}
else
{
pNewText->setFont( m_pScanner->sValue( ) );
nextToken( );
}
if( m_token != STRING_TOK )
{
printExpected( i18n( "string of text" ), m_pScanner->sValue( ) );
return false;
}
else
{
pNewText->setText( m_pScanner->sValue( ) );
nextToken( );
}
if( !parseFloat( thickness ) )
return false;
pNewText->setThickness( thickness );
parseToken( ',' );
if( parseVector( offset, 2 ) )
pNewText->setOffset( offset );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewText );
parseObjectModifiers( pNewText );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseJuliaFractal( PMJuliaFractal* pNewFractal )
{
int oldConsumed;
double d;
int i;
PMVector v( 4 ), v2( 2 );
if( !parseToken( JULIA_FRACTAL_TOK, "julia_fractal" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( v, 4 ) )
return false;
pNewFractal->setJuliaParameter( v );
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case TQUATERNION_TOK:
pNewFractal->setAlgebraType( PMJuliaFractal::Quaternion );
nextToken( );
break;
case HYPERCOMPLEX_TOK:
pNewFractal->setAlgebraType( PMJuliaFractal::Hypercomplex );
nextToken( );
break;
case STQR_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTsqr );
nextToken( );
break;
case CUBE_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTcube );
nextToken( );
break;
case EXP_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTexp );
nextToken( );
break;
case RECIPROCAL_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTreciprocal );
nextToken( );
break;
case SIN_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTsin );
nextToken( );
break;
case ASIN_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTasin );
nextToken( );
break;
case SINH_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTsinh );
nextToken( );
break;
case ASINH_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTasinh );
nextToken( );
break;
case COS_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTcos );
nextToken( );
break;
case ACOS_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTacos );
nextToken( );
break;
case COSH_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTcosh );
nextToken( );
break;
case ACOSH_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTacosh );
nextToken( );
break;
case TAN_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTtan );
nextToken( );
break;
case ATAN_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTatan );
nextToken( );
break;
case TANH_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTtanh );
nextToken( );
break;
case ATANH_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTatanh );
nextToken( );
break;
case LOG_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTlog );
nextToken( );
break;
case PWR_TOK:
pNewFractal->setFunctionType( PMJuliaFractal::FTpwr );
nextToken( );
if( !parseToken( '(' ) )
return false;
if( !parseFloat( v2[0] ) )
return false;
parseToken( ',' );
if( !parseFloat( v2[1] ) )
return false;
if( !parseToken( ')' ) )
return false;
pNewFractal->setExponent( v2 );
break;
case MAX_ITERATION_TOK:
nextToken( );
if( !parseInt( i ) )
return false;
if( i <= 0 )
{
printWarning( i18n( "Maximum iterations are less than 1, fixed" ) );
i = 1;
}
pNewFractal->setMaximumIterations( i );
break;
case PRECISION_TOK:
nextToken( );
if( !parseFloat( d ) )
return false;
if( d < 1.0 )
{
printWarning( i18n( "Precision is less than 1.0, fixed" ) );
d = 1.0;
}
pNewFractal->setPrecision( d );
break;
case SLICE_TOK:
nextToken( );
if( !parseVector( v, 4 ) )
return false;
pNewFractal->setSliceNormal( v );
parseToken( ',' );
if( !parseFloat( d ) )
return false;
pNewFractal->setSliceDistance( d );
break;
}
parseChildObjects( pNewFractal );
parseObjectModifiers( pNewFractal );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parsePlane( PMPlane* pNewPlane )
{
double dist;
PMVector vector;
int oldConsumed;
if( !parseToken( PLANE_TOK, "plane" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewPlane->setNormal( vector );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( dist ) )
return false;
pNewPlane->setDistance( dist );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewPlane );
parseObjectModifiers( pNewPlane );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
const int c_polynomSize[8] = { 0, 0, 10, 20, 35, 56, 84, 120 };
bool PMPovrayParser::parsePolynom( PMPolynom* pNewPoly )
{
PMVector vector;
double d;
PMVector c;
int oldConsumed;
int order = 2;
int type = m_token;
pNewPoly->setSturm( false );
if( ( m_token == TQUADRIC_TOK ) || ( m_token == CUBIC_TOK ) ||
( m_token == TQUARTIC_TOK ) || ( m_token == POLY_TOK ) )
{
nextToken( );
if( !parseToken( '{' ) )
return false;
}
else
printExpected( "poly", m_pScanner->sValue( ) );
if( type == TQUADRIC_TOK )
{
c = PMVector( 10 );
pNewPoly->setPolynomOrder( 2 );
// parse the quadric coefficients
if( !parseVectorLiteral( vector ) )
return false;
vector.resize( 3 );
c[0] = vector[0];
c[4] = vector[1];
c[7] = vector[2];
parseToken( ',' );
if( !parseVectorLiteral( vector ) )
return false;
vector.resize( 3 );
c[1] = vector[0];
c[2] = vector[1];
c[5] = vector[2];
parseToken( ',' );
if( !parseVectorLiteral( vector ) )
return false;
vector.resize( 3 );
c[3] = vector[0];
c[6] = vector[1];
c[8] = vector[2];
parseToken( ',' );
if( !parseFloat( d ) )
return false;
c[9] = d;
pNewPoly->setCoefficients( c );
}
else
{
if( type == CUBIC_TOK )
order = 3;
else if( type == TQUARTIC_TOK )
order = 4;
else
{
if( !parseInt( order ) )
return false;
if( ( order < 2 ) || ( order > 7 ) )
{
printError( i18n( "The polynom order has to be between 2 and 7 inclusive" ) );
return false;
}
parseToken( ',' );
}
pNewPoly->setPolynomOrder( order );
if( !parseVectorLiteral( vector ) )
return false;
if( vector.size( ) != ( unsigned ) c_polynomSize[order] )
{
printError( i18n( "%1 coefficients are needed for a polynom with order %2" )
.tqarg( c_polynomSize[order] ).tqarg( order ) );
vector.resize( c_polynomSize[order] );
}
pNewPoly->setCoefficients( vector );
}
do
{
oldConsumed = m_consumedTokens;
if( m_token == STURM_TOK )
{
pNewPoly->setSturm( true );
nextToken( );
}
parseChildObjects( pNewPoly );
parseObjectModifiers( pNewPoly );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseBicubicPatch( PMBicubicPatch* pNewPatch )
{
PMVector vector;
bool stop = false;
int oldConsumed;
int type;
int steps;
double flatness;
int i;
if( !parseToken( BICUBIC_PATCH_TOK, "bicubic_patch" ) )
return false;
if( !parseToken( '{' ) )
return false;
// parse patch items
do
{
switch( m_token )
{
case TYPE_TOK:
nextToken( );
if( parseInt( type ) )
{
if( ( type == 0 ) || ( type == 1 ) )
pNewPatch->setPatchType( type );
else
printError( i18n( "Patch type has to be 0 or 1" ) );
}
break;
case U_STEPS_TOK:
nextToken( );
if( parseInt( steps ) )
pNewPatch->setUSteps( steps );
break;
case V_STEPS_TOK:
nextToken( );
if( parseInt( steps ) )
pNewPatch->setVSteps( steps );
break;
case FLATNESS_TOK:
nextToken( );
if( parseFloat( flatness ) )
pNewPatch->setFlatness( flatness );
break;
case UV_VECTORS_TOK:
pNewPatch->enableUV( true );
nextToken( );
for ( i = 0; i < 4; ++i )
{
if( parseVector( vector ) )
pNewPatch->setUVVector( i, vector );
else
return false;
}
break;
case ',':
nextToken( );
stop = true;
break;
default:
stop = true;
break;
}
}
while( !stop );
// parse control points
stop = false;
for( i = 0; ( i < 16 ) && !stop; i++ )
{
if( parseVector( vector ) )
{
pNewPatch->setControlPoint( i, vector );
if( i < 15 )
if( !parseToken( ',' ) )
stop = true;
}
else
stop = true;
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewPatch );
parseObjectModifiers( pNewPatch );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseDisc( PMDisc* pNewDisc )
{
double d;
PMVector vector;
int oldConsumed;
if( !parseToken( DISC_TOK, "disc" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewDisc->setCenter( vector );
if( !parseToken( ',' ) )
return false;
if( !parseVector( vector ) )
return false;
pNewDisc->setNormal( vector );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( d ) )
return false;
pNewDisc->setRadius( d );
if( m_token == ',' )
{
nextToken( );
if( !parseFloat( d ) )
return false;
pNewDisc->setHoleRadius( d );
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewDisc );
parseObjectModifiers( pNewDisc );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseTriangle( PMTriangle* pNewTriangle )
{
PMVector vector;
int oldConsumed;
int i;
if( m_token == SMOOTH_TRIANGLE_TOK )
pNewTriangle->setSmoothTriangle( true );
else if( m_token == TRIANGLE_TOK )
pNewTriangle->setSmoothTriangle( false );
else
{
printExpected( "triangle", m_pScanner->sValue( ) );
return false;
}
nextToken( );
if( !parseToken( '{' ) )
return false;
for( i = 0; i < 3; i++ )
{
if( i != 0 )
parseToken( ',' );
if( !parseVector( vector ) )
return false;
pNewTriangle->setPoint( i, vector );
if( pNewTriangle->isSmoothTriangle( ) )
{
parseToken( ',' );
if( !parseVector( vector ) )
return false;
pNewTriangle->setNormal( i, vector );
}
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewTriangle );
parseObjectModifiers( pNewTriangle );
if( m_token == UV_VECTORS_TOK )
{
nextToken( );
pNewTriangle->enableUV( true );
for ( i = 0; i < 3; ++i )
{
if( parseVector( vector ) )
pNewTriangle->setUVVector( i, vector );
else
return false;
}
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseLathe( PMLathe* pNewLathe )
{
PMVector vector;
int oldConsumed;
int i;
bool stop = false;
if( !parseToken( LATHE_TOK, "lathe" ) )
return false;
if( !parseToken( '{' ) )
return false;
int minp = 2;
while( !stop )
{
switch( m_token )
{
case LINEAR_SPLINE_TOK:
pNewLathe->setSplineType( PMLathe::LinearSpline );
nextToken( );
minp = 2;
break;
case TQUADRATIC_SPLINE_TOK:
pNewLathe->setSplineType( PMLathe::QuadraticSpline );
nextToken( );
minp = 3;
break;
case CUBIC_SPLINE_TOK:
pNewLathe->setSplineType( PMLathe::CubicSpline );
nextToken( );
minp = 4;
break;
case BEZIER_SPLINE_TOK:
pNewLathe->setSplineType( PMLathe::BezierSpline );
nextToken( );
minp = 4;
break;
default:
stop = true;
break;
}
}
int nump;
if( !parseInt( nump ) )
return false;
TQValueList<PMVector> points;
for( i = 0; i < nump; i++ )
{
parseToken( ',' );
if( !parseVector( vector ) )
return false;
vector.resize( 2 );
points.append( vector );
}
if( nump < minp )
printError( i18n( "At least %1 points are needed for that spline type" )
.tqarg( minp ) );
else if( ( pNewLathe->splineType( ) == PMLathe::BezierSpline ) &&
( ( nump % 4 ) != 0 ) )
printError( i18n( "Bezier splines need 4 points for each segment" ) );
else
pNewLathe->setPoints( points );
do
{
oldConsumed = m_consumedTokens;
if( m_token == STURM_TOK )
{
pNewLathe->setSturm( true );
nextToken( );
}
parseChildObjects( pNewLathe );
parseObjectModifiers( pNewLathe );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parsePrism( PMPrism* pNewPrism )
{
PMVector vector;
double height;
int oldConsumed;
int i;
bool stop = false;
if( !parseToken( PRISM_TOK, "prism" ) )
return false;
if( !parseToken( '{' ) )
return false;
int minp = 3;
while( !stop )
{
switch( m_token )
{
case LINEAR_SPLINE_TOK:
pNewPrism->setSplineType( PMPrism::LinearSpline );
nextToken( );
minp = 3;
break;
case TQUADRATIC_SPLINE_TOK:
pNewPrism->setSplineType( PMPrism::QuadraticSpline );
nextToken( );
minp = 4;
break;
case CUBIC_SPLINE_TOK:
pNewPrism->setSplineType( PMPrism::CubicSpline );
nextToken( );
minp = 5;
break;
case BEZIER_SPLINE_TOK:
pNewPrism->setSplineType( PMPrism::BezierSpline );
nextToken( );
minp = 4;
break;
case LINEAR_SWEEP_TOK:
pNewPrism->setSweepType( PMPrism::LinearSweep );
nextToken( );
break;
case CONIC_SWEEP_TOK:
pNewPrism->setSweepType( PMPrism::ConicSweep );
nextToken( );
break;
default:
stop = true;
break;
}
}
if( !parseFloat( height ) )
return false;
pNewPrism->setHeight1( height );
parseToken( ',' );
if( !parseFloat( height ) )
return false;
pNewPrism->setHeight2( height );
parseToken( ',' );
int nump;
if( !parseInt( nump ) )
return false;
TQValueList<PMVector> allPoints;
for( i = 0; i < nump; i++ )
{
parseToken( ',' );
if( !parseVector( vector ) )
return false;
vector.resize( 2 );
allPoints.append( vector );
}
TQValueList< TQValueList<PMVector> > points;
TQValueList<PMVector> subPoints;
TQValueList<PMVector>::Iterator it = allPoints.begin( );
int pnr = 0, pmod4;
PMVector ref( 2 ), ref2( 2 );
bool error = false;
bool last = false;
switch( pNewPrism->splineType( ) )
{
case PMPrism::LinearSpline:
for( ; ( it != allPoints.end( ) ) && !error; ++it, pnr++ )
{
if( pnr == 0 )
{
ref = *it;
subPoints.append( *it );
}
else
{
if( ref.approxEqual( *it ) )
{
if( pnr < 3 )
{
printError( i18n( "Linear splines need at least 4 points." ) );
error = true;
}
else
{
points.append( subPoints );
subPoints.clear( );
pnr = -1;
}
}
else
subPoints.append( *it );
}
}
if( ( pnr != 0 ) && ( !error ) )
{
printWarning( i18n( "Linear spline not closed" ) );
if( pnr < 3 )
{
printError( i18n( "Linear splines need at least 4 points." ) );
error = true;
}
else
{
points.append( subPoints );
subPoints.clear( );
}
}
break;
case PMPrism::QuadraticSpline:
for( ; ( it != allPoints.end( ) ) && !error; ++it, pnr++ )
{
if( pnr == 0 )
subPoints.append( *it );
else if( pnr == 1 )
{
ref = *it;
subPoints.append( *it );
}
else
{
if( ref.approxEqual( *it ) )
{
if( pnr < 4 )
{
printError( i18n( "Quadratic splines need at least 5 points." ) );
error = true;
}
else
{
points.append( subPoints );
subPoints.clear( );
pnr = -1;
}
}
else
subPoints.append( *it );
}
}
if( ( pnr != 0 ) && ( !error ) )
{
printError( i18n( "Quadratic spline not closed" ) );
error = true;
}
break;
case PMPrism::CubicSpline:
for( ; ( it != allPoints.end( ) ) && !error; ++it, pnr++ )
{
if( pnr == 0 )
subPoints.append( *it );
else if( pnr == 1 )
{
ref = *it;
subPoints.append( *it );
}
else if( last )
{
if( pnr < 5 )
{
printError( i18n( "Cubic splines need at least 6 points." ) );
error = true;
}
else
{
subPoints.append( *it );
points.append( subPoints );
subPoints.clear( );
pnr = -1;
last = false;
}
}
else
{
if( ref.approxEqual( *it ) )
last = true;
else
subPoints.append( *it );
}
}
if( ( pnr != 0 ) && ( !error ) )
{
printError( i18n( "Cubic spline not closed" ) );
error = true;
}
break;
case PMPrism::BezierSpline:
for( ; ( it != allPoints.end( ) ) && !error; ++it, pnr++ )
{
pmod4 = pnr % 4;
if( pnr == 0 )
{
ref = *it;
subPoints.append( *it );
}
else if( pmod4 == 0 )
{
if( !ref2.approxEqual( *it ) )
{
printError( i18n( "Bezier spline not closed" ) );
error = true;
}
}
else if( pmod4 == 3 )
{
if( ref.approxEqual( *it ) )
{
points.append( subPoints );
subPoints.clear( );
pnr = -1;
}
else
{
subPoints.append( *it );
ref2 = *it;
}
}
else
subPoints.append( *it );
}
if( ( pnr != 0 ) && ( !error ) )
{
printError( i18n( "Bezier spline not closed" ) );
error = true;
}
break;
}
if( !error )
pNewPrism->setPoints( points );
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case STURM_TOK:
pNewPrism->setSturm( true );
nextToken( );
break;
case OPEN_TOK:
pNewPrism->setOpen( true );
nextToken( );
break;
default:
break;
}
parseChildObjects( pNewPrism );
parseObjectModifiers( pNewPrism );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseSor( PMSurfaceOfRevolution* pNewSor )
{
PMVector vector;
int oldConsumed;
int i;
if( !parseToken( SOR_TOK, "sor" ) )
return false;
if( !parseToken( '{' ) )
return false;
int nump;
if( !parseInt( nump ) )
return false;
TQValueList<PMVector> points;
for( i = 0; i < nump; i++ )
{
parseToken( ',' );
if( !parseVector( vector ) )
return false;
vector.resize( 2 );
points.append( vector );
}
if( nump < 4 )
printError( i18n( "At least 4 points are needed for the surface of revolution" ) );
else
{
TQValueList<PMVector>::Iterator it1 = points.begin( );
TQValueList<PMVector>::Iterator it2 = it1; ++it2;
TQValueList<PMVector>::Iterator it3 = it2; ++it3;
int pnr = 0;
for( ; it3 != points.end( ); ++it1, ++it2, ++it3, pnr++ )
{
if( ( pnr == 0 ) || ( pnr == ( nump - 3 ) ) )
{
if( approxZero( ( *it1 )[1] - ( *it3 )[1], c_sorTolerance ) )
{
printError( i18n( "The v coordinate of point %1 and %2 must be different; fixed" )
.tqarg( pnr + 1 ).tqarg( pnr + 3 ) );
if( pnr == 0 )
( *it1 )[1] = ( *it3 )[1] - c_sorTolerance;
else
( *it3 )[1] = ( *it1 )[1] + c_sorTolerance;
}
}
if( pnr != 0 )
{
if( ( ( *it2 )[1] - ( *it1 )[1] ) < c_sorTolerance )
{
printError( i18n( "The v coordinates must be strictly increasing; fixed" ) );
( *it2 )[1] = ( *it1 )[1] + c_sorTolerance;
}
}
}
pNewSor->setPoints( points );
}
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case STURM_TOK:
pNewSor->setSturm( true );
nextToken( );
break;
case OPEN_TOK:
pNewSor->setOpen( true );
nextToken( );
break;
default:
break;
}
parseChildObjects( pNewSor );
parseObjectModifiers( pNewSor );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseSqe( PMSuperquadricEllipsoid* pNewSqe )
{
PMVector vector;
int oldConsumed;
if( !parseToken( SUPERELLIPSOID_TOK ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( vector ) )
return false;
vector.resize( 2 );
if( vector[0] < 0.001 )
{
printError( i18n( "The east-west exponent must be greater than 0.001" ) );
vector[0] = 0.001;
}
if( vector[1] < 0.001 )
{
printError( i18n( "The north-south exponent must be greater than 0.001" ) );
vector[1] = 0.001;
}
pNewSqe->setEastWestExponent( vector[0] );
pNewSqe->setNorthSouthExponent( vector[1] );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pNewSqe );
parseObjectModifiers( pNewSqe );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseRotate( PMRotate* rotate )
{
PMVector v;
if( !parseToken( ROTATE_TOK, "rotate" ) )
return false;
if( !parseVector( v ) )
return false;
rotate->setRotation( v );
return true;
}
bool PMPovrayParser::parseScale( PMScale* scale )
{
PMVector v;
if( !parseToken( SCALE_TOK, "scale" ) )
return false;
if( !parseVector( v ) )
return false;
scale->setScale( v );
return true;
}
bool PMPovrayParser::parseTranslate( PMTranslate* translate )
{
PMVector v;
if( !parseToken( TRANSLATE_TOK, "translate" ) )
return false;
if( !parseVector( v ) )
return false;
translate->setTranslation( v );
return true;
}
bool PMPovrayParser::parseMatrix( PMPovrayMatrix* matrix )
{
PMVector v;
if( !parseToken( MATRIX_TOK ), "matrix" )
return false;
if( !parseVectorLiteral( v ) )
return false;
if( v.size( ) != 12 )
{
printError( i18n( "Wrong number of matrix values." ) );
v.resize( 12 );
}
matrix->setValues( v );
return true;
}
bool PMPovrayParser::parseBoundedBy( PMBoundedBy* bound )
{
int oldConsumed;
if( !parseToken( BOUNDED_BY_TOK, "bounded_by" ) )
return false;
if( !parseToken( '{' ) )
return false;
do
{
oldConsumed = m_consumedTokens;
if( m_token == CLIPPED_BY_TOK )
nextToken( );
parseChildObjects( bound );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseClippedBy( PMClippedBy* clipped )
{
int oldConsumed;
if( !parseToken( CLIPPED_BY_TOK, "clipped_by" ) )
return false;
if( !parseToken( '{' ) )
return false;
do
{
oldConsumed = m_consumedTokens;
if( m_token == BOUNDED_BY_TOK )
nextToken( );
parseChildObjects( clipped );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseCamera( PMCamera* camera )
{
PMVector v;
double d;
int i;
int oldConsumed;
if( !parseToken( CAMERA_TOK, "camera" ) )
return false;
if( !parseToken( '{' ) )
return false;
do
{
oldConsumed = m_consumedTokens;
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case PERSPECTIVE_TOK:
nextToken( );
camera->setCameraType( PMCamera::Perspective );
break;
case ORTHOGRAPHIC_TOK:
nextToken( );
camera->setCameraType( PMCamera::Orthographic );
break;
case FISHEYE_TOK:
nextToken( );
camera->setCameraType( PMCamera::FishEye );
break;
case ULTRA_WIDE_ANGLE_TOK:
nextToken( );
camera->setCameraType( PMCamera::UltraWideAngle );
break;
case OMNIMAX_TOK:
nextToken( );
camera->setCameraType( PMCamera::Omnimax );
break;
case PANORAMIC_TOK:
nextToken( );
camera->setCameraType( PMCamera::Panoramic );
break;
case CYLINDER_TOK:
nextToken( );
camera->setCameraType( PMCamera::Cylinder );
if( parseInt( i ) )
camera->setCylinderType( i );
break;
case LOCATION_TOK:
nextToken( );
if( parseVector( v ) )
camera->setLocation( v );
break;
case SKY_TOK:
nextToken( );
if( parseVector( v ) )
camera->setSky( v );
break;
case UP_TOK:
nextToken( );
if( parseVector( v ) )
camera->setUp( v );
break;
case RIGHT_TOK:
nextToken( );
if( parseVector( v ) )
camera->setRight( v );
break;
case DIRECTION_TOK:
nextToken( );
if( parseVector( v ) )
camera->setDirection( v );
break;
case LOOK_AT_TOK:
nextToken( );
if( parseVector( v ) )
camera->setLookAt( v );
break;
case ANGLE_TOK:
nextToken( );
if( parseFloat( d ) )
{
camera->enableAngle( true );
camera->setAngle( d );
}
break;
case BLUR_SAMPLES_TOK:
nextToken( );
camera->enableFocalBlur( true );
if( parseInt( i ) )
camera->setBlurSamples( i );
break;
case APERTURE_TOK:
nextToken( );
camera->enableFocalBlur( true );
if( parseFloat( d ) )
camera->setAperture( d );
break;
case FOCAL_POINT_TOK:
nextToken( );
if( parseVector( v ) )
camera->setFocalPoint( v );
break;
case CONFIDENCE_TOK:
nextToken( );
if( parseFloat( d ) )
camera->setConfidence( d );
break;
case VARIANCE_TOK:
nextToken( );
if( parseFloat( d ) )
camera->setVariance( d );
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
parseChildObjects( camera );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseLight( PMLight* light )
{
PMVector v;
PMColor c;
double d;
int i;
int oldConsumed;
if( !parseToken( LIGHT_SOURCE_TOK, "light_source" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( !parseVector( v ) )
return false;
light->setLocation( v );
if( m_token == ',' )
nextToken( );
if( !parseColor( c ) )
return false;
light->setColor( c );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( light );
switch( m_token )
{
case SPOTLIGHT_TOK:
nextToken( );
light->setLightType( PMLight::SpotLight );
break;
case CYLINDER_TOK:
nextToken( );
light->setLightType( PMLight::CylinderLight );
break;
case SHADOWLESS_TOK:
nextToken( );
light->setLightType( PMLight::ShadowlessLight );
break;
case RADIUS_TOK:
nextToken( );
if( parseFloat( d ) )
light->setRadius( d );
break;
case FALLOFF_TOK:
nextToken( );
if( parseFloat( d ) )
light->setFalloff( d );
break;
case TIGHTNESS_TOK:
nextToken( );
if( parseFloat( d ) )
light->setTightness( d );
break;
case POINT_AT_TOK:
nextToken( );
if( parseVector( v ) )
light->setPointAt( v );
break;
case PARALLEL_TOK:
nextToken( );
light->setParallel( parseBool( ) );
break;
case AREA_LIGHT_TOK:
nextToken( );
light->setAreaLight( true );
if( parseVector( v ) )
light->setAxis1( v );
parseToken( ',' );
if( parseVector( v ) )
light->setAxis2( v );
parseToken( ',' );
if( parseInt( i ) )
light->setSize1( i );
parseToken( ',' );
if( parseInt( i ) )
light->setSize2( i );
break;
case AREA_CIRCULAR_TOK:
nextToken( );
light->setAreaType( PMLight::Circular );
break;
case ADAPTIVE_TOK:
nextToken( );
if( parseInt( i ) )
light->setAdaptive( i );
break;
case ORIENT_TOK:
nextToken( );
light->setOrient( parseBool( ) );
break;
case JITTER_TOK:
nextToken( );
light->setJitter( parseBool( ) );
break;
case FADE_POWER_TOK:
nextToken( );
light->setFading( true );
if( parseInt( i ) )
light->setFadePower( i );
break;
case FADE_DISTANCE_TOK:
nextToken( );
light->setFading( true );
if( parseFloat( d ) )
light->setFadeDistance( d );
break;
case MEDIA_INTERACTION_TOK:
nextToken( );
light->setMediaInteraction( parseBool( ) );
break;
case MEDIA_ATTENUATION_TOK:
nextToken( );
light->setMediaAttenuation( parseBool( ) );
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseLooksLike( PMLooksLike* ll )
{
if( !parseToken( LOOKS_LIKE_TOK, "looks_like" ) )
return false;
if( !parseToken( '{' ) )
return false;
parseChildObjects( ll );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseProjectedThrough( PMProjectedThrough* ll )
{
if( !parseToken( PROJECTED_THROUGH_TOK, "projected_through" ) )
return false;
if( !parseToken( '{' ) )
return false;
parseChildObjects( ll );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseTexture( PMTexture* texture, bool parseOuter )
{
int oldConsumed;
if( parseOuter )
{
if( !parseToken( TEXTURE_TOK, "texture" ) )
return false;
if( !parseToken( '{' ) )
return false;
}
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !texture->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( texture );
if( m_token == UV_MAPPING_TOK )
{
nextToken();
texture->setUVMapping( parseBool( ) );
}
}
while( oldConsumed != m_consumedTokens );
if( parseOuter )
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parsePattern( PMPattern* pattern, bool normal )
{
PMVector vector;
double f_number;
int i_number;
int oldConsumed;
bool type;
do
{
oldConsumed = m_consumedTokens;
type = false;
switch( m_token )
{
case AGATE_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternAgate );
type = true;
break;
case AGATE_TURB_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
pattern->setAgateTurbulence( f_number );
break;
case AVERAGE_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternAverage );
type = true;
break;
case BOXED_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternBoxed );
type = true;
break;
case BOZO_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternBozo );
type = true;
break;
case BUMPS_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternBumps );
type = true;
break;
case CELLS_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternCells );
type = true;
break;
case CRACKLE_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternCrackle );
type = true;
break;
case CYLINDRICAL_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternCylindrical );
type = true;
break;
case DENTS_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternDents );
type = true;
break;
case DENSITY_FILE_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternDensity );
type = true;
if( !parseToken( DF3_TOK, "df3" ) )
return false;
if( m_token != STRING_TOK )
{
printError( i18n( "Expecting a file name." ) );
return false;
}
else
{
pattern->setDensityFile( m_pScanner->sValue( ) );
nextToken( );
}
if( parseToken( INTERPOLATE_TOK, "interpolate" ) )
{
if( !parseInt( i_number ) )
return false;
else
pattern->setDensityInterpolate( i_number );
}
break;
case GRADIENT_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternGradient );
type = true;
if( !parseVector( vector ) )
return false;
pattern->setGradient( vector );
break;
case GRANITE_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternGranite );
type = true;
break;
case JULIA_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternJulia );
type = true;
if( !parseVector( vector ) )
return false;
pattern->setJuliaComplex( vector );
if( !parseInt( i_number ) )
return false;
pattern->setMaxIterations( i_number );
break;
case LEOPARD_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternLeopard );
type = true;
break;
case MANDEL_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternMandel );
type = true;
if( !parseInt( i_number ) )
return false;
pattern->setMaxIterations( i_number );
break;
case MARBLE_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternMarble );
type = true;
break;
case ONION_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternOnion );
type = true;
break;
case PLANAR_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternPlanar );
type = true;
break;
case TQUILTED_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternQuilted );
type = true;
break;
case CONTROL0_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
pattern->setQuiltControl0( f_number );
break;
case CONTROL1_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
pattern->setQuiltControl1( f_number );
break;
case RADIAL_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternRadial );
type = true;
break;
case RIPPLES_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternRipples );
type = true;
break;
case SLOPE_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternSlope );
type = true;
if( !parseToken( '{' ) )
return false;
if( !parseVector( vector ) )
return false;
pattern->setSlopeDirection( vector );
if ( parseToken( ',' ) )
{
if( !parseFloat( f_number ) )
return false;
pattern->setSlopeLoSlope( f_number );
if ( parseToken( ',' ) )
{
if ( !parseFloat( f_number ) )
return false;
pattern->setSlopeHiSlope( f_number );
}
}
if( m_token == ALTITUDE_TOK )
{
pattern->setSlopeAltFlag( true );
nextToken( );
if ( !parseVector( vector ) )
return false;
pattern->setSlopeAltitude( vector );
if( parseToken( ',' ) )
{
if ( !parseFloat( f_number ) )
return false;
pattern->setSlopeLoAlt( f_number );
if ( parseToken( ',' ) )
{
if( !parseFloat( f_number ) )
return false;
pattern->setSlopeHiAlt( f_number );
}
}
}
if( !parseToken( '}' ) )
return false;
break;
case SPHERICAL_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternSpherical );
type = true;
break;
case SPIRAL1_TOK:
case SPIRAL2_TOK:
if( m_token == SPIRAL1_TOK )
pattern->setPatternType( PMPattern::PatternSpiral1 );
else
pattern->setPatternType( PMPattern::PatternSpiral2 );
type = true;
nextToken( );
if( !parseInt( i_number ) )
return false;
pattern->setSpiralNumberArms( i_number );
break;
case SPOTTED_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternSpotted );
type = true;
break;
case WAVES_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternWaves );
type = true;
break;
case WOOD_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternWood );
type = true;
break;
case WRINKLES_TOK:
nextToken( );
pattern->setPatternType( PMPattern::PatternWrinkles );
type = true;
break;
//crackle parameters
case FORM_TOK:
nextToken( );
if( !parseVector( vector ) )
return false;
pattern->setCrackleForm( vector );
break;
case METRIC_TOK:
nextToken( );
if ( !parseInt( i_number ) )
return false;
pattern->setCrackleMetric( i_number );
break;
case OFFSET_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
pattern->setCrackleOffset( f_number );
break;
case SOLID_TOK:
nextToken( );
pattern->setCrackleSolid( true );
break;
//fractal parameters
case MAGNET_TOK:
nextToken( );
pattern->setFractalMagnet( true );
if ( !parseInt( i_number ) )
return false;
pattern->setFractalMagnetType( i_number );
break;
case EXPONENT_TOK:
nextToken( );
if ( !parseInt( i_number ) )
return false;
pattern->setFractalExponent( i_number );
break;
case EXTERIOR_TOK:
nextToken( );
if ( !parseInt( i_number ) )
return false;
pattern->setFractalExtType( i_number );
if ( !parseFloat( f_number ) )
return false;
pattern->setFractalExtFactor( f_number );
break;
case INTERIOR_TOK:
nextToken( );
if ( !parseInt( i_number ) )
return false;
pattern->setFractalIntType( i_number );
if ( !parseFloat( f_number ) )
return false;
pattern->setFractalIntFactor( f_number );
break;
//turbulence
case TURBULENCE_TOK:
nextToken( );
pattern->enableTurbulence( true );
if( !parseVector( vector ) )
return false;
pattern->setValueVector( vector );
break;
case OCTAVES_TOK:
nextToken( );
if( !parseInt( i_number ) )
return false;
pattern->setOctaves( i_number );
break;
case OMEGA_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
pattern->setOmega( f_number );
break;
case LAMBDA_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
pattern->setLambda( f_number );
break;
case NOISE_GENERATOR_TOK:
nextToken( );
if( !parseInt( i_number ) )
return false;
pattern->setNoiseGenerator( ( PMPattern::PMNoiseType ) ( i_number ) );
break;
default:
break;
}
if( type && normal )
{
// try to parse the normal pattern depth
double depth;
if( parseFloat( depth, true ) )
pattern->setDepth( depth );
}
}
while( oldConsumed != m_consumedTokens );
return true;
}
bool PMPovrayParser::parseBlendMapModifiers( PMBlendMapModifiers* blend )
{
int oldConsumed;
double f_number;
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case FREQUENCY_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
blend->enableFrequency( true );
blend->setFrequency( f_number );
break;
case PHASE_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
blend->enablePhase( true );
blend->setPhase( f_number );
break;
case RAMP_WAVE_TOK:
nextToken( );
blend->enableWaveForm( true );
blend->setWaveFormType( PMBlendMapModifiers::RampWave );
break;
case TRIANGLE_WAVE_TOK:
nextToken( );
blend->enableWaveForm( true );
blend->setWaveFormType( PMBlendMapModifiers::TriangleWave );
break;
case SINE_WAVE_TOK:
nextToken( );
blend->enableWaveForm( true );
blend->setWaveFormType( PMBlendMapModifiers::SineWave );
break;
case SCALLOP_WAVE_TOK:
nextToken( );
blend->enableWaveForm( true );
blend->setWaveFormType( PMBlendMapModifiers::ScallopWave );
break;
case CUBIC_WAVE_TOK:
nextToken( );
blend->enableWaveForm( true );
blend->setWaveFormType( PMBlendMapModifiers::CubicWave );
break;
case POLY_WAVE_TOK:
nextToken( );
blend->enableWaveForm( true );
blend->setWaveFormType( PMBlendMapModifiers::PolyWave );
if( parseFloat( f_number, true ) )
blend->setWaveFormExponent( f_number );
break;
}
}
while( oldConsumed != m_consumedTokens );
return true;
}
bool PMPovrayParser::parseWarp( PMWarp* warp )
{
int oldConsumed;
PMVector vector;
double f_number;
int i_number;
bool parsedFirst;
bool mapping;
if( !parseToken( WARP_TOK, "warp" ) )
return false;
if( !parseToken( '{' ) )
return false;
mapping = false;
parsedFirst = false;
do
{
oldConsumed = m_consumedTokens;
if( !parsedFirst &&
( m_token != REPEAT_TOK ||
m_token != BLACK_HOLE_TOK ||
m_token != TURBULENCE_TOK ||
m_token != CYLINDRICAL_TOK ||
m_token != SPHERICAL_TOK ||
m_token != TOROIDAL_TOK ||
m_token != PLANAR_TOK ) )
{
printError( i18n( "Expecting a warp type" ) );
return false;
}
switch( m_token )
{
case REPEAT_TOK:
nextToken( );
if( !parsedFirst )
{
warp->setWarpType( PMWarp::Repeat );
if( !parseVector( vector ) )
return false;
warp->setDirection( vector );
parsedFirst = true;
}
else
{
if( !parseVector( vector ) )
return false;
warp->setRepeat( vector );
}
break;
case OFFSET_TOK:
nextToken( );
if( !parseVector( vector ) )
return false;
warp->setOffset( vector );
break;
case FLIP_TOK:
nextToken( );
if( !parseVector( vector ) )
return false;
warp->setFlip( vector );
break;
case BLACK_HOLE_TOK:
nextToken( );
warp->setWarpType( PMWarp::BlackHole );
if( !parseVector( vector ) )
return false;
warp->setLocation( vector );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( f_number ) )
return false;
warp->setRadius( f_number );
parsedFirst = true;
break;
case STRENGTH_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
warp->setStrength( f_number );
break;
case FALLOFF_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
warp->setFalloff( f_number );
break;
case INVERSE_TOK:
nextToken( );
warp->setInverse( true );
break;
case TURBULENCE_TOK:
if( !parsedFirst )
{
nextToken( );
warp->setWarpType( PMWarp::Turbulence );
if( !parseVector( vector ) )
return false;
warp->setValueVector( vector );
parsedFirst = true;
}
else
{
if( !parseVector( vector ) )
return false;
warp->setTurbulence( vector );
}
break;
case OCTAVES_TOK:
nextToken( );
if( !parseInt( i_number ) )
return false;
warp->setOctaves( i_number );
break;
case OMEGA_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
warp->setOmega( f_number );
break;
case LAMBDA_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
warp->setLambda( f_number );
break;
case CYLINDRICAL_TOK:
warp->setWarpType( PMWarp::Cylindrical );
mapping = true;
break;
case SPHERICAL_TOK:
warp->setWarpType( PMWarp::Spherical );
mapping = true;
break;
case TOROIDAL_TOK:
warp->setWarpType( PMWarp::Toroidal );
mapping = true;
break;
case PLANAR_TOK:
nextToken( );
warp->setWarpType( PMWarp::Planar );
if( parseVector( vector ) )
{
warp->setOrientation( vector );
if( parseToken( ',' ) )
{
if( !parseFloat( f_number ) )
return false;
warp->setDistExp( f_number );
}
}
parsedFirst = true;
break;
case DIST_EXP_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
warp->setDistExp( f_number );
break;
case MAJOR_RADIUS_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
warp->setMajorRadius( f_number );
break;
default:
break;
}
if( mapping)
{
nextToken( );
if( !parseVector( vector ) )
return false;
warp->setOrientation( vector );
parsedFirst = true;
mapping = false;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parsePigment( PMPigment* pigment, bool parseOuter )
{
PMColor c;
PMSolidColor* sc;
int oldConsumed;
if( parseOuter )
{
if( !parseToken( PIGMENT_TOK, "pigment" ) )
return false;
if( !parseToken( '{' ) )
return false;
}
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMSymbol* s = getSymbol( id );
bool skipID = false;
if( s )
if( s->type( ) == PMSymbol::Value )
skipID = true;
if( !skipID )
{
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !pigment->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( pigment );
switch( m_token )
{
case '<':
case COLOR_TOK:
case COLOUR_TOK:
case RGB_TOK:
case RGBT_TOK:
case RGBF_TOK:
case RGBFT_TOK:
case RED_TOK:
case GREEN_TOK:
case BLUE_TOK:
case TRANSMIT_TOK:
case FILTER_TOK:
case ID_TOK:
if( parseColor( c ) )
{
sc = new PMSolidColor( m_pPart );
sc->setColor( c );
if( !insertChild( sc, pigment ) )
{
delete sc;
sc = 0;
}
}
break;
case UV_MAPPING_TOK:
nextToken();
pigment->setUVMapping( parseBool( ) );
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
if( parseOuter )
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseNormal( PMNormal* normal )
{
double f_number;
int oldConsumed;
if( !parseToken( NORMAL_TOK, "normal" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !normal->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( normal );
switch( m_token )
{
case BUMP_SIZE_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
normal->enableBumpSize( true );
normal->setBumpSize( f_number );
break;
case ACCURACY_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
normal->setAccuracy( f_number );
break;
case UV_MAPPING_TOK:
nextToken( );
normal->setUVMapping( parseBool( ) );
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseTextureMap( PMTextureMap* textureMap )
{
int oldConsumed;
double f_number1;
PMTexture* texture;
TQValueList<double> mapValues;
if( !parseToken( TEXTURE_MAP_TOK, "texture_map" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !textureMap->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
if( m_token == '[' )
{
nextToken( );
if( !parseFloat( f_number1 ) )
return false;
mapValues.append( f_number1 );
texture = new PMTexture( m_pPart );
parseTexture( texture, false );
if( !insertChild( texture, textureMap ) )
delete texture;
if( !parseToken( ']' ) )
return false;
}
}
while( oldConsumed != m_consumedTokens );
textureMap->setMapValues( mapValues );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parsePigmentMap( PMPigmentMap* pigmentMap )
{
int oldConsumed;
double f_number1;
PMPigment* pigment;
TQValueList<double> mapValues;
if( !parseToken( PIGMENT_MAP_TOK, "pigment_map" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !pigmentMap->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
if( m_token == '[' )
{
nextToken( );
if( !parseFloat( f_number1 ) )
return false;
mapValues.append( f_number1 );
pigment = new PMPigment( m_pPart );
parsePigment( pigment, false );
if( !insertChild( pigment, pigmentMap ) )
delete pigment;
if( !parseToken( ']' ) )
return false;
}
}
while( oldConsumed != m_consumedTokens );
pigmentMap->setMapValues( mapValues );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseNormalMap( PMNormalMap* normalMap )
{
int oldConsumed;
double f_number1;
PMNormal* normal;
TQValueList<double> mapValues;
if( !parseToken( NORMAL_MAP_TOK, "normal_map" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !normalMap->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
// If we find '}' no need to search for an entry
if( m_token != '}' && parseToken( '[' ) )
{
if( !parseFloat( f_number1 ) )
return false;
mapValues.append( f_number1 );
normal = new PMNormal( m_pPart );
if( !parseNormal( normal ) )
{
delete normal;
return false;
}
if( !insertChild( normal, normalMap ) )
delete normal;
if( !parseToken( ']' ) )
return false;
}
}
while( oldConsumed != m_consumedTokens );
normalMap->setMapValues( mapValues );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseBumpMap( PMBumpMap* bumpMap )
{
int oldConsumed;
int i_number;
double f_number;
if( !parseToken( BUMP_MAP_TOK, "bump_map" ) )
return false;
if( !parseToken( '{' ) )
return false;
// Parse the bitmap type
if( m_token != STRING_TOK )
{
switch( m_token )
{
case GIF_TOK:
bumpMap->setBitmapType( PMBumpMap::BitmapGif );
nextToken( );
break;
case TGA_TOK:
bumpMap->setBitmapType( PMBumpMap::BitmapTga );
nextToken( );
break;
case IFF_TOK:
bumpMap->setBitmapType( PMBumpMap::BitmapIff );
nextToken( );
break;
case PPM_TOK:
bumpMap->setBitmapType( PMBumpMap::BitmapPpm );
nextToken( );
break;
case PGM_TOK:
bumpMap->setBitmapType( PMBumpMap::BitmapPgm );
nextToken( );
break;
case PNG_TOK:
bumpMap->setBitmapType( PMBumpMap::BitmapPng );
nextToken( );
break;
case SYS_TOK:
bumpMap->setBitmapType( PMBumpMap::BitmapSys );
nextToken( );
break;
default:
printError( i18n( "Unknown bitmap type" ) );
return false;
}
}
// Parse the bitmap file name
if( m_token != STRING_TOK )
{
printError( i18n( "Expecting a file name." ) );
return false;
}
else
{
bumpMap->setBitmapFileName( m_pScanner->sValue( ) );
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case ONCE_TOK:
nextToken( );
bumpMap->enableOnce( true );
break;
case MAP_TYPE_TOK:
nextToken( );
if( !parseInt( i_number ) )
return false;
switch( i_number )
{
case 0:
bumpMap->setMapType( PMBumpMap::MapPlanar );
break;
case 1:
bumpMap->setMapType( PMBumpMap::MapSpherical );
break;
case 2:
bumpMap->setMapType( PMBumpMap::MapCylindrical );
break;
case 5:
bumpMap->setMapType( PMBumpMap::MapToroidal );
break;
}
break;
case INTERPOLATE_TOK:
nextToken( );
if( !parseInt( i_number ) )
return false;
switch( i_number )
{
case 2:
bumpMap->setInterpolateType( PMBumpMap::InterpolateBilinear );
break;
case 4:
bumpMap->setInterpolateType( PMBumpMap::InterpolateNormalized );
break;
}
break;
case USE_INDEX_TOK:
nextToken( );
bumpMap->enableUseIndex( true );
break;
case BUMP_SIZE_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
bumpMap->setBumpSize( f_number );
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseMaterialMap( PMMaterialMap* materialMap )
{
int oldConsumed;
int i_number;
if( !parseToken( MATERIAL_MAP_TOK, "material_map" ) )
return false;
if( !parseToken( '{' ) )
return false;
// Parse the bitmap type
if( m_token != STRING_TOK )
{
switch( m_token )
{
case GIF_TOK:
materialMap->setBitmapType( PMMaterialMap::BitmapGif );
nextToken( );
break;
case TGA_TOK:
materialMap->setBitmapType( PMMaterialMap::BitmapTga );
nextToken( );
break;
case IFF_TOK:
materialMap->setBitmapType( PMMaterialMap::BitmapIff );
nextToken( );
break;
case PPM_TOK:
materialMap->setBitmapType( PMMaterialMap::BitmapPpm );
nextToken( );
break;
case PGM_TOK:
materialMap->setBitmapType( PMMaterialMap::BitmapPgm );
nextToken( );
break;
case PNG_TOK:
materialMap->setBitmapType( PMMaterialMap::BitmapPng );
nextToken( );
break;
case SYS_TOK:
materialMap->setBitmapType( PMMaterialMap::BitmapSys );
nextToken( );
break;
default:
printError( i18n( "Unknown bitmap type" ) );
return false;
}
}
// Parse the bitmap file name
if( m_token != STRING_TOK )
{
printError( i18n( "Expecting a file name." ) );
return false;
}
else
{
materialMap->setBitmapFileName( m_pScanner->sValue( ) );
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( materialMap );
switch( m_token )
{
case ONCE_TOK:
nextToken( );
materialMap->enableOnce( true );
break;
case MAP_TYPE_TOK:
nextToken( );
if( !parseInt( i_number ) )
return false;
switch( i_number )
{
case 0:
materialMap->setMapType( PMMaterialMap::MapPlanar );
break;
case 1:
materialMap->setMapType( PMMaterialMap::MapSpherical );
break;
case 2:
materialMap->setMapType( PMMaterialMap::MapCylindrical );
break;
case 5:
materialMap->setMapType( PMMaterialMap::MapToroidal );
break;
}
break;
case INTERPOLATE_TOK:
nextToken( );
if( !parseInt( i_number ) )
return false;
switch( i_number )
{
case 2:
materialMap->setInterpolateType( PMMaterialMap::InterpolateBilinear );
break;
case 4:
materialMap->setInterpolateType( PMMaterialMap::InterpolateNormalized );
break;
}
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseSlopeMap( PMSlopeMap* slopeMap )
{
int oldConsumed;
double f_number1;
PMSlope* slope;
TQValueList<double> mapValues;
if( !parseToken( SLOPE_MAP_TOK, "slope_map" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !slopeMap->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
// If we find '}' no need to search for an entry
if( m_token != '}' && parseToken( '[' ) )
{
if( !parseFloat( f_number1 ) )
return false;
mapValues.append( f_number1 );
slope = new PMSlope( m_pPart );
if( !parseSlope( slope ) )
{
delete slope;
return false;
}
if( !insertChild( slope, slopeMap ) )
delete slope;
if( !parseToken( ']' ) )
return false;
}
}
while( oldConsumed != m_consumedTokens );
slopeMap->setMapValues( mapValues );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseDensityMap( PMDensityMap* densityMap )
{
int oldConsumed;
double f_number1;
PMDensity* density;
TQValueList<double> mapValues;
if( !parseToken( DENSITY_MAP_TOK, "density_map" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !densityMap->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
// If we find '}' no need to search for an entry
if( m_token != '}' && parseToken( '[' ) )
{
if( !parseFloat( f_number1 ) )
return false;
mapValues.append( f_number1 );
density = new PMDensity( m_pPart );
if( !parseDensity( density ) )
{
delete density;
return false;
}
if( !insertChild( density, densityMap ) )
delete density;
if( !parseToken( ']' ) )
return false;
}
}
while( oldConsumed != m_consumedTokens );
densityMap->setMapValues( mapValues );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseImageMap( PMImageMap* imageMap )
{
int oldConsumed;
int i_number;
double f_number;
PMPaletteValue newPaletteValue;
TQValueList<PMPaletteValue> l_valuesFilter;
TQValueList<PMPaletteValue> l_valuesTransmit;
if( !parseToken( IMAGE_MAP_TOK, "image_map" ) )
return false;
if( !parseToken( '{' ) )
return false;
// Parse the bitmap type
if( m_token != STRING_TOK )
{
switch( m_token )
{
case GIF_TOK:
imageMap->setBitmapType( PMImageMap::BitmapGif );
nextToken( );
break;
case TGA_TOK:
imageMap->setBitmapType( PMImageMap::BitmapTga );
nextToken( );
break;
case IFF_TOK:
imageMap->setBitmapType( PMImageMap::BitmapIff );
nextToken( );
break;
case PPM_TOK:
imageMap->setBitmapType( PMImageMap::BitmapPpm );
nextToken( );
break;
case PGM_TOK:
imageMap->setBitmapType( PMImageMap::BitmapPgm );
nextToken( );
break;
case PNG_TOK:
imageMap->setBitmapType( PMImageMap::BitmapPng );
nextToken( );
break;
case SYS_TOK:
imageMap->setBitmapType( PMImageMap::BitmapSys );
nextToken( );
break;
default:
printError( i18n( "Unknown bitmap type" ) );
return false;
}
}
// Parse the bitmap file name
if( m_token != STRING_TOK )
{
printError( i18n( "Expecting a file name." ) );
return false;
}
else
{
imageMap->setBitmapFileName( m_pScanner->sValue( ) );
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case TRANSMIT_TOK:
nextToken( );
if( m_token == ALL_TOK )
{
nextToken( );
if( !parseFloat( f_number ) )
return false;
imageMap->enableTransmitAll( true );
imageMap->setTransmitAll( f_number );
}
else
{
if( !parseInt( i_number ) )
return false;
parseToken( ',' );
if( !parseFloat( f_number ) )
return false;
newPaletteValue.setIndex( i_number );
newPaletteValue.setValue( f_number );
l_valuesTransmit.append( newPaletteValue );
}
break;
case FILTER_TOK:
nextToken( );
if( m_token == ALL_TOK )
{
nextToken( );
if( !parseFloat( f_number ) )
return false;
imageMap->enableFilterAll( true );
imageMap->setFilterAll( f_number );
}
else
{
if( !parseInt( i_number ) )
return false;
parseToken( ',' );
if( !parseFloat( f_number ) )
return false;
newPaletteValue.setIndex( i_number );
newPaletteValue.setValue( f_number );
l_valuesFilter.append( newPaletteValue );
}
break;
case ONCE_TOK:
nextToken( );
imageMap->enableOnce( true );
break;
case MAP_TYPE_TOK:
nextToken( );
if( !parseInt( i_number ) )
return false;
switch( i_number )
{
case 0:
imageMap->setMapType( PMImageMap::MapPlanar );
break;
case 1:
imageMap->setMapType( PMImageMap::MapSpherical );
break;
case 2:
imageMap->setMapType( PMImageMap::MapCylindrical );
break;
case 5:
imageMap->setMapType( PMImageMap::MapToroidal );
break;
}
break;
case INTERPOLATE_TOK:
nextToken( );
if( !parseInt( i_number ) )
return false;
switch( i_number )
{
case 2:
imageMap->setInterpolateType( PMImageMap::InterpolateBilinear );
break;
case 4:
imageMap->setInterpolateType( PMImageMap::InterpolateNormalized );
break;
}
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
imageMap->setFilters( l_valuesFilter );
imageMap->setTransmits( l_valuesTransmit );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parsePigmentList( PMPigmentList* pigmentList, int expectedItems )
{
int oldConsumed;
PMPigment* pigment;
do
{
oldConsumed = m_consumedTokens;
pigment = new PMPigment( m_pPart );
if( !parsePigment( pigment ) )
{
delete pigment;
return false;
}
if( !insertChild( pigment, pigmentList ) )
delete pigment;
// In the last entry don't expect a comma
if( expectedItems-- )
if( m_token == ',' )
nextToken( );
}
while( oldConsumed != m_consumedTokens && expectedItems );
return true;
}
bool PMPovrayParser::parseColorList( PMColorList* colorList, int expectedItems )
{
int oldConsumed;
PMColor color;
PMSolidColor* sc;
do
{
oldConsumed = m_consumedTokens;
if( !parseColor( color ) )
{
return false;
}
sc = new PMSolidColor( m_pPart );
sc->setColor( color );
if( !insertChild( sc, colorList ) )
delete sc;
// In the last entry don't expect a comma
if( expectedItems-- )
if( m_token == ',' )
nextToken( );
}
while( oldConsumed != m_consumedTokens && expectedItems );
return true;
}
bool PMPovrayParser::parseNormalList( PMNormalList* normalList, int expectedItems )
{
int oldConsumed;
PMNormal* normal;
do
{
oldConsumed = m_consumedTokens;
normal = new PMNormal( m_pPart );
if( !parseNormal( normal ) )
{
delete normal;
return false;
}
if( !insertChild( normal, normalList ) )
delete normal;
// In the last entry don't expect a comma
if( expectedItems-- )
if( m_token == ',' )
nextToken( );
}
while( oldConsumed != m_consumedTokens && expectedItems );
return true;
}
bool PMPovrayParser::parseTextureList( PMTextureList* textureList, int expectedItems )
{
int oldConsumed;
PMTexture* texture;
do
{
oldConsumed = m_consumedTokens;
texture = new PMTexture( m_pPart );
if( !parseTexture( texture ) )
{
delete texture;
return false;
}
if( !insertChild( texture, textureList ) )
delete texture;
// In the last entry don't expect a comma
if( expectedItems-- )
if( m_token == ',' )
nextToken( );
}
while( oldConsumed != m_consumedTokens && expectedItems );
return true;
}
bool PMPovrayParser::parseDensityList( PMDensityList* densityList, int expectedItems )
{
int oldConsumed;
PMDensity* density;
do
{
oldConsumed = m_consumedTokens;
density = new PMDensity( m_pPart );
if( !parseDensity( density ) )
{
delete density;
return false;
}
if( !insertChild( density, densityList ) )
delete density;
// In the last entry don't expect a comma
if( expectedItems-- )
if( m_token == ',' )
nextToken( );
}
while( oldConsumed != m_consumedTokens && expectedItems );
return true;
}
bool PMPovrayParser::parseColorMap( PMColorMap* colorMap )
{
int oldConsumed;
double f_number1, f_number2;
PMColor color1, color2;
PMSolidColor* solidColor;
PMSolidColor* lastColor = 0;
TQValueList<double> mapValues;
bool newEntry;
bool twoColors;
if( m_token != COLOR_MAP_TOK && m_token != COLOUR_MAP_TOK )
return false;
nextToken( );
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !colorMap->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
if( m_token == '[' )
{
nextToken( );
if( !parseFloat( f_number1 ) )
return false;
twoColors = false;
if( m_token == ',' )
{
twoColors = true;
nextToken( );
}
else if( ( m_token == INTEGER_TOK ) || ( m_token == FLOAT_TOK ) )
twoColors = true;
if( twoColors )
{
// Two colors in the same entry
if( parseFloat( f_number2 ) )
{
if( !parseColor( color1 ) )
return false;
if( !parseColor( color2 ) )
return false;
// If the first value doesn't pick up from the previous,
// or the color is different...
newEntry = true;
if( lastColor && !mapValues.isEmpty( ) )
if( ( mapValues.last( ) == f_number1 ) &&
( lastColor->color( ) == color1 ) )
newEntry = false;
if( newEntry )
{
// ... add the two colors in two different entries ...
mapValues.append( f_number1 );
solidColor = new PMSolidColor( m_pPart );
solidColor->setColor( color1 );
if( !insertChild( solidColor, colorMap ) )
delete solidColor;
else
lastColor = solidColor;
mapValues.append( f_number2 );
solidColor = new PMSolidColor( m_pPart );
solidColor->setColor( color2 );
if( !insertChild( solidColor, colorMap ) )
delete solidColor;
else
lastColor = solidColor;
}
else
{
// ... else just add the last value and color
mapValues.append( f_number2 );
solidColor = new PMSolidColor( m_pPart );
solidColor->setColor( color2 );
if( !insertChild( solidColor, colorMap ) )
delete solidColor;
else
lastColor = solidColor;
}
}
}
else
{
// Only one color in the entry
if( !parseColor( color1 ) )
return false;
mapValues.append( f_number1 );
solidColor = new PMSolidColor( m_pPart );
solidColor->setColor( color1 );
if( !insertChild( solidColor, colorMap ) )
delete solidColor;
else
lastColor = solidColor;
}
if( !parseToken( ']' ) )
return false;
}
}
while( oldConsumed != m_consumedTokens );
colorMap->setMapValues( mapValues );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseSkySphere( PMSkySphere* sky )
{
int oldConsumed;
if( !parseToken( SKY_SPHERE_TOK, "sky_sphere" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !sky->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( sky );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseRainbow( PMRainbow* rainbow )
{
PMVector vector;
double f_number;
int oldConsumed;
if( !parseToken( RAINBOW_TOK, "rainbow" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !rainbow->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( rainbow );
switch( m_token )
{
case DIRECTION_TOK:
nextToken( );
if( parseVector( vector ) )
{
rainbow->enableDirection( true );
rainbow->setDirection( vector );
}
break;
case ANGLE_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
rainbow->enableAngle( true );
rainbow->setAngle( f_number );
}
break;
case WIDTH_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
rainbow->enableWidth( true );
rainbow->setWidth( f_number );
}
break;
case DISTANCE_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
rainbow->enableDistance( true );
rainbow->setDistance( f_number );
}
break;
case JITTER_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
rainbow->enableJitter( true );
rainbow->setJitter( f_number );
}
break;
case UP_TOK:
nextToken( );
if( parseVector( vector ) )
{
rainbow->enableUp( true );
rainbow->setUp( vector );
}
break;
case ARC_ANGLE_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
rainbow->enableArcAngle( true );
rainbow->setArcAngle( f_number );
}
break;
case FALLOFF_ANGLE_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
rainbow->enableFalloffAngle( true );
rainbow->setFalloffAngle( f_number );
}
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseFog( PMFog* fog )
{
PMColor color;
PMVector vector;
double f_number;
int i_number;
int fog_type;
int oldConsumed;
if( !parseToken( FOG_TOK, "fog" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !fog->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
fog_type = 1;
if( parseToken( FOG_TYPE_TOK, "fog_type" ) )
{
if( !parseInt( i_number ) )
return false;
fog_type = i_number;
}
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case DISTANCE_TOK:
nextToken( );
if( parseFloat( f_number ) )
fog->setDistance( f_number );
break;
case '<':
case COLOR_TOK:
case COLOUR_TOK:
case RGB_TOK:
case RGBT_TOK:
case RGBF_TOK:
case RGBFT_TOK:
case RED_TOK:
case GREEN_TOK:
case BLUE_TOK:
case TRANSMIT_TOK:
case FILTER_TOK:
case ID_TOK:
if( parseColor( color ) )
fog->setColor( color );
break;
case TURBULENCE_TOK:
nextToken( );
fog->enableTurbulence( true );
if( !parseVector( vector ) )
return false;
fog->setValueVector( vector );
break;
case OCTAVES_TOK:
nextToken( );
if( !parseInt( i_number ) )
return false;
fog->setOctaves( i_number );
break;
case OMEGA_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
fog->setOmega( f_number );
break;
case LAMBDA_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
fog->setLambda( f_number );
break;
case TURB_DEPTH_TOK:
nextToken( );
if( !parseFloat( f_number ) )
return false;
fog->setDepth( f_number );
break;
case FOG_OFFSET_TOK:
nextToken( );
fog_type = 2;
if( parseFloat( f_number ) )
fog->setFogOffset( f_number );
break;
case FOG_ALT_TOK:
nextToken( );
fog_type = 2;
if( parseFloat( f_number ) )
fog->setFogAlt( f_number );
break;
case UP_TOK:
nextToken( );
fog_type = 2;
if( !parseVector( vector ) )
return false;
fog->setUp( vector );
break;
default:
break;
}
// Only parseChildObjects() if the token is not turbulence, because this
// function parses that token.
if( m_token != TURBULENCE_TOK )
parseChildObjects( fog );
}
while( oldConsumed != m_consumedTokens );
fog->setFogType( fog_type );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseMedia( PMMedia* media )
{
PMColor color;
double f_number;
int i_number;
int oldConsumed, oldConsumed1;
if( !parseToken( MEDIA_TOK, "media" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !media->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( media );
switch( m_token )
{
case METHOD_TOK:
nextToken( );
if( parseInt( i_number ) )
media->setMethod( i_number );
break;
case INTERVALS_TOK:
nextToken( );
if( parseInt( i_number ) )
media->setIntervals( i_number );
break;
case SAMPLES_TOK:
nextToken( );
if( parseInt( i_number ) )
media->setSamplesMin( i_number );
parseToken( ',' );
if( parseInt( i_number ) )
media->setSamplesMax( i_number );
break;
case CONFIDENCE_TOK:
nextToken( );
if( parseFloat( f_number ) )
media->setConfidence( f_number );
break;
case VARIANCE_TOK:
nextToken( );
if( parseFloat( f_number ) )
media->setVariance( f_number );
break;
case RATIO_TOK:
nextToken( );
if( parseFloat( f_number ) )
media->setRatio( f_number );
break;
case AA_LEVEL_TOK:
nextToken( );
if ( parseInt( i_number ) )
media->setAALevel( i_number );
break;
case AA_THRESHOLD_TOK:
nextToken( );
if ( parseFloat( f_number ) )
media->setAAThreshold( f_number );
break;
case ABSORPTION_TOK:
nextToken( );
if( parseColor( color ) )
{
media->enableAbsorption( true );
media->setAbsorption( color );
}
break;
case EMISSION_TOK:
nextToken( );
media->enableEmission( true );
if( parseColor( color ) )
media->setEmission( color );
break;
case SCATTERING_TOK:
nextToken( );
parseToken( '{' );
media->enableScattering( true );
if( parseInt( i_number ) )
media->setScatteringType( i_number );
parseToken( ',' );
if( parseColor( color ) )
media->setScatteringColor( color );
do
{
oldConsumed1 = m_consumedTokens;
switch( m_token )
{
case ECCENTRICITY_TOK:
nextToken( );
if( parseFloat( f_number ) )
media->setScatteringEccentricity( f_number );
break;
case EXTINCTION_TOK:
nextToken( );
if( parseFloat( f_number ) )
media->setScatteringExtinction( f_number );
break;
default:
break;
}
}
while( oldConsumed1 != m_consumedTokens );
parseToken( '}' );
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseDensity( PMDensity* density )
{
int oldConsumed;
if( !parseToken( DENSITY_TOK, "density" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !density->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( density );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseInterior( PMInterior* interior )
{
double f_number;
int i_number;
int oldConsumed;
if( !parseToken( INTERIOR_TOK, "interior" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !interior->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( interior );
switch( m_token )
{
case IOR_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
interior->enableIor( true );
interior->setIor( f_number );
}
break;
case CAUSTICS_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
interior->enableCaustics( true );
interior->setCaustics( f_number );
}
break;
case DISPERSION_TOK:
nextToken( );
if ( parseFloat( f_number ) )
{
interior->enableDispersion( true );
interior->setDispersion( f_number );
}
break;
case DISPERSION_SAMPLES_TOK:
nextToken( );
if ( parseInt( i_number ) )
{
interior->enableDispSamples( true );
interior->setDispSamples( i_number );
}
break;
case FADE_DISTANCE_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
interior->enableFadeDistance( true );
interior->setFadeDistance( f_number );
}
break;
case FADE_POWER_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
interior->enableFadePower( true );
interior->setFadePower( f_number );
}
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseMaterial( PMMaterial* material )
{
int oldConsumed;
if( !parseToken( MATERIAL_TOK, "material" ) )
return false;
if( !parseToken( '{' ) )
return false;
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !material->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( material );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseSlope( PMSlope* slope )
{
double f_number;
if( !parseToken( '<' ) )
return false;
if( !parseFloat( f_number ) )
return false;
slope->setHeight( f_number );
if( !parseToken( ',' ) )
return false;
if( !parseFloat( f_number ) )
return false;
slope->setSlope( f_number );
if( !parseToken( '>' ) )
return false;
return true;
}
bool PMPovrayParser::parseGlobalSettings( PMGlobalSettings* globalsettings )
{
PMColor color;
double f_number;
int i_number;
int oldConsumed;
// Initial global settings tokens
if( !parseToken( GLOBAL_SETTINGS_TOK, "global_settings" ) )
return false;
if( !parseToken( '{' ) )
return false;
// Parse global settings tokens
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( globalsettings );
switch( m_token )
{
case ADC_BAILOUT_TOK:
nextToken( );
if( parseFloat( f_number ) )
globalsettings->setAdcBailout( f_number );
break;
case AMBIENT_LIGHT_TOK:
nextToken( );
if( parseColor( color ) )
globalsettings->setAmbientLight( color );
break;
case ASSUMED_GAMMA_TOK:
nextToken( );
if( parseFloat( f_number ) )
globalsettings->setAssumedGamma( f_number );
break;
case HF_GRAY_16_TOK:
nextToken( );
switch( m_token )
{
case ON_TOK:
globalsettings->setHfGray16( true );
nextToken( );
break;
case OFF_TOK:
globalsettings->setHfGray16( false );
nextToken( );
break;
default:
break;
}
break;
case IRID_WAVELENGTH_TOK:
nextToken( );
if( parseColor( color ) )
globalsettings->setIridWaveLength( color );
break;
case MAX_INTERSECTIONS_TOK:
nextToken( );
if( parseInt( i_number ) )
globalsettings->setMaxIntersections( i_number );
break;
case MAX_TRACE_LEVEL_TOK:
nextToken( );
if( parseInt( i_number ) )
globalsettings->setMaxTraceLevel( i_number );
break;
case NUMBER_OF_WAVES_TOK:
nextToken( );
if( parseInt( i_number ) )
globalsettings->setNumberWaves( i_number );
break;
case NOISE_GENERATOR_TOK:
nextToken( );
if ( parseInt( i_number ) )
globalsettings->setNoiseGenerator(
( PMGlobalSettings::PMNoiseType ) ( i_number - 1 ) );
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseFinish( PMFinish* finish )
{
PMColor color;
double f_number;
int oldConsumed, oldConsumed1;
// Initial finish tokens "finish {"
if( !parseToken( FINISH_TOK, "finish" ) )
return false;
if( !parseToken( '{' ) )
return false;
// Parse a possible declare link identifier
if( m_token == ID_TOK )
{
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !finish->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
}
// Parse finish tokens
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case AMBIENT_TOK:
nextToken( );
finish->enableAmbient( true );
if( parseColor( color ) )
finish->setAmbientColor( color );
break;
case DIFFUSE_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
finish->enableDiffuse( true );
finish->setDiffuse( f_number );
}
break;
case BRILLIANCE_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
finish->enableBrilliance( true );
finish->setBrilliance( f_number );
}
break;
case PHONG_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
finish->enablePhong( true );
finish->setPhong( f_number );
}
break;
case PHONG_SIZE_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
finish->enablePhongSize( true );
finish->setPhongSize( f_number );
}
break;
case METALLIC_TOK:
nextToken( );
finish->enableMetallic( true );
finish->setMetallic( 1.0 );
if( parseFloat( f_number, true ) )
finish->setMetallic( f_number );
break;
case SPECULAR_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
finish->enableSpecular( true );
finish->setSpecular( f_number );
}
break;
case ROUGHNESS_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
finish->enableRoughness( true );
finish->setRoughness( f_number );
}
break;
case CRAND_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
finish->enableCrand( true );
finish->setCrand( f_number );
}
break;
case CONSERVE_ENERGY_TOK:
nextToken( );
finish->setConserveEnergy( parseBool( ) );
break;
case REFLECTION_TOK:
nextToken( );
finish->enableReflection( true );
if( !parseToken( '{' ) )
{
printError( i18n( "Using Old Reflection Syntax" ) );
if( parseColor( color ) )
finish->setReflectionColor( color );
}
else if( parseColor( color ) )
{
if( parseToken( ',' ) )
{
finish->enableReflectionMin( true );
finish->setReflectionMinColor( color );
if( parseColor( color ) )
finish->setReflectionColor( color );
else
return false;
}
else
finish->setReflectionColor( color );
do
{
oldConsumed1 = m_consumedTokens;
switch( m_token )
{
case FRESNEL_TOK:
nextToken( );
finish->setReflectionFresnel( parseBool( ) );
break;
case FALLOFF_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
finish->enableRefFalloff( true );
finish->setReflectionFalloff( f_number );
}
break;
case EXPONENT_TOK:
nextToken( );
if( parseFloat( f_number ) )
{
finish->enableRefExponent( true );
finish->setReflectionExponent( f_number );
}
break;
case METALLIC_TOK:
nextToken( );
if ( parseFloat( f_number ) )
{
finish->enableRefMetallic( true );
finish->setReflectionMetallic( f_number );
}
break;
default:
break;
}
}
while( oldConsumed1 != m_consumedTokens );
parseToken( '}' );
}
else
return false;
break;
case REFLECTION_EXPONENT_TOK:
nextToken( );
if ( parseFloat( f_number ) )
{
finish->enableRefExponent( true );
finish->setReflectionExponent( f_number );
}
break;
case IRID_TOK:
nextToken( );
parseToken( '{' );
finish->setIrid( true );
if( parseFloat( f_number ) )
finish->setIridAmount( f_number );
do
{
oldConsumed1 = m_consumedTokens;
switch( m_token )
{
case THICKNESS_TOK:
nextToken( );
if( parseFloat( f_number ) )
finish->setIridThickness( f_number );
break;
case TURBULENCE_TOK:
nextToken( );
if( parseFloat( f_number ) )
finish->setIridTurbulence( f_number );
break;
default:
break;
}
}
while( oldConsumed1 != m_consumedTokens );
parseToken( '}' );
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseDeclare( PMDeclare* decl )
{
PMObject* child = 0;
PMTexture* texture = 0;
bool error = false;
switch( m_token )
{
case OBJECT_TOK:
error = !parseObject( decl );
break;
// finite solid
case BLOB_TOK:
child = new PMBlob( m_pPart );
error = !parseBlob( ( PMBlob* ) child );
break;
case BOX_TOK:
child = new PMBox( m_pPart );
error = !parseBox( ( PMBox* ) child );
break;
case CONE_TOK:
child = new PMCone( m_pPart );
error = !parseCone( ( PMCone* ) child );
break;
case CYLINDER_TOK:
child = new PMCylinder( m_pPart );
error = !parseCylinder( ( PMCylinder* ) child );
break;
case HEIGHT_FIELD_TOK:
child = new PMHeightField( m_pPart );
error = !parseHeightField( ( PMHeightField* ) child );
break;
case JULIA_FRACTAL_TOK:
child = new PMJuliaFractal( m_pPart );
error = !parseJuliaFractal( ( PMJuliaFractal* ) child );
break;
case LATHE_TOK:
child = new PMLathe( m_pPart );
error = !parseLathe( ( PMLathe* ) child );
break;
case PRISM_TOK:
child = new PMPrism( m_pPart );
error = !parsePrism( ( PMPrism* ) child );
break;
case SPHERE_TOK:
child = new PMSphere( m_pPart );
error = !parseSphere( ( PMSphere* ) child );
break;
case SUPERELLIPSOID_TOK:
child = new PMSuperquadricEllipsoid( m_pPart );
error = !parseSqe( ( PMSuperquadricEllipsoid* ) child );
break;
case SOR_TOK:
child = new PMSurfaceOfRevolution( m_pPart );
error = !parseSor( ( PMSurfaceOfRevolution* ) child );
break;
case TEXT_TOK:
child = new PMText( m_pPart );
error = !parseText( ( PMText* ) child );
break;
case TORUS_TOK:
child = new PMTorus( m_pPart );
error = !parseTorus( ( PMTorus* ) child );
break;
// finite patch
case BICUBIC_PATCH_TOK:
child = new PMBicubicPatch( m_pPart );
error = !parseBicubicPatch( ( PMBicubicPatch* ) child );
break;
case DISC_TOK:
child = new PMDisc( m_pPart );
error = !parseDisc( ( PMDisc* ) child );
break;
case TRIANGLE_TOK:
case SMOOTH_TRIANGLE_TOK:
child = new PMTriangle( m_pPart );
error = !parseTriangle( ( PMTriangle* ) child );
break;
// infinite solid
case PLANE_TOK:
child = new PMPlane( m_pPart );
error = !parsePlane( ( PMPlane* ) child );
break;
case TQUADRIC_TOK:
case CUBIC_TOK:
case TQUARTIC_TOK:
case POLY_TOK:
child = new PMPolynom( m_pPart );
error = !parsePolynom( ( PMPolynom* ) child );
break;
// csg
case UNION_TOK:
case DIFFERENCE_TOK:
case INTERSECTION_TOK:
case MERGE_TOK:
child = new PMCSG( m_pPart );
error = !parseCSG( ( PMCSG* ) child );
break;
// textures
case TEXTURE_TOK:
while( m_token == TEXTURE_TOK )
{
texture = new PMTexture( m_pPart );
if( !parseTexture( texture ) )
error = true;
if( !insertChild( texture, decl ) )
{
delete texture;
texture = 0;
}
}
break;
case PIGMENT_TOK:
child = new PMPigment( m_pPart );
error = !parsePigment( ( PMPigment* ) child );
break;
case NORMAL_TOK:
child = new PMNormal( m_pPart );
error = !parseNormal( ( PMNormal* ) child );
break;
case FINISH_TOK:
child = new PMFinish( m_pPart );
error = !parseFinish( ( PMFinish* ) child );
break;
case TEXTURE_MAP_TOK:
child = new PMTextureMap( m_pPart );
error = !parseTextureMap( ( PMTextureMap* ) child );
break;
case PIGMENT_MAP_TOK:
child = new PMPigmentMap( m_pPart );
error = !parsePigmentMap( ( PMPigmentMap* ) child );
break;
case COLOR_MAP_TOK:
case COLOUR_MAP_TOK:
child = new PMColorMap( m_pPart );
error = !parseColorMap( ( PMColorMap* ) child );
break;
case NORMAL_MAP_TOK:
child = new PMNormalMap( m_pPart );
error = !parseNormalMap( ( PMNormalMap* ) child );
break;
case SLOPE_MAP_TOK:
child = new PMSlopeMap( m_pPart );
error = !parseSlopeMap( ( PMSlopeMap* ) child );
break;
case DENSITY_MAP_TOK:
child = new PMDensityMap( m_pPart );
error = !parseDensityMap( ( PMDensityMap* ) child );
break;
case INTERIOR_TOK:
child = new PMInterior( m_pPart );
error = !parseInterior( ( PMInterior* ) child );
break;
case MEDIA_TOK:
child = new PMMedia( m_pPart );
error = !parseMedia( ( PMMedia* ) child );
break;
case DENSITY_TOK:
child = new PMDensity( m_pPart );
error = !parseDensity( ( PMDensity* ) child );
break;
case MATERIAL_TOK:
child = new PMMaterial( m_pPart );
error = !parseMaterial( ( PMMaterial* ) child );
break;
case SKY_SPHERE_TOK:
child = new PMSkySphere( m_pPart );
error = !parseSkySphere( ( PMSkySphere* ) child );
break;
case RAINBOW_TOK:
child = new PMRainbow( m_pPart );
error = !parseRainbow( ( PMRainbow* ) child );
break;
case FOG_TOK:
child = new PMFog( m_pPart );
error = !parseFog( ( PMFog* ) child );
break;
// misc
case LIGHT_SOURCE_TOK:
child = new PMLight( m_pPart );
error = !parseLight( ( PMLight* ) child );
break;
case ISOSURFACE_TOK:
child = new PMIsoSurface( m_pPart );
error = !parseIsoSurface( ( PMIsoSurface* ) child );
break;
case PHOTONS_TOK:
child = new PMPhotons( m_pPart );
error = !parsePhotons( ( PMPhotons* ) child );
break;
case LIGHT_GROUP_TOK:
child = new PMLightGroup( m_pPart );
error = !parseLightGroup( ( PMLightGroup* ) child );
break;
case INTERIOR_TEXTURE_TOK:
child = new PMInteriorTexture( m_pPart );
error = !parseInteriorTexture( ( PMInteriorTexture* ) child );
break;
case SPHERE_SWEEP_TOK:
child = new PMSphereSweep( m_pPart );
error = !parseSphereSweep( ( PMSphereSweep* ) child );
break;
case MESH_TOK:
child = new PMMesh( m_pPart );
error = !parseMesh( ( PMMesh* ) child );
break;
}
if( child )
{
if( !insertChild( child, decl ) )
{
delete child;
child = 0;
}
}
return !error;
}
bool PMPovrayParser::parseObject( PMCompositeObject* parent )
{
PMObject* child;
bool error = false;
if( !parseToken( OBJECT_TOK, "object" ) )
return false;
if( parseToken( '{' ) )
{
switch( m_token )
{
case ID_TOK:
child = new PMObjectLink( m_pPart );
error = !parseObjectLink( ( PMObjectLink* ) child );
if( !insertChild( child, parent ) )
delete child;
break;
default:
{
PMObject* lastChild = 0;
if( parent )
lastChild = parent->lastChild( );
else
lastChild = m_pResultList->last( );
error = !parseChildObjects( parent, 1 );
if( !error )
{
PMObject* newLast = 0;
if( parent )
newLast = parent->lastChild( );
else
newLast = m_pResultList->last( );
if( newLast && ( newLast != lastChild ) &&
newLast->isA( "CompositeObject" ) )
{
// one child was parsed
// append all following objects
error = !parseChildObjects( ( PMCompositeObject* ) newLast );
}
else
{
printError( i18n( "One graphical object expected" ) );
error = true;
}
}
break;
}
}
if( !parseToken( '}' ))
error = true;
}
else
error = true;
return !error;
}
bool PMPovrayParser::parseObjectLink( PMObjectLink* link )
{
int oldConsumed;
if( m_token != ID_TOK )
{
printExpected( "identifier", m_pScanner->sValue( ) );
return false;
}
TQString id( m_pScanner->sValue( ) );
PMDeclare* decl = checkLink( id );
if( decl )
{
if( !link->setLinkedObject( decl ) )
printError( i18n( "Wrong declare type" ) );
}
nextToken( );
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( link );
parseObjectModifiers( link );
}
while( oldConsumed != m_consumedTokens );
return true;
}
bool PMPovrayParser::parseIsoSurface( PMIsoSurface* iso )
{
PMVector vector;
double f;
int i;
int oldConsumed;
if( !parseToken( ISOSURFACE_TOK, "isosurface" ) )
return false;
if( !parseToken( '{' ) )
return false;
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( iso );
parseObjectModifiers( iso );
switch( m_token )
{
case FUNCTION_TOK:
nextToken( );
if( m_token != '{' )
{
printExpected( '{', m_pScanner->sValue( ) );
return false;
}
m_pScanner->scanFunction( );
nextToken( );
if( m_token != FUNCTION_TOK )
return false;
iso->setFunction( TQString( m_pScanner->sValue( ) ).simplifyWhiteSpace( ) );
nextToken( );
parseToken( '}' );
break;
case CONTAINED_BY_TOK:
nextToken( );
if( !parseToken( '{' ) )
return false;
if( m_token == BOX_TOK )
{
iso->setContainedBy( PMIsoSurface::Box );
nextToken( );
parseToken( '{' );
if( parseVector( vector ) )
iso->setCorner1( vector );
parseToken( ',' );
if( parseVector( vector ) )
iso->setCorner2( vector );
if( !parseToken( '}' ) )
return false;
}
else if( m_token == SPHERE_TOK )
{
iso->setContainedBy( PMIsoSurface::Sphere );
nextToken( );
parseToken( '{' );
if( parseVector( vector ) )
iso->setCenter( vector );
parseToken( ',' );
if( parseFloat( f ) )
iso->setRadius( f );
if( !parseToken( '}' ) )
return false;
}
else
{
printUnexpected( m_pScanner->sValue( ) );
return false;
}
if( !parseToken( '}' ) )
return false;
break;
case THRESHOLD_TOK:
nextToken( );
if( parseFloat( f ) )
iso->setThreshold( f );
break;
case ACCURACY_TOK:
nextToken( );
if( parseFloat( f ) )
iso->setAccuracy( f );
break;
case MAX_GRADIENT_TOK:
nextToken( );
if( parseFloat( f ) )
iso->setMaxGradient( f );
break;
case EVALUATE_TOK:
nextToken( );
iso->setEvaluate( true );
if( parseFloat( f ) )
{
iso->setEvaluateValue( 0, f );
if( parseToken( ',' ) && parseFloat( f ) )
{
iso->setEvaluateValue( 1, f );
if( parseToken( ',' ) && parseFloat( f ) )
iso->setEvaluateValue( 2, f );
}
}
break;
case OPEN_TOK:
nextToken( );
iso->setOpen( true );
break;
case MAX_TRACE_TOK:
nextToken( );
if( parseInt( i ) )
iso->setMaxTrace( i );
break;
case ALL_INTERSECTIONS_TOK:
nextToken( );
iso->setAllIntersections( true );
break;
default:
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseRadiosity( PMRadiosity* rad )
{
double f;
int i;
int oldConsumed;
if( !parseToken( RADIOSITY_TOK, "radiosity" ) )
return false;
if( !parseToken( '{' ) )
return false;
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case ADC_BAILOUT_TOK:
nextToken( );
if( parseFloat( f ) )
rad->setAdcBailout( f );
break;
case ALWAYS_SAMPLE_TOK:
nextToken( );
rad->setAlwaysSample( parseBool( ) );
break;
case BRIGHTNESS_TOK:
nextToken( );
if( parseFloat( f ) )
rad->setBrightness( f );
break;
case COUNT_TOK:
nextToken( );
if( parseInt( i ) )
rad->setCount( i );
break;
case ERROR_BOUND_TOK:
nextToken( );
if( parseFloat( f ) )
rad->setErrorBound( f );
break;
case GRAY_THRESHOLD_TOK:
nextToken( );
if( parseFloat( f ) )
rad->setGrayThreshold( f );
break;
case LOW_ERROR_FACTOR_TOK:
nextToken( );
if( parseFloat( f ) )
rad->setLowErrorFactor( f );
break;
case MAX_SAMPLE_TOK:
nextToken( );
if ( parseFloat( f ) )
rad->setMaxSample( f );
break;
case MEDIA_TOK:
nextToken( );
rad->setMedia( parseBool( ) );
break;
case MINIMUM_REUSE_TOK:
nextToken( );
if( parseFloat( f ) )
rad->setMinimumReuse( f );
break;
case NEAREST_COUNT_TOK:
nextToken( );
if( parseInt( i ) )
rad->setNearestCount( i );
break;
case NORMAL_TOK:
nextToken( );
rad->setNormal( parseBool( ) );
break;
case PRETRACE_START_TOK:
nextToken( );
if( parseFloat( f ) )
rad->setPretraceStart( f );
break;
case PRETRACE_END_TOK:
nextToken( );
if( parseFloat( f ) )
rad->setPretraceEnd( f );
break;
case RECURSION_LIMIT_TOK:
nextToken( );
if( parseInt( i) )
rad->setRecursionLimit( i );
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseGlobalPhotons( PMGlobalPhotons* gp )
{
double f;
int i;
int oldConsumed;
if( !parseToken( PHOTONS_TOK, "photons" ) )
return false;
if( !parseToken( '{' ) )
return false;
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case SPACING_TOK:
gp->setNumberType( PMGlobalPhotons::Spacing );
nextToken( );
if ( parseFloat( f ) )
gp->setSpacing( f );
break;
case COUNT_TOK:
gp->setNumberType( PMGlobalPhotons::Count );
nextToken( );
if ( parseInt( i ) )
gp->setCount( i );
break;
case GATHER_TOK:
nextToken( );
if ( parseInt( i ) )
{
gp->setGatherMin( i );
if ( parseToken( ',' ) && parseInt( i ) )
gp->setGatherMax( i );
}
break;
case MEDIA_TOK:
nextToken( );
if ( parseInt( i ) )
{
gp->setMediaMaxSteps( i );
if ( parseToken( ',' ) && parseFloat( f ) )
gp->setMediaFactor( f );
}
case JITTER_TOK:
nextToken( );
if ( parseFloat( f ) )
gp->setJitter( f );
break;
case MAX_TRACE_LEVEL_TOK:
nextToken( );
gp->setMaxTraceLevelGlobal( false );
if ( parseInt( i ) )
gp->setMaxTraceLevel( i );
break;
case ADC_BAILOUT_TOK:
nextToken( );
gp->setAdcBailoutGlobal( false );
if ( parseFloat( f ) )
gp->setAdcBailout( f );
break;
case AUTOSTOP_TOK:
nextToken( );
if ( parseFloat( f ) )
gp->setAutostop( f );
break;
case EXPAND_THRESHOLDS_TOK:
nextToken( );
if ( parseFloat( f ) )
{
gp->setExpandIncrease( f );
if ( parseToken( ',' ) && parseInt( i ) )
gp->setExpandMin( i );
}
break;
case RADIUS_TOK:
nextToken( );
if ( parseFloat( f ) )
{
gp->setRadiusGather( f );
if ( parseToken( ',' ) && parseFloat( f ) )
{
gp->setRadiusGatherMulti( f );
if ( parseToken( ',' ) && parseFloat( f ) )
{
gp->setRadiusMedia( f );
if ( parseToken( ',' ) && parseFloat( f ) )
gp->setRadiusMediaMulti( f );
}
}
}
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parsePhotons( PMPhotons* p )
{
double f;
int oldConsumed;
if( !parseToken( PHOTONS_TOK, "photons" ) )
return false;
if( !parseToken( '{' ) )
return false;
p->setTarget( false );
do
{
oldConsumed = m_consumedTokens;
switch( m_token )
{
case TARGET_TOK:
nextToken( );
p->setTarget( true );
if ( parseFloat( f ) )
p->setSpacingMulti( f );
break;
case REFRACTION_TOK:
nextToken( );
p->setRefraction( parseBool( ) );
break;
case REFLECTION_TOK:
nextToken( );
p->setReflection( parseBool( ) );
break;
case COLLECT_TOK:
nextToken( );
p->setCollect( parseBool( ) );
break;
case PASS_THROUGH_TOK:
nextToken( );
p->setPassThrough( parseBool( ) );
break;
case AREA_LIGHT_TOK:
nextToken( );
p->setAreaLight( parseBool( ) );
break;
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseLightGroup( PMLightGroup* lg )
{
int oldConsumed;
if ( !parseToken( LIGHT_GROUP_TOK, "light_group" ) )
return false;
if( !parseToken( '{' ) )
return false;
do
{
oldConsumed = m_consumedTokens;
if ( m_token == GLOBAL_LIGHTS_TOK )
{
nextToken( );
lg->setGlobalLights( parseBool( ) );
}
else
{
parseChildObjects( lg );
parseObjectModifiers( lg );
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseInteriorTexture( PMInteriorTexture* it )
{
int oldConsumed;
if( !parseToken( INTERIOR_TEXTURE_TOK, "interior_texture" ) )
return false;
if( !parseToken( '{' ) )
return false;
do
{
oldConsumed = m_consumedTokens;
parseChildObjects( it );
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseSphereSweep( PMSphereSweep* ss )
{
int oldConsumed, numspheres;
TQValueList<PMVector> points;
TQValueList<double> radii;
PMVector point;
double f;
if( !parseToken( SPHERE_SWEEP_TOK, "sphere_sweep" ) )
return false;
if( !parseToken( '{' ) )
return false;
nextToken( );
switch ( m_token )
{
case LINEAR_SPLINE_TOK:
ss->setSplineType( PMSphereSweep::LinearSpline );
break;
case B_SPLINE_TOK:
ss->setSplineType( PMSphereSweep::BSpline );
break;
case CUBIC_SPLINE_TOK:
ss->setSplineType( PMSphereSweep::CubicSpline );
break;
default:
return false;
}
if ( !parseInt( numspheres ) )
return false;
for ( int i = 0; i < numspheres; ++i )
{
if ( !parseVector( point ) )
return false;
points.append( point );
if ( !parseToken( ',' ) )
return false;
if ( !parseFloat( f ) )
return false;
radii.append( f );
}
ss->setPoints( points );
ss->setRadii( radii );
do
{
oldConsumed = m_consumedTokens;
if ( m_token == TOLERANCE_TOK )
{
nextToken( );
if ( !parseFloat( f ) )
return false;
ss->setTolerance( f );
}
else
{
parseObjectModifiers( ss );
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}
bool PMPovrayParser::parseMesh( PMMesh* m )
{
int oldConsumed;
PMVector vector;
if( !parseToken( MESH_TOK, "mesh" ) )
return false;
if( !parseToken( '{' ) )
return false;
do
{
oldConsumed = m_consumedTokens;
if ( m_token == HIERARCHY_TOK )
{
nextToken( );
m->setHierarchy( parseBool( ) );
}
else if ( m_token == INSIDE_VECTOR_TOK )
{
nextToken( );
if ( !parseVector( vector ) )
return false;
m->enableInsideVector( true );
m->setInsideVector( vector );
}
else
{
parseChildObjects( m );
parseObjectModifiers( m );
}
}
while( oldConsumed != m_consumedTokens );
if( !parseToken( '}' ) )
return false;
return true;
}