Applied patch for SNOW-586 by Thickbrick Sleaford: Add option to align textures across (planar-mapped, co-planar) faces

Was accidentally left out of a rebase

1 files changed, 159 insertions, 2 deletions

diff --git a/linden/indra/newview/llpanelface.cpp b/linden/indra/newview/llpanelface.cpp
index 6ae2ffe..bd9edec 100644
--- a/linden/indra/newview/llpanelface.cpp
+++ b/linden/indra/newview/llpanelface.cpp
@@ -48,7 +48,9 @@
 #include "llcheckboxctrl.h"
 #include "llcolorswatch.h"
 #include "llcombobox.h"
+#include "lldrawable.h"
 #include "lldrawpoolbump.h"
+#include "llface.h"
 #include "lllineeditor.h"
 #include "llresmgr.h"
 #include "llselectmgr.h"
@@ -173,6 +175,7 @@ BOOL	LLPanelFace::postBuild()
         
         childSetCommitCallback("combobox shininess",&LLPanelFace::onCommitShiny,this);
         childSetCommitCallback("combobox bumpiness",&LLPanelFace::onCommitBump,this);
+        childSetCommitCallback("checkbox planar align",&LLPanelFace::onCommitPlanarAlign, this);
         childSetCommitCallback("TexScaleU",&LLPanelFace::onCommitTextureInfo, this);
         childSetCommitCallback("checkbox flip s",&LLPanelFace::onCommitTextureInfo, this);
         childSetCommitCallback("TexScaleV",&LLPanelFace::onCommitTextureInfo, this);
@@ -364,6 +367,93 @@ private:
         LLPanelFace* mPanel;
 };
 
+// Functor that aligns a face to mCenterFace
+struct LLPanelFaceSetAlignedTEFunctor : public LLSelectedTEFunctor
+{
+        LLPanelFaceSetAlignedTEFunctor(LLPanelFace* panel, LLFace* center_face) :
+                mPanel(panel),
+                mCenterFace(center_face) {}
+
+        virtual bool apply(LLViewerObject* object, S32 te)
+        {
+                LLFace* facep = object->mDrawable->getFace(te);
+                if (!facep)
+                {
+                        return true;
+                }
+
+                bool set_aligned = true;
+                if (facep == mCenterFace)
+                {
+                        set_aligned = false;
+                }
+                if (set_aligned)
+                {
+                        LLVector2 uv_offset, uv_scale;
+                        F32 uv_rot;
+                        set_aligned = facep->calcAlignedPlanarTE(mCenterFace, &uv_offset, &uv_scale, &uv_rot);
+                        if (set_aligned)
+                        {
+                                object->setTEOffset(te, uv_offset.mV[VX], uv_offset.mV[VY]);
+                                object->setTEScale(te, uv_scale.mV[VX], uv_scale.mV[VY]);
+                                object->setTERotation(te, uv_rot);
+                        }
+                }
+                if (!set_aligned)
+                {
+                        LLPanelFaceSetTEFunctor setfunc(mPanel);
+                        setfunc.apply(object, te);
+                }
+                return true;
+        }
+private:
+        LLPanelFace* mPanel;
+        LLFace* mCenterFace;
+};
+
+// Functor that tests if a face is aligned to mCenterFace
+struct LLPanelFaceGetIsAlignedTEFunctor : public LLSelectedTEFunctor
+{
+        LLPanelFaceGetIsAlignedTEFunctor(LLFace* center_face) :
+                mCenterFace(center_face) {}
+
+        virtual bool apply(LLViewerObject* object, S32 te)
+        {
+                LLFace* facep = object->mDrawable->getFace(te);
+                if (!facep)
+                {
+                        return false;
+                }
+                if (facep == mCenterFace)
+                {
+                        return true;
+                }
+
+                LLVector2 aligned_st_offset, aligned_st_scale;
+                F32 aligned_st_rot;
+                if ( facep->calcAlignedPlanarTE(mCenterFace, &aligned_st_offset, &aligned_st_scale, &aligned_st_rot) )
+                {
+                        const LLTextureEntry* tep = facep->getTextureEntry();
+                        LLVector2 st_offset, st_scale;
+                        tep->getOffset(&st_offset.mV[VX], &st_offset.mV[VY]);
+                        tep->getScale(&st_scale.mV[VX], &st_scale.mV[VY]);
+                        F32 st_rot = tep->getRotation();
+                        // needs a fuzzy comparison, because of fp errors
+                        if (is_approx_equal_fraction(st_offset.mV[VX], aligned_st_offset.mV[VX], 14) &&
+                                is_approx_equal_fraction(st_offset.mV[VY], aligned_st_offset.mV[VY], 14) &&
+                                is_approx_equal_fraction(st_scale.mV[VX], aligned_st_scale.mV[VX], 14) &&
+                                is_approx_equal_fraction(st_scale.mV[VY], aligned_st_scale.mV[VY], 14) &&
+                                is_approx_equal_fraction(st_rot, aligned_st_rot, 10))
+                        {
+                                return true;
+                        }
+                }
+                return false;
+        }
+private:
+        LLFace* mCenterFace;
+};
+
 struct LLPanelFaceSendFunctor : public LLSelectedObjectFunctor
 {
         virtual bool apply(LLViewerObject* object)
@@ -375,8 +465,26 @@ struct LLPanelFaceSendFunctor : public LLSelectedObjectFunctor
 
 void LLPanelFace::sendTextureInfo()
 {
-        LLPanelFaceSetTEFunctor setfunc(this);
-        LLSelectMgr::getInstance()->getSelection()->applyToTEs(&setfunc);
+        if ((bool)childGetValue("checkbox planar align").asBoolean())
+        {
+                struct f1 : public LLSelectedTEGetFunctor<LLFace *>
+                {
+                        LLFace* get(LLViewerObject* object, S32 te)
+                        {
+                                return (object->mDrawable) ? object->mDrawable->getFace(te): NULL;
+                        }
+                } get_last_face_func;
+                LLFace* last_face;
+                LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue(&get_last_face_func, last_face);
+
+                LLPanelFaceSetAlignedTEFunctor setfunc(this, last_face);
+                LLSelectMgr::getInstance()->getSelection()->applyToTEs(&setfunc);
+        }
+        else
+        {
+                LLPanelFaceSetTEFunctor setfunc(this);
+                LLSelectMgr::getInstance()->getSelection()->applyToTEs(&setfunc);
+        }
 
         LLPanelFaceSendFunctor sendfunc;
         LLSelectMgr::getInstance()->getSelection()->applyToObjects(&sendfunc);
@@ -483,6 +591,43 @@ void LLPanelFace::getState()
                         }
                 }
 
