Merge pull request #657 from secondlife/DRTVWR-592

Merge PBR terrain and put PBR terrain behind feature flag.

6 files changed, 865 insertions, 8 deletions

diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 4a95cb1ed2..df30b8d298 100644
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -10825,7 +10825,7 @@
     <key>RenderTerrainScale</key>
     <map>
       <key>Comment</key>
-      <string>Terrain detail texture scale</string>
+      <string>Terrain detail texture scale (meters)</string>
       <key>Persist</key>
       <integer>1</integer>
       <key>Type</key>
@@ -10833,6 +10833,61 @@
       <key>Value</key>
       <real>12.0</real>
     </map>
+    <key>RenderTerrainPBREnabled</key>
+    <map>
+      <key>Comment</key>
+      <string>EXPERIMENTAL: Enable PBR Terrain features. Requires restart.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
+    <key>RenderTerrainPBRDetail</key>
+    <map>
+      <key>Comment</key>
+      <string>Detail level for PBR terrain. 0 is full detail. Negative values drop rendering features in accordance with the GLTF specification, which reduces the number of texture binds. Some Intel and Mac graphics drivers do not support more than 16 texture binds. Because PBR terrain exceeds this limit at the highest detail level, reducing texture binds is necessary for compatibility.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>S32</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
+    <key>RenderTerrainPBRScale</key>
+    <map>
+      <key>Comment</key>
+      <string>PBR terrain detail texture scale (meters)</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <real>4.0</real>
+    </map>
+    <key>RenderTerrainPBRPlanarSampleCount</key>
+    <map>
+      <key>Comment</key>
+      <string>How many UV planes to sample PBR terrain textures from. 1 is "flat", 3 is triplanar mapping (aka box mapping)</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>S32</string>
+      <key>Value</key>
+      <real>3</real>
+    </map>
+    <key>RenderTerrainPBRTriplanarBlendFactor</key>
+    <map>
+      <key>Comment</key>
+      <string>Higher values create sharper transitions, but are more likely to produce artifacts.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>F32</string>
+      <key>Value</key>
+      <real>8.0</real>
+    </map>
     <key>RenderTrackerBeacon</key>
     <map>
       <key>Comment</key>
@@ -16576,6 +16631,50 @@
       <key>Value</key>
       <integer>0</integer>
     </map>
