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

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

OpenGL

开发平台：

Visual C++

rendcontext.cpp：源码内容
  1. // rendcontext.cpp
  2. //
  3. // Copyright (C) 2004-2009, the Celestia Development Team
  4. //
  5. // This program is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU General Public License
  7. // as published by the Free Software Foundation; either version 2
  8. // of the License, or (at your option) any later version.
  10. #include <vector>
  11. #include "rendcontext.h"
  12. #include "texmanager.h"
  13. #include "gl.h"
  14. #include "glext.h"
  15. #include "vecgl.h"
  17. using namespace std;
  20. static Mesh::Material defaultMaterial;
  22. static GLenum GLPrimitiveModes[Mesh::PrimitiveTypeMax] =
  23. {
  24.     GL_TRIANGLES,
  25.     GL_TRIANGLE_STRIP,
  26.     GL_TRIANGLE_FAN,
  27.     GL_LINES,
  28.     GL_LINE_STRIP,
  29.     GL_POINTS,
  30.     GL_POINTS,
  31. };
  33. static GLenum GLComponentTypes[Mesh::FormatMax] =
  34. {
  35.      GL_FLOAT,          // Float1
  36.      GL_FLOAT,          // Float2
  37.      GL_FLOAT,          // Float3
  38.      GL_FLOAT,          // Float4,
  39.      GL_UNSIGNED_BYTE,  // UByte4
  40. };
  42. static int GLComponentCounts[Mesh::FormatMax] =
  43. {
  44.      1,  // Float1
  45.      2,  // Float2
  46.      3,  // Float3
  47.      4,  // Float4,
  48.      4,  // UByte4
  49. };
  52. enum {
  53.     TangentAttributeIndex = 6,
  54.     PointSizeAttributeIndex = 7,
  55. };
  58. static void
  59. setStandardVertexArrays(const Mesh::VertexDescription& desc,
  60.                         void* vertexData);
  61. static void
  62. setExtendedVertexArrays(const Mesh::VertexDescription& desc,
  63.                         const void* vertexData);
  66. RenderContext::RenderContext() :
  67.     material(&defaultMaterial),
  68.     locked(false),
  69.     renderPass(PrimaryPass),
  70.     pointScale(1.0f),
  71.     usePointSize(false),
  72.     useNormals(true),
  73.     useColors(false),
  74.     useTexCoords(true)
  75. {
  76. }
  79. RenderContext::RenderContext(const Mesh::Material* _material)
  80. {
  81.     if (_material == NULL)
  82.         material = &defaultMaterial;
  83.     else
  84.         material = _material;
  85. }
  88. const Mesh::Material*
  89. RenderContext::getMaterial() const
  90. {
  91.     return material;
  92. }
  95. void
  96. RenderContext::setMaterial(const Mesh::Material* newMaterial)
  97. {
  98.     if (!locked)
  99.     {
  100.         if (newMaterial == NULL)
  101.             newMaterial = &defaultMaterial;
  103.         if (renderPass == PrimaryPass)
  104.         {
  105.             if (newMaterial != material)
  106.             {
  107.                 material = newMaterial;
  108.                 makeCurrent(*material);
  109.             }
  110.         }
  111.         else if (renderPass == EmissivePass)
  112.         {
  113.             if (material->maps[Mesh::EmissiveMap] !=
  114.                 newMaterial->maps[Mesh::EmissiveMap])
  115.             {
  116.                 material = newMaterial;
  117.                 makeCurrent(*material);
  118.             }
  119.         }
  120.     }
  121. }
  124. void
  125. RenderContext::setPointScale(float _pointScale)
  126. {
  127.     pointScale = _pointScale;
  128. }
  131. float
  132. RenderContext::getPointScale() const
  133. {
  134.     return pointScale;
  135. }
  138. void
  139. RenderContext::setCameraOrientation(const Quatf& q)
  140. {
  141.     cameraOrientation = q;
  142. }
  145. Quatf
  146. RenderContext::getCameraOrientation() const
  147. {
  148.     return cameraOrientation;
  149. }
  152. void
  153. RenderContext::drawGroup(const Mesh::PrimitiveGroup& group)
  154. {
  155.     // Skip rendering if this is the emissive pass but there's no
  156.     // emissive texture.
  157.     if (renderPass == EmissivePass &&
  158.         material->maps[Mesh::EmissiveMap] == InvalidResource)
  159.     {
  160.         return;
  161.     }
  163.     if (group.prim == Mesh::SpriteList)
  164.     {
  165.         glEnable(GL_POINT_SPRITE_ARB);
  166.         glx::glActiveTextureARB(GL_TEXTURE0_ARB);
  167.         glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
  168.         glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
  169.     }
  171.     glDrawElements(GLPrimitiveModes[(int) group.prim],
  172.                    group.nIndices,
  173.                    GL_UNSIGNED_INT,
  174.                    group.indices);
  176.     if (group.prim == Mesh::SpriteList)
  177.     {
  178.         glDisable(GL_POINT_SPRITE_ARB);
  179.         glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
  180.     }
  181. }
  184. FixedFunctionRenderContext::FixedFunctionRenderContext() :
  185.     RenderContext(),
  186.     blendMode(Mesh::InvalidBlend),
  187.     specularOn(false),
  188.     lightingEnabled(true)
  189. {
  190. }
  193. FixedFunctionRenderContext::FixedFunctionRenderContext(const Mesh::Material* _material) :
  194.     RenderContext(_material),
  195.     blendMode(Mesh::InvalidBlend),
  196.     specularOn(false),
  197.     lightingEnabled(true)
  198. {
  199. }
  202. FixedFunctionRenderContext::~FixedFunctionRenderContext()
  203. {
  204.     glDisableClientState(GL_VERTEX_ARRAY);
  205.     glDisableClientState(GL_NORMAL_ARRAY);
  206.     glDisableClientState(GL_COLOR_ARRAY);
  207.     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  208. }
  211. static int blah = 0;
  212. void
  213. FixedFunctionRenderContext::makeCurrent(const Mesh::Material& m)
  214. {
  215.     if (getRenderPass() == PrimaryPass)
  216.     {
  217.         Texture* t = NULL;
  218.         if (m.maps[Mesh::DiffuseMap] != InvalidResource && useTexCoords)
  219.             t = GetTextureManager()->find(m.maps[Mesh::DiffuseMap]);
  221.         if (t == NULL)
  222.         {
  223.             glDisable(GL_TEXTURE_2D);
  224.         }
  225.         else
  226.         {
  227.             glEnable(GL_TEXTURE_2D);
  228.             t->bind();
  229.         }
  231.         Mesh::BlendMode newBlendMode = Mesh::InvalidBlend;
  232.         if (m.opacity != 1.0f ||
  233.             m.blend == Mesh::AdditiveBlend ||
  234.             (t != NULL && t->hasAlpha()))
  235.         {
  236.             newBlendMode = m.blend;
  237.         }
  239.         if (newBlendMode != blendMode)
  240.         {
  241.             blendMode = newBlendMode;
  242.             switch (blendMode)
  243.             {
  244.             case Mesh::NormalBlend:
  245.                 glEnable(GL_BLEND);
  246.                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  247.                 glDepthMask(GL_FALSE);
  248.                 break;
  249.             case Mesh::AdditiveBlend:
  250.                 glEnable(GL_BLEND);
  251.                 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  252.                 glDepthMask(GL_FALSE);
  253.                 break;
  254.             case Mesh::PremultipliedAlphaBlend:
  255.                 glEnable(GL_BLEND);
  256.                 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  257.                 glDepthMask(GL_FALSE);
  258.                 break;
  259.             default:
  260.                 glDisable(GL_BLEND);
  261.                 glDepthMask(GL_TRUE);
  262.                 break;
  263.             }
  264.         }
  266.         if (useNormals || !lightingEnabled)
  267.         {
  268. #ifdef HDR_COMPRESS
  269.             glColor4f(m.diffuse.red()   * 0.5f,
  270.                       m.diffuse.green() * 0.5f,
  271.                       m.diffuse.blue()  * 0.5f,
  272.                       m.opacity);
  273. #else
  274.             glColor4f(m.diffuse.red(),
  275.                       m.diffuse.green(),
  276.                       m.diffuse.blue(),
  277.                       m.opacity);
  278. #endif
  280.             if (m.specular == Color::Black)
  281.             {
  282.                 float matSpecular[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
  283.                 float zero = 0.0f;
  284.                 glMaterialfv(GL_FRONT, GL_SPECULAR, matSpecular);
  285.                 glMaterialfv(GL_FRONT, GL_SHININESS, &zero);
  286.                 specularOn = false;
  287.             }
  288.             else
  289.             {
  290.                 float matSpecular[4] = { m.specular.red(),
  291.                                          m.specular.green(),
  292.                                          m.specular.blue(),
  293.                                          0.0f };
  294.                 glMaterialfv(GL_FRONT, GL_SPECULAR, matSpecular);
  295.                 glMaterialfv(GL_FRONT, GL_SHININESS, &m.specularPower);
  296.                 specularOn = true;
  297.             }
  298.             
  299.             {
  300.                 float matEmissive[4] = { m.emissive.red(),
  301.                                          m.emissive.green(),
  302.                                          m.emissive.blue(),
  303.                                          0.0f };
  304.                 glMaterialfv(GL_FRONT, GL_EMISSION, matEmissive);
  305.             }
  306.         }
  307.         else
  308.         {
  309.             // When lighting without normals, we'll just merge everything
  310.             // into the emissive color. This makes normal-less lighting work
  311.             // more like it does in the GLSL path, though it's not very
  312.             // useful without shadows.
  313.             float matBlack[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
  314.             float zero = 0.0f;
  315.             glMaterialfv(GL_FRONT, GL_DIFFUSE, matBlack);
  316.             glMaterialfv(GL_FRONT, GL_SPECULAR, matBlack);
  317.             glMaterialfv(GL_FRONT, GL_SHININESS, &zero);
  318.             {
  319. #ifdef HDR_COMPRESS
  320.                 float matEmissive[4] = { m.emissive.red() + m.diffuse.red() * 0.5f,
  321.                                          m.emissive.green() + m.diffuse.green() * 0.5f,
  322.                                          m.emissive.blue() + m.diffuse.blue() * 0.5f,
  323.                                          m.opacity };
  324. #else
  325.                 float matEmissive[4] = { m.emissive.red() + m.diffuse.red(),
  326.                                          m.emissive.green() + m.diffuse.green(),
  327.                                          m.emissive.blue() + m.diffuse.blue(),
  328.                                          m.opacity };
  329. #endif
  330.                 glMaterialfv(GL_FRONT, GL_EMISSION, matEmissive);
  331.             }
  332.         }
  333.     }
  334.     else if (getRenderPass() == EmissivePass)
  335.     {
  336.         Texture* t = NULL;
  337.         if (m.maps[Mesh::EmissiveMap] != InvalidResource && useTexCoords)
  338.             t = GetTextureManager()->find(m.maps[Mesh::EmissiveMap]);
  340.         if (t == NULL)
  341.         {
  342.             glDisable(GL_TEXTURE_2D);
  343.         }
  344.         else
  345.         {
  346.             glEnable(GL_TEXTURE_2D);
  347.             t->bind();
  348.         }
  349.     }
  350. }
  353. void
  354. FixedFunctionRenderContext::setVertexArrays(const Mesh::VertexDescription& desc, void* vertexData)
  355. {
  356.     // Update the material if normals appear or disappear in the vertex
  357.     // description.
  358.     bool useNormalsNow = (desc.getAttribute(Mesh::Normal).format == Mesh::Float3);
  359.     bool useColorsNow = (desc.getAttribute(Mesh::Color0).format != Mesh::InvalidFormat);
  360.     bool useTexCoordsNow = (desc.getAttribute(Mesh::Texture0).format != Mesh::InvalidFormat);
  362.     if (useNormalsNow != useNormals ||
  363.         useColorsNow != useColors ||
  364.         useTexCoordsNow != useTexCoords)
  365.     {
  366.         useNormals = useNormalsNow;
  367.         useColors = useColorsNow;
  368.         useTexCoords = useTexCoordsNow;
  369.         if (getMaterial() != NULL)
  370.             makeCurrent(*getMaterial());
  371.     }
  373.     setStandardVertexArrays(desc, vertexData);
  374. }
  377. void
  378. FixedFunctionRenderContext::setLighting(bool enabled)
  379. {
  380.     lightingEnabled = enabled;
  381.     if (lightingEnabled)
  382.         glEnable(GL_LIGHTING);
  383.     else
  384.         glDisable(GL_LIGHTING);
  385. }
  388. void
  389. VP_Combiner_RenderContext::setVertexArrays(const Mesh::VertexDescription& desc, void* vertexData)
  390. {
  391.     setStandardVertexArrays(desc, vertexData);
  392.     setExtendedVertexArrays(desc, vertexData);
  393. }
  396. void
  397. VP_FP_RenderContext::setVertexArrays(const Mesh::VertexDescription& desc, void* vertexData)
  398. {
  399.     setStandardVertexArrays(desc, vertexData);
  400.     setExtendedVertexArrays(desc, vertexData);
  401. }
  406. void
  407. setStandardVertexArrays(const Mesh::VertexDescription& desc,
  408.                         void* vertexData)
  409. {
  410.     const Mesh::VertexAttribute& position  = desc.getAttribute(Mesh::Position);
  411.     const Mesh::VertexAttribute& normal    = desc.getAttribute(Mesh::Normal);
  412.     const Mesh::VertexAttribute& color0    = desc.getAttribute(Mesh::Color0);
  413.     const Mesh::VertexAttribute& texCoord0 = desc.getAttribute(Mesh::Texture0);
  415.     // Can't render anything unless we have positions
  416.     if (position.format != Mesh::Float3)
  417.         return;
  419.     // Set up the vertex arrays
  420.     glEnableClientState(GL_VERTEX_ARRAY);
  421.     glVertexPointer(3, GL_FLOAT, desc.stride,
  422.                     reinterpret_cast<char*>(vertexData) + position.offset);
  424.     // Set up the normal array
  425.     switch (normal.format)
  426.     {
  427.     case Mesh::Float3:
  428.         glEnableClientState(GL_NORMAL_ARRAY);
  429.         glNormalPointer(GLComponentTypes[(int) normal.format],
  430.                         desc.stride,
  431.                         reinterpret_cast<char*>(vertexData) + normal.offset);
  432.         break;
  433.     default:
  434.         glDisableClientState(GL_NORMAL_ARRAY);
  435.         break;
  436.     }
  438.     // Set up the color array
  439.     switch (color0.format)
  440.     {
  441.     case Mesh::Float3:
  442.     case Mesh::Float4:
  443.     case Mesh::UByte4:
  444.         glEnableClientState(GL_COLOR_ARRAY);
  445.         glColorPointer(GLComponentCounts[color0.format],
  446.                        GLComponentTypes[color0.format],
  447.                        desc.stride,
  448.                        reinterpret_cast<char*>(vertexData) + color0.offset);
  449.         break;
  450.     default:
  451.         glDisableClientState(GL_COLOR_ARRAY);
  452.         break;
  453.     }
  455.     // Set up the texture coordinate array
  456.     switch (texCoord0.format)
  457.     {
  458.     case Mesh::Float1:
  459.     case Mesh::Float2:
  460.     case Mesh::Float3:
  461.     case Mesh::Float4:
  462.         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  463.         glTexCoordPointer(GLComponentCounts[(int) texCoord0.format],
  464.                           GLComponentTypes[(int) texCoord0.format],
  465.                           desc.stride,
  466.                           reinterpret_cast<char*>(vertexData) + texCoord0.offset);
  467.         break;
  468.     default:
  469.         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  470.         break;
  471.     }
  472. }
  475. void
  476. setExtendedVertexArrays(const Mesh::VertexDescription& desc,
  477.                         const void* vertexData)
  478. {
  479.     const Mesh::VertexAttribute& tangent  = desc.getAttribute(Mesh::Tangent);
  480.     const char* vertices = reinterpret_cast<const char*>(vertexData);
  482.     switch (tangent.format)
  483.     {
  484.     case Mesh::Float3:
  485.         glx::glEnableVertexAttribArrayARB(TangentAttributeIndex);
  486.         glx::glVertexAttribPointerARB(TangentAttributeIndex,
  487.                                       GLComponentCounts[(int) tangent.format],
  488.                                       GLComponentTypes[(int) tangent.format],
  489.                                       GL_FALSE,
  490.                                       desc.stride,
  491.                                       vertices + tangent.offset);
  492.         break;
  493.     default:
  494.         glx::glDisableVertexAttribArrayARB(TangentAttributeIndex);
  495.         break;
  496.     }
  498.     const Mesh::VertexAttribute& pointsize = desc.getAttribute(Mesh::PointSize);
  499.     switch (pointsize.format)
  500.     {
  501.     case Mesh::Float1:
  502.         glx::glEnableVertexAttribArrayARB(PointSizeAttributeIndex);
  503.         glx::glVertexAttribPointerARB(PointSizeAttributeIndex,
  504.                                       GLComponentCounts[(int) pointsize.format],
  505.                                       GLComponentTypes[(int) pointsize.format],
  506.                                       GL_FALSE,
  507.                                       desc.stride,
  508.                                       vertices + pointsize.offset);
  509.         break;
  510.     default:
  511.         glx::glDisableVertexAttribArrayARB(PointSizeAttributeIndex);
  512.         break;
  513.     }
  514. }
  517. /***** GLSL render context ******/
  519. GLSL_RenderContext::GLSL_RenderContext(const LightingState& ls, float _objRadius, const Mat4f& _xform) :
  520.     lightingState(ls),
  521.     atmosphere(NULL),
  522.     blendMode(Mesh::InvalidBlend),
  523.     objRadius(_objRadius),
  524.     xform(_xform),
  525.     lunarLambert(0.0f)
  526. {
  527.     initLightingEnvironment();
  528. }
  531. GLSL_RenderContext::~GLSL_RenderContext()
  532. {
  533.     glDisableClientState(GL_VERTEX_ARRAY);
  534.     glDisableClientState(GL_NORMAL_ARRAY);
  535.     glDisableClientState(GL_COLOR_ARRAY);
  536.     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  537.     glx::glDisableVertexAttribArrayARB(TangentAttributeIndex);
  538.     glx::glDisableVertexAttribArrayARB(PointSizeAttributeIndex);
  539. }
  542. void
  543. GLSL_RenderContext::initLightingEnvironment()
  544. {
  545.     // Set the light and shadow environment, which is constant for the entire model.
  546.     // The material properties will be set per mesh.
  547.     shaderProps.nLights = min(lightingState.nLights, MaxShaderLights);
  549.     // Set the shadow information.
  550.     // Track the total number of shadows; if there are too many, we'll have
  551.     // to fall back to multipass.
  552.     unsigned int totalShadows = 0;
  553.     for (unsigned int li = 0; li < lightingState.nLights; li++)
  554.     {
  555.         if (lightingState.shadows[li] && !lightingState.shadows[li]->empty())
  556.         {
  557.             unsigned int nShadows = (unsigned int) min((size_t) MaxShaderShadows, lightingState.shadows[li]->size());
  558.             shaderProps.setShadowCountForLight(li, nShadows);
  559.             totalShadows += nShadows;
  560.         }
  561.     }
  563. }
  565. void
  566. GLSL_RenderContext::makeCurrent(const Mesh::Material& m)
  567. {
  568.     Texture* textures[4] = { NULL, NULL, NULL, NULL };
  569.     unsigned int nTextures = 0;
  571.     // Set up the textures used by this object
  572.     Texture* baseTex = NULL;
  573.     Texture* bumpTex = NULL;
  574.     Texture* specTex = NULL;
  575.     Texture* emissiveTex = NULL;
  577.     shaderProps.texUsage = ShaderProperties::SharedTextureCoords;
  579.     if (useNormals)
  580.     {
  581.         if (lunarLambert == 0.0f)
  582.             shaderProps.lightModel = ShaderProperties::DiffuseModel;
  583.         else
  584.             shaderProps.lightModel = ShaderProperties::LunarLambertModel;
  585.     }
  586.     else
  587.     {
  588.         // "particle" lighting is the only type that doesn't
  589.         // depend on having a surface normal.
  590.         // Enable alternate particle model when vertex colors are present;
  591.         // eventually, a render context method will enable the particle
  592.         // model.
  593.         if (useColors)
  594.             shaderProps.lightModel = ShaderProperties::ParticleModel;
  595.         else
  596.             shaderProps.lightModel = ShaderProperties::ParticleDiffuseModel;
  597.     }
  599.     if (m.maps[Mesh::DiffuseMap] != InvalidResource && (useTexCoords || usePointSize))
  600.     {
  601.         baseTex = GetTextureManager()->find(m.maps[Mesh::DiffuseMap]);
  602.         if (baseTex != NULL)
  603.         {
  604.             shaderProps.texUsage |= ShaderProperties::DiffuseTexture;
  605.             textures[nTextures++] = baseTex;
  606.         }
  607.     }
  609.     if (m.maps[Mesh::NormalMap] != InvalidResource)
  610.     {
  611.         bumpTex = GetTextureManager()->find(m.maps[Mesh::NormalMap]);
  612.         if (bumpTex != NULL)
  613.         {
  614.             shaderProps.texUsage |= ShaderProperties::NormalTexture;
  615.             if (bumpTex->getFormatOptions() & Texture::DXT5NormalMap)
  616.             {
  617.                 shaderProps.texUsage |= ShaderProperties::CompressedNormalTexture;
  618.             }
  619.             textures[nTextures++] = bumpTex;
  620.         }
  621.     }
  623.     if (m.specular != Color::Black && useNormals)
  624.     {
  625.         shaderProps.lightModel = ShaderProperties::PerPixelSpecularModel;
  626.         specTex = GetTextureManager()->find(m.maps[Mesh::SpecularMap]);
  627.         if (specTex == NULL)
  628.         {
  629.             if (baseTex != NULL)
  630.                 shaderProps.texUsage |= ShaderProperties::SpecularInDiffuseAlpha;
  631.         }
  632.         else
  633.         {
  634.             shaderProps.texUsage |= ShaderProperties::SpecularTexture;
  635.             textures[nTextures++] = specTex;
  636.         }
  637.     }
  639.     if (m.maps[Mesh::EmissiveMap] != InvalidResource)
  640.     {
  641.         emissiveTex = GetTextureManager()->find(m.maps[Mesh::EmissiveMap]);
  642.         if (emissiveTex != NULL)
  643.         {
  644.             shaderProps.texUsage |= ShaderProperties::EmissiveTexture;
  645.             textures[nTextures++] = emissiveTex;
  646.         }
  647.     }
  649.     if (usePointSize)
  650.         shaderProps.texUsage |= ShaderProperties::PointSprite;
  651.     if (useColors)
  652.         shaderProps.texUsage |= ShaderProperties::VertexColors;
  654.     if (atmosphere != NULL)
  655.     {
  656.         // Only use new atmosphere code in OpenGL 2.0 path when new style parameters are defined.
  657.         if (atmosphere->mieScaleHeight > 0.0f)
  658.             shaderProps.texUsage |= ShaderProperties::Scattering;
  659.     }
  661.     // Get a shader for the current rendering configuration
  662.     CelestiaGLProgram* prog = GetShaderManager().getShader(shaderProps);
  663.     if (prog == NULL)
  664.         return;
  666.     prog->use();
  668.     for (unsigned int i = 0; i < nTextures; i++)
  669.     {
  670.         glx::glActiveTextureARB(GL_TEXTURE0_ARB + i);
  671.         glEnable(GL_TEXTURE_2D);
  672.         textures[i]->bind();
  673.     }
  675.     // setLightParameters() expects opacity in the alpha channel of the diffuse color
  676. #ifdef HDR_COMPRESS
  677.     Color diffuse(m.diffuse.red() * 0.5f, m.diffuse.green() * 0.5f, m.diffuse.blue() * 0.5f, m.opacity);
  678. #else
  679.     Color diffuse(m.diffuse.red(), m.diffuse.green(), m.diffuse.blue(), m.opacity);
  680. #endif
  682.     prog->setLightParameters(lightingState, diffuse, m.specular, m.emissive);
  684.     if (shaderProps.shadowCounts != 0)
  685.         prog->setEclipseShadowParameters(lightingState, objRadius, xform);
  687.     // TODO: handle emissive color
  688.     prog->shininess = m.specularPower;
  689.     if (shaderProps.lightModel == ShaderProperties::LunarLambertModel)
  690.     {
  691.         prog->lunarLambert = lunarLambert;
  692.     }
  694.     // Generally, we want to disable depth writes for blend because it
  695.     // makes translucent objects look a bit better (though there are
  696.     // still problems when rendering them without sorting.) However,
  697.     // when scattering atmospheres are enabled, we need to render with
  698.     // depth writes on, otherwise the atmosphere will be drawn over
  699.     // a planet mesh. See SourceForge bug #1855894 for more details.
  700.     bool disableDepthWriteOnBlend = true;
  702.     if (shaderProps.hasScattering())
  703.     {
  704.         prog->setAtmosphereParameters(*atmosphere, objRadius, objRadius);
  705.         disableDepthWriteOnBlend = false;
  706.     }
  708.     if ((shaderProps.texUsage & ShaderProperties::PointSprite) != 0)
  709.     {
  710.         prog->pointScale = getPointScale();
  711.     }
  713.     Mesh::BlendMode newBlendMode = Mesh::InvalidBlend;
  714.     if (m.opacity != 1.0f ||
  715.         m.blend == Mesh::AdditiveBlend ||
  716.         (baseTex != NULL && baseTex->hasAlpha()))
  717.     {
  718.         newBlendMode = m.blend;
  719.     }
  721.     if (newBlendMode != blendMode)
  722.     {
  723.         blendMode = newBlendMode;
  724.         switch (blendMode)
  725.         {
  726.         case Mesh::NormalBlend:
  727.             glEnable(GL_BLEND);
  728.             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  729.             glDepthMask(disableDepthWriteOnBlend ? GL_FALSE : GL_TRUE);
  730.             break;
  731.         case Mesh::AdditiveBlend:
  732.             glEnable(GL_BLEND);
  733.             glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  734.             glDepthMask(disableDepthWriteOnBlend ? GL_FALSE : GL_TRUE);
  735.             break;
  736.         case Mesh::PremultipliedAlphaBlend:
  737.             glEnable(GL_BLEND);
  738.             glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  739.             glDepthMask(disableDepthWriteOnBlend ? GL_FALSE : GL_TRUE);
  740.             break;                
  741.         default:
  742.             glDisable(GL_BLEND);
  743.             glDepthMask(GL_TRUE);
  744.             break;
  745.         }
  746.     }
  747. }
  750. void
  751. GLSL_RenderContext::setVertexArrays(const Mesh::VertexDescription& desc,
  752.                                     void* vertexData)
  753. {
  754.     setStandardVertexArrays(desc, vertexData);
  755.     setExtendedVertexArrays(desc, vertexData);
  757.     // Normally, the shader that will be used depends only on the material.
  758.     // But the presence of point size and normals can also affect the
  759.     // shader, so force an update of the material if those attributes appear
  760.     // or disappear in the new set of vertex arrays.
  761.     bool usePointSizeNow = (desc.getAttribute(Mesh::PointSize).format == Mesh::Float1);
  762.     bool useNormalsNow = (desc.getAttribute(Mesh::Normal).format == Mesh::Float3);
  763.     bool useColorsNow = (desc.getAttribute(Mesh::Color0).format != Mesh::InvalidFormat);
  764.     bool useTexCoordsNow = (desc.getAttribute(Mesh::Texture0).format != Mesh::InvalidFormat);
  766.     if (usePointSizeNow != usePointSize ||
  767.         useNormalsNow   != useNormals   ||
  768.         useColorsNow    != useColors    ||
  769.         useTexCoordsNow != useTexCoords)
  770.     {
  771.         usePointSize = usePointSizeNow;
  772.         useNormals = useNormalsNow;
  773.         useColors = useColorsNow;
  774.         useTexCoords = useTexCoordsNow;
  775.         if (getMaterial() != NULL)
  776.             makeCurrent(*getMaterial());
  777.     }
  778. }
  781. void
  782. GLSL_RenderContext::setAtmosphere(const Atmosphere* _atmosphere)
  783. {
  784.     atmosphere = _atmosphere;
  785. }
  787. // Extended material properties -- currently just lunarLambert term
  788. void
  789. GLSL_RenderContext::setLunarLambert(float l)
  790. {
  791.     lunarLambert = l;
  792. }
  795. /***** GLSL-Unlit render context ******/
  797. GLSLUnlit_RenderContext::GLSLUnlit_RenderContext(float _objRadius) :
  798.     blendMode(Mesh::InvalidBlend),
  799.     objRadius(_objRadius)
  800. {
  801.     initLightingEnvironment();
  802. }
  805. GLSLUnlit_RenderContext::~GLSLUnlit_RenderContext()
  806. {
  807.     glDisableClientState(GL_VERTEX_ARRAY);
  808.     glDisableClientState(GL_NORMAL_ARRAY);
  809.     glDisableClientState(GL_COLOR_ARRAY);
  810.     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  811.     glx::glDisableVertexAttribArrayARB(TangentAttributeIndex);
  812.     glx::glDisableVertexAttribArrayARB(PointSizeAttributeIndex);
  813. }
  816. void
  817. GLSLUnlit_RenderContext::initLightingEnvironment()
  818. {
  819.     // Set the light and shadow environment, which is constant for the entire model.
  820.     // The material properties will be set per mesh.
  821.     shaderProps.nLights = 1;
  822. }
  825. void
  826. GLSLUnlit_RenderContext::makeCurrent(const Mesh::Material& m)
  827. {
  828.     Texture* textures[4] = { NULL, NULL, NULL, NULL };
  829.     unsigned int nTextures = 0;
  831.     // Set up the textures used by this object
  832.     Texture* baseTex = NULL;
  834.     shaderProps.lightModel = ShaderProperties::EmissiveModel;
  835.     shaderProps.texUsage = ShaderProperties::SharedTextureCoords;
  837.     if (m.maps[Mesh::DiffuseMap] != InvalidResource && (useTexCoords || usePointSize))
  838.     {
  839.         baseTex = GetTextureManager()->find(m.maps[Mesh::DiffuseMap]);
  840.         if (baseTex != NULL)
  841.         {
  842.             shaderProps.texUsage |= ShaderProperties::DiffuseTexture;
  843.             textures[nTextures++] = baseTex;
  844.         }
  845.     }
  847.     if (usePointSize)
  848.         shaderProps.texUsage |= ShaderProperties::PointSprite;
  849.     if (useColors)
  850.         shaderProps.texUsage |= ShaderProperties::VertexColors;
  852.     // Get a shader for the current rendering configuration
  853.     CelestiaGLProgram* prog = GetShaderManager().getShader(shaderProps);
  854.     if (prog == NULL)
  855.         return;
  857.     prog->use();
  859.     for (unsigned int i = 0; i < nTextures; i++)
  860.     {
  861.         glx::glActiveTextureARB(GL_TEXTURE0_ARB + i);
  862.         glEnable(GL_TEXTURE_2D);
  863.         textures[i]->bind();
  864.     }
  866. #ifdef HDR_COMPRESS
  867.     prog->lights[0].diffuse = Vec3f(m.diffuse.red()   * 0.5f,
  868.                                     m.diffuse.green() * 0.5f,
  869.                                     m.diffuse.blue()  * 0.5f);
  870. #else
  871.     prog->lights[0].diffuse = Vec3f(m.diffuse.red(),
  872.                                     m.diffuse.green(),
  873.                                     m.diffuse.blue());
  874. #endif
  875.     prog->opacity = m.opacity;
  877.     if ((shaderProps.texUsage & ShaderProperties::PointSprite) != 0)
  878.     {
  879.         prog->pointScale = getPointScale();
  880.     }
  882.     Mesh::BlendMode newBlendMode = Mesh::InvalidBlend;
  883.     if (m.opacity != 1.0f ||
  884.         m.blend == Mesh::AdditiveBlend ||
  885.         (baseTex != NULL && baseTex->hasAlpha()))
  886.     {
  887.         newBlendMode = m.blend;
  888.     }
  890.     if (newBlendMode != blendMode)
  891.     {
  892.         blendMode = newBlendMode;
  893.         switch (blendMode)
  894.         {
  895.         case Mesh::NormalBlend:
  896.             glEnable(GL_BLEND);
  897.             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  898.             glDepthMask(GL_FALSE);
  899.             break;
  900.         case Mesh::AdditiveBlend:
  901.             glEnable(GL_BLEND);
  902.             glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  903.             glDepthMask(GL_FALSE);
  904.             break;
  905.         case Mesh::PremultipliedAlphaBlend:
  906.             glEnable(GL_BLEND);
  907.             glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  908.             glDepthMask(GL_FALSE);
  909.             break;                
  910.         default:
  911.             glDisable(GL_BLEND);
  912.             glDepthMask(GL_TRUE);
  913.             break;
  914.         }
  915.     }
  916. }
  919. void
  920. GLSLUnlit_RenderContext::setVertexArrays(const Mesh::VertexDescription& desc,
  921.                                          void* vertexData)
  922. {
  923.     setStandardVertexArrays(desc, vertexData);
  924.     setExtendedVertexArrays(desc, vertexData);
  926.     // Normally, the shader that will be used depends only on the material.
  927.     // But the presence of point size and normals can also affect the
  928.     // shader, so force an update of the material if those attributes appear
  929.     // or disappear in the new set of vertex arrays.
  930.     bool usePointSizeNow = (desc.getAttribute(Mesh::PointSize).format == Mesh::Float1);
  931.     bool useNormalsNow = (desc.getAttribute(Mesh::Normal).format == Mesh::Float3);
  932.     bool useColorsNow = (desc.getAttribute(Mesh::Color0).format != Mesh::InvalidFormat);
  933.     bool useTexCoordsNow = (desc.getAttribute(Mesh::Texture0).format != Mesh::InvalidFormat);
  935.     if (usePointSizeNow != usePointSize ||
  936.         useNormalsNow   != useNormals   ||
  937.         useColorsNow    != useColors    ||
  938.         useTexCoordsNow != useTexCoords)
  939.     {
  940.         usePointSize = usePointSizeNow;
  941.         useNormals = useNormalsNow;
  942.         useColors = useColorsNow;
  943.         useTexCoords = useTexCoordsNow;
  944.         if (getMaterial() != NULL)
  945.             makeCurrent(*getMaterial());
  946.     }
  947. }