2590 mac intel and radeon pro 5300m horrible fps 2 (#3030)

RunitaiLinden · web-flow · commit 2b255535efbc · 2024-11-12T15:26:38.000-08:00
* OpenGL 3.3 compatibility pass. Fix for FBO driven downscaling corrupting textures. * Increase maximum texture bias, immediately scale down when textures are loaded higher resolution than desired * #2590 Fix for some frame stalls on Intel Macs
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
@@ -2452,41 +2452,32 @@ bool LLImageGL::scaleDown(S32 desired_discard)
 
     if (gGLManager.mDownScaleMethod == 0)
     { // use an FBO to downscale the texture
-        // allocate new texture
-        U32 temp_texname = 0;
-        generateTextures(1, &temp_texname);
-        gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, temp_texname, true);
-        {
-            LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("scaleDown - glTexImage2D");
-            glTexImage2D(mTarget, 0, mFormatInternal, desired_width, desired_height, 0, mFormatPrimary, mFormatType, NULL);
-        }
-
-        // account for new texture getting created
-        alloc_tex_image(desired_width, desired_height, mFormatInternal, 1);
-
-        // Use render-to-texture to scale down the texture
-        {
-            LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("scaleDown - glFramebufferTexture2D");
-            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, mTarget, temp_texname, 0);
-        }
-
         glViewport(0, 0, desired_width, desired_height);
 
         // draw a full screen triangle
-        gGL.getTexUnit(0)->bind(this);
-        glDrawArrays(GL_TRIANGLES, 0, 3);
-        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+        if (gGL.getTexUnit(0)->bind(this, true, true))
+        {
+            glDrawArrays(GL_TRIANGLES, 0, 3);
 
-        // delete old texture and assign new texture name
-        deleteTextures(1, &mTexName);
-        mTexName = temp_texname;
+            free_tex_image(mTexName);
+            glTexImage2D(mTarget, 0, mFormatInternal, desired_width, desired_height, 0, mFormatPrimary, mFormatType, nullptr);
+            glCopyTexSubImage2D(mTarget, 0, 0, 0, 0, 0, desired_width, desired_height);
+            alloc_tex_image(desired_width, desired_height, mFormatInternal, 1);
 
-        if (mHasMipMaps)
-        { // generate mipmaps if needed
-            LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("scaleDown - glGenerateMipmap");
-            gGL.getTexUnit(0)->bind(this);
-            glGenerateMipmap(mTarget);
-            gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+            mTexOptionsDirty = true;
+
+            if (mHasMipMaps)
+            { // generate mipmaps if needed
+                LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("scaleDown - glGenerateMipmap");
+                gGL.getTexUnit(0)->bind(this);
+                glGenerateMipmap(mTarget);
+                gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+            }
+        }
+        else
+        {
+            LL_WARNS_ONCE("LLImageGL") << "Failed to bind texture for downscaling." << LL_ENDL;
+            return false;
         }
     }
     else
diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
@@ -272,11 +272,13 @@ static GLuint gen_buffer()
     {
         LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("gen buffer");
         sIndex = pool_size;
+#if !LL_DARWIN
         if (!gGLManager.mIsAMD)
         {
             glGenBuffers(pool_size, sNamePool);
         }
         else
+#endif
         { // work around for AMD driver bug
             for (U32 i = 0; i < pool_size; ++i)
             {
@@ -942,6 +944,10 @@ void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
 void LLVertexBuffer::initClass(LLWindow* window)
 {
     llassert(sVBOPool == nullptr);
+
+    LL_INFOS() << "VBO Pooling Disabled" << LL_ENDL;
+    sVBOPool = new LLAppleVBOPool();
+
     if (gGLManager.mIsApple)
     {
         LL_INFOS() << "VBO Pooling Disabled" << LL_ENDL;
diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
@@ -7836,7 +7836,7 @@
         <key>Type</key>
         <string>U32</string>
         <key>Value</key>
-        <integer>1</integer>
+        <integer>0</integer>
     </map>
     <key>RenderDebugTextureBind</key>
     <map>
@@ -16038,5 +16038,16 @@
     <key>Value</key>
     <integer>0</integer>
   </map>
+  <key>RenderHDREnabled</key>
+  <map>
+    <key>Comment</key>
+    <string>Enable HDR rendering.</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>Boolean</string>
+    <key>Value</key>
+    <integer>1</integer>
+  </map>
 </map>
 </llsd>
diff --git a/indra/newview/app_settings/shaders/class1/deferred/avatarF.glsl b/indra/newview/app_settings/shaders/class1/deferred/avatarF.glsl
@@ -36,6 +36,7 @@ in vec2 vary_texcoord0;
 in vec3 vary_position;
 
 void mirrorClip(vec3 pos);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
 
 void main()
 {
@@ -51,7 +52,7 @@ void main()
     frag_data[0] = vec4(diff.rgb, 0.0);
     frag_data[1] = vec4(0,0,0,0);
     vec3 nvn = normalize(vary_normal);
-    frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
+    frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
     frag_data[3] = vec4(0);
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/bumpF.glsl b/indra/newview/app_settings/shaders/class1/deferred/bumpF.glsl
@@ -40,6 +40,8 @@ in vec2 vary_texcoord0;
 in vec3 vary_position;
 
 void mirrorClip(vec3 pos);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
+
 void main()
 {
     mirrorClip(vary_position);
@@ -62,6 +64,6 @@ void main()
         frag_data[1] = vertex_color.aaaa; // spec
         //frag_data[1] = vec4(vec3(vertex_color.a), vertex_color.a+(1.0-vertex_color.a)*vertex_color.a); // spec - from former class3 - maybe better, but not so well tested
         vec3 nvn = normalize(tnorm);
-        frag_data[2] = vec4(nvn, GBUFFER_FLAG_HAS_ATMOS);
+        frag_data[2] = encodeNormal(nvn, GBUFFER_FLAG_HAS_ATMOS);
         frag_data[3] = vec4(vertex_color.a, 0, 0, 0);
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl b/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl
@@ -75,6 +75,9 @@ const float ONE_OVER_PI = 0.3183098861;
 vec3 srgb_to_linear(vec3 cs);
 vec3 atmosFragLightingLinear(vec3 light, vec3 additive, vec3 atten);
 
+vec4 decodeNormal(vec4 norm);
+
+
 float calcLegacyDistanceAttenuation(float distance, float falloff)
 {
     float dist_atten = 1.0 - clamp((distance + falloff)/(1.0 + falloff), 0.0, 1.0);
@@ -145,8 +148,7 @@ vec2 getScreenCoordinate(vec2 screenpos)
 
 vec4 getNorm(vec2 screenpos)
 {
-    vec4 norm = texture(normalMap, screenpos.xy);
-    norm.xyz = normalize(norm.xyz);
+    vec4 norm = decodeNormal(texture(normalMap, screenpos.xy));
     return norm;
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/diffuseAlphaMaskF.glsl b/indra/newview/app_settings/shaders/class1/deferred/diffuseAlphaMaskF.glsl
@@ -39,6 +39,8 @@ in vec2 vary_texcoord0;
 
 void mirrorClip(vec3 pos);
 
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
+
 void main()
 {
     mirrorClip(vary_position);
@@ -53,7 +55,7 @@ void main()
     frag_data[0] = vec4(col.rgb, 0.0);
     frag_data[1] = vec4(0,0,0,0); // spec
     vec3 nvn = normalize(vary_normal);
-    frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
+    frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
     frag_data[3] = vec4(0);
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/diffuseAlphaMaskIndexedF.glsl b/indra/newview/app_settings/shaders/class1/deferred/diffuseAlphaMaskIndexedF.glsl
@@ -36,6 +36,7 @@ in vec4 vertex_color;
 in vec2 vary_texcoord0;
 
 void mirrorClip(vec3 pos);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
 
 void main()
 {
@@ -51,6 +52,6 @@ void main()
     frag_data[0] = vec4(col.rgb, 0.0);
     frag_data[1] = vec4(0,0,0,0);
     vec3 nvn = normalize(vary_normal);
-    frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
+    frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
     frag_data[3] = vec4(0);
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/diffuseAlphaMaskNoColorF.glsl b/indra/newview/app_settings/shaders/class1/deferred/diffuseAlphaMaskNoColorF.glsl
@@ -33,6 +33,7 @@ uniform sampler2D diffuseMap;
 
 in vec3 vary_normal;
 in vec2 vary_texcoord0;
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
 
 void main()
 {
@@ -46,7 +47,7 @@ void main()
     frag_data[0] = vec4(col.rgb, 0.0);
     frag_data[1] = vec4(0,0,0,0); // spec
     vec3 nvn = normalize(vary_normal);
-    frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
+    frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
     frag_data[3] = vec4(0);
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/diffuseF.glsl b/indra/newview/app_settings/shaders/class1/deferred/diffuseF.glsl
@@ -35,16 +35,16 @@ in vec2 vary_texcoord0;
 in vec3 vary_position;
 
 void mirrorClip(vec3 pos);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
 
 void main()
 {
     mirrorClip(vary_position);
     vec3 col = vertex_color.rgb * texture(diffuseMap, vary_texcoord0.xy).rgb;
     frag_data[0] = vec4(col, 0.0);
     frag_data[1] = vertex_color.aaaa; // spec
-    //frag_data[1] = vec4(vec3(vertex_color.a), vertex_color.a+(1.0-vertex_color.a)*vertex_color.a); // spec - from former class3 - maybe better, but not so well tested
     vec3 nvn = normalize(vary_normal);
-    frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
+    frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
     frag_data[3] = vec4(vertex_color.a, 0, 0, 0);
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/diffuseIndexedF.glsl b/indra/newview/app_settings/shaders/class1/deferred/diffuseIndexedF.glsl
@@ -33,6 +33,8 @@ in vec2 vary_texcoord0;
 in vec3 vary_position;
 
 void mirrorClip(vec3 pos);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
+
 vec3 linear_to_srgb(vec3 c);
 
 void main()
@@ -46,6 +48,6 @@ void main()
     frag_data[0] = vec4(col, 0.0);
     frag_data[1] = vec4(spec, vertex_color.a); // spec
     vec3 nvn = normalize(vary_normal);
-    frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
+    frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
     frag_data[3] = vec4(vertex_color.a, 0, 0, 0);
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/globalF.glsl b/indra/newview/app_settings/shaders/class1/deferred/globalF.glsl
@@ -43,3 +43,15 @@ void mirrorClip(vec3 pos)
     }
 }
 
+vec4 encodeNormal(vec3 norm, float gbuffer_flag)
+{
+    return vec4(norm * 0.5 + 0.5, gbuffer_flag);
+}
+
+vec4 decodeNormal(vec4 norm)
+{
+    norm.xyz = norm.xyz * 2.0 - 1.0;
+    return norm;
+}
+
+
diff --git a/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl b/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
@@ -38,6 +38,8 @@ in vec2 vary_texcoord0;
 
 vec3 linear_to_srgb(vec3 c);
 
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
+
 void main()
 {
     vec4 col = texture(diffuseMap, vary_texcoord0.xy);
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbropaqueF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbropaqueF.glsl
@@ -61,6 +61,7 @@ uniform vec4 clipPlane;
 uniform float clipSign;
 
 void mirrorClip(vec3 pos);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
 
 uniform mat3 normal_matrix;
 
@@ -113,7 +114,7 @@ void main()
     // See: C++: addDeferredAttachments(), GLSL: softenLightF
     frag_data[0] = max(vec4(col, 0.0), vec4(0));                                                   // Diffuse
     frag_data[1] = max(vec4(spec.rgb,0.0), vec4(0));                                    // PBR linear packed Occlusion, Roughness, Metal.
-    frag_data[2] = vec4(tnorm, GBUFFER_FLAG_HAS_PBR); // normal, environment intensity, flags
+    frag_data[2] = encodeNormal(tnorm, GBUFFER_FLAG_HAS_PBR); // normal, environment intensity, flags
     frag_data[3] = max(vec4(emissive,0), vec4(0));                                                // PBR sRGB Emissive
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbrterrainF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainF.glsl
@@ -162,6 +162,7 @@ in vec4[2] vary_coords;
 #endif
 
 void mirrorClip(vec3 position);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
 
 float terrain_mix(TerrainMix tm, vec4 tms4);
 
@@ -429,7 +430,7 @@ void main()
 #endif
     frag_data[0] = max(vec4(pbr_mix.col.xyz, 0.0), vec4(0));                                                   // Diffuse
     frag_data[1] = max(vec4(mix_orm.rgb, base_color_factor_alpha), vec4(0));                                    // PBR linear packed Occlusion, Roughness, Metal.
-    frag_data[2] = vec4(tnorm, GBUFFER_FLAG_HAS_PBR); // normal, flags
+    frag_data[2] = encodeNormal(tnorm, GBUFFER_FLAG_HAS_PBR); // normal, flags
     frag_data[3] = max(vec4(mix_emissive,0), vec4(0));                                                // PBR sRGB Emissive
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/terrainF.glsl b/indra/newview/app_settings/shaders/class1/deferred/terrainF.glsl
@@ -39,6 +39,7 @@ in vec4 vary_texcoord0;
 in vec4 vary_texcoord1;
 
 void mirrorClip(vec3 position);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
 
 void main()
 {
@@ -60,7 +61,7 @@ void main()
     frag_data[0] = max(outColor, vec4(0));
     frag_data[1] = vec4(0.0,0.0,0.0,-1.0);
     vec3 nvn = normalize(vary_normal);
-    frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
+    frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
     frag_data[3] = vec4(0);
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/treeF.glsl b/indra/newview/app_settings/shaders/class1/deferred/treeF.glsl
@@ -37,6 +37,8 @@ in vec3 vary_position;
 uniform float minimum_alpha;
 
 void mirrorClip(vec3 pos);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
+
 void main()
 {
     mirrorClip(vary_position);
@@ -49,6 +51,6 @@ void main()
     frag_data[0] = vec4(vertex_color.rgb*col.rgb, 0.0);
     frag_data[1] = vec4(0,0,0,0);
     vec3 nvn = normalize(vary_normal);
-    frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
+    frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);
     frag_data[3] = vec4(0);
 }
diff --git a/indra/newview/app_settings/shaders/class1/gltf/pbrmetallicroughnessF.glsl b/indra/newview/app_settings/shaders/class1/gltf/pbrmetallicroughnessF.glsl
@@ -64,6 +64,8 @@ in vec2 base_color_uv;
 in vec2 emissive_uv;
 
 void mirrorClip(vec3 pos);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
+
 vec3 linear_to_srgb(vec3 c);
 vec3 srgb_to_linear(vec3 c);
 // ==================================
@@ -241,7 +243,7 @@ void main()
 #else
     frag_data[0] = max(vec4(basecolor.rgb, 0.0), vec4(0));
     frag_data[1] = max(vec4(orm.rgb,0.0), vec4(0));
-    frag_data[2] = vec4(norm, GBUFFER_FLAG_HAS_PBR);
+    frag_data[2] = encodeNormal(norm, GBUFFER_FLAG_HAS_PBR);
     frag_data[3] = max(vec4(emissive,0), vec4(0));
 #endif
 #endif
diff --git a/indra/newview/app_settings/shaders/class3/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class3/deferred/materialF.glsl
@@ -51,6 +51,7 @@ uniform mat3 normal_matrix;
 in vec3 vary_position;
 
 void mirrorClip(vec3 pos);
+vec4 encodeNormal(vec3 norm, float gbuffer_flag);
 
 #if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_BLEND)
 
@@ -414,7 +415,7 @@ void main()
 
     frag_data[0] = max(vec4(diffcol.rgb, emissive), vec4(0));        // gbuffer is sRGB for legacy materials
     frag_data[1] = max(vec4(spec.rgb, glossiness), vec4(0));           // XYZ = Specular color. W = Specular exponent.
-    frag_data[2] = vec4(norm, flag);   // XY = Normal.  Z = Env. intensity. W = 1 skip atmos (mask off fog)
+    frag_data[2] = encodeNormal(norm, flag);   // XY = Normal.  Z = Env. intensity. W = 1 skip atmos (mask off fog)
     frag_data[3] = vec4(env, 0, 0, 0);
 
 #endif
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -27,6 +27,8 @@
 
 out vec4 frag_color;
 
+vec4 decodeNormal(vec4 norm);
+
 uniform sampler2D diffuseRect;
 uniform sampler2D specularRect;
 uniform sampler2D emissiveRect; // PBR linear packed Occlusion, Roughness, Metal. See: pbropaqueF.glsl
diff --git a/indra/newview/featuretable.txt b/indra/newview/featuretable.txt
diff --git a/indra/newview/llreflectionmapmanager.cpp b/indra/newview/llreflectionmapmanager.cpp
diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
diff --git a/indra/newview/llviewertexture.h b/indra/newview/llviewertexture.h
diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp

Original file line number	Diff line number	Diff line change
`@@ -272,11 +272,13 @@ static GLuint gen_buffer()`
`272`	`272`	`{`
`273`	`273`	`LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("gen buffer");`
`274`	`274`	`sIndex = pool_size;`
	`275`	`+#if !LL_DARWIN`
`275`	`276`	`if (!gGLManager.mIsAMD)`
`276`	`277`	`{`
`277`	`278`	`glGenBuffers(pool_size, sNamePool);`
`278`	`279`	`}`
`279`	`280`	`else`
	`281`	`+#endif`
`280`	`282`	`{ // work around for AMD driver bug`
`281`	`283`	`for (U32 i = 0; i < pool_size; ++i)`
`282`	`284`	`{`
`@@ -942,6 +944,10 @@ void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const`
`942`	`944`	`void LLVertexBuffer::initClass(LLWindow* window)`
`943`	`945`	`{`
`944`	`946`	`llassert(sVBOPool == nullptr);`
	`947`	`+`
	`948`	`+ LL_INFOS() << "VBO Pooling Disabled" << LL_ENDL;`
	`949`	`+ sVBOPool = new LLAppleVBOPool();`
	`950`	`+`
`945`	`951`	`if (gGLManager.mIsApple)`
`946`	`952`	`{`
`947`	`953`	`LL_INFOS() << "VBO Pooling Disabled" << LL_ENDL;`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ in vec2 vary_texcoord0;`
`36`	`36`	`in vec3 vary_position;`
`37`	`37`
`38`	`38`	`void mirrorClip(vec3 pos);`
	`39`	`+vec4 encodeNormal(vec3 norm, float gbuffer_flag);`
`39`	`40`
`40`	`41`	`void main()`
`41`	`42`	`{`
`@@ -51,7 +52,7 @@ void main()`
`51`	`52`	`frag_data[0] = vec4(diff.rgb, 0.0);`
`52`	`53`	`frag_data[1] = vec4(0,0,0,0);`
`53`	`54`	`vec3 nvn = normalize(vary_normal);`
`54`		`- frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);`
	`55`	`+ frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);`
`55`	`56`	`frag_data[3] = vec4(0);`
`56`	`57`	`}`
`57`	`58`
Original file line number	Diff line number	Diff line change
`@@ -75,6 +75,9 @@ const float ONE_OVER_PI = 0.3183098861;`
`75`	`75`	`vec3 srgb_to_linear(vec3 cs);`
`76`	`76`	`vec3 atmosFragLightingLinear(vec3 light, vec3 additive, vec3 atten);`
`77`	`77`
	`78`	`+vec4 decodeNormal(vec4 norm);`
	`79`	`+`
	`80`	`+`
`78`	`81`	`float calcLegacyDistanceAttenuation(float distance, float falloff)`
`79`	`82`	`{`
`80`	`83`	`float dist_atten = 1.0 - clamp((distance + falloff)/(1.0 + falloff), 0.0, 1.0);`
`@@ -145,8 +148,7 @@ vec2 getScreenCoordinate(vec2 screenpos)`
`145`	`148`
`146`	`149`	`vec4 getNorm(vec2 screenpos)`
`147`	`150`	`{`
`148`		`- vec4 norm = texture(normalMap, screenpos.xy);`
`149`		`- norm.xyz = normalize(norm.xyz);`
	`151`	`+ vec4 norm = decodeNormal(texture(normalMap, screenpos.xy));`
`150`	`152`	`return norm;`
`151`	`153`	`}`
`152`	`154`
Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,8 @@ in vec2 vary_texcoord0;`
`39`	`39`
`40`	`40`	`void mirrorClip(vec3 pos);`
`41`	`41`
	`42`	`+vec4 encodeNormal(vec3 norm, float gbuffer_flag);`
	`43`	`+`
`42`	`44`	`void main()`
`43`	`45`	`{`
`44`	`46`	`mirrorClip(vary_position);`
`@@ -53,7 +55,7 @@ void main()`
`53`	`55`	`frag_data[0] = vec4(col.rgb, 0.0);`
`54`	`56`	`frag_data[1] = vec4(0,0,0,0); // spec`
`55`	`57`	`vec3 nvn = normalize(vary_normal);`
`56`		`- frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);`
	`58`	`+ frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);`
`57`	`59`	`frag_data[3] = vec4(0);`
`58`	`60`	`}`
`59`	`61`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ in vec4 vertex_color;`
`36`	`36`	`in vec2 vary_texcoord0;`
`37`	`37`
`38`	`38`	`void mirrorClip(vec3 pos);`
	`39`	`+vec4 encodeNormal(vec3 norm, float gbuffer_flag);`
`39`	`40`
`40`	`41`	`void main()`
`41`	`42`	`{`
`@@ -51,6 +52,6 @@ void main()`
`51`	`52`	`frag_data[0] = vec4(col.rgb, 0.0);`
`52`	`53`	`frag_data[1] = vec4(0,0,0,0);`
`53`	`54`	`vec3 nvn = normalize(vary_normal);`
`54`		`- frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);`
	`55`	`+ frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);`
`55`	`56`	`frag_data[3] = vec4(0);`
`56`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,7 @@ uniform sampler2D diffuseMap;`
`33`	`33`
`34`	`34`	`in vec3 vary_normal;`
`35`	`35`	`in vec2 vary_texcoord0;`
	`36`	`+vec4 encodeNormal(vec3 norm, float gbuffer_flag);`
`36`	`37`
`37`	`38`	`void main()`
`38`	`39`	`{`
`@@ -46,7 +47,7 @@ void main()`
`46`	`47`	`frag_data[0] = vec4(col.rgb, 0.0);`
`47`	`48`	`frag_data[1] = vec4(0,0,0,0); // spec`
`48`	`49`	`vec3 nvn = normalize(vary_normal);`
`49`		`- frag_data[2] = vec4(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);`
	`50`	`+ frag_data[2] = encodeNormal(nvn.xyz, GBUFFER_FLAG_HAS_ATMOS);`
`50`	`51`	`frag_data[3] = vec4(0);`
`51`	`52`	`}`
`52`	`53`