Render rings with BJ Jonsson radial profiles

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: levinli303

src/celengine/body.h

@@ -102,7 +102,9 @@ struct RingSystem
     float innerRadius;
     float outerRadius;
     Color color{ 1.0f, 1.0f, 1.0f };
+    Color unlitColor{ 1.0f, 0.97075f, 0.952f };
     celestia::util::TextureHandle texture{ celestia::util::TextureHandle::Invalid };
+    celestia::util::TextureHandle colorTexture{ celestia::util::TextureHandle::Invalid };
 };
 
 // Object class enumeration:

src/celengine/shadermanager.cpp

@@ -1856,6 +1856,8 @@ buildRingsVertexShader(const ShaderProperties& props, bool fisheyeEnabled)
 GLFragmentShader
 buildRingsFragmentShader(const ShaderProperties& props)
 {
+    bool useProfiles = util::is_set(props.texUsage, TexUsage::RingColorTexture);
+
     std::string source(VersionHeader);
     source += CommonHeader;
     source += FragmentHeader;
@@ -1873,6 +1875,12 @@ buildRingsFragmentShader(const ShaderProperties& props)
         source += DeclareUniform("diffTex", Shader_Sampler2D);
     }
 
+    if (useProfiles)
+    {
+        source += DeclareUniform("ringColorTex", Shader_Sampler2D);
+        source += DeclareUniform("ringUnlitColor", Shader_Vector3);
+    }
+
     if (props.hasEclipseShadows())
     {
         source += DeclareInput("shadowDepths", Shader_Vector4);
@@ -1901,7 +1909,24 @@ buildRingsFragmentShader(const ShaderProperties& props)
         source += "color = texture(diffTex, diffTexCoord.st);\n";
     else
         source += "color = vec4(1.0);\n";
-    source += DeclareLocal("opticalDepth", Shader_Float, "color.a");
+
+    if (useProfiles)
+    {
+        // BJ Jónsson radial-profile encoding:
+        //   diffTex.r = backscattered brightness (lit side, viewer ~ sun direction)
+        //   diffTex.g = forward-scattered brightness (lit side, viewer opposite sun)
+        //   diffTex.b = unlit-side brightness (transparent areas glow as sunlight filters through)
+        //   diffTex.a = transparency (1 - opticalDepth)
+        // ringColorTex supplies the lit-side color profile.
+        source += DeclareLocal("ringColor", Shader_Vector3,
+                               "texture(ringColorTex, diffTexCoord.st).rgb");
+        source += DeclareLocal("opticalDepth", Shader_Float, "1.0 - color.a");
+    }
+    else
+    {
+        source += DeclareLocal("opticalDepth", Shader_Float, "color.a");
+    }
+
     if (props.hasEclipseShadows())
     {
         // Temporaries required for shadows
@@ -1917,15 +1942,35 @@ buildRingsFragmentShader(const ShaderProperties& props)
     // Ring plane normal pointing toward the viewer
     source += DeclareLocal("ringNormal", Shader_Vector3,
                            "vec3(0.0, sign(eyeDir.y), 0.0)");
+    if (useProfiles)
+    {
+        source += DeclareLocal("phase", Shader_Float);
+        source += DeclareLocal("tint", Shader_Vector3);
+    }
 
     for (unsigned i = 0; i < props.nLights; i++)
     {
         // litSide is 1 when viewer and light are on the same side of the rings, 0 otherwise
         source += "litSide = 1.0 - step(0.0, " + LightProperty(i, "direction") + ".y * eyeDir.y);\n";
-        //source += assign("litSide", 1.0f - step(0.0f, sh_vec3("eyePosition")["y"]));
 
-        source += "intensity = (dot(" + LightProperty(i, "direction") + ", eyeDir) + 1.0) * 0.5;\n";
-        source += "intensity = mix(intensity, intensity * (1.0 - opticalDepth), litSide);\n";
+        if (useProfiles)
+        {
+            // phase: 0 at backscatter (light & eye aligned), 1 at forward scatter.
+            // BJ's forward-scattered profile was captured at phase 139 degrees,
+            // so remap so that phase=139 degrees saturates to the G channel.
+            source += "phase = clamp((1.0 - dot(" + LightProperty(i, "direction")
+                      + ", eyeDir)) * 0.5 * (180.0 / 139.0), 0.0, 1.0);\n";
+            // Lit-side brightness blends backscatter and forward-scatter profiles.
+            // Unlit-side brightness comes from the dedicated profile.
+            source += "intensity = mix(mix(color.r, color.g, phase), color.b, litSide);\n";
+            // Apply unlit color tint when viewer sees the unlit side.
+            source += "tint = mix(ringColor, ringColor * ringUnlitColor, litSide);\n";
+        }
+        else
+        {
+            source += "intensity = (dot(" + LightProperty(i, "direction") + ", eyeDir) + 1.0) * 0.5;\n";
+            source += "intensity = mix(intensity, intensity * (1.0 - opticalDepth), litSide);\n";
+        }
 
         // Specular highlight from sunlight reflecting off icy ring particles.
         // Only contributes when the viewer and the light are on the same side
@@ -1935,32 +1980,27 @@ buildRingsFragmentShader(const ShaderProperties& props)
                   + LightProperty(i, "direction") + " + eyeDir), ringNormal)), 32.0);\n";
         source += "specFactor *= (1.0 - litSide) * opticalDepth;\n";
 
+        std::string lightTerm = useProfiles
+            ? "(intensity * tint + vec3(specFactor))"
+            : "(intensity + specFactor)";
+
         if (props.getEclipseShadowCountForLight(i) > 0)
         {
             source += "shadow = 1.0;\n";
             source += Shadow(i, 0);
             source += "shadow = min(1.0, shadow + step(0.0, " + ShadowDepth(i) + "));\n";
-#if 0
-            source += "diff.rgb += (shadow * " + SeparateDiffuse(i) + ") * " +
-                FragLightProperty(i, "color") + ";\n";
-#endif
-            source += "diff.rgb += shadow * (intensity + specFactor) * " + LightProperty(i, "diffuse") + ";\n";
+            source += "diff.rgb += shadow * " + lightTerm + " * " + LightProperty(i, "diffuse") + ";\n";
         }
         else
         {
-            source += "diff.rgb += (intensity + specFactor) * " + LightProperty(i, "diffuse") + ";\n";
-#if 0
-            source += SeparateDiffuse(i) + " = (dot(" +
-                LightProperty(i, "direction") + ", eyeDir) + 1.0) * 0.5;\n";
-#endif
-#if 0
-            source += "diff.rgb += " + SeparateDiffuse(i) + " * " +
-                FragLightProperty(i, "color") + ";\n";
-#endif
+            source += "diff.rgb += " + lightTerm + " * " + LightProperty(i, "diffuse") + ";\n";
         }
     }
 
-    source += "fragColor = vec4(color.rgb * diff.rgb, opticalDepth);\n";
+    if (useProfiles)
+        source += "fragColor = vec4(diff.rgb, opticalDepth);\n";
+    else
+        source += "fragColor = vec4(color.rgb * diff.rgb, opticalDepth);\n";
 
     source += "}\n";
 
@@ -2873,6 +2913,8 @@ CelestiaGLProgram::initParameters()
     {
         ringWidth            = floatParam("ringWidth");
         ringRadius           = floatParam("ringRadius");
+        if (util::is_set(props.texUsage, TexUsage::RingColorTexture))
+            ringUnlitColor   = vec3Param("ringUnlitColor");
     }
 
     textureOffset = floatParam("texCoordOffset");
@@ -2987,6 +3029,13 @@ CelestiaGLProgram::initSamplers()
         if (GLint slot = glGetUniformLocation(program.getID(), "shadowMapTex0"); slot != -1)
             glUniform1i(slot, nSamplers);
     }
+
+    if (util::is_set(props.texUsage, TexUsage::RingColorTexture))
+    {
+        if (GLint slot = glGetUniformLocation(program.getID(), "ringColorTex"); slot != -1)
+            glUniform1i(slot, nSamplers);
+        nSamplers++;
+    }
 }
 
 void

