[372] | 1 | // ================================================================
|
---|
| 2 | // $Id: environ.cpp,v 1.1 2004/02/16 14:45:59 bittner Exp $
|
---|
| 3 | //
|
---|
| 4 | // environ.cpp
|
---|
| 5 | // Implementation of the environment operations, ie. reading
|
---|
| 6 | // environment file, reading command line parameters etc.
|
---|
| 7 | //
|
---|
| 8 |
|
---|
| 9 | //#define _DEBUG_PARAMS
|
---|
| 10 |
|
---|
| 11 | #include <math.h>
|
---|
| 12 | #include <stdlib.h>
|
---|
| 13 | #include <stdio.h>
|
---|
| 14 | #include <string.h>
|
---|
| 15 | #include <fstream>
|
---|
| 16 |
|
---|
| 17 | #include "gzstream.h"
|
---|
| 18 | #include "common.h"
|
---|
| 19 | #include "Environment.h"
|
---|
| 20 | #include "Vector3.h"
|
---|
| 21 |
|
---|
[863] | 22 | using namespace std;
|
---|
[372] | 23 |
|
---|
[863] | 24 | namespace GtpVisibilityPreprocessor {
|
---|
[860] | 25 |
|
---|
[863] | 26 |
|
---|
| 27 |
|
---|
[1004] | 28 | //Environment *environment = NULL;
|
---|
| 29 | Environment *Environment::sEnvironment = NULL;
|
---|
[372] | 30 |
|
---|
[1004] | 31 |
|
---|
| 32 | Environment *Environment::GetSingleton()
|
---|
| 33 | {
|
---|
| 34 | if (!sEnvironment)
|
---|
| 35 | {
|
---|
| 36 | sEnvironment = new Environment();
|
---|
| 37 | }
|
---|
| 38 |
|
---|
| 39 | return sEnvironment;
|
---|
| 40 | }
|
---|
| 41 |
|
---|
| 42 | void Environment::DelSingleton()
|
---|
| 43 | {
|
---|
| 44 | DEL_PTR(sEnvironment);
|
---|
| 45 | }
|
---|
| 46 |
|
---|
| 47 |
|
---|
[372] | 48 | Environment::~Environment()
|
---|
| 49 | {
|
---|
| 50 | int i, j;
|
---|
| 51 |
|
---|
| 52 | // delete the params structure
|
---|
| 53 | for (i = 0; i < numParams; i++) {
|
---|
| 54 | for (j = 0; j < paramRows; j++)
|
---|
| 55 | if (params[i][j] != NULL)
|
---|
| 56 | delete[] params[i][j];
|
---|
| 57 | if (params[i] != NULL)
|
---|
| 58 | delete[] params[i];
|
---|
| 59 | }
|
---|
| 60 |
|
---|
| 61 | if (params != NULL)
|
---|
| 62 | delete[] params;
|
---|
| 63 |
|
---|
| 64 | // delete the options structure
|
---|
| 65 | if (options != NULL)
|
---|
| 66 | delete[] options;
|
---|
| 67 |
|
---|
| 68 | if (optionalParams != NULL)
|
---|
[938] | 69 | DEL_PTR(optionalParams);
|
---|
[372] | 70 | }
|
---|
| 71 |
|
---|
| 72 | bool
|
---|
| 73 | Environment::CheckForSwitch(const int argc,
|
---|
[492] | 74 | char **argv,
|
---|
| 75 | const char swtch) const
|
---|
[372] | 76 | {
|
---|
| 77 | for (int i = 1; i < argc; i++)
|
---|
| 78 | if ((argv[i][0] == '-') && (argv[i][1] == swtch))
|
---|
| 79 | return true;
|
---|
| 80 | return false;
|
---|
| 81 | }
|
---|
| 82 |
|
---|
| 83 | bool
|
---|
| 84 | Environment::CheckType(const char *value,
|
---|
| 85 | const EOptType type) const
|
---|
| 86 | {
|
---|
| 87 | char *s, *t, *u;
|
---|
| 88 |
|
---|
| 89 | switch (type) {
|
---|
| 90 | case optInt: {
|
---|
| 91 | strtol(value, &t, 10);
|
---|
| 92 | if (value + strlen(value) != t)
|
---|
| 93 | return false;
|
---|
| 94 | else
|
---|
| 95 | return true;
|
---|
| 96 | }
|
---|
| 97 | case optFloat: {
|
---|
| 98 | strtod(value, &t);
|
---|
| 99 | if (value + strlen(value) != t)
|
---|
| 100 | return false;
|
---|
| 101 | else
|
---|
| 102 | return true;
|
---|
| 103 | }
|
---|
| 104 | case optBool: {
|
---|
| 105 | if (!strcasecmp(value, "true") ||
|
---|
| 106 | !strcasecmp(value, "false") ||
|
---|
| 107 | !strcasecmp(value, "YES") ||
|
---|
| 108 | !strcasecmp(value, "NO") ||
|
---|
| 109 | !strcmp(value, "+") ||
|
---|
| 110 | !strcmp(value, "-") ||
|
---|
| 111 | !strcasecmp(value, "ON") ||
|
---|
| 112 | !strcasecmp(value, "OFF"))
|
---|
| 113 | return true;
|
---|
| 114 | return false;
|
---|
| 115 | }
|
---|
| 116 | case optVector:{
|
---|
| 117 | strtod(value, &s);
|
---|
| 118 | if (*s == ' ' || *s == '\t') {
|
---|
| 119 | while (*s == ' ' || *s == '\t')
|
---|
| 120 | s++;
|
---|
| 121 | if (*s != ',')
|
---|
| 122 | s--;
|
---|
| 123 | }
|
---|
| 124 | if ((*s != ',' && *s != ' ' && *s != '\t') || value == s)
|
---|
| 125 | return false;
|
---|
| 126 | t = s;
|
---|
| 127 | strtod(s + 1, &u);
|
---|
| 128 | if (*u == ' ' || *u == '\t') {
|
---|
| 129 | while (*u == ' ' || *u == '\t')
|
---|
| 130 | u++;
|
---|
| 131 | if (*u != ',')
|
---|
| 132 | u--;
|
---|
| 133 | }
|
---|
| 134 | if ((*u != ',' && *s != ' ' && *s != '\t') || t == u)
|
---|
| 135 | return false;
|
---|
| 136 | t = u;
|
---|
| 137 | strtod(u + 1, &s);
|
---|
| 138 | if (t == s || value + strlen(value) != s)
|
---|
| 139 | return false;
|
---|
| 140 | return true;
|
---|
| 141 | }
|
---|
| 142 | case optString: {
|
---|
| 143 | return true;
|
---|
| 144 | }
|
---|
| 145 | default: {
|
---|
| 146 | Debug << "Internal error: Unknown type of option.\n" << flush;
|
---|
| 147 | exit(1);
|
---|
| 148 | }
|
---|
| 149 | }
|
---|
| 150 | return false;
|
---|
| 151 | }
|
---|
| 152 |
|
---|
| 153 | void
|
---|
| 154 | Environment::ReadCmdlineParams(const int argc,
|
---|
[492] | 155 | char **argv,
|
---|
| 156 | const char *optParams)
|
---|
[372] | 157 | {
|
---|
| 158 | int i;
|
---|
| 159 |
|
---|
| 160 | // Make sure we are called for the first time
|
---|
| 161 | if (optionalParams != NULL)
|
---|
| 162 | return;
|
---|
| 163 |
|
---|
[472] | 164 | numParams = (int)strlen(optParams) + 1;
|
---|
[372] | 165 | optionalParams = new char[numParams];
|
---|
| 166 | strcpy(optionalParams, optParams);
|
---|
| 167 |
|
---|
| 168 | // First, count all non-optional parameters on the command line
|
---|
| 169 | for (i = 1; i < argc; i++)
|
---|
| 170 | if (argv[i][0] != '-')
|
---|
| 171 | paramRows++;
|
---|
| 172 |
|
---|
| 173 | // if there is no non-optional parameter add a default one...
|
---|
| 174 | if (paramRows == 0)
|
---|
| 175 | paramRows = 1;
|
---|
| 176 |
|
---|
| 177 | // allocate and initialize the table for parameters
|
---|
| 178 | params = new char **[numParams];
|
---|
| 179 | for (i = 0; i < numParams; i++) {
|
---|
| 180 | params[i] = new char *[paramRows];
|
---|
| 181 | for (int j = 0; j < paramRows; j++)
|
---|
| 182 | params[i][j] = NULL;
|
---|
| 183 | }
|
---|
| 184 | // Now read all non-optional and optional parameters into the table
|
---|
| 185 | curRow = -1;
|
---|
| 186 | for (i = 1; i < argc; i++) {
|
---|
| 187 | if (argv[i][0] != '-') {
|
---|
| 188 | // non-optional parameter encountered
|
---|
| 189 | curRow++;
|
---|
| 190 | params[0][curRow] = new char[strlen(argv[i]) + 1];
|
---|
| 191 | strcpy(params[0][curRow], argv[i]);
|
---|
| 192 | }
|
---|
| 193 | else {
|
---|
| 194 | // option encountered
|
---|
| 195 | char *t = strchr(optionalParams, argv[i][1]);
|
---|
| 196 | if (t != NULL) {
|
---|
| 197 | // this option is optional parameter
|
---|
| 198 | int index = t - optionalParams + 1;
|
---|
| 199 | if (curRow < 0) {
|
---|
| 200 | // it's a global parameter
|
---|
| 201 | for (int j = 0; j < paramRows; j++) {
|
---|
| 202 | params[index][j] = new char[strlen(argv[i] + 2) + 1];
|
---|
| 203 | strcpy(params[index][j], argv[i] + 2);
|
---|
| 204 | }
|
---|
| 205 | }
|
---|
| 206 | else {
|
---|
| 207 | // it's a scene parameter
|
---|
| 208 | if (params[index][curRow] != NULL) {
|
---|
| 209 | delete[] params[index][curRow];
|
---|
| 210 | }
|
---|
| 211 | params[index][curRow] = new char[strlen(argv[i] + 2) + 1];
|
---|
| 212 | strcpy(params[index][curRow], argv[i] + 2);
|
---|
| 213 | }
|
---|
| 214 | }
|
---|
| 215 | }
|
---|
| 216 | }
|
---|
| 217 | curRow = 0;
|
---|
| 218 |
|
---|
| 219 | #ifdef _DEBUG_PARAMS
|
---|
| 220 | // write out the parameter table
|
---|
| 221 | cerr << "Parameter table for " << numParams << " columns and "
|
---|
| 222 | << paramRows << " rows:\n";
|
---|
| 223 | for (int j = 0; j < paramRows; j++) {
|
---|
| 224 | for (i = 0; i < numParams; i++) {
|
---|
| 225 | if (params[i][j] != NULL)
|
---|
| 226 | cerr << params[i][j];
|
---|
| 227 | else
|
---|
| 228 | cerr << "NULL";
|
---|
| 229 | cerr << "\t";
|
---|
| 230 | }
|
---|
| 231 | cerr << "\n";
|
---|
| 232 | }
|
---|
| 233 | cerr << "Params done.\n" << flush;
|
---|
| 234 | #endif // _DEBUG_PARAMS
|
---|
| 235 | }
|
---|
| 236 |
|
---|
| 237 | bool
|
---|
| 238 | Environment::GetParam(const char name,
|
---|
| 239 | const int index,
|
---|
| 240 | char *value) const
|
---|
| 241 | {
|
---|
| 242 | int column;
|
---|
| 243 |
|
---|
| 244 | if (index >= paramRows || index < 0)
|
---|
| 245 | return false;
|
---|
| 246 | if (name == ' ')
|
---|
| 247 | column = 0;
|
---|
| 248 | else {
|
---|
| 249 | char *t = strchr(optionalParams, name);
|
---|
| 250 |
|
---|
| 251 | if (t == NULL)
|
---|
| 252 | return false;
|
---|
| 253 | column = t - optionalParams + 1;
|
---|
| 254 | }
|
---|
| 255 |
|
---|
| 256 | if (params[column][index] == NULL)
|
---|
| 257 | return false;
|
---|
| 258 | // value = new char[strlen(params[column][index]) + 1];
|
---|
| 259 | strcpy(value, params[column][index]);
|
---|
| 260 | return true;
|
---|
| 261 | }
|
---|
| 262 |
|
---|
| 263 | void
|
---|
| 264 | Environment::RegisterOption(const char *name,
|
---|
[1002] | 265 | const EOptType type,
|
---|
| 266 | const char *abbrev,
|
---|
| 267 | const char *defValue)
|
---|
[372] | 268 | {
|
---|
| 269 | int i;
|
---|
| 270 |
|
---|
| 271 | // make sure this option was not yet registered
|
---|
| 272 | for (i = 0; i < numOptions; i++)
|
---|
| 273 | if (!strcmp(name, options[i].name)) {
|
---|
| 274 | Debug << "Error: Option " << name << " registered twice.\n";
|
---|
| 275 | exit(1);
|
---|
| 276 | }
|
---|
| 277 | // make sure we have enough room in memory
|
---|
| 278 | if (numOptions >= maxOptions) {
|
---|
| 279 | Debug << "Error: Too many options. Try enlarge the maxOptions "
|
---|
| 280 | << "definition.\n";
|
---|
| 281 | exit(1);
|
---|
| 282 | }
|
---|
| 283 |
|
---|
| 284 | // make sure the abbreviation doesn't start with 'D'
|
---|
| 285 | if (abbrev != NULL && (abbrev[0] == 'D' )) {
|
---|
| 286 | Debug << "Internal error: reserved switch " << abbrev
|
---|
| 287 | << " used as an abbreviation.\n";
|
---|
| 288 | exit(1);
|
---|
| 289 | }
|
---|
| 290 | // new option
|
---|
| 291 | options[numOptions].type = type;
|
---|
[863] | 292 | options[numOptions].name = ::strdup(name);
|
---|
[372] | 293 | // assign abbreviation, if requested
|
---|
| 294 | if (abbrev != NULL) {
|
---|
[863] | 295 | options[numOptions].abbrev = ::strdup(abbrev);
|
---|
[372] | 296 | }
|
---|
| 297 | // assign default value, if requested
|
---|
| 298 | if (defValue != NULL) {
|
---|
[863] | 299 | options[numOptions].defaultValue = ::strdup(defValue);
|
---|
[372] | 300 | if (!CheckType(defValue, type)) {
|
---|
| 301 | Debug << "Internal error: Inconsistent type and default value in option "
|
---|
| 302 | << name << ".\n";
|
---|
| 303 | exit(1);
|
---|
| 304 | }
|
---|
| 305 | }
|
---|
| 306 | // new option registered
|
---|
| 307 | numOptions++;
|
---|
| 308 | }
|
---|
| 309 |
|
---|
| 310 | bool
|
---|
| 311 | Environment::OptionPresent(const char *name) const
|
---|
| 312 | {
|
---|
| 313 | bool found = false;
|
---|
| 314 | int i;
|
---|
| 315 |
|
---|
| 316 | for (i = 0; i < numOptions; i++)
|
---|
| 317 | if (!strcmp(options[i].name, name)) {
|
---|
| 318 | found = true;
|
---|
| 319 | break;
|
---|
| 320 | }
|
---|
| 321 | if (!found) {
|
---|
| 322 | Debug << "Internal error: Option " << name << " not registered.\n" << flush;
|
---|
| 323 | exit(1);
|
---|
| 324 | }
|
---|
| 325 | if (options[i].value != NULL || options[i].defaultValue != NULL)
|
---|
| 326 | return true;
|
---|
| 327 | else
|
---|
| 328 | return false;
|
---|
| 329 | }
|
---|
| 330 |
|
---|
| 331 | int
|
---|
[938] | 332 | Environment::FindOption(const char *name, const bool isFatal) const
|
---|
[372] | 333 | {
|
---|
| 334 | int i;
|
---|
| 335 | bool found = false;
|
---|
| 336 | // is this option registered ?
|
---|
| 337 | for (i = 0; i < numOptions; i++)
|
---|
| 338 | if (!strcmp(options[i].name, name)) {
|
---|
| 339 | found = true;
|
---|
| 340 | break;
|
---|
| 341 | }
|
---|
| 342 | if (!found) {
|
---|
| 343 | // no registration found
|
---|
| 344 | Debug << "Internal error: Required option " << name
|
---|
| 345 | << " not registered.\n" << flush;
|
---|
| 346 | exit(1);
|
---|
| 347 | }
|
---|
| 348 | if (options[i].value == NULL && options[i].defaultValue == NULL)
|
---|
| 349 | // this option was not initialised to some value
|
---|
| 350 | if (isFatal) {
|
---|
| 351 | Debug << "Error: Required option " << name << " not found.\n" << flush;
|
---|
| 352 | exit(1);
|
---|
| 353 | }
|
---|
| 354 | else {
|
---|
| 355 | Debug << "Error: Required option " << name << " not found.\n" << flush;
|
---|
| 356 | return -1;
|
---|
| 357 | }
|
---|
| 358 | return i;
|
---|
| 359 | }
|
---|
| 360 |
|
---|
| 361 | bool
|
---|
| 362 | Environment::GetIntValue(const char *name,
|
---|
| 363 | int &value,
|
---|
| 364 | const bool isFatal) const
|
---|
| 365 | {
|
---|
| 366 | int i = FindOption(name, isFatal);
|
---|
| 367 |
|
---|
| 368 | if (i<0)
|
---|
| 369 | return false;
|
---|
| 370 |
|
---|
| 371 | if (options[i].value != NULL) {
|
---|
| 372 | // option was explicitly specified
|
---|
| 373 | value = strtol(options[i].value, NULL, 10);
|
---|
| 374 | } else {
|
---|
| 375 | // option was not read, so use the default
|
---|
| 376 | value = strtol(options[i].defaultValue, NULL, 10);
|
---|
| 377 | }
|
---|
| 378 |
|
---|
| 379 | return true;
|
---|
| 380 | }
|
---|
| 381 |
|
---|
| 382 | bool
|
---|
| 383 | Environment::GetDoubleValue(const char *name,
|
---|
| 384 | double &value,
|
---|
| 385 | const bool isFatal) const
|
---|
| 386 | {
|
---|
| 387 | int i = FindOption(name, isFatal);
|
---|
| 388 |
|
---|
| 389 | if (i<0)
|
---|
| 390 | return false;
|
---|
| 391 |
|
---|
| 392 | if (options[i].value != NULL) {
|
---|
| 393 | // option was explicitly specified
|
---|
| 394 | value = strtod(options[i].value, NULL);
|
---|
| 395 | } else {
|
---|
| 396 | // option was not read, so use the default
|
---|
| 397 | value = strtod(options[i].defaultValue, NULL);
|
---|
| 398 | }
|
---|
| 399 | return true;
|
---|
| 400 | }
|
---|
| 401 |
|
---|
| 402 | bool
|
---|
| 403 | Environment::GetRealValue(const char *name,
|
---|
| 404 | Real &value,
|
---|
| 405 | const bool isFatal) const
|
---|
| 406 | {
|
---|
| 407 | int i = FindOption(name, isFatal);
|
---|
| 408 |
|
---|
| 409 | if (i<0)
|
---|
| 410 | return false;
|
---|
| 411 |
|
---|
| 412 | if (options[i].value != NULL) {
|
---|
| 413 | // option was explicitly specified
|
---|
[472] | 414 | value = (Real)strtod(options[i].value, NULL);
|
---|
[372] | 415 | } else {
|
---|
| 416 | // option was not read, so use the default
|
---|
[472] | 417 | value = (Real)strtod(options[i].defaultValue, NULL);
|
---|
[372] | 418 | }
|
---|
| 419 | return true;
|
---|
| 420 | }
|
---|
| 421 |
|
---|
| 422 | bool
|
---|
| 423 | Environment::GetFloatValue(const char *name,
|
---|
| 424 | float &value,
|
---|
| 425 | const bool isFatal) const
|
---|
| 426 | {
|
---|
| 427 | int i = FindOption(name, isFatal);
|
---|
| 428 |
|
---|
| 429 | if (i<0)
|
---|
| 430 | return false;
|
---|
| 431 |
|
---|
| 432 | if (options[i].value != NULL) {
|
---|
| 433 | // option was explicitly specified
|
---|
| 434 | value = (float)strtod(options[i].value, NULL);
|
---|
| 435 | } else {
|
---|
| 436 | // option was not read, so use the default
|
---|
| 437 | value = (float)strtod(options[i].defaultValue, NULL);
|
---|
| 438 | }
|
---|
| 439 | return true;
|
---|
| 440 | }
|
---|
| 441 |
|
---|
| 442 | bool
|
---|
| 443 | Environment::GetBool(const char *name,
|
---|
| 444 | const bool isFatal) const
|
---|
| 445 | {
|
---|
| 446 | bool ret;
|
---|
| 447 | if (GetBoolValue(name, ret, isFatal))
|
---|
| 448 | return ret;
|
---|
| 449 | else
|
---|
| 450 | return false;
|
---|
| 451 | }
|
---|
| 452 |
|
---|
| 453 | bool
|
---|
| 454 | Environment::ParseBool(const char *name) const
|
---|
| 455 | {
|
---|
| 456 |
|
---|
| 457 | bool value = true;
|
---|
| 458 |
|
---|
| 459 | if (!strcasecmp(name, "false") ||
|
---|
| 460 | !strcasecmp(name, "NO") ||
|
---|
| 461 | !strcmp(name, "-") ||
|
---|
| 462 | !strcasecmp(name, "OFF"))
|
---|
| 463 | value = false;
|
---|
| 464 |
|
---|
| 465 | return value;
|
---|
| 466 | }
|
---|
| 467 |
|
---|
| 468 | void
|
---|
| 469 | Environment::ParseVector(const char *name, Vector3 &v) const
|
---|
| 470 | {
|
---|
| 471 | // option was not read, so use the default
|
---|
| 472 | char *s, *t;
|
---|
| 473 |
|
---|
| 474 | v.x = (Real)strtod(name, &s);
|
---|
| 475 | v.y = (Real)strtod(s + 1, &t);
|
---|
| 476 | v.z = (Real)strtod(t + 1, NULL);
|
---|
| 477 |
|
---|
| 478 | }
|
---|
| 479 |
|
---|
| 480 | bool
|
---|
| 481 | Environment::GetBoolValue(const char *name,
|
---|
| 482 | bool &value,
|
---|
| 483 | const bool isFatal) const
|
---|
| 484 | {
|
---|
| 485 | int i = FindOption(name, isFatal);
|
---|
| 486 |
|
---|
| 487 | if (i<0)
|
---|
| 488 | return false;
|
---|
| 489 |
|
---|
| 490 |
|
---|
| 491 | if (options[i].value != NULL)
|
---|
| 492 | value = ParseBool(options[i].value);
|
---|
| 493 | else
|
---|
| 494 | value = ParseBool(options[i].defaultValue);
|
---|
| 495 |
|
---|
| 496 | return true;
|
---|
| 497 | }
|
---|
| 498 |
|
---|
| 499 | bool
|
---|
| 500 | Environment::GetVectorValue(const char *name,
|
---|
| 501 | Vector3 &v,
|
---|
| 502 | const bool isFatal) const
|
---|
| 503 | {
|
---|
| 504 | int i = FindOption(name, isFatal);
|
---|
| 505 | if (i<0)
|
---|
| 506 | return false;
|
---|
| 507 |
|
---|
| 508 | if (options[i].value != NULL)
|
---|
| 509 |
|
---|
| 510 |
|
---|
| 511 | if (options[i].value != NULL) {
|
---|
| 512 | ParseVector(options[i].value, v);
|
---|
| 513 | }
|
---|
| 514 | else {
|
---|
| 515 | ParseVector(options[i].defaultValue, v);
|
---|
| 516 | }
|
---|
| 517 | return true;
|
---|
| 518 | }
|
---|
| 519 |
|
---|
| 520 | bool
|
---|
| 521 | Environment::GetStringValue(const char *name,
|
---|
| 522 | char *value,
|
---|
| 523 | const bool isFatal) const
|
---|
| 524 | {
|
---|
| 525 | int i = FindOption(name, isFatal);
|
---|
| 526 |
|
---|
| 527 | if (i<0)
|
---|
| 528 | return false;
|
---|
| 529 |
|
---|
| 530 |
|
---|
| 531 | if (options[i].value != NULL) {
|
---|
| 532 | // option was not read, so use the default
|
---|
| 533 | strcpy(value, options[i].value);
|
---|
| 534 | }
|
---|
| 535 | else {
|
---|
| 536 | // option was explicitly specified
|
---|
| 537 | strcpy(value, options[i].defaultValue);
|
---|
| 538 | }
|
---|
| 539 | return true;
|
---|
| 540 | }
|
---|
| 541 |
|
---|
| 542 | void
|
---|
| 543 | Environment::SetInt(const char *name, const int value)
|
---|
| 544 | {
|
---|
| 545 |
|
---|
| 546 | int i = FindOption(name);
|
---|
| 547 | if (i<0)
|
---|
| 548 | return;
|
---|
| 549 |
|
---|
| 550 | if (options[i].type == optInt) {
|
---|
| 551 | delete options[i].value;
|
---|
| 552 | options[i].value = new char[16];
|
---|
| 553 | sprintf(options[i].value, "%.15d", value);
|
---|
| 554 | }
|
---|
| 555 | else {
|
---|
| 556 | Debug << "Internal error: Trying to set non-integer option " << name
|
---|
| 557 | << " to integral value.\n" << flush;
|
---|
| 558 | exit(1);
|
---|
| 559 | }
|
---|
| 560 | }
|
---|
| 561 |
|
---|
| 562 | void
|
---|
| 563 | Environment::SetFloat(const char *name, const Real value)
|
---|
| 564 | {
|
---|
| 565 | int i = FindOption(name);
|
---|
| 566 | if (i<0)
|
---|
| 567 | return;
|
---|
| 568 |
|
---|
| 569 | if (options[i].type == optFloat) {
|
---|
| 570 | delete options[i].value;
|
---|
| 571 | options[i].value = new char[25];
|
---|
| 572 | sprintf(options[i].value, "%.15e", value);
|
---|
| 573 | }
|
---|
| 574 | else {
|
---|
| 575 | Debug << "Internal error: Trying to set non-Real option " << name
|
---|
| 576 | << " to Real value.\n" << flush;
|
---|
| 577 | exit(1);
|
---|
| 578 | }
|
---|
| 579 | }
|
---|
| 580 |
|
---|
| 581 | void
|
---|
| 582 | Environment::SetBool(const char *name, const bool value)
|
---|
| 583 | {
|
---|
| 584 | int i = FindOption(name);
|
---|
| 585 | if (i<0)
|
---|
| 586 | return;
|
---|
| 587 |
|
---|
| 588 | if (options[i].type == optBool) {
|
---|
| 589 | delete options[i].value;
|
---|
| 590 | options[i].value = new char[6];
|
---|
| 591 | if (value)
|
---|
| 592 | sprintf(options[i].value, "true");
|
---|
| 593 | else
|
---|
| 594 | sprintf(options[i].value, "false");
|
---|
| 595 | }
|
---|
| 596 | else {
|
---|
| 597 | Debug << "Internal error: Trying to set non-bool option " << name
|
---|
| 598 | << " to boolean value.\n" << flush;
|
---|
| 599 | exit(1);
|
---|
| 600 | }
|
---|
| 601 | }
|
---|
| 602 |
|
---|
| 603 | void
|
---|
| 604 | Environment::SetVector(const char *name,
|
---|
| 605 | const Vector3 &v)
|
---|
| 606 | {
|
---|
| 607 | int i = FindOption(name);
|
---|
| 608 | if (i<0)
|
---|
| 609 | return;
|
---|
| 610 |
|
---|
| 611 | if (options[i].type == optVector) {
|
---|
| 612 | delete options[i].value;
|
---|
| 613 | options[i].value = new char[128];
|
---|
| 614 | sprintf(options[i].value, "%.15e,%.15e,%.15e", v.x, v.y, v.z);
|
---|
| 615 | }
|
---|
| 616 | else {
|
---|
| 617 | Debug << "Internal error: Trying to set non-vector option " << name
|
---|
| 618 | << " to vector value.\n" << flush;
|
---|
| 619 | exit(1);
|
---|
| 620 | }
|
---|
| 621 | }
|
---|
| 622 |
|
---|
| 623 | void
|
---|
| 624 | Environment::SetString(const char *name, const char *value)
|
---|
| 625 | {
|
---|
| 626 | int i = FindOption(name);
|
---|
| 627 | if (i<0)
|
---|
| 628 | return;
|
---|
| 629 |
|
---|
| 630 | if (options[i].type == optString) {
|
---|
| 631 | delete options[i].value;
|
---|
[863] | 632 | options[i].value = ::strdup(value);
|
---|
[372] | 633 | }
|
---|
| 634 | else {
|
---|
| 635 | Debug << "Internal error: Trying to set non-string option " << name
|
---|
| 636 | << " to string value.\n" << flush;
|
---|
| 637 | exit(1);
|
---|
| 638 | }
|
---|
| 639 | }
|
---|
| 640 |
|
---|
| 641 | void
|
---|
| 642 | Environment::ParseCmdline(const int argc,
|
---|
[492] | 643 | char **argv,
|
---|
| 644 | const int index)
|
---|
[372] | 645 | {
|
---|
| 646 | int curIndex = -1;
|
---|
| 647 |
|
---|
| 648 | for (int i = 1; i < argc; i++) {
|
---|
| 649 | // if this parameter is non-optional, skip it and increment the counter
|
---|
| 650 | if (argv[i][0] != '-') {
|
---|
| 651 | curIndex++;
|
---|
| 652 | continue;
|
---|
| 653 | }
|
---|
| 654 | // make sure to skip all non-optional parameters
|
---|
| 655 | char *t = strchr(optionalParams, argv[i][1]);
|
---|
| 656 | if (t != NULL)
|
---|
| 657 | continue;
|
---|
| 658 |
|
---|
| 659 | // if we are in the scope of the current parameter, parse it
|
---|
| 660 | if (curIndex == -1 || curIndex == index) {
|
---|
| 661 | if (argv[i][1] == 'D') {
|
---|
| 662 | // it's a full name definition
|
---|
| 663 | bool found = false;
|
---|
| 664 | int j;
|
---|
| 665 |
|
---|
| 666 | char *t = strchr(argv[i] + 2, '=');
|
---|
| 667 | if (t == NULL) {
|
---|
| 668 | Debug << "Error: Missing '=' in option. "
|
---|
| 669 | << "Syntax is -D<name>=<value>.\n" << flush;
|
---|
| 670 | exit(1);
|
---|
| 671 | }
|
---|
| 672 | for (j = 0; j < numOptions; j++)
|
---|
| 673 | if (!strncmp(options[j].name, argv[i] + 2, t - argv[i] - 2) &&
|
---|
| 674 | (unsigned)(t - argv[i] - 2) == strlen(options[j].name)) {
|
---|
| 675 | found = true;
|
---|
| 676 | break;
|
---|
| 677 | }
|
---|
| 678 | if (!found) {
|
---|
| 679 | Debug << "Warning: Unregistered option " << argv[i] << ".\n" << flush;
|
---|
| 680 | // exit(1);
|
---|
| 681 | }
|
---|
| 682 | if (found) {
|
---|
| 683 | if (!CheckType(t + 1, options[j].type)) {
|
---|
| 684 | Debug << "Error: invalid type of value " << t + 1 << " in option "
|
---|
| 685 | << options[j].name << ".\n";
|
---|
| 686 | exit(1);
|
---|
| 687 | }
|
---|
| 688 | if (options[j].value != NULL)
|
---|
| 689 | delete options[j].value;
|
---|
| 690 | options[j].value = strdup(t + 1);
|
---|
| 691 | }
|
---|
| 692 | }
|
---|
| 693 | else {
|
---|
| 694 | // it's an abbreviation
|
---|
| 695 | bool found = false;
|
---|
| 696 | int j;
|
---|
| 697 |
|
---|
| 698 | for (j = 0; j < numOptions; j++)
|
---|
| 699 | if (options[j].abbrev != NULL &&
|
---|
| 700 | !strncmp(options[j].abbrev, argv[i] + 1, strlen(options[j].abbrev))) {
|
---|
| 701 | found = true;
|
---|
| 702 | break;
|
---|
| 703 | }
|
---|
| 704 | if (!found) {
|
---|
| 705 | Debug << "Warning: Unregistered option " << argv[i] << ".\n" << flush;
|
---|
| 706 | // exit(1);
|
---|
| 707 | }
|
---|
| 708 | if (found) {
|
---|
| 709 | if (!CheckType(argv[i] + 1 + strlen(options[j].abbrev), options[j].type)) {
|
---|
| 710 | Debug << "Error: invalid type of value "
|
---|
| 711 | << argv[i] + 1 + strlen(options[j].abbrev) << "in option "
|
---|
| 712 | << options[j].name << ".\n";
|
---|
| 713 | exit(1);
|
---|
| 714 | }
|
---|
| 715 | if (options[j].value != NULL)
|
---|
| 716 | delete options[j].value;
|
---|
| 717 | options[j].value = strdup(argv[i] + 1 + strlen(options[j].abbrev));
|
---|
| 718 | }
|
---|
| 719 | }
|
---|
| 720 | }
|
---|
| 721 | }
|
---|
| 722 | #ifdef _DEBUG_PARAMS
|
---|
| 723 | // write out the options table
|
---|
| 724 | cerr << "Options table for " << numOptions << " options:\n";
|
---|
| 725 | for (int j = 0; j < numOptions; j++) {
|
---|
| 726 | cerr << options[j];
|
---|
| 727 | cerr << "\n";
|
---|
| 728 | }
|
---|
| 729 | cerr << "Options done.\n" << flush;
|
---|
| 730 | #endif // _DEBUG_PARAMS
|
---|
| 731 | }
|
---|
| 732 |
|
---|
| 733 |
|
---|
| 734 | char *
|
---|
| 735 | Environment::ParseString(char *buffer, char *string) const
|
---|
| 736 | {
|
---|
| 737 | char *s = buffer;
|
---|
| 738 | char *t = string + strlen(string);
|
---|
| 739 |
|
---|
| 740 | // skip leading whitespaces
|
---|
| 741 | while (*s == ' ' || *s == '\t')
|
---|
| 742 | s++;
|
---|
| 743 | if (*s == '\0')
|
---|
| 744 | return NULL;
|
---|
| 745 | while ((*s >= 'a' && *s <= 'z') ||
|
---|
| 746 | (*s >= 'A' && *s <= 'Z') ||
|
---|
| 747 | (*s >= '0' && *s <= '9') ||
|
---|
| 748 | *s == '_')
|
---|
| 749 | *t++ = *s++;
|
---|
| 750 | *t = '\0';
|
---|
| 751 | // skip trailing whitespaces
|
---|
| 752 | while (*s == ' ' || *s == '\t')
|
---|
| 753 | s++;
|
---|
| 754 | return s;
|
---|
| 755 | }
|
---|
| 756 |
|
---|
| 757 | const char code[] = "JIDHipewhfdhyd74387hHO&{WK:DOKQEIDKJPQ*H#@USX:#FWCQ*EJMQAHPQP(@G#RD";
|
---|
| 758 |
|
---|
| 759 | void
|
---|
| 760 | Environment::DecodeString(char *buff, int max)
|
---|
| 761 | {
|
---|
| 762 | buff[max] = 0;
|
---|
| 763 | char *p = buff;
|
---|
| 764 | const char *cp = code;
|
---|
| 765 | for (; *p; p++) {
|
---|
| 766 | if (*p != '\n')
|
---|
| 767 | *p = *p ^ *cp;
|
---|
| 768 | ++cp;
|
---|
| 769 | if (*cp == 0)
|
---|
| 770 | cp = code;
|
---|
| 771 | }
|
---|
| 772 | }
|
---|
| 773 |
|
---|
| 774 | void
|
---|
| 775 | Environment::CodeString(char *buff, int max)
|
---|
| 776 | {
|
---|
| 777 | buff[max] = 0;
|
---|
| 778 | char *p = buff;
|
---|
| 779 | const char *cp = code;
|
---|
| 780 | for (; *p; p++) {
|
---|
| 781 | if (*p != '\n')
|
---|
| 782 | *p = *p ^ *cp;
|
---|
| 783 | ++cp;
|
---|
| 784 | if (*cp == 0)
|
---|
| 785 | cp = code;
|
---|
| 786 | }
|
---|
| 787 | }
|
---|
| 788 |
|
---|
| 789 | void
|
---|
| 790 | Environment::SaveCodedFile(char *filenameText,
|
---|
| 791 | char *filenameCoded)
|
---|
| 792 | {
|
---|
| 793 | ifstream envStream(filenameText);
|
---|
| 794 |
|
---|
| 795 | // some error had occured
|
---|
| 796 | if (envStream.fail()) {
|
---|
| 797 | cerr << "Error: Can't open file " << filenameText << " for reading (err. "
|
---|
| 798 | << envStream.rdstate() << ").\n";
|
---|
| 799 | return;
|
---|
| 800 | }
|
---|
| 801 | char buff[256];
|
---|
| 802 | envStream.getline(buff, 255);
|
---|
| 803 | buff[8] = 0;
|
---|
| 804 | if (strcmp(buff, "CGX_CF10") == 0)
|
---|
| 805 | return;
|
---|
| 806 |
|
---|
| 807 | ofstream cStream(filenameCoded);
|
---|
| 808 | cStream<<"CGX_CF10";
|
---|
| 809 |
|
---|
| 810 | // main loop
|
---|
| 811 | for (;;) {
|
---|
| 812 | // read in one line
|
---|
| 813 | envStream.getline(buff, 255);
|
---|
| 814 | if (!envStream)
|
---|
| 815 | break;
|
---|
| 816 | CodeString(buff, 255);
|
---|
| 817 | cStream<<buff;
|
---|
| 818 | }
|
---|
| 819 |
|
---|
| 820 | }
|
---|
| 821 |
|
---|
| 822 | bool
|
---|
| 823 | Environment::ReadEnvFile(const char *envFilename)
|
---|
[975] | 824 | {
|
---|
[372] | 825 | char buff[MaxStringLength], name[MaxStringLength];
|
---|
| 826 | char *s, *t;
|
---|
| 827 | int i, line = 0;
|
---|
| 828 | bool found;
|
---|
| 829 | igzstream envStream(envFilename);
|
---|
| 830 |
|
---|
| 831 | // some error had occured
|
---|
| 832 | if (envStream.fail()) {
|
---|
| 833 | cerr << "Error: Can't open file " << envFilename << " for reading (err. "
|
---|
| 834 | << envStream.rdstate() << ").\n";
|
---|
| 835 | return false;
|
---|
| 836 | }
|
---|
[971] | 837 |
|
---|
[372] | 838 | name[0] = '\0';
|
---|
| 839 |
|
---|
| 840 | // bool coded;
|
---|
| 841 | // envStream.getline(buff, 255);
|
---|
| 842 | // buff[8] = 0;
|
---|
| 843 | // if (strcmp(buff, "CGX_CF10") == 0)
|
---|
| 844 | // coded = true;
|
---|
| 845 | // else {
|
---|
| 846 | // coded = false;
|
---|
| 847 | // envStream.Rewind();
|
---|
| 848 | // }
|
---|
| 849 |
|
---|
| 850 | // main loop
|
---|
| 851 | for (;;) {
|
---|
| 852 | // read in one line
|
---|
| 853 | envStream.getline(buff, 255);
|
---|
| 854 |
|
---|
| 855 | if (!envStream)
|
---|
| 856 | break;
|
---|
| 857 |
|
---|
| 858 | // if (coded)
|
---|
| 859 | // DecodeString(buff, 255);
|
---|
| 860 |
|
---|
| 861 | line++;
|
---|
| 862 | // get rid of comments
|
---|
| 863 | s = strchr(buff, '#');
|
---|
| 864 | if (s != NULL)
|
---|
| 865 | *s = '\0';
|
---|
| 866 |
|
---|
| 867 | // get one identifier
|
---|
| 868 | s = ParseString(buff, name);
|
---|
| 869 | // parse line
|
---|
| 870 | while (s != NULL) {
|
---|
| 871 | // it's a group name - make the full name
|
---|
| 872 | if (*s == '{') {
|
---|
| 873 | strcat(name, ".");
|
---|
| 874 | s++;
|
---|
| 875 | s = ParseString(s, name);
|
---|
| 876 | continue;
|
---|
| 877 | }
|
---|
| 878 | // end of group
|
---|
| 879 | if (*s == '}') {
|
---|
| 880 | if (strlen(name) == 0) {
|
---|
| 881 | cerr << "Error: unpaired } in " << envFilename << " (line "
|
---|
| 882 | << line << ").\n";
|
---|
| 883 | envStream.close();
|
---|
| 884 | return false;
|
---|
| 885 | }
|
---|
| 886 | name[strlen(name) - 1] = '\0';
|
---|
| 887 | t = strrchr(name, '.');
|
---|
| 888 | if (t == NULL)
|
---|
| 889 | name[0] = '\0';
|
---|
| 890 | else
|
---|
| 891 | *(t + 1) = '\0';
|
---|
| 892 | s++;
|
---|
| 893 | s = ParseString(s, name);
|
---|
| 894 | continue;
|
---|
| 895 | }
|
---|
| 896 | // find variable name in the table
|
---|
| 897 | found = false;
|
---|
| 898 | for (i = 0; i < numOptions; i++)
|
---|
| 899 | if (!strcmp(name, options[i].name)) {
|
---|
| 900 | found = true;
|
---|
| 901 | break;
|
---|
| 902 | }
|
---|
| 903 | if (!found) {
|
---|
| 904 | cerr << "Warning: unknown option " << name << " in environment file "
|
---|
| 905 | << envFilename << " (line " << line << ").\n";
|
---|
| 906 | } else
|
---|
| 907 | switch (options[i].type) {
|
---|
| 908 | case optInt: {
|
---|
| 909 | strtol(s, &t, 10);
|
---|
| 910 | if (t == s || (*t != ' ' && *t != '\t' &&
|
---|
| 911 | *t != '\0' && *t != '}')) {
|
---|
| 912 | cerr << "Error: Mismatch in int variable " << name << " in "
|
---|
| 913 | << "environment file " << envFilename << " (line "
|
---|
| 914 | << line << ").\n";
|
---|
| 915 | envStream.close();
|
---|
| 916 | return false;
|
---|
| 917 | }
|
---|
| 918 | if (options[i].value != NULL)
|
---|
| 919 | delete options[i].value;
|
---|
| 920 | options[i].value = new char[t - s + 1];
|
---|
| 921 | strncpy(options[i].value, s, t - s);
|
---|
| 922 | options[i].value[t - s] = '\0';
|
---|
| 923 | s = t;
|
---|
| 924 | break;
|
---|
| 925 | }
|
---|
| 926 | case optFloat: {
|
---|
| 927 | strtod(s, &t);
|
---|
| 928 | if (t == s || (*t != ' ' && *t != '\t' &&
|
---|
| 929 | *t != '\0' && *t != '}')) {
|
---|
| 930 | cerr << "Error: Mismatch in Real variable " << name << " in "
|
---|
| 931 | << "environment file " << envFilename << " (line "
|
---|
| 932 | << line << ").\n";
|
---|
| 933 | envStream.close();
|
---|
| 934 | return false;
|
---|
| 935 | }
|
---|
| 936 | if (options[i].value != NULL)
|
---|
| 937 | delete options[i].value;
|
---|
| 938 | options[i].value = new char[t - s + 1];
|
---|
| 939 | strncpy(options[i].value, s, t - s);
|
---|
| 940 | options[i].value[t - s] = '\0';
|
---|
| 941 | s = t;
|
---|
| 942 | break;
|
---|
| 943 | }
|
---|
| 944 | case optBool: {
|
---|
| 945 | t = s;
|
---|
| 946 | while ((*t >= 'a' && *t <= 'z') ||
|
---|
| 947 | (*t >= 'A' && *t <= 'Z') ||
|
---|
| 948 | *t == '+' || *t == '-')
|
---|
| 949 | t++;
|
---|
| 950 | if (((!strncasecmp(s, "true", t - s) && t - s == 4) ||
|
---|
| 951 | (!strncasecmp(s, "false", t - s) && t - s == 5) ||
|
---|
| 952 | (!strncasecmp(s, "YES", t -s) && t - s == 3) ||
|
---|
| 953 | (!strncasecmp(s, "NO", t - s) && t - s == 2) ||
|
---|
| 954 | (!strncasecmp(s, "ON", t - s) && t - s == 2) ||
|
---|
| 955 | (!strncasecmp(s, "OFF", t - s) && t - s == 3) ||
|
---|
| 956 | (t - s == 1 && (*s == '+' || *s == '-'))) &&
|
---|
| 957 | (*t == ' ' || *t == '\t' || *t == '\0' || *t == '}')) {
|
---|
| 958 | if (options[i].value != NULL)
|
---|
| 959 | delete options[i].value;
|
---|
| 960 | options[i].value = new char[t - s + 1];
|
---|
| 961 | strncpy(options[i].value, s, t - s);
|
---|
| 962 | options[i].value[t - s] = '\0';
|
---|
| 963 | s = t;
|
---|
| 964 | }
|
---|
| 965 | else {
|
---|
| 966 | cerr << "Error: Mismatch in bool variable " << name << " in "
|
---|
| 967 | << "environment file " << envFilename << " (line "
|
---|
| 968 | << line << ").\n";
|
---|
| 969 | envStream.close();
|
---|
| 970 | return false;
|
---|
| 971 | }
|
---|
| 972 | break;
|
---|
| 973 | }
|
---|
| 974 | case optVector:{
|
---|
| 975 | strtod(s, &t);
|
---|
| 976 | if (*t == ' ' || *t == '\t') {
|
---|
| 977 | while (*t == ' ' || *t == '\t')
|
---|
| 978 | t++;
|
---|
| 979 | if (*t != ',')
|
---|
| 980 | t--;
|
---|
| 981 | }
|
---|
| 982 | if (t == s || (*t != ' ' && *t != '\t' && *t != ',')) {
|
---|
| 983 | cerr << "Error: Mismatch in vector variable " << name << " in "
|
---|
| 984 | << "environment file " << envFilename << " (line "
|
---|
| 985 | << line << ").\n";
|
---|
| 986 | envStream.close();
|
---|
| 987 | return false;
|
---|
| 988 | }
|
---|
| 989 | char *u;
|
---|
| 990 | strtod(t, &u);
|
---|
| 991 | t = u;
|
---|
| 992 | if (*t == ' ' || *t == '\t') {
|
---|
| 993 | while (*t == ' ' || *t == '\t')
|
---|
| 994 | t++;
|
---|
| 995 | if (*t != ',')
|
---|
| 996 | t--;
|
---|
| 997 | }
|
---|
| 998 | if (t == s || (*t != ' ' && *t != '\t' && *t != ',')) {
|
---|
| 999 | cerr << "Error: Mismatch in vector variable " << name << " in "
|
---|
| 1000 | << "environment file " << envFilename << " (line "
|
---|
| 1001 | << line << ").\n";
|
---|
| 1002 | envStream.close();
|
---|
| 1003 | return false;
|
---|
| 1004 | }
|
---|
| 1005 | strtod(t, &u);
|
---|
| 1006 | t = u;
|
---|
| 1007 | if (t == s || (*t != ' ' && *t != '\t' &&
|
---|
| 1008 | *t != '\0' && *t != '}')) {
|
---|
| 1009 | cerr << "Error: Mismatch in vector variable " << name << " in "
|
---|
| 1010 | << "environment file " << envFilename << " (line "
|
---|
| 1011 | << line << ").\n";
|
---|
| 1012 | envStream.close();
|
---|
| 1013 | return false;
|
---|
| 1014 | }
|
---|
| 1015 | if (options[i].value != NULL)
|
---|
| 1016 | delete options[i].value;
|
---|
| 1017 | options[i].value = new char[t - s + 1];
|
---|
| 1018 | strncpy(options[i].value, s, t - s);
|
---|
| 1019 | options[i].value[t - s] = '\0';
|
---|
| 1020 | s = t;
|
---|
| 1021 | break;
|
---|
| 1022 | }
|
---|
| 1023 | case optString: {
|
---|
| 1024 | if (options[i].value != NULL)
|
---|
| 1025 | delete options[i].value;
|
---|
| 1026 | options[i].value = new char[strlen(s) + 1];
|
---|
| 1027 | strcpy(options[i].value, s);
|
---|
| 1028 | s += strlen(s);
|
---|
| 1029 | break;
|
---|
| 1030 | }
|
---|
| 1031 | default: {
|
---|
| 1032 | Debug << "Internal error: Unknown type of option.\n" << flush;
|
---|
| 1033 | exit(1);
|
---|
| 1034 | }
|
---|
| 1035 | }
|
---|
| 1036 | // prepare the variable name for next pass
|
---|
| 1037 | t = strrchr(name, '.');
|
---|
| 1038 | if (t == NULL)
|
---|
| 1039 | name[0] = '\0';
|
---|
| 1040 | else
|
---|
| 1041 | *(t + 1) = '\0';
|
---|
| 1042 | // get next identifier
|
---|
| 1043 | s = ParseString(s, name);
|
---|
| 1044 | }
|
---|
| 1045 | }
|
---|
| 1046 | envStream.close();
|
---|
| 1047 | return true;
|
---|
| 1048 | }
|
---|
| 1049 |
|
---|
| 1050 | void
|
---|
| 1051 | Environment::PrintUsage(ostream &s) const
|
---|
| 1052 | {
|
---|
| 1053 | // Print out all environment variable names
|
---|
| 1054 | s << "Registered options:\n";
|
---|
| 1055 | for (int j = 0; j < numOptions; j++)
|
---|
| 1056 | s << options[j] << "\n";
|
---|
| 1057 | s << flush;
|
---|
| 1058 | }
|
---|
| 1059 |
|
---|
[859] | 1060 | /**
|
---|
| 1061 | Input scene filename. Currently simplified X3D (.x3d), Unigraphics (.dat),
|
---|
| 1062 | and UNC (.ply) formats are supported.
|
---|
| 1063 | */
|
---|
[372] | 1064 |
|
---|
| 1065 | Environment::Environment()
|
---|
| 1066 | {
|
---|
| 1067 | optionalParams = NULL;
|
---|
| 1068 | paramRows = 0;
|
---|
| 1069 | numParams = 0;
|
---|
| 1070 | params = NULL;
|
---|
[539] | 1071 | maxOptions = 500;
|
---|
[372] | 1072 |
|
---|
| 1073 |
|
---|
| 1074 | // this is maximal nuber of options.
|
---|
| 1075 | numOptions = 0;
|
---|
| 1076 |
|
---|
| 1077 | options = new COption[maxOptions];
|
---|
| 1078 |
|
---|
| 1079 | if (options == NULL ) {
|
---|
| 1080 | Debug << "Error: Memory allocation failed.\n";
|
---|
| 1081 | exit(1);
|
---|
| 1082 | }
|
---|
| 1083 |
|
---|
| 1084 | // register all basic options
|
---|
| 1085 |
|
---|
| 1086 | RegisterOption("Limits.threshold", optFloat, NULL, "0.01");
|
---|
| 1087 | RegisterOption("Limits.small", optFloat, NULL, "1e-6");
|
---|
| 1088 | RegisterOption("Limits.infinity", optFloat, NULL, "1e6");
|
---|
| 1089 |
|
---|
| 1090 | RegisterOption("Scene.filename",
|
---|
[492] | 1091 | optString,
|
---|
| 1092 | "scene_filename=",
|
---|
| 1093 | "atlanta2.x3d");
|
---|
[372] | 1094 |
|
---|
[859] | 1095 |
|
---|
[372] | 1096 | RegisterOption("Unigraphics.meshGrouping",
|
---|
[492] | 1097 | optInt,
|
---|
| 1098 | "unigraphics_mesh_grouping=",
|
---|
| 1099 | "0");
|
---|
[372] | 1100 |
|
---|
| 1101 |
|
---|
| 1102 | RegisterOption("KdTree.Termination.minCost",
|
---|
[492] | 1103 | optInt,
|
---|
| 1104 | "kd_term_min_cost=",
|
---|
| 1105 | "10");
|
---|
[859] | 1106 |
|
---|
[752] | 1107 | RegisterOption("KdTree.Termination.maxNodes",
|
---|
| 1108 | optInt,
|
---|
| 1109 | "kd_term_max_nodes=",
|
---|
| 1110 | "200000");
|
---|
[859] | 1111 |
|
---|
[372] | 1112 | RegisterOption("KdTree.Termination.maxDepth",
|
---|
[492] | 1113 | optInt,
|
---|
| 1114 | "kd_term_max_depth=",
|
---|
| 1115 | "20");
|
---|
[372] | 1116 |
|
---|
| 1117 | RegisterOption("KdTree.Termination.maxCostRatio",
|
---|
[492] | 1118 | optFloat,
|
---|
| 1119 | "kd_term_max_cost_ratio=",
|
---|
| 1120 | "1.5");
|
---|
[372] | 1121 |
|
---|
| 1122 | RegisterOption("KdTree.Termination.ct_div_ci",
|
---|
[492] | 1123 | optFloat,
|
---|
| 1124 | "kd_term_ct_div_ci=",
|
---|
| 1125 | "1.0");
|
---|
[372] | 1126 |
|
---|
| 1127 | RegisterOption("KdTree.splitMethod",
|
---|
[492] | 1128 | optString,
|
---|
| 1129 | "kd_split_method=",
|
---|
| 1130 | "spatialMedian");
|
---|
[372] | 1131 |
|
---|
| 1132 | RegisterOption("KdTree.splitBorder",
|
---|
| 1133 | optFloat,
|
---|
[492] | 1134 | "kd_split_border=",
|
---|
[372] | 1135 | "0.1");
|
---|
| 1136 |
|
---|
| 1137 | RegisterOption("KdTree.sahUseFaces",
|
---|
| 1138 | optBool,
|
---|
[492] | 1139 | "kd_sah_use_faces=",
|
---|
[372] | 1140 | "true");
|
---|
| 1141 |
|
---|
| 1142 |
|
---|
| 1143 | RegisterOption("MeshKdTree.Termination.minCost",
|
---|
| 1144 | optInt,
|
---|
[492] | 1145 | "kd_term_min_cost=",
|
---|
[372] | 1146 | "10");
|
---|
| 1147 |
|
---|
| 1148 | RegisterOption("MeshKdTree.Termination.maxDepth",
|
---|
| 1149 | optInt,
|
---|
[492] | 1150 | "kd_term_max_depth=",
|
---|
[372] | 1151 | "20");
|
---|
| 1152 |
|
---|
| 1153 | RegisterOption("MeshKdTree.Termination.maxCostRatio",
|
---|
| 1154 | optFloat,
|
---|
[492] | 1155 | "kd_term_max_cost_ratio=",
|
---|
[372] | 1156 | "1.5");
|
---|
| 1157 |
|
---|
| 1158 | RegisterOption("MeshKdTree.Termination.ct_div_ci",
|
---|
| 1159 | optFloat,
|
---|
[492] | 1160 | "kd_term_ct_div_ci=",
|
---|
[372] | 1161 | "1.0");
|
---|
| 1162 |
|
---|
| 1163 | RegisterOption("MeshKdTree.splitMethod",
|
---|
| 1164 | optString,
|
---|
[492] | 1165 | "kd_split_method=",
|
---|
[372] | 1166 | "spatialMedian");
|
---|
| 1167 |
|
---|
| 1168 | RegisterOption("MeshKdTree.splitBorder",
|
---|
| 1169 | optFloat,
|
---|
[492] | 1170 | "kd_split_border=",
|
---|
[372] | 1171 | "0.1");
|
---|
| 1172 |
|
---|
[508] | 1173 | RegisterOption("SamplingPreprocessor.totalSamples",
|
---|
[372] | 1174 | optInt,
|
---|
[492] | 1175 | "total_samples=",
|
---|
[372] | 1176 | "1000000");
|
---|
| 1177 |
|
---|
[508] | 1178 | RegisterOption("SamplingPreprocessor.samplesPerPass",
|
---|
[372] | 1179 | optInt,
|
---|
[492] | 1180 | "samples_per_pass=",
|
---|
[372] | 1181 | "10");
|
---|
| 1182 |
|
---|
[811] | 1183 | RegisterOption("RenderSampler.samples",
|
---|
| 1184 | optInt,
|
---|
| 1185 | "render_sampler_samples=",
|
---|
| 1186 | "1000");
|
---|
| 1187 |
|
---|
[1001] | 1188 | RegisterOption("RenderSampler.visibleThreshold",
|
---|
| 1189 | optInt,
|
---|
| 1190 | "render_sampler_visible_threshold=",
|
---|
| 1191 | "0");
|
---|
| 1192 |
|
---|
| 1193 |
|
---|
[997] | 1194 | RegisterOption("RenderSampler.useOcclusionQueries",
|
---|
| 1195 | optBool,
|
---|
| 1196 | "render_sampler_use_occlusion_queries=",
|
---|
| 1197 | "true");
|
---|
| 1198 |
|
---|
| 1199 | RegisterOption("VssPreprocessor.initialSamples",
|
---|
[492] | 1200 | optInt,
|
---|
| 1201 | "initial_samples=",
|
---|
| 1202 | "100000");
|
---|
| 1203 |
|
---|
[1001] | 1204 | RegisterOption("VssPreprocessor.testBeamSampling",
|
---|
| 1205 | optBool,
|
---|
| 1206 | "beam_sampling",
|
---|
| 1207 | "false");
|
---|
[532] | 1208 |
|
---|
[469] | 1209 | RegisterOption("VssPreprocessor.vssSamples",
|
---|
[492] | 1210 | optInt,
|
---|
| 1211 | "vss_samples=",
|
---|
| 1212 | "1000000");
|
---|
[376] | 1213 |
|
---|
[427] | 1214 | RegisterOption("VssPreprocessor.vssSamplesPerPass",
|
---|
[492] | 1215 | optInt,
|
---|
| 1216 | "vss_samples_per_pass=",
|
---|
| 1217 | "1000");
|
---|
| 1218 |
|
---|
[469] | 1219 | RegisterOption("VssPreprocessor.samplesPerPass",
|
---|
[492] | 1220 | optInt,
|
---|
| 1221 | "samples_per_pass=",
|
---|
| 1222 | "100000");
|
---|
[376] | 1223 |
|
---|
[403] | 1224 | RegisterOption("VssPreprocessor.useImportanceSampling",
|
---|
[492] | 1225 | optBool,
|
---|
| 1226 | "vss_use_importance=",
|
---|
| 1227 | "true");
|
---|
[403] | 1228 |
|
---|
[674] | 1229 | RegisterOption("VssPreprocessor.enlargeViewSpace",
|
---|
| 1230 | optBool,
|
---|
| 1231 | "vss_enlarge_viewspace=",
|
---|
[675] | 1232 | "false");
|
---|
[674] | 1233 |
|
---|
[490] | 1234 | RegisterOption("VssPreprocessor.loadInitialSamples",
|
---|
| 1235 | optBool,
|
---|
[674] | 1236 | "vss_load_loadInitialSamples=",
|
---|
[490] | 1237 | "false");
|
---|
[445] | 1238 |
|
---|
[490] | 1239 | RegisterOption("VssPreprocessor.storeInitialSamples",
|
---|
| 1240 | optBool,
|
---|
[674] | 1241 | "vss_store_storedInitialSamples=",
|
---|
[490] | 1242 | "false");
|
---|
| 1243 |
|
---|
| 1244 |
|
---|
[501] | 1245 | RegisterOption("VssPreprocessor.useViewSpaceBox",
|
---|
| 1246 | optBool,
|
---|
[674] | 1247 | "vss_use_viewspace_box=",
|
---|
[508] | 1248 | "false");
|
---|
[501] | 1249 |
|
---|
| 1250 |
|
---|
[445] | 1251 | /************************************************************************************/
|
---|
| 1252 | /* View cells related options */
|
---|
| 1253 | /************************************************************************************/
|
---|
| 1254 |
|
---|
| 1255 |
|
---|
[508] | 1256 | RegisterOption("ViewCells.type",
|
---|
| 1257 | optString,
|
---|
[664] | 1258 | "view_cells_type=",
|
---|
[662] | 1259 | "vspBspTree");
|
---|
[372] | 1260 |
|
---|
[662] | 1261 | RegisterOption("ViewCells.samplingType",
|
---|
| 1262 | optString,
|
---|
[664] | 1263 | "view_cells_sampling_type=",
|
---|
[662] | 1264 | "box");
|
---|
| 1265 |
|
---|
[666] | 1266 | RegisterOption("ViewCells.mergeStats",
|
---|
[660] | 1267 | optString,
|
---|
[666] | 1268 | "view_cells_merge_stats=",
|
---|
| 1269 | "mergeStats.log");
|
---|
[660] | 1270 |
|
---|
[664] | 1271 | RegisterOption("ViewCells.Evaluation.statsPrefix",
|
---|
[660] | 1272 | optString,
|
---|
[664] | 1273 | "view_cells_evaluation_stats_prefix=",
|
---|
[660] | 1274 | "viewCells");
|
---|
[735] | 1275 | RegisterOption("ViewCells.Evaluation.histogram",
|
---|
| 1276 | optBool,
|
---|
| 1277 | "view_cells_evaluation_histogram=",
|
---|
| 1278 | "false");
|
---|
| 1279 |
|
---|
[997] | 1280 | RegisterOption("ViewCells.Evaluation.histoStepSize",
|
---|
[735] | 1281 | optInt,
|
---|
[997] | 1282 | "view_cells_evaluation_histo_step_size=",
|
---|
[744] | 1283 | "5000");
|
---|
[735] | 1284 |
|
---|
[728] | 1285 | RegisterOption("ViewCells.renderCostEvaluationType",
|
---|
| 1286 | optString,
|
---|
| 1287 | "view_cells_render_cost_evaluation=",
|
---|
| 1288 | "perobject");
|
---|
| 1289 |
|
---|
[660] | 1290 | RegisterOption("ViewCells.active",
|
---|
| 1291 | optInt,
|
---|
[664] | 1292 | "view_cells_active=",
|
---|
[660] | 1293 | "1000");
|
---|
[581] | 1294 |
|
---|
[574] | 1295 | RegisterOption("ViewCells.Construction.samples",
|
---|
| 1296 | optInt,
|
---|
| 1297 | "view_cells_construction_samples=",
|
---|
[1134] | 1298 | "0");
|
---|
[574] | 1299 |
|
---|
| 1300 | RegisterOption("ViewCells.Construction.samplesPerPass",
|
---|
| 1301 | optInt,
|
---|
| 1302 | "view_cells_construction_samples_per_pass=",
|
---|
| 1303 | "500000");
|
---|
| 1304 |
|
---|
[508] | 1305 | RegisterOption("ViewCells.PostProcess.samples",
|
---|
| 1306 | optInt,
|
---|
[712] | 1307 | "view_cells_post_process_samples=",
|
---|
[1134] | 1308 | "0");
|
---|
[421] | 1309 |
|
---|
[508] | 1310 | RegisterOption("ViewCells.Visualization.samples",
|
---|
| 1311 | optInt,
|
---|
| 1312 | "view_cells_visualization_samples=",
|
---|
[1134] | 1313 | "0");
|
---|
[372] | 1314 |
|
---|
[1020] | 1315 | RegisterOption("ViewCells.Visualization.maxOutput",
|
---|
| 1316 | optInt,
|
---|
| 1317 | "view_cells_visualization_max_output=",
|
---|
| 1318 | "20");
|
---|
| 1319 |
|
---|
[697] | 1320 | RegisterOption("ViewCells.Filter.maxSize",
|
---|
| 1321 | optInt,
|
---|
| 1322 | "view_cells_filter_max_size=",
|
---|
| 1323 | "4");
|
---|
| 1324 |
|
---|
| 1325 | RegisterOption("ViewCells.Filter.width",
|
---|
| 1326 | optFloat,
|
---|
| 1327 | "view_cells_filter_width=",
|
---|
[746] | 1328 | "200.0");
|
---|
[697] | 1329 |
|
---|
[508] | 1330 | RegisterOption("ViewCells.loadFromFile",
|
---|
| 1331 | optBool,
|
---|
[664] | 1332 | "view_cells_load_from_file=",
|
---|
[508] | 1333 | "false");
|
---|
[485] | 1334 |
|
---|
[586] | 1335 | RegisterOption("ViewCells.PostProcess.refine",
|
---|
| 1336 | optBool,
|
---|
[664] | 1337 | "view_cells_refine=",
|
---|
[586] | 1338 | "false");
|
---|
| 1339 |
|
---|
| 1340 | RegisterOption("ViewCells.PostProcess.compress",
|
---|
| 1341 | optBool,
|
---|
[664] | 1342 | "view_cells_post_process_compress=",
|
---|
[586] | 1343 | "false");
|
---|
| 1344 |
|
---|
[662] | 1345 | RegisterOption("ViewCells.Evaluation.samples",
|
---|
| 1346 | optInt,
|
---|
| 1347 | "view_cells_evaluation_samples=",
|
---|
| 1348 | "8000000");
|
---|
| 1349 |
|
---|
[722] | 1350 | RegisterOption("ViewCells.Evaluation.samplingType",
|
---|
[837] | 1351 | optString,
|
---|
| 1352 | "view_cells_evaluation_sampling_type=",
|
---|
| 1353 | "box");
|
---|
[722] | 1354 |
|
---|
[662] | 1355 | RegisterOption("ViewCells.Evaluation.samplesPerPass",
|
---|
| 1356 | optInt,
|
---|
| 1357 | "view_cells_evaluation_samples_per_pass=",
|
---|
| 1358 | "300000");
|
---|
| 1359 |
|
---|
[508] | 1360 | RegisterOption("ViewCells.exportToFile",
|
---|
| 1361 | optBool,
|
---|
[676] | 1362 | "view_cells_export_to_file=",
|
---|
[508] | 1363 | "false");
|
---|
| 1364 |
|
---|
[844] | 1365 | RegisterOption("ViewCells.exportPvs",
|
---|
| 1366 | optBool,
|
---|
| 1367 | "view_cells_export_pvs=",
|
---|
| 1368 | "false");
|
---|
| 1369 |
|
---|
[840] | 1370 | RegisterOption("ViewCells.exportBboxesForPvs",
|
---|
| 1371 | optBool,
|
---|
[844] | 1372 | "view_cells_export_bounding_boxes=",
|
---|
[840] | 1373 | "true");
|
---|
| 1374 |
|
---|
| 1375 | RegisterOption("ViewCells.boxesFilename",
|
---|
| 1376 | optString,
|
---|
| 1377 | "view_cells_boxes_filename=",
|
---|
| 1378 | "boxes.out");
|
---|
| 1379 |
|
---|
[664] | 1380 | RegisterOption("ViewCells.evaluateViewCells",
|
---|
| 1381 | optBool,
|
---|
[670] | 1382 | "view_cells_evaluate=",
|
---|
[664] | 1383 | "false");
|
---|
| 1384 |
|
---|
[508] | 1385 | RegisterOption("ViewCells.maxViewCells",
|
---|
[667] | 1386 | optInt,
|
---|
| 1387 | "view_cells_max_view_cells=",
|
---|
| 1388 | "0");
|
---|
[508] | 1389 |
|
---|
[511] | 1390 | RegisterOption("ViewCells.maxPvsRatio",
|
---|
| 1391 | optFloat,
|
---|
| 1392 | "view_cells_max_pvs_ratio=",
|
---|
| 1393 | "0.1");
|
---|
[508] | 1394 |
|
---|
| 1395 | RegisterOption("ViewCells.filename",
|
---|
[667] | 1396 | optString,
|
---|
| 1397 | "view_cells_filename=",
|
---|
| 1398 | "atlanta_viewcells_large.x3d");
|
---|
[508] | 1399 |
|
---|
| 1400 | RegisterOption("ViewCells.height",
|
---|
[667] | 1401 | optFloat,
|
---|
| 1402 | "view_cells_height=",
|
---|
| 1403 | "5.0");
|
---|
[508] | 1404 |
|
---|
| 1405 | RegisterOption("ViewCells.Visualization.colorCode",
|
---|
[667] | 1406 | optString,
|
---|
[708] | 1407 | "view_cells_visualization_color_code=",
|
---|
[667] | 1408 | "PVS");
|
---|
[482] | 1409 |
|
---|
[667] | 1410 | RegisterOption("ViewCells.Visualization.clipPlanePos",
|
---|
| 1411 | optFloat,
|
---|
[708] | 1412 | "view_cells_visualization_clip_plane_pos=",
|
---|
[667] | 1413 | "0.35");
|
---|
[579] | 1414 |
|
---|
[508] | 1415 | RegisterOption("ViewCells.Visualization.exportGeometry",
|
---|
[667] | 1416 | optBool,
|
---|
[708] | 1417 | "view_cells_visualization_export_geometry=",
|
---|
[667] | 1418 | "false");
|
---|
[445] | 1419 |
|
---|
[667] | 1420 | RegisterOption("ViewCells.Visualization.exportRays",
|
---|
| 1421 | optBool,
|
---|
[708] | 1422 | "view_cells_visualization_export_rays=",
|
---|
[667] | 1423 | "false");
|
---|
| 1424 |
|
---|
[564] | 1425 | RegisterOption("ViewCells.pruneEmptyViewCells",
|
---|
[667] | 1426 | optBool,
|
---|
[708] | 1427 | "view_cells_prune_empty=",
|
---|
[667] | 1428 | "false");
|
---|
[445] | 1429 |
|
---|
[564] | 1430 | RegisterOption("ViewCells.processOnlyValidViewCells",
|
---|
[667] | 1431 | optBool,
|
---|
[708] | 1432 | "view_cells_process_only_valid_view_cells=",
|
---|
[667] | 1433 | "false");
|
---|
[660] | 1434 |
|
---|
[564] | 1435 |
|
---|
[580] | 1436 | RegisterOption("ViewCells.PostProcess.maxCostRatio",
|
---|
| 1437 | optFloat,
|
---|
[667] | 1438 | "view_cells_post_process_max_cost_ratio=",
|
---|
[580] | 1439 | "0.9");
|
---|
| 1440 |
|
---|
| 1441 | RegisterOption("ViewCells.PostProcess.renderCostWeight",
|
---|
| 1442 | optFloat,
|
---|
[667] | 1443 | "view_cells_post_process_render_cost_weight",
|
---|
[580] | 1444 | "0.5");
|
---|
| 1445 |
|
---|
| 1446 | RegisterOption("ViewCells.PostProcess.avgCostMaxDeviation",
|
---|
| 1447 | optFloat,
|
---|
[1143] | 1448 | "view_cells_avgcost_max_deviations",
|
---|
[580] | 1449 | "0.5");
|
---|
| 1450 |
|
---|
| 1451 | RegisterOption("ViewCells.PostProcess.maxMergesPerPass",
|
---|
| 1452 | optInt,
|
---|
[667] | 1453 | "view_cells_post_process_max_merges_per_pass=",
|
---|
[580] | 1454 | "500");
|
---|
| 1455 |
|
---|
| 1456 | RegisterOption("ViewCells.PostProcess.minViewCells",
|
---|
| 1457 | optInt,
|
---|
[667] | 1458 | "view_cells_post_process_min_view_cells=",
|
---|
[580] | 1459 | "1000");
|
---|
| 1460 |
|
---|
| 1461 | RegisterOption("ViewCells.PostProcess.useRaysForMerge",
|
---|
| 1462 | optBool,
|
---|
| 1463 | "view_cells_post_process_use_rays_for_merge=",
|
---|
| 1464 | "false");
|
---|
[591] | 1465 |
|
---|
| 1466 | RegisterOption("ViewCells.PostProcess.merge",
|
---|
| 1467 | optBool,
|
---|
[666] | 1468 | "view_cells_post_process_merge=",
|
---|
[591] | 1469 | "true");
|
---|
[580] | 1470 |
|
---|
| 1471 | RegisterOption("ViewCells.Visualization.exportMergedViewCells",
|
---|
| 1472 | optBool,
|
---|
| 1473 | "view_cells_viz_export_merged_viewcells=",
|
---|
| 1474 | "false");
|
---|
| 1475 |
|
---|
[582] | 1476 | RegisterOption("ViewCells.maxStaticMemory",
|
---|
| 1477 | optFloat,
|
---|
| 1478 | "view_cells_max_static_mem=",
|
---|
| 1479 | "8.0");
|
---|
[580] | 1480 |
|
---|
[660] | 1481 | RegisterOption("ViewCells.Visualization.useClipPlane",
|
---|
[591] | 1482 | optBool,
|
---|
[660] | 1483 | "view_cells_viz_use_clip_plane=",
|
---|
[591] | 1484 | "false");
|
---|
| 1485 |
|
---|
[666] | 1486 | RegisterOption("ViewCells.showVisualization",
|
---|
| 1487 | optBool,
|
---|
| 1488 | "view_cells_show_visualization=",
|
---|
| 1489 | "false");
|
---|
| 1490 |
|
---|
[660] | 1491 | RegisterOption("ViewCells.Visualization.clipPlaneAxis",
|
---|
[591] | 1492 | optInt,
|
---|
[660] | 1493 | "view_cells_viz_clip_plane_axis=",
|
---|
[591] | 1494 | "0");
|
---|
| 1495 |
|
---|
[1159] | 1496 | RegisterOption("ViewCells.storeKdPvs",
|
---|
| 1497 | optBool,
|
---|
| 1498 | "view_cells_store_kd_pvs=",
|
---|
| 1499 | "false");
|
---|
| 1500 |
|
---|
[591] | 1501 |
|
---|
[508] | 1502 | /************************************************************************************/
|
---|
| 1503 | /* Render simulation related options */
|
---|
| 1504 | /************************************************************************************/
|
---|
[372] | 1505 |
|
---|
[406] | 1506 |
|
---|
[508] | 1507 | RegisterOption("Simulation.objRenderCost",
|
---|
| 1508 | optFloat,
|
---|
| 1509 | "simulation_obj_render_cost",
|
---|
| 1510 | "1.0");
|
---|
[409] | 1511 |
|
---|
[508] | 1512 | RegisterOption("Simulation.vcOverhead",
|
---|
| 1513 | optFloat,
|
---|
| 1514 | "simulation_vc_overhead",
|
---|
| 1515 | "0.05");
|
---|
[445] | 1516 |
|
---|
[508] | 1517 | RegisterOption("Simulation.moveSpeed",
|
---|
| 1518 | optFloat,
|
---|
| 1519 | "simulation_moveSpeed",
|
---|
| 1520 | "1.0");
|
---|
[445] | 1521 |
|
---|
| 1522 |
|
---|
| 1523 |
|
---|
| 1524 |
|
---|
[508] | 1525 | /************************************************************************************/
|
---|
| 1526 | /* Bsp tree related options */
|
---|
| 1527 | /************************************************************************************/
|
---|
[372] | 1528 |
|
---|
| 1529 |
|
---|
[508] | 1530 | RegisterOption("BspTree.Construction.input",
|
---|
| 1531 | optString,
|
---|
| 1532 | "bsp_construction_input=",
|
---|
| 1533 | "fromViewCells");
|
---|
[372] | 1534 |
|
---|
[660] | 1535 | RegisterOption("BspTree.subdivisionStats",
|
---|
| 1536 | optString,
|
---|
[666] | 1537 | "bsp_subdivision_stats=",
|
---|
[660] | 1538 | "bspSubdivisionStats.log");
|
---|
| 1539 |
|
---|
[508] | 1540 | RegisterOption("BspTree.Construction.samples",
|
---|
| 1541 | optInt,
|
---|
| 1542 | "bsp_construction_samples=",
|
---|
| 1543 | "100000");
|
---|
[390] | 1544 |
|
---|
[508] | 1545 | RegisterOption("BspTree.Construction.epsilon",
|
---|
| 1546 | optFloat,
|
---|
[1023] | 1547 | "bsp_construction_epsilon=",
|
---|
[508] | 1548 | "0.002");
|
---|
[397] | 1549 |
|
---|
[508] | 1550 | RegisterOption("BspTree.Termination.minPolygons",
|
---|
| 1551 | optInt,
|
---|
| 1552 | "bsp_term_min_polygons=",
|
---|
| 1553 | "5");
|
---|
[409] | 1554 |
|
---|
[508] | 1555 | RegisterOption("BspTree.Termination.minPvs",
|
---|
| 1556 | optInt,
|
---|
| 1557 | "bsp_term_min_pvs=",
|
---|
| 1558 | "20");
|
---|
[372] | 1559 |
|
---|
[587] | 1560 | RegisterOption("BspTree.Termination.minProbability",
|
---|
[508] | 1561 | optFloat,
|
---|
[587] | 1562 | "bsp_term_min_probability=",
|
---|
[508] | 1563 | "0.001");
|
---|
[424] | 1564 |
|
---|
[508] | 1565 | RegisterOption("BspTree.Termination.maxRayContribution",
|
---|
| 1566 | optFloat,
|
---|
| 1567 | "bsp_term_ray_contribution=",
|
---|
| 1568 | "0.005");
|
---|
[372] | 1569 |
|
---|
[508] | 1570 | RegisterOption("BspTree.Termination.minAccRayLenght",
|
---|
| 1571 | optFloat,
|
---|
| 1572 | "bsp_term_min_acc_ray_length=",
|
---|
| 1573 | "50");
|
---|
[372] | 1574 |
|
---|
[508] | 1575 | RegisterOption("BspTree.Termination.minRays",
|
---|
| 1576 | optInt,
|
---|
| 1577 | "bsp_term_min_rays=",
|
---|
| 1578 | "-1");
|
---|
[372] | 1579 |
|
---|
[508] | 1580 | RegisterOption("BspTree.Termination.ct_div_ci",
|
---|
| 1581 | optFloat,
|
---|
| 1582 | "bsp_term_ct_div_ci=",
|
---|
| 1583 | "0.0");
|
---|
[372] | 1584 |
|
---|
[508] | 1585 | RegisterOption("BspTree.Termination.maxDepth",
|
---|
| 1586 | optInt,
|
---|
| 1587 | "bsp_term_max_depth=",
|
---|
| 1588 | "100");
|
---|
[372] | 1589 |
|
---|
[508] | 1590 | RegisterOption("BspTree.Termination.maxCostRatio",
|
---|
| 1591 | optFloat,
|
---|
| 1592 | "bsp_term_axis_aligned_max_cost_ratio=",
|
---|
| 1593 | "1.5");
|
---|
[372] | 1594 |
|
---|
[508] | 1595 | RegisterOption("BspTree.Termination.AxisAligned.ct_div_ci",
|
---|
| 1596 | optFloat,
|
---|
| 1597 | "bsp_term_axis_aligned_ct_div_ci=",
|
---|
| 1598 | "0.5");
|
---|
[372] | 1599 |
|
---|
[508] | 1600 | RegisterOption("BspTree.AxisAligned.splitBorder",
|
---|
| 1601 | optFloat,
|
---|
| 1602 | "bsp__axis_aligned_split_border=",
|
---|
| 1603 | "0.1");
|
---|
[372] | 1604 |
|
---|
[508] | 1605 | RegisterOption("BspTree.Termination.AxisAligned.minPolys",
|
---|
| 1606 | optInt,
|
---|
| 1607 | "bsp_term_axis_aligned_max_polygons=",
|
---|
| 1608 | "50");
|
---|
[379] | 1609 |
|
---|
[508] | 1610 | RegisterOption("BspTree.Termination.AxisAligned.minObjects",
|
---|
| 1611 | optInt,
|
---|
| 1612 | "bsp_term_min_objects=",
|
---|
| 1613 | "3");
|
---|
[441] | 1614 |
|
---|
[508] | 1615 | RegisterOption("BspTree.Termination.AxisAligned.minRays",
|
---|
| 1616 | optInt,
|
---|
| 1617 | "bsp_term_axis_aligned_min_rays=",
|
---|
| 1618 | "-1");
|
---|
[374] | 1619 |
|
---|
[508] | 1620 | RegisterOption("BspTree.splitPlaneStrategy",
|
---|
| 1621 | optString,
|
---|
| 1622 | "bsp_split_method=",
|
---|
| 1623 | "leastSplits");
|
---|
[424] | 1624 |
|
---|
[508] | 1625 | RegisterOption("BspTree.maxPolyCandidates",
|
---|
| 1626 | optInt,
|
---|
| 1627 | "bsp_max_poly_candidates=",
|
---|
| 1628 | "20");
|
---|
[469] | 1629 |
|
---|
[508] | 1630 | RegisterOption("BspTree.maxRayCandidates",
|
---|
| 1631 | optInt,
|
---|
| 1632 | "bsp_max_plane_candidates=",
|
---|
| 1633 | "20");
|
---|
[382] | 1634 |
|
---|
[508] | 1635 | RegisterOption("BspTree.maxTests",
|
---|
| 1636 | optInt,
|
---|
| 1637 | "bsp_max_tests=",
|
---|
| 1638 | "5000");
|
---|
[382] | 1639 |
|
---|
[587] | 1640 | RegisterOption("BspTree.Termination.maxViewCells",
|
---|
| 1641 | optInt,
|
---|
| 1642 | "bsp_max_view_cells=",
|
---|
| 1643 | "5000");
|
---|
| 1644 |
|
---|
[508] | 1645 | RegisterOption("BspTree.Visualization.exportSplits",
|
---|
| 1646 | optBool,
|
---|
| 1647 | "bsp_visualization.export_splits",
|
---|
| 1648 | "false");
|
---|
[445] | 1649 |
|
---|
[508] | 1650 | RegisterOption("BspTree.Factor.verticalSplits", optFloat, "bsp_factor_vertical=", "1.0");
|
---|
| 1651 | RegisterOption("BspTree.Factor.largestPolyArea", optFloat, "bsp_factor_largest_poly=", "1.0");
|
---|
| 1652 | RegisterOption("BspTree.Factor.blockedRays", optFloat, "bsp_factor_blocked=", "1.0");
|
---|
| 1653 | RegisterOption("BspTree.Factor.leastSplits", optFloat, "bsp_factor_least_splits=", "1.0");
|
---|
| 1654 | RegisterOption("BspTree.Factor.balancedPolys", optFloat, "bsp_factor_balanced_polys=", "1.0");
|
---|
| 1655 | RegisterOption("BspTree.Factor.balancedViewCells", optFloat, "bsp_factor_balanced_view_cells=", "1.0");
|
---|
| 1656 | RegisterOption("BspTree.Factor.leastRaySplits", optFloat, "bsp_factor_least_ray_splits=", "1.0");
|
---|
| 1657 | RegisterOption("BspTree.Factor.balancedRays", optFloat, "bsp_factor_balanced_rays=", "1.0");
|
---|
| 1658 | RegisterOption("BspTree.Factor.pvs", optFloat, "bsp_factor_pvs=", "1.0");
|
---|
[408] | 1659 |
|
---|
[508] | 1660 | /************************************************************************************/
|
---|
| 1661 | /* Preprocessor related options */
|
---|
| 1662 | /************************************************************************************/
|
---|
[408] | 1663 |
|
---|
[508] | 1664 | RegisterOption("Preprocessor.type",
|
---|
| 1665 | optString,
|
---|
| 1666 | "preprocessor=",
|
---|
| 1667 | "sampling");
|
---|
[408] | 1668 |
|
---|
[508] | 1669 | RegisterOption("Preprocessor.samplesFilename",
|
---|
| 1670 | optString,
|
---|
[676] | 1671 | "preprocessor_samples_filename=",
|
---|
[508] | 1672 | "rays.out");
|
---|
[408] | 1673 |
|
---|
[658] | 1674 | RegisterOption("Preprocessor.loadPolygonsAsMeshes",
|
---|
| 1675 | optBool,
|
---|
| 1676 | "loadPolygonsAsMeshes=",
|
---|
| 1677 | "false");
|
---|
| 1678 |
|
---|
[563] | 1679 | RegisterOption("Preprocessor.pvsRenderErrorSamples",
|
---|
| 1680 | optInt,
|
---|
| 1681 | "pvsRenderErrorSamples=",
|
---|
| 1682 | "10000");
|
---|
[682] | 1683 |
|
---|
| 1684 | RegisterOption("Preprocessor.useGlRenderer",
|
---|
| 1685 | optBool,
|
---|
| 1686 | "preprocessor_use_gl_renderer=",
|
---|
| 1687 | "false");
|
---|
| 1688 |
|
---|
[538] | 1689 | RegisterOption("Preprocessor.useGlDebugger",
|
---|
| 1690 | optBool,
|
---|
[682] | 1691 | "preprocessor_use_gl_debugger=",
|
---|
[538] | 1692 | "false");
|
---|
| 1693 |
|
---|
[534] | 1694 | RegisterOption("Preprocessor.detectEmptyViewSpace",
|
---|
| 1695 | optBool,
|
---|
[682] | 1696 | "preprocessor_detect_empty_viewspace=",
|
---|
[534] | 1697 | "false");
|
---|
| 1698 |
|
---|
[599] | 1699 | RegisterOption("Preprocessor.quitOnFinish",
|
---|
| 1700 | optBool,
|
---|
[1112] | 1701 | "preprocessor_quit_on_finish",
|
---|
[599] | 1702 | "true");
|
---|
[534] | 1703 |
|
---|
[685] | 1704 | RegisterOption("Preprocessor.computeVisibility",
|
---|
| 1705 | optBool,
|
---|
| 1706 | "preprocessor_compute_visibility=",
|
---|
| 1707 | "true");
|
---|
[682] | 1708 |
|
---|
[871] | 1709 | RegisterOption("Preprocessor.exportVisibility",
|
---|
| 1710 | optBool,
|
---|
[997] | 1711 | "preprocessor_export_visibility=",
|
---|
[871] | 1712 | "true");
|
---|
[682] | 1713 |
|
---|
[871] | 1714 | RegisterOption("Preprocessor.visibilityFile",
|
---|
| 1715 | optString,
|
---|
| 1716 | "preprocessor_visibility_file=",
|
---|
| 1717 | "visibility.xml");
|
---|
| 1718 |
|
---|
| 1719 | RegisterOption("Preprocessor.applyVisibilityFilter",
|
---|
| 1720 | optBool,
|
---|
[997] | 1721 | "preprocessor_apply_filter=",
|
---|
[871] | 1722 | "true");
|
---|
[904] | 1723 |
|
---|
| 1724 | RegisterOption("Preprocessor.applyVisibilitySpatialFilter",
|
---|
| 1725 | optBool,
|
---|
[997] | 1726 | "preprocessor_apply_spatial_filter=",
|
---|
[904] | 1727 | "true");
|
---|
[871] | 1728 |
|
---|
[878] | 1729 | RegisterOption("Preprocessor.visibilityFilterWidth",
|
---|
| 1730 | optFloat,
|
---|
| 1731 | "preprocessor_visibility_filter_width=",
|
---|
| 1732 | "0.02");
|
---|
[871] | 1733 |
|
---|
[991] | 1734 | RegisterOption("Preprocessor.histogram.maxValue",
|
---|
| 1735 | optInt,
|
---|
| 1736 | "preprocessor_histogram_max_value=",
|
---|
| 1737 | "1000");
|
---|
[871] | 1738 |
|
---|
[991] | 1739 | RegisterOption("Preprocessor.histogram.intervals",
|
---|
| 1740 | optInt,
|
---|
| 1741 | "preprocessor_histogram_intervals=",
|
---|
| 1742 | "20");
|
---|
[878] | 1743 |
|
---|
[991] | 1744 |
|
---|
[469] | 1745 | /************************************************************************************/
|
---|
| 1746 | /* VSS Preprocessor cells related options */
|
---|
| 1747 | /************************************************************************************/
|
---|
[382] | 1748 |
|
---|
[469] | 1749 | RegisterOption("VssTree.maxDepth", optInt, "kd_depth=", "12");
|
---|
| 1750 | RegisterOption("VssTree.minPvs", optInt, "kd_minpvs=", "1");
|
---|
| 1751 | RegisterOption("VssTree.minRays", optInt, "kd_minrays=", "10");
|
---|
| 1752 | RegisterOption("VssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
|
---|
| 1753 | RegisterOption("VssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
|
---|
[382] | 1754 |
|
---|
[469] | 1755 | RegisterOption("VssTree.epsilon", optFloat, "kd_eps=", "1e-6");
|
---|
| 1756 | RegisterOption("VssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
|
---|
| 1757 | RegisterOption("VssTree.randomize", optBool, "randomize", "false");
|
---|
| 1758 | RegisterOption("VssTree.splitType", optString, "split=", "queries");
|
---|
| 1759 | RegisterOption("VssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
|
---|
| 1760 | RegisterOption("VssTree.useRss", optBool, "rss=", "false");
|
---|
| 1761 | RegisterOption("VssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
|
---|
[382] | 1762 |
|
---|
[469] | 1763 | RegisterOption("VssTree.minSize", optFloat, "minsize=", "0.001");
|
---|
[382] | 1764 |
|
---|
[469] | 1765 | RegisterOption("VssTree.maxTotalMemory", optFloat, "mem=", "60.0");
|
---|
| 1766 | RegisterOption("VssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
|
---|
[438] | 1767 |
|
---|
[469] | 1768 | RegisterOption("VssTree.queryType", optString, "qtype=", "static");
|
---|
[438] | 1769 |
|
---|
[532] | 1770 |
|
---|
| 1771 |
|
---|
[469] | 1772 | RegisterOption("VssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
|
---|
[997] | 1773 | RegisterOption("VssTree.useRefDirSplits", optBool, "refdir=", "false");
|
---|
[469] | 1774 | RegisterOption("VssTree.refDirAngle", optFloat, "refangle=", "10");
|
---|
| 1775 | RegisterOption("VssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
|
---|
| 1776 | RegisterOption("VssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
|
---|
| 1777 | RegisterOption("VssTree.minCollapseDepth", optInt, "colldepth=", "4");
|
---|
[446] | 1778 |
|
---|
[469] | 1779 | RegisterOption("VssTree.interleaveDirSplits", optBool, "interleavedirsplits", "true");
|
---|
| 1780 | RegisterOption("VssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
|
---|
| 1781 |
|
---|
| 1782 |
|
---|
| 1783 | RegisterOption("RssPreprocessor.initialSamples",
|
---|
| 1784 | optInt,
|
---|
[492] | 1785 | "initial_samples=",
|
---|
[469] | 1786 | "100000");
|
---|
| 1787 |
|
---|
[463] | 1788 | RegisterOption("RssPreprocessor.vssSamples",
|
---|
[508] | 1789 | optInt,
|
---|
| 1790 | "rss_vss_samples=",
|
---|
| 1791 | "1000000");
|
---|
| 1792 |
|
---|
[469] | 1793 | RegisterOption("RssPreprocessor.vssSamplesPerPass",
|
---|
[508] | 1794 | optInt,
|
---|
| 1795 | "rss_vss_samples_per_pass=",
|
---|
| 1796 | "1000");
|
---|
| 1797 |
|
---|
[492] | 1798 | RegisterOption("RssPreprocessor.samplesPerPass",
|
---|
[508] | 1799 | optInt,
|
---|
| 1800 | "rss_samples_per_pass=",
|
---|
| 1801 | "100000");
|
---|
| 1802 |
|
---|
[469] | 1803 | RegisterOption("RssPreprocessor.useImportanceSampling",
|
---|
[508] | 1804 | optBool,
|
---|
[1112] | 1805 | "rss_use_importance",
|
---|
[508] | 1806 | "true");
|
---|
| 1807 |
|
---|
[492] | 1808 | RegisterOption("RssPreprocessor.objectBasedSampling",
|
---|
[508] | 1809 | optBool,
|
---|
[1112] | 1810 | "rss_object_based_sampling",
|
---|
[508] | 1811 | "true");
|
---|
| 1812 |
|
---|
[492] | 1813 | RegisterOption("RssPreprocessor.directionalSampling",
|
---|
[508] | 1814 | optBool,
|
---|
[1112] | 1815 | "rss_directional_sampling",
|
---|
[508] | 1816 | "false");
|
---|
| 1817 |
|
---|
[469] | 1818 | RegisterOption("RssTree.maxDepth", optInt, "kd_depth=", "12");
|
---|
| 1819 | RegisterOption("RssTree.minPvs", optInt, "kd_minpvs=", "1");
|
---|
| 1820 | RegisterOption("RssTree.minRays", optInt, "kd_minrays=", "10");
|
---|
| 1821 | RegisterOption("RssTree.maxCostRatio", optFloat, "maxcost=", "0.95");
|
---|
| 1822 | RegisterOption("RssTree.maxRayContribution", optFloat, "maxraycontrib=", "0.5");
|
---|
[508] | 1823 |
|
---|
[469] | 1824 | RegisterOption("RssTree.epsilon", optFloat, "kd_eps=", "1e-6");
|
---|
| 1825 | RegisterOption("RssTree.ct_div_ci", optFloat, "kd_ctdivci=", "1.0");
|
---|
[997] | 1826 | RegisterOption("RssTree.randomize", optBool, "randomize=", "false");
|
---|
[469] | 1827 | RegisterOption("RssTree.splitType", optString, "split=", "queries");
|
---|
| 1828 | RegisterOption("RssTree.splitUseOnlyDrivingAxis", optBool, "splitdriving=", "false");
|
---|
[508] | 1829 |
|
---|
[469] | 1830 | RegisterOption("RssTree.numberOfEndPointDomains", optInt, "endpoints=", "10000");
|
---|
[508] | 1831 |
|
---|
[469] | 1832 | RegisterOption("RssTree.minSize", optFloat, "minsize=", "0.001");
|
---|
[508] | 1833 |
|
---|
[469] | 1834 | RegisterOption("RssTree.maxTotalMemory", optFloat, "mem=", "60.0");
|
---|
| 1835 | RegisterOption("RssTree.maxStaticMemory", optFloat, "statmem=", "8.0");
|
---|
[508] | 1836 |
|
---|
[469] | 1837 | RegisterOption("RssTree.queryType", optString, "qtype=", "static");
|
---|
[508] | 1838 |
|
---|
[469] | 1839 | RegisterOption("RssTree.queryPosWeight", optFloat, "qposweight=", "0.0");
|
---|
| 1840 | RegisterOption("RssTree.useRefDirSplits", optBool, "refdir", "false");
|
---|
| 1841 | RegisterOption("RssTree.refDirAngle", optFloat, "refangle=", "10");
|
---|
| 1842 | RegisterOption("RssTree.refDirBoxMaxSize", optFloat, "refboxsize=", "0.1");
|
---|
| 1843 | RegisterOption("RssTree.accessTimeThreshold", optInt, "accesstime=", "1000");
|
---|
| 1844 | RegisterOption("RssTree.minCollapseDepth", optInt, "colldepth=", "4");
|
---|
[508] | 1845 |
|
---|
[997] | 1846 | RegisterOption("RssTree.interleaveDirSplits", optBool, "interleavedirsplits=", "true");
|
---|
[469] | 1847 | RegisterOption("RssTree.dirSplitDepth", optInt, "dirsplidepth=", "10");
|
---|
[997] | 1848 | RegisterOption("RssTree.importanceBasedCost", optBool, "importance_based_cost=", "true");
|
---|
[492] | 1849 | RegisterOption("RssTree.maxRays", optInt, "rss_max_rays=", "2000000");
|
---|
[508] | 1850 |
|
---|
[516] | 1851 | RegisterOption("RssTree.perObjectTree", optBool, "rss_per_object_tree", "false");
|
---|
| 1852 |
|
---|
[997] | 1853 | RegisterOption("RssPreprocessor.Export.pvs", optBool, "rss_export_pvs=", "false");
|
---|
| 1854 | RegisterOption("RssPreprocessor.Export.rssTree", optBool, "rss_export_rss_tree=", "false");
|
---|
| 1855 | RegisterOption("RssPreprocessor.Export.rays", optBool, "rss_export_rays=", "false");
|
---|
[469] | 1856 | RegisterOption("RssPreprocessor.Export.numRays", optInt, "rss_export_num_rays=", "5000");
|
---|
[997] | 1857 | RegisterOption("RssPreprocessor.useViewcells", optBool, "rss_use_viewcells=", "false");
|
---|
[563] | 1858 | RegisterOption("RssPreprocessor.updateSubdivision",
|
---|
| 1859 | optBool,
|
---|
[997] | 1860 | "rss_update_subdivision=",
|
---|
[563] | 1861 | "false");
|
---|
[463] | 1862 |
|
---|
[492] | 1863 |
|
---|
[508] | 1864 | /************************************************************************************/
|
---|
[1023] | 1865 | /* Rss preprocessor related options */
|
---|
[508] | 1866 | /************************************************************************************/
|
---|
| 1867 |
|
---|
| 1868 |
|
---|
[490] | 1869 | RegisterOption("RssPreprocessor.loadInitialSamples",
|
---|
[508] | 1870 | optBool,
|
---|
| 1871 | "vss_load_loadInitialSamples=",
|
---|
| 1872 | "false");
|
---|
[445] | 1873 |
|
---|
[490] | 1874 | RegisterOption("RssPreprocessor.storeInitialSamples",
|
---|
[508] | 1875 | optBool,
|
---|
| 1876 | "vss_store_storeInitialSamples=",
|
---|
| 1877 | "false");
|
---|
[490] | 1878 |
|
---|
[508] | 1879 |
|
---|
| 1880 | /************************************************************************************/
|
---|
[1023] | 1881 | /* View space partition BSP tree related options */
|
---|
[508] | 1882 | /************************************************************************************/
|
---|
| 1883 |
|
---|
[654] | 1884 | RegisterOption("VspBspTree.Termination.minGlobalCostRatio",
|
---|
| 1885 | optFloat,
|
---|
[997] | 1886 | "vsp_bsp_term_min_global_cost_ratio=",
|
---|
[654] | 1887 | "0.0001");
|
---|
[508] | 1888 |
|
---|
[655] | 1889 | RegisterOption("VspBspTree.useSplitCostQueue",
|
---|
| 1890 | optBool,
|
---|
[667] | 1891 | "vsp_bsp_use_split_cost_queue=",
|
---|
[655] | 1892 | "true");
|
---|
| 1893 |
|
---|
[654] | 1894 | RegisterOption("VspBspTree.Termination.globalCostMissTolerance",
|
---|
| 1895 | optInt,
|
---|
[997] | 1896 | "vsp_bsp_term_global_cost_miss_tolerance=",
|
---|
[654] | 1897 | "4");
|
---|
| 1898 |
|
---|
[469] | 1899 | RegisterOption("VspBspTree.Termination.minPolygons",
|
---|
[508] | 1900 | optInt,
|
---|
| 1901 | "vsp_bsp_term_min_polygons=",
|
---|
[1134] | 1902 | "-1");
|
---|
[445] | 1903 |
|
---|
[469] | 1904 | RegisterOption("VspBspTree.Termination.minPvs",
|
---|
[508] | 1905 | optInt,
|
---|
| 1906 | "vsp_bsp_term_min_pvs=",
|
---|
| 1907 | "20");
|
---|
[660] | 1908 |
|
---|
[547] | 1909 | RegisterOption("VspBspTree.Termination.minProbability",
|
---|
[508] | 1910 | optFloat,
|
---|
[547] | 1911 | "vsp_bsp_term_min_probability=",
|
---|
[508] | 1912 | "0.001");
|
---|
[445] | 1913 |
|
---|
[660] | 1914 | RegisterOption("VspBspTree.subdivisionStats",
|
---|
| 1915 | optString,
|
---|
| 1916 | "vsp_bsp_subdivision_stats=",
|
---|
| 1917 | "vspBspSubdivisionStats.log");
|
---|
| 1918 |
|
---|
[469] | 1919 | RegisterOption("VspBspTree.Termination.maxRayContribution",
|
---|
[508] | 1920 | optFloat,
|
---|
| 1921 | "vsp_bsp_term_ray_contribution=",
|
---|
[1134] | 1922 | "2");
|
---|
[463] | 1923 |
|
---|
[469] | 1924 | RegisterOption("VspBspTree.Termination.minAccRayLenght",
|
---|
[508] | 1925 | optFloat,
|
---|
| 1926 | "vsp_bsp_term_min_acc_ray_length=",
|
---|
| 1927 | "50");
|
---|
[445] | 1928 |
|
---|
[469] | 1929 | RegisterOption("VspBspTree.Termination.minRays",
|
---|
[508] | 1930 | optInt,
|
---|
| 1931 | "vsp_bsp_term_min_rays=",
|
---|
| 1932 | "-1");
|
---|
[445] | 1933 |
|
---|
[469] | 1934 | RegisterOption("VspBspTree.Termination.ct_div_ci",
|
---|
[508] | 1935 | optFloat,
|
---|
| 1936 | "vsp_bsp_term_ct_div_ci=",
|
---|
| 1937 | "0.0");
|
---|
[445] | 1938 |
|
---|
[469] | 1939 | RegisterOption("VspBspTree.Termination.maxDepth",
|
---|
[508] | 1940 | optInt,
|
---|
| 1941 | "vsp_bsp_term_max_depth=",
|
---|
[1134] | 1942 | "50");
|
---|
[445] | 1943 |
|
---|
[469] | 1944 | RegisterOption("VspBspTree.Termination.AxisAligned.maxCostRatio",
|
---|
[482] | 1945 | optFloat,
|
---|
[666] | 1946 | "vsp_bsp_term_axis_aligned_max_cost_ratio=",
|
---|
[482] | 1947 | "1.5");
|
---|
[445] | 1948 |
|
---|
[612] | 1949 | RegisterOption("VspBspTree.useCostHeuristics",
|
---|
| 1950 | optBool,
|
---|
[666] | 1951 | "vsp_bsp_use_cost_heuristics=",
|
---|
[612] | 1952 | "false");
|
---|
| 1953 |
|
---|
[478] | 1954 | RegisterOption("VspBspTree.Termination.maxViewCells",
|
---|
[482] | 1955 | optInt,
|
---|
[666] | 1956 | "vsp_bsp_term_max_view_cells=",
|
---|
[744] | 1957 | "10000");
|
---|
[478] | 1958 |
|
---|
[472] | 1959 | RegisterOption("VspBspTree.Termination.maxCostRatio",
|
---|
| 1960 | optFloat,
|
---|
[666] | 1961 | "vsp_bsp_term_max_cost_ratio=",
|
---|
[472] | 1962 | "1.5");
|
---|
[445] | 1963 |
|
---|
[472] | 1964 | RegisterOption("VspBspTree.Termination.missTolerance",
|
---|
[997] | 1965 | optInt,
|
---|
| 1966 | "vsp_bsp_term_miss_tolerance=",
|
---|
| 1967 | "4");
|
---|
| 1968 |
|
---|
[469] | 1969 | RegisterOption("VspBspTree.splitPlaneStrategy",
|
---|
[1134] | 1970 | optInt,
|
---|
[508] | 1971 | "vsp_bsp_split_method=",
|
---|
[1134] | 1972 | "1026");
|
---|
[448] | 1973 |
|
---|
[469] | 1974 | RegisterOption("VspBspTree.maxPolyCandidates",
|
---|
[508] | 1975 | optInt,
|
---|
| 1976 | "vsp_bsp_max_poly_candidates=",
|
---|
| 1977 | "20");
|
---|
[1134] | 1978 |
|
---|
[469] | 1979 | RegisterOption("VspBspTree.maxRayCandidates",
|
---|
[508] | 1980 | optInt,
|
---|
| 1981 | "vsp_bsp_max_plane_candidates=",
|
---|
| 1982 | "20");
|
---|
[469] | 1983 |
|
---|
| 1984 | RegisterOption("VspBspTree.maxTests",
|
---|
[508] | 1985 | optInt,
|
---|
| 1986 | "vsp_bsp_max_tests=",
|
---|
| 1987 | "5000");
|
---|
[469] | 1988 |
|
---|
| 1989 | RegisterOption("VspBspTree.Construction.samples",
|
---|
[508] | 1990 | optInt,
|
---|
[673] | 1991 | "vsp_bsp_construction_samples=",
|
---|
[508] | 1992 | "100000");
|
---|
[469] | 1993 |
|
---|
[801] | 1994 | RegisterOption("VspBspTree.Construction.minBand",
|
---|
| 1995 | optFloat,
|
---|
| 1996 | "vsp_bsp_construction_min_band=",
|
---|
[1074] | 1997 | "0.01");
|
---|
[801] | 1998 |
|
---|
| 1999 | RegisterOption("VspBspTree.Construction.maxBand",
|
---|
| 2000 | optFloat,
|
---|
[1147] | 2001 | "vsp_bsp_construction_max_band=",
|
---|
[1074] | 2002 | "0.99");
|
---|
[801] | 2003 |
|
---|
[822] | 2004 | RegisterOption("VspBspTree.Construction.useDrivingAxisForMaxCost",
|
---|
| 2005 | optBool,
|
---|
| 2006 | "vsp_bsp_construction_use_drivingaxis_for_maxcost=",
|
---|
| 2007 | "false");
|
---|
| 2008 |
|
---|
[469] | 2009 | RegisterOption("VspBspTree.Construction.epsilon",
|
---|
[508] | 2010 | optFloat,
|
---|
[1023] | 2011 | "vsp_bsp_construction_epsilon=",
|
---|
[508] | 2012 | "0.002");
|
---|
[469] | 2013 |
|
---|
| 2014 | RegisterOption("VspBspTree.Visualization.exportSplits",
|
---|
[508] | 2015 | optBool,
|
---|
| 2016 | "vsp_bsp_visualization.export_splits",
|
---|
| 2017 | "false");
|
---|
| 2018 |
|
---|
[485] | 2019 | RegisterOption("VspBspTree.splitUseOnlyDrivingAxis",
|
---|
[508] | 2020 | optBool,
|
---|
[667] | 2021 | "vsp_bsp_split_only_driving_axis=",
|
---|
[508] | 2022 | "false");
|
---|
| 2023 |
|
---|
[607] | 2024 | RegisterOption("VspBspTree.usePolygonSplitIfAvailable",
|
---|
| 2025 | optBool,
|
---|
| 2026 | "vsp_bsp_usePolygonSplitIfAvailable=",
|
---|
[611] | 2027 | "false");
|
---|
[607] | 2028 |
|
---|
[508] | 2029 | RegisterOption("VspBspTree.Termination.AxisAligned.minRays",
|
---|
| 2030 | optInt,
|
---|
| 2031 | "bsp_term_axis_aligned_min_rays=",
|
---|
[1134] | 2032 | "0");
|
---|
[492] | 2033 |
|
---|
[508] | 2034 | RegisterOption("VspBspTree.Termination.AxisAligned.maxRayContribution",
|
---|
| 2035 | optFloat,
|
---|
| 2036 | "bsp_term_axis_aligned_min_rays=",
|
---|
[1134] | 2037 | "2");
|
---|
[508] | 2038 |
|
---|
[676] | 2039 | RegisterOption("VspBspTree.Factor.leastRaySplits",
|
---|
| 2040 | optFloat,
|
---|
| 2041 | "vsp_bsp_factor_least_ray_splits=",
|
---|
| 2042 | "1.0");
|
---|
| 2043 |
|
---|
| 2044 | RegisterOption("VspBspTree.Factor.balancedRays",
|
---|
| 2045 | optFloat,
|
---|
| 2046 | "vsp_bsp_factor_balanced_rays=",
|
---|
| 2047 | "1.0");
|
---|
| 2048 |
|
---|
| 2049 | RegisterOption("VspBspTree.Factor.pvs",
|
---|
| 2050 | optFloat,
|
---|
| 2051 | "vsp_bsp_factor_pvs=",
|
---|
| 2052 | "1.0");
|
---|
[664] | 2053 |
|
---|
[580] | 2054 | RegisterOption("VspBspTree.Construction.renderCostWeight",
|
---|
[478] | 2055 | optFloat,
|
---|
[1002] | 2056 | "vsp_bsp_post_process_render_cost_weight=",
|
---|
[1134] | 2057 | "1.0");
|
---|
[478] | 2058 |
|
---|
[1020] | 2059 | RegisterOption("VspBspTree.Construction.renderCostDecreaseWeight",
|
---|
| 2060 | optFloat,
|
---|
[1121] | 2061 | "vsp_bsp_construction_render_cost_decrease_weight=",
|
---|
[1020] | 2062 | "0.99");
|
---|
| 2063 |
|
---|
[486] | 2064 | RegisterOption("VspBspTree.Construction.randomize",
|
---|
| 2065 | optBool,
|
---|
| 2066 | "vsp_bsp_construction_randomize=",
|
---|
| 2067 | "false");
|
---|
[508] | 2068 |
|
---|
[663] | 2069 | RegisterOption("VspBspTree.simulateOctree",
|
---|
| 2070 | optBool,
|
---|
| 2071 | "vsp_bsp_simulate_octree=",
|
---|
| 2072 | "false");
|
---|
| 2073 |
|
---|
[735] | 2074 | RegisterOption("VspBspTree.nodePriorityQueueType",
|
---|
| 2075 | optInt,
|
---|
| 2076 | "vsp_bsp_node_queue_type=",
|
---|
| 2077 | "0");
|
---|
[664] | 2078 |
|
---|
| 2079 | RegisterOption("VspBspTree.useRandomAxis",
|
---|
| 2080 | optBool,
|
---|
| 2081 | "-vsp_bsp_use_random_axis=",
|
---|
| 2082 | "false");
|
---|
| 2083 |
|
---|
[508] | 2084 | RegisterOption("VspBspTree.maxTotalMemory",
|
---|
| 2085 | optFloat,
|
---|
| 2086 | "vsp_bsp_max_total_mem=",
|
---|
| 2087 | "60.0");
|
---|
| 2088 |
|
---|
| 2089 | RegisterOption("VspBspTree.maxStaticMemory",
|
---|
| 2090 | optFloat,
|
---|
| 2091 | "vsp_bsp_max_static_mem=",
|
---|
| 2092 | "8.0");
|
---|
[564] | 2093 |
|
---|
[1023] | 2094 |
|
---|
| 2095 |
|
---|
[1027] | 2096 | /***************************************************************************/
|
---|
| 2097 | /* View space partition tree related options */
|
---|
| 2098 | /***************************************************************************/
|
---|
[1023] | 2099 |
|
---|
[580] | 2100 |
|
---|
[1027] | 2101 | RegisterOption("VspTree.Construction.samples",
|
---|
| 2102 | optInt,
|
---|
| 2103 | "vsp_construction_samples=",
|
---|
| 2104 | "10000");
|
---|
| 2105 |
|
---|
[1121] | 2106 |
|
---|
| 2107 | RegisterOption("VspTree.Construction.renderCostDecreaseWeight",
|
---|
| 2108 | optFloat,
|
---|
| 2109 | "vsp_construction_render_cost_decrease_weight=",
|
---|
| 2110 | "0.99");
|
---|
| 2111 |
|
---|
[1023] | 2112 | RegisterOption("VspTree.Termination.maxDepth",
|
---|
| 2113 | optInt,
|
---|
| 2114 | "vsp_term_max_depth=",
|
---|
| 2115 | "100");
|
---|
| 2116 |
|
---|
| 2117 | RegisterOption("VspTree.Termination.minRays",
|
---|
| 2118 | optInt,
|
---|
| 2119 | "vsp_term_min_rays=",
|
---|
| 2120 | "-1");
|
---|
| 2121 |
|
---|
| 2122 |
|
---|
| 2123 | RegisterOption("VspTree.Termination.minPvs",
|
---|
| 2124 | optInt,
|
---|
| 2125 | "vsp_term_min_pvs=",
|
---|
| 2126 | "20");
|
---|
| 2127 |
|
---|
| 2128 | RegisterOption("VspTree.Termination.minProbability",
|
---|
| 2129 | optFloat,
|
---|
| 2130 | "vsp_term_min_probability=",
|
---|
| 2131 | "0.001");
|
---|
| 2132 |
|
---|
| 2133 | RegisterOption("VspTree.Termination.maxRayContribution",
|
---|
| 2134 | optFloat,
|
---|
| 2135 | "vsp_term_ray_contribution=",
|
---|
| 2136 | "0.9");
|
---|
| 2137 |
|
---|
| 2138 | RegisterOption("VspTree.Termination.maxCostRatio",
|
---|
| 2139 | optFloat,
|
---|
| 2140 | "vsp_term_max_cost_ratio=",
|
---|
| 2141 | "1.5");
|
---|
| 2142 |
|
---|
| 2143 | RegisterOption("VspTree.Termination.maxViewCells",
|
---|
| 2144 | optInt,
|
---|
| 2145 | "vsp_term_max_view_cells=",
|
---|
| 2146 | "10000");
|
---|
[564] | 2147 |
|
---|
[1023] | 2148 |
|
---|
| 2149 | RegisterOption("VspTree.Termination.missTolerance",
|
---|
| 2150 | optInt,
|
---|
| 2151 | "vsp_term_miss_tolerance=",
|
---|
| 2152 | "4");
|
---|
| 2153 |
|
---|
| 2154 | RegisterOption("VspTree.Termination.minGlobalCostRatio",
|
---|
| 2155 | optFloat,
|
---|
| 2156 | "vsp_term_min_global_cost_ratio=",
|
---|
| 2157 | "0.0001");
|
---|
| 2158 |
|
---|
| 2159 | RegisterOption("VspTree.Termination.globalCostMissTolerance",
|
---|
| 2160 | optInt,
|
---|
| 2161 | "vsp_term_global_cost_miss_tolerance=",
|
---|
| 2162 | "4");
|
---|
| 2163 |
|
---|
| 2164 | RegisterOption("VspTree.Termination.ct_div_ci",
|
---|
| 2165 | optFloat,
|
---|
| 2166 | "vsp_term_ct_div_ci=",
|
---|
| 2167 | "0.0");
|
---|
| 2168 |
|
---|
| 2169 | RegisterOption("VspTree.Construction.epsilon",
|
---|
| 2170 | optFloat,
|
---|
| 2171 | "vsp_construction_epsilon=",
|
---|
| 2172 | "0.002");
|
---|
| 2173 |
|
---|
| 2174 | RegisterOption("VspTree.splitUseOnlyDrivingAxis",
|
---|
| 2175 | optBool,
|
---|
| 2176 | "vsp_split_only_driving_axis=",
|
---|
| 2177 | "false");
|
---|
| 2178 |
|
---|
| 2179 | RegisterOption("VspTree.maxStaticMemory",
|
---|
| 2180 | optFloat,
|
---|
| 2181 | "vsp_max_static_mem=",
|
---|
| 2182 | "8.0");
|
---|
| 2183 |
|
---|
| 2184 | RegisterOption("VspTree.useCostHeuristics",
|
---|
| 2185 | optBool,
|
---|
| 2186 | "vsp_use_cost_heuristics=",
|
---|
| 2187 | "false");
|
---|
| 2188 |
|
---|
| 2189 | RegisterOption("VspTree.simulateOctree",
|
---|
| 2190 | optBool,
|
---|
| 2191 | "vsp_simulate_octree=",
|
---|
| 2192 | "false");
|
---|
| 2193 |
|
---|
| 2194 | RegisterOption("VspTree.Construction.randomize",
|
---|
| 2195 | optBool,
|
---|
| 2196 | "vsp_construction_randomize=",
|
---|
| 2197 | "false");
|
---|
| 2198 |
|
---|
| 2199 | RegisterOption("VspTree.subdivisionStats",
|
---|
| 2200 | optString,
|
---|
| 2201 | "vsp_subdivision_stats=",
|
---|
| 2202 | "vspSubdivisionStats.log");
|
---|
| 2203 |
|
---|
| 2204 | RegisterOption("VspTree.Construction.minBand",
|
---|
| 2205 | optFloat,
|
---|
| 2206 | "vsp_construction_min_band=",
|
---|
[1074] | 2207 | "0.01");
|
---|
[1023] | 2208 |
|
---|
| 2209 | RegisterOption("VspTree.Construction.maxBand",
|
---|
| 2210 | optFloat,
|
---|
[1074] | 2211 | "vsp_construction_max_band=",
|
---|
| 2212 | "0.99");
|
---|
[1023] | 2213 |
|
---|
[1141] | 2214 | RegisterOption("VspTree.useKdPvsForHeuristics",
|
---|
[1139] | 2215 | optBool,
|
---|
[1141] | 2216 | "vsp_use_kd_pvs_for_heuristics=",
|
---|
[1139] | 2217 | "true");
|
---|
[1074] | 2218 |
|
---|
[1141] | 2219 | RegisterOption("VspTree.storeKdPvs",
|
---|
| 2220 | optBool,
|
---|
[1142] | 2221 | "vsp_store_kd_pvs=",
|
---|
[1141] | 2222 | "true");
|
---|
[1106] | 2223 |
|
---|
[1149] | 2224 | RegisterOption("VspTree.maxTests",
|
---|
| 2225 | optInt,
|
---|
| 2226 | "vsp_max_tests=",
|
---|
[1161] | 2227 | "5000");
|
---|
[1143] | 2228 |
|
---|
| 2229 |
|
---|
[1106] | 2230 | /***************************************************************************/
|
---|
| 2231 | /* Object space partition tree related options */
|
---|
| 2232 | /***************************************************************************/
|
---|
[1074] | 2233 |
|
---|
[1143] | 2234 |
|
---|
[1106] | 2235 | RegisterOption("OspTree.Construction.randomize",
|
---|
| 2236 | optBool,
|
---|
| 2237 | "osp_construction_randomize=",
|
---|
| 2238 | "false");
|
---|
| 2239 |
|
---|
| 2240 | RegisterOption("OspTree.Termination.maxDepth",
|
---|
| 2241 | optInt,
|
---|
| 2242 | "osp_term_max_depth=",
|
---|
| 2243 | "30");
|
---|
| 2244 |
|
---|
| 2245 | RegisterOption("OspTree.Termination.maxLeaves",
|
---|
| 2246 | optInt,
|
---|
| 2247 | "osp_term_max_leaves=",
|
---|
| 2248 | "1000");
|
---|
| 2249 |
|
---|
| 2250 | RegisterOption("OspTree.Termination.minObjects",
|
---|
| 2251 | optInt,
|
---|
| 2252 | "osp_term_min_objects=",
|
---|
| 2253 | "1");
|
---|
| 2254 |
|
---|
| 2255 | RegisterOption("OspTree.Termination.minProbability",
|
---|
| 2256 | optFloat,
|
---|
| 2257 | "osp_term_min_objects=",
|
---|
| 2258 | "0.0001");
|
---|
| 2259 |
|
---|
| 2260 | RegisterOption("OspTree.Termination.missTolerance",
|
---|
| 2261 | optInt,
|
---|
| 2262 | "osp_term_miss_tolerance=",
|
---|
| 2263 | "4");
|
---|
| 2264 |
|
---|
| 2265 | RegisterOption("OspTree.Termination.maxCostRatio",
|
---|
| 2266 | optFloat,
|
---|
| 2267 | "osp_term_max_cost_ratio=",
|
---|
| 2268 | "0.99");
|
---|
| 2269 |
|
---|
| 2270 | RegisterOption("OspTree.Termination.minGlobalCostRatio",
|
---|
| 2271 | optFloat,
|
---|
| 2272 | "osp_term_min_global_cost_ratio=",
|
---|
| 2273 | "0.00001");
|
---|
| 2274 |
|
---|
| 2275 | RegisterOption("OspTree.Termination.globalCostMissTolerance",
|
---|
| 2276 | optInt,
|
---|
| 2277 | "osp_term_global_cost_miss_tolerance=",
|
---|
| 2278 | "4");
|
---|
| 2279 |
|
---|
| 2280 | RegisterOption("OspTree.Termination.ct_div_ci",
|
---|
| 2281 | optFloat,
|
---|
| 2282 | "osp_term_ct_div_ci=",
|
---|
| 2283 | "0");
|
---|
| 2284 |
|
---|
| 2285 | RegisterOption("OspTree.Construction.epsilon",
|
---|
| 2286 | optFloat,
|
---|
| 2287 | "osp_construction_epsilon=",
|
---|
| 2288 | "0.00001");
|
---|
| 2289 |
|
---|
| 2290 | // if only the driving axis is used for axis aligned split
|
---|
| 2291 | RegisterOption("OspTree.splitUseOnlyDrivingAxis",
|
---|
| 2292 | optBool,
|
---|
| 2293 | "osp_split_only_driving_axis=",
|
---|
| 2294 | "false");
|
---|
| 2295 |
|
---|
| 2296 | RegisterOption("OspTree.maxStaticMemory",
|
---|
| 2297 | optFloat,
|
---|
| 2298 | "osp_max_static_mem=",
|
---|
| 2299 | "8.0");
|
---|
| 2300 |
|
---|
| 2301 | RegisterOption("OspTree.useCostHeuristics",
|
---|
| 2302 | optBool,
|
---|
| 2303 | "osp_use_cost_heuristics=",
|
---|
| 2304 | "false");
|
---|
| 2305 |
|
---|
| 2306 | RegisterOption("OspTree.subdivisionStats",
|
---|
| 2307 | optString,
|
---|
| 2308 | "osp_subdivision_stats=",
|
---|
| 2309 | "ospSubdivisionStats.log");
|
---|
| 2310 |
|
---|
| 2311 | RegisterOption("OspTree.Construction.splitBorder",
|
---|
| 2312 | optFloat,
|
---|
| 2313 | "osp_construction_split_border=",
|
---|
| 2314 | "0.01");
|
---|
| 2315 |
|
---|
[1121] | 2316 | RegisterOption("OspTree.Construction.renderCostDecreaseWeight",
|
---|
| 2317 | optFloat,
|
---|
| 2318 | "osp_construction_render_cost_decrease_weight=",
|
---|
| 2319 | "0.99");
|
---|
[1106] | 2320 |
|
---|
| 2321 |
|
---|
[1174] | 2322 | RegisterOption("Hierarchy.subdivisionStats",
|
---|
| 2323 | optString,
|
---|
| 2324 | "hierarchy_subdivision_stats=",
|
---|
| 2325 | "hierarchySubdivisionStats.log");
|
---|
| 2326 |
|
---|
[469] | 2327 | //////////////////////////////////////////////////////////////////////////////////
|
---|
[372] | 2328 | }
|
---|
| 2329 |
|
---|
| 2330 | void
|
---|
| 2331 | Environment::SetStaticOptions()
|
---|
| 2332 | {
|
---|
| 2333 |
|
---|
| 2334 | // get Global option values
|
---|
| 2335 | GetRealValue("Limits.threshold", Limits::Threshold);
|
---|
| 2336 | GetRealValue("Limits.small", Limits::Small);
|
---|
| 2337 | GetRealValue("Limits.infinity", Limits::Infinity);
|
---|
| 2338 |
|
---|
| 2339 |
|
---|
| 2340 | }
|
---|
| 2341 |
|
---|
[938] | 2342 | bool
|
---|
[492] | 2343 | Environment::Parse(const int argc, char **argv, bool useExePath)
|
---|
[372] | 2344 | {
|
---|
[938] | 2345 | bool result = true;
|
---|
[372] | 2346 | // Read the names of the scene, environment and output files
|
---|
| 2347 | ReadCmdlineParams(argc, argv, "");
|
---|
| 2348 |
|
---|
| 2349 | char *envFilename = new char[128];
|
---|
| 2350 |
|
---|
| 2351 | char filename[64];
|
---|
| 2352 |
|
---|
| 2353 | // Get the environment file name
|
---|
| 2354 | if (!GetParam(' ', 0, filename)) {
|
---|
| 2355 | // user didn't specified environment file explicitly, so
|
---|
[1004] | 2356 | strcpy(filename, "default.Environment::GetSingleton()");
|
---|
[372] | 2357 | }
|
---|
| 2358 |
|
---|
| 2359 | if (useExePath) {
|
---|
| 2360 | char *path = GetPath(argv[0]);
|
---|
| 2361 | if (*path != 0)
|
---|
| 2362 | sprintf(envFilename, "%s/%s", path, filename);
|
---|
| 2363 | else
|
---|
| 2364 | strcpy(envFilename, filename);
|
---|
| 2365 |
|
---|
| 2366 | delete path;
|
---|
| 2367 | }
|
---|
| 2368 | else
|
---|
| 2369 | strcpy(envFilename, filename);
|
---|
| 2370 |
|
---|
| 2371 |
|
---|
| 2372 | // Now it's time to read in environment file.
|
---|
| 2373 | if (!ReadEnvFile(envFilename)) {
|
---|
| 2374 | // error - bad input file name specified ?
|
---|
| 2375 | cerr<<"Error parsing environment file "<<envFilename<<endl;
|
---|
[938] | 2376 | result = false;
|
---|
[372] | 2377 | }
|
---|
| 2378 | delete envFilename;
|
---|
| 2379 |
|
---|
| 2380 | // Parse the command line; options given on the command line subsume
|
---|
| 2381 | // stuff specified in the input environment file.
|
---|
| 2382 | ParseCmdline(argc, argv, 0);
|
---|
| 2383 |
|
---|
| 2384 | SetStaticOptions();
|
---|
| 2385 |
|
---|
| 2386 | // Check for request for help
|
---|
| 2387 | if (CheckForSwitch(argc, argv, '?')) {
|
---|
| 2388 | PrintUsage(cout);
|
---|
| 2389 | exit(0);
|
---|
| 2390 | }
|
---|
[938] | 2391 |
|
---|
| 2392 | return true;
|
---|
[372] | 2393 | }
|
---|
[860] | 2394 |
|
---|
[878] | 2395 | }
|
---|