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

535 lines
13 KiB

//-*-C++-*-
/*
**************************************************************************
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. *
* *
**************************************************************************/
#ifndef PMPOVRAYPARSER_H
#define PMPOVRAYPARSER_H
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "pmparser.h"
#include "pmcomment.h"
#include "pmvector.h"
class PMCompositeObject;
class PMGraphicalObject;
class PMBox;
class PMSphere;
class PMCylinder;
class PMCone;
class PMTorus;
class PMPlane;
class PMPolynom;
class PMDisc;
class PMBlob;
class PMBlobCylinder;
class PMBlobSphere;
class PMBicubicPatch;
class PMTriangle;
class PMCSG;
class PMHeightField;
class PMText;
class PMJuliaFractal;
class PMLathe;
class PMPrism;
class PMSurfaceOfRevolution;
class PMSuperquadricEllipsoid;
class PMScale;
class PMRotate;
class PMTranslate;
class PMBoundedBy;
class PMClippedBy;
class PMPovrayMatrix;
class PMCamera;
class PMLight;
class PMLooksLike;
class PMProjectedThrough;
class PMColor;
class PMTexture;
class PMPattern;
class PMBlendMapModifiers;
class PMWarp;
class PMPigment;
class PMNormal;
class PMTextureMap;
class PMPigmentMap;
class PMColorMap;
class PMNormalMap;
class PMBumpMap;
class PMMaterialMap;
class PMSlopeMap;
class PMDensityMap;
class PMListPattern;
class PMTextureList;
class PMPigmentList;
class PMColorList;
class PMNormalList;
class PMDensityList;
class PMImageMap;
class PMSlope;
class PMFinish;
class PMInterior;
class PMMedia;
class PMDensity;
class PMMaterial;
class PMSkySphere;
class PMRainbow;
class PMFog;
class PMDeclare;
class PMObjectLink;
class PMGlobalSettings;
class PMIsoSurface;
class PMRadiosity;
class PMGlobalPhotons;
class PMPhotons;
class PMLightGroup;
class PMInteriorTexture;
class PMSphereSweep;
class PMMesh;
/**
* Parser that parses povray code.
*
* All parse functions return false or 0 if an error occurred and the parse
* function couldn't recover.
*/
class PMPovrayParser : public PMParser
{
public:
/**
* Parser that parses the device
*/
PMPovrayParser( PMPart* part, TQIODevice* device );
/**
* Parser that parses the byte array
*/
PMPovrayParser( PMPart* part, const TQByteArray& array );
/**
* Deletes the parser
*/
virtual ~PMPovrayParser( );
protected:
/**
* Top level parse function
*/
virtual void topParse( );
private:
/**
* Initializes the parser
*/
void init( );
/**
* Sets m_token to the next token
*/
void nextToken( );
/**
* Returns true if the current token is ON_TOK, TRUE_TOK or YES_TOK
*/
bool isTrue( ) const;
/**
* Returns true if the current token is OFF_TOK, FALSE_TOK or NO_TOK
*/
bool isFalse( ) const;
/**
* Returns true if the next token is no bool value or one of the
* ON, TRUE or YES tokens
*/
bool parseBool( );
/**
* Looks for child objects, parses them and appends them to the parent
* object. If parent is 0, all objects are appended to the result list.
*
* If max is > 0, then the maximum number of parsed objects is max.
*
* Returns true if there where no objects or parsing was successful.
*/
bool parseChildObjects( PMCompositeObject* parent, int max = -1 );
/**
* Parses the token t.
*
* If the next token is not t, it appends an error to the messages
* and returns false.
*
* If t is not a single character token, set tokenName to the token
* name (like "box", "sphere" ...)
*/
bool parseToken( int t, const TQString& tokenName = TQString() );
/**
* Parses an item of a vector, float or color expression
*/
bool parseNumericItem( PMValue& v, bool checkForBool = false );
/**
* Parse function for a vector literal <x, y, z, ...>
*/
bool parseVectorLiteral( PMVector& v );
/**
* Parses a vector, float or color expression
*/
bool parseNumericExpression( PMValue& v, bool checkForBool = false );
/**
* parses a vector and float expression and returns a vector
* of size s
*/
bool parseVector( PMVector& v, unsigned int s=3 );
/**
* parses a vector and float expression and returns the
* float value or the first coordinate of the vector
*/
bool parseFloat( double& d, bool suppressError = false );
/**
* parses a float or int value and rounds if necessary
*/
bool parseInt( int& d );
/**
* parses a color expression
*/
bool parseColor( PMColor& c );
/**
* Parse function for object modifiers
*/
bool parseObjectModifiers( PMGraphicalObject* obj );
/**
* Parse function for cvs objects
*/
bool parseCSG( PMCSG* csg );
/**
* Parse function for box objects
*/
bool parseBox( PMBox* box );
/**
* Parse function for box objects
*/
bool parseSphere( PMSphere* sphere );
/**
* Parse function for cylinder objects
*/
bool parseCylinder( PMCylinder* pNewCyl );
/**
* Parse function for cone objects
*/
bool parseCone( PMCone* pNewCone );
/**
* Parse function for torus objects
*/
bool parseTorus( PMTorus* pNewTorus );
/**
* Parse function for blob objects
*/
bool parseBlob( PMBlob* pNewBlob );
/**
* Parse function for blob sphere components
*/
bool parseBlobSphere( PMBlobSphere* pNewBlobSphere );
/**
* Parse function for blob cylinder components
*/
bool parseBlobCylinder( PMBlobCylinder* pNewBlobCylinder );
/**
* Parse function for old blob components
*/
bool parseBlobComponent( PMBlobSphere* pNewBlobSphere );
/**
* Parse function for height fields
*/
bool parseHeightField( PMHeightField* pNewHeightField );
/**
* Parse function for text objects
*/
bool parseText( PMText* pNewText );
/**
* Parse function for julia fractals
*/
bool parseJuliaFractal( PMJuliaFractal* pNewFractal );
/**
* Parse function for plane objects
*/
bool parsePlane( PMPlane* pNewPlane );
/**
* Parse function for quadric, cubic, quartic and poly
*/
bool parsePolynom( PMPolynom* pNewPoly );
/**
* Parse function for bicubic patch objects
*/
bool parseBicubicPatch( PMBicubicPatch* pNewPatch );
/**
* Parse function for disks
*/
bool parseDisc( PMDisc* pNewDisc );
/**
* Parse function for triangles
*/
bool parseTriangle( PMTriangle* pNewTriangle );
/**
* Parse function for lathes
*/
bool parseLathe( PMLathe* pNewLathe );
/**
* Parse function for prisms
*/
bool parsePrism( PMPrism* pNewPrism );
/**
* Parse function for surface of revolutions
*/
bool parseSor( PMSurfaceOfRevolution* pNewSor );
/**
* Parse function for superquadric ellipsoid
*/
bool parseSqe( PMSuperquadricEllipsoid* pNewSqe );
/**
* Parse function for scale commands
*/
bool parseScale( PMScale* scale );
/**
* Parse function for rotate commands
*/
bool parseRotate( PMRotate* rotate );
/**
* Parse function for translate commands
*/
bool parseTranslate( PMTranslate* translate );
/**
* Parse function for matrix commands
*/
bool parseMatrix( PMPovrayMatrix* matrix );
/**
* Parse function for bounded_by statements
*/
bool parseBoundedBy( PMBoundedBy* bound );
/**
* Parse function for clipped_by statements
*/
bool parseClippedBy( PMClippedBy* clipped );
/**
* Parse function for camera objects
*/
bool parseCamera( PMCamera* camera );
/**
* Parse function for light objects
*/
bool parseLight( PMLight* light );
/**
* Parse function for looks_like statement
*/
bool parseLooksLike( PMLooksLike* ll );
/**
* Parse function for projected_through statement
*/
bool parseProjectedThrough( PMProjectedThrough* ll );
/**
* Parse function for texture objects. If parseOuter is false, the parser
* won't search for the texture{} wrapper. This is useful inside a texture
* map.
*/
bool parseTexture( PMTexture* pigment, bool parseOuter = true );
/**
* Parse function for pattern objects
*/
bool parsePattern( PMPattern* pattern, bool normal = false );
/**
* Parse function for blend map modifier objects
*/
bool parseBlendMapModifiers( PMBlendMapModifiers* blend );
/**
* Parse function for warp objects
*/
bool parseWarp( PMWarp* pattern );
/**
* Parse function for pigment objects
*/
bool parsePigment( PMPigment* pigment, bool parseOuter = true );
/**
* Parse function for normal objects
*/
bool parseNormal( PMNormal* normal );
/**
* Parse function for texture map objects
*/
bool parseTextureMap( PMTextureMap* textureMap );
/**
* Parse function for pigment map objects
*/
bool parsePigmentMap( PMPigmentMap* pigmentMap );
/**
* Parse function for color map objects
*/
bool parseColorMap( PMColorMap* colorMap );
/**
* Parse function for normal map objects
*/
bool parseNormalMap( PMNormalMap* normalMap );
/**
* Parse function for bump map objects
*/
bool parseBumpMap( PMBumpMap* bumpMap );
/**
* Parse function for material map objects
*/
bool parseMaterialMap( PMMaterialMap* materialMap );
/**
* Parse function for slope map objects
*/
bool parseSlopeMap( PMSlopeMap* slopeMap );
/**
* Parse function for density map objects
*/
bool parseDensityMap( PMDensityMap* densityMap );
/**
* Parse function for image map objects
*/
bool parseImageMap( PMImageMap* imageMap );
/**
* Parse function for slope objects
*/
bool parseSlope( PMSlope* slope );
/**
* Parse function for texture list objects
*/
bool parseTextureList( PMTextureList* textureList, int expectedItems );
/**
* Parse function for pigment list objects
*/
bool parsePigmentList( PMPigmentList* pigmentList, int expectedItems );
/**
* Parse function for color list objects
*/
bool parseColorList( PMColorList* colorList, int expectedItems );
/**
* Parse function for normal list objects
*/
bool parseNormalList( PMNormalList* normalList, int expectedItems );
/**
* Parse function for density list objects
*/
bool parseDensityList( PMDensityList* densityList, int expectedItems );
/**
* Parse function for finish objects
*/
bool parseFinish( PMFinish* finish );
/**
* Parse function for interior objects
*/
bool parseInterior( PMInterior* interior );
/**
* Parse function for media objects
*/
bool parseMedia( PMMedia* media );
/**
* Parse function for density objects
*/
bool parseDensity( PMDensity* density );
/**
* Parse function for material objects
*/
bool parseMaterial( PMMaterial* material );
/**
* Parse function for sky sphere objects
*/
bool parseSkySphere( PMSkySphere* sky );
/**
* Parse function for rainbow objects
*/
bool parseRainbow( PMRainbow* rainbow );
/**
* Parse function for fog objects
*/
bool parseFog( PMFog* fog );
/**
* Parse function for global settings
*/
bool parseGlobalSettings( PMGlobalSettings* decl );
/**
* Parse function for declares
*/
bool parseDeclare( PMDeclare* decl );
/**
* Parse function for object links
*/
bool parseObjectLink( PMObjectLink* link );
/**
* Parse function for object keywords
*/
bool parseObject( PMCompositeObject* parent );
// POV-Ray 3.5 objects
bool parseIsoSurface( PMIsoSurface* iso );
bool parseRadiosity( PMRadiosity* rad );
bool parseGlobalPhotons( PMGlobalPhotons* gp );
bool parsePhotons( PMPhotons* p );
bool parseLightGroup( PMLightGroup* lg );
bool parseInteriorTexture( PMInteriorTexture* it );
bool parseSphereSweep( PMSphereSweep * ss );
bool parseMesh( PMMesh* m );
/**
* The used scanner
*/
PMScanner* m_pScanner;
/**
* The last scanned token
*/
int m_token;
/**
* Number of consumed tokens.
*/
int m_consumedTokens;
/**
* All comments are skipped during parsing and stored here
*/
TQPtrList<PMComment> m_skippedComments;
/**
* The last skipped comment text with special kpovmodeler tags*/
TQString m_lastPMComment;
/**
* true if m_lastPMComment is empty
*/
bool m_bLastPMCommentEmpty;
};
#endif