+                // planar align
+                bool align_planar = false;
+                bool identical_planar_aligned = false;
+                {
+                        LLCheckBoxCtrl* cb_planar_align = getChild<LLCheckBoxCtrl>("checkbox planar align");
+                        align_planar = (cb_planar_align && cb_planar_align->get());
+                        struct f1 : public LLSelectedTEGetFunctor<bool>
+                        {
+                                bool get(LLViewerObject* object, S32 face)
+                                {
+                                        return (object->getTE(face)->getTexGen() == LLTextureEntry::TEX_GEN_PLANAR);
+                                }
+                        } func;
+
+                        bool is_planar;
+                        bool texgens_identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, is_planar );
+                        bool enabled = (editable && texgens_identical && is_planar);
+                        childSetValue("checkbox planar align", align_planar && enabled);
+                        childSetEnabled("checkbox planar align", enabled);
+
+                        if (align_planar && enabled)
+                        {
+                                struct f2 : public LLSelectedTEGetFunctor<LLFace *>
+                                {
+                                        LLFace* get(LLViewerObject* object, S32 te)
+                                        {
+                                                return (object->mDrawable) ? object->mDrawable->getFace(te): NULL;
+                                        }
+                                } get_te_face_func;
+                                LLFace* last_face;
+                                LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue(&get_te_face_func, last_face);
+                                LLPanelFaceGetIsAlignedTEFunctor get_is_aligend_func(last_face);
+                                // this will determine if the texture param controls are tentative:
+                                identical_planar_aligned = LLSelectMgr::getInstance()->getSelection()->applyToTEs(&get_is_aligend_func);
+                        }
+                }
+
                 // Texture scale
                 {
                         childSetEnabled("tex scale",editable);
@@ -496,6 +641,7 @@ void LLPanelFace::getState()
                                 }
                         } func;
                         identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, scale_s );
+                        identical = align_planar ? identical_planar_aligned : identical;
                         childSetValue("TexScaleU",editable ? llabs(scale_s) : 0);
                         childSetTentative("TexScaleU",LLSD((BOOL)(!identical)));
                         childSetEnabled("TexScaleU",editable);
@@ -514,6 +660,7 @@ void LLPanelFace::getState()
                                 }
                         } func;
                         identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, scale_t );
+                        identical = align_planar ? identical_planar_aligned : identical;
 
                         childSetValue("TexScaleV",llabs(editable ? llabs(scale_t) : 0));
                         childSetTentative("TexScaleV",LLSD((BOOL)(!identical)));
@@ -535,6 +682,7 @@ void LLPanelFace::getState()
                                 }
                         } func;
                         identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, offset_s );
+                        identical = align_planar ? identical_planar_aligned : identical;
                         childSetValue("TexOffsetU", editable ? offset_s : 0);
                         childSetTentative("TexOffsetU",!identical);
                         childSetEnabled("TexOffsetU",editable);
@@ -550,6 +698,7 @@ void LLPanelFace::getState()
                                 }
                         } func;
                         identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, offset_t );
+                        identical = align_planar ? identical_planar_aligned : identical;
                         childSetValue("TexOffsetV", editable ? offset_t : 0);
                         childSetTentative("TexOffsetV",!identical);
                         childSetEnabled("TexOffsetV",editable);
@@ -567,6 +716,7 @@ void LLPanelFace::getState()
                                 }
                         } func;
                         identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, rotation );
+                        identical = align_planar ? identical_planar_aligned : identical;
                         childSetValue("TexRot", editable ? rotation * RAD_TO_DEG : 0);
                         childSetTentative("TexRot",!identical);
                         childSetEnabled("TexRot",editable);
@@ -999,6 +1149,13 @@ void LLPanelFace::onClickAutoFix(void* userdata)
 }
 
 // static
+void LLPanelFace::onCommitPlanarAlign(LLUICtrl* ctrl, void* userdata)
+{
+        LLPanelFace* self = (LLPanelFace*) userdata;
+        self->getState();
+}
+
+// static
 void LLPanelFace::onClickTextureConstants(void *)
 {
         LLNotifications::instance().add("ClickTextureConstants");