1 files changed, 87 insertions, 30 deletions

diff --git a/indra/newview/llvlcomposition.cpp b/indra/newview/llvlcomposition.cpp
index 368934dffc..ba255f2b24 100644
--- a/indra/newview/llvlcomposition.cpp
+++ b/indra/newview/llvlcomposition.cpp
@@ -115,14 +115,24 @@ LLTerrainMaterials::~LLTerrainMaterials()
     unboost();
 }
 
+void LLTerrainMaterials::apply(const LLModifyRegion& other)
+{
+    for (S32 i = 0; i < LLTerrainMaterials::ASSET_COUNT; ++i)
+    {
+        const LLGLTFMaterial* other_override = other.getMaterialOverride(i);
+        LLGLTFMaterial* material_override = other_override ? new LLGLTFMaterial(*other_override) : nullptr;
+        setMaterialOverride(i, material_override);
+    }
+}
+
 bool LLTerrainMaterials::generateMaterials()
 {
-    if (texturesReady(true, true))
+    if (makeTexturesReady(true, true))
     {
         return true;
     }
 
-    if (materialsReady(true, true))
+    if (makeMaterialsReady(true, true))
     {
         return true;
     }
@@ -188,24 +198,39 @@ void LLTerrainMaterials::setDetailAssetID(S32 asset, const LLUUID& id)
     mDetailTextures[asset] = fetch_terrain_texture(id);
     LLPointer<LLFetchedGLTFMaterial>& mat = mDetailMaterials[asset];
     mat = id.isNull() ? nullptr : gGLTFMaterialList.getMaterial(id);
+    mDetailRenderMaterials[asset] = nullptr;
     mMaterialTexturesSet[asset] = false;
 }
 
+const LLGLTFMaterial* LLTerrainMaterials::getMaterialOverride(S32 asset) const
+{
+    return mDetailMaterialOverrides[asset];
+}
+
+void LLTerrainMaterials::setMaterialOverride(S32 asset, LLGLTFMaterial* mat_override)
+{
+    // Non-null overrides must be nontrivial. Otherwise, please set the override to null instead.
+    llassert(!mat_override || *mat_override != LLGLTFMaterial::sDefault);
+
+    mDetailMaterialOverrides[asset] = mat_override;
+    mDetailRenderMaterials[asset] = nullptr;
+}
+
 LLTerrainMaterials::Type LLTerrainMaterials::getMaterialType()
 {
     LL_PROFILE_ZONE_SCOPED;
 
-    const bool use_textures = texturesReady(false, false) || !materialsReady(false, false);
+    const bool use_textures = makeTexturesReady(false, false) || !makeMaterialsReady(false, false);
     return use_textures ? Type::TEXTURE : Type::PBR;
 }
 
-bool LLTerrainMaterials::texturesReady(bool boost, bool strict)
+bool LLTerrainMaterials::makeTexturesReady(bool boost, bool strict)
 {
     bool ready[ASSET_COUNT];
-    // *NOTE: Calls to textureReady may boost textures. Do not early-return.
+    // *NOTE: Calls to makeTextureReady may boost textures. Do not early-return.
     for (S32 i = 0; i < ASSET_COUNT; i++)
     {
-        ready[i] = mDetailTextures[i].notNull() && textureReady(mDetailTextures[i], boost);
+        ready[i] = mDetailTextures[i].notNull() && makeTextureReady(mDetailTextures[i], boost);
     }
 
     bool one_ready = false;
@@ -221,13 +246,36 @@ bool LLTerrainMaterials::texturesReady(bool boost, bool strict)
     return one_ready;
 }
 
-bool LLTerrainMaterials::materialsReady(bool boost, bool strict)
+namespace
+{
+    bool material_asset_ready(LLFetchedGLTFMaterial* mat) { return mat && mat->isLoaded(); }
+};
+
+bool LLTerrainMaterials::makeMaterialsReady(bool boost, bool strict)
 {
     bool ready[ASSET_COUNT];
-    // *NOTE: Calls to materialReady may boost materials/textures. Do not early-return.
+    // *NOTE: This section may boost materials/textures. Do not early-return if ready[i] is false.
     for (S32 i = 0; i < ASSET_COUNT; i++)
     {
-        ready[i] = materialReady(mDetailMaterials[i], mMaterialTexturesSet[i], boost, strict);
+        ready[i] = false;
+        LLPointer<LLFetchedGLTFMaterial>& mat = mDetailMaterials[i];
+        if (!material_asset_ready(mat)) { continue; }
+
+        LLPointer<LLFetchedGLTFMaterial>& render_mat = mDetailRenderMaterials[i];
+        if (!render_mat)
+        {
+            render_mat = new LLFetchedGLTFMaterial();
+            *render_mat = *mat;
+            // This render_mat is effectively already loaded, because it gets its data from mat.
+
+            LLPointer<LLGLTFMaterial>& override_mat = mDetailMaterialOverrides[i];
+            if (override_mat)
+            {
+                render_mat->applyOverride(*override_mat);
+            }
+        }
+
+        ready[i] = materialTexturesReady(render_mat, mMaterialTexturesSet[i], boost, strict);
     }
 
 #if 1
@@ -267,7 +315,7 @@ bool LLTerrainMaterials::materialsReady(bool boost, bool strict)
 // Boost the texture loading priority
 // Return true when ready to use (i.e. texture is sufficiently loaded)
 // static
-bool LLTerrainMaterials::textureReady(LLPointer<LLViewerFetchedTexture>& tex, bool boost)
+bool LLTerrainMaterials::makeTextureReady(LLPointer<LLViewerFetchedTexture>& tex, bool boost)
 {
     llassert(tex);
     if (!tex) { return false; }
@@ -308,15 +356,13 @@ bool LLTerrainMaterials::textureReady(LLPointer<LLViewerFetchedTexture>& tex, bo
     return true;
 }
 
-// Boost the loading priority of every known texture in the material
-// Return true when ready to use
+// Make sure to call material_asset_ready first
+// strict = true -> all materials must be sufficiently loaded
+// strict = false -> at least one material must be loaded
 // static
-bool LLTerrainMaterials::materialReady(LLPointer<LLFetchedGLTFMaterial> &mat, bool &textures_set, bool boost, bool strict)
+bool LLTerrainMaterials::materialTexturesReady(LLPointer<LLFetchedGLTFMaterial>& mat, bool& textures_set, bool boost, bool strict)
 {
-    if (!mat || !mat->isLoaded())
-    {
-        return false;
-    }
+    llassert(mat);
 
     // Material is loaded, but textures may not be
     if (!textures_set)
@@ -331,17 +377,17 @@ bool LLTerrainMaterials::materialReady(LLPointer<LLFetchedGLTFMaterial> &mat, bo
         mat->mEmissiveTexture          = fetch_terrain_texture(mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE]);
     }
 
-    // *NOTE: Calls to textureReady may boost textures. Do not early-return.
+    // *NOTE: Calls to makeTextureReady may boost textures. Do not early-return.
     bool ready[LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT];
     ready[LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR] =
-        mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR].isNull() || textureReady(mat->mBaseColorTexture, boost);
+        mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR].isNull() || makeTextureReady(mat->mBaseColorTexture, boost);
     ready[LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL] =
