Add TE support for texture gamma on legacy content.

This is a work around for legacy content to ensure that users can get alpha blending for their stuff closer to what it used to be.  This is mainly focused on the messaging end and plumbing.

Author: Geenz

indra/llprimitive/llprimitive.cpp

@@ -385,6 +385,11 @@ S32  LLPrimitive::setTEBumpmap(const U8 index, const U8 bump)
     return mTextureList.setBumpMap(index, bump);
 }
 
+S32 LLPrimitive::setTEAlphaGamma(const U8 index, const U8 gamma)
+{
+    return mTextureList.setAlphaGamma(index, gamma);
+}
+
 S32  LLPrimitive::setTEBumpShiny(const U8 index, const U8 bump_shiny)
 {
     updateNumBumpmap(index, bump_shiny);
@@ -1213,6 +1218,7 @@ bool LLPrimitive::packTEMessage(LLMessageSystem *mesgsys) const
     S16    offset_t[MAX_TES];
     S16    image_rot[MAX_TES];
     U8     bump[MAX_TES];
+    U8     alpha_gamma[MAX_TES];
     U8     media_flags[MAX_TES];
     U8     glow[MAX_TES];
     U8     material_data[MAX_TES*16];
@@ -1251,6 +1257,7 @@ bool LLPrimitive::packTEMessage(LLMessageSystem *mesgsys) const
             offset_t[face_index] = (S16) ll_round((llclamp(te->mOffsetT,-1.0f,1.0f) * (F32)0x7FFF)) ;
             image_rot[face_index] = (S16) ll_round(((fmod(te->mRotation, F_TWO_PI)/F_TWO_PI) * TEXTURE_ROTATION_PACK_FACTOR));
             bump[face_index] = te->getBumpShinyFullbright();
+            alpha_gamma[face_index]  = te->getAlphaGamma();
             media_flags[face_index] = te->getMediaTexGen();
             glow[face_index] = (U8) ll_round((llclamp(te->getGlow(), 0.0f, 1.0f) * (F32)0xFF));
 
@@ -1278,7 +1285,10 @@ bool LLPrimitive::packTEMessage(LLMessageSystem *mesgsys) const
         *cur_ptr++ = 0;
         cur_ptr += packTEField(cur_ptr, (U8 *)glow, 1 ,last_face_index, MVT_U8);
         *cur_ptr++ = 0;
-        cur_ptr += packTEField(cur_ptr, (U8 *)material_data, 16, last_face_index, MVT_LLUUID);
+        cur_ptr += packTEField(cur_ptr, (U8 *) material_data, 16, last_face_index, MVT_LLUUID);
+        *cur_ptr++ = 0;
+        *cur_ptr++ = 0x01;
+        cur_ptr += packTEField(cur_ptr, (U8 *) alpha_gamma, 1, last_face_index, MVT_U8);
     }
     mesgsys->addBinaryDataFast(_PREHASH_TextureEntry, packed_buffer, (S32)(cur_ptr - packed_buffer));
 
@@ -1298,6 +1308,7 @@ bool LLPrimitive::packTEMessage(LLDataPacker &dp) const
     S16    offset_t[MAX_TES];
     S16    image_rot[MAX_TES];
     U8     bump[MAX_TES];
+    U8     alpha_gamma[MAX_TES];
     U8     media_flags[MAX_TES];
     U8     glow[MAX_TES];
     U8     material_data[MAX_TES*16];
@@ -1336,6 +1347,7 @@ bool LLPrimitive::packTEMessage(LLDataPacker &dp) const
             offset_t[face_index] = (S16) ll_round((llclamp(te->mOffsetT,-1.0f,1.0f) * (F32)0x7FFF)) ;
             image_rot[face_index] = (S16) ll_round(((fmod(te->mRotation, F_TWO_PI)/F_TWO_PI) * TEXTURE_ROTATION_PACK_FACTOR));
             bump[face_index] = te->getBumpShinyFullbright();
+            alpha_gamma[face_index]  = te->getAlphaGamma();
             media_flags[face_index] = te->getMediaTexGen();
             glow[face_index] = (U8) ll_round((llclamp(te->getGlow(), 0.0f, 1.0f) * (F32)0xFF));
 
