1 files changed, 310 insertions, 112 deletions

diff --git a/linden/indra/newview/llvovolume.cpp b/linden/indra/newview/llvovolume.cpp
index 385dbe0..d4c4020 100644
--- a/linden/indra/newview/llvovolume.cpp
+++ b/linden/indra/newview/llvovolume.cpp
@@ -54,6 +54,7 @@
 #include "llspatialpartition.h"
 #include "llhudmanager.h"
 #include "llflexibleobject.h"
+
 #include "llsky.h"
 #include "lltexturefetch.h"
 #include "llviewercamera.h"
@@ -67,6 +68,9 @@
 const S32 MIN_QUIET_FRAMES_COALESCE = 30;
 const F32 FORCE_SIMPLE_RENDER_AREA = 512.f;
 const F32 FORCE_CULL_AREA = 8.f;
+const F32 MAX_LOD_DISTANCE = 24.f;
+const S32 MAX_SCULPT_REZ = 128;
+
 
 BOOL gAnimateTextures = TRUE;
 extern BOOL gHideSelectedObjects;
@@ -91,6 +95,7 @@ LLVOVolume::LLVOVolume(const LLUUID &id, const LLPCode pcode, LLViewerRegion *re
         mNumFaces = 0;
         mLODChanged = FALSE;
         mSculptChanged = FALSE;
+        mSpotLightPriority = 0.f;
 }
 
 LLVOVolume::~LLVOVolume()
@@ -214,7 +219,7 @@ U32 LLVOVolume::processUpdateMessage(LLMessageSystem *mesgsys,
                                 std::string mask;
                                 mask = gDirUtilp->getDirDelimiter() + "*.slc";
                                 gDirUtilp->deleteFilesInDir(gDirUtilp->getExpandedFilename(LL_PATH_CACHE,""), mask);
-//                              llerrs << "Bogus TE data in " << getID() << ", crashing!" << llendl;
+//                              llwarns << "Bogus TE data in " << getID() << ", crashing!" << llendl;
                                 llwarns << "Bogus TE data in " << getID() << llendl;
                         }
                         else if (res2 & (TEM_CHANGE_TEXTURE|TEM_CHANGE_COLOR))
@@ -314,11 +319,6 @@ void LLVOVolume::animateTextures()
                                 te->getScale(&scale_s, &scale_t);
                         }
 
-                        LLVector3 scale(scale_s, scale_t, 1.f);
-                        LLVector3 trans(off_s+0.5f, off_t+0.5f, 0.f);
-                        LLQuaternion quat;
-                        quat.setQuat(rot, 0, 0, -1.f);
-                
                         if (!facep->mTextureMatrix)
                         {
                                 facep->mTextureMatrix = new LLMatrix4();
@@ -326,7 +326,43 @@ void LLVOVolume::animateTextures()
 
                         LLMatrix4& tex_mat = *facep->mTextureMatrix;
                         tex_mat.setIdentity();
-                        tex_mat.translate(LLVector3(-0.5f, -0.5f, 0.f));
+                        LLVector3 trans ;
+
+                        if(facep->isAtlasInUse())
+                        {
+                                //
+                                //if use atlas for animated texture
+                                //apply the following transform to the animation matrix.
+                                //
+
+                                F32 tcoord_xoffset = 0.f ;
+                                F32 tcoord_yoffset = 0.f ;
+                                F32 tcoord_xscale = 1.f ;
+                                F32 tcoord_yscale = 1.f ;                       
+                                if(facep->isAtlasInUse())
+                                {
+                                        const LLVector2* tmp = facep->getTexCoordOffset() ;
+                                        tcoord_xoffset = tmp->mV[0] ; 
+                                        tcoord_yoffset = tmp->mV[1] ;
+
+                                        tmp = facep->getTexCoordScale() ;
+                                        tcoord_xscale = tmp->mV[0] ; 
+                                        tcoord_yscale = tmp->mV[1] ;    
+                                }
+                                trans.set(LLVector3(tcoord_xoffset + tcoord_xscale * (off_s+0.5f), tcoord_yoffset + tcoord_yscale * (off_t+0.5f), 0.f));
+
+                                tex_mat.translate(LLVector3(-(tcoord_xoffset + tcoord_xscale * 0.5f), -(tcoord_yoffset + tcoord_yscale * 0.5f), 0.f));
+                        }
+                        else    //non atlas
+                        {
+                                trans.set(LLVector3(off_s+0.5f, off_t+0.5f, 0.f));                      
+                                tex_mat.translate(LLVector3(-0.5f, -0.5f, 0.f));
+                        }
+
+                        LLVector3 scale(scale_s, scale_t, 1.f);                 
+                        LLQuaternion quat;
+                        quat.setQuat(rot, 0, 0, -1.f);
+                
                         tex_mat.rotate(quat);                           
 
                         LLMatrix4 mat;
@@ -403,30 +439,28 @@ BOOL LLVOVolume::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
         return TRUE;
 }
 
