TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-03 10:22:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

parm -> param

Browse Source
This commit is contained in:
David Rose 2003-10-14 21:45:50 +00:00
parent e936606b8d
commit 5abb4121ca
10 changed files with 105 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
pandatool/src/egg-qtess/eggQtess.cxx
View File

@ -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");

2
pandatool/src/egg-qtess/eggQtess.h
View File

@ -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;

2
pandatool/src/egg-qtess/isoPlacer.h
View File

@ -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 {

10
pandatool/src/egg-qtess/qtessInputEntry.I
View File

@ -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;
}

58
pandatool/src/egg-qtess/qtessInputEntry.cxx
View File

@ -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;

12
pandatool/src/egg-qtess/qtessInputEntry.h
View File

@ -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;

82
pandatool/src/egg-qtess/qtessInputFile.cxx
View File

@ -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;

2
pandatool/src/egg-qtess/qtessSurface.I
View File

@ -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.
////////////////////////////////////////////////////////////////////

16
pandatool/src/egg-qtess/qtessSurface.cxx
View File

@ -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 {

4
pandatool/src/egg-qtess/qtessSurface.h
View File

@ -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