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.
534 lines
13 KiB
534 lines
13 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. *
|
|
* *
|
|
**************************************************************************/
|
|
|
|
|
|
#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
|