-void LLVOVolume::updateTextures()
+void LLVOVolume::updateTextures(LLAgent &agent) // KL sd
 {
         const F32 TEXTURE_AREA_REFRESH_TIME = 5.f; // seconds
-        if (mTextureUpdateTimer.getElapsedTimeF32() > TEXTURE_AREA_REFRESH_TIME)
+        if (mDrawable.notNull() && mTextureUpdateTimer.getElapsedTimeF32() > TEXTURE_AREA_REFRESH_TIME)
         {
-                updateTextureVirtualSize();             
+                if (mDrawable->isVisible())
+                {
+                        updateTextures();
+                }
         }
 }
 
-void LLVOVolume::updateTextureVirtualSize()
+void LLVOVolume::updateTextures()
 {
         // Update the pixel area of all faces
 
-        if(mDrawable.isNull() || !mDrawable->isVisible())
-        {
-                return ;
-        }
-
         if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SIMPLE))
         {
                 return;
         }
         
-        if (LLViewerImage::sDontLoadVolumeTextures || LLAppViewer::getTextureFetch()->mDebugPause)
+        if (LLViewerImage::sDontLoadVolumeTextures || mDrawable.isNull()) // || !mDrawable->isVisible())
         {
                 return;
         }
@@ -443,15 +477,14 @@ void LLVOVolume::updateTextureVirtualSize()
                 LLFace* face = mDrawable->getFace(i);
                 const LLTextureEntry *te = face->getTextureEntry();
                 LLViewerImage *imagep = face->getTexture();
-                if (!imagep || !te ||                   
+                if (!imagep || !te ||
                         face->mExtents[0] == face->mExtents[1])
                 {
                         continue;
                 }
                 
                 F32 vsize;
-                F32 old_size = face->getVirtualSize();
-
+                
                 if (isHUDAttachment())
                 {
                         F32 area = (F32) LLViewerCamera::getInstance()->getScreenPixelArea();
@@ -461,21 +494,24 @@ void LLVOVolume::updateTextureVirtualSize()
                 }
                 else
                 {
-                        vsize = face->getTextureVirtualSize();
+                        vsize = getTextureVirtualSize(face);
                 }
 
-                mPixelArea = llmax(mPixelArea, face->getPixelArea());           
+                mPixelArea = llmax(mPixelArea, face->getPixelArea());
+
+                F32 old_size = face->getVirtualSize();
 
                 if (face->mTextureMatrix != NULL)
                 {
-                        if ((vsize < MIN_TEX_ANIM_SIZE && old_size > MIN_TEX_ANIM_SIZE) ||
-                                (vsize > MIN_TEX_ANIM_SIZE && old_size < MIN_TEX_ANIM_SIZE))
+                        if (vsize < MIN_TEX_ANIM_SIZE && old_size > MIN_TEX_ANIM_SIZE ||
+                                vsize > MIN_TEX_ANIM_SIZE && old_size < MIN_TEX_ANIM_SIZE)
                         {
                                 gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD, FALSE);
                         }
                 }
                 
                 face->setVirtualSize(vsize);
