Merge branch 'DRTVWR-559' of bitbucket.org:lindenlab/viewer into DRTVWR-559

8 files changed, 250 insertions, 116 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbropaqueF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbropaqueF.glsl
index 1b5a1c82a2..5538b445fa 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/pbropaqueF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/pbropaqueF.glsl
@@ -32,10 +32,18 @@
 
 uniform sampler2D diffuseMap;  //always in sRGB space
 
+uniform float metallicFactor;
+uniform float roughnessFactor;
+uniform vec3 emissiveColor;
+
 #ifdef HAS_NORMAL_MAP
     uniform sampler2D bumpMap;
 #endif
 
+#ifdef HAS_EMISSIVE_MAP
+    uniform sampler2D emissiveMap;
+#endif
+
 #ifdef HAS_SPECULAR_MAP
     uniform sampler2D specularMap; // Packed: Occlusion, Metal, Roughness
 #endif
@@ -76,8 +84,6 @@ void main()
 // else
     vec3 col = vertex_color.rgb * texture2D(diffuseMap, vary_texcoord0.xy).rgb;
 
-    vec3 emissive = vec3(0);
-
 #ifdef HAS_NORMAL_MAP
     vec4 norm = texture2D(bumpMap, vary_texcoord1.xy);
     norm.xyz = norm.xyz * 2 - 1;
@@ -105,6 +111,14 @@ void main()
     vec3 spec = vec3(1,1,1);
 #endif
     
+    spec.g *= roughnessFactor;
+    spec.b *= metallicFactor;
+
+    vec3 emissive = emissiveColor;
+#ifdef HAS_EMISSIVE_MAP
+    emissive *= texture2D(emissiveMap, vary_texcoord0.xy).rgb;
+#endif
+
 
 #if DEBUG_BASIC
     col.rgb = vec3( 1, 0, 1 );
diff --git a/indra/newview/app_settings/shaders/class2/deferred/reflectionProbeF.glsl b/indra/newview/app_settings/shaders/class2/deferred/reflectionProbeF.glsl
index 8c1323ba1a..ab5badf538 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/reflectionProbeF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/reflectionProbeF.glsl
@@ -473,4 +473,5 @@ void applyGlossEnv(inout vec3 color, vec3 glossenv, vec4 spec, vec3 pos, vec3 no
     fresnel = min(fresnel+envIntensity, 1.0);
     reflected_color *= (envIntensity*fresnel)*brighten(spec.rgb);
     color = mix(color.rgb, reflected_color, envIntensity);
- }
\ No newline at end of file
+ }
+
diff --git a/indra/newview/lldrawpoolpbropaque.cpp b/indra/newview/lldrawpoolpbropaque.cpp
index 86b3ac0d46..0c257a33a5 100644
--- a/indra/newview/lldrawpoolpbropaque.cpp
+++ b/indra/newview/lldrawpoolpbropaque.cpp
@@ -99,30 +99,48 @@ void LLDrawPoolPBROpaque::renderDeferred(S32 pass)
     {
         LLDrawInfo& params = **i;
 
-//gGL.getTexUnit(0)->activate();
+        //gGL.getTexUnit(0)->activate();
 
-        if (mShaderLevel > 1)
+        if (params.mTexture.notNull())
         {
-            if (params.mTexture.notNull())
-            {
-                gGL.getTexUnit(0)->bindFast(params.mTexture); // diffuse
-            }
+            gGL.getTexUnit(0)->bindFast(params.mTexture); // diffuse
+        }
+        else
+        {
+            gGL.getTexUnit(0)->bindFast(LLViewerFetchedTexture::sWhiteImagep);
         }
 
         if (params.mNormalMap)
         {
             gDeferredPBROpaqueProgram.bindTexture(LLShaderMgr::BUMP_MAP, params.mNormalMap);
         }
+        else
+        {
+            // TODO: bind default normal map (???? WTF is it ???)
+        }
 
         if (params.mSpecularMap)
         {
             gDeferredPBROpaqueProgram.bindTexture(LLShaderMgr::SPECULAR_MAP, params.mSpecularMap); // Packed Occlusion Roughness Metal
         }
+        else
+        {
+            gDeferredPBROpaqueProgram.bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
+        }
+
+        if (params.mEmissiveMap)
+        {
+            gDeferredPBROpaqueProgram.bindTexture(LLShaderMgr::EMISSIVE_MAP, params.mEmissiveMap); // Packed Occlusion Roughness Metal
+        }
+        else
+        {
+            gDeferredPBROpaqueProgram.bindTexture(LLShaderMgr::EMISSIVE_MAP, LLViewerFetchedTexture::sWhiteImagep);
+        }
+        
+        gDeferredPBROpaqueProgram.uniform1f(LLShaderMgr::ROUGHNESS_FACTOR, params.mGLTFMaterial->mRoughnessFactor);
+        gDeferredPBROpaqueProgram.uniform1f(LLShaderMgr::METALLIC_FACTOR, params.mGLTFMaterial->mMetallicFactor);
+        gDeferredPBROpaqueProgram.uniform3fv(LLShaderMgr::EMISSIVE_COLOR, 1, params.mGLTFMaterial->mEmissiveColor.mV);
 
-        // Similar to LLDrawPooLMaterials::pushMaterialsBatch(params, getVertexDataMask(), false);
         LLRenderPass::pushBatch(params, getVertexDataMask(), FALSE, FALSE);
-        //LLRenderPass::applyModelMatrix(params);
-        //params.mVertexBuffer->setBufferFast(getVertexDataMask());
-        //params.mVertexBuffer->drawRangeFast(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
     }
 }
