|
From: <cha...@us...> - 2008-08-24 23:23:27
|
Revision: 18470
http://bzflag.svn.sourceforge.net/bzflag/?rev=18470&view=rev
Author: chaos-dev
Date: 2008-08-24 23:23:37 +0000 (Sun, 24 Aug 2008)
Log Message:
-----------
* Operation classes -- proper disposal
* Operation.h/cxx style cleanup
* OperationTemplate template for multi-expression templates
Modified Paths:
--------------
trunk/bzwgen/inc/Operation.h
trunk/bzwgen/inc/Product.h
trunk/bzwgen/src/Operation.cxx
Modified: trunk/bzwgen/inc/Operation.h
===================================================================
--- trunk/bzwgen/inc/Operation.h 2008-08-24 21:56:28 UTC (rev 18469)
+++ trunk/bzwgen/inc/Operation.h 2008-08-24 23:23:37 UTC (rev 18470)
@@ -24,19 +24,81 @@
protected:
RuleSet* ruleset;
public:
- Operation(RuleSet* _ruleset) : ruleset(_ruleset) {}
- virtual int runMesh(Mesh*,int) = 0;
+ Operation( RuleSet* _ruleset ) : ruleset( _ruleset ) {}
+ virtual int runMesh( Mesh*, int ) = 0;
virtual ~Operation() {}
};
typedef std::vector <Operation*> OperationVector;
typedef OperationVector::iterator OperationVectIter;
+template < int SIZE >
+class OperationTemplate : public Operation {
+protected:
+ typedef Expression* ExpressionPtr;
+ ExpressionPtr exp[SIZE];
+ double value[SIZE];
+public:
+ OperationTemplate( RuleSet* _ruleset )
+ : Operation( _ruleset ) {
+ for ( int i = 0; i < SIZE; ++i )
+ exp[i] = NULL;
+ }
+ void flatten( Mesh* mesh, int face ) {
+ for ( int i = 0; i < SIZE; ++i )
+ if ( exp[i] )
+ value[i] = exp[i]->calculate( mesh, face );
+ }
+ virtual ~OperationTemplate() {
+ for ( int i = 0; i < SIZE; ++i )
+ deletePointer( exp[i] );
+ }
+};
+
+class OperationSingle : public OperationTemplate<1> {
+public:
+ OperationSingle( RuleSet* _ruleset, Expression* exp0 )
+ : OperationTemplate<1>( _ruleset ) {
+ exp[0] = exp0;
+ }
+};
+
+class OperationDouble : public OperationTemplate<2> {
+public:
+ OperationDouble( RuleSet* _ruleset, Expression* exp0, Expression* exp1 )
+ : OperationTemplate<2>( _ruleset ) {
+ exp[0] = exp0;
+ exp[1] = exp1;
+ }
+};
+
+class OperationTriple : public OperationTemplate<3> {
+public:
+ OperationTriple( RuleSet* _ruleset, Expression* exp0, Expression* exp1, Expression* exp2 )
+ : OperationTemplate<3>( _ruleset ) {
+ exp[0] = exp0;
+ exp[1] = exp1;
+ exp[2] = exp2;
+ }
+};
+
+class OperationQuad : public OperationTemplate<4> {
+public:
+ OperationQuad( RuleSet* _ruleset, Expression* exp0, Expression* exp1, Expression* exp2, Expression* exp3 )
+ : OperationTemplate<4>( _ruleset ) {
+ exp[0] = exp0;
+ exp[1] = exp1;
+ exp[2] = exp2;
+ exp[3] = exp3;
+ }
+};
+
class OperationNonterminal : public Operation {
String ref;
public:
- OperationNonterminal(RuleSet* _ruleset, const char* _ref) : Operation(_ruleset), ref(_ref) { };
- int runMesh(Mesh* mesh, int face);
+ OperationNonterminal( RuleSet* _ruleset, const char* _ref )
+ : Operation( _ruleset ), ref( _ref ) { };
+ int runMesh( Mesh* mesh, int face );
};
class OperationLoadMaterial : public Operation {
@@ -44,37 +106,43 @@
String filename;
bool noradar;
public:
- OperationLoadMaterial(RuleSet* _ruleset, const char* _id, const char* _filename, bool _noradar ) : Operation(_ruleset), id(_id), filename(_filename), noradar(_noradar) { };
- int runMesh(Mesh* mesh, int face);
+ OperationLoadMaterial( RuleSet* _ruleset, const char* _id, const char* _filename, bool _noradar )
+ : Operation( _ruleset ), id( _id ), filename( _filename ), noradar( _noradar ) { };
+ int runMesh( Mesh* mesh, int face );
};
class OperationAddFace : public Operation {
String ref;
public:
- OperationAddFace(RuleSet* _ruleset, const char* _ref) : Operation(_ruleset), ref(_ref) { };
- int runMesh(Mesh* mesh, int face);
+ OperationAddFace( RuleSet* _ruleset, const char* _ref )
+ : Operation( _ruleset ), ref( _ref ) { };
+ int runMesh( Mesh* mesh, int face );
};
class OperationMultiFace : public Operation {
public:
- OperationMultiFace(RuleSet* _ruleset) : Operation(_ruleset) { };
- int runMesh(Mesh* mesh, int face);
+ OperationMultiFace( RuleSet* _ruleset ) : Operation( _ruleset ) { };
+ int runMesh( Mesh* mesh, int face );
};
class OperationSpawn : public Operation {
String ref;
public:
- OperationSpawn(RuleSet* _ruleset, const char* _ref) : Operation(_ruleset), ref(_ref) { };
- int runMesh(Mesh* mesh, int face);
+ OperationSpawn( RuleSet* _ruleset, const char* _ref )
+ : Operation( _ruleset ), ref( _ref ) { };
+ int runMesh( Mesh* mesh, int face );
};
class OperationUnchamfer : public Operation {
public:
- OperationUnchamfer(RuleSet* _ruleset) : Operation(_ruleset) { };
- int runMesh(Mesh* mesh, int face) {
+ OperationUnchamfer( RuleSet* _ruleset ) : Operation( _ruleset ) { };
+ int runMesh( Mesh* mesh, int face ) {
size_t size = mesh->getFace(face)->size();
- for ( size_t i = 0; i < size_t(size / 2); i++ ) {
- mesh->weldVertices( mesh->getFace(face)->getVertex( i ), mesh->getFace(face)->getVertex( i+1 ) );
+ for ( size_t i = 0; i < size_t( size / 2 ); i++ ) {
+ mesh->weldVertices(
+ mesh->getFace( face )->getVertex( i ),
+ mesh->getFace( face )->getVertex( i+1 )
+ );
}
return face;
}
@@ -82,17 +150,17 @@
class OperationFree : public Operation {
public:
- OperationFree(RuleSet* _ruleset) : Operation(_ruleset) { };
- int runMesh(Mesh* mesh, int face) {
- mesh->freeFace(face);
+ OperationFree( RuleSet* _ruleset ) : Operation( _ruleset ) { };
+ int runMesh( Mesh* mesh, int face ) {
+ mesh->freeFace( face );
return face;
}
};
class OperationDriveThrough : public Operation {
public:
- OperationDriveThrough(RuleSet* _ruleset) : Operation(_ruleset) { };
- int runMesh(Mesh* mesh, int face) {
+ OperationDriveThrough( RuleSet* _ruleset ) : Operation( _ruleset ) { };
+ int runMesh( Mesh* mesh, int face ) {
mesh->setPassable();
return face;
}
@@ -100,122 +168,112 @@
class OperationRemove : public Operation {
public:
- OperationRemove(RuleSet* _ruleset) : Operation(_ruleset) { };
- int runMesh(Mesh* mesh, int face) {
- mesh->getFace(face)->setOutput(false);
+ OperationRemove( RuleSet* _ruleset ) : Operation( _ruleset ) { };
+ int runMesh( Mesh* mesh, int face ) {
+ mesh->getFace( face )->setOutput( false );
return face;
}
};
class OperationTextureFull : public Operation {
public:
- OperationTextureFull(RuleSet* _ruleset) : Operation(_ruleset) { };
- int runMesh(Mesh* mesh, int face) {
- mesh->textureFaceFull(face);
+ OperationTextureFull( RuleSet* _ruleset ) : Operation( _ruleset ) { };
+ int runMesh( Mesh* mesh, int face ) {
+ mesh->textureFaceFull( face );
return face;
}
};
class OperationTextureClear : public Operation {
public:
- OperationTextureClear(RuleSet* _ruleset) : Operation(_ruleset) { };
- int runMesh(Mesh* mesh, int face) {
- mesh->getFace(face)->clearTexCoords();
+ OperationTextureClear( RuleSet* _ruleset ) : Operation( _ruleset ) { };
+ int runMesh( Mesh* mesh, int face ) {
+ mesh->getFace( face )->clearTexCoords();
return face;
}
};
class OperationTexture : public Operation {
public:
- OperationTexture(RuleSet* _ruleset) : Operation(_ruleset) { };
- int runMesh(Mesh* mesh, int face);
+ OperationTexture( RuleSet* _ruleset ) : Operation( _ruleset ) { };
+ int runMesh( Mesh* mesh, int face );
};
-class OperationTextureQuad : public Operation {
- Expression* a;
- Expression* b;
- Expression* c;
- Expression* d;
+class OperationTextureQuad : public OperationQuad {
public:
- OperationTextureQuad(RuleSet* _ruleset, Expression* _a, Expression* _b, Expression* _c, Expression* _d) : Operation(_ruleset), a(_a), b(_b), c(_c), d(_d) { };
- int runMesh(Mesh* mesh, int face) {
- mesh->textureFaceQuad(face,a->calculate(mesh,face),b->calculate(mesh,face),c->calculate(mesh,face),d->calculate(mesh,face));
+ OperationTextureQuad( RuleSet* _ruleset, Expression* exp0, Expression* exp1, Expression* exp2, Expression* exp3 )
+ : OperationQuad( _ruleset, exp0, exp1, exp2, exp3 ) { };
+ int runMesh( Mesh* mesh, int face ) {
+ flatten( mesh, face );
+ mesh->textureFaceQuad( face, value[0], value[1], value[2], value[3] );
return face;
}
};
-class OperationScale : public Operation {
- Expression* x;
- Expression* y;
+class OperationScale : public OperationDouble {
public:
- OperationScale(RuleSet* _ruleset, Expression* _x, Expression* _y) : Operation(_ruleset), x(_x), y(_y) { };
- int runMesh(Mesh* mesh, int face) {
+ OperationScale(RuleSet* _ruleset, Expression* x, Expression* y)
+ : OperationDouble(_ruleset, x, y ) { };
+ int runMesh( Mesh* mesh, int face ) {
if (mesh == NULL) return 0;
- mesh->scaleFace(face,x->calculate(mesh,face),y->calculate(mesh,face));
- return face;
+ flatten( mesh, face );
+ mesh->scaleFace( face, value[0], value[1] );
+ return face;
}
};
-class OperationTranslate : public Operation {
- Expression* x;
- Expression* y;
- Expression* z;
+class OperationTranslate : public OperationTriple {
public:
- OperationTranslate(RuleSet* _ruleset, Expression* _x, Expression* _y, Expression* _z) : Operation(_ruleset), x(_x), y(_y), z(_z) { };
- int runMesh(Mesh* mesh, int face) {
+ OperationTranslate(RuleSet* _ruleset, Expression* x, Expression* y, Expression* z)
+ : OperationTriple( _ruleset, x, y, z ) { };
+ int runMesh( Mesh* mesh, int face ) {
if (mesh == NULL) return 0;
- mesh->translateFace(face,x->calculate(mesh,face),y->calculate(mesh,face),z->calculate(mesh,face));
- return face;
+ flatten( mesh, face );
+ mesh->translateFace( face, value[0], value[1], value[2] );
+ return face;
}
};
-class OperationTranslateR : public Operation {
- Expression* x;
- Expression* y;
- Expression* z;
+class OperationTranslateR : public OperationTriple {
public:
- OperationTranslateR(RuleSet* _ruleset, Expression* _x, Expression* _y, Expression* _z) : Operation(_ruleset), x(_x), y(_y), z(_z) { };
- int runMesh(Mesh* mesh, int face) {
+ OperationTranslateR(RuleSet* _ruleset, Expression* x, Expression* y, Expression* z)
+ : OperationTriple( _ruleset, x, y, z ) { };
+ int runMesh( Mesh* mesh, int face ) {
if (mesh == NULL) return 0;
- mesh->translateFace(face,x->calculate(mesh,face)*mesh->faceH(face),y->calculate(mesh,face)*mesh->faceV(face),z->calculate(mesh,face)*mesh->faceCenter(face).z);
- return face;
+ mesh->translateFace( face, value[0]*mesh->faceH(face),
+ value[1]*mesh->faceV(face),
+ value[2]*mesh->faceCenter(face).z);
+ return face;
}
};
-class OperationSingle : public Operation {
-protected:
- Expression *exp;
- double value;
-public:
- OperationSingle(RuleSet* _ruleset, Expression* _exp) : Operation(_ruleset), exp(_exp) { };
- void flatten(Mesh* mesh,int face) { value = exp->calculate(mesh,face); }
- ~OperationSingle() {
- delete exp;
- }
-};
-class OperationNGon : public OperationSingle {
- Expression* nsize;
+class OperationNGon : public OperationDouble {
public:
- OperationNGon(RuleSet* _ruleset, Expression* _exp, Expression* _nsize = NULL) : OperationSingle(_ruleset,_exp), nsize(_nsize) {}
- int runMesh(Mesh* mesh,int face) {
- flatten(mesh,face);
+ OperationNGon(RuleSet* _ruleset, Expression* _exp, Expression* _nsize = NULL)
+ : OperationDouble( _ruleset, _exp, _nsize ) {}
+ int runMesh( Mesh* mesh,int face) {
+ flatten( mesh, face );
mesh->freeFace(face);
- if (nsize != NULL) {
- face = mesh->createNGon(mesh->faceCenter(face),nsize->calculate(mesh,face),math::roundToInt(value));
- } else {
- face = mesh->createNGon(mesh->faceCenter(face),math::min(mesh->faceH(face),mesh->faceV(face))/2,math::roundToInt(value));
+
+ int sides = math::roundToInt( value[0] );
+ double radius = value[1];
+ if ( exp[1] == NULL ) {
+ radius = math::min( mesh->faceH(face), mesh->faceV(face) ) / 2;
}
+ face = mesh->createNGon( mesh->faceCenter(face), radius, sides );
+
return face;
}
};
class OperationAssert : public OperationSingle {
public:
- OperationAssert(RuleSet* _ruleset, Expression* _exp) : OperationSingle(_ruleset,_exp) {}
- int runMesh(Mesh* mesh,int face) {
- flatten(mesh,face);
- if (value >= 0.0) return face; else return -1;
+ OperationAssert( RuleSet* _ruleset, Expression* _exp )
+ : OperationSingle( _ruleset, _exp ) { }
+ int runMesh( Mesh* mesh, int face ) {
+ flatten( mesh, face );
+ return value[0] >= 0.0 ? face : -1;
}
};
@@ -223,52 +281,57 @@
protected:
String attrname;
public:
- OperationAssign(RuleSet* _ruleset, Expression* _exp, const char* _attrname ) : OperationSingle(_ruleset,_exp), attrname(_attrname) {}
- int runMesh(Mesh*,int face);
+ OperationAssign( RuleSet* _ruleset, Expression* _exp, const char* _attrname )
+ : OperationSingle( _ruleset, _exp ), attrname( _attrname ) { }
+ int runMesh( Mesh*, int face );
};
class OperationMaterial : public OperationSingle {
public:
- OperationMaterial(RuleSet* _ruleset, Expression* _exp) : OperationSingle(_ruleset,_exp) {}
- int runMesh(Mesh* mesh,int face) {
- if (mesh == NULL) return 0;
- flatten(mesh,face);
- mesh->getFace(face)->setMaterial( math::roundToInt(value) );
- return face;
+ OperationMaterial( RuleSet* _ruleset, Expression* _exp )
+ : OperationSingle( _ruleset, _exp ) { }
+ int runMesh( Mesh* mesh, int face ) {
+ if ( mesh == NULL ) return 0;
+ flatten( mesh, face );
+ mesh->getFace( face )->setMaterial( math::roundToInt( value[0] ) );
+ return face;
};
};
class OperationExpand : public OperationSingle {
public:
- OperationExpand(RuleSet* _ruleset, Expression* _exp) : OperationSingle(_ruleset,_exp) {}
- int runMesh(Mesh* mesh,int face) {
- if (mesh == NULL) return 0;
- flatten(mesh,face);
- mesh->expandFace(face,value);
- return face;
+ OperationExpand( RuleSet* _ruleset, Expression* _exp )
+ : OperationSingle( _ruleset, _exp ) { }
+ int runMesh( Mesh* mesh,int face ) {
+ if ( mesh == NULL ) return 0;
+ flatten( mesh, face );
+ mesh->expandFace( face, value[0] );
+ return face;
};
};
class OperationTaper : public OperationSingle {
public:
- OperationTaper(RuleSet* _ruleset, Expression* _exp) : OperationSingle(_ruleset,_exp) {}
- int runMesh(Mesh* mesh,int face) {
- if (mesh == NULL) return 0;
- flatten(mesh,face);
- mesh->taperFace(face,value);
- return face;
+ OperationTaper( RuleSet* _ruleset, Expression* _exp )
+ : OperationSingle( _ruleset, _exp ) { }
+ int runMesh(Mesh* mesh,int face) {
+ if ( mesh == NULL ) return 0;
+ flatten( mesh, face );
+ mesh->taperFace( face, value[0] );
+ return face;
};
};
class OperationChamfer : public OperationSingle {
public:
- OperationChamfer(RuleSet* _ruleset, Expression* _exp) : OperationSingle(_ruleset,_exp) {}
- int runMesh(Mesh* mesh,int face) {
- if (mesh == NULL) return 0;
- flatten(mesh,face);
- mesh->chamferFace(face,value);
- return face;
+ OperationChamfer( RuleSet* _ruleset, Expression* _exp )
+ : OperationSingle( _ruleset, _exp ) { }
+ int runMesh( Mesh* mesh, int face ) {
+ if ( mesh == NULL ) return 0;
+ flatten( mesh, face );
+ mesh->chamferFace( face, value[0] );
+ return face;
};
};
@@ -277,45 +340,53 @@
StringVector* facerules;
bool allsame;
public:
- OperationMultifaces(RuleSet* _ruleset, Expression* _exp, StringVector* _facerules);
- int runMesh(Mesh* mesh,int, IntVector* faces);
+ OperationMultifaces( RuleSet* _ruleset, Expression* _exp, StringVector* _facerules );
+ int runMesh( Mesh* mesh, int, IntVector* faces );
~OperationMultifaces() {
- if (facerules != NULL) delete facerules;
- }
+ deletePointer( facerules );
+ }
};
class OperationDetachFace : public OperationMultifaces {
public:
- OperationDetachFace(RuleSet* _ruleset, Expression* _exp, StringVector* _facerules) : OperationMultifaces(_ruleset,_exp,_facerules) {}
- int runMesh(Mesh* mesh,int face);
+ OperationDetachFace( RuleSet* _ruleset, Expression* _exp, StringVector* _facerules )
+ : OperationMultifaces( _ruleset, _exp, _facerules ) { }
+ int runMesh( Mesh* mesh, int face );
};
class OperationExtrude : public OperationMultifaces {
public:
- OperationExtrude(RuleSet* _ruleset, Expression* _exp, StringVector* facerules) : OperationMultifaces(_ruleset,_exp,facerules) {}
- int runMesh(Mesh* mesh,int face);
+ OperationExtrude( RuleSet* _ruleset, Expression* _exp, StringVector* facerules )
+ : OperationMultifaces( _ruleset, _exp, facerules ) { }
+ int runMesh( Mesh* mesh, int face );
};
class OperationExtrudeT : public OperationMultifaces {
public:
- OperationExtrudeT(RuleSet* _ruleset, Expression* _exp, StringVector* facerules) : OperationMultifaces(_ruleset,_exp,facerules) {}
- int runMesh(Mesh* mesh,int face);
+ OperationExtrudeT( RuleSet* _ruleset, Expression* _exp, StringVector* facerules )
+ : OperationMultifaces( _ruleset, _exp, facerules ) { }
+ int runMesh( Mesh* mesh, int face );
};
class OperationSplitFace : public OperationMultifaces {
bool horiz;
ExpressionVector* splits;
public:
- OperationSplitFace(RuleSet* _ruleset, bool _horiz, StringVector* facerules, ExpressionVector* _splits, Expression* _esnap = NULL) : OperationMultifaces(_ruleset,_esnap,facerules), horiz(_horiz), splits(_splits) {}
- int runMesh(Mesh* mesh,int face);
+ OperationSplitFace( RuleSet* _ruleset, bool _horiz, StringVector* facerules, ExpressionVector* _splits, Expression* _esnap = NULL)
+ : OperationMultifaces( _ruleset, _esnap, facerules ), horiz( _horiz ), splits( _splits ) {}
+ int runMesh( Mesh* mesh, int face );
+ ~OperationSplitFace() {
+ deletePointerVector( splits );
+ }
};
class OperationRepeat : public OperationMultifaces {
bool horiz;
public:
- OperationRepeat(RuleSet* _ruleset, Expression* _exp, bool _horiz, StringVector* facerules) : OperationMultifaces(_ruleset,_exp,facerules), horiz(_horiz) {}
- int runMesh(Mesh* mesh,int face);
+ OperationRepeat( RuleSet* _ruleset, Expression* _exp, bool _horiz, StringVector* facerules )
+ : OperationMultifaces( _ruleset, _exp, facerules ), horiz( _horiz ) {}
+ int runMesh( Mesh* mesh, int face );
};
Modified: trunk/bzwgen/inc/Product.h
===================================================================
--- trunk/bzwgen/inc/Product.h 2008-08-24 21:56:28 UTC (rev 18469)
+++ trunk/bzwgen/inc/Product.h 2008-08-24 23:23:37 UTC (rev 18470)
@@ -83,12 +83,6 @@
~Product() {
deletePointerVector( operations );
deletePointer( condition );
- OperationVectIter itr;
-// for ( itr = ops->begin(); itr!= ops->end(); ++itr)
-// delete ( *itr );
-// delete ops;
-// if ( cond != NULL )
-// delete cond;
}
private:
/**
Modified: trunk/bzwgen/src/Operation.cxx
===================================================================
--- trunk/bzwgen/src/Operation.cxx 2008-08-24 21:56:28 UTC (rev 18469)
+++ trunk/bzwgen/src/Operation.cxx 2008-08-24 23:23:37 UTC (rev 18470)
@@ -14,151 +14,153 @@
#include "RuleSet.h"
#include "MultiFace.h"
-int OperationNonterminal::runMesh(Mesh* mesh, int face) {
- return ruleset->runMesh(mesh,face,ref);
+int OperationNonterminal::runMesh( Mesh* mesh, int face ) {
+ return ruleset->runMesh( mesh, face, ref );
}
-int OperationLoadMaterial::runMesh(Mesh*, int face) {
- ruleset->loadMaterial(id,filename,noradar);
+int OperationLoadMaterial::runMesh( Mesh*, int face ) {
+ ruleset->loadMaterial( id, filename, noradar );
return face;
}
-int OperationAddFace::runMesh(Mesh* mesh, int face) {
- if (!mesh->getFace(face)->isMultiFace()) {
- printf("Error: addface passed on a non-MultiFace face!");
+int OperationAddFace::runMesh( Mesh* mesh, int face ) {
+ if (!mesh->getFace( face )->isMultiFace()) {
+ Logger.log( "OperationAddFace: Error! addface passed on a non-MultiFace face!" );
return face;
}
int newface = mesh->rePushBase();
- newface = ruleset->runMesh(mesh,newface,ref);
- ((MultiFace*)mesh->getFace(face))->addFace(mesh->getFace(newface));
+ newface = ruleset->runMesh( mesh, newface, ref );
+ ( (MultiFace*) mesh->getFace( face ) )->addFace( mesh->getFace( newface ) );
return face;
}
-int OperationSpawn::runMesh(Mesh* mesh, int face) {
- ruleset->runNewMesh(mesh,face,ref);
+int OperationSpawn::runMesh( Mesh* mesh, int face ) {
+ ruleset->runNewMesh( mesh, face, ref );
return face;
}
-int OperationAssign::runMesh(Mesh* mesh, int face) {
- flatten(mesh,face);
- ruleset->addAttr(attrname,value);
- return face;
+int OperationAssign::runMesh( Mesh* mesh, int face ) {
+ flatten( mesh, face );
+ ruleset->addAttr( attrname, value[0] );
+ return face;
}
-OperationMultifaces::OperationMultifaces(RuleSet* _ruleset, Expression* _exp, StringVector* _facerules)
-: OperationSingle(_ruleset, _exp), facerules(_facerules), allsame(false) {
- if (facerules != NULL) {
- if (facerules->size() == 0) {
- delete facerules;
+OperationMultifaces::OperationMultifaces( RuleSet* _ruleset, Expression* _exp, StringVector* _facerules )
+: OperationSingle( _ruleset, _exp ), facerules( _facerules ), allsame( false ) {
+ if ( facerules != NULL ) {
+ if ( facerules->size() == 0 ) {
+ delete facerules;
facerules = NULL;
} else
- if (facerules->size() == 1 && facerules->at(0)[0] == '@') {
+ if ( facerules->size() == 1 && facerules->at(0)[0] == '@' ) {
allsame = true;
- facerules->at(0).erase(0,1);
+ facerules->at( 0 ).erase( 0, 1 );
}
}
}
int OperationDetachFace::runMesh(Mesh* mesh,int face) {
- if (!mesh->getFace(face)->isMultiFace()) {
- printf("Error: detachface passed on a non-MultiFace face!");
+ if ( !mesh->getFace( face)->isMultiFace() ) {
+ Logger.log( "OperationDetachFace: Error! detachface passed on a non-MultiFace face!" );
return face;
}
- flatten(mesh,face);
- IntVector* faces = ((MultiFace*)mesh->getFace(face))->detachFace(math::roundToInt(value));
- if (faces != NULL) {
- OperationMultifaces::runMesh(mesh,face,faces);
+ flatten( mesh,face );
+ IntVector* faces = ( (MultiFace*)mesh->getFace( face ) )->detachFace( math::roundToInt( value[0] ) );
+ if ( faces != NULL ) {
+ OperationMultifaces::runMesh( mesh, face, faces );
delete faces;
}
return face;
}
-int OperationMultifaces::runMesh(Mesh* mesh,int,IntVector* faces) {
- if (mesh == NULL) return 0;
- if (allsame) {
- for (size_t i = 0; i < faces->size(); i++)
- ruleset->runMesh(mesh,faces->at(i),facerules->at(0));
+int OperationMultifaces::runMesh( Mesh* mesh, int, IntVector* faces ) {
+ if ( mesh == NULL ) return 0;
+ if ( allsame ) {
+ for ( size_t i = 0; i < faces->size(); i++ )
+ ruleset->runMesh( mesh, faces->at(i), facerules->at(0) );
return 0;
}
- if (facerules != NULL) {
- for (size_t i = 0; i < facerules->size(); i++) {
- if (facerules->at(i).empty()) continue;
- if (i >= faces->size()) break;
- ruleset->runMesh(mesh,faces->at(i),facerules->at(i));
+ if ( facerules != NULL ) {
+ for ( size_t i = 0; i < facerules->size(); i++ ) {
+ if ( facerules->at(i).empty() ) continue;
+ if ( i >= faces->size() ) break;
+ ruleset->runMesh( mesh, faces->at(i), facerules->at(i) );
}
}
return 0;
}
-int OperationExtrude::runMesh(Mesh* mesh,int face) {
- if (mesh == NULL) return 0;
- flatten(mesh,face);
- if (facerules != NULL) {
+int OperationExtrude::runMesh( Mesh* mesh, int face ) {
+ if ( mesh == NULL ) return 0;
+ flatten( mesh, face );
+ if ( facerules != NULL ) {
IntVector* faces = new IntVector;
- mesh->extrudeFace(face,value,mesh->getFace(face)->getMaterial(),faces);
- OperationMultifaces::runMesh(mesh,face,faces);
+ mesh->extrudeFace( face, value[0], mesh->getFace( face )->getMaterial(), faces );
+ OperationMultifaces::runMesh( mesh, face, faces );
delete faces;
} else {
- mesh->extrudeFace(face,value,mesh->getFace(face)->getMaterial());
+ mesh->extrudeFace( face, value[0], mesh->getFace( face )->getMaterial() );
}
- return face;
+ return face;
}
-int OperationExtrudeT::runMesh(Mesh* mesh,int face) {
+int OperationExtrudeT::runMesh( Mesh* mesh, int face ) {
if (mesh == NULL) return 0;
- flatten(mesh,face);
+ flatten( mesh, face );
IntVector* faces = new IntVector;
- mesh->extrudeFace(face,value,mesh->getFace(face)->getMaterial(), faces);
- double snap = ruleset->getAttr("SNAP");
- double textile = ruleset->getAttr("TEXTILE");
- for (size_t i = 0; i < faces->size(); i++) {
- mesh->textureFace(faces->at(i),snap,textile);
+ mesh->extrudeFace( face, value[0], mesh->getFace( face )->getMaterial(), faces );
+
+ double snap = ruleset->getAttr( "SNAP" );
+ double textile = ruleset->getAttr( "TEXTILE" );
+
+ for ( size_t i = 0; i < faces->size(); i++ ) {
+ mesh->textureFace( faces->at(i), snap, textile );
}
- if (facerules != NULL) {
- OperationMultifaces::runMesh(mesh,face,faces);
+ if ( facerules != NULL ) {
+ OperationMultifaces::runMesh( mesh, face, faces );
}
delete faces;
- return face;
+ return face;
}
-int OperationTexture::runMesh(Mesh* mesh, int face) {
- mesh->textureFace(face,ruleset->getAttr("SNAP"),ruleset->getAttr("TEXTILE"));
+int OperationTexture::runMesh( Mesh* mesh, int face ) {
+ mesh->textureFace( face, ruleset->getAttr( "SNAP" ), ruleset->getAttr( "TEXTILE" ) );
return face;
}
-int OperationSplitFace::runMesh(Mesh* mesh,int face) {
- if (mesh == NULL) return 0;
+int OperationSplitFace::runMesh( Mesh* mesh,int face ) {
+ if ( mesh == NULL ) return 0;
- DoubleVector* dv = new DoubleVector(splits->size());
- for (size_t i = 0; i < splits->size(); i++)
- (*dv)[i] = splits->at(i)->calculate(mesh,face);
+ DoubleVector* dv = new DoubleVector( splits->size() );
+ for ( size_t i = 0; i < splits->size(); i++ )
+ (*dv)[i] = splits->at(i)->calculate( mesh, face );
IntVector* faces;
- if (exp != NULL)
- faces = mesh->splitFace(face,dv,horiz,exp->calculate(mesh,face));
+ if (exp[0] != NULL)
+ faces = mesh->splitFace( face, dv, horiz, exp[0]->calculate(mesh,face) );
else
- faces = mesh->splitFace(face,dv,horiz);
+ faces = mesh->splitFace( face, dv, horiz );
if (facerules != NULL) {
- OperationMultifaces::runMesh(mesh,face,faces);
+ OperationMultifaces::runMesh( mesh, face, faces );
}
delete faces;
delete dv;
- return face;
+ return face;
}
-int OperationRepeat::runMesh(Mesh* mesh,int face) {
+int OperationRepeat::runMesh( Mesh* mesh,int face ) {
if (mesh == NULL) return 0;
- flatten(mesh,face);
- IntVector* faces = mesh->repeatSubdivdeFace(face,value,horiz);
+ flatten( mesh, face );
+ IntVector* faces = mesh->repeatSubdivdeFace( face, value[0], horiz );
if (facerules != NULL) {
- OperationMultifaces::runMesh(mesh,face,faces);
+ OperationMultifaces::runMesh( mesh, face, faces );
}
delete faces;
- return face;
+ return face;
}
int OperationMultiFace::runMesh(Mesh* mesh, int face) {
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|