src/celengine/shadermanager.h

@@ -71,6 +71,7 @@ enum class TexUsage : std::uint32_t
     StaticPointSize         = 0x10000,
     LineAsTriangles         = 0x20000,
     TextureCoordTransform   = 0x40000,
+    RingColorTexture        = 0x80000,
 };
 
 ENUM_CLASS_BITWISE_OPS(TexUsage);
@@ -257,6 +258,7 @@ class CelestiaGLProgram
     FloatShaderParameter ringRadius;
     Vec4ShaderParameter ringPlane;
     Vec3ShaderParameter ringCenter;
+    Vec3ShaderParameter ringUnlitColor;
 
     // Mix of Lambertian and "lunar" (Lommel-Seeliger) photometric models.
     // 0 = pure Lambertian, 1 = L-S

src/celengine/solarsys.cpp

@@ -1325,12 +1325,22 @@ void ReadRings(Body* body,
     if (auto color = ringsData->getColor("Color"); color.has_value())
         rings->color = *color;
 
+    if (auto unlitColor = ringsData->getColor("UnlitColor"); unlitColor.has_value())
+        rings->unlitColor = *unlitColor;
+
     if (auto textureName = GetFilename(*ringsData, "Texture"sv, "Invalid filename in rings Texture\n");
         textureName.has_value())
     {
         rings->texture = texturePaths.getHandle(*textureName, path);
     }
 
+    if (auto colorTextureName = GetFilename(*ringsData, "ColorTexture"sv,
+                                            "Invalid filename in rings ColorTexture\n");
+        colorTextureName.has_value())
+    {
+        rings->colorTexture = texturePaths.getHandle(*colorTextureName, path);
+    }
+
     if (newRings != nullptr)
         bodyFeaturesManager->setRings(body, std::move(newRings));
 }

