SF.net SVN: bzflag:[18470] trunk/bzwgen

[<cha...@us...>]

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.