parm -> param

pandatool/src/egg-qtess/eggQtess.cxx

@@ -47,16 +47,16 @@ EggQtess() {
 
   add_option
     ("up", "subdiv", 0,
-     "Specify a uniform subdivision per patch (isoparm).  Each NURBS "
+     "Specify a uniform subdivision per patch (isoparam).  Each NURBS "
      "surface is made up of N x M patches, each of which is divided "
      "into subdiv x subdiv quads.  A fractional number is allowed.",
-     &EggQtess::dispatch_double, NULL, &_uniform_per_isoparm);
+     &EggQtess::dispatch_double, NULL, &_uniform_per_isoparam);
 
   add_option
     ("us", "subdiv", 0,
      "Specify a uniform subdivision per surface.  Each NURBS "
      "surface is subdivided into subdiv x subdiv quads, regardless "
-     "of the number of isoparms it has.  A fractional number is "
+     "of the number of isoparams it has.  A fractional number is "
      "meaningless.",
      &EggQtess::dispatch_int, NULL, &_uniform_per_surface);
 
@@ -79,7 +79,7 @@ EggQtess() {
     ("ad", "", 0,
      "Attempt to automatically distribute polygons among the surfaces "
      "where they are most needed according to curvature and size, "
-     "instead of according to the number of isoparms.  This only has "
+     "instead of according to the number of isoparams.  This only has "
      "meaning when used in conjunction with -t.",
      &EggQtess::dispatch_none, &QtessGlobals::_auto_distribute);
 
@@ -111,7 +111,7 @@ EggQtess() {
      "Describe the format of the qtess parameter file specified with -f.",
      &EggQtess::dispatch_none, &_describe_qtess);
 
-  _uniform_per_isoparm = 0.0;
+  _uniform_per_isoparam = 0.0;
   _uniform_per_surface = 0;
   _total_tris = 0;
 }
@@ -173,14 +173,14 @@ run() {
 
     default_entry.set_num_tris(extra_tris);
 
-  } else if (_uniform_per_isoparm!=0.0) {
-    default_entry.set_per_isoparm(_uniform_per_isoparm);
+  } else if (_uniform_per_isoparam!=0.0) {
+    default_entry.set_per_isoparam(_uniform_per_isoparam);
 
   } else if (_uniform_per_surface!=0.0) {
     default_entry.set_uv(_uniform_per_surface, _uniform_per_surface);
 
   } else {
-    default_entry.set_per_isoparm(1.0);
+    default_entry.set_per_isoparam(1.0);
   }
 
   default_entry.count_tris();
