1 files changed, 342 insertions, 325 deletions

diff --git a/linden/indra/llprimitive/llprimitive.cpp b/linden/indra/llprimitive/llprimitive.cpp
index f1b7522..0ad9f79 100644..100755
--- a/linden/indra/llprimitive/llprimitive.cpp
+++ b/linden/indra/llprimitive/llprimitive.cpp
@@ -4,7 +4,7 @@
  *
  * $LicenseInfo:firstyear=2001&license=viewergpl$
  * 
- * Copyright (c) 2001-2009, Linden Research, Inc.
+ * Copyright (c) 2001-2010, Linden Research, Inc.
  * 
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
@@ -43,7 +43,8 @@
 #include "llvolumemgr.h"
 #include "llstring.h"
 #include "lldatapacker.h"
-#include "llsdutil.h"
+#include "llsdutil.h"//_math.h"
+#include "llprimtexturelist.h"
 
 /**
  * exported constants
@@ -111,6 +112,7 @@ const F32 FLEXIBLE_OBJECT_DEFAULT_LENGTH = 1.0f;
 const BOOL FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE = FALSE;
 const BOOL FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE = FALSE;
 
+const S32 MAX_FACE_BITS = 9;
 
 const char *SCULPT_DEFAULT_TEXTURE = "be293869-d0d9-0a69-5989-ad27f1946fd4"; // old inverted texture: "7595d345-a24c-e7ef-f0bd-78793792133e";
 
@@ -129,7 +131,7 @@ void LLPrimitive::setVolumeManager( LLVolumeMgr* volume_manager )
 {
         if ( !volume_manager || sVolumeManager )
         {
-                llerrs << "Unable to set LLPrimitive::sVolumeManager to NULL" << llendl;
+                llerrs << "LLPrimitive::sVolumeManager attempting to be set to NULL or it already has been set." << llendl;
         }
         sVolumeManager = volume_manager;
 }
@@ -150,7 +152,9 @@ bool LLPrimitive::cleanupVolumeManager()
 
 //===============================================================
 LLPrimitive::LLPrimitive()
-:       mMiscFlags(0)
+:       mTextureList(),
+        mNumTEs(0),
+        mMiscFlags(0)
 {
         mPrimitiveCode = 0;
 
@@ -167,20 +171,12 @@ LLPrimitive::LLPrimitive()
         mAngularVelocity.setVec(0.f,0.f,0.f);
         
         mScale.setVec(1.f,1.f,1.f);
-
-        mNumTEs = 0;
-        mTextureList = NULL;
 }
 
 //===============================================================
 LLPrimitive::~LLPrimitive()
 {
-        if (mTextureList)
-        {
-                delete [] mTextureList;
-                mTextureList = NULL;
-        }
-
+        clearTextureList();
         // Cleanup handled by volume manager
         if (mVolumep)
         {
@@ -189,6 +185,10 @@ LLPrimitive::~LLPrimitive()
         mVolumep = NULL;
 }
 
+void LLPrimitive::clearTextureList()
+{
+}
+
 //===============================================================
 // static
 LLPrimitive *LLPrimitive::createPrimitive(LLPCode p_code)
@@ -212,15 +212,7 @@ LLPrimitive *LLPrimitive::createPrimitive(LLPCode p_code)
 void LLPrimitive::init_primitive(LLPCode p_code)
 {
         LLMemType m1(LLMemType::MTYPE_PRIMITIVE);
-        if (mNumTEs)
-        {
-                if (mTextureList)
-                {
-                        delete [] mTextureList;
-                }
-                mTextureList = new LLTextureEntry[mNumTEs];
-        }
-
+        clearTextureList();
         mPrimitiveCode = p_code;
 }
 
@@ -230,342 +222,147 @@ void LLPrimitive::setPCode(const U8 p_code)
 }
 
 //===============================================================
-const LLTextureEntry * LLPrimitive::getTE(const U8 te_num) const
+LLTextureEntry* LLPrimitive::getTE(const U8 index) const
 {
-        // if we're asking for a non-existent face, return null
-        if (mNumTEs && (te_num< mNumTEs))
-        {
-                return(&mTextureList[te_num]);
-        }
-        else
-        {       
-                return(NULL);
-        }
+        return mTextureList.getTexture(index);
 }
 
 //===============================================================
 void LLPrimitive::setNumTEs(const U8 num_tes)
 {
-        if (num_tes == mNumTEs)
-        {
-                return;
-        }
-        
-        // Right now, we don't try and preserve entries when the number of faces
-        // changes.
-
-        LLMemType m1(LLMemType::MTYPE_PRIMITIVE);
-        if (num_tes)
-        {
-                LLTextureEntry *new_tes;
-                new_tes = new LLTextureEntry[num_tes];
-                U32 i;
-                for (i = 0; i < num_tes; i++)
-                {
-                        if (i < mNumTEs)
-                        {
-                                new_tes[i] = mTextureList[i];
-                        }
-                        else if (mNumTEs)
-                        {
-                                new_tes[i] = mTextureList[mNumTEs - 1];
-                        }
-                        else
-                        {
-                                new_tes[i] = LLTextureEntry();
-                        }
-                }
-                delete[] mTextureList;
-                mTextureList = new_tes;
-        }
-        else
-        {
-                delete[] mTextureList;
-                mTextureList = NULL;
-        }
-
-
-        mNumTEs = num_tes;
+        mTextureList.setSize(num_tes);
 }
 
 //===============================================================
 void  LLPrimitive::setAllTETextures(const LLUUID &tex_id)
 {
-        U8 i;
-
-        for (i = 0; i < mNumTEs; i++)
-        {
-                mTextureList[i].setID(tex_id);
-        }
+        mTextureList.setAllIDs(tex_id);
 }
 
 //===============================================================
-void LLPrimitive::setTE(const U8 index, const LLTextureEntry &te)
+void LLPrimitive::setTE(const U8 index, const LLTextureEntry& te)
 {
-        mTextureList[index] = te;
+        mTextureList.copyTexture(index, te);
 }
 
-S32  LLPrimitive::setTETexture(const U8 te, const LLUUID &tex_id)
+S32  LLPrimitive::setTETexture(const U8 index, const LLUUID &id)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setID(tex_id);
+        return mTextureList.setID(index, id);
 }
 
-S32  LLPrimitive::setTEColor(const U8 te, const LLColor4 &color)
+S32  LLPrimitive::setTEColor(const U8 index, const LLColor4 &color)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
 
-        return mTextureList[te].setColor(color);
+        return mTextureList.setColor(index, color);
 }
 
-S32  LLPrimitive::setTEColor(const U8 te, const LLColor3 &color)
+S32  LLPrimitive::setTEColor(const U8 index, const LLColor3 &color)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setColor(color);
+        return mTextureList.setColor(index, color);
 }
 
-S32  LLPrimitive::setTEAlpha(const U8 te, const F32 alpha)
+S32  LLPrimitive::setTEAlpha(const U8 index, const F32 alpha)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setAlpha(alpha);
+        return mTextureList.setAlpha(index, alpha);
 }
 
 //===============================================================
-S32  LLPrimitive::setTEScale(const U8 te, const F32 s, const F32 t)
+S32  LLPrimitive::setTEScale(const U8 index, const F32 s, const F32 t)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "Setting nonexistent face" << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setScale(s,t);
+        return mTextureList.setScale(index, s, t);
 }
 
 
 // BUG: slow - done this way because texture entries have some
 // voodoo related to texture coords
-S32 LLPrimitive::setTEScaleS(const U8 te, const F32 s)
+S32 LLPrimitive::setTEScaleS(const U8 index, const F32 s)
 {
-        if (te >= mNumTEs)
-        {
-                llwarns << "Setting nonexistent face" << llendl;
-                return 0;
-        }
-
-        F32 ignore, t;
-        mTextureList[te].getScale(&ignore, &t);
-        return mTextureList[te].setScale(s,t);
+        return mTextureList.setScaleS(index, s);
 }
 
 
 // BUG: slow - done this way because texture entries have some
 // voodoo related to texture coords
-S32 LLPrimitive::setTEScaleT(const U8 te, const F32 t)
+S32 LLPrimitive::setTEScaleT(const U8 index, const F32 t)
 {
-        if (te >= mNumTEs)
-        {
-                llwarns << "Setting nonexistent face" << llendl;
-                return 0;
-        }
-
-        F32 s, ignore;
-        mTextureList[te].getScale(&s, &ignore);
-        return mTextureList[te].setScale(s,t);
+        return mTextureList.setScaleT(index, t);
 }
 
 
 //===============================================================
-S32  LLPrimitive::setTEOffset(const U8 te, const F32 s, const F32 t)
+S32  LLPrimitive::setTEOffset(const U8 index, const F32 s, const F32 t)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "Setting nonexistent face" << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setOffset(s,t);
+        return mTextureList.setOffset(index, s, t);
 }
 
 
 // BUG: slow - done this way because texture entries have some
 // voodoo related to texture coords
-S32 LLPrimitive::setTEOffsetS(const U8 te, const F32 s)
+S32 LLPrimitive::setTEOffsetS(const U8 index, const F32 s)
 {
-        if (te >= mNumTEs)
-        {
-                llwarns << "Setting nonexistent face" << llendl;
-                return 0;
-        }
-
-        F32 ignore, t;
-        mTextureList[te].getOffset(&ignore, &t);
-        return mTextureList[te].setOffset(s,t);
+        return mTextureList.setOffsetS(index, s);
 }
 
 
 // BUG: slow - done this way because texture entries have some
 // voodoo related to texture coords
-S32 LLPrimitive::setTEOffsetT(const U8 te, const F32 t)
+S32 LLPrimitive::setTEOffsetT(const U8 index, const F32 t)
 {
-        if (te >= mNumTEs)
-        {
-                llwarns << "Setting nonexistent face" << llendl;
-                return 0;
-        }
-
-        F32 s, ignore;
-        mTextureList[te].getOffset(&s, &ignore);
-        return mTextureList[te].setOffset(s,t);
+        return mTextureList.setOffsetT(index, t);
 }
 
 
 //===============================================================
-S32  LLPrimitive::setTERotation(const U8 te, const F32 r)
+S32  LLPrimitive::setTERotation(const U8 index, const F32 r)
 {
-     // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "Setting nonexistent face" << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setRotation(r);
+        return mTextureList.setRotation(index, r);
 }
 
 
 //===============================================================
-S32  LLPrimitive::setTEBumpShinyFullbright(const U8 te, const U8 bump)
+S32  LLPrimitive::setTEBumpShinyFullbright(const U8 index, const U8 bump)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setBumpShinyFullbright( bump );
+        return mTextureList.setBumpShinyFullbright(index, bump);
 }
 
-S32  LLPrimitive::setTEMediaTexGen(const U8 te, const U8 media)
+S32  LLPrimitive::setTEMediaTexGen(const U8 index, const U8 media)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setMediaTexGen( media );
+        return mTextureList.setMediaTexGen(index, media);
 }
 
-S32  LLPrimitive::setTEBumpmap(const U8 te, const U8 bump)
+S32  LLPrimitive::setTEBumpmap(const U8 index, const U8 bump)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setBumpmap( bump );
+        return mTextureList.setBumpMap(index, bump);
 }
 
-S32  LLPrimitive::setTEBumpShiny(const U8 te, const U8 bump_shiny)
+S32  LLPrimitive::setTEBumpShiny(const U8 index, const U8 bump_shiny)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setBumpShiny( bump_shiny );
+        return mTextureList.setBumpShiny(index, bump_shiny);
 }
 
-S32  LLPrimitive::setTETexGen(const U8 te, const U8 texgen)
+S32  LLPrimitive::setTETexGen(const U8 index, const U8 texgen)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setTexGen( texgen );
+        return mTextureList.setTexGen(index, texgen);
 }
 
-S32  LLPrimitive::setTEShiny(const U8 te, const U8 shiny)
+S32  LLPrimitive::setTEShiny(const U8 index, const U8 shiny)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setShiny( shiny );
+        return mTextureList.setShiny(index, shiny);
 }
 
-S32  LLPrimitive::setTEFullbright(const U8 te, const U8 fullbright)
+S32  LLPrimitive::setTEFullbright(const U8 index, const U8 fullbright)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setFullbright( fullbright );
+        return mTextureList.setFullbright(index, fullbright);
 }
 
-S32  LLPrimitive::setTEMediaFlags(const U8 te, const U8 media_flags)
+S32  LLPrimitive::setTEMediaFlags(const U8 index, const U8 media_flags)
 {
-    // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                return 0;
-        }
-
-        return mTextureList[te].setMediaFlags( media_flags );
+        return mTextureList.setMediaFlags(index, media_flags);
 }
 
-S32 LLPrimitive::setTEGlow(const U8 te, const F32 glow)
+S32 LLPrimitive::setTEGlow(const U8 index, const F32 glow)
 {
-        // if we're asking for a non-existent face, return null
-        if (te >= mNumTEs)
-        {
-                llwarns << "setting non-existent te " << te << llendl;
-                        return 0;
-        }
-
-        return mTextureList[te].setGlow( glow );
+        return mTextureList.setGlow(index, glow);
 }
 
 
@@ -877,25 +674,18 @@ std::string LLPrimitive::pCodeToString(const LLPCode pcode)
 void LLPrimitive::copyTEs(const LLPrimitive *primitivep)
 {
         U32 i;
-        if (primitivep->getNumTEs() != getNumTEs())
+        if (primitivep->getExpectedNumTEs() != getExpectedNumTEs())
+        {
+                llwarns << "Primitives don't have same expected number of TE's" << llendl;
+        }
+        U32 num_tes = llmin(primitivep->getExpectedNumTEs(), getExpectedNumTEs());
+        if (mTextureList.size() < getExpectedNumTEs())
         {
-                llwarns << "Primitives don't have same number of TE's" << llendl;
+                mTextureList.setSize(getExpectedNumTEs());
         }
-        U32 num_tes = llmin(primitivep->getNumTEs(), getNumTEs());
         for (i = 0; i < num_tes; i++)
         {
-                const LLTextureEntry *tep = primitivep->getTE(i);
-                F32 s, t;
-                setTETexture(i, tep->getID());
-                setTEColor(i, tep->getColor());
-                tep->getScale(&s, &t);
-                setTEScale(i, s, t);
-                tep->getOffset(&s, &t);
-                setTEOffset(i, s, t);
-                setTERotation(i, tep->getRotation());
-                setTEBumpShinyFullbright(i, tep->getBumpShinyFullbright());
-                setTEMediaTexGen(i, tep->getMediaTexGen());
-                setTEGlow(i, tep->getGlow());
+                mTextureList.copyTexture(i, *(primitivep->getTE(i)));
         }
 }
 
@@ -957,73 +747,208 @@ BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detai
 
         U32 old_face_mask = mVolumep->mFaceMask;
 
+
+        S32 face_bit = 0;
+        S32 cur_mask = 0;
+
+        // Grab copies of the old faces from the original shape, ordered by type.
+        // We will use these to figure out what old texture info gets mapped to new
+        // faces in the new shape.
+        std::vector<LLProfile::Face> old_faces; 
+        for (S32 face = 0; face < mVolumep->getNumFaces(); face++)
+        {
+                old_faces.push_back(mVolumep->getProfile().mFaces[face]);
+        }
+
+        // Copy the old texture info off to the side, but not in the order in which
+        // they live in the mTextureList, rather in order of ther "face id" which
+        // is the corresponding value of LLVolueParams::LLProfile::mFaces::mIndex.
+        //
+        // Hence, some elements of old_tes::mEntryList will be invalid.  It is
+        // initialized to a size of 9 (max number of possible faces on a volume?)
+        // and only the ones with valid types are filled in.
+        LLPrimTextureList old_tes;
+        old_tes.setSize(9);
+        for (face_bit = 0; face_bit < 9; face_bit++)
+        {
+                cur_mask = 0x1 << face_bit;
+                if (old_face_mask & cur_mask)
+                {
+                        S32 te_index = face_index_from_id(cur_mask, old_faces);
+                        old_tes.copyTexture(face_bit, *(getTE(te_index)));
+                        //llinfos << face_bit << ":" << te_index << ":" << old_tes[face_bit].getID() << llendl;
+                }
+        }
+
+
         // build the new object
         sVolumeManager->unrefVolume(mVolumep);
         mVolumep = volumep;
         
-        U32 new_face_mask = mVolumep->mFaceMask;        
-        if (old_face_mask != new_face_mask) 
-        {
-                setNumTEs(mVolumep->getNumFaces());
-        }       
-        
-        return TRUE;
-}
+        U32 new_face_mask = mVolumep->mFaceMask;
+        S32 i;
 
-BOOL LLPrimitive::setMaterial(U8 material)
-{
-        if (material != mMaterial)
+        if (old_face_mask == new_face_mask) 
         {
-                mMaterial = material;
+                setNumTEs(mVolumep->getNumFaces());
                 return TRUE;
         }
-        else
-        {
-                return FALSE;
-        }
-}
 
-void LLPrimitive::setTEArrays(const U8 size,
-                                                          const LLUUID* image_ids,
-                                                          const F32* scale_s,
-                                                          const F32* scale_t)
-{
-        S32 cur_size = size;
-        if (cur_size > getNumTEs())
+        // initialize face_mapping
+        S32 face_mapping[9];
+        for (face_bit = 0; face_bit < 9; face_bit++)
         {
-                llwarns << "Trying to set more TEs than exist!" << llendl;
-                cur_size = getNumTEs();
+                face_mapping[face_bit] = face_bit;
         }
 
-        S32 i;
-        // Copy over image information
-        for (i = 0; i < cur_size; i++)
+        // The new shape may have more faces than the original, but we can't just
+        // add them to the end -- the ordering matters and it may be that we must
+        // insert the new faces in the middle of the list.  When we add a face it
+        // will pick up the texture/color info of one of the old faces an so we
+        // now figure out which old face info gets mapped to each new face, and 
+        // store in the face_mapping lookup table.
+        for (face_bit = 0; face_bit < 9; face_bit++)
         {
-                // This is very BAD!!!!!!
-                if (image_ids != NULL)
+                cur_mask = 0x1 << face_bit;
+                if (!(new_face_mask & cur_mask))
                 {
-                        setTETexture(i,image_ids[i]);
+                        // Face doesn't exist in new map.
+                        face_mapping[face_bit] = -1;
+                        continue;
                 }
-                if (scale_s && scale_t)
+                else if (old_face_mask & cur_mask)
                 {
-                        setTEScale(i, scale_s[i], scale_t[i]);
+                        // Face exists in new and old map.
+                        face_mapping[face_bit] = face_bit;
+                        continue;
                 }
-        }
 
-        if (i < getNumTEs())
-        {
-                cur_size--;
-                for (i=i; i < getNumTEs(); i++)         // the i=i removes a gcc warning
+                // OK, how we've got a mismatch, where we have to fill a new face with one from
+                // the old face.
+                if (cur_mask & (LL_FACE_PATH_BEGIN | LL_FACE_PATH_END | LL_FACE_INNER_SIDE))
                 {
-                        if (image_ids != NULL)
+                        // It's a top/bottom/hollow interior face.
+                        if (old_face_mask & LL_FACE_PATH_END)
                         {
-                                setTETexture(i, image_ids[cur_size]);
+                                face_mapping[face_bit] = 1;
+                                continue;
                         }
-                        if (scale_s && scale_t)
+                        else
                         {
-                                setTEScale(i, scale_s[cur_size], scale_t[cur_size]);
+                                S32 cur_outer_mask = LL_FACE_OUTER_SIDE_0;
+                                for (i = 0; i < 4; i++)
+                                {
+                                        if (old_face_mask & cur_outer_mask)
+                                        {
+                                                face_mapping[face_bit] = 5 + i;
+                                                break;
+                                        }
+                                        cur_outer_mask <<= 1;
+                                }
+                                if (i == 4)
+                                {
+                                        llwarns << "No path end or outer face in volume!" << llendl;
+                                }
+                                continue;
                         }
                 }
+
+                if (cur_mask & (LL_FACE_PROFILE_BEGIN | LL_FACE_PROFILE_END))
+                {
+                        // A cut slice.  Use the hollow interior if we have it.
+                        if (old_face_mask & LL_FACE_INNER_SIDE)
+                        {
+                                face_mapping[face_bit] = 2;
+                                continue;
+                        }
+
+                        // No interior, use the bottom face.
+                        // Could figure out which of the outer faces was nearest, but that would be harder.
+                        if (old_face_mask & LL_FACE_PATH_END)
+                        {
+                                face_mapping[face_bit] = 1;
+                                continue;
+                        }
+                        else
+                        {
+                                S32 cur_outer_mask = LL_FACE_OUTER_SIDE_0;
+                                for (i = 0; i < 4; i++)
+                                {
+                                        if (old_face_mask & cur_outer_mask)
+                                        {
+                                                face_mapping[face_bit] = 5 + i;
+                                                break;
+                                        }
+                                        cur_outer_mask <<= 1;
+                                }
+                                if (i == 4)
+                                {
+                                        llwarns << "No path end or outer face in volume!" << llendl;
+                                }
+                                continue;
+                        }
+                }
+
+                // OK, the face that's missing is an outer face...
+                // Pull from the nearest adjacent outer face (there's always guaranteed to be one...
+                S32 cur_outer = face_bit - 5;
+                S32 min_dist = 5;
+                S32 min_outer_bit = -1;
+                S32 i;
+                for (i = 0; i < 4; i++)
+                {
+                        if (old_face_mask & (LL_FACE_OUTER_SIDE_0 << i))
+                        {
+                                S32 dist = abs(i - cur_outer);
+                                if (dist < min_dist)
+                                {
+                                        min_dist = dist;
+                                        min_outer_bit = i + 5;
+                                }
+                        }
+                }
+                if (-1 == min_outer_bit)
+                {
+                        llinfos << (LLVolume *)mVolumep << llendl;
+                        llwarns << "Bad!  No outer faces, impossible!" << llendl;
+                }
+                face_mapping[face_bit] = min_outer_bit;
+        }
+        
+
+        setNumTEs(mVolumep->getNumFaces());
+        for (face_bit = 0; face_bit < 9; face_bit++)
+        {
+                // For each possible face type on the new shape we check to see if that
+                // face exists and if it does we create a texture entry that is a copy
+                // of one of the originals.  Since the originals might not have a
+                // matching face, we use the face_mapping lookup table to figure out
+                // which face information to copy.
+                cur_mask = 0x1 << face_bit;
+                if (new_face_mask & cur_mask)
+                {
+                        if (-1 == face_mapping[face_bit])
+                        {
+                                llwarns << "No mapping from old face to new face!" << llendl;
+                        }
+
+                        S32 te_num = face_index_from_id(cur_mask, mVolumep->getProfile().mFaces);
+                        setTE(te_num, *(old_tes.getTexture(face_mapping[face_bit])));
+                }
+        }
+        return TRUE;
+}
+
+BOOL LLPrimitive::setMaterial(U8 material)
+{
+        if (material != mMaterial)
+        {
+                mMaterial = material;
+                return TRUE;
+        }
+        else
+        {
+                return FALSE;
         }
 }
 
@@ -1178,6 +1103,7 @@ BOOL LLPrimitive::packTEMessage(LLMessageSystem *mesgsys, int shield) const
                                 else memcpy(&image_ids[face_index*16],LLUUID("4934f1bf-3b1f-cf4f-dbdf-a72550d05bc6").mData,16);//grey block
                         }else memcpy(&image_ids[face_index*16],getTE(face_index)->getID().mData,16);    /* Flawfinder: ignore */ 
 