@@ -1363,7 +1375,10 @@ bool LLPrimitive::packTEMessage(LLDataPacker &dp) const
         *cur_ptr++ = 0;
         cur_ptr += packTEField(cur_ptr, (U8 *)glow, 1 ,last_face_index, MVT_U8);
         *cur_ptr++ = 0;
-        cur_ptr += packTEField(cur_ptr, (U8 *)material_data, 16, last_face_index, MVT_LLUUID);
+        cur_ptr += packTEField(cur_ptr, (U8 *) material_data, 16, last_face_index, MVT_LLUUID);
+        *cur_ptr++ = 0;
+        *cur_ptr++ = 0x01;
+        cur_ptr += packTEField(cur_ptr, (U8 *) alpha_gamma, 1, last_face_index, MVT_U8);
     }
 
     dp.packBinaryData(packed_buffer, (S32)(cur_ptr - packed_buffer), "TextureEntry");
@@ -1420,7 +1435,8 @@ S32 LLPrimitive::parseTEMessage(LLMessageSystem* mesgsys, char const* block_name
             unpack_TEField<S16>(tec.image_rot, tec.face_count, cur_ptr, buffer_end, MVT_S16) &&
             unpack_TEField<U8>(tec.bump, tec.face_count, cur_ptr, buffer_end, MVT_U8) &&
             unpack_TEField<U8>(tec.media_flags, tec.face_count, cur_ptr, buffer_end, MVT_U8) &&
-            unpack_TEField<U8>(tec.glow, tec.face_count, cur_ptr, buffer_end, MVT_U8)))
+            unpack_TEField<U8>(tec.glow, tec.face_count, cur_ptr, buffer_end, MVT_U8) &&
+            unpack_TEField<U8>(tec.alpha_gamma, tec.face_count, cur_ptr, buffer_end, MVT_U8)))
     {
         LL_WARNS("TEXTUREENTRY") << "Failure parsing Texture Entry Message due to malformed TE Field! Dropping changes on the floor. " << LL_ENDL;
         return 0;
@@ -1456,6 +1472,7 @@ S32 LLPrimitive::applyParsedTEMessage(LLTEContents& tec)
         retval |= setTEMediaTexGen(i, tec.media_flags[i]);
         retval |= setTEGlow(i, (F32)tec.glow[i] / (F32)0xFF);
         retval |= setTEMaterialID(i, tec.material_ids[i]);
+        retval |= setTEAlphaGamma(i, tec.alpha_gamma[i]);
 
         // Note:  This is an optimization to send common colors (1.f, 1.f, 1.f, 1.f)
         // as all zeros.  However, the subtraction and addition must be done in unsigned

indra/llprimitive/llprimitive.h

@@ -411,6 +411,7 @@ struct LLTEContents
     S16    offset_t[MAX_TES];
     S16    image_rot[MAX_TES];
     U8     bump[MAX_TES];
+    U8     alpha_gamma[MAX_TES];
     U8     media_flags[MAX_TES];
     U8     glow[MAX_TES];
     LLMaterialID material_ids[MAX_TES];
@@ -482,6 +483,7 @@ class LLPrimitive : public LLXform
     virtual S32 setTEBumpShiny(const U8 te, const U8 bump);
     virtual S32 setTEMediaTexGen(const U8 te, const U8 media);
     virtual S32 setTEBumpmap(const U8 te, const U8 bump);
+    virtual S32 setTEAlphaGamma(const U8 te, const U8 alphagamma);
     virtual S32 setTETexGen(const U8 te, const U8 texgen);
     virtual S32 setTEShiny(const U8 te, const U8 shiny);
     virtual S32 setTEFullbright(const U8 te, const U8 fullbright);

indra/llprimitive/llprimtexturelist.cpp

@@ -305,6 +305,15 @@ S32 LLPrimTextureList::setBumpMap(const U8 index, const U8 bump)
     return TEM_CHANGE_NONE;
 }
 