+	<key>LocalTerrainAsset1</key>
+    <map>
+      <key>Comment</key>
+      <string>If set to a non-null UUID, overrides the terrain asset locally for all regions with material assets. Local terrain assets are not visible to others. Please keep in mind that this debug setting may be temporary. Do not rely on this setting existing in future viewer builds.</string>
+      <key>Persist</key>
+      <integer>0</integer>
+      <key>Type</key>
+      <string>String</string>
+      <key>Value</key>
+      <string>00000000-0000-0000-0000-000000000000</string>
+    </map>
+	<key>LocalTerrainAsset2</key>
+    <map>
+      <key>Comment</key>
+      <string>If set to a non-null UUID, overrides the terrain asset locally for all regions with material assets. Local terrain assets are not visible to others. Please keep in mind that this debug setting may be temporary. Do not rely on this setting existing in future viewer builds.</string>
+      <key>Persist</key>
+      <integer>0</integer>
+      <key>Type</key>
+      <string>String</string>
+      <key>Value</key>
+      <string>00000000-0000-0000-0000-000000000000</string>
+    </map>
+	<key>LocalTerrainAsset3</key>
+    <map>
+      <key>Comment</key>
+      <string>If set to a non-null UUID, overrides the terrain asset locally for all regions with material assets. Local terrain assets are not visible to others. Please keep in mind that this debug setting may be temporary. Do not rely on this setting existing in future viewer builds.</string>
+      <key>Persist</key>
+      <integer>0</integer>
+      <key>Type</key>
+      <string>String</string>
+      <key>Value</key>
+      <string>00000000-0000-0000-0000-000000000000</string>
+    </map>
+	<key>LocalTerrainAsset4</key>
+    <map>
+      <key>Comment</key>
+      <string>If set to a non-null UUID, overrides the terrain asset locally for all regions with material assets. Local terrain assets are not visible to others. Please keep in mind that this debug setting may be temporary. Do not rely on this setting existing in future viewer builds.</string>
+      <key>Persist</key>
+      <integer>0</integer>
+      <key>Type</key>
+      <string>String</string>
+      <key>Value</key>
+      <string>00000000-0000-0000-0000-000000000000</string>
+    </map>
 	<key>PathfindingRetrieveNeighboringRegion</key>
     <map>
       <key>Comment</key>
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbrterrainF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainF.glsl
new file mode 100644
index 0000000000..db03e0885c
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainF.glsl
@@ -0,0 +1,272 @@
+/** 
+ * @file class1\deferred\terrainF.glsl
+ *
+ * $LicenseInfo:firstyear=2023&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2023, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+#define TERRAIN_PBR_DETAIL_EMISSIVE 0
+
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+#define TerrainCoord vec4[2]
+#elif TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 1
+#define TerrainCoord vec2
+#endif
+
+#define MIX_X    1 << 3
+#define MIX_Y    1 << 4
+#define MIX_Z    1 << 5
+#define MIX_W    1 << 6
+
+// TODO: Decide if this struct needs to be declared
+struct TerrainMix
+{
+    vec4 weight;
+    int type;
+};
+
+TerrainMix get_terrain_mix_weights(float alpha1, float alpha2, float alphaFinal);
+
+// TODO: Decide if this struct needs to be declared
+struct PBRMix
+{
+    vec4 col;       // RGB color with alpha, linear space
+    vec3 orm;       // Occlusion, roughness, metallic
+    vec3 vNt;       // Unpacked normal texture sample, vector
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    vec3 emissive;  // RGB emissive color, linear space
+#endif
+};
+
+PBRMix init_pbr_mix();
+
+PBRMix terrain_sample_and_multiply_pbr(
+    TerrainCoord terrain_coord
+    , sampler2D tex_col
+    , sampler2D tex_orm
+    , sampler2D tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , sampler2D tex_emissive
+#endif
+    , vec4 factor_col
+    , vec3 factor_orm
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , vec3 factor_emissive
+#endif
+    );
+
+PBRMix mix_pbr(PBRMix mix1, PBRMix mix2, float mix2_weight);
+
+out vec4 frag_data[4];
+
+uniform sampler2D alpha_ramp;
+
+// *TODO: More configurable quality level which disables PBR features on machines
+// with limited texture availability
+// https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#additional-textures
+uniform sampler2D detail_0_base_color;
+uniform sampler2D detail_1_base_color;
+uniform sampler2D detail_2_base_color;
+uniform sampler2D detail_3_base_color;
+uniform sampler2D detail_0_normal;
+uniform sampler2D detail_1_normal;
+uniform sampler2D detail_2_normal;
+uniform sampler2D detail_3_normal;
+uniform sampler2D detail_0_metallic_roughness;
+uniform sampler2D detail_1_metallic_roughness;
+uniform sampler2D detail_2_metallic_roughness;
+uniform sampler2D detail_3_metallic_roughness;
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+uniform sampler2D detail_0_emissive;
+uniform sampler2D detail_1_emissive;
+uniform sampler2D detail_2_emissive;
+uniform sampler2D detail_3_emissive;
+#endif
+
+uniform vec4[4] baseColorFactors; // See also vertex_color in pbropaqueV.glsl
+uniform vec4 metallicFactors;
+uniform vec4 roughnessFactors;
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+uniform vec3[4] emissiveColors;
+#endif
+uniform vec4 minimum_alphas; // PBR alphaMode: MASK, See: mAlphaCutoff, setAlphaCutoff()
+
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+in vec4[2] vary_coords;
+#endif
+in vec3 vary_normal;
+in vec3 vary_tangent;
+flat in float vary_sign;
+in vec4 vary_texcoord0;
+in vec4 vary_texcoord1;
+
+vec2 encode_normal(vec3 n);
+
+float terrain_mix(TerrainMix tm, vec4 tms4);
+
+void main()
+{
+
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+    TerrainCoord terrain_texcoord = vary_coords;
+#elif TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 1
+    TerrainCoord terrain_texcoord = vary_texcoord0.xy;
+#endif
+
+    float alpha1 = texture(alpha_ramp, vary_texcoord0.zw).a;
+    float alpha2 = texture(alpha_ramp,vary_texcoord1.xy).a;
+    float alphaFinal = texture(alpha_ramp, vary_texcoord1.zw).a;
+
+    TerrainMix tm = get_terrain_mix_weights(alpha1, alpha2, alphaFinal);
+
+    // RGB = Occlusion, Roughness, Metal
+    // default values, see LLViewerTexture::sDefaultPBRORMImagep
+    //   occlusion 1.0
+    //   roughness 0.0
+    //   metal     0.0
+    vec3[4] orm_factors;
+    orm_factors[0] = vec3(1.0, roughnessFactors.x, metallicFactors.x);
+    orm_factors[1] = vec3(1.0, roughnessFactors.y, metallicFactors.y);
+    orm_factors[2] = vec3(1.0, roughnessFactors.z, metallicFactors.z);
+    orm_factors[3] = vec3(1.0, roughnessFactors.w, metallicFactors.w);
+
+    PBRMix mix = init_pbr_mix();
+    PBRMix mix2;
+    switch (tm.type & MIX_X)
+    {
+    case MIX_X:
+        mix2 = terrain_sample_and_multiply_pbr(
+            terrain_texcoord
+            , detail_0_base_color
+            , detail_0_metallic_roughness
+            , detail_0_normal
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , detail_0_emissive
+#endif
+            , baseColorFactors[0]
+            , orm_factors[0]
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , emissiveColors[0]
+#endif
+        );
+        mix = mix_pbr(mix, mix2, tm.weight.x);
+        break;
+    default:
+        break;
+    }
+    switch (tm.type & MIX_Y)
+    {
+    case MIX_Y:
+        mix2 = terrain_sample_and_multiply_pbr(
+            terrain_texcoord
+            , detail_1_base_color
+            , detail_1_metallic_roughness
+            , detail_1_normal
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , detail_1_emissive
+#endif
+            , baseColorFactors[1]
+            , orm_factors[1]
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , emissiveColors[1]
+#endif
+        );
+        mix = mix_pbr(mix, mix2, tm.weight.y);
+        break;
+    default:
+        break;
+    }
+    switch (tm.type & MIX_Z)
+    {
+    case MIX_Z:
+        mix2 = terrain_sample_and_multiply_pbr(
+            terrain_texcoord
+            , detail_2_base_color
+            , detail_2_metallic_roughness
+            , detail_2_normal
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , detail_2_emissive
+#endif
+            , baseColorFactors[2]
+            , orm_factors[2]
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , emissiveColors[2]
+#endif
+        );
+        mix = mix_pbr(mix, mix2, tm.weight.z);
+        break;
+    default:
+        break;
+    }
+    switch (tm.type & MIX_W)
+    {
+    case MIX_W:
+        mix2 = terrain_sample_and_multiply_pbr(
+            terrain_texcoord
+            , detail_3_base_color
+            , detail_3_metallic_roughness
+            , detail_3_normal
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , detail_3_emissive
+#endif
+            , baseColorFactors[3]
+            , orm_factors[3]
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , emissiveColors[3]
+#endif
+        );
+        mix = mix_pbr(mix, mix2, tm.weight.w);
+        break;
+    default:
+        break;
+    }
+
+    float minimum_alpha = terrain_mix(tm, minimum_alphas);
+    if (mix.col.a < minimum_alpha)
+    {
+        discard;
+    }
+    float base_color_factor_alpha = terrain_mix(tm, vec4(baseColorFactors[0].z, baseColorFactors[1].z, baseColorFactors[2].z, baseColorFactors[3].z));
+
+    // from mikktspace.com
+    vec3 vNt = mix.vNt;
+    vec3 vN = vary_normal;
+    vec3 vT = vary_tangent.xyz;
+    
+    vec3 vB = vary_sign * cross(vN, vT);
+    vec3 tnorm = normalize( vNt.x * vT + vNt.y * vB + vNt.z * vN );
+
+    tnorm *= gl_FrontFacing ? 1.0 : -1.0;
+   
+
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+#define emissive mix.emissive
+#else
+#define emissive vec3(0)
+#endif
+    frag_data[0] = max(vec4(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] = max(vec4(encode_normal(tnorm), base_color_factor_alpha, GBUFFER_FLAG_HAS_PBR), vec4(0)); // 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/pbrterrainUtilF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainUtilF.glsl
new file mode 100644
index 0000000000..316b751590
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainUtilF.glsl
@@ -0,0 +1,396 @@
+/** 
+ * @file class1\deferred\pbrterrainUtilF.glsl
+ *
+ * $LicenseInfo:firstyear=2023&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2023, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+/*[EXTRA_CODE_HERE]*/
+
+/**
+ * Triplanar mapping implementation adapted from Inigo Quilez' example shader,
+ * MIT license.
+ * https://www.shadertoy.com/view/MtsGWH
+ * Copyright © 2015 Inigo Quilez
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions: The above copyright
+ * notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS",
+ * WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+ * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define TERRAIN_PBR_DETAIL_EMISSIVE 0
+
+in vec3 vary_vertex_normal;
+
+vec3 srgb_to_linear(vec3 c);
+
+// A relatively agressive threshold for terrain material mixing sampling
+// cutoff. This ensures that only one or two materials are used in most places,
+// making PBR terrain blending more performant. Should be greater than 0 to work.
+#define TERRAIN_RAMP_MIX_THRESHOLD 0.1
+// A small threshold for triplanar mapping sampling cutoff. This and
+// TERRAIN_TRIPLANAR_BLEND_FACTOR together ensures that only one or two samples
+// per texture are used in most places, making triplanar mapping more
+// performant. Should be greater than 0 to work.
+// There's also an artistic design choice in the use of these factors, and the
+// use of triplanar generally. Don't take these triplanar constants for granted.
+#define TERRAIN_TRIPLANAR_MIX_THRESHOLD 0.01
+
+#define SAMPLE_X 1 << 0
+#define SAMPLE_Y 1 << 1
+#define SAMPLE_Z 1 << 2
+#define MIX_X    1 << 3
+#define MIX_Y    1 << 4
+#define MIX_Z    1 << 5
+#define MIX_W    1 << 6
+
+struct PBRMix
+{
+    vec4 col;       // RGB color with alpha, linear space
+    vec3 orm;       // Occlusion, roughness, metallic
+    vec3 vNt;       // Unpacked normal texture sample, vector
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    vec3 emissive;  // RGB emissive color, linear space
+#endif
+};
+
+PBRMix init_pbr_mix()
+{
+    PBRMix mix;
+    mix.col = vec4(0);
+    mix.orm = vec3(0);
+    mix.vNt = vec3(0);
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    mix.emissive = vec3(0);
+#endif
+    return mix;
+}
+
+// Usage example, for two weights:
+// vec2 weights = ... // Weights must add up to 1
+// PBRMix mix = init_pbr_mix();
+// PBRMix mix1 = ...
+// mix = mix_pbr(mix, mix1, weights.x);
+// PBRMix mix2 = ...
+// mix = mix_pbr(mix, mix2, weights.y);
+PBRMix mix_pbr(PBRMix mix1, PBRMix mix2, float mix2_weight)
+{
+    PBRMix mix;
+    mix.col      = mix1.col      + (mix2.col      * mix2_weight);
+    mix.orm      = mix1.orm      + (mix2.orm      * mix2_weight);
+    mix.vNt      = mix1.vNt      + (mix2.vNt      * mix2_weight);
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    mix.emissive = mix1.emissive + (mix2.emissive * mix2_weight);
+#endif
+    return mix;
+}
+
+PBRMix sample_pbr(
+    vec2 uv
+    , sampler2D tex_col
+    , sampler2D tex_orm
+    , sampler2D tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , sampler2D tex_emissive
+#endif
+    )
+{
+    PBRMix mix;
+    mix.col = texture(tex_col, uv);
+    mix.col.rgb = srgb_to_linear(mix.col.rgb);
+    mix.orm = texture(tex_orm, uv).xyz;
+    mix.vNt = texture(tex_vNt, uv).xyz*2.0-1.0;
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    mix.emissive = srgb_to_linear(texture(tex_emissive, uv).xyz);
+#endif
+    return mix;
+}
+
+struct TerrainTriplanar
+{
+    vec3 weight;
+    int type;
+};
+
+struct TerrainMix
+{
+    vec4 weight;
+    int type;
+};
+
+#define TerrainMixSample vec4[4]
+#define TerrainMixSample3 vec3[4]
+
+TerrainMix get_terrain_mix_weights(float alpha1, float alpha2, float alphaFinal)
+{
+    TerrainMix tm;
+    vec4 sample_x = vec4(1,0,0,0);
+    vec4 sample_y = vec4(0,1,0,0);
+    vec4 sample_z = vec4(0,0,1,0);
+    vec4 sample_w = vec4(0,0,0,1);
+
+    tm.weight = mix( mix(sample_w, sample_z, alpha2), mix(sample_y, sample_x, alpha1), alphaFinal );
+    tm.weight -= TERRAIN_RAMP_MIX_THRESHOLD;
+    ivec4 usage = max(ivec4(0), ivec4(ceil(tm.weight)));
+    // Prevent negative weights and keep weights balanced
+    tm.weight = tm.weight*vec4(usage);
+    tm.weight /= (tm.weight.x + tm.weight.y + tm.weight.z + tm.weight.w);
+
+    tm.type = (usage.x * MIX_X) |
+              (usage.y * MIX_Y) |
+              (usage.z * MIX_Z) |
+              (usage.w * MIX_W);
+    return tm;
+}
+
+TerrainTriplanar _t_triplanar()
+{
+    float sharpness = TERRAIN_TRIPLANAR_BLEND_FACTOR;
+    float threshold = TERRAIN_TRIPLANAR_MIX_THRESHOLD;
+    vec3 weight_signed = pow(abs(vary_vertex_normal), vec3(sharpness));
+    weight_signed /= (weight_signed.x + weight_signed.y + weight_signed.z);
+    weight_signed -= vec3(threshold);
+    TerrainTriplanar tw;
+    // *NOTE: Make sure the threshold doesn't affect the materials
+    tw.weight = max(vec3(0), weight_signed);
+    tw.weight /= (tw.weight.x + tw.weight.y + tw.weight.z);
+    ivec3 usage = ivec3(round(max(vec3(0), sign(weight_signed))));
+    tw.type = ((usage.x) * SAMPLE_X) |
+              ((usage.y) * SAMPLE_Y) |
+              ((usage.z) * SAMPLE_Z);
+    return tw;
+}
+
+// Assume weights add to 1
+float terrain_mix(TerrainMix tm, vec4 tms4)
+{
+    return (tm.weight.x * tms4[0]) +
+           (tm.weight.y * tms4[1]) +
+           (tm.weight.z * tms4[2]) +
+           (tm.weight.w * tms4[3]);
+}
+
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+// Triplanar mapping
+
+// Pre-transformed texture coordinates for each axial uv slice (Packing: xy, yz, (-x)z, unused)
+#define TerrainCoord vec4[2]
+
+vec2 _t_uv(vec2 uv_unflipped, float sign_or_zero)
+{
+    // Handle case where sign is 0
+    float sign = (2.0*sign_or_zero) + 1.0;
+    sign /= abs(sign);
+    // If the vertex normal is negative, flip the texture back
+    // right-side up.
+    vec2 uv = uv_unflipped * vec2(sign, 1);
+    return uv;
+}
+
+vec3 _t_normal_post_1(vec3 vNt0, float sign_or_zero)
+{
+    // Assume normal is unpacked
+    vec3 vNt1 = vNt0;
+    // Get sign
+    float sign = sign_or_zero;
+    // Handle case where sign is 0
+    sign = (2.0*sign) + 1.0;
+    sign /= abs(sign);
+    // If the sign is negative, rotate normal by 180 degrees
+    vNt1.xy = (min(0, sign) * vNt1.xy) + (min(0, -sign) * -vNt1.xy);
+    return vNt1;
+}
+
+// Triplanar-specific normal texture fixes
+vec3 _t_normal_post_x(vec3 vNt0)
+{
+    vec3 vNt_x = _t_normal_post_1(vNt0, sign(vary_vertex_normal.x));
+    // *HACK: Transform normals according to orientation of the UVs
+    vNt_x.xy = vec2(-vNt_x.y, vNt_x.x);
+    return vNt_x;
+}
+vec3 _t_normal_post_y(vec3 vNt0)
+{
+    vec3 vNt_y = _t_normal_post_1(vNt0, sign(vary_vertex_normal.y));
+    // *HACK: Transform normals according to orientation of the UVs
+    vNt_y.xy = -vNt_y.xy;
+    return vNt_y;
+}
+vec3 _t_normal_post_z(vec3 vNt0)
+{
+    vec3 vNt_z = _t_normal_post_1(vNt0, sign(vary_vertex_normal.z));
+    return vNt_z;
+}
+
+PBRMix terrain_sample_pbr(
+    TerrainCoord terrain_coord
+    , TerrainTriplanar tw
+    , sampler2D tex_col
+    , sampler2D tex_orm
+    , sampler2D tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , sampler2D tex_emissive
+#endif
+    )
+{
+    PBRMix mix = init_pbr_mix();
+
+#define get_uv_x() _t_uv(terrain_coord[0].zw, sign(vary_vertex_normal.x))
+#define get_uv_y() _t_uv(terrain_coord[1].xy, sign(vary_vertex_normal.y))
+#define get_uv_z() _t_uv(terrain_coord[0].xy, sign(vary_vertex_normal.z))
+    switch (tw.type & SAMPLE_X)
+    {
+    case SAMPLE_X:
+        PBRMix mix_x = sample_pbr(
+            get_uv_x()
+            , tex_col
+            , tex_orm
+            , tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , tex_emissive
+#endif
+            );
+        // Triplanar-specific normal texture fix
+        mix_x.vNt = _t_normal_post_x(mix_x.vNt);
+        mix = mix_pbr(mix, mix_x, tw.weight.x);
+        break;
+    default:
+        break;
+    }
+
+    switch (tw.type & SAMPLE_Y)
+    {
+    case SAMPLE_Y:
+        PBRMix mix_y = sample_pbr(
+            get_uv_y()
+            , tex_col
+            , tex_orm
+            , tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , tex_emissive
+#endif
+            );
+        // Triplanar-specific normal texture fix
+        mix_y.vNt = _t_normal_post_y(mix_y.vNt);
+        mix = mix_pbr(mix, mix_y, tw.weight.y);
+        break;
+    default:
+        break;
+    }
+
+    switch (tw.type & SAMPLE_Z)
+    {
+    case SAMPLE_Z:
+        PBRMix mix_z = sample_pbr(
+            get_uv_z()
+            , tex_col
+            , tex_orm
+            , tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+            , tex_emissive
+#endif
+            );
+        // Triplanar-specific normal texture fix
+        // *NOTE: Bottom face has not been tested
+        mix_z.vNt = _t_normal_post_z(mix_z.vNt);
+        mix = mix_pbr(mix, mix_z, tw.weight.z);
+        break;
+    default:
+        break;
+    }
+    
+    return mix;
+}
+
+#elif TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 1
+
+#define TerrainCoord vec2
+
+#define terrain_sample_pbr sample_pbr
+
+#endif
+
+PBRMix multiply_factors_pbr(
+    PBRMix mix_in
+    , vec4 factor_col
+    , vec3 factor_orm
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , vec3 factor_emissive
+#endif
+    )
+{
+    PBRMix mix = mix_in;
+    mix.col *= factor_col;
+    mix.orm *= factor_orm;
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    mix.emissive *= factor_emissive;
+#endif
+    return mix;
+}
+
+PBRMix terrain_sample_and_multiply_pbr(
+    TerrainCoord terrain_coord
+    , sampler2D tex_col
+    , sampler2D tex_orm
+    , sampler2D tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , sampler2D tex_emissive
+#endif
+    , vec4 factor_col
+    , vec3 factor_orm
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+    , vec3 factor_emissive
+#endif
+    )
+{
+    PBRMix mix = terrain_sample_pbr(
+        terrain_coord
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+        , _t_triplanar()
+#endif
+        , tex_col
+        , tex_orm
+        , tex_vNt
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+        , tex_emissive
+#endif
+        );
+
+    mix = multiply_factors_pbr(mix
+        , factor_col
+        , factor_orm
+#if (TERRAIN_PBR_DETAIL >= TERRAIN_PBR_DETAIL_EMISSIVE)
+        , factor_emissive
+#endif
+    );
+
+    return mix;
+}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbrterrainV.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainV.glsl
new file mode 100644
index 0000000000..dbb9404219
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/deferred/pbrterrainV.glsl
@@ -0,0 +1,93 @@
+/** 
+ * @file class1\environment\pbrterrainV.glsl
+ *
+ * $LicenseInfo:firstyear=2023&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2023, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+uniform mat3 normal_matrix;
+uniform mat4 texture_matrix0;
+uniform mat4 modelview_projection_matrix;
+
+in vec3 position;
+in vec3 normal;
+in vec4 tangent;
+in vec4 diffuse_color;
+in vec2 texcoord1;
+
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+out vec4[2] vary_coords;
+#endif
+out vec3 vary_vertex_normal; // Used by pbrterrainUtilF.glsl
+out vec3 vary_normal;
+out vec3 vary_tangent;
+flat out float vary_sign;
+out vec4 vary_texcoord0;
+out vec4 vary_texcoord1;
+
+// *HACK: tangent_space_transform should use texture_normal_transform, or maybe
+// we shouldn't use tangent_space_transform at all. See the call to
+// tangent_space_transform below.
+uniform vec4[2] texture_base_color_transform;
+
+vec2 texture_transform(vec2 vertex_texcoord, vec4[2] khr_gltf_transform, mat4 sl_animation_transform);
+vec3 tangent_space_transform(vec4 vertex_tangent, vec3 vertex_normal, vec4[2] khr_gltf_transform, mat4 sl_animation_transform);
+
+void main()
+{
+    //transform vertex
+	gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0); 
+
+	vec3 n = normal_matrix * normal;
+    vary_vertex_normal = normal;
+	vec3 t = normal_matrix * tangent.xyz;
+
+    vary_tangent = normalize(t);
+    // *TODO: Decide if we want this. It may be better to just calculate the
+    // tangents on-the-fly in the fragment shader, due to the subtleties of the
+    // effect of triplanar mapping on UVs.
+    // *HACK: Should be using texture_normal_transform here. The KHR texture
+    // transform spec requires handling texture transforms separately for each
+    // individual texture.
+    vary_tangent = normalize(tangent_space_transform(vec4(t, tangent.w), n, texture_base_color_transform, texture_matrix0));
+    vary_sign = tangent.w;
+    vary_normal = normalize(n);
+
+    // Transform and pass tex coords
+    // *HACK: texture_base_color_transform is used for all of these here, but
+    // the KHR texture transform spec requires handling texture transforms
+    // separately for each individual texture.
+#if TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 3
+    // xy
+    vary_coords[0].xy = texture_transform(position.xy, texture_base_color_transform, texture_matrix0);
+    // yz
+    vary_coords[0].zw = texture_transform(position.yz, texture_base_color_transform, texture_matrix0);
+    // (-x)z
+    vary_coords[1].xy = texture_transform(position.xz * vec2(-1, 1), texture_base_color_transform, texture_matrix0);
+#elif TERRAIN_PLANAR_TEXTURE_SAMPLE_COUNT == 1
+    vary_texcoord0.xy = texture_transform(position.xy, texture_base_color_transform, texture_matrix0);
+#endif
+    
+    vec4 tc = vec4(texcoord1,0,1);
+    vary_texcoord0.zw = tc.xy;
+    vary_texcoord1.xy = tc.xy-vec2(2.0, 0.0);
+    vary_texcoord1.zw = tc.xy-vec2(1.0, 0.0);
+}
diff --git a/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl b/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
index f6d3b59e85..33a78fd26d 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
@@ -30,7 +30,6 @@ uniform mat4 modelview_projection_matrix;
 in vec3 position;
 in vec3 normal;
 in vec4 diffuse_color;
-in vec2 texcoord0;
 in vec2 texcoord1;
 
 out vec3 pos;
@@ -41,18 +40,16 @@ out vec4 vary_texcoord1;
 uniform vec4 object_plane_s;
 uniform vec4 object_plane_t;
 
-vec4 texgen_object(vec4  vpos, vec4 tc, mat4 mat, vec4 tp0, vec4 tp1)
+vec2 texgen_object(vec4 vpos, mat4 mat, vec4 tp0, vec4 tp1)
 {
     vec4 tcoord;
     
     tcoord.x = dot(vpos, tp0);
     tcoord.y = dot(vpos, tp1);
-    tcoord.z = tc.z;
-    tcoord.w = tc.w;
     
     tcoord = mat * tcoord; 
     
-    return tcoord; 
+    return tcoord.xy; 
 }
 
 void main()
@@ -67,7 +64,7 @@ void main()
     vary_normal = normalize(normal_matrix * normal);
     
     // Transform and pass tex coords
-    vary_texcoord0.xy = texgen_object(vec4(position, 1.0), vec4(texcoord0,0,1), texture_matrix0, object_plane_s, object_plane_t).xy;
+    vary_texcoord0.xy = texgen_object(vec4(position, 1.0), texture_matrix0, object_plane_s, object_plane_t);
     
     vec4 t = vec4(texcoord1,0,1);
     
diff --git a/indra/newview/app_settings/shaders/class1/deferred/textureUtilV.glsl b/indra/newview/app_settings/shaders/class1/deferred/textureUtilV.glsl
index 636dfed4ba..732333311c 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/textureUtilV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/textureUtilV.glsl
@@ -65,7 +65,7 @@ vec2 texture_transform(vec2 vertex_texcoord, vec4[2] khr_gltf_transform, mat4 sl
     // Apply texture animation first to avoid shearing and other artifacts
     texcoord = (sl_animation_transform * vec4(texcoord, 0, 1)).xy;
     // Convert to left-handed coordinate system. The offset of 1 is necessary
-    // for rotations to be applied correctly.
+    // for rotation and scale to be applied correctly.
     texcoord.y = 1.0 - texcoord.y;
     texcoord = khr_texture_transform(texcoord, khr_gltf_transform[0].xy, khr_gltf_transform[0].z, khr_gltf_transform[1].xy);
     // Convert back to right-handed coordinate system