@@ -252,11 +252,11 @@ describe_qtess_format() {
   
   show_text("  NUM NUM [[!]u# [!]u# ...] [[!]v# [!]v# ...]", 10,
             "Tesselate to NUM x NUM quads.  If u# or v# appear, they indicate "
-            "additional isoparms to insert (or remove if preceded by an "
+            "additional isoparams to insert (or remove if preceded by an "
             "exclamation point).  The range is [0, 1].\n\n");
 
   show_text("  iNUM", 10,
-            "Subdivision amount per isoparm.  Equivalent to the command-line "
+            "Subdivision amount per isoparam.  Equivalent to the command-line "
             "option -u NUM.\n\n");
   
   show_text("  NUM%", 10,
@@ -308,7 +308,7 @@ describe_qtess_format() {
 
   show_text("  !ad", 10,
             "Do not automatically distribute polygons; distribute "
-            "them according to the number of isoparms of each surface.\n\n");
+            "them according to the number of isoparams of each surface.\n\n");
 
   show_text("  arNUM", 10,
             "Specify the ratio of dominance of size to curvature.\n\n");

pandatool/src/egg-qtess/eggQtess.h

@@ -46,7 +46,7 @@ private:
   void find_surfaces(EggNode *egg_node);
 
   Filename _qtess_filename;
-  double _uniform_per_isoparm;
+  double _uniform_per_isoparam;
   int _uniform_per_surface;
   int _total_tris;
   bool _qtess_output;

pandatool/src/egg-qtess/isoPlacer.h

@@ -27,7 +27,7 @@ class NurbsSurfaceResult;
 
 ////////////////////////////////////////////////////////////////////
 //       Class : IsoPlacer
-// Description : Contains the logic used to place isoparms where
+// Description : Contains the logic used to place isoparams where
 //               they'll do the most good on a surface.
 ////////////////////////////////////////////////////////////////////
 class IsoPlacer {

pandatool/src/egg-qtess/qtessInputEntry.I

@@ -156,14 +156,14 @@ set_uv(int u, int v) {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: QtessInputEntry::set_per_isoparm
+//     Function: QtessInputEntry::set_per_isoparam
 //       Access: Public
 //  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE void QtessInputEntry::
-set_per_isoparm(double pi) {
-  _per_isoparm = pi;
-  _type = T_per_isoparm;
+set_per_isoparam(double pi) {
+  _per_isoparam = pi;
+  _type = T_per_isoparam;
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -173,7 +173,7 @@ set_per_isoparm(double pi) {
 ////////////////////////////////////////////////////////////////////
 INLINE void QtessInputEntry::
 set_per_score(double pi) {
-  _per_isoparm = pi;
+  _per_isoparam = pi;
   _type = T_per_score;
 }
 

pandatool/src/egg-qtess/qtessInputEntry.cxx

@@ -55,7 +55,7 @@ operator = (const QtessInputEntry &copy) {
   _num_tris = copy._num_tris;
   _num_u = copy._num_u;
   _num_v = copy._num_v;
-  _per_isoparm = copy._per_isoparm;
+  _per_isoparam = copy._per_isoparam;
   _iso_u = copy._iso_u;
   _iso_v = copy._iso_v;
   _surfaces = copy._surfaces;
@@ -100,11 +100,11 @@ public:
 //     Function: QtessInputEntry::set_uv
 //       Access: Public
 //  Description: Sets specific tesselation.  The tesselation will be u
-//               by v quads, with the addition of any isoparms
-//               described in the list of parms.
+//               by v quads, with the addition of any isoparams
+//               described in the list of params.
 ////////////////////////////////////////////////////////////////////
 void QtessInputEntry::
-set_uv(int u, int v, const string parms[], int num_parms) {
+set_uv(int u, int v, const string params[], int num_params) {
   _num_u = u;
   _num_v = v;
 
@@ -118,16 +118,16 @@ set_uv(int u, int v, const string parms[], int num_parms) {
   }
 
   // Then get out all the additional entries.
-  for (i = 0; i < num_parms; i++) {
-    const string &parm = parms[i];
+  for (i = 0; i < num_params; i++) {
+    const string &param = params[i];
 
-    if (parm[0] == '!' && parm.size() > 2) {
+    if (param[0] == '!' && param.size() > 2) {
       double value;
-      if (!string_to_double(parm.substr(2), value)) {
+      if (!string_to_double(param.substr(2), value)) {
         qtess_cat.warning()
-          << "Ignoring invalid parameter: " << parm << "\n";
+          << "Ignoring invalid parameter: " << param << "\n";
       } else {
-        switch (tolower(parm[1])) {
+        switch (tolower(param[1])) {
         case 'u':
           _auto_place = false;
           _iso_u.erase(remove_if(_iso_u.begin(), _iso_u.end(), 
@@ -144,16 +144,16 @@ set_uv(int u, int v, const string parms[], int num_parms) {
 	
         default:
           qtess_cat.warning()
-            << "Ignoring invalid parameter: " << parms[i] << "\n";
+            << "Ignoring invalid parameter: " << params[i] << "\n";
         }
       }
     } else {
       double value;
-      if (!string_to_double(parm.substr(1), value)) {
+      if (!string_to_double(param.substr(1), value)) {
         qtess_cat.warning()
-          << "Ignoring invalid parameter: " << parm << "\n";
+          << "Ignoring invalid parameter: " << param << "\n";
       } else {
-        switch (tolower(parm[0])) {
+        switch (tolower(param[0])) {
         case 'u':
           _auto_place = false;
           _iso_u.push_back(value);
@@ -166,7 +166,7 @@ set_uv(int u, int v, const string parms[], int num_parms) {
           
         default:
           qtess_cat.warning()
-            << "Ignoring invalid parameter: " << parms[i] << "\n";
+            << "Ignoring invalid parameter: " << params[i] << "\n";
         }
       }
     }
@@ -183,24 +183,24 @@ set_uv(int u, int v, const string parms[], int num_parms) {
 
 
 ////////////////////////////////////////////////////////////////////
-//     Function: QtessInputEntry::add_extra_u_isoparm
+//     Function: QtessInputEntry::add_extra_u_isoparam
 //       Access: Public
 //  Description: May be called a number of times before set_uv() to add
-//               specific additional isoparms to the tesselation.
+//               specific additional isoparams to the tesselation.
 ////////////////////////////////////////////////////////////////////
 void QtessInputEntry::
-add_extra_u_isoparm(double u) {
+add_extra_u_isoparam(double u) {
   _iso_u.push_back(u);
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: QtessInputEntry::add_extra_v_isoparm
+//     Function: QtessInputEntry::add_extra_v_isoparam
 //       Access: Public
 //  Description: May be called a number of times before set_uv() to add
-//               specific additional isoparms to the tesselation.
+//               specific additional isoparams to the tesselation.
 ////////////////////////////////////////////////////////////////////
 void QtessInputEntry::
-add_extra_v_isoparm(double v) {
+add_extra_v_isoparam(double v) {
   _iso_v.push_back(v);
 }
 
@@ -321,12 +321,12 @@ count_tris(double tri_factor, int attempts) {
 
   if (_type == T_num_tris && _num_patches > 0.0) {
     // If we wanted to aim for a particular number of triangles for
-    // the group, choose a per-isoparm setting that will approximately
+    // the group, choose a per-isoparam setting that will approximately
     // achieve this.
     if (_auto_distribute) {
       set_per_score(sqrt(0.5 * (double)_num_tris / _num_patches / tri_factor));
     } else {
-      set_per_isoparm(sqrt(0.5 * (double)_num_tris / _num_patches / tri_factor));
+      set_per_isoparam(sqrt(0.5 * (double)_num_tris / _num_patches / tri_factor));
     }
     aim_for_tris = true;
   }
@@ -349,12 +349,12 @@ count_tris(double tri_factor, int attempts) {
       }
       break;
       
-    case T_per_isoparm:
-      surface->tesselate_per_isoparm(_per_isoparm, _auto_place, _curvature_ratio);
+    case T_per_isoparam:
+      surface->tesselate_per_isoparam(_per_isoparam, _auto_place, _curvature_ratio);
       break;
       
     case T_per_score:
-      surface->tesselate_per_score(_per_isoparm, _auto_place, _curvature_ratio);
+      surface->tesselate_per_score(_per_isoparam, _auto_place, _curvature_ratio);
       break;
 
     default:
@@ -380,7 +380,7 @@ count_tris(double tri_factor, int attempts) {
 ////////////////////////////////////////////////////////////////////
 //     Function: QtessInputEntry::output_extra
 //       Access: Public, Static
-//  Description: This function is used to identify the extra isoparms
+//  Description: This function is used to identify the extra isoparams
 //               in the list added by user control.
 ////////////////////////////////////////////////////////////////////
 void QtessInputEntry::
@@ -439,9 +439,9 @@ output(ostream &out) const {
     show_auto = true;
     break;
 
-  case T_per_isoparm:
+  case T_per_isoparam:
   case T_per_score:
-    out << "i" << _per_isoparm;
+    out << "i" << _per_isoparam;
     show_auto = true;
     break;
 

pandatool/src/egg-qtess/qtessInputEntry.h

@@ -34,7 +34,7 @@ class QtessSurface;
 class QtessInputEntry {
 public:
   enum Type {
-    T_undefined, T_omit, T_num_tris, T_uv, T_per_isoparm, T_per_score,
+    T_undefined, T_omit, T_num_tris, T_uv, T_per_isoparam, T_per_score,
     T_importance, T_match_uu, T_match_vv, T_match_uv, T_match_vu,
     T_min_u, T_min_v
   };
@@ -55,11 +55,11 @@ public:
   INLINE void set_omit();
   INLINE void set_num_tris(int nt);
   INLINE void set_uv(int u, int v);
-  void set_uv(int u, int v, const string parms[], int num_parms);
-  INLINE void set_per_isoparm(double pi);
+  void set_uv(int u, int v, const string params[], int num_params);
+  INLINE void set_per_isoparam(double pi);
   INLINE void set_per_score(double pi);
-  void add_extra_u_isoparm(double u);
-  void add_extra_v_isoparm(double u);
+  void add_extra_u_isoparam(double u);
+  void add_extra_v_isoparam(double u);
 
   Type match(QtessSurface *surface);
   INLINE int get_num_surfaces() const;
@@ -80,7 +80,7 @@ private:
 
   int _num_tris;
   int _num_u, _num_v;
-  double _per_isoparm;
+  double _per_isoparam;
   pvector<double> _iso_u, _iso_v;
   Type _type;
 

pandatool/src/egg-qtess/qtessInputFile.cxx

@@ -96,10 +96,10 @@ read(const Filename &filename) {
 	}
 	
         // Split the line into two groups of words at the colon: names
-        // before the colon, and parms following it.
-        vector_string names, parms;
+        // before the colon, and params following it.
+        vector_string names, params;
         extract_words(line.substr(0, colon), names);
-        extract_words(line.substr(colon + 1), parms);
+        extract_words(line.substr(colon + 1), params);
         
         vector_string::const_iterator ni;
         for (ni = names.begin(); ni != names.end(); ++ni) {
@@ -109,19 +109,19 @@ read(const Filename &filename) {
 	// Scan for things like ap, ad, ar, and pull them out of the
 	// stream.
 	vector_string::iterator ci, cnext;
-	ci = parms.begin();
-	while (ci != parms.end()) {
+	ci = params.begin();
+	while (ci != params.end()) {
 	  cnext = ci;
 	  ++cnext;
 	  
-	  string parm = *ci;
+	  string param = *ci;
 	  bool invert = false;
-	  if (parm[0] == '!' && parm.size() > 1) {
+	  if (param[0] == '!' && param.size() > 1) {
 	    invert = true;
-	    parm = parm.substr(1);
+	    param = param.substr(1);
 	  }
-	  if (tolower(parm[0]) == 'a' && parm.size() > 1) {
-	    switch (tolower(parm[1])) {
+	  if (tolower(param[0]) == 'a' && param.size() > 1) {
+	    switch (tolower(param[1])) {
 	    case 'p':
 	      entry._auto_place = !invert;
 	      break;
@@ -131,10 +131,10 @@ read(const Filename &filename) {
 	      break;
 
 	    case 'r':
-              if (!string_to_double(parm.substr(2), entry._curvature_ratio)) {
+              if (!string_to_double(param.substr(2), entry._curvature_ratio)) {
 		qtess_cat.error()
                   << _filename << ": line " << line_number 
-                  << " - invalid field " << parm << "\n";
+                  << " - invalid field " << param << "\n";
 		return false;
 	      }
 	      break;
@@ -145,84 +145,84 @@ read(const Filename &filename) {
                 << line_number << ".\n";
 	      return false;
 	    }
-	    parms.erase(ci);
+	    params.erase(ci);
 	  } else {
 	    ci = cnext;
 	  }
 	}
 	
-	if (!parms.empty()) {
+	if (!params.empty()) {
 	  bool okflag = true;
-	  if (cmp_nocase(parms[0], "omit")==0) {
+	  if (cmp_nocase(params[0], "omit")==0) {
 	    entry.set_omit();
 
-	  } else if (cmp_nocase(parms[0], "matchuu")==0) {
+	  } else if (cmp_nocase(params[0], "matchuu")==0) {
 	    entry.set_match_uu();
-	    if (parms.size() > 1 && cmp_nocase(parms[1], "matchvv")==0) {
+	    if (params.size() > 1 && cmp_nocase(params[1], "matchvv")==0) {
 	      entry.set_match_vv();
 	    }
 
-	  } else if (cmp_nocase(parms[0], "matchvv")==0) {
+	  } else if (cmp_nocase(params[0], "matchvv")==0) {
 	    entry.set_match_vv();
-	    if (parms.size() > 1 && cmp_nocase(parms[1], "matchuu")==0) {
+	    if (params.size() > 1 && cmp_nocase(params[1], "matchuu")==0) {
 	      entry.set_match_uu();
 	    }
 
-	  } else if (cmp_nocase(parms[0], "matchuv")==0) {
+	  } else if (cmp_nocase(params[0], "matchuv")==0) {
 	    entry.set_match_uv();
-	    if (parms.size() > 1 && cmp_nocase(parms[1], "matchvu")==0) {
+	    if (params.size() > 1 && cmp_nocase(params[1], "matchvu")==0) {
 	      entry.set_match_vu();
 	    }
 
-	  } else if (cmp_nocase(parms[0], "matchvu")==0) {
+	  } else if (cmp_nocase(params[0], "matchvu")==0) {
 	    entry.set_match_vu();
-	    if (parms.size() > 1 && cmp_nocase(parms[1], "matchuv")==0) {
+	    if (params.size() > 1 && cmp_nocase(params[1], "matchuv")==0) {
 	      entry.set_match_uv();
 	    }
 
-	  } else if (cmp_nocase(parms[0], "minu")==0) {
+	  } else if (cmp_nocase(params[0], "minu")==0) {
 	    // minu #: minimum tesselation in U.
-	    if (parms.size() < 2) {
+	    if (params.size() < 2) {
 	      okflag = false;
 	    } else {
               int value = 0;
-              okflag = string_to_int(parms[1], value);
+              okflag = string_to_int(params[1], value);
 	      entry.set_min_u(value);
 	    }
 
-	  } else if (cmp_nocase(parms[0], "minv")==0) {
+	  } else if (cmp_nocase(params[0], "minv")==0) {
 	    // minu #: minimum tesselation in V.
-	    if (parms.size() < 2) {
+	    if (params.size() < 2) {
 	      okflag = false;
 	    } else {
               int value = 0;
-              okflag = string_to_int(parms[1], value);
+              okflag = string_to_int(params[1], value);
 	      entry.set_min_v(value);
 	    }
 
-	  } else if (tolower(parms[0][0]) == 'i') {
-	    // "i#": per-isoparm tesselation.
+	  } else if (tolower(params[0][0]) == 'i') {
+	    // "i#": per-isoparam tesselation.
             int value = 0;
-            okflag = string_to_int(parms[0].substr(1), value);
-            entry.set_per_isoparm(value);
+            okflag = string_to_int(params[0].substr(1), value);
+            entry.set_per_isoparam(value);
 
-	  } else if (parms[0][parms[0].length() - 1] == '%') {
+	  } else if (params[0][params[0].length() - 1] == '%') {
             double value = 0.0;
-            okflag = string_to_double(parms[0].substr(0, parms[0].length() - 1), value);
+            okflag = string_to_double(params[0].substr(0, params[0].length() - 1), value);
 	    entry.set_importance(value / 100.0);
 
-	  } else if (parms.size() == 1) {
+	  } else if (params.size() == 1) {
 	    // One numeric parameter: the number of triangles.
             int value = 0;
-            okflag = string_to_int(parms[0], value);
+            okflag = string_to_int(params[0], value);
             entry.set_num_tris(value);
 
-	  } else if (parms.size() >= 2) {
+	  } else if (params.size() >= 2) {
 	    // Two or more numeric parameters: the number of u by v quads,
-	    // followed by an optional list of specific isoparms.
+	    // followed by an optional list of specific isoparams.
             int u = 0, v = 0;
-            okflag = string_to_int(parms[0], u) && string_to_int(parms[1], v);
-	    entry.set_uv(u, v, &parms[2], parms.size() - 2);
+            okflag = string_to_int(params[0], u) && string_to_int(params[1], v);
+	    entry.set_uv(u, v, &params[2], params.size() - 2);
 
 	  } else {
 	    okflag = false;

pandatool/src/egg-qtess/qtessSurface.I

@@ -117,7 +117,7 @@ set_min_v(int min_v) {
 //     Function: QtessSurface::count_patches
 //       Access: Public
 //  Description: Returns the number of patches the NURBS contains.
-//               Each patch is a square area bounded by isoparms.
+//               Each patch is a square area bounded by isoparams.
 //               This actually scales by the importance of the
 //               surface, if it is not 1.
 ////////////////////////////////////////////////////////////////////

pandatool/src/egg-qtess/qtessSurface.cxx

@@ -90,9 +90,9 @@ QtessSurface(EggNurbsSurface *egg_surface) :
 //  Description: Computes the curvature/stretch score for the surface,
 //               if it has not been already computed, and returns the
 //               net surface score.  This is used both for
-//               automatically distributing isoparms among the
+//               automatically distributing isoparams among the
 //               surfaces by curvature, as well as for automatically
-//               placing the isoparms within each surface by
+//               placing the isoparams within each surface by
 //               curvature.
 ////////////////////////////////////////////////////////////////////
 double QtessSurface::
@@ -203,7 +203,7 @@ tesselate_uv(int u, int v, bool autoplace, double ratio) {
 //     Function: QtessSurface::tesselate_specific
 //       Access: Public
 //  Description: Sets the surface up to tesselate itself at specific
-//               isoparms only.
+//               isoparams only.
 ////////////////////////////////////////////////////////////////////
 void QtessSurface::
 tesselate_specific(const pvector<double> &u_list,
@@ -215,13 +215,13 @@ tesselate_specific(const pvector<double> &u_list,
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: QtessSurface::tesselate_per_isoparm
+//     Function: QtessSurface::tesselate_per_isoparam
 //       Access: Public
 //  Description: Sets the surface up to tesselate itself to a uniform
-//               amount per isoparm.
+//               amount per isoparam.
 ////////////////////////////////////////////////////////////////////
 void QtessSurface::
-tesselate_per_isoparm(double pi, bool autoplace, double ratio) {
+tesselate_per_isoparam(double pi, bool autoplace, double ratio) {
   if (_num_u == 0 || _num_v == 0) {
     omit();
 
@@ -264,7 +264,7 @@ tesselate_per_score(double pi, bool autoplace, double ratio) {
 //       Access: Public
 //  Description: Sets the surface up to tesselate itself by
 //               automatically determining the best place to put the
-//               indicated u x v isoparms.
+//               indicated u x v isoparams.
 ////////////////////////////////////////////////////////////////////
 void QtessSurface::
 tesselate_auto(int u, int v, double ratio) {
@@ -388,7 +388,7 @@ apply_match() {
 //       Access: Private
 //  Description: Subdivide the surface uniformly according to the
 //               parameters specified by an earlier call to omit(),
-//               teseselate_uv(), or tesselate_per_isoparm().
+//               teseselate_uv(), or tesselate_per_isoparam().
 ////////////////////////////////////////////////////////////////////
 PT(EggGroup) QtessSurface::
 do_uniform_tesselate(int &tris) const {

pandatool/src/egg-qtess/qtessSurface.h

@@ -59,7 +59,7 @@ public:
   void tesselate_uv(int u, int v, bool autoplace, double ratio);
   void tesselate_specific(const pvector<double> &u_list,
                           const pvector<double> &v_list);
-  void tesselate_per_isoparm(double pi, bool autoplace, double ratio);
+  void tesselate_per_isoparam(double pi, bool autoplace, double ratio);
   void tesselate_per_score(double pi, bool autoplace, double ratio);
   void tesselate_auto(int u, int v, double ratio);
 
@@ -90,7 +90,7 @@ private:
 
   int _num_u, _num_v;
   int _tess_u, _tess_v;
-  pvector<double> _iso_u, _iso_v;  // If nonempty, isoparms at which to tess.
+  pvector<double> _iso_u, _iso_v;  // If nonempty, isoparams at which to tess.
 
   // _importance is the relative importance of the surface along either
   // axis; _importance2 is this number squared, which is the value set by