开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
stellarclass.cpp
资源名称：celestia-1.6.0.tar.gz　[点击查看]
上传用户：center1979
上传日期：2022-07-26
资源大小：50633k
文件大小：15k
源码类别：

OpenGL

开发平台：

Visual C++

stellarclass.cpp：源码内容
  1. // stellarclass.cpp
  2. //
  3. // Copyright (C) 2001, Chris Laurel <claurel@shatters.net>
  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.
  10. #include <cstring>
  11. #include <cstdio>
  12. #include <cassert>
  13. #include "celestia.h"
  14. #include "stellarclass.h"
  16. using namespace std;
  19. Color StellarClass::getApparentColor() const
  20. {
  21.     return getApparentColor(getSpectralClass());
  22. }
  25. Color StellarClass::getApparentColor(StellarClass::SpectralClass sc) const
  26. {
  27.     switch (sc)
  28.     {
  29.     case Spectral_O:
  30.         return Color(0.7f, 0.8f, 1.0f);
  31.     case Spectral_B:
  32.         return Color(0.8f, 0.9f, 1.0f);
  33.     case Spectral_A:
  34.         return Color(1.0f, 1.0f, 1.0f);
  35.     case Spectral_F:
  36.         return Color(1.0f, 1.0f, 0.88f);
  37.     case Spectral_G:
  38.         return Color(1.0f, 1.0f, 0.75f);
  39.     case StellarClass::Spectral_K:
  40.         return Color(1.0f, 0.9f, 0.7f);
  41.     case StellarClass::Spectral_M:
  42.         return Color(1.0f, 0.7f, 0.7f);
  43.     case StellarClass::Spectral_R:
  44.     case StellarClass::Spectral_S:
  45.     case StellarClass::Spectral_N:
  46.     case StellarClass::Spectral_C:
  47.         return Color(1.0f, 0.4f, 0.4f);
  48.     case StellarClass::Spectral_L:
  49.     case StellarClass::Spectral_T:
  50.         return Color(0.75f, 0.2f, 0.2f);
  51.     default:
  52.         // TODO: Figure out reasonable colors for Wolf-Rayet stars,
  53.         // white dwarfs, and other oddities
  54.         return Color(1.0f, 1.0f, 1.0f);
  55.     }
  56. }
  59. // The << method of converting the stellar class to a string is
  60. // preferred, but it's not always practical, especially when you've
  61. // got a completely broken implemtation of stringstreams to
  62. // deal with (*cough* gcc *cough*).
  63. //
  64. // Return the buffer if successful or NULL if not (the buffer wasn't
  65. // large enough.)
  66. char* StellarClass::str(char* buf, unsigned int buflen) const
  67. {
  68.     StellarClass::StarType st = getStarType();
  69.     char s0[3];
  70.     char s1[2];
  71.     const char* s2 = "";
  72.     s0[0] = '';
  73.     s1[0] = '';
  75.     if (st == StellarClass::WhiteDwarf)
  76.     {
  77.         strcpy(s0, "WD");
  78.     }
  79.     else if (st == StellarClass::NeutronStar)
  80.     {
  81.         strcpy(s0, "Q");
  82.     }
  83.     else if (st == StellarClass::BlackHole)
  84.     {
  85.         strcpy(s0, "X");
  86.     }
  87.     else if (st == StellarClass::NormalStar)
  88.     {
  89. s0[0] = "OBAFGKMRSNWW?LTC"[(unsigned int) getSpectralClass()];
  90.         s0[1] = '';
  91. s1[0] = "0123456789"[getSubclass()];
  92.         s1[1] = '';
  93. switch (getLuminosityClass())
  94.         {
  95. case StellarClass::Lum_Ia0:
  96.     s2 = " I-a0";
  97.     break;
  98. case StellarClass::Lum_Ia:
  99.     s2 = " I-a";
  100.     break;
  101. case StellarClass::Lum_Ib:
  102.     s2 = " I-b";
  103.     break;
  104. case StellarClass::Lum_II:
  105.     s2 = " II";
  106.     break;
  107. case StellarClass::Lum_III:
  108.     s2 = " III";
  109.     break;
  110. case StellarClass::Lum_IV:
  111.     s2 = " IV";
  112.     break;
  113. case StellarClass::Lum_V:
  114.     s2 = " V";
  115.     break;
  116. case StellarClass::Lum_VI:
  117.     s2 = " VI";
  118.     break;
  120.         default: break;  // Do nothing, but prevent GCC4 warnings (Beware: potentially dangerous)
  121. }
  122.     }
  123.     else
  124.     {
  125.         strcpy(s0, "?");
  126.     }
  128.     if (strlen(s0) + strlen(s1) + strlen(s2) >= buflen)
  129.     {
  130.         return NULL;
  131.     }
  132.     else
  133.     {
  134.         sprintf(buf, "%s%s%s", s0, s1, s2);
  135.         return buf;
  136.     }
  137. }
  140. string StellarClass::str() const
  141. {
  142.     char buf[20];
  143.     str(buf, sizeof buf);
  144.     return string(buf);
  145. }
  148. uint16
  149. StellarClass::pack() const
  150. {
  151.     return (((uint16) starType << 12) |
  152.     (((uint16) specClass & 0xf) << 8) |
  153.     ((uint16) subclass << 4) |
  154.     ((uint16) lumClass));
  155. }
  158. bool
  159. StellarClass::unpack(uint16 st)
  160. {
  161.     starType = static_cast<StellarClass::StarType>(st >> 12);
  163.     switch (starType)
  164.     {
  165.     case NormalStar:
  166.         specClass = static_cast<SpectralClass>(st >> 8 & 0xf);
  167.         subclass = st >> 4 & 0xf;
  168.         lumClass = static_cast<LuminosityClass>(st & 0xf);
  169.         break;
  170.     case WhiteDwarf:
  171.         if ((st >> 8 & 0xf) >= WDClassCount)
  172.             return false;
  173.         specClass = static_cast<SpectralClass>((st >> 8 & 0xf) + Spectral_DA);
  174.         subclass = st >> 4 & 0xf;
  175.         lumClass = Lum_Unknown;
  176.         break;
  177.     case NeutronStar:
  178.     case BlackHole:
  179.         specClass = Spectral_Unknown;
  180.         subclass = Subclass_Unknown;
  181.         lumClass = Lum_Unknown;
  182.         break;
  183.     default:
  184.         return false;
  185.     }
  187.     return true;
  188. }
  191. ostream& operator<<(ostream& os, const StellarClass& sc)
  192. {
  193.     char buf[20];
  194.     char *scString = sc.str(buf, sizeof buf);
  195.     assert(scString != NULL);
  197.     os << scString;
  199.     return os;
  200. }
  203. bool operator<(const StellarClass& sc0, const StellarClass& sc1)
  204. {
  205.     return sc0.pack() < sc1.pack();
  206. }
  209. // The following code implements a state machine for parsing spectral
  210. // types.  It is a very forgiving parser, returning unknown for any of the
  211. // spectral type fields it can't find, and silently ignoring any extra
  212. // characters in the spectral type.  The parser is written this way because
  213. // the spectral type strings from the Hipparcos catalog are quite irregular.
  214. enum ParseState
  215. {
  216.     BeginState,
  217.     EndState,
  218.     NormalStarState,
  219.     WolfRayetTypeState,
  220.     NormalStarClassState,
  221.     NormalStarSubclassState,
  222.     NormalStarSubclassDecimalState,
  223.     NormalStarSubclassFinalState,
  224.     LumClassBeginState,
  225.     LumClassIState,
  226.     LumClassIIState,
  227.     LumClassVState,
  228.     LumClassIdashState,
  229.     LumClassIaState,
  230.     WDTypeState,
  231.     WDExtendedTypeState,
  232.     WDSubclassState,
  233.     SubdwarfPrefixState,
  234. };
  237. StellarClass
  238. StellarClass::parse(const string& st)
  239. {
  240.     uint32 i = 0;
  241.     ParseState state = BeginState;
  242.     StellarClass::StarType starType = StellarClass::NormalStar;
  243.     StellarClass::SpectralClass specClass = StellarClass::Spectral_Unknown;
  244.     StellarClass::LuminosityClass lumClass = StellarClass::Lum_Unknown;
  245.     unsigned int subclass = StellarClass::Subclass_Unknown;
  247.     while (state != EndState)
  248.     {
  249.         char c;
  250.         if (i < st.length())
  251.             c = st[i];
  252.         else
  253.             c = '';
  255.         switch (state)
  256.         {
  257.         case BeginState:
  258.             switch (c)
  259.             {
  260.             case 'Q':
  261.                 starType = StellarClass::NeutronStar;
  262.                 state = EndState;
  263.                 break;
  264.             case 'X':
  265.                 starType = StellarClass::BlackHole;
  266.                 state = EndState;
  267.                 break;
  268.             case 'D':
  269.                 starType = StellarClass::WhiteDwarf;
  270.                 specClass = StellarClass::Spectral_D;
  271.                 state = WDTypeState;
  272.                 i++;
  273.                 break;
  274.             case 's':
  275.                 // Hipparcos uses sd prefix for stars with luminosity
  276.                 // class VI ('subdwarfs')
  277.                 state = SubdwarfPrefixState;
  278.                 i++;
  279.                 break;
  280.             case '?':
  281.                 state = EndState;
  282.                 break;
  283.             default:
  284.                 state = NormalStarClassState;
  285.                 break;
  286.             }
  287.             break;
  289.         case WolfRayetTypeState:
  290.             switch (c)
  291.             {
  292.             case 'C':
  293.                 specClass = StellarClass::Spectral_WC;
  294.                 state = NormalStarSubclassState;
  295.                 i++;
  296.                 break;
  297.             case 'N':
  298.                 specClass = StellarClass::Spectral_WN;
  299.                 state = NormalStarSubclassState;
  300.                 i++;
  301.                 break;
  302.             default:
  303.                 specClass = StellarClass::Spectral_WC;
  304.                 state = NormalStarSubclassState;
  305.                 break;
  306.             }
  307.             break;
  309.         case SubdwarfPrefixState:
  310.             if (c == 'd')
  311.             {
  312.                 lumClass = StellarClass::Lum_VI;
  313.                 state = NormalStarClassState;
  314.                 i++;
  315.                 break;
  316.             }
  317.             else
  318.             {
  319.                 state = EndState;
  320.             }
  321.             break;
  323.         case NormalStarClassState:
  324.             switch (c)
  325.             {
  326.             case 'W':
  327.                 state = WolfRayetTypeState;
  328.                 break;
  329.             case 'O':
  330.                 specClass = StellarClass::Spectral_O;
  331.                 state = NormalStarSubclassState;
  332.                 break;
  333.             case 'B':
  334.                 specClass = StellarClass::Spectral_B;
  335.                 state = NormalStarSubclassState;
  336.                 break;
  337.             case 'A':
  338.                 specClass = StellarClass::Spectral_A;
  339.                 state = NormalStarSubclassState;
  340.                 break;
  341.             case 'F':
  342.                 specClass = StellarClass::Spectral_F;
  343.                 state = NormalStarSubclassState;
  344.                 break;
  345.             case 'G':
  346.                 specClass = StellarClass::Spectral_G;
  347.                 state = NormalStarSubclassState;
  348.                 break;
  349.             case 'K':
  350.                 specClass = StellarClass::Spectral_K;
  351.                 state = NormalStarSubclassState;
  352.                 break;
  353.             case 'M':
  354.                 specClass = StellarClass::Spectral_M;
  355.                 state = NormalStarSubclassState;
  356.                 break;
  357.             case 'R':
  358.                 specClass = StellarClass::Spectral_R;
  359.                 state = NormalStarSubclassState;
  360.                 break;
  361.             case 'S':
  362.                 specClass = StellarClass::Spectral_S;
  363.                 state = NormalStarSubclassState;
  364.                 break;
  365.             case 'N':
  366.                 specClass = StellarClass::Spectral_N;
  367.                 state = NormalStarSubclassState;
  368.                 break;
  369.             case 'L':
  370.                 specClass = StellarClass::Spectral_L;
  371.                 state = NormalStarSubclassState;
  372.                 break;
  373.             case 'T':
  374.                 specClass = StellarClass::Spectral_T;
  375.                 state = NormalStarSubclassState;
  376.                 break;
  377.             case 'C':
  378.                 specClass = StellarClass::Spectral_C;
  379.                 state = NormalStarSubclassState;
  380.                 break;
  381.             default:
  382.                 state = EndState;
  383.                 break;
  384.             }
  385.             i++;
  386.             break;
  388.         case NormalStarSubclassState:
  389.             if (isdigit(c))
  390.             {
  391.                 subclass = (unsigned int) c - (unsigned int) '0';
  392.                 state = NormalStarSubclassDecimalState;
  393.                 i++;
  394.             }
  395.             else
  396.             {
  397.                 state = LumClassBeginState;
  398.             }
  399.             break;
  401.         case NormalStarSubclassDecimalState:
  402.             if (c == '.')
  403.             {
  404.                 state = NormalStarSubclassFinalState;
  405.                 i++;
  406.             }
  407.             else
  408.             {
  409.                 state = LumClassBeginState;
  410.             }
  411.             break;
  413.         case NormalStarSubclassFinalState:
  414.             if (isdigit(c))
  415.                 state = LumClassBeginState;
  416.             else
  417.                 state = EndState;
  418.             i++;
  419.             break;
  421.         case LumClassBeginState:
  422.             switch (c)
  423.             {
  424.             case 'I':
  425.                 state = LumClassIState;
  426.                 break;
  427.             case 'V':
  428.                 state = LumClassVState;
  429.                 break;
  430.             default:
  431.                 state = EndState;
  432.                 break;
  433.             }
  434.             i++;
  435.             break;
  437.         case LumClassIState:
  438.             switch (c)
  439.             {
  440.             case 'I':
  441.                 state = LumClassIIState;
  442.                 break;
  443.             case 'V':
  444.                 lumClass = StellarClass::Lum_IV;
  445.                 state = EndState;
  446.                 break;
  447.             case 'a':
  448.                 state = LumClassIaState;
  449.                 break;
  450.             case 'b':
  451.                 lumClass = StellarClass::Lum_Ib;
  452.                 state = EndState;
  453.                 break;
  454.             case '-':
  455.                 state = LumClassIdashState;
  456.                 break;
  457.             default:
  458.                 lumClass = StellarClass::Lum_Ib;
  459.                 state = EndState;
  460.                 break;
  461.             }
  462.             i++;
  463.             break;
  465.         case LumClassIIState:
  466.             switch (c)
  467.             {
  468.             case 'I':
  469.                 lumClass = StellarClass::Lum_III;
  470.                 state = EndState;
  471.                 break;
  472.             default:
  473.                 lumClass = StellarClass::Lum_II;
  474.                 state = EndState;
  475.                 break;
  476.             }
  477.             break;
  479.         case LumClassIdashState:
  480.             switch (c)
  481.             {
  482.             case 'a':
  483.                 state = LumClassIaState;
  484.                 break;
  485.             case 'b':
  486.                 lumClass = StellarClass::Lum_Ib;
  487.                 state = EndState;
  488.                 break;
  489.             default:
  490.                 lumClass = StellarClass::Lum_Ib;
  491.                 state = EndState;
  492.                 break;
  493.             }
  494.             break;
  496.         case LumClassIaState:
  497.             switch (c)
  498.             {
  499.             case '0':
  500.                 lumClass = StellarClass::Lum_Ia0;
  501.                 state = EndState;
  502.                 break;
  503.             default:
  504.                 lumClass = StellarClass::Lum_Ia;
  505.                 state = EndState;
  506.                 break;
  507.             }
  508.             break;
  510.         case LumClassVState:
  511.             switch (c)
  512.             {
  513.             case 'I':
  514.                 lumClass = StellarClass::Lum_VI;
  515.                 state = EndState;
  516.                 break;
  517.             default:
  518.                 lumClass = StellarClass::Lum_V;
  519.                 state = EndState;
  520.                 break;
  521.             }
  522.             break;
  524.         case WDTypeState:
  525.             switch (c)
  526.             {
  527.             case 'A':
  528.                 specClass = StellarClass::Spectral_DA;
  529.                 i++;
  530.                 break;
  531.             case 'B':
  532.                 specClass = StellarClass::Spectral_DB;
  533.                 i++;
  534.                 break;
  535.             case 'C':
  536.                 specClass = StellarClass::Spectral_DC;
  537.                 i++;
  538.                 break;
  539.             case 'O':
  540.                 specClass = StellarClass::Spectral_DO;
  541.                 i++;
  542.                 break;
  543.             case 'Q':
  544.                 specClass = StellarClass::Spectral_DQ;
  545.                 i++;
  546.                 break;
  547.             case 'X':
  548.                 specClass = StellarClass::Spectral_DX;
  549.                 i++;
  550.                 break;
  551.             case 'Z':
  552.                 specClass = StellarClass::Spectral_DZ;
  553.                 i++;
  554.                 break;
  555.             default:
  556.                 specClass = StellarClass::Spectral_D;
  557.                 break;
  558.             }
  559.             state = WDExtendedTypeState;
  560.             break;
  562.         case WDExtendedTypeState:
  563.             switch (c)
  564.             {
  565.             case 'A':
  566.             case 'B':
  567.             case 'C':
  568.             case 'O':
  569.             case 'Q':
  570.             case 'Z':
  571.             case 'X':
  572.             case 'V': // variable
  573.             case 'P': // magnetic stars with polarized light
  574.             case 'H': // magnetic stars without polarized light
  575.             case 'E': // emission lines
  576.                 i++;
  577.                 break;
  578.             default:
  579.                 state = WDSubclassState;
  580.                 break;
  581.             }
  582.             break;
  584.         case WDSubclassState:
  585.             if (isdigit(c))
  586.             {
  587.                 subclass = (unsigned int) c - (unsigned int) '0';
  588.                 i++;
  589.             }
  590.             state = EndState;
  591.             break;
  593.         default:
  594.             assert(0);
  595.             state = EndState;
  596.             break;
  597.         }
  598.     }
  600.     return StellarClass(starType, specClass, subclass, lumClass);
  601. }