+S32 LLPrimTextureList::setAlphaGamma(const U8 index, const U8 gamma)
+{
+    if (index < mEntryList.size())
+    {
+        return mEntryList[index]->setAlphaGamma(gamma);
+    }
+    return TEM_CHANGE_NONE;
+}
+
 S32 LLPrimTextureList::setBumpShiny(const U8 index, const U8 bump_shiny)
 {
     if (index < mEntryList.size())

indra/llprimitive/llprimtexturelist.h

@@ -99,6 +99,7 @@ class LLPrimTextureList
     S32 setMediaTexGen(const U8 index, const U8 media);
     S32 setBumpMap(const U8 index, const U8 bump);
     S32 setBumpShiny(const U8 index, const U8 bump_shiny);
+    S32 setAlphaGamma(const U8 index, const U8 gamma);
     S32 setTexGen(const U8 index, const U8 texgen);
     S32 setShiny(const U8 index, const U8 shiny);
     S32 setFullbright(const U8 index, const U8 t);

indra/llprimitive/lltextureentry.cpp

@@ -34,6 +34,7 @@
 #include "v4color.h"
 
 const U8 DEFAULT_BUMP_CODE = 0;  // no bump or shininess
+const U8 DEFAULT_ALPHA_GAMMA = 100;  // Gamma 1 (linear) for alpha blending
 
 const LLTextureEntry LLTextureEntry::null;
 
@@ -64,15 +65,15 @@ LLTextureEntry::LLTextureEntry()
   , mSelected(false)
   , mMaterialUpdatePending(false)
 {
-    init(LLUUID::null,1.f,1.f,0.f,0.f,0.f,DEFAULT_BUMP_CODE);
+    init(LLUUID::null, 1.f, 1.f, 0.f, 0.f, 0.f, DEFAULT_BUMP_CODE, DEFAULT_ALPHA_GAMMA);
 }
 
 LLTextureEntry::LLTextureEntry(const LLUUID& tex_id)
   : mMediaEntry(NULL)
   , mSelected(false)
   , mMaterialUpdatePending(false)
 {
-    init(tex_id,1.f,1.f,0.f,0.f,0.f,DEFAULT_BUMP_CODE);
+    init(tex_id, 1.f, 1.f, 0.f, 0.f, 0.f, DEFAULT_BUMP_CODE, DEFAULT_ALPHA_GAMMA);
 }
 
 LLTextureEntry::LLTextureEntry(const LLTextureEntry &rhs)
@@ -95,6 +96,7 @@ LLTextureEntry &LLTextureEntry::operator=(const LLTextureEntry &rhs)
         mRotation = rhs.mRotation;
         mColor = rhs.mColor;
         mBump = rhs.mBump;
+        mAlphaGamma = rhs.mAlphaGamma;
         mMediaFlags = rhs.mMediaFlags;
         mGlow = rhs.mGlow;
         mMaterialID = rhs.mMaterialID;
@@ -135,7 +137,7 @@ LLTextureEntry &LLTextureEntry::operator=(const LLTextureEntry &rhs)
     return *this;
 }
 