-        mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL].isNull() || textureReady(mat->mNormalTexture, boost);
+        mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL].isNull() || makeTextureReady(mat->mNormalTexture, boost);
     ready[LLGLTFMaterial::GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS] =
         mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS].isNull() ||
-        textureReady(mat->mMetallicRoughnessTexture, boost);
+        makeTextureReady(mat->mMetallicRoughnessTexture, boost);
     ready[LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE] =
-        mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE].isNull() || textureReady(mat->mEmissiveTexture, boost);
+        mat->mTextureId[LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE].isNull() || makeTextureReady(mat->mEmissiveTexture, boost);
 
     if (strict)
     {
@@ -357,6 +403,16 @@ bool LLTerrainMaterials::materialReady(LLPointer<LLFetchedGLTFMaterial> &mat, bo
     return true;
 }
 
+// Boost the loading priority of every known texture in the material
+// Return true when ready to use
+// static
+bool LLTerrainMaterials::makeMaterialReady(LLPointer<LLFetchedGLTFMaterial> &mat, bool &textures_set, bool boost, bool strict)
+{
+    if (!material_asset_ready(mat)) { return false; }
+
+    return materialTexturesReady(mat, textures_set, boost, strict);
+}
+
 // static
 const LLUUID (&LLVLComposition::getDefaultTextures())[ASSET_COUNT]
 {
@@ -638,11 +694,11 @@ bool LLVLComposition::generateMinimapTileLand(const F32 x, const F32 y,
     const bool use_textures = getMaterialType() != LLTerrainMaterials::Type::PBR;
     if (use_textures)
     {
-        if (!texturesReady(true, true)) { return false; }
+        if (!makeTexturesReady(true, true)) { return false; }
     }
     else
     {
-        if (!materialsReady(true, true)) { return false; }
+        if (!makeMaterialsReady(true, true)) { return false; }
     }
 
     for (S32 i = 0; i < ASSET_COUNT; i++)
@@ -668,19 +724,20 @@ bool LLVLComposition::generateMinimapTileLand(const F32 x, const F32 y,
             }
             else
             {
-                tex = mDetailMaterials[i]->mBaseColorTexture;
-                tex_emissive = mDetailMaterials[i]->mEmissiveTexture;
-                base_color_factor = LLColor3(mDetailMaterials[i]->mBaseColor);
+                LLPointer<LLFetchedGLTFMaterial>& mat = mDetailRenderMaterials[i];
+                tex = mat->mBaseColorTexture;
+                tex_emissive = mat->mEmissiveTexture;
+                base_color_factor = LLColor3(mat->mBaseColor);
                 // *HACK: Treat alpha as black
-                base_color_factor *= (mDetailMaterials[i]->mBaseColor.mV[VW]);
-                emissive_factor = mDetailMaterials[i]->mEmissiveColor;
+                base_color_factor *= (mat->mBaseColor.mV[VW]);
+                emissive_factor = mat->mEmissiveColor;
                 has_base_color_factor = (base_color_factor.mV[VX] != 1.f ||
                                          base_color_factor.mV[VY] != 1.f ||
                                          base_color_factor.mV[VZ] != 1.f);
                 has_emissive_factor = (emissive_factor.mV[VX] != 1.f ||
                                        emissive_factor.mV[VY] != 1.f ||
                                        emissive_factor.mV[VZ] != 1.f);
-                has_alpha = mDetailMaterials[i]->mAlphaMode != LLGLTFMaterial::ALPHA_MODE_OPAQUE;
+                has_alpha = mat->mAlphaMode != LLGLTFMaterial::ALPHA_MODE_OPAQUE;
             }
 
             if (!tex) { tex = LLViewerFetchedTexture::sWhiteImagep; }