SL-18105 Hook up render pipe directly to LLTextureEntry::mGLTFMaterial and add LLViewerFetchedTextures to LLFetchedGLTFMaterial. Lower reflection probe resolution to 128x128 per side.

3 files changed, 247 insertions, 33 deletions

diff --git a/indra/llprimitive/llgltfmaterial.cpp b/indra/llprimitive/llgltfmaterial.cpp
index 951b768678..19081cd76f 100644
--- a/indra/llprimitive/llgltfmaterial.cpp
+++ b/indra/llprimitive/llgltfmaterial.cpp
@@ -28,12 +28,44 @@
 
 #include "llgltfmaterial.h"
 
-#include "tiny_gltf.h"
+#include "tinygltf/tiny_gltf.h"
+
+LLGLTFMaterial::LLGLTFMaterial(const LLGLTFMaterial& rhs)
+{
+    *this = rhs;
+}
+
+LLGLTFMaterial& LLGLTFMaterial::operator=(const LLGLTFMaterial& rhs)
+{
+    //have to do a manual operator= because of LLRefCount 
+    mBaseColorId = rhs.mBaseColorId;
+    mNormalId = rhs.mNormalId;
+    mMetallicRoughnessId = rhs.mMetallicRoughnessId;
+    mEmissiveId = rhs.mEmissiveId;
+
+    mBaseColor = rhs.mBaseColor;
+    mEmissiveColor = rhs.mEmissiveColor;
+
+    mMetallicFactor = rhs.mMetallicFactor;
+    mRoughnessFactor = rhs.mRoughnessFactor;
+    mAlphaCutoff = rhs.mAlphaCutoff;
+
+    mDoubleSided = rhs.mDoubleSided;
+    mAlphaMode = rhs.mAlphaMode;
+
+    for (S32 i = 0; i < 3; ++i)
+    {
+        mTextureTransform[i] = rhs.mTextureTransform[i];
+    }
+
+    return *this;
+}
 
 bool LLGLTFMaterial::fromJSON(const std::string& json, std::string& warn_msg, std::string& error_msg)
 {
+#if 1
     tinygltf::TinyGLTF gltf;
-    
+
     tinygltf::Model model_in;
 
     if (gltf.LoadASCIIFromString(&model_in, &error_msg, &warn_msg, json.c_str(), json.length(), ""))
@@ -45,12 +77,13 @@ bool LLGLTFMaterial::fromJSON(const std::string& json, std::string& warn_msg, st
 
         return true;
     }
-
+#endif
     return false;
 }
 
 std::string LLGLTFMaterial::asJSON(bool prettyprint) const
 {
+#if 1
     tinygltf::TinyGLTF gltf;
     tinygltf::Model model_out;
 
@@ -61,6 +94,9 @@ std::string LLGLTFMaterial::asJSON(bool prettyprint) const
     gltf.WriteGltfSceneToStream(&model_out, str, prettyprint, false);
 
     return str.str();
+#else
+    return "";
+#endif
 }
 
 void LLGLTFMaterial::setFromModel(const tinygltf::Model& model, S32 mat_index)
@@ -130,7 +166,7 @@ void LLGLTFMaterial::setFromModel(const tinygltf::Model& model, S32 mat_index)
 
 void LLGLTFMaterial::writeToModel(tinygltf::Model& model, S32 mat_index) const
 {
-    if (model.materials.size() < mat_index+1)
+    if (model.materials.size() < mat_index + 1)
     {
         model.materials.resize(mat_index + 1);
     }
@@ -143,7 +179,7 @@ void LLGLTFMaterial::writeToModel(tinygltf::Model& model, S32 mat_index) const
         U32 idx = model.images.size();
         model.images.resize(idx + 1);
         model.textures.resize(idx + 1);
-        
+
         material_out.pbrMetallicRoughness.baseColorTexture.index = idx;
         model.textures[idx].source = idx;
         model.images[idx].uri = mBaseColorId.asString();
@@ -160,7 +196,7 @@ void LLGLTFMaterial::writeToModel(tinygltf::Model& model, S32 mat_index) const
         model.textures[idx].source = idx;
         model.images[idx].uri = mNormalId.asString();
     }