+
                         // Cast LLColor4 to LLColor4U
                         coloru.setVec( getTE(face_index)->getColor() );
 
@@ -1402,6 +1328,7 @@ S32 LLPrimitive::unpackTEMessage(LLMessageSystem *mesgsys, char *block_name, con
                 color.mV[VALPHA]        = F32(255 - coloru.mV[VALPHA]) / 255.f;
 
                 retval |= setTEColor(i, color);
+
         }
 
         return retval;
@@ -1501,11 +1428,24 @@ S32 LLPrimitive::unpackTEMessage(LLDataPacker &dp)
         return retval;
 }
 
-void LLPrimitive::setTextureList(LLTextureEntry *listp)
+U8      LLPrimitive::getExpectedNumTEs() const
+{
+        U8 expected_face_count = 0;
+        if (mVolumep)
+        {
+                expected_face_count = mVolumep->getNumFaces();
+        }
+        return expected_face_count;
+}
+
+void LLPrimitive::copyTextureList(const LLPrimTextureList& other_list)
+{
+        mTextureList.copy(other_list);
+}
+
+void LLPrimitive::takeTextureList(LLPrimTextureList& other_list)
 {
-        LLTextureEntry* old_texture_list = mTextureList;
-        mTextureList = listp;
-        delete[] old_texture_list;
+        mTextureList.take(other_list);
 }
 
 //============================================================================
