//-*-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