configfile.cpp
上传用户:center1979
上传日期:2022-07-26
资源大小:50633k
文件大小:14k
源码类别:

OpenGL

开发平台:

Visual C++

  1. // configfile.cpp
  2. //
  3. // Copyright (C) 2001-2009, the Celestia Development Team
  4. //
  5. // This program is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU General Public License
  7. // as published by the Free Software Foundation; either version 2
  8. // of the License, or (at your option) any later version.
  9. #include <iostream>
  10. #include <fstream>
  11. #include <cassert>
  12. #include <celutil/debug.h>
  13. #include <celutil/directory.h>
  14. #include <celutil/util.h>
  15. #include <celengine/celestia.h>
  16. #include <celengine/texmanager.h>
  17. #include "configfile.h"
  18. using namespace std;
  19. static unsigned int getUint(Hash* params,
  20.                             const string& paramName,
  21.                             unsigned int defaultValue)
  22. {
  23.     double value = 0.0;
  24.     if (params->getNumber(paramName, value))
  25.         return (unsigned int) value;
  26.     else
  27.         return defaultValue;
  28. }
  29. CelestiaConfig* ReadCelestiaConfig(string filename, CelestiaConfig *config)
  30. {
  31.     ifstream configFile(filename.c_str());
  32.     if (!configFile.good())
  33.     {
  34.         DPRINTF(0, "Error opening config file '%s'.n", filename.c_str());
  35.         return config;
  36.     }
  37.     Tokenizer tokenizer(&configFile);
  38.     Parser parser(&tokenizer);
  39.     if (tokenizer.nextToken() != Tokenizer::TokenName)
  40.     {
  41.         DPRINTF(0, "%s:%d 'Configuration' expected.n", filename.c_str(),
  42.                 tokenizer.getLineNumber());
  43.         return config;
  44.     }
  45.     if (tokenizer.getStringValue() != "Configuration")
  46.     {
  47.         DPRINTF(0, "%s:%d 'Configuration' expected.n", filename.c_str(),
  48.                 tokenizer.getLineNumber());
  49.         return config;
  50.     }
  51.     Value* configParamsValue = parser.readValue();
  52.     if (configParamsValue == NULL || configParamsValue->getType() != Value::HashType)
  53.     {
  54.         DPRINTF(0, "%s: Bad configuration file.n", filename.c_str());
  55.         return config;
  56.     }
  57.     Hash* configParams = configParamsValue->getHash();
  58.     if (config == NULL)
  59.         config = new CelestiaConfig();
  60. #ifdef CELX
  61.     config->configParams = configParams;  
  62.     configParams->getString("LuaHook", config->luaHook);    
  63.     config->luaHook = WordExp(config->luaHook);             
  64. #endif
  65.     config->faintestVisible = 6.0f;
  66.     configParams->getNumber("FaintestVisibleMagnitude", config->faintestVisible);
  67.     configParams->getString("FavoritesFile", config->favoritesFile);
  68.     config->favoritesFile = WordExp(config->favoritesFile);
  69.     configParams->getString("DestinationFile", config->destinationsFile);
  70.     config->destinationsFile = WordExp(config->destinationsFile);
  71.     configParams->getString("InitScript", config->initScriptFile);
  72.     config->initScriptFile = WordExp(config->initScriptFile);
  73.     configParams->getString("DemoScript", config->demoScriptFile);
  74.     config->demoScriptFile = WordExp(config->demoScriptFile);
  75.     configParams->getString("AsterismsFile", config->asterismsFile);
  76.     config->asterismsFile = WordExp(config->asterismsFile);
  77.     configParams->getString("BoundariesFile", config->boundariesFile);
  78.     config->boundariesFile = WordExp(config->boundariesFile);
  79.     configParams->getString("StarDatabase", config->starDatabaseFile);
  80.     config->starDatabaseFile = WordExp(config->starDatabaseFile);
  81.     configParams->getString("StarNameDatabase", config->starNamesFile);
  82.     config->starNamesFile = WordExp(config->starNamesFile);
  83.     configParams->getString("HDCrossIndex", config->HDCrossIndexFile);
  84.     config->HDCrossIndexFile = WordExp(config->HDCrossIndexFile);
  85.     configParams->getString("SAOCrossIndex", config->SAOCrossIndexFile);
  86.     config->SAOCrossIndexFile = WordExp(config->SAOCrossIndexFile);
  87.     configParams->getString("GlieseCrossIndex", config->GlieseCrossIndexFile);
  88.     config->GlieseCrossIndexFile = WordExp(config->GlieseCrossIndexFile);
  89.     configParams->getString("Font", config->mainFont);
  90.     configParams->getString("LabelFont", config->labelFont);
  91.     configParams->getString("TitleFont", config->titleFont);
  92.     configParams->getString("LogoTexture", config->logoTextureFile);
  93.     configParams->getString("Cursor", config->cursor);
  94.     double aaSamples = 1;
  95.     configParams->getNumber("AntialiasingSamples", aaSamples);
  96.     config->aaSamples = (unsigned int) aaSamples;
  97.     config->hdr = false;
  98.     configParams->getBoolean("HighDynamicRange", config->hdr);
  99.     config->rotateAcceleration = 120.0f;
  100.     configParams->getNumber("RotateAcceleration", config->rotateAcceleration);
  101.     config->mouseRotationSensitivity = 1.0f;
  102.     configParams->getNumber("MouseRotationSensitivity", config->mouseRotationSensitivity);
  103.     config->reverseMouseWheel = false;
  104.     configParams->getBoolean("ReverseMouseWheel", config->reverseMouseWheel);
  105.     configParams->getString("ScriptScreenshotDirectory", config->scriptScreenshotDirectory);
  106.     config->scriptScreenshotDirectory = WordExp(config->scriptScreenshotDirectory);
  107.     config->scriptSystemAccessPolicy = "ask";
  108.     configParams->getString("ScriptSystemAccessPolicy", config->scriptSystemAccessPolicy);
  109.     config->ringSystemSections = getUint(configParams, "RingSystemSections", 100);
  110.     config->orbitPathSamplePoints = getUint(configParams, "OrbitPathSamplePoints", 100);
  111.     config->shadowTextureSize = getUint(configParams, "ShadowTextureSize", 256);
  112.     config->eclipseTextureSize = getUint(configParams, "EclipseTextureSize", 128);
  113.     config->consoleLogRows = getUint(configParams, "LogSize", 200);
  114.     Value* solarSystemsVal = configParams->getValue("SolarSystemCatalogs");
  115.     if (solarSystemsVal != NULL)
  116.     {
  117.         if (solarSystemsVal->getType() != Value::ArrayType)
  118.         {
  119.             DPRINTF(0, "%s: SolarSystemCatalogs must be an array.n", filename.c_str());
  120.         }
  121.         else
  122.         {
  123.             Array* solarSystems = solarSystemsVal->getArray();
  124.             // assert(solarSystems != NULL);
  125.             for (Array::iterator iter = solarSystems->begin(); iter != solarSystems->end(); iter++)
  126.             {
  127.                 Value* catalogNameVal = *iter;
  128.                 // assert(catalogNameVal != NULL);
  129.                 if (catalogNameVal->getType() == Value::StringType)
  130.                 {
  131.                     config->solarSystemFiles.insert(config->solarSystemFiles.end(),
  132.                                                     WordExp(catalogNameVal->getString()));
  133.                 }
  134.                 else
  135.                 {
  136.                     DPRINTF(0, "%s: Solar system catalog name must be a string.n",
  137.                             filename.c_str());
  138.                 }
  139.             }
  140.         }
  141.     }
  142.     Value* starCatalogsVal = configParams->getValue("StarCatalogs");
  143.     if (starCatalogsVal != NULL)
  144.     {
  145.         if (starCatalogsVal->getType() != Value::ArrayType)
  146.         {
  147.             DPRINTF(0, "%s: StarCatalogs must be an array.n",
  148.                     filename.c_str());
  149.         }
  150.         else
  151.         {
  152.             Array* starCatalogs = starCatalogsVal->getArray();
  153.             assert(starCatalogs != NULL);
  154.             for (Array::iterator iter = starCatalogs->begin();
  155.                  iter != starCatalogs->end(); iter++)
  156.             {
  157.                 Value* catalogNameVal = *iter;
  158.                 assert(catalogNameVal != NULL);
  159.                 if (catalogNameVal->getType() == Value::StringType)
  160.                 {
  161.                     config->starCatalogFiles.push_back(WordExp(catalogNameVal->getString()));
  162.                 }
  163.                 else
  164.                 {
  165.                     DPRINTF(0, "%s: Star catalog name must be a string.n",
  166.                             filename.c_str());
  167.                 }
  168.             }
  169.         }
  170.     }
  171.     
  172. Value* dsoCatalogsVal = configParams->getValue("DeepSkyCatalogs");
  173.     if (dsoCatalogsVal != NULL)
  174.     {
  175.         if (dsoCatalogsVal->getType() != Value::ArrayType)
  176.         {
  177.             DPRINTF(0, "%s: DeepSkyCatalogs must be an array.n",
  178.                     filename.c_str());
  179.         }
  180.         else
  181.         {
  182.             Array* dsoCatalogs = dsoCatalogsVal->getArray();
  183.             assert(dsoCatalogs != NULL);
  184.             for (Array::iterator iter = dsoCatalogs->begin();
  185.                  iter != dsoCatalogs->end(); iter++)
  186.             {
  187.                 Value* catalogNameVal = *iter;
  188.                 assert(catalogNameVal != NULL);
  189.                 if (catalogNameVal->getType() == Value::StringType)
  190.                 {
  191.                     config->dsoCatalogFiles.push_back(WordExp(catalogNameVal->getString()));
  192.                 }
  193.                 else
  194.                 {
  195.                     DPRINTF(0, "%s: DeepSky catalog name must be a string.n",
  196.                             filename.c_str());
  197.                 }
  198.             }
  199.         }
  200.     }
  201.     Value* extrasDirsVal = configParams->getValue("ExtrasDirectories");
  202.     if (extrasDirsVal != NULL)
  203.     {
  204.         if (extrasDirsVal->getType() == Value::ArrayType)
  205.         {
  206.             Array* extrasDirs = extrasDirsVal->getArray();
  207.             assert(extrasDirs != NULL);
  208.             for (Array::iterator iter = extrasDirs->begin();
  209.                  iter != extrasDirs->end(); iter++)
  210.             {
  211.                 Value* dirNameVal = *iter;
  212.                 if (dirNameVal->getType() == Value::StringType)
  213.                 {
  214.                     config->extrasDirs.insert(config->extrasDirs.end(),
  215.                                               WordExp(dirNameVal->getString()));
  216.                 }
  217.                 else
  218.                 {
  219.                     DPRINTF(0, "%s: Extras directory name must be a string.n",
  220.                             filename.c_str());
  221.                 }
  222.             }
  223.         }
  224.         else if (extrasDirsVal->getType() == Value::StringType)
  225.         {
  226.             config->extrasDirs.insert(config->extrasDirs.end(),
  227.                                       WordExp(extrasDirsVal->getString()));
  228.         }
  229.         else
  230.         {
  231.             DPRINTF(0, "%s: ExtrasDirectories must be an array or string.n", filename.c_str());
  232.         }
  233.     }
  234.     Value* ignoreExtVal = configParams->getValue("IgnoreGLExtensions");
  235.     if (ignoreExtVal != NULL)
  236.     {
  237.         if (ignoreExtVal->getType() != Value::ArrayType)
  238.         {
  239.             DPRINTF(0, "%s: IgnoreGLExtensions must be an array.n",
  240.                     filename.c_str());
  241.         }
  242.         else
  243.         {
  244.             Array* ignoreExt = ignoreExtVal->getArray();
  245.             for (Array::iterator iter = ignoreExt->begin();
  246.                  iter != ignoreExt->end(); iter++)
  247.             {
  248.                 Value* extVal = *iter;
  249.                 if (extVal->getType() == Value::StringType)
  250.                 {
  251.                     config->ignoreGLExtensions.push_back(extVal->getString());
  252.                 }
  253.                 else
  254.                 {
  255.                     DPRINTF(0, "%s: extension name must be a string.n", filename.c_str());
  256.                 }
  257.             }
  258.         }
  259.     }
  260.     
  261.     Value* starTexValue = configParams->getValue("StarTextures");
  262.     if (starTexValue != NULL)
  263.     {
  264.         if (starTexValue->getType() != Value::HashType)
  265.         {
  266.             DPRINTF(0, "%s: StarTextures must be a property list.n", filename.c_str());
  267.         }
  268.         else
  269.         {
  270.             Hash* starTexTable = starTexValue->getHash();
  271.             string starTexNames[StellarClass::Spectral_Count];
  272.             starTexTable->getString("O", starTexNames[StellarClass::Spectral_O]);
  273.             starTexTable->getString("B", starTexNames[StellarClass::Spectral_B]);
  274.             starTexTable->getString("A", starTexNames[StellarClass::Spectral_A]);
  275.             starTexTable->getString("F", starTexNames[StellarClass::Spectral_F]);
  276.             starTexTable->getString("G", starTexNames[StellarClass::Spectral_G]);
  277.             starTexTable->getString("K", starTexNames[StellarClass::Spectral_K]);
  278.             starTexTable->getString("M", starTexNames[StellarClass::Spectral_M]);
  279.             starTexTable->getString("R", starTexNames[StellarClass::Spectral_R]);
  280.             starTexTable->getString("S", starTexNames[StellarClass::Spectral_S]);
  281.             starTexTable->getString("N", starTexNames[StellarClass::Spectral_N]);
  282.             starTexTable->getString("WC", starTexNames[StellarClass::Spectral_WC]);
  283.             starTexTable->getString("WN", starTexNames[StellarClass::Spectral_WN]);
  284.             starTexTable->getString("Unknown", starTexNames[StellarClass::Spectral_Unknown]);
  285.             starTexTable->getString("L", starTexNames[StellarClass::Spectral_L]);
  286.             starTexTable->getString("T", starTexNames[StellarClass::Spectral_T]);
  287.             starTexTable->getString("C", starTexNames[StellarClass::Spectral_C]);
  288.             
  289.             // One texture for all white dwarf types; not sure if this needs to be
  290.             // changed. White dwarfs vary widely in temperature, so texture choice
  291.             // should probably be based on that instead of spectral type.
  292.             starTexTable->getString("WD", starTexNames[StellarClass::Spectral_D]);
  293.             
  294.             string neutronStarTexName;
  295.             if (starTexTable->getString("NeutronStar", neutronStarTexName))
  296.             {
  297.                 config->starTextures.neutronStarTex.setTexture(neutronStarTexName, "textures");
  298.             }
  299.             
  300.             string defaultTexName;
  301.             if (starTexTable->getString("Default", defaultTexName))
  302.             {
  303.                 config->starTextures.defaultTex.setTexture(defaultTexName, "textures");
  304.             }
  305.             
  306.             for (unsigned int i = 0; i < (unsigned int) StellarClass::Spectral_Count; i++)
  307.             {
  308.                 if (starTexNames[i] != "")
  309.                 {
  310.                     config->starTextures.starTex[i].setTexture(starTexNames[i], "textures");
  311.                 }
  312.             }
  313.         }
  314.     }
  315.     // TODO: not cleaning up properly here--we're just saving the hash, not the instance of Value
  316.     config->params = configParams;
  317. #ifndef CELX
  318.      delete configParamsValue;
  319. #endif
  320.     return config;
  321. }
  322. float
  323. CelestiaConfig::getFloatValue(const string& name)
  324. {
  325.     assert(params != NULL);
  326.     
  327.     double x = 0.0;
  328.     params->getNumber(name, x);
  329.     
  330.     return (float) x;
  331. }
  332. const string
  333. CelestiaConfig::getStringValue(const string& name)
  334. {
  335.     assert(params != NULL);
  336.     
  337.     Value* v = params->getValue(name);
  338.     if (v == NULL || v->getType() != Value::StringType)
  339.         return string("");
  340.     return v->getString();
  341. }