diff --git a/indra/newview/llface.cpp b/indra/newview/llface.cpp
index d1ea5409ed..071e770811 100644
--- a/indra/newview/llface.cpp
+++ b/indra/newview/llface.cpp
@@ -1384,6 +1384,11 @@ BOOL LLFace::getGeometryVolume(const LLVolume& volume,
 
 	LLColor4U color = tep->getColor();
 
+    if (tep->getGLTFMaterial())
+    {
+        color = tep->getGLTFMaterial()->mAlbedoColor;
+    }
+
 	if (rebuild_color)
 	{ //decide if shiny goes in alpha channel of color
 		if (tep && 
diff --git a/indra/newview/llmaterialeditor.cpp b/indra/newview/llmaterialeditor.cpp
index 86f629db95..3c9d722b87 100644
--- a/indra/newview/llmaterialeditor.cpp
+++ b/indra/newview/llmaterialeditor.cpp
@@ -459,28 +459,115 @@ const tinygltf::Image* get_image_from_texture_index(const tinygltf::Model& model
     return nullptr;
 }
 
-static LLViewerFetchedTexture* get_texture(const std::string& folder, const tinygltf::Model& model, S32 texture_index)
+static LLImageRaw* get_texture(const std::string& folder, const tinygltf::Model& model, S32 texture_index)
 {
-    LLViewerFetchedTexture* ret = nullptr;
-
     const tinygltf::Image* image = get_image_from_texture_index(model, texture_index);
 
+    LLImageRaw* rawImage = nullptr;
+
     if (image != nullptr && 
         image->bits == 8 &&
         !image->image.empty() &&
         image->component <= 4)
     {
-        LLPointer<LLImageRaw> rawImage = new LLImageRaw(&image->image[0], image->width, image->height, image->component);
+        rawImage = new LLImageRaw(&image->image[0], image->width, image->height, image->component);
         rawImage->verticalFlip();
-        
-        ret = LLViewerTextureManager::getFetchedTexture(rawImage, FTType::FTT_LOCAL_FILE, true);
+    }
 
-        ret->forceToSaveRawImage(0, F32_MAX);
+    return rawImage;
+}
+
+static void strip_alpha_channel(LLPointer<LLImageRaw>& img)
+{
+    if (img->getComponents() == 4)
+    {
+        LLImageRaw* tmp = new LLImageRaw(img->getWidth(), img->getHeight(), 3);
+        tmp->copyUnscaled4onto3(img);
+        img = tmp;
     }
+}
+
+// copy red channel from src_img to dst_img
+// PRECONDITIONS:
+// dst_img must be 3 component
+// src_img and dst_image must have the same dimensions
+static void copy_red_channel(LLPointer<LLImageRaw>& src_img, LLPointer<LLImageRaw>& dst_img)
+{
+    llassert(src_img->getWidth() == dst_img->getWidth() && src_img->getHeight() == dst_img->getHeight());
+    llassert(dst_img->getComponents() == 3);
 
-    // TODO: provide helpful error message if image fails to load
+    U32 pixel_count = dst_img->getWidth() * dst_img->getHeight();
+    U8* src = src_img->getData();
+    U8* dst = dst_img->getData();
+    S8 src_components = src_img->getComponents();
 
-    return ret;
+    for (U32 i = 0; i < pixel_count; ++i)
+    {
+        dst[i * 3] = src[i * src_components];
+    }
+}
+
+static void pack_textures(tinygltf::Model& model, tinygltf::Material& material, 
+    LLPointer<LLImageRaw>& albedo_img,
+    LLPointer<LLImageRaw>& normal_img,
+    LLPointer<LLImageRaw>& mr_img,
+    LLPointer<LLImageRaw>& emissive_img,
+    LLPointer<LLImageRaw>& occlusion_img,
+    LLPointer<LLViewerFetchedTexture>& albedo_tex,
+    LLPointer<LLViewerFetchedTexture>& normal_tex,
+    LLPointer<LLViewerFetchedTexture>& mr_tex,
+    LLPointer<LLViewerFetchedTexture>& emissive_tex)
+{
+    // TODO: downscale if needed
+    if (albedo_img)
+    {
+        albedo_tex = LLViewerTextureManager::getFetchedTexture(albedo_img, FTType::FTT_LOCAL_FILE, true);
+    }
+
+    if (normal_img)
+    {
+        strip_alpha_channel(normal_img);
+        normal_tex = LLViewerTextureManager::getFetchedTexture(normal_img, FTType::FTT_LOCAL_FILE, true);
+    }
+
+    if (mr_img)
+    {
+        strip_alpha_channel(mr_img);
+
+        if (occlusion_img && material.pbrMetallicRoughness.metallicRoughnessTexture.index != material.occlusionTexture.index)
+        {
+            // occlusion is a distinct texture from pbrMetallicRoughness
+            // pack into mr red channel
+            int occlusion_idx = material.occlusionTexture.index;
+            int mr_idx = material.pbrMetallicRoughness.metallicRoughnessTexture.index;
+            if (occlusion_idx != mr_idx)
+            {
+                //scale occlusion image to match resolution of mr image
+                occlusion_img->scale(mr_img->getWidth(), mr_img->getHeight());
+             
+                copy_red_channel(occlusion_img, mr_img);
+            }
+        }
+    }
+    else if (occlusion_img)
+    {
+        //no mr but occlusion exists, make a white mr_img and copy occlusion red channel over
+        mr_img = new LLImageRaw(occlusion_img->getWidth(), occlusion_img->getHeight(), 3);
+        mr_img->clear(255, 255, 255);
+        copy_red_channel(occlusion_img, mr_img);
+
+    }
+
+    if (mr_img)
+    {
+        mr_tex = LLViewerTextureManager::getFetchedTexture(mr_img, FTType::FTT_LOCAL_FILE, true);
+    }
+
+    if (emissive_img)
+    {
+        strip_alpha_channel(emissive_img);
+        emissive_tex = LLViewerTextureManager::getFetchedTexture(emissive_img, FTType::FTT_LOCAL_FILE, true);
+    }
 }
 
 static LLColor4 get_color(const std::vector<double>& in)
@@ -545,41 +632,56 @@ void LLMaterialFilePicker::loadMaterial(const std::string& filename)
     model_out.materials.resize(1);
 
     // get albedo texture
-    LLPointer<LLViewerFetchedTexture> albedo_tex = get_texture(folder, model_in, material_in.pbrMetallicRoughness.baseColorTexture.index);
+    LLPointer<LLImageRaw> albedo_img = get_texture(folder, model_in, material_in.pbrMetallicRoughness.baseColorTexture.index);
+    // get normal map
+    LLPointer<LLImageRaw> normal_img = get_texture(folder, model_in, material_in.normalTexture.index);
+    // get metallic-roughness texture
+    LLPointer<LLImageRaw> mr_img = get_texture(folder, model_in, material_in.pbrMetallicRoughness.metallicRoughnessTexture.index);
+    // get emissive texture
+    LLPointer<LLImageRaw> emissive_img = get_texture(folder, model_in, material_in.emissiveTexture.index);
+    // get occlusion map if needed
+    LLPointer<LLImageRaw> occlusion_img;
+    if (material_in.occlusionTexture.index != material_in.pbrMetallicRoughness.metallicRoughnessTexture.index)
+    {
+        occlusion_img = get_texture(folder, model_in, material_in.occlusionTexture.index);
+    }
 
+    LLPointer<LLViewerFetchedTexture> albedo_tex;
+    LLPointer<LLViewerFetchedTexture> normal_tex;
+    LLPointer<LLViewerFetchedTexture> mr_tex;
+    LLPointer<LLViewerFetchedTexture> emissive_tex;
+    
+    pack_textures(model_in, material_in, albedo_img, normal_img, mr_img, emissive_img, occlusion_img,
+        albedo_tex, normal_tex, mr_tex, emissive_tex);
+    
     LLUUID albedo_id;
     if (albedo_tex != nullptr)
     {
+        albedo_tex->forceToSaveRawImage(0, F32_MAX);        
         albedo_id = albedo_tex->getID();
     }
 
-    // get metallic-roughness texture
-    LLPointer<LLViewerFetchedTexture> mr_tex = get_texture(folder, model_in, material_in.pbrMetallicRoughness.metallicRoughnessTexture.index);
+    LLUUID normal_id;
+    if (normal_tex != nullptr)
+    {
+        normal_tex->forceToSaveRawImage(0, F32_MAX);
+        normal_id = normal_tex->getID();
+    }
 
     LLUUID mr_id;
     if (mr_tex != nullptr)
     {
+        mr_tex->forceToSaveRawImage(0, F32_MAX);
         mr_id = mr_tex->getID();
     }
 
-    // get emissive texture
-    LLPointer<LLViewerFetchedTexture> emissive_tex = get_texture(folder, model_in, material_in.emissiveTexture.index);
-
     LLUUID emissive_id;
     if (emissive_tex != nullptr)
     {
+        emissive_tex->forceToSaveRawImage(0, F32_MAX);
         emissive_id = emissive_tex->getID();
     }
 
-    // get normal map
-    LLPointer<LLViewerFetchedTexture> normal_tex = get_texture(folder, model_in, material_in.normalTexture.index);
-
-    LLUUID normal_id;
-    if (normal_tex != nullptr)
-    {
-        normal_id = normal_tex->getID();
-    }
-
     mME->setAlbedoId(albedo_id);
     mME->setMetallicRoughnessId(mr_id);
     mME->setEmissiveId(emissive_id);
diff --git a/indra/newview/llreflectionmapmanager.cpp b/indra/newview/llreflectionmapmanager.cpp
index bde8c0c51c..583c6de77b 100644
--- a/indra/newview/llreflectionmapmanager.cpp
+++ b/indra/newview/llreflectionmapmanager.cpp
@@ -109,12 +109,6 @@ void LLReflectionMapManager::update()
         }
     }
 
-    // =============== TODO -- move to an init function  =================
-
-    // naively drop probes every 16m as we move the camera around for now
-    // later, use LLSpatialPartition to manage probes
-    const F32 PROBE_SPACING = 16.f;
-    const U32 MAX_PROBES = 8;
 
     LLVector4a camera_pos;
     camera_pos.load3(LLViewerCamera::instance().getOrigin().mV);
@@ -122,7 +116,7 @@ void LLReflectionMapManager::update()
     // process kill list
     for (auto& probe : mKillList)
     {
-        auto& iter = std::find(mProbes.begin(), mProbes.end(), probe);
+        auto const & iter = std::find(mProbes.begin(), mProbes.end(), probe);
         if (iter != mProbes.end())
         {
             deleteProbe(iter - mProbes.begin());
@@ -143,7 +137,6 @@ void LLReflectionMapManager::update()
     {
         return;
     }
-    const F32 UPDATE_INTERVAL = 5.f;  //update no more than once every 5 seconds
 
     bool did_update = false;
 
@@ -366,7 +359,7 @@ void LLReflectionMapManager::deleteProbe(U32 i)
     // remove from any Neighbors lists
     for (auto& other : probe->mNeighbors)
     {
-        auto& iter = std::find(other->mNeighbors.begin(), other->mNeighbors.end(), probe);
+        auto const & iter = std::find(other->mNeighbors.begin(), other->mNeighbors.end(), probe);
         llassert(iter != other->mNeighbors.end());
         other->mNeighbors.erase(iter);
     }
@@ -599,7 +592,7 @@ void LLReflectionMapManager::updateNeighbors(LLReflectionMap* probe)
     
         for (auto& other : probe->mNeighbors)
         {
-            auto& iter = std::find(other->mNeighbors.begin(), other->mNeighbors.end(), probe);
+            auto const & iter = std::find(other->mNeighbors.begin(), other->mNeighbors.end(), probe);
             llassert(iter != other->mNeighbors.end()); // <--- bug davep if this ever happens, something broke badly
             other->mNeighbors.erase(iter);
         }
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 49eba9856c..e76f0b36ee 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -1650,6 +1650,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gDeferredPBROpaqueProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
         gDeferredPBROpaqueProgram.addPermutation("HAS_NORMAL_MAP", "1");
         gDeferredPBROpaqueProgram.addPermutation("HAS_SPECULAR_MAP", "1");
+        gDeferredPBROpaqueProgram.addPermutation("HAS_EMISSIVE_MAP", "1");
         gDeferredPBROpaqueProgram.addPermutation("DIFFUSE_ALPHA_MODE", "0");
 
         success = make_rigged_variant(gDeferredPBROpaqueProgram, gDeferredSkinnedPBROpaqueProgram);
diff --git a/indra/newview/llvovolume.h b/indra/newview/llvovolume.h
index 1ca6b49c7d..f0a4fd427e 100644
--- a/indra/newview/llvovolume.h
+++ b/indra/newview/llvovolume.h
@@ -114,39 +114,39 @@ public:
 	};
 
 public:
-						LLVOVolume(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp);
-	/*virtual*/ void markDead();		// Override (and call through to parent) to clean up media references
+	LLVOVolume(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp);
+	void markDead() override;		// Override (and call through to parent) to clean up media references
 
-	/*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline);
+	LLDrawable* createDrawable(LLPipeline *pipeline) override;
 
 				void	deleteFaces();
 
 				void	animateTextures();
 	
 	            BOOL    isVisible() const ;
-	/*virtual*/ BOOL	isActive() const;
-	/*virtual*/ BOOL	isAttachment() const;
-	/*virtual*/ BOOL	isRootEdit() const; // overridden for sake of attachments treating themselves as a root object
-	/*virtual*/ BOOL	isHUDAttachment() const;
+	BOOL isActive() const override;
+	BOOL isAttachment() const override;
+	BOOL isRootEdit() const override; // overridden for sake of attachments treating themselves as a root object
+	BOOL isHUDAttachment() const override;
 
 				void	generateSilhouette(LLSelectNode* nodep, const LLVector3& view_point);
-	/*virtual*/	BOOL	setParent(LLViewerObject* parent);
-				S32		getLOD() const						{ return mLOD; }
+	/*virtual*/	BOOL	setParent(LLViewerObject* parent) override;
+				S32		getLOD() const override				{ return mLOD; }
 				void	setNoLOD()							{ mLOD = NO_LOD; mLODChanged = TRUE; }
 				bool	isNoLOD() const						{ return NO_LOD == mLOD; }
-	const LLVector3		getPivotPositionAgent() const;
+	const LLVector3		getPivotPositionAgent() const override;
 	const LLMatrix4&	getRelativeXform() const				{ return mRelativeXform; }
 	const LLMatrix3&	getRelativeXformInvTrans() const		{ return mRelativeXformInvTrans; }
-	/*virtual*/	const LLMatrix4	getRenderMatrix() const;
+	/*virtual*/	const LLMatrix4	getRenderMatrix() const override;
 				typedef std::map<LLUUID, S32> texture_cost_t;
 				U32 	getRenderCost(texture_cost_t &textures) const;
-    /*virtual*/	F32		getEstTrianglesMax() const;
-    /*virtual*/	F32		getEstTrianglesStreamingCost() const;
-    /* virtual*/ F32	getStreamingCost() const;
-    /*virtual*/ bool getCostData(LLMeshCostData& costs) const;
+    /*virtual*/	F32		getEstTrianglesMax() const override;
+    /*virtual*/	F32		getEstTrianglesStreamingCost() const override;
+    /* virtual*/ F32	getStreamingCost() const override;
+    /*virtual*/ bool getCostData(LLMeshCostData& costs) const override;
 
-	/*virtual*/ U32		getTriangleCount(S32* vcount = NULL) const;
-	/*virtual*/ U32		getHighLODTriangleCount();
+	/*virtual*/ U32		getTriangleCount(S32* vcount = NULL) const override;
+	/*virtual*/ U32		getHighLODTriangleCount() override;
 	/*virtual*/ BOOL lineSegmentIntersect(const LLVector4a& start, const LLVector4a& end, 
 										  S32 face = -1,                        // which face to check, -1 = ALL_SIDES
 										  BOOL pick_transparent = FALSE,
@@ -157,7 +157,7 @@ public:
 										  LLVector2* tex_coord = NULL,          // return the texture coordinates of the intersection point
 										  LLVector4a* normal = NULL,             // return the surface normal at the intersection point
 										  LLVector4a* tangent = NULL           // return the surface tangent at the intersection point
-		);
+		) override;
 	
 				LLVector3 agentPositionToVolume(const LLVector3& pos) const;
 				LLVector3 agentDirectionToVolume(const LLVector3& dir) const;
@@ -167,17 +167,17 @@ public:
 				
 				BOOL	getVolumeChanged() const				{ return mVolumeChanged; }
 				
-	/*virtual*/ F32  	getRadius() const						{ return mVObjRadius; };
-				const LLMatrix4& getWorldMatrix(LLXformMatrix* xform) const;
+	F32 getVObjRadius() const override				{ return mVObjRadius; };
+				const LLMatrix4& getWorldMatrix(LLXformMatrix* xform) const override;
 
-				void	markForUpdate(BOOL priority);
+				void	markForUpdate(BOOL priority) override;
 				void	markForUnload()							{ LLViewerObject::markForUnload(TRUE); mVolumeChanged = TRUE; }
 				void    faceMappingChanged()                    { mFaceMappingChanged=TRUE; };
 
-	/*virtual*/ void	onShift(const LLVector4a &shift_vector); // Called when the drawable shifts
+	/*virtual*/ void	onShift(const LLVector4a &shift_vector) override; // Called when the drawable shifts
 
-	/*virtual*/ void	parameterChanged(U16 param_type, bool local_origin);
-	/*virtual*/ void	parameterChanged(U16 param_type, LLNetworkData* data, BOOL in_use, bool local_origin);
+	/*virtual*/ void	parameterChanged(U16 param_type, bool local_origin) override;
+	/*virtual*/ void	parameterChanged(U16 param_type, LLNetworkData* data, BOOL in_use, bool local_origin) override;
 
     // update mReflectionProbe based on isReflectionProbe()
     void updateReflectionProbePtr();
@@ -185,40 +185,40 @@ public:
 	/*virtual*/ U32		processUpdateMessage(LLMessageSystem *mesgsys,
 											void **user_data,
 											U32 block_num, const EObjectUpdateType update_type,
-											LLDataPacker *dp);
-
-	/*virtual*/ void	setSelected(BOOL sel);
-	/*virtual*/ BOOL	setDrawableParent(LLDrawable* parentp);
-
-	/*virtual*/ void	setScale(const LLVector3 &scale, BOOL damped);
-
-	/*virtual*/ void    changeTEImage(S32 index, LLViewerTexture* new_image)  ;
-	/*virtual*/ void	setNumTEs(const U8 num_tes);
-	/*virtual*/ void	setTEImage(const U8 te, LLViewerTexture *imagep);
-	/*virtual*/ S32		setTETexture(const U8 te, const LLUUID &uuid);
-	/*virtual*/ S32		setTEColor(const U8 te, const LLColor3 &color);
-	/*virtual*/ S32		setTEColor(const U8 te, const LLColor4 &color);
-	/*virtual*/ S32		setTEBumpmap(const U8 te, const U8 bump);
-	/*virtual*/ S32		setTEShiny(const U8 te, const U8 shiny);
-	/*virtual*/ S32		setTEFullbright(const U8 te, const U8 fullbright);
-	/*virtual*/ S32		setTEBumpShinyFullbright(const U8 te, const U8 bump);
-	/*virtual*/ S32		setTEMediaFlags(const U8 te, const U8 media_flags);
-	/*virtual*/ S32		setTEGlow(const U8 te, const F32 glow);
-	/*virtual*/ S32		setTEMaterialID(const U8 te, const LLMaterialID& pMaterialID);
+											LLDataPacker *dp) override;
+
+	/*virtual*/ void	setSelected(BOOL sel) override;
+	/*virtual*/ BOOL	setDrawableParent(LLDrawable* parentp) override;
+
+	/*virtual*/ void	setScale(const LLVector3 &scale, BOOL damped) override;
+
+	/*virtual*/ void    changeTEImage(S32 index, LLViewerTexture* new_image) override;
+	/*virtual*/ void	setNumTEs(const U8 num_tes) override;
+	/*virtual*/ void	setTEImage(const U8 te, LLViewerTexture *imagep) override;
+	/*virtual*/ S32		setTETexture(const U8 te, const LLUUID &uuid) override;
+	/*virtual*/ S32		setTEColor(const U8 te, const LLColor3 &color) override;
+	/*virtual*/ S32		setTEColor(const U8 te, const LLColor4 &color) override;
+	/*virtual*/ S32		setTEBumpmap(const U8 te, const U8 bump) override;
+	/*virtual*/ S32		setTEShiny(const U8 te, const U8 shiny) override;
+	/*virtual*/ S32		setTEFullbright(const U8 te, const U8 fullbright) override;
+	/*virtual*/ S32		setTEBumpShinyFullbright(const U8 te, const U8 bump) override;
+	/*virtual*/ S32		setTEMediaFlags(const U8 te, const U8 media_flags) override;
+	/*virtual*/ S32		setTEGlow(const U8 te, const F32 glow) override;
+	/*virtual*/ S32		setTEMaterialID(const U8 te, const LLMaterialID& pMaterialID) override;
 	
 	static void	setTEMaterialParamsCallbackTE(const LLUUID& objectID, const LLMaterialID& pMaterialID, const LLMaterialPtr pMaterialParams, U32 te);
 