+        //      imagep->addTextureStats(vsize);
                 if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
                 {
                         if (vsize < min_vsize) min_vsize = vsize;
@@ -503,46 +539,46 @@ void LLVOVolume::updateTextureVirtualSize()
                 mSculptTexture = gImageList.getImage(id);
                 if (mSculptTexture.notNull())
                 {
+                        S32 lod = llmin(mLOD, 3);
+                        F32 lodf = ((F32)(lod + 1.0f)/4.f); 
+                        F32 tex_size = lodf * MAX_SCULPT_REZ;
+                        mSculptTexture->addTextureStats(2.f * tex_size * tex_size);
                         mSculptTexture->setBoostLevel(llmax((S32)mSculptTexture->getBoostLevel(),
                                                                                                 (S32)LLViewerImageBoostLevel::BOOST_SCULPTED));
-                        mSculptTexture->setForSculpt() ;
-                        
-                        if(!mSculptTexture->isCachedRawImageReady())
-                        {
-                                S32 lod = llmin(mLOD, 3);
-                                F32 lodf = ((F32)(lod + 1.0f)/4.f);
-                                F32 tex_size = lodf * LLViewerImage::sMaxSculptRez ;
-                                mSculptTexture->addTextureStats(2.f * tex_size * tex_size, FALSE);
-                        
-                                //if the sculpty very close to the view point, load first
-                                {                               
-                                        LLVector3 lookAt = getPositionAgent() - LLViewerCamera::getInstance()->getOrigin();
-                                        F32 dist = lookAt.normVec() ;
-                                        F32 cos_angle_to_view_dir = lookAt * LLViewerCamera::getInstance()->getXAxis() ;                                
-                                        mSculptTexture->setAdditionalDecodePriority(0.8f * LLFace::calcImportanceToCamera(cos_angle_to_view_dir, dist)) ;
-                                }
-                        }
-        
-                        S32 texture_discard = mSculptTexture->getCachedRawImageLevel(); //try to match the texture
-                        S32 current_discard = mSculptLevel;
+                }
 
-                        if (texture_discard >= 0 && //texture has some data available
-                                (texture_discard < current_discard || //texture has more data than last rebuild
-                                current_discard < 0)) //no previous rebuild
-                        {
-                                gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, FALSE);
-                                mSculptChanged = TRUE;
-                        }
+                S32 texture_discard = mSculptTexture->getDiscardLevel(); //try to match the texture
+                S32 current_discard = mSculptLevel;
 
-                        if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SCULPTED))
+                if (texture_discard >= 0 && //texture has some data available
+                        (texture_discard < current_discard || //texture has more data than last rebuild
+                        current_discard < 0)) //no previous rebuild
+                {
+                        gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, FALSE);
+                        mSculptChanged = TRUE;
+                }
+
+                if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SCULPTED))
                         {
                                 setDebugText(llformat("T%d C%d V%d\n%dx%d",
-                                                                                  texture_discard, current_discard, getVolume()->getSculptLevel(),
-                                                                                  mSculptTexture->getHeight(), mSculptTexture->getWidth()));
+                                                                          texture_discard, current_discard, getVolume()->getSculptLevel(),
+                                                                          mSculptTexture->getHeight(), mSculptTexture->getWidth()));
                         }
-                }
         }
 
+        if (getLightTextureID().notNull())
+        {
+                LLLightImageParams* params = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+                LLUUID id = params->getLightTexture();
+                mLightTexture = gImageList.getImage(id);
+                if (mLightTexture.notNull())
+                {
+                        F32 rad = getLightRadius();
+                        mLightTexture->addTextureStats(gPipeline.calcPixelArea(getPositionAgent(), 
+                                                                                                                                        LLVector3(rad,rad,rad),
+                                                                                                                                        *LLViewerCamera::getInstance()));
+                }       
+        }
 
         if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
         {
@@ -563,6 +599,36 @@ void LLVOVolume::updateTextureVirtualSize()
         }
 }
 