-    
+
     // set metallic-roughness texture
     if (mMetallicRoughnessId.notNull())
     {
@@ -187,7 +223,7 @@ void LLGLTFMaterial::writeToModel(tinygltf::Model& model, S32 mat_index) const
 
     material_out.alphaMode = getAlphaMode();
     material_out.alphaCutoff = mAlphaCutoff;
-    
+
     mBaseColor.write(material_out.pbrMetallicRoughness.baseColorFactor);
     mEmissiveColor.write(material_out.emissiveFactor);
 
@@ -195,11 +231,130 @@ void LLGLTFMaterial::writeToModel(tinygltf::Model& model, S32 mat_index) const
     material_out.pbrMetallicRoughness.roughnessFactor = mRoughnessFactor;
 
     material_out.doubleSided = mDoubleSided;
+
+    model.asset.version = "2.0";
+}
+
+
+void LLGLTFMaterial::setBaseColorId(const LLUUID& id)
+{
+    mBaseColorId = id;
+}
+
+void LLGLTFMaterial::setNormalId(const LLUUID& id)
+{
+    mNormalId = id;
+}
+
+void LLGLTFMaterial::setMetallicRoughnessId(const LLUUID& id)
+{
+    mMetallicRoughnessId = id;
+}
+
+void LLGLTFMaterial::setEmissiveId(const LLUUID& id)
+{
+    mEmissiveId = id;
+}
+
+void LLGLTFMaterial::setBaseColorFactor(const LLColor3& baseColor, F32 transparency)
+{
+    mBaseColor.set(baseColor, transparency);
+    mBaseColor.clamp();
+}
+
+void LLGLTFMaterial::setAlphaCutoff(F32 cutoff)
+{
+    mAlphaCutoff = llclamp(cutoff, 0.f, 1.f);
+}
+
+void LLGLTFMaterial::setEmissiveColorFactor(const LLColor3& emissiveColor)
+{
+    mEmissiveColor = emissiveColor;
+    mEmissiveColor.clamp();
+}
+
+void LLGLTFMaterial::setMetallicFactor(F32 metallic)
+{
+    mMetallicFactor = llclamp(metallic, 0.f, 1.f);
+}
+
+void LLGLTFMaterial::setRoughnessFactor(F32 roughness)
+{
+    mRoughnessFactor = llclamp(roughness, 0.f, 1.f);
+}
+
+void LLGLTFMaterial::setAlphaMode(S32 mode)
+{
+    mAlphaMode = (AlphaMode)llclamp(mode, (S32)ALPHA_MODE_OPAQUE, (S32)ALPHA_MODE_MASK);
+}
+
+void LLGLTFMaterial::setDoubleSided(bool double_sided)
+{
+    // sure, no clamping will ever be needed for a bool, but include the 
+    // setter for consistency with the clamping API
+    mDoubleSided = double_sided;
+}
+
+// Default value accessors
+
+LLUUID LLGLTFMaterial::getDefaultBaseColorId()
+{
+    return LLUUID::null;
+}
+
+LLUUID LLGLTFMaterial::getDefaultNormalId()
+{
+    return LLUUID::null;
+}
+
+LLUUID LLGLTFMaterial::getDefaultEmissiveId()
+{
+    return LLUUID::null;
+}
+
+LLUUID LLGLTFMaterial::getDefaultMetallicRoughnessId()
+{
+    return LLUUID::null;
+}
+
+F32 LLGLTFMaterial::getDefaultAlphaCutoff()
+{
+    return 0.f;
+}
+
+S32 LLGLTFMaterial::getDefaultAlphaMode()
+{
+    return (S32)ALPHA_MODE_OPAQUE;
+}
+
+F32 LLGLTFMaterial::getDefaultMetallicFactor()
+{
+    return 0.f;
+}
+
+F32 LLGLTFMaterial::getDefaultRoughnessFactor()
+{
+    return 0.f;
+}
+
+LLColor4 LLGLTFMaterial::getDefaultBaseColor()
+{
+    return LLColor4::white;
+}
+
+LLColor3 LLGLTFMaterial::getDefaultEmissiveColor()
+{
+    return LLColor3::black;
+}
+
+bool LLGLTFMaterial::getDefaultDoubleSided()
+{
+    return false;
 }
 
