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

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

OpenGL

开发平台：

Visual C++

render.cpp：源码内容
  1.             ri.baseTex->bind();
  2.             glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  3.             ri.bumpTex->bind();
  4.             setupBumpTexenv();
  5.             g_lodSphere->render(context,
  6.                                 LODSphereMesh::Normals | LODSphereMesh::Tangents |
  7.                                 LODSphereMesh::TexCoords0 | LODSphereMesh::VertexProgParams,
  8.                                 frustum, ri.pixWidth,
  9.                                 ri.bumpTex, ri.baseTex);
  10.             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  11.         }
  12.     }
  13.     else
  14.     {
  15.         if (ls.nLights > 1)
  16.             vproc->use(vp::diffuse_2light);
  17.         else
  18.             vproc->use(vp::diffuse);
  19.         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  20.         g_lodSphere->render(context,
  21.                             LODSphereMesh::Normals | LODSphereMesh::TexCoords0 |
  22.                             LODSphereMesh::VertexProgParams,
  23.                             frustum, ri.pixWidth,
  24.                             ri.baseTex);
  25.     }
  27.     // Render a specular pass; can't be done in one pass because
  28.     // specular needs to be modulated with a gloss map.
  29.     if (ri.specularColor != Color::Black)
  30.     {
  31.         glEnable(GL_BLEND);
  32.         glBlendFunc(GL_ONE, GL_ONE);
  33.         vproc->use(vp::glossMap);
  35.         if (ri.glossTex != NULL)
  36.             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  37.         else
  38.             setupTexenvGlossMapAlpha();
  40.         g_lodSphere->render(context,
  41.                             LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  42.                             frustum, ri.pixWidth,
  43.                             ri.glossTex != NULL ? ri.glossTex : ri.baseTex);
  45.         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  46.         glDisable(GL_BLEND);
  47.     }
  49.     if (ri.nightTex != NULL)
  50.     {
  51.         ri.nightTex->bind();
  52. #ifdef USE_HDR
  53.         // Scale night light intensity
  54. #ifdef HDR_COMPRESS
  55.         Color nightColor0(ls.lights[0].color.red()  *ri.color.red()  *2.f,
  56.                           ls.lights[0].color.green()*ri.color.green()*2.f,
  57.                           ls.lights[0].color.blue() *ri.color.blue() *2.f,
  58.                           ri.nightLightScale); // Modulate brightness with alpha
  59. #else
  60.         Color nightColor0(ls.lights[0].color.red()  *ri.color.red(),
  61.                           ls.lights[0].color.green()*ri.color.green(),
  62.                           ls.lights[0].color.blue() *ri.color.blue(),
  63.                           ri.nightLightScale); // Modulate brightness with alpha
  64. #endif
  65.         vproc->parameter(vp::DiffuseColor0, nightColor0);
  66. #endif
  67.         if (ls.nLights > 1)
  68.         {
  69. #ifdef USE_HDR
  70. #ifdef HDR_COMPRESS
  71.             Color nightColor1(ls.lights[1].color.red()  *ri.color.red()  *2.f,
  72.                               ls.lights[1].color.green()*ri.color.green()*2.f,
  73.                               ls.lights[1].color.blue() *ri.color.blue() *2.f,
  74.                               ri.nightLightScale);
  75. #else
  76.             Color nightColor1(ls.lights[1].color.red()  *ri.color.red(),
  77.                               ls.lights[1].color.green()*ri.color.green(),
  78.                               ls.lights[1].color.blue() *ri.color.blue(),
  79.                               ri.nightLightScale);
  80. #endif
  81.             vproc->parameter(vp::DiffuseColor0, nightColor1);
  82. #endif
  83. #ifdef HDR_COMPRESS
  84.             vproc->use(vp::nightLights_2lightHDR);
  85. #else
  86.             vproc->use(vp::nightLights_2light);
  87. #endif
  88.         }
  89.         else
  90.         {
  91. #ifdef HDR_COMPRESS
  92.             vproc->use(vp::nightLightsHDR);
  93. #else
  94.             vproc->use(vp::nightLights);
  95. #endif
  96.         }
  97. #ifdef USE_HDR
  98.         glEnable(GL_BLEND);
  99.         glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  100. #else
  101.         setupNightTextureCombine();
  102.         glEnable(GL_BLEND);
  103.         glBlendFunc(GL_ONE, GL_ONE);
  104. #endif
  105.         g_lodSphere->render(context,
  106.                             LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  107.                             frustum, ri.pixWidth,
  108.                             ri.nightTex);
  109. #ifdef USE_HDR
  110.         vproc->parameter(vp::DiffuseColor0, ls.lights[0].color * ri.color);
  111.         if (ls.nLights > 1)
  112.             vproc->parameter(vp::DiffuseColor1, ls.lights[1].color * ri.color);
  113. #endif
  114.         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  115.     }
  117.     if (ri.overlayTex != NULL)
  118.     {
  119.         ri.overlayTex->bind();
  120.         vproc->use(vp::diffuse);
  121.         glEnable(GL_BLEND);
  122.         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  123.         g_lodSphere->render(context,
  124.                             LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  125.                             frustum, ri.pixWidth,
  126.                             ri.overlayTex);
  127.         glBlendFunc(GL_ONE, GL_ONE);
  128.     }
  130.     vproc->disable();
  131. }
  134. static void renderSphere_Combiners_VP(const RenderInfo& ri,
  135.                                       const LightingState& ls,
  136.                                       const Frustum& frustum,
  137.                                       const GLContext& context)
  138. {
  139.     Texture* textures[4];
  140.     VertexProcessor* vproc = context.getVertexProcessor();
  141.     assert(vproc != NULL);
  143.     if (ri.baseTex == NULL)
  144.     {
  145.         glDisable(GL_TEXTURE_2D);
  146.     }
  147.     else
  148.     {
  149.         glEnable(GL_TEXTURE_2D);
  150.         ri.baseTex->bind();
  151.     }
  153.     // Set up the fog parameters if the haze density is non-zero
  154.     float hazeDensity = ri.hazeColor.alpha();
  155. #ifdef HDR_COMPRESS
  156.     Color hazeColor(ri.hazeColor.red()   * 0.5f,
  157.                     ri.hazeColor.green() * 0.5f,
  158.                     ri.hazeColor.blue()  * 0.5f,
  159.                     hazeDensity);
  160. #else
  161.     Color hazeColor = ri.hazeColor;
  162. #endif
  164.     if (hazeDensity > 0.0f && !buggyVertexProgramEmulation)
  165.     {
  166.         glEnable(GL_FOG);
  167.         float fogColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
  168.         fogColor[0] = hazeColor.red();
  169.         fogColor[1] = hazeColor.green();
  170.         fogColor[2] = hazeColor.blue();
  171.         glFogfv(GL_FOG_COLOR, fogColor);
  172.         glFogi(GL_FOG_MODE, GL_LINEAR);
  173.         glFogf(GL_FOG_START, 0.0);
  174.         glFogf(GL_FOG_END, 1.0f / hazeDensity);
  175.     }
  177.     vproc->enable();
  179.     vproc->parameter(vp::EyePosition, ri.eyePos_obj);
  180.     setLightParameters_VP(*vproc, ls, ri.color, ri.specularColor);
  182.     vproc->parameter(vp::SpecularExponent, 0.0f, 1.0f, 0.5f, ri.specularPower);
  183.     vproc->parameter(vp::AmbientColor, ri.ambientColor * ri.color);
  184.     vproc->parameter(vp::HazeColor, hazeColor);
  186.     // Don't use a normal map if it's a dxt5nm map--only the GLSL path
  187.     // can handle them.
  188.     if (ri.bumpTex != NULL &&
  189.         (ri.bumpTex->getFormatOptions() & Texture::DXT5NormalMap) == 0)
  190.     {
  191.         if (hazeDensity > 0.0f)
  192.         {
  193. #ifdef HDR_COMPRESS
  194.             vproc->use(vp::diffuseBumpHazeHDR);
  195. #else
  196.             vproc->use(vp::diffuseBumpHaze);
  197. #endif
  198.         }
  199.         else
  200.         {
  201. #ifdef HDR_COMPRESS
  202.             vproc->use(vp::diffuseBumpHDR);
  203. #else
  204.             vproc->use(vp::diffuseBump);
  205. #endif
  206.         }
  207.         SetupCombinersDecalAndBumpMap(*(ri.bumpTex),
  208.                                       ri.ambientColor * ri.color,
  209.                                       ri.sunColor * ri.color);
  210.         g_lodSphere->render(context,
  211.                             LODSphereMesh::Normals | LODSphereMesh::Tangents |
  212.                             LODSphereMesh::TexCoords0 | LODSphereMesh::VertexProgParams,
  213.                             frustum, ri.pixWidth,
  214.                             ri.baseTex, ri.bumpTex);
  215.         DisableCombiners();
  217.         // Render a specular pass
  218.         if (ri.specularColor != Color::Black)
  219.         {
  220.             glEnable(GL_BLEND);
  221.             glBlendFunc(GL_ONE, GL_ONE);
  222.             glEnable(GL_COLOR_SUM_EXT);
  223.             vproc->use(vp::specular);
  225.             // Disable ambient and diffuse
  226.             vproc->parameter(vp::AmbientColor, Color::Black);
  227.             vproc->parameter(vp::DiffuseColor0, Color::Black);
  228.             SetupCombinersGlossMap(ri.glossTex != NULL ? GL_TEXTURE0_ARB : 0);
  230.             textures[0] = ri.glossTex != NULL ? ri.glossTex : ri.baseTex;
  231.             g_lodSphere->render(context,
  232.                                 LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  233.                                 frustum, ri.pixWidth,
  234.                                 textures, 1);
  236.             // re-enable diffuse
  237.             vproc->parameter(vp::DiffuseColor0, ri.sunColor * ri.color);
  239.             DisableCombiners();
  240.             glDisable(GL_COLOR_SUM_EXT);
  241.             glDisable(GL_BLEND);
  242.         }
  243.     }
  244.     else if (ri.specularColor != Color::Black)
  245.     {
  246.         glEnable(GL_COLOR_SUM_EXT);
  247.         if (ls.nLights > 1)
  248.             vproc->use(vp::specular_2light);
  249.         else
  250.             vproc->use(vp::specular);
  251.         SetupCombinersGlossMapWithFog(ri.glossTex != NULL ? GL_TEXTURE1_ARB : 0);
  252.         unsigned int attributes = LODSphereMesh::Normals | LODSphereMesh::TexCoords0 |
  253.             LODSphereMesh::VertexProgParams;
  254.         g_lodSphere->render(context,
  255.                             attributes, frustum, ri.pixWidth,
  256.                             ri.baseTex, ri.glossTex);
  257.         DisableCombiners();
  258.         glDisable(GL_COLOR_SUM_EXT);
  259.     }
  260.     else
  261.     {
  262.         if (ls.nLights > 1)
  263.         {
  264.             if (hazeDensity > 0.0f)
  265.                 vproc->use(vp::diffuseHaze_2light);
  266.             else
  267.                 vproc->use(vp::diffuse_2light);
  268.         }
  269.         else
  270.         {
  271.             if (hazeDensity > 0.0f)
  272.                 vproc->use(vp::diffuseHaze);
  273.             else
  274.                 vproc->use(vp::diffuse);
  275.         }
  277.         g_lodSphere->render(context,
  278.                             LODSphereMesh::Normals | LODSphereMesh::TexCoords0 |
  279.                             LODSphereMesh::VertexProgParams,
  280.                             frustum, ri.pixWidth,
  281.                             ri.baseTex);
  282.     }
  284.     if (hazeDensity > 0.0f)
  285.         glDisable(GL_FOG);
  287.     if (ri.nightTex != NULL)
  288.     {
  289.         ri.nightTex->bind();
  290. #ifdef USE_HDR
  291.         // Scale night light intensity
  292. #ifdef HDR_COMPRESS
  293.         Color nightColor0(ls.lights[0].color.red()  *ri.color.red()  *2.f,
  294.                           ls.lights[0].color.green()*ri.color.green()*2.f,
  295.                           ls.lights[0].color.blue() *ri.color.blue() *2.f,
  296.                           ri.nightLightScale); // Modulate brightness with alpha
  297. #else
  298.         Color nightColor0(ls.lights[0].color.red()  *ri.color.red(),
  299.                           ls.lights[0].color.green()*ri.color.green(),
  300.                           ls.lights[0].color.blue() *ri.color.blue(),
  301.                           ri.nightLightScale); // Modulate brightness with alpha
  302. #endif
  303.         vproc->parameter(vp::DiffuseColor0, nightColor0);
  304. #endif
  305.         if (ls.nLights > 1)
  306.         {
  307. #ifdef USE_HDR
  308. #ifdef HDR_COMPRESS
  309.             Color nightColor1(ls.lights[1].color.red()  *ri.color.red()  *2.f,
  310.                               ls.lights[1].color.green()*ri.color.green()*2.f,
  311.                               ls.lights[1].color.blue() *ri.color.blue() *2.f,
  312.                               ri.nightLightScale);
  313. #else
  314.             Color nightColor1(ls.lights[1].color.red()  *ri.color.red(),
  315.                               ls.lights[1].color.green()*ri.color.green(),
  316.                               ls.lights[1].color.blue() *ri.color.blue(),
  317.                               ri.nightLightScale);
  318. #endif
  319.             vproc->parameter(vp::DiffuseColor0, nightColor1);
  320. #endif
  321. #ifdef HDR_COMPRESS
  322.             vproc->use(vp::nightLights_2lightHDR);
  323. #else
  324.             vproc->use(vp::nightLights_2light);
  325. #endif
  326.         }
  327.         else
  328.         {
  329. #ifdef HDR_COMPRESS
  330.             vproc->use(vp::nightLightsHDR);
  331. #else
  332.             vproc->use(vp::nightLights);
  333. #endif
  334.         }
  335. #ifdef USE_HDR
  336.         glEnable(GL_BLEND);
  337.         glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  338. #else
  339.         setupNightTextureCombine();
  340.         glEnable(GL_BLEND);
  341.         glBlendFunc(GL_ONE, GL_ONE);
  342. #endif
  343.         g_lodSphere->render(context,
  344.                             LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  345.                             frustum, ri.pixWidth,
  346.                             ri.nightTex);
  347. #ifdef USE_HDR
  348.         vproc->parameter(vp::DiffuseColor0, ri.sunColor * ri.color);
  349. #endif
  350.         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  351.     }
  353.     if (ri.overlayTex != NULL)
  354.     {
  355.         ri.overlayTex->bind();
  356.         vproc->use(vp::diffuse);
  357.         glEnable(GL_BLEND);
  358.         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  359.         g_lodSphere->render(context,
  360.                             LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  361.                             frustum, ri.pixWidth,
  362.                             ri.overlayTex);
  363.         glBlendFunc(GL_ONE, GL_ONE);
  364.     }
  366.     vproc->disable();
  367. }
  370. // Render a planet sphere using both fragment and vertex programs
  371. static void renderSphere_FP_VP(const RenderInfo& ri,
  372.                                const Frustum& frustum,
  373.                                const GLContext& context)
  374. {
  375.     Texture* textures[4];
  376.     VertexProcessor* vproc = context.getVertexProcessor();
  377.     FragmentProcessor* fproc = context.getFragmentProcessor();
  378.     assert(vproc != NULL && fproc != NULL);
  380.     if (ri.baseTex == NULL)
  381.     {
  382.         glDisable(GL_TEXTURE_2D);
  383.     }
  384.     else
  385.     {
  386.         glEnable(GL_TEXTURE_2D);
  387.         ri.baseTex->bind();
  388.     }
  390.     // Compute the half angle vector required for specular lighting
  391.     Vec3f halfAngle_obj = ri.eyeDir_obj + ri.sunDir_obj;
  392.     if (halfAngle_obj.length() != 0.0f)
  393.         halfAngle_obj.normalize();
  395.     // Set up the fog parameters if the haze density is non-zero
  396.     float hazeDensity = ri.hazeColor.alpha();
  398.     if (hazeDensity > 0.0f)
  399.     {
  400.         glEnable(GL_FOG);
  401.         float fogColor[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
  402.         fogColor[0] = ri.hazeColor.red();
  403.         fogColor[1] = ri.hazeColor.green();
  404.         fogColor[2] = ri.hazeColor.blue();
  405.         glFogfv(GL_FOG_COLOR, fogColor);
  406.         glFogi(GL_FOG_MODE, GL_LINEAR);
  407.         glFogf(GL_FOG_START, 0.0);
  408.         glFogf(GL_FOG_END, 1.0f / hazeDensity);
  409.     }
  411.     vproc->enable();
  413.     vproc->parameter(vp::EyePosition, ri.eyePos_obj);
  414.     vproc->parameter(vp::LightDirection0, ri.sunDir_obj);
  415.     vproc->parameter(vp::DiffuseColor0, ri.sunColor * ri.color);
  416.     vproc->parameter(vp::SpecularExponent, 0.0f, 1.0f, 0.5f, ri.specularPower);
  417.     vproc->parameter(vp::SpecularColor0, ri.sunColor * ri.specularColor);
  418.     vproc->parameter(vp::AmbientColor, ri.ambientColor * ri.color);
  419.     vproc->parameter(vp::HazeColor, ri.hazeColor);
  421.     if (ri.bumpTex != NULL)
  422.     {
  423.         fproc->enable();
  425.         if (hazeDensity > 0.0f)
  426.             vproc->use(vp::diffuseBumpHaze);
  427.         else
  428.             vproc->use(vp::diffuseBump);
  429.         fproc->use(fp::texDiffuseBump);
  430.         g_lodSphere->render(context,
  431.                             LODSphereMesh::Normals | LODSphereMesh::Tangents |
  432.                             LODSphereMesh::TexCoords0 | LODSphereMesh::VertexProgParams,
  433.                             frustum, ri.pixWidth,
  434.                             ri.baseTex, ri.bumpTex);
  435.         fproc->disable();
  437.         // Render a specular pass
  438.         if (ri.specularColor != Color::Black)
  439.         {
  440.             glEnable(GL_BLEND);
  441.             glBlendFunc(GL_ONE, GL_ONE);
  442.             glEnable(GL_COLOR_SUM_EXT);
  443.             vproc->use(vp::specular);
  445.             // Disable ambient and diffuse
  446.             vproc->parameter(vp::AmbientColor, Color::Black);
  447.             vproc->parameter(vp::DiffuseColor0, Color::Black);
  448.             SetupCombinersGlossMap(ri.glossTex != NULL ? GL_TEXTURE0_ARB : 0);
  450.             textures[0] = ri.glossTex != NULL ? ri.glossTex : ri.baseTex;
  451.             g_lodSphere->render(context,
  452.                                 LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  453.                                 frustum, ri.pixWidth,
  454.                                 textures, 1);
  456.             // re-enable diffuse
  457.             vproc->parameter(vp::DiffuseColor0, ri.sunColor * ri.color);
  459.             DisableCombiners();
  460.             glDisable(GL_COLOR_SUM_EXT);
  461.             glDisable(GL_BLEND);
  462.         }
  463.     }
  464.     else if (ri.specularColor != Color::Black)
  465.     {
  466.         fproc->enable();
  467.         if (ri.glossTex == NULL)
  468.         {
  469.             vproc->use(vp::perFragmentSpecularAlpha);
  470.             fproc->use(fp::texSpecularAlpha);
  471.         }
  472.         else
  473.         {
  474.             vproc->use(vp::perFragmentSpecular);
  475.             fproc->use(fp::texSpecular);
  476.         }
  477.         fproc->parameter(fp::DiffuseColor, ri.sunColor * ri.color);
  478.         fproc->parameter(fp::SunDirection, ri.sunDir_obj);
  479.         fproc->parameter(fp::SpecularColor, ri.specularColor);
  480.         fproc->parameter(fp::SpecularExponent, ri.specularPower, 0.0f, 0.0f, 0.0f);
  481.         fproc->parameter(fp::AmbientColor, ri.ambientColor);
  483.         unsigned int attributes = LODSphereMesh::Normals |
  484.                                   LODSphereMesh::TexCoords0 |
  485.                                   LODSphereMesh::VertexProgParams;
  486.         g_lodSphere->render(context,
  487.                             attributes, frustum, ri.pixWidth,
  488.                             ri.baseTex, ri.glossTex);
  489.         fproc->disable();
  490.     }
  491.     else
  492.     {
  493.         fproc->enable();
  494.         if (hazeDensity > 0.0f)
  495.             vproc->use(vp::diffuseHaze);
  496.         else
  497.             vproc->use(vp::diffuse);
  498.         fproc->use(fp::texDiffuse);
  499.         g_lodSphere->render(context,
  500.                             LODSphereMesh::Normals | LODSphereMesh::TexCoords0 |
  501.                             LODSphereMesh::VertexProgParams,
  502.                             frustum, ri.pixWidth,
  503.                             ri.baseTex);
  504.         fproc->disable();
  505.     }
  507.     if (hazeDensity > 0.0f)
  508.         glDisable(GL_FOG);
  510.     if (ri.nightTex != NULL)
  511.     {
  512.         ri.nightTex->bind();
  513.         vproc->use(vp::nightLights);
  514.         setupNightTextureCombine();
  515.         glEnable(GL_BLEND);
  516.         glBlendFunc(GL_ONE, GL_ONE);
  517.         g_lodSphere->render(context,
  518.                             LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  519.                             frustum, ri.pixWidth,
  520.                             ri.nightTex);
  521.         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  522.     }
  524.     if (ri.overlayTex != NULL)
  525.     {
  526.         ri.overlayTex->bind();
  527.         vproc->use(vp::diffuse);
  528.         glEnable(GL_BLEND);
  529.         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  530.         g_lodSphere->render(context,
  531.                             LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  532.                             frustum, ri.pixWidth,
  533.                             ri.overlayTex);
  534.         glBlendFunc(GL_ONE, GL_ONE);
  535.     }
  537.     vproc->disable();
  538. }
  541. static void texGenPlane(GLenum coord, GLenum mode, const Vec4f& plane)
  542. {
  543.     float f[4];
  544.     f[0] = plane.x; f[1] = plane.y; f[2] = plane.z; f[3] = plane.w;
  545.     glTexGenfv(coord, mode, f);
  546. }
  548. static void renderShadowedGeometryDefault(Geometry* geometry,
  549.                                        const RenderInfo& ri,
  550.                                        const Frustum& frustum,
  551.                                        float *sPlane,
  552.                                        float *tPlane,
  553.                                        const Vec3f& lightDir,
  554.                                        bool useShadowMask,
  555.                                        const GLContext& context)
  556. {
  557.     glEnable(GL_TEXTURE_GEN_S);
  558.     glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  559.     glTexGenfv(GL_S, GL_OBJECT_PLANE, sPlane);
  560.     //texGenPlane(GL_S, GL_OBJECT_PLANE, sPlane);
  561.     glEnable(GL_TEXTURE_GEN_T);
  562.     glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  563.     glTexGenfv(GL_T, GL_OBJECT_PLANE, tPlane);
  565.     if (useShadowMask)
  566.     {
  567.         glx::glActiveTextureARB(GL_TEXTURE1_ARB);
  568.         glEnable(GL_TEXTURE_GEN_S);
  569.         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  570.         texGenPlane(GL_S, GL_OBJECT_PLANE,
  571.                     Vec4f(lightDir.x, lightDir.y, lightDir.z, 0.5f));
  572.         glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  573.     }
  575.     glColor4f(1, 1, 1, 1);
  576.     glDisable(GL_LIGHTING);
  578.     if (geometry == NULL)
  579.     {
  580.         g_lodSphere->render(context,
  581.                             LODSphereMesh::Normals | LODSphereMesh::Multipass,
  582.                             frustum, ri.pixWidth, NULL);
  583.     }
  584.     else
  585.     {
  586.         FixedFunctionRenderContext rc;
  587.         geometry->render(rc);
  588.     }
  589.     glEnable(GL_LIGHTING);
  591.     if (useShadowMask)
  592.     {
  593.         glx::glActiveTextureARB(GL_TEXTURE1_ARB);
  594.         glDisable(GL_TEXTURE_GEN_S);
  595.         glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  596.     }
  597.     glDisable(GL_TEXTURE_GEN_S);
  598.     glDisable(GL_TEXTURE_GEN_T);
  599. }
  602. static void renderShadowedGeometryVertexShader(const RenderInfo& ri,
  603.                                             const Frustum& frustum,
  604.                                             float* sPlane, float* tPlane,
  605.                                             Vec3f& lightDir,
  606.                                             const GLContext& context)
  607. {
  608.     VertexProcessor* vproc = context.getVertexProcessor();
  609.     assert(vproc != NULL);
  611.     vproc->enable();
  612.     vproc->parameter(vp::LightDirection0, lightDir);
  613.     vproc->parameter(vp::TexGen_S, sPlane);
  614.     vproc->parameter(vp::TexGen_T, tPlane);
  615.     vproc->use(vp::shadowTexture);
  617.     g_lodSphere->render(context,
  618.                         LODSphereMesh::Normals | LODSphereMesh::Multipass, frustum,
  619.                         ri.pixWidth, NULL);
  621.     vproc->disable();
  622. }
  625. static void renderRings(RingSystem& rings,
  626.                         RenderInfo& ri,
  627.                         float planetRadius,
  628.                         float planetOblateness,
  629.                         unsigned int textureResolution,
  630.                         bool renderShadow,
  631.                         const GLContext& context,
  632.                         unsigned int nSections)
  633. {
  634.     float inner = rings.innerRadius / planetRadius;
  635.     float outer = rings.outerRadius / planetRadius;
  637.     // Ring Illumination:
  638.     // Since a ring system is composed of millions of individual
  639.     // particles, it's not at all realistic to model it as a flat
  640.     // Lambertian surface.  We'll approximate the llumination
  641.     // function by assuming that the ring system contains Lambertian
  642.     // particles, and that the brightness at some point in the ring
  643.     // system is proportional to the illuminated fraction of a
  644.     // particle there.  In fact, we'll simplify things further and
  645.     // set the illumination of the entire ring system to the same
  646.     // value, computing the illuminated fraction of a hypothetical
  647.     // particle located at the center of the planet.  This
  648.     // approximation breaks down when you get close to the planet.
  649.     float ringIllumination = 0.0f;
  650.     {
  651.         float illumFraction = (1.0f + ri.eyeDir_obj * ri.sunDir_obj) / 2.0f;
  652.         // Just use the illuminated fraction for now . . .
  653.         ringIllumination = illumFraction;
  654.     }
  656.     GLContext::VertexPath vpath = context.getVertexPath();
  657.     VertexProcessor* vproc = context.getVertexProcessor();
  658.     FragmentProcessor* fproc = context.getFragmentProcessor();
  660.     if (vproc != NULL)
  661.     {
  662.         vproc->enable();
  663.         vproc->use(vp::ringIllum);
  664.         vproc->parameter(vp::LightDirection0, ri.sunDir_obj);
  665.         vproc->parameter(vp::DiffuseColor0, ri.sunColor * rings.color);
  666.         vproc->parameter(vp::AmbientColor, ri.ambientColor * ri.color);
  667.         vproc->parameter(vp::Constant0, Vec3f(0, 0.5, 1.0));
  668.     }
  670.     // If we have multi-texture support, we'll use the second texture unit
  671.     // to render the shadow of the planet on the rings.  This is a bit of
  672.     // a hack, and assumes that the planet is ellipsoidal in shape,
  673.     // and only works for a planet illuminated by a single sun where the
  674.     // distance to the sun is very large relative to its diameter.
  675.     if (renderShadow)
  676.     {
  677.         glx::glActiveTextureARB(GL_TEXTURE1_ARB);
  678.         glEnable(GL_TEXTURE_2D);
  679.         shadowTex->bind();
  681.         float sPlane[4] = { 0, 0, 0, 0.5f };
  682.         float tPlane[4] = { 0, 0, 0, 0.5f };
  684.         // Compute the projection vectors based on the sun direction.
  685.         // I'm being a little careless here--if the sun direction lies
  686.         // along the y-axis, this will fail.  It's unlikely that a
  687.         // planet would ever orbit underneath its sun (an orbital
  688.         // inclination of 90 degrees), but this should be made
  689.         // more robust anyway.
  690.         Vec3f axis = Vec3f(0, 1, 0) ^ ri.sunDir_obj;
  691.         float cosAngle = Vec3f(0.0f, 1.0f, 0.0f) * ri.sunDir_obj;
  692.         /*float angle = (float) acos(cosAngle);     Unused*/
  693.         axis.normalize();
  695.         float sScale = 1.0f;
  696.         float tScale = 1.0f;
  697.         if (fproc == NULL)
  698.         {
  699.             // When fragment programs aren't used, we render shadows with circular
  700.             // textures.  We scale up the texture slightly to account for the
  701.             // padding pixels near the texture borders.
  702.             sScale *= ShadowTextureScale;
  703.             tScale *= ShadowTextureScale;
  704.         }
  706.         if (planetOblateness != 0.0f)
  707.         {
  708.             // For oblate planets, the size of the shadow volume will vary based
  709.             // on the light direction.
  711.             // A vertical slice of the planet is an ellipse
  712.             float a = 1.0f;                          // semimajor axis
  713.             float b = a * (1.0f - planetOblateness); // semiminor axis
  714.             float ecc2 = 1.0f - (b * b) / (a * a);   // square of eccentricity
  716.             // Calculate the radius of the ellipse at the incident angle of the
  717.             // light on the ring plane + 90 degrees.
  718.             float r = a * (float) sqrt((1.0f - ecc2) /
  719.                                        (1.0f - ecc2 * square(cosAngle)));
  721.             tScale *= a / r;
  722.         }
  724.         // The s axis is perpendicular to the shadow axis in the plane of the
  725.         // of the rings, and the t axis completes the orthonormal basis.
  726.         Vec3f sAxis = axis * 0.5f;
  727.         Vec3f tAxis = (axis ^ ri.sunDir_obj) * 0.5f * tScale;
  729.         sPlane[0] = sAxis.x; sPlane[1] = sAxis.y; sPlane[2] = sAxis.z;
  730.         tPlane[0] = tAxis.x; tPlane[1] = tAxis.y; tPlane[2] = tAxis.z;
  732.         if (vproc != NULL)
  733.         {
  734.             vproc->parameter(vp::TexGen_S, sPlane);
  735.             vproc->parameter(vp::TexGen_T, tPlane);
  736.         }
  737.         else
  738.         {
  739.             glEnable(GL_TEXTURE_GEN_S);
  740.             glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
  741.             glTexGenfv(GL_S, GL_EYE_PLANE, sPlane);
  742.             glEnable(GL_TEXTURE_GEN_T);
  743.             glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
  744.             glTexGenfv(GL_T, GL_EYE_PLANE, tPlane);
  745.         }
  747.         glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  749.         if (fproc != NULL)
  750.         {
  751.             float r0 = 0.24f;
  752.             float r1 = 0.25f;
  753.             float bias = 1.0f / (1.0f - r1 / r0);
  754.             float scale = -bias / r0;
  756.             fproc->enable();
  757.             fproc->use(fp::sphereShadowOnRings);
  758.             fproc->parameter(fp::ShadowParams0, scale, bias, 0.0f, 0.0f);
  759.             fproc->parameter(fp::AmbientColor, ri.ambientColor * ri.color);
  760.         }
  761.     }
  763.     glEnable(GL_BLEND);
  764.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  766.     Texture* ringsTex = rings.texture.find(textureResolution);
  768.     if (ringsTex != NULL)
  769.     {
  770.         glEnable(GL_TEXTURE_2D);
  771.         ringsTex->bind();
  772.     }
  773.     else
  774.     {
  775.         glDisable(GL_TEXTURE_2D);
  776.     }
  778.     // Perform our own lighting for the rings.
  779.     // TODO: Don't forget about light source color (required when we
  780.     // paying attention to star color.)
  781.     if (vpath == GLContext::VPath_Basic)
  782.     {
  783.         glDisable(GL_LIGHTING);
  784.         Vec3f litColor(rings.color.red(), rings.color.green(), rings.color.blue());
  785.         litColor = litColor * ringIllumination +
  786.             Vec3f(ri.ambientColor.red(), ri.ambientColor.green(),
  787.                   ri.ambientColor.blue());
  788.         glColor4f(litColor.x, litColor.y, litColor.z, 1.0f);
  789.     }
  791.     // This gets tricky . . .  we render the rings in two parts.  One
  792.     // part is potentially shadowed by the planet, and we need to
  793.     // render that part with the projected shadow texture enabled.
  794.     // The other part isn't shadowed, but will appear so if we don't
  795.     // first disable the shadow texture.  The problem is that the
  796.     // shadow texture will affect anything along the line between the
  797.     // sun and the planet, regardless of whether it's in front or
  798.     // behind the planet.
  800.     // Compute the angle of the sun projected on the ring plane
  801.     float sunAngle = (float) atan2(ri.sunDir_obj.z, ri.sunDir_obj.x);
  803.     // If there's a fragment program, it will handle the ambient term--make
  804.     // sure that we don't add it both in the fragment and vertex programs.
  805.     if (vproc != NULL && fproc != NULL)
  806.         glAmbientLightColor(Color::Black);
  808.     renderRingSystem(inner, outer,
  809.                      (float) (sunAngle + PI / 2),
  810.                      (float) (sunAngle + 3 * PI / 2),
  811.                      nSections / 2);
  812.     renderRingSystem(inner, outer,
  813.                      (float) (sunAngle +  3 * PI / 2),
  814.                      (float) (sunAngle + PI / 2),
  815.                      nSections / 2);
  817.     if (vproc != NULL && fproc != NULL)
  818.         glAmbientLightColor(ri.ambientColor * ri.color);
  820.     // Disable the second texture unit if it was used
  821.     if (renderShadow)
  822.     {
  823.         glx::glActiveTextureARB(GL_TEXTURE1_ARB);
  824.         glDisable(GL_TEXTURE_2D);
  825.         glDisable(GL_TEXTURE_GEN_S);
  826.         glDisable(GL_TEXTURE_GEN_T);
  827.         glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  829.         if (fproc != NULL)
  830.             fproc->disable();
  831.     }
  833.     // Render the unshadowed side
  834.     renderRingSystem(inner, outer,
  835.                      (float) (sunAngle - PI / 2),
  836.                      (float) (sunAngle + PI / 2),
  837.                      nSections / 2);
  838.     renderRingSystem(inner, outer,
  839.                      (float) (sunAngle + PI / 2),
  840.                      (float) (sunAngle - PI / 2),
  841.                      nSections / 2);
  842.     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  844.     if (vproc != NULL)
  845.         vproc->disable();
  846. }
  849. static void
  850. renderEclipseShadows(Geometry* geometry,
  851.                      vector<EclipseShadow>& eclipseShadows,
  852.                      RenderInfo& ri,
  853.                      float planetRadius,
  854.                      Mat4f& planetMat,
  855.                      Frustum& viewFrustum,
  856.                      const GLContext& context)
  857. {
  858.     // Eclipse shadows on mesh objects aren't working yet.
  859.     if (geometry != NULL)
  860.         return;
  862.     for (vector<EclipseShadow>::iterator iter = eclipseShadows.begin();
  863.          iter != eclipseShadows.end(); iter++)
  864.     {
  865.         EclipseShadow shadow = *iter;
  867. #ifdef DEBUG_ECLIPSE_SHADOWS
  868.         // Eclipse debugging: render the central axis of the eclipse
  869.         // shadow volume.
  870.         glDisable(GL_TEXTURE_2D);
  871.         glColor4f(1, 0, 0, 1);
  872.         Point3f blorp = shadow.origin * planetMat;
  873.         Vec3f blah = shadow.direction * planetMat;
  874.         blorp.x /= planetRadius; blorp.y /= planetRadius; blorp.z /= planetRadius;
  875.         float foo = blorp.distanceFromOrigin();
  876.         glBegin(GL_LINES);
  877.         glVertex(blorp);
  878.         glVertex(blorp + foo * blah);
  879.         glEnd();
  880.         glEnable(GL_TEXTURE_2D);
  881. #endif
  883.         // Determine which eclipse shadow texture to use.  This is only
  884.         // a very rough approximation to reality.  Since there are an
  885.         // infinite number of possible eclipse volumes, what we should be
  886.         // doing is generating the eclipse textures on the fly using
  887.         // render-to-texture.  But for now, we'll just choose from a fixed
  888.         // set of eclipse shadow textures based on the relative size of
  889.         // the umbra and penumbra.
  890.         Texture* eclipseTex = NULL;
  891.         float umbra = shadow.umbraRadius / shadow.penumbraRadius;
  892.         if (umbra < 0.1f)
  893.             eclipseTex = eclipseShadowTextures[0];
  894.         else if (umbra < 0.35f)
  895.             eclipseTex = eclipseShadowTextures[1];
  896.         else if (umbra < 0.6f)
  897.             eclipseTex = eclipseShadowTextures[2];
  898.         else if (umbra < 0.9f)
  899.             eclipseTex = eclipseShadowTextures[3];
  900.         else
  901.             eclipseTex = shadowTex;
  903.         // Compute the transformation to use for generating texture
  904.         // coordinates from the object vertices.
  905.         Point3f origin = shadow.origin * planetMat;
  906.         Vec3f dir = shadow.direction * planetMat;
  907.         float scale = planetRadius / shadow.penumbraRadius;
  908.         Vec3f axis = Vec3f(0, 1, 0) ^ dir;
  909.         float angle = (float) acos(Vec3f(0, 1, 0) * dir);
  910.         axis.normalize();
  911.         Mat4f mat = Mat4f::rotation(axis, -angle);
  912.         Vec3f sAxis = Vec3f(0.5f * scale, 0, 0) * mat;
  913.         Vec3f tAxis = Vec3f(0, 0, 0.5f * scale) * mat;
  915.         float sPlane[4] = { 0, 0, 0, 0 };
  916.         float tPlane[4] = { 0, 0, 0, 0 };
  917.         sPlane[0] = sAxis.x; sPlane[1] = sAxis.y; sPlane[2] = sAxis.z;
  918.         tPlane[0] = tAxis.x; tPlane[1] = tAxis.y; tPlane[2] = tAxis.z;
  919.         sPlane[3] = (Point3f(0, 0, 0) - origin) * sAxis / planetRadius + 0.5f;
  920.         tPlane[3] = (Point3f(0, 0, 0) - origin) * tAxis / planetRadius + 0.5f;
  922.         // TODO: Multiple eclipse shadows should be rendered in a single
  923.         // pass using multitexture.
  924.         if (eclipseTex != NULL)
  925.             eclipseTex->bind();
  926.         // shadowMaskTexture->bind();
  927.         glEnable(GL_BLEND);
  928.         glBlendFunc(GL_ZERO, GL_SRC_COLOR);
  930.         // If the ambient light level is greater than zero, reduce the
  931.         // darkness of the shadows.
  932.         if (ri.useTexEnvCombine)
  933.         {
  934.             float color[4] = { ri.ambientColor.red(), ri.ambientColor.green(),
  935.                                ri.ambientColor.blue(), 1.0f };
  936.             glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
  937.             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
  938.             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_CONSTANT_EXT);
  939.             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
  940.             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE);
  941.             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
  942.             glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD);
  944.             // The second texture unit has the shadow 'mask'
  945.             glx::glActiveTextureARB(GL_TEXTURE1_ARB);
  946.             glEnable(GL_TEXTURE_2D);
  947.             shadowMaskTexture->bind();
  948.             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
  949.             glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD);
  950.             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_PREVIOUS_EXT);
  951.             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
  952.             glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE);
  953.             glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
  954.             glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  955.         }
  957.         // Since invariance between nVidia's vertex programs and the
  958.         // standard transformation pipeline isn't guaranteed, we have to
  959.         // make sure to use the same transformation engine on subsequent
  960.         // rendering passes as we did on the initial one.
  961.         if (context.getVertexPath() != GLContext::VPath_Basic && geometry == NULL)
  962.         {
  963.             renderShadowedGeometryVertexShader(ri, viewFrustum,
  964.                                            sPlane, tPlane,
  965.                                            dir,
  966.                                            context);
  967.         }
  968.         else
  969.         {
  970.             renderShadowedGeometryDefault(geometry, ri, viewFrustum,
  971.                                        sPlane, tPlane,
  972.                                        dir,
  973.                                        ri.useTexEnvCombine,
  974.                                        context);
  975.         }
  977.         if (ri.useTexEnvCombine)
  978.         {
  979.             // Disable second texture unit
  980.             glx::glActiveTextureARB(GL_TEXTURE1_ARB);
  981.             glDisable(GL_TEXTURE_2D);
  982.             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  983.             glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  985.             float color[4] = { 0, 0, 0, 0 };
  986.             glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
  987.             glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  988.         }
  990.         glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  991.         glDisable(GL_BLEND);
  992.     }
  993. }
  996. static void
  997. renderEclipseShadows_Shaders(Geometry* geometry,
  998.                              vector<EclipseShadow>& eclipseShadows,
  999.                              RenderInfo& ri,
  1000.                              float planetRadius,
  1001.                              Mat4f& planetMat,
  1002.                              Frustum& viewFrustum,
  1003.                              const GLContext& context)
  1004. {
  1005.     // Eclipse shadows on mesh objects aren't working yet.
  1006.     if (geometry != NULL)
  1007.         return;
  1009.     glEnable(GL_TEXTURE_2D);
  1010.     penumbraFunctionTexture->bind();
  1012.     glEnable(GL_BLEND);
  1013.     glBlendFunc(GL_ZERO, GL_SRC_COLOR);
  1015.     float sPlanes[4][4];
  1016.     float tPlanes[4][4];
  1017.     float shadowParams[4][4];
  1019.     int n = 0;
  1020.     for (vector<EclipseShadow>::iterator iter = eclipseShadows.begin();
  1021.          iter != eclipseShadows.end() && n < 4; iter++, n++)
  1022.     {
  1023.         EclipseShadow shadow = *iter;
  1025.         float R2 = 0.25f;
  1026.         float umbra = shadow.umbraRadius / shadow.penumbraRadius;
  1027.         umbra = umbra * umbra;
  1028.         if (umbra < 0.0001f)
  1029.             umbra = 0.0001f;
  1030.         else if (umbra > 0.99f)
  1031.             umbra = 0.99f;
  1033.         float umbraRadius = R2 * umbra;
  1034.         float penumbraRadius = R2;
  1035.         float shadowBias = 1.0f / (1.0f - penumbraRadius / umbraRadius);
  1036.         float shadowScale = -shadowBias / umbraRadius;
  1038.         shadowParams[n][0] = shadowScale;
  1039.         shadowParams[n][1] = shadowBias;
  1040.         shadowParams[n][2] = 0.0f;
  1041.         shadowParams[n][3] = 0.0f;
  1043.         // Compute the transformation to use for generating texture
  1044.         // coordinates from the object vertices.
  1045.         Point3f origin = shadow.origin * planetMat;
  1046.         Vec3f dir = shadow.direction * planetMat;
  1047.         float scale = planetRadius / shadow.penumbraRadius;
  1048.         Vec3f axis = Vec3f(0, 1, 0) ^ dir;
  1049.         float angle = (float) acos(Vec3f(0, 1, 0) * dir);
  1050.         axis.normalize();
  1051.         Mat4f mat = Mat4f::rotation(axis, -angle);
  1052.         Vec3f sAxis = Vec3f(0.5f * scale, 0, 0) * mat;
  1053.         Vec3f tAxis = Vec3f(0, 0, 0.5f * scale) * mat;
  1055.         sPlanes[n][0] = sAxis.x;
  1056.         sPlanes[n][1] = sAxis.y;
  1057.         sPlanes[n][2] = sAxis.z;
  1058.         sPlanes[n][3] = (Point3f(0, 0, 0) - origin) * sAxis / planetRadius + 0.5f;
  1059.         tPlanes[n][0] = tAxis.x;
  1060.         tPlanes[n][1] = tAxis.y;
  1061.         tPlanes[n][2] = tAxis.z;
  1062.         tPlanes[n][3] = (Point3f(0, 0, 0) - origin) * tAxis / planetRadius + 0.5f;
  1063.     }
  1066.     VertexProcessor* vproc = context.getVertexProcessor();
  1067.     FragmentProcessor* fproc = context.getFragmentProcessor();
  1069.     vproc->enable();
  1070.     vproc->use(vp::multiShadow);
  1072.     fproc->enable();
  1073.     if (n == 1)
  1074.         fproc->use(fp::eclipseShadow1);
  1075.     else
  1076.         fproc->use(fp::eclipseShadow2);
  1078.     fproc->parameter(fp::ShadowParams0, shadowParams[0]);
  1079.     vproc->parameter(vp::TexGen_S, sPlanes[0]);
  1080.     vproc->parameter(vp::TexGen_T, tPlanes[0]);
  1081.     if (n >= 2)
  1082.     {
  1083.         fproc->parameter(fp::ShadowParams1, shadowParams[1]);
  1084.         vproc->parameter(vp::TexGen_S2, sPlanes[1]);
  1085.         vproc->parameter(vp::TexGen_T2, tPlanes[1]);
  1086.     }
  1087.     if (n >= 3)
  1088.     {
  1089.         //fproc->parameter(fp::ShadowParams2, shadowParams[2]);
  1090.         vproc->parameter(vp::TexGen_S3, sPlanes[2]);
  1091.         vproc->parameter(vp::TexGen_T3, tPlanes[2]);
  1092.     }
  1093.     if (n >= 4)
  1094.     {
  1095.         //fproc->parameter(fp::ShadowParams3, shadowParams[3]);
  1096.         vproc->parameter(vp::TexGen_S4, sPlanes[3]);
  1097.         vproc->parameter(vp::TexGen_T4, tPlanes[3]);
  1098.     }
  1100.     //vproc->parameter(vp::LightDirection0, lightDir);
  1102.     g_lodSphere->render(context,
  1103.                         LODSphereMesh::Normals | LODSphereMesh::Multipass,
  1104.                         viewFrustum,
  1105.                         ri.pixWidth, NULL);
  1107.     vproc->disable();
  1108.     fproc->disable();
  1110.     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  1111.     glDisable(GL_BLEND);
  1112. }
  1115. static void
  1116. renderRingShadowsVS(Geometry* /*geometry*/,           //TODO: Remove unused parameters??
  1117.                     const RingSystem& rings,
  1118.                     const Vec3f& /*sunDir*/,
  1119.                     RenderInfo& ri,
  1120.                     float planetRadius,
  1121.                     float /*oblateness*/,
  1122.                     Mat4f& /*planetMat*/,
  1123.                     Frustum& viewFrustum,
  1124.                     const GLContext& context)
  1125. {
  1126.     // Compute the transformation to use for generating texture
  1127.     // coordinates from the object vertices.
  1128.     float ringWidth = rings.outerRadius - rings.innerRadius;
  1129.     float s = ri.sunDir_obj.y;
  1130.     float scale = (abs(s) < 0.001f) ? 1000.0f : 1.0f / s;
  1132.     if (abs(s) > 1.0f - 1.0e-4f)
  1133.     {
  1134.         // Planet is illuminated almost directly from above, so
  1135.         // no ring shadow will be cast on the planet.  Conveniently
  1136.         // avoids some potential division by zero when ray-casting.
  1137.         return;
  1138.     }
  1140.     glEnable(GL_BLEND);
  1141.     glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
  1143.     // If the ambient light level is greater than zero, reduce the
  1144.     // darkness of the shadows.
  1145.     float color[4] = { ri.ambientColor.red(), ri.ambientColor.green(),
  1146.                        ri.ambientColor.blue(), 1.0f };
  1147.     glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
  1148.     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
  1149.     glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_CONSTANT_EXT);
  1150.     glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
  1151.     glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE);
  1152.     glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
  1153.     glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD);
  1155.     // Tweak the texture--set clamp to border and a border color with
  1156.     // a zero alpha.  If a graphics card doesn't support clamp to border,
  1157.     // it doesn't get to play.  It's possible to get reasonable behavior
  1158.     // by turning off mipmaps and assuming transparent rows of pixels for
  1159.     // the top and bottom of the ring textures . . . maybe later.
  1160.     float bc[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
  1161.     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, bc);
  1162.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER_ARB);
  1164.     // Ring shadows look strange if they're always completely black.  Vary
  1165.     // the darkness of the shadow based on the angle between the sun and the
  1166.     // ring plane.  There's some justification for this--the larger the angle
  1167.     // between the sun and the ring plane (normal), the more ring material
  1168.     // there is to travel through.
  1169.     //float alpha = (1.0f - abs(ri.sunDir_obj.y)) * 1.0f;
  1170.     // ...but, images from Cassini are showing very dark ring shadows, so we'll
  1171.     // go with that.
  1172.     float alpha = 1.0f;
  1174.     VertexProcessor* vproc = context.getVertexProcessor();
  1175.     assert(vproc != NULL);
  1177.     vproc->enable();
  1178.     vproc->use(vp::ringShadow);
  1179.     vproc->parameter(vp::LightDirection0, ri.sunDir_obj);
  1180.     vproc->parameter(vp::DiffuseColor0, 1, 1, 1, alpha); // color = white
  1181.     vproc->parameter(vp::TexGen_S,
  1182.                      rings.innerRadius / planetRadius,
  1183.                      1.0f / (ringWidth / planetRadius),
  1184.                      0.0f, 0.5f);
  1185.     vproc->parameter(vp::TexGen_T, scale, 0, 0, 0);
  1186.     g_lodSphere->render(context, LODSphereMesh::Multipass,
  1187.                         viewFrustum, ri.pixWidth, NULL);
  1188.     vproc->disable();
  1190.     // Restore the texture combiners
  1191.     if (ri.useTexEnvCombine)
  1192.     {
  1193.         float color[4] = { 0, 0, 0, 0 };
  1194.         glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
  1195.         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  1196.     }
  1198.     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  1199.     glDisable(GL_BLEND);
  1200. }
  1203. void Renderer::renderLocations(const Body& body,
  1204.                                const Vec3d& bodyPosition,
  1205.                                const Quatd& bodyOrientation)
  1206. {
  1207.     const vector<Location*>* locations = body.getLocations();
  1208.     if (locations == NULL)
  1209.         return;
  1210.     
  1211.     Vec3f semiAxes = body.getSemiAxes();
  1212.     
  1213.     float nearDist = getNearPlaneDistance();
  1214.     double boundingRadius = max(semiAxes.x, max(semiAxes.y, semiAxes.z));
  1216.     Vec3d bodyCenter(bodyPosition.x, bodyPosition.y, bodyPosition.z);
  1217.     Vec3d viewRayOrigin = -bodyCenter * (~bodyOrientation).toMatrix3();
  1218.     double labelOffset = 0.0001;
  1220.     Vec3f vn  = Vec3f(0.0f, 0.0f, -1.0f) * getCameraOrientation().toMatrix3();
  1221.     Vec3d viewNormal(vn.x, vn.y, vn.z);
  1222.     
  1223.     Ellipsoidd bodyEllipsoid(Vec3d(semiAxes.x, semiAxes.y, semiAxes.z));
  1224.     
  1225.     Mat3d bodyMatrix = bodyOrientation.toMatrix3();
  1226.     
  1227.     for (vector<Location*>::const_iterator iter = locations->begin();
  1228.          iter != locations->end(); iter++)
  1229.     {
  1230.         const Location& location = **iter;
  1231.         
  1232.         if (location.getFeatureType() & locationFilter)
  1233.         {
  1234.             // Get the position of the location with respect to the planet center
  1235.             Vec3f ppos = location.getPosition();
  1236.             
  1237.             // Compute the bodycentric position of the location
  1238.             Vec3d locPos = Vec3d(ppos.x, ppos.y, ppos.z);
  1239.             
  1240.             // Get the planetocentric position of the label.  Add a slight scale factor
  1241.             // to keep the point from being exactly on the surface.
  1242.             Vec3d pcLabelPos = locPos * (1.0 + labelOffset);
  1243.             
  1244.             // Get the camera space label position
  1245.             Vec3d labelPos = bodyCenter + locPos * bodyMatrix;
  1246.             
  1247.             float effSize = location.getImportance();
  1248.             if (effSize < 0.0f)
  1249.                 effSize = location.getSize();
  1250.             
  1251.             float pixSize = effSize / (float) (labelPos.length() * pixelSize);
  1252.             
  1253.             if (pixSize > minFeatureSize && labelPos * viewNormal > 0.0)
  1254.             {
  1255.                 // Labels on non-ellipsoidal bodies need special handling; the
  1256.                 // ellipsoid visibility test will always fail for them, since they
  1257.                 // will lie on the surface of the mesh, which is inside the
  1258.                 // the bounding ellipsoid. The following code projects location positions
  1259.                 // onto the bounding sphere.
  1260.                 if (!body.isEllipsoid())
  1261.                 {
  1262.                     double r = locPos.length();
  1263.                     if (r < boundingRadius)
  1264.                         pcLabelPos = locPos * (boundingRadius * 1.01 / r);
  1265.                 }
  1266.                 
  1267.                 double t = 0.0;
  1268.                 
  1269.                 // Test for an intersection of the eye-to-location ray with
  1270.                 // the planet ellipsoid.  If we hit the planet first, then
  1271.                 // the label is obscured by the planet.  An exact calculation
  1272.                 // for irregular objects would be too expensive, and the
  1273.                 // ellipsoid approximation works reasonably well for them.
  1274.                 Ray3d testRay(Point3d(viewRayOrigin.x, viewRayOrigin.y, viewRayOrigin.z),
  1275.                               pcLabelPos - viewRayOrigin);
  1276.                 bool hit = testIntersection(testRay, bodyEllipsoid, t);
  1277.                 Vec3d blah = labelPos - viewRayOrigin;
  1279.                 if (!hit || t >= 1.0)
  1280.                 {                    
  1281.                     // Calculate the intersection of the eye-to-label ray with the plane perpendicular to
  1282.                     // the view normal that touches the front of the object's bounding sphere
  1283.                     double planetZ = viewNormal * bodyCenter - boundingRadius;
  1284.                     if (planetZ < -nearDist * 1.001)
  1285.                         planetZ = -nearDist * 1.001;
  1286.                     double z = viewNormal * labelPos;
  1287.                     labelPos *= planetZ / z;
  1288.                                         
  1289.                     uint32 featureType = location.getFeatureType();
  1290.                     MarkerRepresentation* locationMarker = NULL;
  1291.                     if (featureType & Location::City)
  1292.                         locationMarker = &cityRep;
  1293.                     else if (featureType & (Location::LandingSite | Location::Observatory))
  1294.                         locationMarker = &observatoryRep;
  1295.                     else if (featureType & (Location::Crater | Location::Patera))
  1296.                         locationMarker = &craterRep;
  1297.                     else if (featureType & (Location::Mons | Location::Tholus))
  1298.                         locationMarker = &mountainRep;
  1299.                     else if (featureType & (Location::EruptiveCenter))
  1300.                         locationMarker = &genericLocationRep;
  1302.                     Color labelColor = location.isLabelColorOverridden() ? location.getLabelColor() : LocationLabelColor;
  1303.                     addObjectAnnotation(locationMarker,
  1304.                                         location.getName(true),
  1305.                                         labelColor,
  1306.                                         Point3f((float) labelPos.x, (float) labelPos.y, (float) labelPos.z));
  1307.                 }
  1308.             }
  1309.         }
  1310.     }    
  1311. }
  1314. // Estimate the fraction of light reflected from a sphere that
  1315. // reaches an object at the specified position relative to that
  1316. // sphere.
  1317. //
  1318. // This is function is just a rough approximation to the actual
  1319. // lighting integral, but it reproduces the important features
  1320. // of the way that phase and distance affect reflected light:
  1321. //    - Higher phase angles mean less reflected light
  1322. //    - The closer an object is to the reflector, the less
  1323. //      area of the reflector that is visible.
  1324. //
  1325. // We approximate the reflected light by taking a weighted average
  1326. // of the reflected light at three points on the reflector: the
  1327. // light receiver's sub-point, and the two horizon points in the
  1328. // plane of the light vector and receiver-to-reflector vector.
  1329. //
  1330. // The reflecting object is assumed to be spherical and perfectly
  1331. // Lambertian.
  1332. static float
  1333. estimateReflectedLightFraction(const Vec3d& toSun,
  1334.                                const Vec3d& toObject,
  1335.                                float radius)
  1336. {
  1337.     // Theta is half the arc length visible to the reflector
  1338.     double d = toObject.length();
  1339.     float cosTheta = (float) (radius / d);
  1340.     if (cosTheta > 0.999f)
  1341.         cosTheta = 0.999f;
  1343.     // Phi is the angle between the light vector and receiver-to-reflector vector.
  1344.     // cos(phi) is thus the illumination at the sub-point. The horizon points are
  1345.     // at phi+theta and phi-theta.
  1346.     float cosPhi = (float) ((toSun * toObject) / (d * toSun.length()));
  1348.     // Use a trigonometric identity to compute cos(phi +/- theta):
  1349.     //   cos(phi + theta) = cos(phi) * cos(theta) - sin(phi) * sin(theta)
  1351.     // s = sin(phi) * sin(theta)
  1352.     float s = (float) sqrt((1.0f - cosPhi * cosPhi) * (1.0f - cosTheta * cosTheta));
  1353.     
  1354.     float cosPhi1 = cosPhi * cosTheta - s;  // cos(phi + theta)
  1355.     float cosPhi2 = cosPhi * cosTheta + s;  // cos(phi - theta)
  1357.     // Calculate a weighted average of illumination at the three points
  1358.     return (2.0f * max(cosPhi, 0.0f) + max(cosPhi1, 0.0f) + max(cosPhi2, 0.0f)) * 0.25f;
  1359. }
  1362. static void
  1363. setupObjectLighting(const vector<LightSource>& suns,
  1364.                     const vector<SecondaryIlluminator>& secondaryIlluminators,
  1365.                     const Quatf& objOrientation,
  1366.                     const Vec3f& objScale,
  1367.                     const Point3f& objPosition_eye,
  1368.                     bool isNormalized,
  1369. #ifdef USE_HDR
  1370.                     const float faintestMag,
  1371.                     const float saturationMag,
  1372.                     const float appMag,
  1373. #endif
  1374.                     LightingState& ls)
  1375. {
  1376.     unsigned int nLights = min(MaxLights, (unsigned int) suns.size());
  1377.     if (nLights == 0)
  1378.         return;
  1380. #ifdef USE_HDR
  1381.     float exposureFactor = (faintestMag - appMag)/(faintestMag - saturationMag + 0.001f);
  1382. #endif
  1384.     unsigned int i;
  1385.     for (i = 0; i < nLights; i++)
  1386.     {
  1387.         Vec3d dir = suns[i].position - Vec3d(objPosition_eye.x, objPosition_eye.y, objPosition_eye.z);
  1389.         ls.lights[i].direction_eye =
  1390.             Vec3f((float) dir.x, (float) dir.y, (float) dir.z);
  1391.         float distance = ls.lights[i].direction_eye.length();
  1392.         ls.lights[i].direction_eye *= 1.0f / distance;
  1393.         distance = astro::kilometersToAU((float) dir.length());
  1394.         ls.lights[i].irradiance = suns[i].luminosity / (distance * distance);
  1395.         ls.lights[i].color = suns[i].color;
  1397.         // Store the position and apparent size because we'll need them for
  1398.         // testing for eclipses.
  1399.         ls.lights[i].position = dir;
  1400.         ls.lights[i].apparentSize = (float) (suns[i].radius / dir.length());
  1401.         ls.lights[i].castsShadows = true;
  1402.     }
  1404.     // Include effects of secondary illumination (i.e. planetshine)
  1405.     if (!secondaryIlluminators.empty() && i < MaxLights - 1)
  1406.     {
  1407.         float maxIrr = 0.0f;
  1408.         unsigned int maxIrrSource = 0;
  1409.         Vec3d objpos(objPosition_eye.x, objPosition_eye.y, objPosition_eye.z);
  1411.         // Only account for light from the brightest secondary source
  1412.         for (vector<SecondaryIlluminator>::const_iterator iter = secondaryIlluminators.begin();
  1413.              iter != secondaryIlluminators.end(); iter++)
  1414.         {
  1415.             Vec3d toIllum = iter->position_v - objpos;  // reflector-to-object vector
  1416.             float distSquared = (float) toIllum.lengthSquared() / square(iter->radius);
  1418.             if (distSquared > 0.01f)
  1419.             {
  1420.                 // Irradiance falls off with distance^2
  1421.                 float irr = iter->reflectedIrradiance / distSquared;
  1423.                 // Phase effects will always leave the irradiance unaffected or reduce it;
  1424.                 // don't bother calculating them if we've already found a brighter secondary
  1425.                 // source.
  1426.                 if (irr > maxIrr)
  1427.                 {
  1428.                     // Account for the phase
  1429.                     Vec3d toSun = objpos - suns[0].position;
  1430.                     irr *= estimateReflectedLightFraction(toSun, toIllum, iter->radius);              
  1431.                     if (irr > maxIrr)
  1432.                     {
  1433.                         maxIrr = irr;
  1434.                         maxIrrSource = iter - secondaryIlluminators.begin();
  1435.                     }
  1436.                 }
  1437.             }
  1438.         }
  1439. #if DEBUG_SECONDARY_ILLUMINATION      
  1440.         clog << "maxIrr = " << maxIrr << ", "
  1441.              << secondaryIlluminators[maxIrrSource].body->getName() << ", "
  1442.              << secondaryIlluminators[maxIrrSource].reflectedIrradiance << endl;
  1443. #endif
  1445.         if (maxIrr > 0.0f)
  1446.         {
  1447.             Vec3d toIllum = secondaryIlluminators[maxIrrSource].position_v - objpos;
  1449.             ls.lights[i].direction_eye = Vec3f((float) toIllum.x, (float) toIllum.y, (float) toIllum.z);
  1450.             ls.lights[i].direction_eye.normalize();
  1451.             ls.lights[i].irradiance = maxIrr;
  1452.             ls.lights[i].color = secondaryIlluminators[maxIrrSource].body->getSurface().color;        
  1453.             ls.lights[i].apparentSize = 0.0f;
  1454.             ls.lights[i].castsShadows = false;
  1455.             i++;
  1456.             nLights++;
  1457.         }
  1458.     }
  1460.     // Sort light sources by brightness.  Light zero should always be the
  1461.     // brightest.  Optimize common cases of one and two lights.
  1462.     if (nLights == 2)
  1463.     {
  1464.         if (ls.lights[0].irradiance < ls.lights[1].irradiance)
  1465.             swap(ls.lights[0], ls.lights[1]);
  1466.     }
  1467.     else if (nLights > 2)
  1468.     {
  1469.         sort(ls.lights, ls.lights + nLights, LightIrradiancePredicate());
  1470.     }
  1472.     // Compute the total irradiance
  1473.     float totalIrradiance = 0.0f;
  1474.     for (i = 0; i < nLights; i++)
  1475.         totalIrradiance += ls.lights[i].irradiance;
  1477.     // Compute a gamma factor to make dim light sources visible.  This is
  1478.     // intended to approximate what we see with our eyes--for example,
  1479.     // Earth-shine is visible on the night side of the Moon, even though
  1480.     // the amount of reflected light from the Earth is 1/10000 of what
  1481.     // the Moon receives directly from the Sun.
  1482.     //
  1483.     // TODO: Skip this step when high dynamic range rendering to floating point
  1484.     //   buffers is enabled.
  1485.     float minVisibleFraction = 1.0f / 10000.0f;
  1486.     float minDisplayableValue = 1.0f / 255.0f;
  1487.     float gamma = (float) (log(minDisplayableValue) / log(minVisibleFraction));
  1488.     float minVisibleIrradiance = minVisibleFraction * totalIrradiance;
  1490.     Mat3f m = (~objOrientation).toMatrix3();
  1492.     // Gamma scale and normalize the light sources; cull light sources that
  1493.     // aren't bright enough to contribute the final pixels rendered into the
  1494.     // frame buffer.
  1495.     ls.nLights = 0;
  1496.     for (i = 0; i < nLights && ls.lights[i].irradiance > minVisibleIrradiance; i++)
  1497.     {
  1498. #ifdef USE_HDR
  1499.         ls.lights[i].irradiance *= exposureFactor / totalIrradiance;
  1500. #else
  1501.         ls.lights[i].irradiance =
  1502.             (float) pow(ls.lights[i].irradiance / totalIrradiance, gamma);
  1503. #endif
  1505.         // Compute the direction of the light in object space
  1506.         ls.lights[i].direction_obj = ls.lights[i].direction_eye * m;
  1508.         ls.nLights++;
  1509.     }
  1511.     ls.eyePos_obj = Point3f(-objPosition_eye.x / objScale.x,
  1512.                             -objPosition_eye.y / objScale.y,
  1513.                             -objPosition_eye.z / objScale.z) * m;
  1514.     ls.eyeDir_obj = (Point3f(0.0f, 0.0f, 0.0f) - objPosition_eye) * m;
  1515.     ls.eyeDir_obj.normalize();
  1517.     // When the camera is very far from the object, some view-dependent
  1518.     // calculations in the shaders can exhibit precision problems. This
  1519.     // occurs with atmospheres, where the scale height of the atmosphere
  1520.     // is very small relative to the planet radius. To address the problem,
  1521.     // we'll clamp the eye distance to some maximum value. The effect of the
  1522.     // adjustment should be impercetible, since at large distances rays from
  1523.     // the camera to object vertices are all nearly parallel to each other.
  1524.     float eyeFromCenterDistance = ls.eyePos_obj.distanceFromOrigin();
  1525.     if (eyeFromCenterDistance > 100.0f && isNormalized)
  1526.     {
  1527.         float s = 100.0f / eyeFromCenterDistance;
  1528.         ls.eyePos_obj.x *= s;
  1529.         ls.eyePos_obj.y *= s;
  1530.         ls.eyePos_obj.z *= s;
  1531.     }
  1533.     ls.ambientColor = Vec3f(0.0f, 0.0f, 0.0f);
  1535. #if 0
  1536.     // Old code: linear scaling approach
  1538.     // After sorting, the first light is always the brightest
  1539.     float maxIrradiance = ls.lights[0].irradiance;
  1541.     // Normalize the brightnesses of the light sources.
  1542.     // TODO: Investigate logarithmic functions for scaling light brightness, to
  1543.     //   better simulate what the human eye would see.
  1544.     ls.nLights = 0;
  1545.     for (i = 0; i < nLights; i++)
  1546.     {
  1547.         ls.lights[i].irradiance /= maxIrradiance;
  1549.         // Cull light sources that don't contribute significantly (less than
  1550.         // the resolution of an 8-bit color channel.)
  1551.         if (ls.lights[i].irradiance < 1.0f / 255.0f)
  1552.             break;
  1554.         // Compute the direction of the light in object space
  1555.         ls.lights[i].direction_obj = ls.lights[i].direction_eye * m;
  1557.         ls.nLights++;
  1558.     }
  1559. #endif
  1560. }
  1563. void Renderer::renderObject(Point3f pos,
  1564.                             float distance,
  1565.                             double now,
  1566.                             Quatf cameraOrientation,
  1567.                             float nearPlaneDistance,
  1568.                             float farPlaneDistance,
  1569.                             RenderProperties& obj,
  1570.                             const LightingState& ls)
  1571. {
  1572.     RenderInfo ri;
  1574.     float altitude = distance - obj.radius;
  1575.     float discSizeInPixels = obj.radius /
  1576.         (max(nearPlaneDistance, altitude) * pixelSize);
  1578.     ri.sunDir_eye = Vec3f(0.0f, 1.0f, 0.0f);
  1579.     ri.sunDir_obj = Vec3f(0.0f, 1.0f, 0.0f);
  1580.     ri.sunColor = Color(0.0f, 0.0f, 0.0f);
  1581.     if (ls.nLights > 0)
  1582.     {
  1583.         ri.sunDir_eye = ls.lights[0].direction_eye;
  1584.         ri.sunDir_obj = ls.lights[0].direction_obj;
  1585.         ri.sunColor   = ls.lights[0].color;// * ls.lights[0].intensity;
  1586.     }
  1588.     // Enable depth buffering
  1589.     glEnable(GL_DEPTH_TEST);
  1590.     glDepthMask(GL_TRUE);
  1592.     glDisable(GL_BLEND);
  1594.     // Get the object's geometry; NULL indicates that object is an
  1595.     // ellipsoid.
  1596.     Geometry* geometry = NULL;
  1597.     if (obj.geometry != InvalidResource)
  1598.     {
  1599.         // This is a model loaded from a file
  1600.         geometry = GetGeometryManager()->find(obj.geometry);
  1601.     }
  1603.     // Get the textures . . .
  1604.     if (obj.surface->baseTexture.tex[textureResolution] != InvalidResource)
  1605.         ri.baseTex = obj.surface->baseTexture.find(textureResolution);
  1606.     if ((obj.surface->appearanceFlags & Surface::ApplyBumpMap) != 0 &&
  1607.         context->bumpMappingSupported() &&
  1608.         obj.surface->bumpTexture.tex[textureResolution] != InvalidResource)
  1609.         ri.bumpTex = obj.surface->bumpTexture.find(textureResolution);
  1610.     if ((obj.surface->appearanceFlags & Surface::ApplyNightMap) != 0 &&
  1611.         (renderFlags & ShowNightMaps) != 0)
  1612.         ri.nightTex = obj.surface->nightTexture.find(textureResolution);
  1613.     if ((obj.surface->appearanceFlags & Surface::SeparateSpecularMap) != 0)
  1614.         ri.glossTex = obj.surface->specularTexture.find(textureResolution);
  1615.     if ((obj.surface->appearanceFlags & Surface::ApplyOverlay) != 0)
  1616.         ri.overlayTex = obj.surface->overlayTexture.find(textureResolution);
  1618.     // Apply the modelview transform for the object
  1619.     glPushMatrix();
  1620.     glTranslate(pos);
  1621.     glRotate(~obj.orientation);
  1623.     // Scaling will be nonuniform for nonspherical planets. As long as the
  1624.     // deviation from spherical isn't too large, the nonuniform scale factor
  1625.     // shouldn't mess up the lighting calculations enough to be noticeable
  1626.     // (and we turn on renormalization anyhow, which most graphics cards
  1627.     // support.)
  1628.     float radius = obj.radius;
  1629.     Vec3f scaleFactors;
  1630.     float geometryScale;
  1631.     if (geometry == NULL || geometry->isNormalized())
  1632.     {
  1633.         geometryScale = obj.radius;
  1634.         scaleFactors = obj.radius * obj.semiAxes;
  1635.         ri.pointScale = 2.0f * obj.radius / pixelSize;
  1636.     }
  1637.     else
  1638.     {
  1639.         geometryScale = obj.geometryScale;
  1640.         scaleFactors = Vec3f(geometryScale, geometryScale, geometryScale);
  1641.         ri.pointScale = 2.0f * geometryScale / pixelSize;
  1642.     }
  1643.     glScale(scaleFactors);
  1645.     Mat4f planetMat = (~obj.orientation).toMatrix4();
  1646.     ri.eyeDir_obj = (Point3f(0, 0, 0) - pos) * planetMat;
  1647.     ri.eyeDir_obj.normalize();
  1648.     ri.eyePos_obj = Point3f(-pos.x / scaleFactors.x,
  1649.                             -pos.y / scaleFactors.y,
  1650.                             -pos.z / scaleFactors.z) * planetMat;
  1652.     ri.orientation = cameraOrientation * ~obj.orientation;
  1654.     ri.pixWidth = discSizeInPixels;
  1656.     // Set up the colors
  1657.     if (ri.baseTex == NULL ||
  1658.         (obj.surface->appearanceFlags & Surface::BlendTexture) != 0)
  1659.     {
  1660.         ri.color = obj.surface->color;
  1661.     }
  1663.     ri.ambientColor = ambientColor;
  1664.     ri.hazeColor = obj.surface->hazeColor;
  1665.     ri.specularColor = obj.surface->specularColor;
  1666.     ri.specularPower = obj.surface->specularPower;
  1667.     ri.useTexEnvCombine = context->getRenderPath() != GLContext::GLPath_Basic;
  1668.     ri.lunarLambert = obj.surface->lunarLambert;
  1669. #ifdef USE_HDR
  1670.     ri.nightLightScale = obj.surface->nightLightRadiance * exposure * 1.e5f * .5f;
  1671. #endif
  1673.     // See if the surface should be lit
  1674.     bool lit = (obj.surface->appearanceFlags & Surface::Emissive) == 0;
  1676.     // Set the OpenGL light state
  1677.     unsigned int i;
  1678.     for (i = 0; i < ls.nLights; i++)
  1679.     {
  1680.         const DirectionalLight& light = ls.lights[i];
  1682.         glLightDirection(GL_LIGHT0 + i, ls.lights[i].direction_obj);
  1684.         // RANT ALERT!
  1685.         // This sucks, but it's necessary.  glScale is used to scale a unit
  1686.         // sphere up to planet size.  Since normals are transformed by the
  1687.         // inverse transpose of the model matrix, this means they end up
  1688.         // getting scaled by a factor of 1.0 / planet radius (in km).  This
  1689.         // has terrible effects on lighting: the planet appears almost
  1690.         // completely dark.  To get around this, the GL_rescale_normal
  1691.         // extension was introduced and eventually incorporated into into the
  1692.         // OpenGL 1.2 standard.  Of course, not everyone implemented this
  1693.         // incredibly simple and essential little extension.  Microsoft is
  1694.         // notorious for half-assed support of OpenGL, but 3dfx should have
  1695.         // known better: no Voodoo 1/2/3 drivers seem to support this
  1696.         // extension.  The following is an attempt to get around the problem by
  1697.         // scaling the light brightness by the planet radius.  According to the
  1698.         // OpenGL spec, this should work fine, as clamping of colors to [0, 1]
  1699.         // occurs *after* lighting.  It works fine on my GeForce3 when I
  1700.         // disable EXT_rescale_normal, but I'm not certain whether other
  1701.         // drivers are as well behaved as nVidia's.
  1702.         //
  1703.         // Addendum: Unsurprisingly, using color values outside [0, 1] produces
  1704.         // problems on Savage4 cards.
  1706.         Vec3f lightColor = Vec3f(light.color.red(),
  1707.                                  light.color.green(),
  1708.                                  light.color.blue()) * light.irradiance;
  1709.         if (useRescaleNormal)
  1710.         {
  1711.             glLightColor(GL_LIGHT0 + i, GL_DIFFUSE, lightColor);
  1712.             glLightColor(GL_LIGHT0 + i, GL_SPECULAR, lightColor);
  1713.         }
  1714.         else
  1715.         {
  1716.             glLightColor(GL_LIGHT0 + i, GL_DIFFUSE, lightColor * radius);
  1717.         }
  1718.         glEnable(GL_LIGHT0 + i);
  1719.     }
  1721.     // Compute the inverse model/view matrix
  1722.     Mat4f invMV = (cameraOrientation.toMatrix4() *
  1723.                    Mat4f::translation(Point3f(-pos.x, -pos.y, -pos.z)) *
  1724.                    planetMat *
  1725.                    Mat4f::scaling(1.0f / radius));
  1727.     // The sphere rendering code uses the view frustum to determine which
  1728.     // patches are visible. In order to avoid rendering patches that can't
  1729.     // be seen, make the far plane of the frustum as close to the viewer
  1730.     // as possible.
  1731.     float frustumFarPlane = farPlaneDistance;
  1732.     if (obj.geometry == InvalidResource)
  1733.     {
  1734.         // Only adjust the far plane for ellipsoidal objects
  1735.         float d = pos.distanceFromOrigin();
  1737.         // Account for non-spherical objects
  1738.         float eradius = min(scaleFactors.x, min(scaleFactors.y, scaleFactors.z));
  1740.         if (d > eradius)
  1741.         {
  1742.             // Include a fudge factor to eliminate overaggressive clipping
  1743.             // due to limited floating point precision
  1744.             frustumFarPlane = (float) sqrt(square(d) - square(eradius)) * 1.1f;
  1745.         }
  1746.         else
  1747.         {
  1748.             // We're inside the bounding sphere; leave the far plane alone
  1749.         }
  1751.         if (obj.atmosphere != NULL)
  1752.         {
  1753.             float atmosphereHeight = max(obj.atmosphere->cloudHeight,
  1754.                                          obj.atmosphere->mieScaleHeight * (float) -log(AtmosphereExtinctionThreshold));
  1755.             if (atmosphereHeight > 0.0f)
  1756.             {
  1757.                 // If there's an atmosphere, we need to move the far plane
  1758.                 // out so that the clouds and atmosphere shell aren't clipped.
  1759.                 float atmosphereRadius = eradius + atmosphereHeight;
  1760.                 frustumFarPlane += (float) sqrt(square(atmosphereRadius) -
  1761.                                                 square(eradius));
  1762.             }
  1763.         }
  1764.     }
  1766.     // Transform the frustum into object coordinates using the
  1767.     // inverse model/view matrix.
  1768.     Frustum viewFrustum(degToRad(fov),
  1769.                         (float) windowWidth / (float) windowHeight,
  1770.                         nearPlaneDistance, frustumFarPlane);
  1771.     viewFrustum.transform(invMV);
  1773.     // Get cloud layer parameters
  1774.     Texture* cloudTex       = NULL;
  1775.     Texture* cloudNormalMap = NULL;
  1776.     float cloudTexOffset    = 0.0f;
  1777.     if (obj.atmosphere != NULL)
  1778.     {
  1779.         Atmosphere* atmosphere = const_cast<Atmosphere*>(obj.atmosphere); // Ugly cast required because MultiResTexture::find() is non-const
  1780.         if ((renderFlags & ShowCloudMaps) != 0)
  1781.         {
  1782.             if (atmosphere->cloudTexture.tex[textureResolution] != InvalidResource)
  1783.                 cloudTex = atmosphere->cloudTexture.find(textureResolution);
  1784.             if (atmosphere->cloudNormalMap.tex[textureResolution] != InvalidResource)
  1785.                 cloudNormalMap = atmosphere->cloudNormalMap.find(textureResolution);
  1786.         }
  1787.         if (atmosphere->cloudSpeed != 0.0f)
  1788.             cloudTexOffset = (float) (-pfmod(now * atmosphere->cloudSpeed / (2 * PI), 1.0));
  1789.     }
  1791.     if (obj.geometry == InvalidResource)
  1792.     {
  1793.         // A null model indicates that this body is a sphere
  1794.         if (lit)
  1795.         {
  1796.             switch (context->getRenderPath())
  1797.             {
  1798.             case GLContext::GLPath_GLSL:
  1799.                 renderSphere_GLSL(ri, ls, obj.rings,
  1800.                                   const_cast<Atmosphere*>(obj.atmosphere), cloudTexOffset,
  1801.                                   obj.radius,
  1802.                                   textureResolution,
  1803.                                   renderFlags,
  1804.                                   planetMat, viewFrustum, *context);
  1805.                 break;
  1807.             case GLContext::GLPath_NV30:
  1808.                 renderSphere_FP_VP(ri, viewFrustum, *context);
  1809.                 break;
  1811.             case GLContext::GLPath_NvCombiner_ARBVP:
  1812.             case GLContext::GLPath_NvCombiner_NvVP:
  1813.                 renderSphere_Combiners_VP(ri, ls, viewFrustum, *context);
  1814.                 break;
  1816.             case GLContext::GLPath_NvCombiner:
  1817.                 renderSphere_Combiners(ri, viewFrustum, *context);
  1818.                 break;
  1820.             case GLContext::GLPath_DOT3_ARBVP:
  1821.                 renderSphere_DOT3_VP(ri, ls, viewFrustum, *context);
  1822.                 break;
  1824.             default:
  1825.                 renderSphereDefault(ri, viewFrustum, true, *context);
  1826.             }
  1827.         }
  1828.         else
  1829.         {
  1830.             renderSphereDefault(ri, viewFrustum, false, *context);
  1831.         }
  1832.     }
  1833.     else
  1834.     {
  1835.         if (geometry != NULL)
  1836.         {
  1837.             ResourceHandle texOverride = obj.surface->baseTexture.tex[textureResolution];
  1839.             if (context->getRenderPath() == GLContext::GLPath_GLSL)
  1840.             {
  1841.                 if (lit)
  1842.                 {
  1843.                     renderGeometry_GLSL(geometry,
  1844.                                         ri,
  1845.                                         texOverride,
  1846.                                         ls,
  1847.                                         obj.atmosphere,
  1848.                                         geometryScale,
  1849.                                         renderFlags,
  1850.                                         planetMat,
  1851.                                         astro::daysToSecs(now - astro::J2000));
  1852.                 }
  1853.                 else
  1854.                 {
  1855.                     renderGeometry_GLSL_Unlit(geometry,
  1856.                                               ri,
  1857.                                               texOverride,
  1858.                                               geometryScale,
  1859.                                               renderFlags,
  1860.                                               planetMat,
  1861.                                               astro::daysToSecs(now - astro::J2000));
  1862.                 }
  1864.                 for (unsigned int i = 1; i < 8;/*context->getMaxTextures();*/ i++)
  1865.                 {
  1866.                     glx::glActiveTextureARB(GL_TEXTURE0_ARB + i);
  1867.                     glDisable(GL_TEXTURE_2D);
  1868.                 }
  1869.                 glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  1870.                 glEnable(GL_TEXTURE_2D);
  1871.                 glx::glUseProgramObjectARB(0);
  1872.             }
  1873.             else
  1874.             {
  1875.                 renderModelDefault(geometry, ri, lit, texOverride);
  1876.             }
  1877.         }
  1878.     }
  1880.     if (obj.rings != NULL && distance <= obj.rings->innerRadius)
  1881.     {
  1882.         if (context->getRenderPath() == GLContext::GLPath_GLSL)
  1883.         {
  1884.             renderRings_GLSL(*obj.rings, ri, ls,
  1885.                              radius, 1.0f - obj.semiAxes.y,
  1886.                              textureResolution,
  1887.                              (renderFlags & ShowRingShadows) != 0 && lit,
  1888.                              detailOptions.ringSystemSections);
  1889.         }
  1890.         else
  1891.         {
  1892.             renderRings(*obj.rings, ri, radius, 1.0f - obj.semiAxes.y,
  1893.                         textureResolution,
  1894.                         context->getMaxTextures() > 1 &&
  1895.                         (renderFlags & ShowRingShadows) != 0 && lit,
  1896.                         *context,
  1897.                         detailOptions.ringSystemSections);
  1898.         }
  1899.     }
  1901.     if (obj.atmosphere != NULL)
  1902.     {
  1903.         Atmosphere* atmosphere = const_cast<Atmosphere *>(obj.atmosphere);
  1905.         // Compute the apparent thickness in pixels of the atmosphere.
  1906.         // If it's only one pixel thick, it can look quite unsightly
  1907.         // due to aliasing.  To avoid popping, we gradually fade in the
  1908.         // atmosphere as it grows from two to three pixels thick.
  1909.         float fade;
  1910.         float thicknessInPixels = 0.0f;
  1911.         if (distance - radius > 0.0f)
  1912.         {
  1913.             thicknessInPixels = atmosphere->height /
  1914.                 ((distance - radius) * pixelSize);
  1915.             fade = clamp(thicknessInPixels - 2);
  1916.         }
  1917.         else
  1918.         {
  1919.             fade = 1.0f;
  1920.         }
  1922.         if (fade > 0 && (renderFlags & ShowAtmospheres) != 0)
  1923.         {
  1924.             // Only use new atmosphere code in OpenGL 2.0 path when new style parameters are defined.
  1925.             // TODO: convert old style atmopshere parameters
  1926.             if (context->getRenderPath() == GLContext::GLPath_GLSL &&
  1927.                 atmosphere->mieScaleHeight > 0.0f)
  1928.             {
  1929.                 float atmScale = 1.0f + atmosphere->height / radius;
  1931.                 renderAtmosphere_GLSL(ri, ls,
  1932.                                       atmosphere,
  1933.                                       radius * atmScale,
  1934.                                       planetMat,
  1935.                                       viewFrustum,
  1936.                                       *context);
  1937.             }
  1938.             else
  1939.             {
  1940.                 glPushMatrix();
  1941.                 glLoadIdentity();
  1942.                 glDisable(GL_LIGHTING);
  1943.                 glDisable(GL_TEXTURE_2D);
  1944.                 glEnable(GL_BLEND);
  1945.                 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  1947.                 glRotate(cameraOrientation);
  1949.                 renderEllipsoidAtmosphere(*atmosphere,
  1950.                                           pos,
  1951.                                           obj.orientation,
  1952.                                           scaleFactors,
  1953.                                           ri.sunDir_eye,
  1954.                                           ls,
  1955.                                           thicknessInPixels,
  1956.                                           lit);
  1957.                 glEnable(GL_TEXTURE_2D);
  1958.                 glPopMatrix();
  1959.             }
  1960.         }
  1962.         // If there's a cloud layer, we'll render it now.
  1963.         if (cloudTex != NULL)
  1964.         {
  1965.             glPushMatrix();
  1967.             float cloudScale = 1.0f + atmosphere->cloudHeight / radius;
  1968.             glScalef(cloudScale, cloudScale, cloudScale);
  1970.             // If we're beneath the cloud level, render the interior of
  1971.             // the cloud sphere.
  1972.             if (distance - radius < atmosphere->cloudHeight)
  1973.                 glFrontFace(GL_CW);
  1975.             if (atmosphere->cloudSpeed != 0.0f)
  1976.             {
  1977.                 // Make the clouds appear to rotate above the surface of
  1978.                 // the planet.  This is easier to do with the texture
  1979.                 // matrix than the model matrix because changing the
  1980.                 // texture matrix doesn't require us to compute a second
  1981.                 // set of model space rendering parameters.
  1982.                 glMatrixMode(GL_TEXTURE);
  1983.                 glTranslatef(cloudTexOffset, 0.0f, 0.0f);
  1984.                 glMatrixMode(GL_MODELVIEW);
  1985.             }
  1987.             glEnable(GL_LIGHTING);
  1988.             glDepthMask(GL_FALSE);
  1989.             cloudTex->bind();
  1990.             glEnable(GL_BLEND);
  1991.             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  1992. #ifdef HDR_COMPRESS
  1993.             glColor4f(0.5f, 0.5f, 0.5f, 1);
  1994. #else
  1995.             glColor4f(1, 1, 1, 1);
  1996. #endif
  1998.             // Cloud layers can be trouble for the depth buffer, since they tend
  1999.             // to be very close to the surface of a planet relative to the radius
  2000.             // of the planet. We'll help out by offsetting the cloud layer toward
  2001.             // the viewer.
  2002.             if (distance > radius * 1.1f)
  2003.             {
  2004.                 glEnable(GL_POLYGON_OFFSET_FILL);
  2005.                 glPolygonOffset(-1.0f, -1.0f);
  2006.             }
  2008.             if (lit)
  2009.             {
  2010.                 if (context->getRenderPath() == GLContext::GLPath_GLSL)
  2011.                 {
  2012.                     renderClouds_GLSL(ri, ls,
  2013.                                       atmosphere,
  2014.                                       cloudTex,
  2015.                                       cloudNormalMap,
  2016.                                       cloudTexOffset,
  2017.                                       obj.rings,
  2018.                                       radius,
  2019.                                       textureResolution,
  2020.                                       renderFlags,
  2021.                                       planetMat,
  2022.                                       viewFrustum,
  2023.                                       *context);
  2024.                 }
  2025.                 else
  2026.                 {
  2027.                     VertexProcessor* vproc = context->getVertexProcessor();
  2028.                     if (vproc != NULL)
  2029.                     {
  2030.                         vproc->enable();
  2031.                         vproc->parameter(vp::AmbientColor, ri.ambientColor * ri.color);
  2032.                         vproc->parameter(vp::TextureTranslation,
  2033.                                          cloudTexOffset, 0.0f, 0.0f, 0.0f);
  2034.                         if (ls.nLights > 1)
  2035.                             vproc->use(vp::diffuseTexOffset_2light);
  2036.                         else
  2037.                             vproc->use(vp::diffuseTexOffset);
  2038.                         setLightParameters_VP(*vproc, ls, ri.color, Color::Black);
  2039.                     }
  2041.                     g_lodSphere->render(*context,
  2042.                                         LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  2043.                                         viewFrustum,
  2044.                                         ri.pixWidth,
  2045.                                         cloudTex);
  2047.                     if (vproc != NULL)
  2048.                         vproc->disable();
  2049.                 }
  2050.             }
  2051.             else
  2052.             {
  2053.                 glDisable(GL_LIGHTING);
  2054.                 g_lodSphere->render(*context,
  2055.                                     LODSphereMesh::Normals | LODSphereMesh::TexCoords0,
  2056.                                     viewFrustum,
  2057.                                     ri.pixWidth,
  2058.                                     cloudTex);
  2059.                 glEnable(GL_LIGHTING);
  2060.             }
  2062.             glDisable(GL_POLYGON_OFFSET_FILL);
  2064.             // Reset the texture matrix
  2065.             glMatrixMode(GL_TEXTURE);
  2066.             glLoadIdentity();
  2067.             glMatrixMode(GL_MODELVIEW);
  2069.             glDepthMask(GL_TRUE);
  2070.             glFrontFace(GL_CCW);
  2072.             glPopMatrix();
  2073.         }
  2074.     }
  2076.     // No separate shadow rendering pass required for GLSL path
  2077.     if (ls.shadows[0] != NULL &&
  2078.         ls.shadows[0]->size() != 0 &&
  2079.         (obj.surface->appearanceFlags & Surface::Emissive) == 0 &&
  2080.         context->getRenderPath() != GLContext::GLPath_GLSL)
  2081.     {
  2082.         if (context->getVertexProcessor() != NULL &&
  2083.             context->getFragmentProcessor() != NULL)
  2084.         {
  2085.             renderEclipseShadows_Shaders(geometry,
  2086.                                          *ls.shadows[0],
  2087.                                          ri,
  2088.                                          radius, planetMat, viewFrustum,
  2089.                                          *context);
  2090.         }
  2091.         else
  2092.         {
  2093.             renderEclipseShadows(geometry,
  2094.                                  *ls.shadows[0],
  2095.                                  ri,
  2096.                                  radius, planetMat, viewFrustum,
  2097.                                  *context);
  2098.         }
  2099.     }
  2101.     if (obj.rings != NULL &&
  2102.         (obj.surface->appearanceFlags & Surface::Emissive) == 0 &&
  2103.         (renderFlags & ShowRingShadows) != 0)
  2104.     {
  2105.         Texture* ringsTex = obj.rings->texture.find(textureResolution);
  2106.         if (ringsTex != NULL)
  2107.         {
  2108.             Vec3f sunDir = pos - Point3f(0, 0, 0);
  2109.             sunDir.normalize();
  2111.             glEnable(GL_TEXTURE_2D);
  2112.             ringsTex->bind();
  2114.             if (useClampToBorder &&
  2115.                 context->getVertexPath() != GLContext::VPath_Basic &&
  2116.                 context->getRenderPath() != GLContext::GLPath_GLSL)
  2117.             {
  2118.                 renderRingShadowsVS(geometry,
  2119.                                     *obj.rings,
  2120.                                     sunDir,
  2121.                                     ri,
  2122.                                     radius, 1.0f - obj.semiAxes.y,
  2123.                                     planetMat, viewFrustum,
  2124.                                     *context);
  2125.             }
  2126.         }
  2127.     }
  2129.     if (obj.rings != NULL && distance > obj.rings->innerRadius)
  2130.     {
  2131.         glDepthMask(GL_FALSE);
  2132.         if (context->getRenderPath() == GLContext::GLPath_GLSL)
  2133.         {
  2134.             renderRings_GLSL(*obj.rings, ri, ls,
  2135.                              radius, 1.0f - obj.semiAxes.y,
  2136.                              textureResolution,
  2137.                              (renderFlags & ShowRingShadows) != 0 && lit,
  2138.                              detailOptions.ringSystemSections);
  2139.         }
  2140.         else
  2141.         {
  2142.             renderRings(*obj.rings, ri, radius, 1.0f - obj.semiAxes.y,
  2143.                         textureResolution,
  2144.                         (context->hasMultitexture() &&
  2145.                          (renderFlags & ShowRingShadows) != 0 && lit),
  2146.                         *context,
  2147.                         detailOptions.ringSystemSections);
  2148.         }
  2149.     }
  2151.     // Disable all light sources other than the first
  2152.     for (i = 0; i < ls.nLights; i++)
  2153.         glDisable(GL_LIGHT0 + i);
  2155.     glPopMatrix();
  2156.     glDisable(GL_DEPTH_TEST);
  2157.     glDepthMask(GL_FALSE);
  2158.     glDisable(GL_LIGHTING);
  2159.     glEnable(GL_BLEND);
  2160. }
  2163. bool Renderer::testEclipse(const Body& receiver,
  2164.                            const Body& caster,
  2165.                            const DirectionalLight& light,
  2166.                            double now,
  2167.                            vector<EclipseShadow>& shadows)
  2168. {
  2169.     // Ignore situations where the shadow casting body is much smaller than
  2170.     // the receiver, as these shadows aren't likely to be relevant.  Also,
  2171.     // ignore eclipses where the caster is not an ellipsoid, since we can't
  2172.     // generate correct shadows in this case.
  2173.     if (caster.getRadius() >= receiver.getRadius() * MinRelativeOccluderRadius &&
  2174.         caster.hasVisibleGeometry() &&
  2175.         caster.extant(now) &&
  2176.         caster.isEllipsoid())
  2177.     {
  2178.         // All of the eclipse related code assumes that both the caster
  2179.         // and receiver are spherical.  Irregular receivers will work more
  2180.         // or less correctly, but casters that are sufficiently non-spherical
  2181.         // will produce obviously incorrect shadows.  Another assumption we
  2182.         // make is that the distance between the caster and receiver is much
  2183.         // less than the distance between the sun and the receiver.  This
  2184.         // approximation works everywhere in the solar system, and is likely
  2185.         // valid for any orbitally stable pair of objects orbiting a star.
  2186.         Point3d posReceiver = receiver.getAstrocentricPosition(now);
  2187.         Point3d posCaster = caster.getAstrocentricPosition(now);
  2189.         //const Star* sun = receiver.getSystem()->getStar();
  2190.         //assert(sun != NULL);
  2191.         //double distToSun = posReceiver.distanceFromOrigin();
  2192.         //float appSunRadius = (float) (sun->getRadius() / distToSun);
  2193.         float appSunRadius = light.apparentSize;
  2195.         Vec3d dir = posCaster - posReceiver;
  2196.         double distToCaster = dir.length() - receiver.getRadius();
  2197.         float appOccluderRadius = (float) (caster.getRadius() / distToCaster);
  2199.         // The shadow radius is the radius of the occluder plus some additional
  2200.         // amount that depends upon the apparent radius of the sun.  For
  2201.         // a sun that's distant/small and effectively a point, the shadow
  2202.         // radius will be the same as the radius of the occluder.
  2203.         float shadowRadius = (1 + appSunRadius / appOccluderRadius) *
  2204.             caster.getRadius();
  2206.         // Test whether a shadow is cast on the receiver.  We want to know
  2207.         // if the receiver lies within the shadow volume of the caster.  Since
  2208.         // we're assuming that everything is a sphere and the sun is far
  2209.         // away relative to the caster, the shadow volume is a
  2210.         // cylinder capped at one end.  Testing for the intersection of a
  2211.         // singly capped cylinder is as simple as checking the distance
  2212.         // from the center of the receiver to the axis of the shadow cylinder.
  2213.         // If the distance is less than the sum of the caster's and receiver's
  2214.         // radii, then we have an eclipse. We also need to verify that the
  2215.         // receiver is behind the caster when seen from the light source.
  2216.         float R = receiver.getRadius() + shadowRadius;
  2218.         // The stored light position is receiver-relative; thus the caster-to-light
  2219.         // direction is casterPos - (receiverPos + lightPos)
  2220.         Point3d lightPosition = posReceiver + light.position;
  2221.         Vec3d lightToCasterDir = posCaster - lightPosition;
  2222.         Vec3d receiverToCasterDir = posReceiver - posCaster;
  2224.         double dist = distance(posReceiver,
  2225.                                Ray3d(posCaster, lightToCasterDir));
  2226.         if (dist < R && lightToCasterDir * receiverToCasterDir > 0.0)
  2227.         {
  2228.             Vec3d sunDir = lightToCasterDir;
  2229.             sunDir.normalize();
  2231.             EclipseShadow shadow;
  2232.             shadow.origin = Point3f((float) dir.x,
  2233.                                     (float) dir.y,
  2234.                                     (float) dir.z);
  2235.             shadow.direction = Vec3f((float) sunDir.x,
  2236.                                      (float) sunDir.y,
  2237.                                      (float) sunDir.z);
  2238.             shadow.penumbraRadius = shadowRadius;
  2240.             // The umbra radius will be positive if the apparent size of the occluder
  2241.             // is greater than the apparent size of the sun, zero if they're equal,
  2242.             // and negative when the eclipse is partial. The absolute value of the
  2243.             // umbra radius is the radius of the shadow region with constant depth:
  2244.             // for total eclipses, this area is actually the umbra, with a depth of
  2245.             // 1. For annular eclipses and transits, it is less than 1.
  2246.             shadow.umbraRadius = caster.getRadius() *
  2247.                 (appOccluderRadius - appSunRadius) / appOccluderRadius;
  2248.             shadow.maxDepth = std::min(1.0f, square(appOccluderRadius / appSunRadius));
  2250.             // Ignore transits that don't produce a visible shadow.
  2251.             if (shadow.maxDepth > 1.0f / 256.0f)
  2252.                 shadows.push_back(shadow);
  2254.             return true;
  2255.         }
  2256.     }
  2258.     return false;
  2259. }
  2262. void Renderer::renderPlanet(Body& body,
  2263.                             Point3f pos,
  2264.                             float distance,
  2265.                             float appMag,
  2266.                             const Observer& observer,
  2267.                             const Quatf& cameraOrientation,
  2268.                             float nearPlaneDistance,
  2269.                             float farPlaneDistance)
  2270. {
  2271.     double now = observer.getTime();
  2272.     float altitude = distance - body.getRadius();
  2273.     float discSizeInPixels = body.getRadius() /
  2274.         (max(nearPlaneDistance, altitude) * pixelSize);
  2276.     if (discSizeInPixels > 1 && body.hasVisibleGeometry())
  2277.     {
  2278.         RenderProperties rp;
  2280.         if (displayedSurface.empty())
  2281.         {
  2282.             rp.surface = const_cast<Surface*>(&body.getSurface());
  2283.         }
  2284.         else
  2285.         {
  2286.             rp.surface = body.getAlternateSurface(displayedSurface);
  2287.             if (rp.surface == NULL)
  2288.                 rp.surface = const_cast<Surface*>(&body.getSurface());
  2289.         }
  2290.         rp.atmosphere = body.getAtmosphere();
  2291.         rp.rings = body.getRings();
  2292.         rp.radius = body.getRadius();
  2293.         rp.geometry = body.getGeometry();
  2294.         rp.semiAxes = body.getSemiAxes() * (1.0f / rp.radius);
  2295.         rp.geometryScale = body.getGeometryScale();
  2297.         Quatd q = body.getRotationModel(now)->spin(now) *
  2298.             body.getEclipticToEquatorial(now);
  2300.         rp.orientation = body.getOrientation() *
  2301.             Quatf((float) q.w, (float) q.x, (float) q.y, (float) q.z);
  2303.         if (body.getLocations() != NULL && (labelMode & LocationLabels) != 0)
  2304.             body.computeLocations();
  2306.         Vec3f scaleFactors;
  2307.         bool isNormalized = false;
  2308.         Geometry* geometry = NULL;
  2309.         if (rp.geometry != InvalidResource)
  2310.             geometry = GetGeometryManager()->find(rp.geometry);
  2311.         if (geometry == NULL || geometry->isNormalized())
  2312.         {
  2313.             scaleFactors = rp.semiAxes * rp.radius;
  2314.             isNormalized = true;
  2315.         }
  2316.         else
  2317.         {
  2318.             float scale = rp.geometryScale;
  2319.             scaleFactors = Vec3f(scale, scale, scale);
  2320.         }
  2322.         LightingState lights;
  2323.         setupObjectLighting(lightSourceList,
  2324.                             secondaryIlluminators,
  2325.                             rp.orientation,
  2326.                             scaleFactors,
  2327.                             pos,
  2328.                             isNormalized,
  2329. #ifdef USE_HDR
  2330.                             faintestMag,
  2331.                             DEFAULT_EXPOSURE + brightPlus, //exposure + brightPlus,
  2332.                             appMag,
  2333. #endif
  2334.                             lights);
  2335.         assert(lights.nLights <= MaxLights);
  2337.         lights.ambientColor = Vec3f(ambientColor.red(),
  2338.                                     ambientColor.green(),
  2339.                                     ambientColor.blue());
  2341.         {
  2342.             // Clear out the list of eclipse shadows
  2343.             for (unsigned int li = 0; li < lights.nLights; li++)
  2344.             {
  2345.                 eclipseShadows[li].clear();
  2346.                 lights.shadows[li] = &eclipseShadows[li];
  2347.             }
  2348.         }
  2351.         // Calculate eclipse circumstances
  2352.         if ((renderFlags & ShowEclipseShadows) != 0 &&
  2353.             body.getSystem() != NULL)
  2354.         {
  2355.             PlanetarySystem* system = body.getSystem();
  2357.             if (system->getPrimaryBody() == NULL &&
  2358.                 body.getSatellites() != NULL)
  2359.             {
  2360.                 // The body is a planet.  Check for eclipse shadows
  2361.                 // from all of its satellites.
  2362.                 PlanetarySystem* satellites = body.getSatellites();
  2363.                 if (satellites != NULL)
  2364.                 {
  2365.                     int nSatellites = satellites->getSystemSize();
  2366.                     for (unsigned int li = 0; li < lights.nLights; li++)
  2367.                     {
  2368.                         if (lights.lights[li].castsShadows)
  2369.                         {
  2370.                             for (int i = 0; i < nSatellites; i++)
  2371.                             {
  2372.                                 testEclipse(body, *satellites->getBody(i),
  2373.                                             lights.lights[li],
  2374.                                             now, *lights.shadows[li]);
  2375.                             }
  2376.                         }
  2377.                     }
  2378.                 }
  2379.             }
  2380.             else if (system->getPrimaryBody() != NULL)
  2381.             {
  2382.                 for (unsigned int li = 0; li < lights.nLights; li++)
  2383.                 {
  2384.                     if (lights.lights[li].castsShadows)
  2385.                     {
  2386.                         // The body is a moon.  Check for eclipse shadows from
  2387.                         // the parent planet and all satellites in the system.
  2388.                         // Traverse up the hierarchy so that any parent objects
  2389.                         // of the parent are also considered (TODO: their child
  2390.                         // objects will not be checked for shadows.)
  2391.                         Body* planet = system->getPrimaryBody();
  2392.                         while (planet != NULL)
  2393.                         {
  2394.                             testEclipse(body, *planet, lights.lights[li],
  2395.                                         now, *lights.shadows[li]);
  2396.                             if (planet->getSystem() != NULL)
  2397.                                 planet = planet->getSystem()->getPrimaryBody();
  2398.                             else
  2399.                                 planet = NULL;
  2400.                         }
  2402.                         int nSatellites = system->getSystemSize();
  2403.                         for (int i = 0; i < nSatellites; i++)
  2404.                         {
  2405.                             if (system->getBody(i) != &body)
  2406.                             {
  2407.                                 testEclipse(body, *system->getBody(i),
  2408.                                             lights.lights[li],
  2409.                                             now, *lights.shadows[li]);
  2410.                             }
  2411.                         }
  2412.                     }
  2413.                 }
  2414.             }
  2415.         }
  2417.         renderObject(pos, distance, now,
  2418.                      cameraOrientation, nearPlaneDistance, farPlaneDistance,
  2419.                      rp, lights);
  2421.         if (body.getLocations() != NULL && (labelMode & LocationLabels) != 0)
  2422.         {
  2423.             // Set up location markers for this body
  2424.             mountainRep    = MarkerRepresentation(MarkerRepresentation::Triangle, 8.0f, LocationLabelColor);
  2425.             craterRep      = MarkerRepresentation(MarkerRepresentation::Circle,   8.0f, LocationLabelColor);
  2426.             observatoryRep = MarkerRepresentation(MarkerRepresentation::Plus,     8.0f, LocationLabelColor);
  2427.             cityRep        = MarkerRepresentation(MarkerRepresentation::X,        3.0f, LocationLabelColor);
  2428.             genericLocationRep = MarkerRepresentation(MarkerRepresentation::Square, 8.0f, LocationLabelColor);
  2429.             
  2430.             glEnable(GL_DEPTH_TEST);
  2431.             glDepthMask(GL_FALSE);
  2432.             glDisable(GL_BLEND);
  2434.             // We need a double precision body-relative position of the
  2435.             // observer, otherwise location labels will tend to jitter.
  2436.             Vec3d posd = (body.getPosition(observer.getTime()) -
  2437.                           observer.getPosition()) * astro::microLightYearsToKilometers(1.0);
  2438.             renderLocations(body, posd, q);
  2440.             glDisable(GL_DEPTH_TEST);
  2441.         }
  2442.     }
  2444.     glEnable(GL_TEXTURE_2D);
  2445.     glEnable(GL_BLEND);
  2446.     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  2447. #ifdef USE_HDR
  2448.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
  2449. #endif
  2451.     if (body.isVisibleAsPoint())
  2452.     {
  2453.         if (useNewStarRendering)
  2454.         {
  2455.             renderObjectAsPoint(pos,
  2456.                                 body.getRadius(),
  2457.                                 appMag,
  2458.                                 faintestMag,
  2459.                                 discSizeInPixels,
  2460.                                 body.getSurface().color,
  2461.                                 cameraOrientation,
  2462.                                 false, false);
  2463.         }
  2464.         else
  2465.         {
  2466.             renderObjectAsPoint_nosprite(pos,
  2467.                                  body.getRadius(),
  2468.                                  appMag,
  2469.                                  faintestMag,
  2470.                                  discSizeInPixels,
  2471.                                  body.getSurface().color,
  2472.                                  cameraOrientation,
  2473.                                  false);
  2474.         }
  2475.     }
  2476. #ifdef USE_HDR
  2477.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  2478. #endif
  2479. }
  2482. void Renderer::renderStar(const Star& star,
  2483.                           Point3f pos,
  2484.                           float distance,
  2485.                           float appMag,
  2486.                           Quatf cameraOrientation,
  2487.                           double now,
  2488.                           float nearPlaneDistance,
  2489.                           float farPlaneDistance)
  2490. {
  2491.     if (!star.getVisibility())
  2492.         return;
  2494.     Color color = colorTemp->lookupColor(star.getTemperature());
  2495.     float radius = star.getRadius();
  2496.     float discSizeInPixels = radius / (distance * pixelSize);
  2498.     if (discSizeInPixels > 1)
  2499.     {
  2500.         Surface surface;
  2501.         RenderProperties rp;
  2503.         surface.color = color;
  2505.         MultiResTexture mtex = star.getTexture();
  2506.         if (mtex.tex[textureResolution] != InvalidResource)
  2507.         {
  2508.             surface.baseTexture = mtex;
  2509.         }
  2510.         else
  2511.         {
  2512.             surface.baseTexture = InvalidResource;
  2513.         }
  2514.         surface.appearanceFlags |= Surface::ApplyBaseTexture;
  2515.         surface.appearanceFlags |= Surface::Emissive;
  2517.         rp.surface = &surface;
  2518.         rp.rings = NULL;
  2519.         rp.radius = star.getRadius();
  2520.         rp.semiAxes = star.getEllipsoidSemiAxes();
  2521.         rp.geometry = star.getGeometry();
  2523. #ifndef USE_HDR
  2524.         Atmosphere atmosphere;
  2525.         Color atmColor(color.red() * 0.5f, color.green() * 0.5f, color.blue() * 0.5f);
  2526.         atmosphere.height = radius * CoronaHeight;
  2527.         atmosphere.lowerColor = atmColor;
  2528.         atmosphere.upperColor = atmColor;
  2529.         atmosphere.skyColor = atmColor;
  2531.         // Use atmosphere effect to give stars a fuzzy fringe
  2532.         if (rp.geometry == InvalidResource)
  2533.             rp.atmosphere = &atmosphere;
  2534.         else
  2535. #endif
  2536.         rp.atmosphere = NULL;
  2538.         Quatd q = star.getRotationModel()->orientationAtTime(now);
  2539.         rp.orientation = Quatf((float) q.w, (float) q.x, (float) q.y, (float) q.z);
  2541.         renderObject(pos, distance, now,
  2542.                      cameraOrientation, nearPlaneDistance, farPlaneDistance,
  2543.                      rp, LightingState());
  2544.     }
  2546.     glEnable(GL_TEXTURE_2D);
  2547.     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  2548. #ifdef USE_HDR
  2549.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
  2550. #endif
  2552. #ifndef USE_HDR
  2553.     if (useNewStarRendering)
  2554.     {
  2555. #endif
  2556.         renderObjectAsPoint(pos,
  2557.                             star.getRadius(),
  2558.                             appMag,
  2559.                             faintestMag,
  2560.                             discSizeInPixels,
  2561.                             color,
  2562.                             cameraOrientation,
  2563.                             true, true);
  2564. #ifndef USE_HDR
  2565.     }
  2566.     else
  2567.     {
  2568.         renderObjectAsPoint_nosprite(pos,
  2569.                                      star.getRadius(),
  2570.                                      appMag,
  2571.                                      faintestPlanetMag,
  2572.                                      discSizeInPixels,
  2573.                                      color,
  2574.                                      cameraOrientation,
  2575.                                      true);
  2576.     }
  2577. #endif
  2578. #ifdef USE_HDR
  2579.     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  2580. #endif
  2581. }
  2584. static const int MaxCometTailPoints = 120;
  2585. static const int CometTailSlices = 48;
  2586. struct CometTailVertex
  2587. {
  2588.     Point3f point;
  2589.     Vec3f normal;
  2590.     Point3f paraboloidPoint;
  2591.     float brightness;
  2592. };
  2594. static CometTailVertex cometTailVertices[CometTailSlices * MaxCometTailPoints];
  2596. static void ProcessCometTailVertex(const CometTailVertex& v,
  2597.                                    const Vec3f& viewDir,
  2598.                                    float fadeDistFromSun)
  2599. {
  2600.     // If fadeDistFromSun = x/x0 >= 1.0, comet tail starts fading,
  2601.     // i.e. fadeFactor quickly transits from 1 to 0.
  2603.     float fadeFactor = 0.5f - 0.5f * (float) tanh(fadeDistFromSun - 1.0f / fadeDistFromSun);
  2604.     float shade = abs(viewDir * v.normal * v.brightness * fadeFactor);
  2605.     glColor4f(0.5f, 0.5f, 0.75f, shade);
  2606.     glVertex(v.point);
  2607. }
  2609. #if 0
  2610. static void ProcessCometTailVertex(const CometTailVertex& v,
  2611.                                    const Point3f& cameraPos)
  2612. {
  2613.     Vec3f viewDir = v.point - cameraPos;
  2614.     viewDir.normalize();
  2615.     float shade = abs(viewDir * v.normal * v.brightness);
  2616.     glColor4f(0.0f, 0.5f, 1.0f, shade);
  2617.     glVertex(v.point);
  2618. }
  2619. #endif
  2621. #if 0
  2622. static void ProcessCometTailVertex(const CometTailVertex& v,
  2623.                                    const Point3f& eyePos_obj,
  2624.                                    float b,
  2625.                                    float h)
  2626. {
  2627.     float shade = 0.0f;
  2628.     Vec3f R = v.paraboloidPoint - eyePos_obj;
  2629.     float c0 = b * (square(eyePos_obj.x) + square(eyePos_obj.y)) + eyePos_obj.z;
  2630.     float c1 = 2 * b * (R.x * eyePos_obj.x + R.y * eyePos_obj.y) - R.z;
  2631.     float c2 = b * (square(R.x) + square(R.y));
  2633.     float disc = square(c1) - 4 * c0 * c2;
  2635.     if (disc < 0.0f)
  2636.     {
  2637.         shade = 0.0f;
  2638.     }
  2639.     else
  2640.     {
  2641.         disc = (float) sqrt(disc);
  2642.         float s = 1.0f / (2 * c2);
  2643.         float t0 = (h - eyePos_obj.z) / R.z;
  2644.         float t1 = (c1 - disc) * s;
  2645.         float t2 = (c1 + disc) * s;
  2646.         /*float u0 = max(t0, 0.0f);     Unused*/
  2647.         float u1, u2;
  2649.         if (R.z < 0.0f)
  2650.         {
  2651.             u1 = max(t1, t0);
  2652.             u2 = max(t2, t0);
  2653.         }
  2654.         else
  2655.         {
  2656.             u1 = min(t1, t0);
  2657.             u2 = min(t2, t0);
  2658.         }
  2659.         u1 = max(0.0f, u1);
  2660.         u2 = max(0.0f, u2);
  2662.         shade = u2 - u1;
  2663.     }
  2665.     glColor4f(0.0f, 0.5f, 1.0f, shade);
  2666.     glVertex(v.point);
  2667. }
  2668. #endif
  2671. // Compute a rough estimate of the visible length of the dust tail.
  2672. // TODO: This is old code that needs to be rewritten. For one thing,
  2673. // the length is inversely proportional to the distance from the sun,
  2674. // whereas the 1/distance^2 is probably more realistic. There should
  2675. // also be another parameter that specifies how active the comet is.
  2676. static float cometDustTailLength(float distanceToSun,
  2677.                                  float radius)
  2678. {
  2679.     return (1.0e8f / distanceToSun) * (radius / 5.0f) * 1.0e7f;
  2680. }
  2683. // TODO: Remove unused parameters??
  2684. void Renderer::renderCometTail(const Body& body,
  2685.                                Point3f pos,
  2686.                                double now,
  2687.                                float discSizeInPixels)
  2688. {
  2689.     Point3f cometPoints[MaxCometTailPoints];
  2690.     Point3d pos0 = body.getOrbit(now)->positionAtTime(now);
  2691.     Point3d pos1 = body.getOrbit(now)->positionAtTime(now - 0.01);
  2692.     Vec3d vd = pos1 - pos0;
  2693.     double t = now;
  2694.     /*float f = 1.0e15f;    Unused*/
  2695.     /*int nSteps = MaxCometTailPoints;  Unused*/
  2696.     /*float dt = 10000000.0f / (nSteps * (float) vd.length() * 100.0f);     Unused*/
  2697.     float distanceFromSun, irradiance_max = 0.0f;
  2698.     unsigned int li_eff = 0;    // Select the first sun as default to
  2699.                                 // shut up compiler warnings
  2701.     // Adjust the amount of triangles used for the comet tail based on
  2702.     // the screen size of the comet.
  2703.     float lod = min(1.0f, max(0.2f, discSizeInPixels / 1000.0f));
  2704.     int nTailPoints = (int) (MaxCometTailPoints * lod);
  2705.     int nTailSlices = (int) (CometTailSlices * lod);
  2707.     // Find the sun with the largest irrradiance of light onto the comet
  2708.     // as function of the comet's position;
  2709.     // irradiance = sun's luminosity / square(distanceFromSun);
  2711.     for (unsigned int li = 0; li < lightSourceList.size(); li++)
  2712.     {
  2713.         distanceFromSun = (float) (Vec3d(pos.x, pos.y, pos.z) - lightSourceList[li].position).length();
  2714.         float irradiance = lightSourceList[li].luminosity / square(distanceFromSun);
  2715.         if (irradiance > irradiance_max)
  2716.         {
  2717.             li_eff = li;
  2718.             irradiance_max = irradiance;
  2719.         }
  2720.     }
  2721.     float fadeDistance = 1.0f / (float) (COMET_TAIL_ATTEN_DIST_SOL * sqrt(irradiance_max));
  2723.     // direction to sun with dominant light irradiance:
  2725.     Vec3d sd = Vec3d(pos.x, pos.y, pos.z) - lightSourceList[li_eff].position;
  2726.     Vec3f sunDir = Vec3f((float) sd.x, (float) sd.y, (float) sd.z);
  2727.     sunDir.normalize();
  2729.     float dustTailLength = cometDustTailLength((float) pos0.distanceFromOrigin(), body.getRadius());
  2730.     float dustTailRadius = dustTailLength * 0.1f;
  2732.     Point3f origin(0, 0, 0);
  2733.     origin -= sunDir * (body.getRadius() * 100);
  2735.     int i;
  2736.     for (i = 0; i < nTailPoints; i++)
  2737.     {
  2738.         float alpha = (float) i / (float) nTailPoints;
  2739.         alpha = alpha * alpha;
  2740.         cometPoints[i] = origin + sunDir * (dustTailLength * alpha);
  2741.     }
  2743.     // We need three axes to define the coordinate system for rendering the
  2744.     // comet.  The first axis is the velocity.  We choose the second one
  2745.     // based on the orientation of the comet.  And the third is just the cross
  2746.     // product of the first and second axes.
  2747.     Quatd qd = body.getEclipticToEquatorial(t);
  2748.     Quatf q((float) qd.w, (float) qd.x, (float) qd.y, (float) qd.z);
  2749.     Vec3f v = cometPoints[1] - cometPoints[0];
  2750.     v.normalize();
  2751.     Vec3f u0 = Vec3f(0, 1, 0) * q.toMatrix3();
  2752.     Vec3f u1 = Vec3f(1, 0, 0) * q.toMatrix3();
  2753.     Vec3f u;
  2754.     if (abs(u0 * v) < abs(u1 * v))
  2755.         u = v ^ u0;
  2756.     else
  2757.         u = v ^ u1;
  2758.     u.normalize();
  2759.     Vec3f w = u ^ v;
  2761.     glColor4f(0.0f, 1.0f, 1.0f, 0.5f);
  2762.     glPushMatrix();
  2763.     glTranslate(pos);
  2765.     // glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  2766.     glDisable(GL_TEXTURE_2D);
  2767.     glDisable(GL_LIGHTING);
  2768.     glDepthMask(GL_FALSE);
  2769.     glEnable(GL_BLEND);
  2770.     glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  2772.     for (i = 0; i < nTailPoints; i++)
  2773.     {
  2774.         float brightness = 1.0f - (float) i / (float) (nTailPoints - 1);
  2775.         Vec3f v0, v1;
  2776.         float sectionLength;
  2777.         if (i != 0 && i != nTailPoints - 1)
  2778.         {
  2779.             v0 = cometPoints[i] - cometPoints[i - 1];
  2780.             v1 = cometPoints[i + 1] - cometPoints[i];
  2781.             sectionLength = v0.length();
  2782.             v0.normalize();
  2783.             v1.normalize();
  2784.             Vec3f axis = v1 ^ v0;
  2785.             float axisLength = axis.length();
  2786.             if (axisLength > 1e-5f)
  2787.             {
  2788.                 axis *= 1.0f / axisLength;
  2789.                 q.setAxisAngle(axis, (float) asin(axisLength));
  2790.                 Mat3f m = q.toMatrix3();
  2792.                 u = u * m;
  2793.                 v = v * m;
  2794.                 w = w * m;
  2795.             }
  2796.         }
  2797.         else if (i == 0)
  2798.         {
  2799.             v0 = cometPoints[i + 1] - cometPoints[i];
  2800.             sectionLength = v0.length();