-void LLTextureEntry::init(const LLUUID& tex_id, F32 scale_s, F32 scale_t, F32 offset_s, F32 offset_t, F32 rotation, U8 bump)
+void LLTextureEntry::init(const LLUUID& tex_id, F32 scale_s, F32 scale_t, F32 offset_s, F32 offset_t, F32 rotation, U8 bump, U8 alphagamma)
 {
     setID(tex_id);
 
@@ -145,6 +147,7 @@ void LLTextureEntry::init(const LLUUID& tex_id, F32 scale_s, F32 scale_t, F32 of
     mOffsetT = offset_t;
     mRotation = rotation;
     mBump = bump;
+    mAlphaGamma = alphagamma;
     mMediaFlags = 0x0;
     mGlow = 0;
     mMaterialID.clear();
@@ -181,6 +184,7 @@ bool LLTextureEntry::operator!=(const LLTextureEntry &rhs) const
     if (mRotation != rhs.mRotation) return(true);
     if (mColor != rhs.mColor) return (true);
     if (mBump != rhs.mBump) return (true);
+    if (mAlphaGamma != rhs.mAlphaGamma) return (true);
     if (mMediaFlags != rhs.mMediaFlags) return (true);
     if (mGlow != rhs.mGlow) return (true);
     if (mMaterialID != rhs.mMaterialID) return (true);
@@ -197,6 +201,7 @@ bool LLTextureEntry::operator==(const LLTextureEntry &rhs) const
     if (mRotation != rhs.mRotation) return(false);
     if (mColor != rhs.mColor) return (false);
     if (mBump != rhs.mBump) return (false);
+    if (mAlphaGamma != rhs.mAlphaGamma) return (false);
     if (mMediaFlags != rhs.mMediaFlags) return false;
     if (mGlow != rhs.mGlow) return false;
     if (mMaterialID != rhs.mMaterialID) return (false);
@@ -221,6 +226,7 @@ void LLTextureEntry::asLLSD(LLSD& sd) const
     sd["offsett"] = mOffsetT;
     sd["imagerot"] = mRotation;
     sd["bump"] = getBumpShiny();
+    sd["alphagamma"]  = getAlphaGamma();
     sd["fullbright"] = getFullbright();
     sd["media_flags"] = mMediaFlags;
     if (hasMedia()) {
@@ -274,6 +280,11 @@ bool LLTextureEntry::fromLLSD(const LLSD& sd)
     {
         setBumpShiny( sd[w].asInteger() );
     } else goto fail;
+    w = "alphagamma";
+    if (sd.has(w))
+    {
+        setAlphaGamma(sd[w].asInteger());
+    } // else goto fail;
     w = "fullbright";
     if (sd.has(w))
     {
@@ -472,6 +483,16 @@ S32 LLTextureEntry::setBumpShinyFullbright(U8 bump)
     return TEM_CHANGE_NONE;
 }
 
+S32 LLTextureEntry::setAlphaGamma(U8 alpha_gamma)
+{
+    if (mAlphaGamma != alpha_gamma)
+    {
+        mAlphaGamma = alpha_gamma;
+        return TEM_CHANGE_TEXTURE;
+    }
+    return TEM_CHANGE_NONE;
+}
+
 S32 LLTextureEntry::setMediaTexGen(U8 media)
 {
     S32 result = TEM_CHANGE_NONE;

indra/llprimitive/lltextureentry.h

@@ -103,7 +103,7 @@ class LLTextureEntry
     virtual LLTextureEntry* newBlank() const;
     virtual LLTextureEntry* newCopy() const;
 
-    void init(const LLUUID& tex_id, F32 scale_s, F32 scale_t, F32 offset_s, F32 offset_t, F32 rotation, U8 bump);
+    void init(const LLUUID& tex_id, F32 scale_s, F32 scale_t, F32 offset_s, F32 offset_t, F32 rotation, U8 bump, U8 alphagamma);
 
     bool hasPendingMaterialUpdate() const { return mMaterialUpdatePending; }
     bool isSelected() const { return mSelected; }
@@ -128,6 +128,8 @@ class LLTextureEntry
     S32  setBumpShiny(U8 bump);
     S32  setBumpShinyFullbright(U8 bump);
 
+    S32  setAlphaGamma(U8 alpha_gamma);
+
     S32  setMediaFlags(U8 media_flags);
     S32  setTexGen(U8 texGen);
     S32  setMediaTexGen(U8 media);
@@ -156,6 +158,8 @@ class LLTextureEntry
     U8   getBumpShiny() const { return mBump & TEM_BUMP_SHINY_MASK; }
     U8   getBumpShinyFullbright() const { return mBump; }
 
+    U8   getAlphaGamma() const { return mAlphaGamma; }
+
     U8   getMediaFlags() const { return mMediaFlags & TEM_MEDIA_MASK; }
     LLTextureEntry::e_texgen     getTexGen() const  { return LLTextureEntry::e_texgen(mMediaFlags & TEM_TEX_GEN_MASK); }
     U8   getMediaTexGen() const { return mMediaFlags; }
@@ -233,6 +237,7 @@ class LLTextureEntry
     LLColor4            mColor;
     U8                  mBump;                  // Bump map, shiny, and fullbright
     U8                  mMediaFlags;            // replace with web page, movie, etc.
+    U8                  mAlphaGamma;            // Fixed point gamma correction for alpha blending.
     F32                 mGlow;
     bool                mMaterialUpdatePending;
     LLMaterialID        mMaterialID;

indra/newview/llpanelface.cpp

@@ -421,6 +421,11 @@ bool LLPanelFace::postBuild()
 
     getChildSetCommitCallback(mCheckFullbright, "checkbox fullbright", [&](LLUICtrl*, const LLSD&) { onCommitFullbright(); });
 
+    
+    mLabelTexGen = getChild<LLTextBox>("alpha gamma");
+    getChildSetCommitCallback(mComboAlphaGamma, "combobox alpha gamma", [&](LLUICtrl *, const LLSD &) { onCommitAlphaGamma(); });
+    mComboAlphaGamma->setFollows(FOLLOWS_LEFT | FOLLOWS_TOP);
+
     mLabelTexGen = getChild<LLTextBox>("tex gen");
     getChildSetCommitCallback(mComboTexGen, "combobox texgen", [&](LLUICtrl*, const LLSD&) { onCommitTexGen(); });
     mComboTexGen->setFollows(FOLLOWS_LEFT | FOLLOWS_TOP);
@@ -553,6 +558,12 @@ void LLPanelFace::sendBump(U32 bumpiness)
     LLSelectMgr::getInstance()->selectionSetBumpmap( bump, mBumpyTextureCtrl->getImageItemID() );
 }
 
+void LLPanelFace::sendAlphaGamma()
+{
+    U8 alpha_gamma = (U8) mComboAlphaGamma->getCurrentIndex() << TEM_TEX_GEN_SHIFT;
+    LLSelectMgr::getInstance()->selectionSetAlphaGamma(alpha_gamma);
+}
+
 void LLPanelFace::sendTexGen()
 {
     U8 tex_gen = (U8)mComboTexGen->getCurrentIndex() << TEM_TEX_GEN_SHIFT;
@@ -2914,6 +2925,11 @@ void LLPanelFace::onCommitBump()
     sendBump(mComboBumpiness->getCurrentIndex());
 }
 
+void LLPanelFace::onCommitAlphaGamma()
+{
+    sendAlphaGamma();
+}
+
 void LLPanelFace::onCommitTexGen()
 {
     sendTexGen();

indra/newview/llpanelface.h

@@ -146,6 +146,7 @@ class LLPanelFace : public LLPanel
     void sendColor();              // applies and sends color
     void sendAlpha();              // applies and sends transparency
     void sendBump(U32 bumpiness);  // applies and sends bump map
+    void sendAlphaGamma();         // applies and sends bump map
     void sendTexGen();             // applies and sends bump map
     void sendShiny(U32 shininess); // applies and sends shininess
     void sendFullbright();         // applies and sends full bright
@@ -234,6 +235,7 @@ class LLPanelFace : public LLPanel
     void onClickBtnDeleteMedia();
     void onClickBtnAddMedia();
     void onCommitBump();
+    void onCommitAlphaGamma();
     void onCommitTexGen();
     void onCommitShiny();
     void onCommitAlphaMode();
@@ -304,6 +306,8 @@ class LLPanelFace : public LLPanel
     LLTextBox* mLabelTexGen { nullptr };
     LLComboBox* mComboTexGen { nullptr };
 
+    LLComboBox *mComboAlphaGamma {nullptr};
+
     LLRadioGroup* mRadioMaterialType { nullptr };
     LLRadioGroup* mRadioPbrType { nullptr };
 

indra/newview/llselectmgr.cpp

@@ -2330,6 +2330,28 @@ void LLSelectMgr::selectionSetBumpmap(U8 bumpmap, const LLUUID &image_id)
     getSelection()->applyToObjects(&sendfunc);
 }
 
+void LLSelectMgr::selectionSetAlphaGamma(U8 gamma)
+{
+    struct f : public LLSelectedTEFunctor
+    {
+        U8 mAlphaGamma;
+        f(const U8 &t) : mAlphaGamma(t) {}
+        bool apply(LLViewerObject *object, S32 te)
+        {
+            if (object->permModify())
+            {
+                // update viewer side color in anticipation of update from simulator
+                object->setTEAlphaGamma(te, mAlphaGamma);
+            }
+            return true;
+        }
+    } setfunc(gamma);
+    getSelection()->applyToTEs(&setfunc);
+
+    LLSelectMgrSendFunctor sendfunc;
+    getSelection()->applyToObjects(&sendfunc);
+}
+
 void LLSelectMgr::selectionSetTexGen(U8 texgen)
 {
     struct f : public LLSelectedTEFunctor

indra/newview/llselectmgr.h

@@ -660,6 +660,7 @@ class LLSelectMgr : public LLEditMenuHandler, public LLSimpleton<LLSelectMgr>
     bool selectionRevertTextures();
     void selectionRevertGLTFMaterials();
     void selectionSetBumpmap( U8 bumpmap, const LLUUID &image_id );
+    void selectionSetAlphaGamma( U8 gamma );
     void selectionSetTexGen( U8 texgen );
     void selectionSetShiny( U8 shiny, const LLUUID &image_id );
     void selectionSetFullbright( U8 fullbright );