-void LLGLTFMaterial::writeOverridesToModel(tinygltf::Model & model, S32 mat_index, LLGLTFMaterial const * base_material) const
+void LLGLTFMaterial::writeOverridesToModel(tinygltf::Model& model, S32 mat_index, LLGLTFMaterial const* base_material) const
 {
-    if (model.materials.size() < mat_index+1)
+    if (model.materials.size() < mat_index + 1)
     {
         model.materials.resize(mat_index + 1);
     }
@@ -256,37 +411,37 @@ void LLGLTFMaterial::writeOverridesToModel(tinygltf::Model & model, S32 mat_inde
         model.images[idx].uri = mEmissiveId.asString();
     }
 
-    if(mAlphaMode != base_material->mAlphaMode)
+    if (mAlphaMode != base_material->mAlphaMode)
     {
         material_out.alphaMode = getAlphaMode();
     }
 
-    if(mAlphaCutoff != base_material->mAlphaCutoff)
+    if (mAlphaCutoff != base_material->mAlphaCutoff)
     {
         material_out.alphaCutoff = mAlphaCutoff;
     }
 
-    if(mBaseColor != base_material->mBaseColor)
+    if (mBaseColor != base_material->mBaseColor)
     {
         mBaseColor.write(material_out.pbrMetallicRoughness.baseColorFactor);
     }
 
-    if(mEmissiveColor != base_material->mEmissiveColor)
+    if (mEmissiveColor != base_material->mEmissiveColor)
     {
         mEmissiveColor.write(material_out.emissiveFactor);
     }
 
-    if(mMetallicFactor != base_material->mMetallicFactor)
+    if (mMetallicFactor != base_material->mMetallicFactor)
     {
         material_out.pbrMetallicRoughness.metallicFactor = mMetallicFactor;
     }
 
-    if(mRoughnessFactor != base_material->mRoughnessFactor)
+    if (mRoughnessFactor != base_material->mRoughnessFactor)
     {
         material_out.pbrMetallicRoughness.roughnessFactor = mRoughnessFactor;
     }
 
-    if(mDoubleSided != base_material->mDoubleSided)
+    if (mDoubleSided != base_material->mDoubleSided)
     {
         material_out.doubleSided = mDoubleSided;
     }
diff --git a/indra/llprimitive/llgltfmaterial.h b/indra/llprimitive/llgltfmaterial.h
index e8d1d67f1b..9c82f08805 100644
--- a/indra/llprimitive/llgltfmaterial.h
+++ b/indra/llprimitive/llgltfmaterial.h
@@ -27,8 +27,10 @@
 #pragma once
 
 #include "llrefcount.h"
+#include "llmemory.h"
 #include "v4color.h"
 #include "v3color.h"
+#include "v2math.h"
 #include "lluuid.h"
 #include "llmd5.h"
 
@@ -43,6 +45,13 @@ class LLGLTFMaterial : public LLRefCount
 {
 public:
 
+    struct TextureTransform
+    {
+        LLVector2 mOffset = { 0.f, 0.f };
+        LLVector2 mScale = { 1.f, 1.f };
+        F32 mRotation = 0.f;
+    };
+
     enum AlphaMode
     {
         ALPHA_MODE_OPAQUE = 0,
@@ -50,6 +59,11 @@ public:
         ALPHA_MODE_MASK
     };
 
+    LLGLTFMaterial() {}
+    LLGLTFMaterial(const LLGLTFMaterial& rhs);
+
+    LLGLTFMaterial& operator=(const LLGLTFMaterial& rhs);
+
     LLUUID mBaseColorId;
     LLUUID mNormalId;
     LLUUID mMetallicRoughnessId;
@@ -65,17 +79,41 @@ public:
     bool mDoubleSided = false;
     AlphaMode mAlphaMode = ALPHA_MODE_OPAQUE;
 
-    // get a UUID based on a hash of this LLGLTFMaterial
-    LLUUID getHash() const
+    enum TextureTransformIdx : U32
     {
-        LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
-        LLMD5 md5;
-        md5.update((unsigned char*)this, sizeof(this));
-        md5.finalize();
-        LLUUID id;
-        md5.raw_digest(id.mData);
-        return id;
-    }
+        TEXTURE_TRANSFORM_DIFFUSE_EMISSIVE,
+        TEXTURE_TRANSFORM_NORMAL,
+        TEXTURE_TRANSFORM_METALLIC_ROUGHNESS
+    };
+    TextureTransform mTextureTransform[3];
+
+    //setters for various members (will clamp to acceptable ranges)
+
+    void setBaseColorId(const LLUUID& id);
+    void setNormalId(const LLUUID& id);
+    void setMetallicRoughnessId(const LLUUID& id);
+    void setEmissiveId(const LLUUID& id);
+
+    void setBaseColorFactor(const LLColor3& baseColor, F32 transparency);
+    void setAlphaCutoff(F32 cutoff);
+    void setEmissiveColorFactor(const LLColor3& emissiveColor);
+    void setMetallicFactor(F32 metallic);
+    void setRoughnessFactor(F32 roughness);
+    void setAlphaMode(S32 mode);
+    void setDoubleSided(bool double_sided);
+
+    // Default value accessors
+    static LLUUID getDefaultBaseColorId();
+    static LLUUID getDefaultNormalId();
+    static LLUUID getDefaultEmissiveId();
+    static LLUUID getDefaultMetallicRoughnessId();
+    static F32 getDefaultAlphaCutoff();
+    static S32 getDefaultAlphaMode();
+    static F32 getDefaultMetallicFactor();
+    static F32 getDefaultRoughnessFactor();
+    static LLColor4 getDefaultBaseColor();
+    static LLColor3 getDefaultEmissiveColor();
+    static bool getDefaultDoubleSided();
 
     // set mAlphaMode from string.
     // Anything otherthan "MASK" or "BLEND" sets mAlphaMode to ALPHA_MODE_OPAQUE
@@ -123,7 +161,18 @@ public:
     // write to given tinygltf::Model
     void writeToModel(tinygltf::Model& model, S32 mat_index) const;
 
+    // get a UUID based on a hash of this LLGLTFMaterial
+    LLUUID getHash() const
+    {
+        LLMD5 md5;
+        md5.update((unsigned char*)this, sizeof(this));
+        md5.finalize();
+        LLUUID id;
+        md5.raw_digest(id.mData);
+        return id;
+    }
+
     // calculate the fields in this material that differ from a base material and write them out to a given tinygltf::Model
-    void writeOverridesToModel(tinygltf::Model & model, S32 mat_index, LLGLTFMaterial const * base_material) const;
+    void writeOverridesToModel(tinygltf::Model& model, S32 mat_index, LLGLTFMaterial const* base_material) const;
 };
 