-	/*virtual*/ S32		setTEMaterialParams(const U8 te, const LLMaterialPtr pMaterialParams);
-	/*virtual*/ S32		setTEScale(const U8 te, const F32 s, const F32 t);
-	/*virtual*/ S32		setTEScaleS(const U8 te, const F32 s);
-	/*virtual*/ S32		setTEScaleT(const U8 te, const F32 t);
-	/*virtual*/ S32		setTETexGen(const U8 te, const U8 texgen);
-	/*virtual*/ S32		setTEMediaTexGen(const U8 te, const U8 media);
-	/*virtual*/ BOOL 	setMaterial(const U8 material);
+	/*virtual*/ S32		setTEMaterialParams(const U8 te, const LLMaterialPtr pMaterialParams) override;
+	/*virtual*/ S32		setTEScale(const U8 te, const F32 s, const F32 t) override;
+	/*virtual*/ S32		setTEScaleS(const U8 te, const F32 s) override;
+	/*virtual*/ S32		setTEScaleT(const U8 te, const F32 t) override;
+	/*virtual*/ S32		setTETexGen(const U8 te, const U8 texgen) override;
+	/*virtual*/ S32		setTEMediaTexGen(const U8 te, const U8 media) override;
+	/*virtual*/ BOOL 	setMaterial(const U8 material) override;
 
 				void	setTexture(const S32 face);
 				S32     getIndexInTex(U32 ch) const {return mIndexInTex[ch];}