@@ -1569,6 +1509,8 @@ BOOL LLNetworkData::isValid(U16 param_type, U32 size)
                 return (size == 16);
         case PARAMS_SCULPT:
                 return (size == 17);
+        case PARAMS_LIGHT_IMAGE:
+                return (size == 28);
         }
         
         return FALSE;
@@ -1901,3 +1843,78 @@ bool LLSculptParams::fromLLSD(LLSD& sd)
         return false;
 }
 
+//============================================================================
+
+LLLightImageParams::LLLightImageParams()
+{
+        mType = PARAMS_LIGHT_IMAGE;
+        mParams.setVec(F_PI*0.5f, 0.f, 0.f);
+}
+
+BOOL LLLightImageParams::pack(LLDataPacker &dp) const
+{
+        dp.packUUID(mLightTexture, "texture");
+        dp.packVector3(mParams, "params");
+
+        return TRUE;
+}
+
+BOOL LLLightImageParams::unpack(LLDataPacker &dp)
+{
+        dp.unpackUUID(mLightTexture, "texture");
+        dp.unpackVector3(mParams, "params");
+        
+        return TRUE;
+}
+
+bool LLLightImageParams::operator==(const LLNetworkData& data) const
+{
+        if (data.mType != PARAMS_LIGHT_IMAGE)
+        {
+                return false;
+        }
+        
+        const LLLightImageParams *param = (const LLLightImageParams*)&data;
+        if ( (param->mLightTexture != mLightTexture) )
+        {
+                return false;
+        }
+
+        if ( (param->mParams != mParams ) )
+        {
+                return false;
+        }
+        
+        return true;
+}
+
+void LLLightImageParams::copy(const LLNetworkData& data)
+{
+        const LLLightImageParams *param = (LLLightImageParams*)&data;
+        mLightTexture = param->mLightTexture;
+        mParams = param->mParams;
+}
+
+
+
+LLSD LLLightImageParams::asLLSD() const
+{
+        LLSD sd;
+        
+        sd["texture"] = mLightTexture;
+        sd["params"] = mParams.getValue();
+                
+        return sd;
+}
+
+bool LLLightImageParams::fromLLSD(LLSD& sd)
+{
+        if (sd.has("texture"))
+        {
+                setLightTexture( sd["texture"] );
+                setParams( LLVector3( sd["params"] ) );
+                return true;
+        } 
+        
+        return false;
+}