diff --git a/indra/llprimitive/lltextureentry.h b/indra/llprimitive/lltextureentry.h
index 24875f0d21..bb74d258fd 100644
--- a/indra/llprimitive/lltextureentry.h
+++ b/indra/llprimitive/lltextureentry.h
@@ -135,10 +135,6 @@ public:
 	S32  setMaterialID(const LLMaterialID& pMaterialID);
 	S32  setMaterialParams(const LLMaterialPtr pMaterialParams);
 	
-    void setGLTFMaterial(LLGLTFMaterial* material) { mGLTFMaterial = material; }
-    LLGLTFMaterial* getGLTFMaterial() { return mGLTFMaterial; }
-
-
 	virtual const LLUUID &getID() const { return mID; }
 	const LLColor4 &getColor() const { return mColor; }
     const F32 getAlpha() const { return mColor.mV[VALPHA]; }
@@ -200,10 +196,18 @@ public:
 	// Media flags
 	enum { MF_NONE = 0x0, MF_HAS_MEDIA = 0x1 };
 
+    // GLTF asset
+    void setGLTFMaterial(LLGLTFMaterial* material) { mGLTFMaterial = material; }
+    LLGLTFMaterial* getGLTFMaterial() { return mGLTFMaterial; }
+
     // GLTF override
     LLGLTFMaterial* getGLTFMaterialOverride() { return mGLTFMaterialOverrides; }
     void setGLTFMaterialOverride(LLGLTFMaterial* mat) { mGLTFMaterialOverrides = mat; }
 
+    // GLTF render
+    LLGLTFMaterial* getGLTFRenderMaterial() { return mGLTFRenderMaterial; }
+    void setGLTFRenderMaterial(LLGLTFMaterial* mat) { mGLTFRenderMaterial = mat; }
+
 public:
 	F32                 mScaleS;                // S, T offset
 	F32                 mScaleT;                // S, T offset
@@ -230,12 +234,18 @@ protected:
 	bool                mMaterialUpdatePending;
 	LLMaterialID        mMaterialID;
 	LLMaterialPtr		mMaterial;
-    LLPointer<LLGLTFMaterial> mGLTFMaterial;  // if present, ignore mMaterial
+    
+    // Reference to GLTF material asset state
+    // On the viewer, this should be the same LLGLTFMaterial instance that exists in LLGLTFMaterialList
+    LLPointer<LLGLTFMaterial> mGLTFMaterial;  
 
     // GLTF material parameter overrides -- the viewer will use this data to override material parameters
-    // set by the asset
+    // set by the asset and store the results in mRenderGLTFMaterial
     LLPointer<LLGLTFMaterial> mGLTFMaterialOverrides;
 
+    // GLTF material to use for rendering -- will always be an LLFetchedGLTFMaterial
+    LLPointer<LLGLTFMaterial> mGLTFRenderMaterial; 
+
 	// Note the media data is not sent via the same message structure as the rest of the TE
 	LLMediaEntry*		mMediaEntry;			// The media data for the face