-	/*virtual*/ BOOL	setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume = false);
+	/*virtual*/ BOOL	setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume = false) override;
 				void	updateSculptTexture();
 				void    setIndexInTex(U32 ch, S32 index) { mIndexInTex[ch] = index ;}
 				void	sculpt();
@@ -227,21 +227,21 @@ public:
 												 void* user_data, S32 status, LLExtStat ext_status);
 					
 				void	updateRelativeXform(bool force_identity = false);
-	/*virtual*/ BOOL	updateGeometry(LLDrawable *drawable);
-	/*virtual*/ void	updateFaceSize(S32 idx);
-	/*virtual*/ BOOL	updateLOD();
-				void	updateRadius();
-	/*virtual*/ void	updateTextures();
+	/*virtual*/ BOOL	updateGeometry(LLDrawable *drawable) override;
+	/*virtual*/ void	updateFaceSize(S32 idx) override;
+	/*virtual*/ BOOL	updateLOD() override;
+				void	updateRadius() override;
+	/*virtual*/ void	updateTextures() override;
 				void	updateTextureVirtualSize(bool forced = false);
 
 				void	updateFaceFlags();
 				void	regenFaces();
 				BOOL	genBBoxes(BOOL force_global);
 				void	preRebuild();
-	virtual		void	updateSpatialExtents(LLVector4a& min, LLVector4a& max);
-	virtual		F32		getBinRadius();
+	virtual		void	updateSpatialExtents(LLVector4a& min, LLVector4a& max) override;
+	virtual		F32		getBinRadius() override;
 	