src/celrender/ringrenderer.cpp

@@ -18,6 +18,7 @@
 
 #include <celcompat/numbers.h>
 #include <celengine/body.h>
+#include <celengine/glsupport.h>
 #include <celengine/lightenv.h>
 #include <celengine/render.h>
 #include <celengine/renderinfo.h>
@@ -44,6 +45,7 @@ struct RingVertex
 ShaderProperties
 createShaderProperties(const LightingState& ls,
                        const Texture* ringsTex,
+                       const Texture* colorTex,
                        bool renderShadow)
 {
     // Set up the shader properties for ring rendering
@@ -61,6 +63,12 @@ createShaderProperties(const LightingState& ls,
     if (ringsTex != nullptr)
         shadprop.texUsage = TexUsage::DiffuseTexture;
 
+    // BJ Jónsson radial-profile mode: enabled when both the profile texture
+    // (RGBA: back/forward/unlit/transparency) and a separate color texture
+    // are supplied.
+    if (ringsTex != nullptr && colorTex != nullptr)
+        shadprop.texUsage |= TexUsage::RingColorTexture;
+
     return shadprop;
 }
 
@@ -158,8 +166,10 @@ RingRenderer::renderRings(const RingSystem& rings,
     float inner = rings.innerRadius / planetRadius;
     float outer = rings.outerRadius / planetRadius;
     Texture* ringsTex = renderer.getTextureManager()->find(rings.texture);
+    Texture* colorTex = renderer.getTextureManager()->find(rings.colorTexture);
+    bool useProfiles = ringsTex != nullptr && colorTex != nullptr;
 
-    ShaderProperties shadprop = createShaderProperties(ls, ringsTex, renderShadow);
+    ShaderProperties shadprop = createShaderProperties(ls, ringsTex, colorTex, renderShadow);
 
     // Get a shader for the current rendering configuration
     auto* prog = renderer.getShaderManager().getShader(shadprop);
@@ -171,15 +181,32 @@ RingRenderer::renderRings(const RingSystem& rings,
 
     prog->eyePosition = ls.eyePos_obj;
     prog->ambientColor = ri.ambientColor.toVector3();
-    prog->setLightParameters(ls, ri.color, ri.specularColor, Color::Black);
+    // In BJ-profile mode the ColorTexture supplies the ring tint, so don't
+    // double-tint by baking ri.color into light.diffuse.
+    Color lightDiffuseTint = useProfiles ? Color::White : ri.color;
+    prog->setLightParameters(ls, lightDiffuseTint, ri.specularColor, Color::Black);
 
     prog->ringRadius = inner;
     prog->ringWidth = outer - inner;
+    if (useProfiles)
+        prog->ringUnlitColor = rings.unlitColor.toVector3();
 
     setUpShadowParameters(prog, ls, planetOblateness);
 
+    unsigned int texUnit = 0;
     if (ringsTex != nullptr)
+    {
+        glActiveTexture(GL_TEXTURE0 + texUnit);
         ringsTex->bind();
+        texUnit++;
+    }
+    if (useProfiles)
+    {
+        glActiveTexture(GL_TEXTURE0 + texUnit);
+        colorTex->bind();
+        texUnit++;
+    }
+    glActiveTexture(GL_TEXTURE0);
 
     // Determine level of detail
     std::uint32_t nSections = BaseSectionCount;