+F32 LLVOVolume::getTextureVirtualSize(LLFace* face)
+{
+        //get area of circle around face
+        LLVector3 center = face->getPositionAgent();
+        LLVector3 size = (face->mExtents[1] - face->mExtents[0]) * 0.5f;
+        
+        F32 face_area = LLPipeline::calcPixelArea(center, size, *LLViewerCamera::getInstance());
+
+        face->setPixelArea(face_area);
+
+        if (face_area <= 0)
+        {
+                return 0.f;
+        }
+
+        //get area of circle in texture space
+        LLVector2 tdim = face->mTexExtents[1] - face->mTexExtents[0];
+        F32 texel_area = (tdim * 0.5f).lengthSquared()*3.14159f;
+        if (texel_area <= 0)
+        {
+                // Probably animated, use default
+                texel_area = 1.f;
+        }
+
+        //apply texel area to face area to get accurate ratio
+        face_area /= llclamp(texel_area, 1.f/64.f, 16.f);
+
+        return face_area;
+}
+
 BOOL LLVOVolume::isActive() const
 {
         return !mStatic || mTextureAnimp || (mVolumeImpl && mVolumeImpl->isActive());
@@ -699,21 +765,31 @@ BOOL LLVOVolume::setVolume(const LLVolumeParams &volume_params, const S32 detail
 
 // sculpt replaces generate() for sculpted surfaces
 void LLVOVolume::sculpt()
-{       
+{
+        U16 sculpt_height = 0;
+        U16 sculpt_width = 0;
+        S8 sculpt_components = 0;
+        const U8* sculpt_data = NULL;
+
         if (mSculptTexture.notNull())
-        {                               
-                U16 sculpt_height = 0;
-                U16 sculpt_width = 0;
-                S8 sculpt_components = 0;
-                const U8* sculpt_data = NULL;
-        
-                S32 discard_level = mSculptTexture->getCachedRawImageLevel() ;
-                LLImageRaw* raw_image = mSculptTexture->getCachedRawImage() ;
+        {
+                S32 discard_level;
+                S32 desired_discard = 0; // lower discard levels have MUCH less resolution 
+
+                discard_level = desired_discard;
                 
                 S32 max_discard = mSculptTexture->getMaxDiscardLevel();
                 if (discard_level > max_discard)
                         discard_level = max_discard;    // clamp to the best we can do
 
+                S32 best_discard = mSculptTexture->getDiscardLevel();
+                if (discard_level < best_discard)
+                        discard_level = best_discard;   // clamp to what we have
+
+                if (best_discard == -1)
+                        discard_level = -1;  // and if we have nothing, set to nothing
+
+                
                 S32 current_discard = getVolume()->getSculptLevel();
                 if(current_discard < -2)
                 {
@@ -735,17 +811,28 @@ void LLVOVolume::sculpt()
                 if (current_discard == discard_level)  // no work to do here
                         return;
                 
-                if(!raw_image)
+                LLPointer<LLImageRaw> raw_image = new LLImageRaw();
+                BOOL is_valid = mSculptTexture->readBackRaw(discard_level, raw_image, FALSE);
+
+                sculpt_height = raw_image->getHeight();
+                sculpt_width = raw_image->getWidth();
+                sculpt_components = raw_image->getComponents();         
+
+                if(is_valid)
+                {
+                        is_valid = mSculptTexture->isValidForSculpt(discard_level, sculpt_width, sculpt_height, sculpt_components) ;
+                }
+                if(!is_valid)
                 {
                         sculpt_width = 0;
                         sculpt_height = 0;
                         sculpt_data = NULL ;
                 }
                 else
-                {                                       
-                        sculpt_height = raw_image->getHeight();
-                        sculpt_width = raw_image->getWidth();
-                        sculpt_components = raw_image->getComponents();         
+                {
+                        if (raw_image->getDataSize() < sculpt_height * sculpt_width * sculpt_components)
+                                llwarns << "Sculpt: image data size = " << raw_image->getDataSize()
+                                           << " < " << sculpt_height << " x " << sculpt_width << " x " <<sculpt_components << llendl;
                                            
                         sculpt_data = raw_image->getData();
                 }
@@ -777,7 +864,7 @@ BOOL LLVOVolume::calcLOD()
         }
 
         //update face texture sizes on lod calculation
-        updateTextureVirtualSize();
+        // updateTextureVirtualSize();
 
         S32 cur_detail = 0;
         
@@ -1231,28 +1318,15 @@ S32 LLVOVolume::setTEColor(const U8 te, const LLColor3& color)
 
 S32 LLVOVolume::setTEColor(const U8 te, const LLColor4& color)
 {
-        S32 retval = 0;
-        const LLTextureEntry *tep = getTE(te);
-        if (!tep)
+        S32 res = LLViewerObject::setTEColor(te, color);
+        if (res && mDrawable.notNull())
         {
-                llwarns << "No texture entry for te " << (S32)te << ", object " << mID << llendl;
+                //gPipeline.markTextured(mDrawable);
+                mDrawable->setState(LLDrawable::REBUILD_COLOR);
+                dirtyMesh();
+                //mFaceMappingChanged = TRUE;
         }
-        else if (color != tep->getColor())
-        {
-                if (color.mV[3] != tep->getColor().mV[3])
-                {
-                        gPipeline.markTextured(mDrawable);
-                }
-                retval = LLPrimitive::setTEColor(te, color);
-                if (mDrawable.notNull() && retval)
-                {
-                        // These should only happen on updates which are not the initial update.
-                        mDrawable->setState(LLDrawable::REBUILD_COLOR);
-                        dirtyMesh();
-                }
-        }
-
-        return  retval;
+        return  res;
 }
 
 S32 LLVOVolume::setTEBumpmap(const U8 te, const U8 bumpmap)
@@ -1318,7 +1392,7 @@ S32 LLVOVolume::setTEBumpShinyFullbright(const U8 te, const U8 bump)
                 gPipeline.markTextured(mDrawable);
                 mFaceMappingChanged = TRUE;
         }
-        return res;
+        return  res;
 }
 
 S32 LLVOVolume::setTEMediaFlags(const U8 te, const U8 media_flags)
@@ -1387,6 +1461,40 @@ void LLVOVolume::updateTEData()
 
 //----------------------------------------------------------------------------
 
+void LLVOVolume::setLightTextureID(LLUUID id)
+{
+        if (id.notNull())
+        {
+                if (!hasLightTexture())
+                {
+                        setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE, TRUE, true);
+                }
+                LLLightImageParams* param_block = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+                if (param_block && param_block->getLightTexture() != id)
+                {
+                        param_block->setLightTexture(id);
+                        parameterChanged(LLNetworkData::PARAMS_LIGHT_IMAGE, true);
+                }
+        }
+        else
+        {
+                if (hasLightTexture())
+                {
+                        setParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE, FALSE, true);
+                }
+        }               
+}
+
+void LLVOVolume::setSpotLightParams(LLVector3 params)
+{
+        LLLightImageParams* param_block = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+        if (param_block && param_block->getParams() != params)
+        {
+                param_block->setParams(params);
+                parameterChanged(LLNetworkData::PARAMS_LIGHT_IMAGE, true);
+        }
+}
+                
 void LLVOVolume::setIsLight(BOOL is_light)
 {
         if (is_light != getIsLight())
@@ -1513,6 +1621,77 @@ LLColor3 LLVOVolume::getLightColor() const
         }
 }
 
+LLUUID LLVOVolume::getLightTextureID() const
+{
+        const LLLightImageParams *param_block = (const LLLightImageParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+        if (param_block)
+        {
+                return param_block->getLightTexture();
+        }
+        
+        return LLUUID::null;
+}
+
+
+LLVector3 LLVOVolume::getSpotLightParams() const
+{
+        const LLLightImageParams *param_block = (const LLLightImageParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
+        if (param_block)
+        {
+                return param_block->getParams();
+        }
+        
+        return LLVector3();
+}
+
+F32 LLVOVolume::getSpotLightPriority() const
+{
+        return mSpotLightPriority;
+}
+
+void LLVOVolume::updateSpotLightPriority()
+{
+        LLVector3 pos = mDrawable->getPositionAgent();
+        LLVector3 at(0,0,-1);
+        at *= getRenderRotation();
+
+        F32 r = getLightRadius()*0.5f;
+
+        pos += at * r;
+
+        at = LLViewerCamera::getInstance()->getAtAxis();
+
+        pos -= at * r;
+        
+        mSpotLightPriority = gPipeline.calcPixelArea(pos, LLVector3(r,r,r), *LLViewerCamera::getInstance());
+ // KL needed for S19?
+        if (mLightTexture.notNull())
+        {
+                mLightTexture->addTextureStats(mSpotLightPriority);
+                mLightTexture->setBoostLevel(LLViewerImageBoostLevel::BOOST_CLOUDS);
+        }
+}
+
+
+LLViewerImage* LLVOVolume::getLightTexture()
+{
+        LLUUID id = getLightTextureID();
+
+        if (id.notNull())
+        {
+                if (mLightTexture.isNull() || id != mLightTexture->getID())
+                {
+                        mLightTexture = gImageList.getImage(id);
+                }
+        }
+        else
+        {
+                mLightTexture = NULL;
+        }
+
+        return mLightTexture;
+}
+
 F32 LLVOVolume::getLightIntensity() const
 {
         const LLLightParams *param_block = (const LLLightParams *)getParameterEntry(LLNetworkData::PARAMS_LIGHT);
@@ -1604,6 +1783,16 @@ BOOL LLVOVolume::isSculpted() const
         return FALSE;
 }
 
+BOOL LLVOVolume::hasLightTexture() const
+{
+        if (getParameterEntryInUse(LLNetworkData::PARAMS_LIGHT_IMAGE))
+        {
+                return TRUE;
+        }
+
+        return FALSE;
+}
+
 BOOL LLVOVolume::isVolumeGlobal() const
 {
         if (mVolumeImpl)
@@ -2056,9 +2245,9 @@ U32 LLVOVolume::getPartitionType() const
 }
 
 LLVolumePartition::LLVolumePartition()
-: LLSpatialPartition(LLVOVolume::VERTEX_DATA_MASK, FALSE)
+: LLSpatialPartition(LLVOVolume::VERTEX_DATA_MASK, TRUE, GL_DYNAMIC_DRAW_ARB) // KL
 {
-        mLODPeriod = 16;
+        mLODPeriod = 32; // KL 32 in SD
         mDepthMask = FALSE;
         mDrawableType = LLPipeline::RENDER_TYPE_VOLUME;
         mPartitionType = LLViewerRegion::PARTITION_VOLUME;
@@ -2067,10 +2256,10 @@ LLVolumePartition::LLVolumePartition()
 }
 
 LLVolumeBridge::LLVolumeBridge(LLDrawable* drawablep)
-: LLSpatialBridge(drawablep, LLVOVolume::VERTEX_DATA_MASK)
+: LLSpatialBridge(drawablep, TRUE, LLVOVolume::VERTEX_DATA_MASK) // KL SD
 {
         mDepthMask = FALSE;
-        mLODPeriod = 16;
+        mLODPeriod = 32;  // KL 32 in SD
         mDrawableType = LLPipeline::RENDER_TYPE_VOLUME;
         mPartitionType = LLViewerRegion::PARTITION_BRIDGE;
         
@@ -2125,7 +2314,7 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep,
 
         U8 bump = (type == LLRenderPass::PASS_BUMP ? facep->getTextureEntry()->getBumpmap() : 0);
         
-        LLViewerImage* tex = facep->getTexture();
+     LLImageGL* tex = facep->getGLTexture(); // LLViewerImage* tex = facep->getTexture(); // KL SD
 
         U8 glow = 0;
                 
@@ -2136,7 +2325,7 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep,
 
         if (facep->mVertexBuffer.isNull())
         {
-                llerrs << "WTF?" << llendl;
+                llwarns << "WTF?" << llendl;
         }
 
         if (idx >= 0 && 
@@ -2167,6 +2356,7 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep,
                 U32 offset = facep->getIndicesStart();
                 U32 count = facep->getIndicesCount();
                 LLPointer<LLDrawInfo> draw_info = new LLDrawInfo(start,end,count,offset,tex, 
+                        (LLImageGL*)facep->getTexture() == tex ? facep->getTexture() : NULL,
                         facep->mVertexBuffer, fullbright, bump); 
                 draw_info->mGroup = group;
                 draw_info->mVSize = facep->getVirtualSize();
@@ -2254,9 +2444,11 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
 
                 LLVOVolume* vobj = drawablep->getVOVolume();
                 llassert_always(vobj);
-                vobj->updateTextureVirtualSize();
+                vobj->updateTextures();
                 vobj->preRebuild();
 
+                drawablep->clearState(LLDrawable::HAS_ALPHA); // KL SD
+
                 //for each face
                 for (S32 i = 0; i < drawablep->getNumFaces(); i++)
                 {
@@ -2325,6 +2517,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
                                         }
                                         else
                                         {
+                                                drawablep->setState(LLDrawable::HAS_ALPHA); // KL SD
                                                 alpha_faces.push_back(facep);
                                         }
                                 }
@@ -2348,7 +2541,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
                                                 }
                                                 else 
                                                 { //doesn't need normal
-                                                        facep->setState(LLFace::FULLBRIGHT);
+                                                        //facep->setState(LLFace::FULLBRIGHT);
                                                         fullbright_faces.push_back(facep);
                                                 }
                                         }
@@ -2358,14 +2551,14 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
                                                 { //needs normal + binormal
                                                         bump_faces.push_back(facep);
                                                 }
-                                                else if ((te->getShiny() && LLPipeline::sRenderBump) ||
+                                                else if (te->getShiny() && LLPipeline::sRenderBump ||
                                                         !te->getFullbright())
                                                 { //needs normal
                                                         simple_faces.push_back(facep);
                                                 }
                                                 else 
                                                 { //doesn't need normal
-                                                        facep->setState(LLFace::FULLBRIGHT);
+                                                //      facep->setState(LLFace::FULLBRIGHT);
                                                         fullbright_faces.push_back(facep);
                                                 }
                                         }
@@ -2413,7 +2606,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
 
         if (LLPipeline::sDelayVBUpdate)
         {
-                group->setState(LLSpatialGroup::MESH_DIRTY);
+                group->setState(LLSpatialGroup::MESH_DIRTY | LLSpatialGroup::NEW_DRAWINFO); // KL SD
         }
 
         mFaceList.clear();
@@ -2421,7 +2614,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
 
 void LLVolumeGeometryManager::rebuildMesh(LLSpatialGroup* group)
 {
-        if (group->isState(LLSpatialGroup::MESH_DIRTY))
+        if (group->isState(LLSpatialGroup::MESH_DIRTY) && !group->isState(LLSpatialGroup::GEOM_DIRTY)) // KL SD
         {
                 S32 num_mapped_veretx_buffer = LLVertexBuffer::sMappedCount ;
 
@@ -2499,7 +2692,7 @@ void LLVolumeGeometryManager::rebuildMesh(LLSpatialGroup* group)
                         } 
                 }
 
-                group->clearState(LLSpatialGroup::MESH_DIRTY);
+                group->clearState(LLSpatialGroup::MESH_DIRTY | LLSpatialGroup::NEW_DRAWINFO); // KL SD
         }
 }
 
@@ -2524,7 +2717,7 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::
         
         LLSpatialGroup::buffer_map_t buffer_map;
 
-        LLViewerImage* last_tex = NULL;
+    LLImageGL* last_tex = NULL;//       LLViewerImage* last_tex = NULL;  // KL SD
         S32 buffer_index = 0;
 
         if (distance_sort)
@@ -2536,7 +2729,7 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::
         {
                 //pull off next face
                 LLFace* facep = *face_iter;
-                LLViewerImage* tex = facep->getTexture();
+                LLImageGL* tex = facep->getGLTexture(); // LLViewerImage* tex = facep->getTexture();  // KL SD
 
                 if (distance_sort)
                 {
@@ -2561,7 +2754,7 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::
                 ++i;
                 
                 while (i != faces.end() && 
-                        (LLPipeline::sTextureBindTest || (distance_sort || (*i)->getTexture() == tex)))
+                        (LLPipeline::sTextureBindTest || (distance_sort || (*i)->getGLTexture() == tex))) // KL SD getTexture
                 {
                         facep = *i;
                         
@@ -2644,6 +2837,11 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::
 
                         BOOL force_simple = facep->mPixelArea < FORCE_SIMPLE_RENDER_AREA;
                         BOOL fullbright = facep->isState(LLFace::FULLBRIGHT);
+                        if ((mask & LLVertexBuffer::MAP_NORMAL) == 0) // KL SD
+                        { //paranoia check to make sure GL doesn't try to read non-existant normals
+                                fullbright = TRUE;
+                        }
+
                         const LLTextureEntry* te = facep->getTextureEntry();
 
                         BOOL is_alpha = facep->getPoolType() == LLDrawPool::POOL_ALPHA ? TRUE : FALSE;
@@ -2695,7 +2893,7 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::
                                         }
                                         else
                                         {
-                                                llassert(mask & LLVertexBuffer::MAP_NORMAL);
+                                        //      llassert(mask & LLVertexBuffer::MAP_NORMAL);
                                                 registerFace(group, facep, LLRenderPass::PASS_SIMPLE);
                                         }
                                 }
@@ -2726,7 +2924,7 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::
                                         }
                                         else
                                         {
-                                                llassert(mask & LLVertexBuffer::MAP_NORMAL);
+                                        //      llassert(mask & LLVertexBuffer::MAP_NORMAL);
                                                 registerFace(group, facep, LLRenderPass::PASS_SIMPLE);
                                         }
                                 }
@@ -2739,8 +2937,8 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std::
                         
                         if (!is_alpha && !LLPipeline::sRenderDeferred)
                         {
-                                llassert((mask & LLVertexBuffer::MAP_NORMAL) || fullbright);
-                                facep->setPoolType((fullbright) ? LLDrawPool::POOL_FULLBRIGHT : LLDrawPool::POOL_SIMPLE);
+                        //      llassert((mask & LLVertexBuffer::MAP_NORMAL) || fullbright);
+                facep->setPoolType(LLDrawPool::POOL_SIMPLE);    //      facep->setPoolType((fullbright) ? LLDrawPool::POOL_FULLBRIGHT : LLDrawPool::POOL_SIMPLE);
                                 
                                 if (!force_simple && te->getBumpmap())
                                 {
@@ -2819,7 +3017,7 @@ LLHUDPartition::LLHUDPartition()
         mPartitionType = LLViewerRegion::PARTITION_HUD;
         mDrawableType = LLPipeline::RENDER_TYPE_HUD;
         mSlopRatio = 0.f;
-        mLODPeriod = 1;
+        mLODPeriod = 32;  // KL 32 in SD
 }
 
 void LLHUDPartition::shift(const LLVector3 &offset)