-	virtual U32 getPartitionType() const;
+	virtual U32 getPartitionType() const override;
 
 	// For Lights
 	void setIsLight(BOOL is_light);
@@ -300,11 +300,11 @@ public:
 
 	// Flexible Objects
 	U32 getVolumeInterfaceID() const;
-	virtual BOOL isFlexible() const;
-	virtual BOOL isSculpted() const;
-	virtual BOOL isMesh() const;
-	virtual BOOL isRiggedMesh() const;
-	virtual BOOL hasLightTexture() const;
+	virtual BOOL isFlexible() const override;
+	virtual BOOL isSculpted() const override;
+	virtual BOOL isMesh() const override;
+	virtual BOOL isRiggedMesh() const override;
+	virtual BOOL hasLightTexture() const override;
 
     
 	BOOL isVolumeGlobal() const;
@@ -321,12 +321,12 @@ public:
     void onSetExtendedMeshFlags(U32 flags);
     void setExtendedMeshFlags(U32 flags);
     bool canBeAnimatedObject() const;
-    bool isAnimatedObject() const;
-    virtual void onReparent(LLViewerObject *old_parent, LLViewerObject *new_parent);
-    virtual void afterReparent();
+    bool isAnimatedObject() const override;
+    virtual void onReparent(LLViewerObject *old_parent, LLViewerObject *new_parent) override;
+    virtual void afterReparent() override;
 
     //virtual
-    void updateRiggingInfo();
+    void updateRiggingInfo() override;
     S32 mLastRiggingInfoLOD;
     
     // Functions that deal with media, or media navigation