diff --git a/indra/llcharacter/llmultigesture.cpp b/indra/llcharacter/llmultigesture.cpp
index 0baae63a5f001c5a83557b5e61b7e6ff5ec2714b..bef1fbd519af2b82208cb1643aceff8211e5488d 100644
--- a/indra/llcharacter/llmultigesture.cpp
+++ b/indra/llcharacter/llmultigesture.cpp
@@ -309,13 +309,13 @@ std::vector<std::string> LLGestureStepAnimation::getLabel() const
 //	std::string label;
 	if (mFlags & ANIM_FLAG_STOP)
 	{
-		strings.push_back( "AnimFlagStop");
+		strings.emplace_back( "AnimFlagStop");
 
 //		label = "Stop Animation: ";
 	}
 	else
 	{
-		strings.push_back( "AnimFlagStart");
+		strings.emplace_back( "AnimFlagStart");
 
 //		label = "Start Animation: "; 
 	}
@@ -376,7 +376,7 @@ BOOL LLGestureStepSound::deserialize(LLDataPacker& dp)
 std::vector<std::string> LLGestureStepSound::getLabel() const
 {
 	std::vector<std::string> strings;
-	strings.push_back( "Sound");
+	strings.emplace_back( "Sound");
 	strings.push_back( mSoundName);	
 //	std::string label("Sound: ");
 //	label += mSoundName;
@@ -431,7 +431,7 @@ BOOL LLGestureStepChat::deserialize(LLDataPacker& dp)
 std::vector<std::string> LLGestureStepChat::getLabel() const
 {
 	std::vector<std::string> strings;
-	strings.push_back("Chat");
+	strings.emplace_back("Chat");
 	strings.push_back(mChatText);
 	return strings;
 }
@@ -482,24 +482,24 @@ BOOL LLGestureStepWait::deserialize(LLDataPacker& dp)
 std::vector<std::string> LLGestureStepWait::getLabel() const
 {
 	std::vector<std::string> strings;
-	strings.push_back( "Wait" );
+	strings.emplace_back( "Wait" );
 	
 //	std::string label("--- Wait: ");
 	if (mFlags & WAIT_FLAG_TIME)
 	{
 		char buffer[64];		/* Flawfinder: ignore */
 		snprintf(buffer, sizeof(buffer), "%.1f seconds", (double)mWaitSeconds);	/* Flawfinder: ignore */
-		strings.push_back(buffer);
+		strings.emplace_back(buffer);
 //		label += buffer;
 	}
 	else if (mFlags & WAIT_FLAG_ALL_ANIM)
 	{
-		strings.push_back("until animations are done");
+		strings.emplace_back("until animations are done");
 	//	label += "until animations are done";
 	}
 	else
 	{
-		strings.push_back("");
+		strings.emplace_back("");
 	}
 
 	return strings;
diff --git a/indra/llcommon/llregistry.h b/indra/llcommon/llregistry.h
index f251fc32ed6d093f9bf2ab83c4bd1e399b5a39c6..5dcded29686e195a53941045a0e4605bc8bbdb12 100644
--- a/indra/llcommon/llregistry.h
+++ b/indra/llcommon/llregistry.h
@@ -148,7 +148,7 @@ public:
 
 	ptr_const_value_t getValue(ref_const_key_t key) const
 	{
-		for(scope_list_const_iterator_t it = mActiveScopes.begin();
+		for(auto it = mActiveScopes.begin();
 			it != mActiveScopes.end();
 			++it)
 		{
@@ -160,7 +160,7 @@ public:
 
 	bool exists(ref_const_key_t key) const
 	{
-		for(scope_list_const_iterator_t it = mActiveScopes.begin();
+		for(auto it = mActiveScopes.begin();
 			it != mActiveScopes.end();
 			++it)
 		{
diff --git a/indra/llmath/llvolume.cpp b/indra/llmath/llvolume.cpp
index 3e852b9e26495ffeafae42051aa15a6448417230..86a199d99a2a6f424e787eb5b4a1d53c053be9a0 100644
--- a/indra/llmath/llvolume.cpp
+++ b/indra/llmath/llvolume.cpp
@@ -3719,7 +3719,7 @@ void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
 	
 	S32 cur_index = 0;
 	//for each face
-	for (face_list_t::iterator iter = mVolumeFaces.begin();
+	for (auto iter = mVolumeFaces.begin();
 		 iter != mVolumeFaces.end(); ++iter)
 	{
 		LLVolumeFace& face = *iter;
@@ -3735,9 +3735,9 @@ void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
 			LLVector4a* v = (LLVector4a*)face.mPositions;
 			LLVector4a* n = (LLVector4a*)face.mNormals;
 
-			for (S32 j = 0; j < face.mNumIndices / 3; j++)
+			for (auto j = 0; j < face.mNumIndices / 3; j++)
 			{
-				for (S32 k = 0; k < 3; k++)
+				for (auto k = 0; k < 3; k++)
 				{
 					S32 index = face.mEdge[j * 3 + k];
 
@@ -3750,19 +3750,19 @@ void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
 
 						LLVector4a t;
 						mat.affineTransform(v[v1], t);
-						vertices.push_back(LLVector3(t[0], t[1], t[2]));
+						vertices.emplace_back(t[0], t[1], t[2]);
 
 						norm_mat.rotate(n[v1], t);
 
 						t.normalize3fast();
-						normals.push_back(LLVector3(t[0], t[1], t[2]));
+						normals.emplace_back(t[0], t[1], t[2]);
 
 						mat.affineTransform(v[v2], t);
-						vertices.push_back(LLVector3(t[0], t[1], t[2]));
+						vertices.emplace_back(t[0], t[1], t[2]);
 
 						norm_mat.rotate(n[v2], t);
 						t.normalize3fast();
-						normals.push_back(LLVector3(t[0], t[1], t[2]));
+						normals.emplace_back(t[0], t[1], t[2]);
 					}
 				}
 			}
@@ -3934,19 +3934,19 @@ void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
 						
 						LLVector4a t;
 						mat.affineTransform(v[v1], t);
-						vertices.push_back(LLVector3(t[0], t[1], t[2]));
+						vertices.emplace_back(t[0], t[1], t[2]);
 
 						norm_mat.rotate(n[v1], t);
 
 						t.normalize3fast();
-						normals.push_back(LLVector3(t[0], t[1], t[2]));
+						normals.emplace_back(t[0], t[1], t[2]);
 
 						mat.affineTransform(v[v2], t);
-						vertices.push_back(LLVector3(t[0], t[1], t[2]));
+						vertices.emplace_back(t[0], t[1], t[2]);
 						
 						norm_mat.rotate(n[v2], t);
 						t.normalize3fast();
-						normals.push_back(LLVector3(t[0], t[1], t[2]));
+						normals.emplace_back(t[0], t[1], t[2]);
 					}
 				}		
 			}
diff --git a/indra/llrender/llrender2dutils.cpp b/indra/llrender/llrender2dutils.cpp
index 591058de325ee5baf08d32c055f4c2c1424448f6..718b28113942fea8a50034abf1c3ea60eb263e5d 100644
--- a/indra/llrender/llrender2dutils.cpp
+++ b/indra/llrender/llrender2dutils.cpp
@@ -1491,7 +1491,7 @@ void LLRender2D::translate(F32 x, F32 y, F32 z)
 void LLRender2D::pushMatrix()
 {
 	gGL.pushUIMatrix();
-	LLFontGL::sOriginStack.push_back(std::make_pair(LLFontGL::sCurOrigin, LLFontGL::sCurDepth));
+	LLFontGL::sOriginStack.emplace_back(LLFontGL::sCurOrigin, LLFontGL::sCurDepth);
 }
 
 //static
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 7c234cd84dbeded60c398501035fc58e14e647c1..5425a5da32177910e01d3da86659a0502ed99a35 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -1208,238 +1208,238 @@ BOOL LLShaderMgr::validateProgramObject(GLuint program)
 void LLShaderMgr::initAttribsAndUniforms()
 {
 	//MUST match order of enum in LLVertexBuffer.h
-	mReservedAttribs.push_back("position");
-	mReservedAttribs.push_back("normal");
-	mReservedAttribs.push_back("texcoord0");
-	mReservedAttribs.push_back("texcoord1");
-	mReservedAttribs.push_back("texcoord2");
-	mReservedAttribs.push_back("texcoord3");
-	mReservedAttribs.push_back("diffuse_color");
-	mReservedAttribs.push_back("emissive");
-	mReservedAttribs.push_back("tangent");
-	mReservedAttribs.push_back("weight");
-	mReservedAttribs.push_back("weight4");
-	mReservedAttribs.push_back("clothing");
-	mReservedAttribs.push_back("texture_index");
+	mReservedAttribs.emplace_back("position");
+	mReservedAttribs.emplace_back("normal");
+	mReservedAttribs.emplace_back("texcoord0");
+	mReservedAttribs.emplace_back("texcoord1");
+	mReservedAttribs.emplace_back("texcoord2");
+	mReservedAttribs.emplace_back("texcoord3");
+	mReservedAttribs.emplace_back("diffuse_color");
+	mReservedAttribs.emplace_back("emissive");
+	mReservedAttribs.emplace_back("tangent");
+	mReservedAttribs.emplace_back("weight");
+	mReservedAttribs.emplace_back("weight4");
+	mReservedAttribs.emplace_back("clothing");
+	mReservedAttribs.emplace_back("texture_index");
 	
 	//matrix state
-	mReservedUniforms.push_back("modelview_matrix");
-	mReservedUniforms.push_back("projection_matrix");
-	mReservedUniforms.push_back("inv_proj");
-	mReservedUniforms.push_back("modelview_projection_matrix");
-	mReservedUniforms.push_back("normal_matrix");
-	mReservedUniforms.push_back("texture_matrix0");
-	mReservedUniforms.push_back("texture_matrix1");
-	mReservedUniforms.push_back("texture_matrix2");
-	mReservedUniforms.push_back("texture_matrix3");
-	mReservedUniforms.push_back("object_plane_s");
-	mReservedUniforms.push_back("object_plane_t");
+	mReservedUniforms.emplace_back("modelview_matrix");
+	mReservedUniforms.emplace_back("projection_matrix");
+	mReservedUniforms.emplace_back("inv_proj");
+	mReservedUniforms.emplace_back("modelview_projection_matrix");
+	mReservedUniforms.emplace_back("normal_matrix");
+	mReservedUniforms.emplace_back("texture_matrix0");
+	mReservedUniforms.emplace_back("texture_matrix1");
+	mReservedUniforms.emplace_back("texture_matrix2");
+	mReservedUniforms.emplace_back("texture_matrix3");
+	mReservedUniforms.emplace_back("object_plane_s");
+	mReservedUniforms.emplace_back("object_plane_t");
 	llassert(mReservedUniforms.size() == LLShaderMgr::OBJECT_PLANE_T+1);
 
-	mReservedUniforms.push_back("light_position");
-	mReservedUniforms.push_back("light_direction");
-	mReservedUniforms.push_back("light_attenuation");
-	mReservedUniforms.push_back("light_diffuse");
-	mReservedUniforms.push_back("light_ambient");
-	mReservedUniforms.push_back("light_count");
-	mReservedUniforms.push_back("light");
-	mReservedUniforms.push_back("light_col");
-	mReservedUniforms.push_back("far_z");
+	mReservedUniforms.emplace_back("light_position");
+	mReservedUniforms.emplace_back("light_direction");
+	mReservedUniforms.emplace_back("light_attenuation");
+	mReservedUniforms.emplace_back("light_diffuse");
+	mReservedUniforms.emplace_back("light_ambient");
+	mReservedUniforms.emplace_back("light_count");
+	mReservedUniforms.emplace_back("light");
+	mReservedUniforms.emplace_back("light_col");
+	mReservedUniforms.emplace_back("far_z");
 
 	llassert(mReservedUniforms.size() == LLShaderMgr::MULTI_LIGHT_FAR_Z+1);
 
 
-	mReservedUniforms.push_back("proj_mat");
-	mReservedUniforms.push_back("proj_near");
-	mReservedUniforms.push_back("proj_p");
-	mReservedUniforms.push_back("proj_n");
-	mReservedUniforms.push_back("proj_origin");
-	mReservedUniforms.push_back("proj_range");
-	mReservedUniforms.push_back("proj_ambiance");
-	mReservedUniforms.push_back("proj_shadow_idx");
-	mReservedUniforms.push_back("shadow_fade");
-	mReservedUniforms.push_back("proj_focus");
-	mReservedUniforms.push_back("proj_lod");
-	mReservedUniforms.push_back("proj_ambient_lod");
+	mReservedUniforms.emplace_back("proj_mat");
+	mReservedUniforms.emplace_back("proj_near");
+	mReservedUniforms.emplace_back("proj_p");
+	mReservedUniforms.emplace_back("proj_n");
+	mReservedUniforms.emplace_back("proj_origin");
+	mReservedUniforms.emplace_back("proj_range");
+	mReservedUniforms.emplace_back("proj_ambiance");
+	mReservedUniforms.emplace_back("proj_shadow_idx");
+	mReservedUniforms.emplace_back("shadow_fade");
+	mReservedUniforms.emplace_back("proj_focus");
+	mReservedUniforms.emplace_back("proj_lod");
+	mReservedUniforms.emplace_back("proj_ambient_lod");
 
 	llassert(mReservedUniforms.size() == LLShaderMgr::PROJECTOR_AMBIENT_LOD+1);
 
-	mReservedUniforms.push_back("color");
+	mReservedUniforms.emplace_back("color");
 		
-	mReservedUniforms.push_back("diffuseMap");
-	mReservedUniforms.push_back("specularMap");
-	mReservedUniforms.push_back("bumpMap");
-	mReservedUniforms.push_back("environmentMap");
-	mReservedUniforms.push_back("cloude_noise_texture");
-	mReservedUniforms.push_back("fullbright");
-	mReservedUniforms.push_back("lightnorm");
-	mReservedUniforms.push_back("sunlight_color_copy");
-	mReservedUniforms.push_back("ambient");
-	mReservedUniforms.push_back("blue_horizon");
-	mReservedUniforms.push_back("blue_density");
-	mReservedUniforms.push_back("haze_horizon");
-	mReservedUniforms.push_back("haze_density");
-	mReservedUniforms.push_back("cloud_shadow");
-	mReservedUniforms.push_back("density_multiplier");
-	mReservedUniforms.push_back("distance_multiplier");
-	mReservedUniforms.push_back("max_y");
-	mReservedUniforms.push_back("glow");
-	mReservedUniforms.push_back("cloud_color");
-	mReservedUniforms.push_back("cloud_pos_density1");
-	mReservedUniforms.push_back("cloud_pos_density2");
-	mReservedUniforms.push_back("cloud_scale");
-	mReservedUniforms.push_back("gamma");
-	mReservedUniforms.push_back("scene_light_strength");
+	mReservedUniforms.emplace_back("diffuseMap");
+	mReservedUniforms.emplace_back("specularMap");
+	mReservedUniforms.emplace_back("bumpMap");
+	mReservedUniforms.emplace_back("environmentMap");
+	mReservedUniforms.emplace_back("cloude_noise_texture");
+	mReservedUniforms.emplace_back("fullbright");
+	mReservedUniforms.emplace_back("lightnorm");
+	mReservedUniforms.emplace_back("sunlight_color_copy");
+	mReservedUniforms.emplace_back("ambient");
+	mReservedUniforms.emplace_back("blue_horizon");
+	mReservedUniforms.emplace_back("blue_density");
+	mReservedUniforms.emplace_back("haze_horizon");
+	mReservedUniforms.emplace_back("haze_density");
+	mReservedUniforms.emplace_back("cloud_shadow");
+	mReservedUniforms.emplace_back("density_multiplier");
+	mReservedUniforms.emplace_back("distance_multiplier");
+	mReservedUniforms.emplace_back("max_y");
+	mReservedUniforms.emplace_back("glow");
+	mReservedUniforms.emplace_back("cloud_color");
+	mReservedUniforms.emplace_back("cloud_pos_density1");
+	mReservedUniforms.emplace_back("cloud_pos_density2");
+	mReservedUniforms.emplace_back("cloud_scale");
+	mReservedUniforms.emplace_back("gamma");
+	mReservedUniforms.emplace_back("scene_light_strength");
 
 	llassert(mReservedUniforms.size() == LLShaderMgr::SCENE_LIGHT_STRENGTH+1);
 
-	mReservedUniforms.push_back("center");
-	mReservedUniforms.push_back("size");
-	mReservedUniforms.push_back("falloff");
+	mReservedUniforms.emplace_back("center");
+	mReservedUniforms.emplace_back("size");
+	mReservedUniforms.emplace_back("falloff");
 
-	mReservedUniforms.push_back("box_center");
-	mReservedUniforms.push_back("box_size");
+	mReservedUniforms.emplace_back("box_center");
+	mReservedUniforms.emplace_back("box_size");
 
 
-	mReservedUniforms.push_back("minLuminance");
-	mReservedUniforms.push_back("maxExtractAlpha");
-	mReservedUniforms.push_back("lumWeights");
-	mReservedUniforms.push_back("warmthWeights");
-	mReservedUniforms.push_back("warmthAmount");
-	mReservedUniforms.push_back("glowStrength");
-	mReservedUniforms.push_back("glowDelta");
+	mReservedUniforms.emplace_back("minLuminance");
+	mReservedUniforms.emplace_back("maxExtractAlpha");
+	mReservedUniforms.emplace_back("lumWeights");
+	mReservedUniforms.emplace_back("warmthWeights");
+	mReservedUniforms.emplace_back("warmthAmount");
+	mReservedUniforms.emplace_back("glowStrength");
+	mReservedUniforms.emplace_back("glowDelta");
 
 	llassert(mReservedUniforms.size() == LLShaderMgr::GLOW_DELTA+1);
 
 
-	mReservedUniforms.push_back("minimum_alpha");
-	mReservedUniforms.push_back("emissive_brightness");
-
-	mReservedUniforms.push_back("shadow_matrix");
-	mReservedUniforms.push_back("env_mat");
-	mReservedUniforms.push_back("shadow_clip");
-	mReservedUniforms.push_back("sun_wash");
-	mReservedUniforms.push_back("shadow_noise");
-	mReservedUniforms.push_back("blur_size");
-	mReservedUniforms.push_back("ssao_radius");
-	mReservedUniforms.push_back("ssao_max_radius");
-	mReservedUniforms.push_back("ssao_factor");
-	mReservedUniforms.push_back("ssao_factor_inv");
-	mReservedUniforms.push_back("ssao_effect");
-	mReservedUniforms.push_back("ssao_scale");
-	mReservedUniforms.push_back("kern_scale");
-	mReservedUniforms.push_back("noise_scale");
-	mReservedUniforms.push_back("near_clip");
-	mReservedUniforms.push_back("shadow_offset");
-	mReservedUniforms.push_back("shadow_bias");
-	mReservedUniforms.push_back("spot_shadow_bias");
-	mReservedUniforms.push_back("spot_shadow_offset");
-	mReservedUniforms.push_back("sun_dir");
-	mReservedUniforms.push_back("shadow_res");
-	mReservedUniforms.push_back("proj_shadow_res");
-	mReservedUniforms.push_back("depth_cutoff");
-	mReservedUniforms.push_back("norm_cutoff");
-	mReservedUniforms.push_back("shadow_target_width");
-	mReservedUniforms.push_back("downsampled_depth_scale");
+	mReservedUniforms.emplace_back("minimum_alpha");
+	mReservedUniforms.emplace_back("emissive_brightness");
+
+	mReservedUniforms.emplace_back("shadow_matrix");
+	mReservedUniforms.emplace_back("env_mat");
+	mReservedUniforms.emplace_back("shadow_clip");
+	mReservedUniforms.emplace_back("sun_wash");
+	mReservedUniforms.emplace_back("shadow_noise");
+	mReservedUniforms.emplace_back("blur_size");
+	mReservedUniforms.emplace_back("ssao_radius");
+	mReservedUniforms.emplace_back("ssao_max_radius");
+	mReservedUniforms.emplace_back("ssao_factor");
+	mReservedUniforms.emplace_back("ssao_factor_inv");
+	mReservedUniforms.emplace_back("ssao_effect");
+	mReservedUniforms.emplace_back("ssao_scale");
+	mReservedUniforms.emplace_back("kern_scale");
+	mReservedUniforms.emplace_back("noise_scale");
+	mReservedUniforms.emplace_back("near_clip");
+	mReservedUniforms.emplace_back("shadow_offset");
+	mReservedUniforms.emplace_back("shadow_bias");
+	mReservedUniforms.emplace_back("spot_shadow_bias");
+	mReservedUniforms.emplace_back("spot_shadow_offset");
+	mReservedUniforms.emplace_back("sun_dir");
+	mReservedUniforms.emplace_back("shadow_res");
+	mReservedUniforms.emplace_back("proj_shadow_res");
+	mReservedUniforms.emplace_back("depth_cutoff");
+	mReservedUniforms.emplace_back("norm_cutoff");
+	mReservedUniforms.emplace_back("shadow_target_width");
+	mReservedUniforms.emplace_back("downsampled_depth_scale");
 	
 	llassert(mReservedUniforms.size() == LLShaderMgr::DEFERRED_DOWNSAMPLED_DEPTH_SCALE+1);
 
-	mReservedUniforms.push_back("rcp_screen_res");
-	mReservedUniforms.push_back("rcp_frame_opt");
-	mReservedUniforms.push_back("rcp_frame_opt2");
+	mReservedUniforms.emplace_back("rcp_screen_res");
+	mReservedUniforms.emplace_back("rcp_frame_opt");
+	mReservedUniforms.emplace_back("rcp_frame_opt2");
 	
-	mReservedUniforms.push_back("focal_distance");
-	mReservedUniforms.push_back("blur_constant");
-	mReservedUniforms.push_back("tan_pixel_angle");
-	mReservedUniforms.push_back("magnification");
-	mReservedUniforms.push_back("max_cof");
-	mReservedUniforms.push_back("res_scale");
-	mReservedUniforms.push_back("dof_width");
-	mReservedUniforms.push_back("dof_height");
-
-	mReservedUniforms.push_back("depthMap");
-	mReservedUniforms.push_back("depthMapDownsampled");
-	mReservedUniforms.push_back("shadowMap0");
-	mReservedUniforms.push_back("shadowMap1");
-	mReservedUniforms.push_back("shadowMap2");
-	mReservedUniforms.push_back("shadowMap3");
-	mReservedUniforms.push_back("shadowMap4");
-	mReservedUniforms.push_back("shadowMap5");
+	mReservedUniforms.emplace_back("focal_distance");
+	mReservedUniforms.emplace_back("blur_constant");
+	mReservedUniforms.emplace_back("tan_pixel_angle");
+	mReservedUniforms.emplace_back("magnification");
+	mReservedUniforms.emplace_back("max_cof");
+	mReservedUniforms.emplace_back("res_scale");
+	mReservedUniforms.emplace_back("dof_width");
+	mReservedUniforms.emplace_back("dof_height");
+
+	mReservedUniforms.emplace_back("depthMap");
+	mReservedUniforms.emplace_back("depthMapDownsampled");
+	mReservedUniforms.emplace_back("shadowMap0");
+	mReservedUniforms.emplace_back("shadowMap1");
+	mReservedUniforms.emplace_back("shadowMap2");
+	mReservedUniforms.emplace_back("shadowMap3");
+	mReservedUniforms.emplace_back("shadowMap4");
+	mReservedUniforms.emplace_back("shadowMap5");
 
 	llassert(mReservedUniforms.size() == LLShaderMgr::DEFERRED_SHADOW5+1);
 
-	mReservedUniforms.push_back("normalMap");
-	mReservedUniforms.push_back("positionMap");
-	mReservedUniforms.push_back("diffuseRect");
-	mReservedUniforms.push_back("specularRect");
-	mReservedUniforms.push_back("noiseMap");
-	mReservedUniforms.push_back("lightFunc");
-	mReservedUniforms.push_back("lightMap");
-	mReservedUniforms.push_back("bloomMap");
-	mReservedUniforms.push_back("projectionMap");
-	mReservedUniforms.push_back("norm_mat");
-
-	mReservedUniforms.push_back("global_gamma");
-	mReservedUniforms.push_back("texture_gamma");
+	mReservedUniforms.emplace_back("normalMap");
+	mReservedUniforms.emplace_back("positionMap");
+	mReservedUniforms.emplace_back("diffuseRect");
+	mReservedUniforms.emplace_back("specularRect");
+	mReservedUniforms.emplace_back("noiseMap");
+	mReservedUniforms.emplace_back("lightFunc");
+	mReservedUniforms.emplace_back("lightMap");
+	mReservedUniforms.emplace_back("bloomMap");
+	mReservedUniforms.emplace_back("projectionMap");
+	mReservedUniforms.emplace_back("norm_mat");
+
+	mReservedUniforms.emplace_back("global_gamma");
+	mReservedUniforms.emplace_back("texture_gamma");
 	
-	mReservedUniforms.push_back("specular_color");
-	mReservedUniforms.push_back("env_intensity");
+	mReservedUniforms.emplace_back("specular_color");
+	mReservedUniforms.emplace_back("env_intensity");
 
-	mReservedUniforms.push_back("matrixPalette");
-	mReservedUniforms.push_back("translationPalette");
-	mReservedUniforms.push_back("maxWeight");
+	mReservedUniforms.emplace_back("matrixPalette");
+	mReservedUniforms.emplace_back("translationPalette");
+	mReservedUniforms.emplace_back("maxWeight");
 	
-	mReservedUniforms.push_back("screenTex");
-	mReservedUniforms.push_back("screenDepth");
-	mReservedUniforms.push_back("refTex");
-	mReservedUniforms.push_back("eyeVec");
-	mReservedUniforms.push_back("time");
-	mReservedUniforms.push_back("d1");
-	mReservedUniforms.push_back("d2");
-	mReservedUniforms.push_back("lightDir");
-	mReservedUniforms.push_back("specular");
-	mReservedUniforms.push_back("lightExp");
-	mReservedUniforms.push_back("waterFogColor");
-	mReservedUniforms.push_back("waterFogDensity");
-	mReservedUniforms.push_back("waterFogKS");
-	mReservedUniforms.push_back("refScale");
-	mReservedUniforms.push_back("waterHeight");
-	mReservedUniforms.push_back("waterPlane");
-	mReservedUniforms.push_back("normScale");
-	mReservedUniforms.push_back("fresnelScale");
-	mReservedUniforms.push_back("fresnelOffset");
-	mReservedUniforms.push_back("blurMultiplier");
-	mReservedUniforms.push_back("sunAngle");
-	mReservedUniforms.push_back("scaledAngle");
-	mReservedUniforms.push_back("sunAngle2");
+	mReservedUniforms.emplace_back("screenTex");
+	mReservedUniforms.emplace_back("screenDepth");
+	mReservedUniforms.emplace_back("refTex");
+	mReservedUniforms.emplace_back("eyeVec");
+	mReservedUniforms.emplace_back("time");
+	mReservedUniforms.emplace_back("d1");
+	mReservedUniforms.emplace_back("d2");
+	mReservedUniforms.emplace_back("lightDir");
+	mReservedUniforms.emplace_back("specular");
+	mReservedUniforms.emplace_back("lightExp");
+	mReservedUniforms.emplace_back("waterFogColor");
+	mReservedUniforms.emplace_back("waterFogDensity");
+	mReservedUniforms.emplace_back("waterFogKS");
+	mReservedUniforms.emplace_back("refScale");
+	mReservedUniforms.emplace_back("waterHeight");
+	mReservedUniforms.emplace_back("waterPlane");
+	mReservedUniforms.emplace_back("normScale");
+	mReservedUniforms.emplace_back("fresnelScale");
+	mReservedUniforms.emplace_back("fresnelOffset");
+	mReservedUniforms.emplace_back("blurMultiplier");
+	mReservedUniforms.emplace_back("sunAngle");
+	mReservedUniforms.emplace_back("scaledAngle");
+	mReservedUniforms.emplace_back("sunAngle2");
 	
-	mReservedUniforms.push_back("camPosLocal");
+	mReservedUniforms.emplace_back("camPosLocal");
 
-	mReservedUniforms.push_back("gWindDir");
-	mReservedUniforms.push_back("gSinWaveParams");
-	mReservedUniforms.push_back("gGravity");
+	mReservedUniforms.emplace_back("gWindDir");
+	mReservedUniforms.emplace_back("gSinWaveParams");
+	mReservedUniforms.emplace_back("gGravity");
 
-	mReservedUniforms.push_back("detail_0");
-	mReservedUniforms.push_back("detail_1");
-	mReservedUniforms.push_back("detail_2");
-	mReservedUniforms.push_back("detail_3");
-	mReservedUniforms.push_back("alpha_ramp");
+	mReservedUniforms.emplace_back("detail_0");
+	mReservedUniforms.emplace_back("detail_1");
+	mReservedUniforms.emplace_back("detail_2");
+	mReservedUniforms.emplace_back("detail_3");
+	mReservedUniforms.emplace_back("alpha_ramp");
 
-	mReservedUniforms.push_back("origin");
+	mReservedUniforms.emplace_back("origin");
 	// <alchemy>
-	mReservedUniforms.push_back("seconds60");
+	mReservedUniforms.emplace_back("seconds60");
 	// </alchemy>
 	llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);
 
 	std::set<std::string> dupe_check;
 
-	for (U32 i = 0; i < mReservedUniforms.size(); ++i)
-	{
-		if (dupe_check.find(mReservedUniforms[i]) != dupe_check.end())
+	for (const auto& uniform : mReservedUniforms)
+    {
+		if (dupe_check.find(uniform) != dupe_check.end())
 		{
-			LL_ERRS() << "Duplicate reserved uniform name found: " << mReservedUniforms[i] << LL_ENDL;
+			LL_ERRS() << "Duplicate reserved uniform name found: " << uniform << LL_ENDL;
 		}
-		dupe_check.insert(mReservedUniforms[i]);
+		dupe_check.insert(uniform);
 	}
 }
 
diff --git a/indra/llui/llloadingindicator.cpp b/indra/llui/llloadingindicator.cpp
index e8b6b7e43b50e2eed0b55f60f48a8d7123be4925..1892351f75808a9851dbe4872391b1876cfb3ed8 100644
--- a/indra/llui/llloadingindicator.cpp
+++ b/indra/llui/llloadingindicator.cpp
@@ -53,7 +53,7 @@ void LLLoadingIndicator::initFromParams(const Params& p)
 {
 	for (LLUIImage* image : p.images().image)
 	{
-		mImages.push_back(image);
+		mImages.emplace_back(image);
 	}
 
 	// Start timer for switching images.
diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp
index 131a9f4b115b993cd0918f2949396eb51da64b0b..57744c7043c7f6117ba4b2d1e2aa6f0caea3c743 100644
--- a/indra/llui/llscrolllistctrl.cpp
+++ b/indra/llui/llscrolllistctrl.cpp
@@ -2601,7 +2601,7 @@ void LLScrollListCtrl::updateSort() const
 void LLScrollListCtrl::sortOnce(S32 column, BOOL ascending)
 {
 	std::vector<std::pair<S32, BOOL> > sort_column;
-	sort_column.push_back(std::make_pair(column, ascending));
+	sort_column.emplace_back(column, ascending);
 
 	// do stable sort to preserve any previous sorts
 	std::stable_sort(
diff --git a/indra/llui/llxuiparser.cpp b/indra/llui/llxuiparser.cpp
index ebbd908c5d3f2a96d62975787a99d856d9ec4c34..6775a046c9010dbd5804401c15a953cb6d91e9d0 100644
--- a/indra/llui/llxuiparser.cpp
+++ b/indra/llui/llxuiparser.cpp
@@ -1392,7 +1392,7 @@ bool LLSimpleXUIParser::readXUI(const std::string& filename, LLInitParam::BaseBl
 	XML_SetElementHandler(			mParser,	startElementHandler, endElementHandler);
 	XML_SetCharacterDataHandler(	mParser,	characterDataHandler);
 
-	mOutputStack.push_back(std::make_pair(&block, 0));
+	mOutputStack.emplace_back(&block, 0);
 	mNameStack.clear();
 	mCurFileName = filename;
 	mCurReadDepth = 0;
diff --git a/indra/llvfs/lldir.cpp b/indra/llvfs/lldir.cpp
index fd4bb97df820800e212693d498aacbd73c7e92d3..9ddfb97a610daa1416adb19fdbccaf821d7f74ef 100644
--- a/indra/llvfs/lldir.cpp
+++ b/indra/llvfs/lldir.cpp
@@ -784,7 +784,7 @@ std::vector<std::string> LLDir::findSkinnedFilenames(const std::string& subdir,
 	if (found->second.empty())
 	{
 		// subdir is not localized. filename should be located directly within it.
-		subsubdirs.push_back("");
+		subsubdirs.emplace_back("");
 	}
 	else
 	{
diff --git a/indra/newview/llfloatermodelpreview.cpp b/indra/newview/llfloatermodelpreview.cpp
index a9e85a7416b8826b70f862d65b470bcfdfbac920..71d864a8125e5edf03e816e89a7840d1ac9ec990 100644
--- a/indra/newview/llfloatermodelpreview.cpp
+++ b/indra/newview/llfloatermodelpreview.cpp
@@ -3972,7 +3972,7 @@ BOOL LLModelPreview::render()
 
 											if (i+1 >= hull_colors.size())
 											{
-												hull_colors.push_back(LLColor4U(rand()%128+127, rand()%128+127, rand()%128+127, 128));
+												hull_colors.emplace_back(rand()%128+127, rand()%128+127, rand()%128+127, 128);
 											}
 
 											gGL.diffuseColor4ubv(hull_colors[i].mV);
diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp
index 81b99eccbf3a618feca7c8bb50b638bd2d884a54..22d8e7d71a559bf18be25cc807b447d4f41d0f4c 100644
--- a/indra/newview/llfloaterpreference.cpp
+++ b/indra/newview/llfloaterpreference.cpp
@@ -2522,8 +2522,8 @@ class LLPanelPreferencePrivacy final : public LLPanelPreference
 public:
 	LLPanelPreferencePrivacy()
 	{
-		mAccountIndependentSettings.push_back("VoiceCallsFriendsOnly");
-		mAccountIndependentSettings.push_back("AutoDisengageMic");
+		mAccountIndependentSettings.emplace_back("VoiceCallsFriendsOnly");
+		mAccountIndependentSettings.emplace_back("AutoDisengageMic");
 	}
 
 	void saveSettings() override
@@ -3045,7 +3045,7 @@ void collectChildren( LLView const *aView, ll::prefs::PanelDataPtr aParentPanel,
 			pCurTabContainer->mPanel = 0;
 
 			if( aParentPanel )
-				aParentPanel->mChildPanel.push_back( pCurTabContainer );
+				aParentPanel->mChildPanel.emplace_back( pCurTabContainer );
 			if( aParentTabContainer )
 				aParentTabContainer->mChildPanel.push_back( pCurTabContainer );
 		}
diff --git a/indra/newview/llglsandbox.cpp b/indra/newview/llglsandbox.cpp
index b03095835e457fb7f7a3e70bd5d355ec6fd342cf..ca10a9f838f67d858c99e469a473936d03545d73 100644
--- a/indra/newview/llglsandbox.cpp
+++ b/indra/newview/llglsandbox.cpp
@@ -981,8 +981,8 @@ F32 gpu_benchmark()
 		gBenchmarkProgram.mName = "Benchmark Shader";
 		gBenchmarkProgram.mFeatures.attachNothing = true;
 		gBenchmarkProgram.mShaderFiles.clear();
-		gBenchmarkProgram.mShaderFiles.push_back(std::make_pair("interface/benchmarkV.glsl", GL_VERTEX_SHADER));
-		gBenchmarkProgram.mShaderFiles.push_back(std::make_pair("interface/benchmarkF.glsl", GL_FRAGMENT_SHADER));
+		gBenchmarkProgram.mShaderFiles.emplace_back("interface/benchmarkV.glsl", GL_VERTEX_SHADER);
+		gBenchmarkProgram.mShaderFiles.emplace_back("interface/benchmarkF.glsl", GL_FRAGMENT_SHADER);
 		gBenchmarkProgram.mShaderLevel = 1;
 		if (!gBenchmarkProgram.createShader(nullptr, nullptr))
 		{
diff --git a/indra/newview/llhudmanager.cpp b/indra/newview/llhudmanager.cpp
index 6fce2acfa4cbd932c980ec9783f4e4c25a639d71..2b7cb006713dd0a4935eb1ab5440dc15524ed5d7 100644
--- a/indra/newview/llhudmanager.cpp
+++ b/indra/newview/llhudmanager.cpp
@@ -141,7 +141,7 @@ LLHUDEffect *LLHUDManager::createViewerEffect(const U8 type, BOOL send_to_sim, B
 	hep->setNeedsSendToSim(send_to_sim);
 	hep->setOriginatedHere(originated_here);
 
-	mHUDEffects.push_back(hep);
+	mHUDEffects.emplace_back(hep);
 	return hep;
 }
 
diff --git a/indra/newview/llhudnametag.cpp b/indra/newview/llhudnametag.cpp
index 83d4ba2ca296225d70cb407dc9e9dc22c0879bb0..e96aced647cdb06f93ac4949d7847651d10fa3de 100644
--- a/indra/newview/llhudnametag.cpp
+++ b/indra/newview/llhudnametag.cpp
@@ -526,7 +526,7 @@ void LLHUDNameTag::updateVisibility()
 	{
 		//LL_WARNS() << "LLHUDNameTag::updateScreenPos -- mSourceObject is NULL!" << LL_ENDL;
 		mVisible = TRUE;
-		sVisibleTextObjects.push_back(LLPointer<LLHUDNameTag> (this));
+		sVisibleTextObjects.emplace_back(this);
 		return;
 	}
 
@@ -593,7 +593,7 @@ void LLHUDNameTag::updateVisibility()
 	}
 
 	mVisible = TRUE;
-	sVisibleTextObjects.push_back(LLPointer<LLHUDNameTag> (this));
+	sVisibleTextObjects.emplace_back(this);
 }
 
 LLVector2 LLHUDNameTag::updateScreenPos(const LLVector2 &offset)
diff --git a/indra/newview/llhudobject.cpp b/indra/newview/llhudobject.cpp
index cda918bb02eef4d25bd4c2e52b1980335e2010b2..a75eec2805eabae862a5547d2033520c99444ee1 100644
--- a/indra/newview/llhudobject.cpp
+++ b/indra/newview/llhudobject.cpp
@@ -150,14 +150,14 @@ LLHUDObject *LLHUDObject::addHUDObject(const U8 type)
 	}
 	if (hud_objectp)
 	{
-		sHUDObjects.push_back(hud_objectp);
+		sHUDObjects.emplace_back(hud_objectp);
 	}
 	return hud_objectp;
 }
 
 LLHUDEffect *LLHUDObject::addHUDEffect(const U8 type)
 {
-	LLHUDEffect *hud_objectp = NULL;
+	LLHUDEffect *hud_objectp = nullptr;
 	
 	switch (type)
 	{
@@ -247,7 +247,7 @@ LLHUDEffect *LLHUDObject::addHUDEffect(const U8 type)
 
 	if (hud_objectp)
 	{
-		sHUDObjects.push_back(hud_objectp);
+		sHUDObjects.emplace_back(hud_objectp);
 	}
 	return hud_objectp;
 }
diff --git a/indra/newview/llhudtext.cpp b/indra/newview/llhudtext.cpp
index b060b6afd7b6e6b96a545e0c78ac798b69c72075..5216b6b1ebdc9f48b554d8e4dab1a5c8e72e761d 100644
--- a/indra/newview/llhudtext.cpp
+++ b/indra/newview/llhudtext.cpp
@@ -317,11 +317,11 @@ void LLHUDText::updateVisibility()
 		mVisible = TRUE;
 		if (mOnHUDAttachment)
 		{
-			sVisibleHUDTextObjects.push_back(LLPointer<LLHUDText> (this));
+			sVisibleHUDTextObjects.emplace_back(LLPointer<LLHUDText> (this));
 		}
 		else
 		{
-			sVisibleTextObjects.push_back(LLPointer<LLHUDText> (this));
+			sVisibleTextObjects.emplace_back(LLPointer<LLHUDText> (this));
 		}
 		return;
 	}
@@ -341,7 +341,7 @@ void LLHUDText::updateVisibility()
 	if (mOnHUDAttachment)
 	{
 		mVisible = TRUE;
-		sVisibleHUDTextObjects.push_back(LLPointer<LLHUDText> (this));
+		sVisibleHUDTextObjects.emplace_back(this);
 		mLastDistance = mPositionAgent.mV[VX];
 		return;
 	}
@@ -421,7 +421,7 @@ void LLHUDText::updateVisibility()
 	}
 
 	mVisible = TRUE;
-	sVisibleTextObjects.push_back(LLPointer<LLHUDText> (this));
+	sVisibleTextObjects.emplace_back(this);
 }
 
 LLVector2 LLHUDText::updateScreenPos(const LLVector2 &offset)
diff --git a/indra/newview/llmeshrepository.cpp b/indra/newview/llmeshrepository.cpp
index be286cfe53a454c6fce7e2f65cf434c85af32688..4be064f4c6227be002567c4d478cdf9573b16eb7 100644
--- a/indra/newview/llmeshrepository.cpp
+++ b/indra/newview/llmeshrepository.cpp
@@ -2030,7 +2030,7 @@ bool LLMeshRepoThread::physicsShapeReceived(const LLUUID& mesh_id, U8* data, S32
 			S32 vertex_count = 0;
 			S32 index_count = 0;
 
-			for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
+			for (auto i = 0; i < volume->getNumVolumeFaces(); ++i)
 			{
 				const LLVolumeFace& face = volume->getVolumeFace(i);
 				vertex_count += face.mNumVertices;
@@ -2042,16 +2042,16 @@ bool LLMeshRepoThread::physicsShapeReceived(const LLUUID& mesh_id, U8* data, S32
 			std::vector<LLVector3>& pos = d->mPhysicsShapeMesh.mPositions;
 			std::vector<LLVector3>& norm = d->mPhysicsShapeMesh.mNormals;
 
-			for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
+			for (auto i = 0; i < volume->getNumVolumeFaces(); ++i)
 			{
 				const LLVolumeFace& face = volume->getVolumeFace(i);
 			
-				for (S32 i = 0; i < face.mNumIndices; ++i)
+				for (auto i = 0; i < face.mNumIndices; ++i)
 				{
 					U16 idx = face.mIndices[i];
 
-					pos.push_back(LLVector3(face.mPositions[idx].getF32ptr()));
-					norm.push_back(LLVector3(face.mNormals[idx].getF32ptr()));				
+					pos.emplace_back(face.mPositions[idx].getF32ptr());
+					norm.emplace_back(face.mNormals[idx].getF32ptr());
 				}			
 			}
 		}
@@ -3654,7 +3654,7 @@ S32 LLMeshRepository::loadMesh(LLVOVolume* vobj, const LLVolumeParams& mesh_para
 		{
 			//first request for this mesh
 			mLoadingMeshes[detail][mesh_params].push_back(vobj);
-			mPendingRequests.push_back(LLMeshRepoThread::LODRequest(mesh_params, detail));
+			mPendingRequests.emplace_back(mesh_params, detail);
 			LLMeshRepository::sLODPending++;
 		}
 	}
@@ -5169,7 +5169,7 @@ void LLPhysicsDecomp::Request::assignData(LLModel* mdl)
 	mBBox[0] = LLVector3(F32_MAX, F32_MAX, F32_MAX) ;
 		
 	//queue up vertex positions and indices
-	for (S32 i = 0; i < mdl->getNumVolumeFaces(); ++i)
+	for (auto i = 0; i < mdl->getNumVolumeFaces(); ++i)
 	{
 		const LLVolumeFace& face = mdl->getVolumeFace(i);
 		if (mPositions.size() + face.mNumVertices > 65535)
@@ -5177,9 +5177,9 @@ void LLPhysicsDecomp::Request::assignData(LLModel* mdl)
 			continue;
 		}
 
-		for (S32 j = 0; j < face.mNumVertices; ++j)
+		for (auto j = 0; j < face.mNumVertices; ++j)
 		{
-			mPositions.push_back(LLVector3(face.mPositions[j].getF32ptr()));
+			mPositions.emplace_back(face.mPositions[j].getF32ptr());
 			for(U32 k = 0 ; k < 3 ; k++)
 			{
 				mBBox[0].mV[k] = llmin(mBBox[0].mV[k], mPositions[j].mV[k]) ;
@@ -5189,7 +5189,7 @@ void LLPhysicsDecomp::Request::assignData(LLModel* mdl)
 
 		updateTriangleAreaThreshold() ;
 
-		for (S32 j = 0; j+2 < face.mNumIndices; j += 3)
+		for (auto j = 0; j+2 < face.mNumIndices; j += 3)
 		{
 			tri[0] = face.mIndices[j] + index_offset ;
 			tri[1] = face.mIndices[j + 1] + index_offset ;
@@ -5205,8 +5205,6 @@ void LLPhysicsDecomp::Request::assignData(LLModel* mdl)
 
 		index_offset += face.mNumVertices;
 	}
-
-	return ;
 }
 
 void LLPhysicsDecomp::Request::updateTriangleAreaThreshold() 
diff --git a/indra/newview/llpanelgroupbulk.cpp b/indra/newview/llpanelgroupbulk.cpp
index b70195d5b59a2ba657385e3c935e5c4a7c7ddaa3..7c4d8a955dc0cca0f3cd72ce0a3bec7feaa34ec3 100644
--- a/indra/newview/llpanelgroupbulk.cpp
+++ b/indra/newview/llpanelgroupbulk.cpp
@@ -386,7 +386,7 @@ void LLPanelGroupBulk::addUsers(uuid_vec_t& agent_ids)
 			else 
 			{
 				LL_WARNS() << "llPanelGroupBulk: Selected avatar has no name: " << dest->getID() << LL_ENDL;
-				names.push_back("(Unknown)");
+				names.emplace_back("(Unknown)");
 			}
 		}
 		else
diff --git a/indra/newview/llpanelgroupinvite.cpp b/indra/newview/llpanelgroupinvite.cpp
index 8cd2fae3573a3cc4d24fb1e0528ab235da7b95ad..9065cbd52873ddae642fefc1a7ae86e65539538f 100644
--- a/indra/newview/llpanelgroupinvite.cpp
+++ b/indra/newview/llpanelgroupinvite.cpp
@@ -494,7 +494,7 @@ void LLPanelGroupInvite::addUsers(uuid_vec_t& agent_ids)
 			else 
 			{
 				LL_WARNS() << "llPanelGroupInvite: Selected avatar has no name: " << dest->getID() << LL_ENDL;
-				names.push_back("(Unknown)");
+				names.emplace_back("(Unknown)");
 			}
 		}
 		else
diff --git a/indra/newview/llpanelobjectinventory.cpp b/indra/newview/llpanelobjectinventory.cpp
index 7adf0a0b9f93f69728d16ad72f73f843b05fe7f4..1051e8dea5eec8f5679b31edfd407c69981f269e 100644
--- a/indra/newview/llpanelobjectinventory.cpp
+++ b/indra/newview/llpanelobjectinventory.cpp
@@ -544,24 +544,24 @@ void LLTaskInvFVBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
 
 	if (canOpenItem())
 	{
-		items.push_back(std::string("Task Open"));
+		items.emplace_back("Task Open");
 	}
-	items.push_back(std::string("Task Properties"));
+	items.emplace_back("Task Properties");
 	if ((flags & FIRST_SELECTED_ITEM) == 0)
 	{
-		disabled_items.push_back(std::string("Task Properties"));
+		disabled_items.emplace_back("Task Properties");
 	}
 	if(isItemRenameable())
 	{
-		items.push_back(std::string("Task Rename"));
+		items.emplace_back("Task Rename");
 		if ((flags & FIRST_SELECTED_ITEM) == 0)
 		{
-			disabled_items.push_back(std::string("Task Rename"));
+			disabled_items.emplace_back("Task Rename");
 		}
 	}
 	if(isItemRemovable())
 	{
-		items.push_back(std::string("Task Remove"));
+		items.emplace_back("Task Remove");
 	}
 
 	hide_context_entries(menu, items, disabled_items);
@@ -841,24 +841,24 @@ void LLTaskSoundBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
 	{
 		if (!isItemCopyable())
 		{
-			disabled_items.push_back(std::string("Task Open"));
+			disabled_items.emplace_back("Task Open");
 		}
 	}
-	items.push_back(std::string("Task Properties"));
+	items.emplace_back("Task Properties");
 	if ((flags & FIRST_SELECTED_ITEM) == 0)
 	{
-		disabled_items.push_back(std::string("Task Properties"));
+		disabled_items.emplace_back("Task Properties");
 	}
 	if(isItemRenameable())
 	{
-		items.push_back(std::string("Task Rename"));
+		items.emplace_back("Task Rename");
 	}
 	if(isItemRemovable())
 	{
-		items.push_back(std::string("Task Remove"));
+		items.emplace_back("Task Remove");
 	}
 
-	items.push_back(std::string("Task Play"));
+	items.emplace_back("Task Play");
 
 
 	hide_context_entries(menu, items, disabled_items);
diff --git a/indra/newview/llplacesinventorybridge.cpp b/indra/newview/llplacesinventorybridge.cpp
index d6b13571b95ae171b3511b0b5a0ee4a46bf5845c..24c38950990a0b170df052e9a36f5acf38df296f 100644
--- a/indra/newview/llplacesinventorybridge.cpp
+++ b/indra/newview/llplacesinventorybridge.cpp
@@ -61,13 +61,13 @@ void LLPlacesLandmarkBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
 
 	if(isItemInTrash())
 	{
-		items.push_back(std::string("Purge Item"));
+		items.emplace_back("Purge Item");
 		if (!isItemRemovable() || (gInventory.getCategory(mUUID) && !gInventory.isCategoryComplete(mUUID)))
 		{
-			disabled_items.push_back(std::string("Purge Item"));
+			disabled_items.emplace_back("Purge Item");
 		}
 
-		items.push_back(std::string("Restore Item"));
+		items.push_back("Restore Item");
 	}
 	else
 	{
diff --git a/indra/newview/llpreviewtexture.cpp b/indra/newview/llpreviewtexture.cpp
index d731ffc41ec48134d8f923b3ade309f7fa1b58e8..ff7051f1534e36bc6629fc5b97836a4f3a7470d3 100644
--- a/indra/newview/llpreviewtexture.cpp
+++ b/indra/newview/llpreviewtexture.cpp
@@ -106,13 +106,13 @@ void LLPreviewTexture::populateRatioList()
 	// Fill in ratios list with common aspect ratio values
 	mRatiosList.clear();
 	mRatiosList.push_back(LLTrans::getString("Unconstrained"));
-	mRatiosList.push_back("1:1");
-	mRatiosList.push_back("4:3");
-	mRatiosList.push_back("10:7");
-	mRatiosList.push_back("3:2");
-	mRatiosList.push_back("16:10");
-	mRatiosList.push_back("16:9");
-	mRatiosList.push_back("2:1");
+	mRatiosList.emplace_back("1:1");
+	mRatiosList.emplace_back("4:3");
+	mRatiosList.emplace_back("10:7");
+	mRatiosList.emplace_back("3:2");
+	mRatiosList.emplace_back("16:10");
+	mRatiosList.emplace_back("16:9");
+	mRatiosList.emplace_back("2:1");
 	
 	// Now fill combo box with provided list
 	LLComboBox* combo = getChild<LLComboBox>("combo_aspect_ratio");
diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp
index 51c3ade526cde84c8793533a8131a01a7149ab6e..d35456289ea3f3729bdb460c314aed08ab792fea 100644
--- a/indra/newview/llspatialpartition.cpp
+++ b/indra/newview/llspatialpartition.cpp
@@ -2362,7 +2362,7 @@ void renderPhysicsShape(LLDrawable* drawable, LLVOVolume* volume)
 
 					for (S32 j = 0; j < face.mNumVertices; ++j)
 					{
-						pos.push_back(LLVector3(face.mPositions[j].getF32ptr()));
+						pos.emplace_back(face.mPositions[j].getF32ptr());
 					}
 
 					for (S32 j = 0; j < face.mNumIndices; ++j)
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 0cbf22cb9de43e77ddb65bff8d562c014c140ec7..9714f54a0c39d03ad8bc49dcb0c2afc3d1fd61b3 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -4725,7 +4725,7 @@ void LLTextureFetchDebugger::debugGLTextureCreation()
                 if (tex && !tex->isForSculptOnly())
                 {
                     tex->destroyGLTexture();
-                    mTempTexList.push_back(tex);
+                    mTempTexList.emplace_back(tex);
                 }
             }
 		}
diff --git a/indra/newview/lltoastnotifypanel.cpp b/indra/newview/lltoastnotifypanel.cpp
index c86f93df507338261c83cf1e86bc8f9345ec57bb..e3693c331316a1f710f3378fa6fde54c30f548c8 100644
--- a/indra/newview/lltoastnotifypanel.cpp
+++ b/indra/newview/lltoastnotifypanel.cpp
@@ -353,7 +353,7 @@ void LLToastNotifyPanel::init( LLRect rect, bool show_images )
             LLButton* new_button = createButton(form_element, TRUE);
             buttons_width += new_button->getRect().getWidth();
             S32 index = form_element["index"].asInteger();
-            buttons.push_back(index_button_pair_t(index,new_button));
+            buttons.emplace_back(index,new_button);
         }
         if (buttons.empty())
         {
diff --git a/indra/newview/llviewerobjectlist.cpp b/indra/newview/llviewerobjectlist.cpp
index 67edc53ae675259716cffbd20d87944117e90126..23d5cada5783c235c1e78ec4c6cdabcd38736669 100644
--- a/indra/newview/llviewerobjectlist.cpp
+++ b/indra/newview/llviewerobjectlist.cpp
@@ -1539,7 +1539,7 @@ void LLViewerObjectList::updateActive(LLViewerObject *objectp)
 			S32 idx = objectp->getListIndex();
 			if (idx <= -1)
 			{
-				mActiveObjects.push_back(objectp);
+				mActiveObjects.emplace_back(objectp);
 				objectp->setListIndex(mActiveObjects.size()-1);
 			objectp->setOnActiveList(TRUE);
 		}
diff --git a/indra/newview/llviewerparceloverlay.cpp b/indra/newview/llviewerparceloverlay.cpp
index 5f14d8ace3f702b7953acb463819d6ac08341d66..41ab4ae050afe10bd71551074a35f0bf7b0f1945 100644
--- a/indra/newview/llviewerparceloverlay.cpp
+++ b/indra/newview/llviewerparceloverlay.cpp
@@ -755,8 +755,8 @@ void LLViewerParcelOverlay::addPropertyLine(
 	if (outside_z > 20.f) color_array.push_back( color );
 	else color_array.push_back( underwater );
 
-	vertex_array.push_back( LLVector3(outside_x, outside_y, outside_z) );
-	coord_array.push_back(  LLVector2(outside_x - start_x, 0.f) );
+	vertex_array.emplace_back(outside_x, outside_y, outside_z);
+	coord_array.emplace_back(outside_x - start_x, 0.f);
 
 	inside_x += dx * LINE_WIDTH;
 	inside_y += dy * LINE_WIDTH;
@@ -774,11 +774,11 @@ void LLViewerParcelOverlay::addPropertyLine(
 	if (outside_z > 20.f) color_array.push_back( color );
 	else color_array.push_back( underwater );
 
-	vertex_array.push_back( LLVector3(inside_x, inside_y, inside_z) );
-	vertex_array.push_back( LLVector3(outside_x, outside_y, outside_z) );
+	vertex_array.emplace_back(inside_x, inside_y, inside_z);
+	vertex_array.emplace_back(outside_x, outside_y, outside_z);
 
-	coord_array.push_back(  LLVector2(outside_x - start_x, 1.f) );
-	coord_array.push_back(  LLVector2(outside_x - start_x, 0.f) );
+	coord_array.emplace_back(outside_x - start_x, 1.f);
+	coord_array.emplace_back(outside_x - start_x, 0.f);
 
 	inside_x += dx * (dx - LINE_WIDTH);
 	inside_y += dy * (dy - LINE_WIDTH);
@@ -800,11 +800,11 @@ void LLViewerParcelOverlay::addPropertyLine(
 		if (outside_z > 20.f) color_array.push_back( color );
 		else color_array.push_back( underwater );
 
-		vertex_array.push_back( LLVector3(inside_x, inside_y, inside_z) );
-		vertex_array.push_back( LLVector3(outside_x, outside_y, outside_z) );
+		vertex_array.emplace_back(inside_x, inside_y, inside_z);
+		vertex_array.emplace_back(outside_x, outside_y, outside_z);
 
-		coord_array.push_back(  LLVector2(outside_x - start_x, 1.f) );
-		coord_array.push_back(  LLVector2(outside_x - start_x, 0.f) );
+		coord_array.emplace_back(outside_x - start_x, 1.f);
+		coord_array.emplace_back(outside_x - start_x, 0.f);
 
 		inside_x += dx;
 		inside_y += dy;
@@ -829,11 +829,11 @@ void LLViewerParcelOverlay::addPropertyLine(
 	if (outside_z > 20.f) color_array.push_back( color );
 	else color_array.push_back( underwater );
 
-	vertex_array.push_back( LLVector3(inside_x, inside_y, inside_z) );
-	vertex_array.push_back( LLVector3(outside_x, outside_y, outside_z) );
+	vertex_array.emplace_back(inside_x, inside_y, inside_z);
+	vertex_array.emplace_back(outside_x, outside_y, outside_z);
 
-	coord_array.push_back(  LLVector2(outside_x - start_x, 1.f) );
-	coord_array.push_back(  LLVector2(outside_x - start_x, 0.f) );
+	coord_array.emplace_back(outside_x - start_x, 1.f);
+	coord_array.emplace_back(outside_x - start_x, 0.f);
 
 	inside_x += dx * LINE_WIDTH;
 	inside_y += dy * LINE_WIDTH;
@@ -847,8 +847,8 @@ void LLViewerParcelOverlay::addPropertyLine(
 	if (outside_z > 20.f) color_array.push_back( color );
 	else color_array.push_back( underwater );
 
-	vertex_array.push_back( LLVector3(outside_x, outside_y, outside_z) );
-	coord_array.push_back(  LLVector2(outside_x - start_x, 0.f) );
+	vertex_array.emplace_back(outside_x, outside_y, outside_z);
+	coord_array.emplace_back(outside_x - start_x, 0.f);
 }
 
 
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 10ea51535df211b3f3f0ac46e3a63f7069b5219e..93cdf217b2c965a10d83e84961bbafa007d10353 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -30,7 +30,6 @@
 #include "llfeaturemanager.h"
 #include "llviewershadermgr.h"
 
-#include "llfile.h"
 #include "llviewerwindow.h"
 #include "llwindow.h"
 #include "llviewercontrol.h"
@@ -41,7 +40,6 @@
 #include "llsky.h"
 #include "llvosky.h"
 #include "llrender.h"
-#include "lljoint.h"
 #include "llskinningutil.h"
 
 static LLStaticHashedString sTexture0("texture0");
@@ -816,23 +814,23 @@ BOOL LLViewerShaderMgr::loadBasicShaders()
 	// (in order of shader function call depth for reference purposes, deepest level first)
 
 	std::vector< std::pair<std::string, S32> > shaders;
-	shaders.push_back( std::make_pair( "windlight/atmosphericsVarsV.glsl",		mVertexShaderLevel[SHADER_WINDLIGHT] ) );
-	shaders.push_back( std::make_pair( "windlight/atmosphericsVarsWaterV.glsl",	mVertexShaderLevel[SHADER_WINDLIGHT] ) );
-	shaders.push_back( std::make_pair( "windlight/atmosphericsHelpersV.glsl",	mVertexShaderLevel[SHADER_WINDLIGHT] ) );
-	shaders.push_back( std::make_pair( "lighting/lightFuncV.glsl",				mVertexShaderLevel[SHADER_LIGHTING] ) );
-	shaders.push_back( std::make_pair( "lighting/sumLightsV.glsl",				sum_lights_class ) );
-	shaders.push_back( std::make_pair( "lighting/lightV.glsl",					mVertexShaderLevel[SHADER_LIGHTING] ) );
-	shaders.push_back( std::make_pair( "lighting/lightFuncSpecularV.glsl",		mVertexShaderLevel[SHADER_LIGHTING] ) );
+	shaders.emplace_back( "windlight/atmosphericsVarsV.glsl",		mVertexShaderLevel[SHADER_WINDLIGHT]);
+	shaders.emplace_back( "windlight/atmosphericsVarsWaterV.glsl",	mVertexShaderLevel[SHADER_WINDLIGHT]);
+	shaders.emplace_back( "windlight/atmosphericsHelpersV.glsl",	mVertexShaderLevel[SHADER_WINDLIGHT]);
+	shaders.emplace_back( "lighting/lightFuncV.glsl",				mVertexShaderLevel[SHADER_LIGHTING]);
+	shaders.emplace_back( "lighting/sumLightsV.glsl",				sum_lights_class);
+	shaders.emplace_back( "lighting/lightV.glsl",					mVertexShaderLevel[SHADER_LIGHTING]);
+	shaders.emplace_back( "lighting/lightFuncSpecularV.glsl",		mVertexShaderLevel[SHADER_LIGHTING]);
 	shaders.push_back( std::make_pair( "lighting/sumLightsSpecularV.glsl",		sum_lights_class ) );
 	shaders.push_back( std::make_pair( "lighting/lightSpecularV.glsl",			mVertexShaderLevel[SHADER_LIGHTING] ) );
-	shaders.push_back( std::make_pair( "windlight/atmosphericsV.glsl",			mVertexShaderLevel[SHADER_WINDLIGHT] ) );
-	shaders.push_back( std::make_pair( "avatar/avatarSkinV.glsl",				1 ) );
-	shaders.push_back( std::make_pair( "avatar/objectSkinV.glsl",				1 ) );
+	shaders.emplace_back( "windlight/atmosphericsV.glsl",			mVertexShaderLevel[SHADER_WINDLIGHT]);
+	shaders.emplace_back( "avatar/avatarSkinV.glsl",				1);
+	shaders.emplace_back( "avatar/objectSkinV.glsl",				1);
 	if (gGLManager.mGLSLVersionMajor >= 2 || gGLManager.mGLSLVersionMinor >= 30)
 	{
-		shaders.push_back( std::make_pair( "objects/indexedTextureV.glsl",			1 ) );
+		shaders.emplace_back( "objects/indexedTextureV.glsl",			1);
 	}
-	shaders.push_back( std::make_pair( "objects/nonindexedTextureV.glsl",		1 ) );
+	shaders.emplace_back( "objects/nonindexedTextureV.glsl",		1);
 
 	boost::unordered_map<std::string, std::string> attribs;
 	attribs["MAX_JOINTS_PER_MESH_OBJECT"] = fmt::to_string(LLSkinningUtil::getMaxJointCount());
@@ -859,36 +857,36 @@ BOOL LLViewerShaderMgr::loadBasicShaders()
 	}
 
 	std::vector<S32> index_channels;
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "windlight/atmosphericsVarsF.glsl",		mVertexShaderLevel[SHADER_WINDLIGHT] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "windlight/atmosphericsVarsWaterF.glsl",		mVertexShaderLevel[SHADER_WINDLIGHT] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "windlight/gammaF.glsl",					mVertexShaderLevel[SHADER_WINDLIGHT]) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "windlight/atmosphericsF.glsl",			mVertexShaderLevel[SHADER_WINDLIGHT] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "windlight/transportF.glsl",				mVertexShaderLevel[SHADER_WINDLIGHT] ) );	
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "environment/waterFogF.glsl",				mVertexShaderLevel[SHADER_WATER] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightNonIndexedF.glsl",					mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightAlphaMaskNonIndexedF.glsl",					mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightNonIndexedF.glsl",			mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightNonIndexedAlphaMaskF.glsl",			mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightWaterNonIndexedF.glsl",				mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightWaterAlphaMaskNonIndexedF.glsl",				mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightWaterNonIndexedF.glsl",	mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightWaterNonIndexedAlphaMaskF.glsl",	mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightShinyNonIndexedF.glsl",				mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightShinyNonIndexedF.glsl",	mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightShinyWaterNonIndexedF.glsl",			mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(-1);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightShinyWaterNonIndexedF.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightF.glsl",					mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightAlphaMaskF.glsl",					mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightF.glsl",			mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightAlphaMaskF.glsl",			mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightWaterF.glsl",				mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightWaterAlphaMaskF.glsl",	mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightWaterF.glsl",	mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightWaterAlphaMaskF.glsl",	mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightShinyF.glsl",				mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightShinyF.glsl",	mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightShinyWaterF.glsl",			mVertexShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);	 shaders.push_back( std::make_pair( "lighting/lightFullbrightShinyWaterF.glsl", mVertexShaderLevel[SHADER_LIGHTING] ) );
+	index_channels.push_back(-1);	 shaders.emplace_back( "windlight/atmosphericsVarsF.glsl",		mVertexShaderLevel[SHADER_WINDLIGHT]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "windlight/atmosphericsVarsWaterF.glsl",		mVertexShaderLevel[SHADER_WINDLIGHT]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "windlight/gammaF.glsl",					mVertexShaderLevel[SHADER_WINDLIGHT]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "windlight/atmosphericsF.glsl",			mVertexShaderLevel[SHADER_WINDLIGHT]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "windlight/transportF.glsl",				mVertexShaderLevel[SHADER_WINDLIGHT]);	
+	index_channels.push_back(-1);	 shaders.emplace_back( "environment/waterFogF.glsl",				mVertexShaderLevel[SHADER_WATER]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightNonIndexedF.glsl",					mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightAlphaMaskNonIndexedF.glsl",					mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightFullbrightNonIndexedF.glsl",			mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightFullbrightNonIndexedAlphaMaskF.glsl",			mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightWaterNonIndexedF.glsl",				mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightWaterAlphaMaskNonIndexedF.glsl",				mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightFullbrightWaterNonIndexedF.glsl",	mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightFullbrightWaterNonIndexedAlphaMaskF.glsl",	mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightShinyNonIndexedF.glsl",				mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightFullbrightShinyNonIndexedF.glsl",	mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightShinyWaterNonIndexedF.glsl",			mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(-1);	 shaders.emplace_back( "lighting/lightFullbrightShinyWaterNonIndexedF.glsl", mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightF.glsl",					mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightAlphaMaskF.glsl",					mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightFullbrightF.glsl",			mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightFullbrightAlphaMaskF.glsl",			mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightWaterF.glsl",				mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightWaterAlphaMaskF.glsl",	mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightFullbrightWaterF.glsl",	mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightFullbrightWaterAlphaMaskF.glsl",	mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightShinyF.glsl",				mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightFullbrightShinyF.glsl",	mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightShinyWaterF.glsl",			mVertexShaderLevel[SHADER_LIGHTING]);
+	index_channels.push_back(ch);	 shaders.emplace_back( "lighting/lightFullbrightShinyWaterF.glsl", mVertexShaderLevel[SHADER_LIGHTING]);
 	
 	for (U32 i = 0; i < shaders.size(); i++)
 	{
@@ -922,8 +920,8 @@ BOOL LLViewerShaderMgr::loadShadersEnvironment()
 		gTerrainProgram.mFeatures.disableTextureIndex = true;
 		gTerrainProgram.mFeatures.hasGamma = true;
 		gTerrainProgram.mShaderFiles.clear();
-		gTerrainProgram.mShaderFiles.push_back(std::make_pair("environment/terrainV.glsl", GL_VERTEX_SHADER));
-		gTerrainProgram.mShaderFiles.push_back(std::make_pair("environment/terrainF.glsl", GL_FRAGMENT_SHADER));
+		gTerrainProgram.mShaderFiles.emplace_back("environment/terrainV.glsl", GL_VERTEX_SHADER);
+		gTerrainProgram.mShaderFiles.emplace_back("environment/terrainF.glsl", GL_FRAGMENT_SHADER);
 		gTerrainProgram.mShaderLevel = mVertexShaderLevel[SHADER_ENVIRONMENT];
 		success = gTerrainProgram.createShader(nullptr, nullptr);
 	}
@@ -960,8 +958,8 @@ BOOL LLViewerShaderMgr::loadShadersWater()
 		gWaterProgram.mFeatures.hasGamma = true;
 		gWaterProgram.mFeatures.hasTransport = true;
 		gWaterProgram.mShaderFiles.clear();
-		gWaterProgram.mShaderFiles.push_back(std::make_pair("environment/waterV.glsl", GL_VERTEX_SHADER));
-		gWaterProgram.mShaderFiles.push_back(std::make_pair("environment/waterF.glsl", GL_FRAGMENT_SHADER));
+		gWaterProgram.mShaderFiles.emplace_back("environment/waterV.glsl", GL_VERTEX_SHADER);
+		gWaterProgram.mShaderFiles.emplace_back("environment/waterF.glsl", GL_FRAGMENT_SHADER);
 		gWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_WATER];
 		success = gWaterProgram.createShader(nullptr, nullptr);
 	}
@@ -972,8 +970,8 @@ BOOL LLViewerShaderMgr::loadShadersWater()
 		gUnderWaterProgram.mName = "Underwater Shader";
 		gUnderWaterProgram.mFeatures.calculatesAtmospherics = true;
 		gUnderWaterProgram.mShaderFiles.clear();
-		gUnderWaterProgram.mShaderFiles.push_back(std::make_pair("environment/waterV.glsl", GL_VERTEX_SHADER));
-		gUnderWaterProgram.mShaderFiles.push_back(std::make_pair("environment/underWaterF.glsl", GL_FRAGMENT_SHADER));
+		gUnderWaterProgram.mShaderFiles.emplace_back("environment/waterV.glsl", GL_VERTEX_SHADER);
+		gUnderWaterProgram.mShaderFiles.emplace_back("environment/underWaterF.glsl", GL_FRAGMENT_SHADER);
 		gUnderWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_WATER];
 		gUnderWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		
@@ -991,8 +989,8 @@ BOOL LLViewerShaderMgr::loadShadersWater()
 		gTerrainWaterProgram.mFeatures.mIndexedTextureChannels = 0;
 		gTerrainWaterProgram.mFeatures.disableTextureIndex = true;
 		gTerrainWaterProgram.mShaderFiles.clear();
-		gTerrainWaterProgram.mShaderFiles.push_back(std::make_pair("environment/terrainV.glsl", GL_VERTEX_SHADER));
-		gTerrainWaterProgram.mShaderFiles.push_back(std::make_pair("environment/terrainWaterF.glsl", GL_FRAGMENT_SHADER));
+		gTerrainWaterProgram.mShaderFiles.emplace_back("environment/terrainV.glsl", GL_VERTEX_SHADER);
+		gTerrainWaterProgram.mShaderFiles.emplace_back("environment/terrainWaterF.glsl", GL_FRAGMENT_SHADER);
 		gTerrainWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_ENVIRONMENT];
 		gTerrainWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		terrainWaterSuccess = gTerrainWaterProgram.createShader(nullptr, nullptr);
@@ -1039,8 +1037,8 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 	{
 		gGlowProgram.mName = "Glow Shader (Post)";
 		gGlowProgram.mShaderFiles.clear();
-		gGlowProgram.mShaderFiles.push_back(std::make_pair("effects/glowV.glsl", GL_VERTEX_SHADER));
-		gGlowProgram.mShaderFiles.push_back(std::make_pair("effects/glowF.glsl", GL_FRAGMENT_SHADER));
+		gGlowProgram.mShaderFiles.emplace_back("effects/glowV.glsl", GL_VERTEX_SHADER);
+		gGlowProgram.mShaderFiles.emplace_back("effects/glowF.glsl", GL_FRAGMENT_SHADER);
 		gGlowProgram.mShaderLevel = mVertexShaderLevel[SHADER_EFFECT];
 		success = gGlowProgram.createShader(nullptr, nullptr);
 		if (!success)
@@ -1053,8 +1051,8 @@ BOOL LLViewerShaderMgr::loadShadersEffects()
 	{
 		gGlowExtractProgram.mName = "Glow Extract Shader (Post)";
 		gGlowExtractProgram.mShaderFiles.clear();
-		gGlowExtractProgram.mShaderFiles.push_back(std::make_pair("effects/glowExtractV.glsl", GL_VERTEX_SHADER));
-		gGlowExtractProgram.mShaderFiles.push_back(std::make_pair("effects/glowExtractF.glsl", GL_FRAGMENT_SHADER));
+		gGlowExtractProgram.mShaderFiles.emplace_back("effects/glowExtractV.glsl", GL_VERTEX_SHADER);
+		gGlowExtractProgram.mShaderFiles.emplace_back("effects/glowExtractF.glsl", GL_FRAGMENT_SHADER);
 		gGlowExtractProgram.mShaderLevel = mVertexShaderLevel[SHADER_EFFECT];
 		success = gGlowExtractProgram.createShader(nullptr, nullptr);
 		if (!success)
@@ -1145,8 +1143,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredHighlightProgram.mName = "Deferred Highlight Shader";
 		gDeferredHighlightProgram.mShaderFiles.clear();
-		gDeferredHighlightProgram.mShaderFiles.push_back(std::make_pair("interface/highlightV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredHighlightProgram.mShaderFiles.push_back(std::make_pair("deferred/highlightF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredHighlightProgram.mShaderFiles.emplace_back("interface/highlightV.glsl", GL_VERTEX_SHADER_ARB);
+		gDeferredHighlightProgram.mShaderFiles.emplace_back("deferred/highlightF.glsl", GL_FRAGMENT_SHADER_ARB);
 		gDeferredHighlightProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];		
 		success = gDeferredHighlightProgram.createShader(NULL, NULL);
 	}
@@ -1155,8 +1153,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredHighlightNormalProgram.mName = "Deferred Highlight Normals Shader";
 		gDeferredHighlightNormalProgram.mShaderFiles.clear();
-		gDeferredHighlightNormalProgram.mShaderFiles.push_back(std::make_pair("interface/highlightNormV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredHighlightNormalProgram.mShaderFiles.push_back(std::make_pair("deferred/highlightF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredHighlightNormalProgram.mShaderFiles.emplace_back("interface/highlightNormV.glsl", GL_VERTEX_SHADER_ARB);
+		gDeferredHighlightNormalProgram.mShaderFiles.emplace_back("deferred/highlightF.glsl", GL_FRAGMENT_SHADER_ARB);
 		gDeferredHighlightNormalProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];		
 		success = gDeferredHighlightNormalProgram.createShader(NULL, NULL);
 	}
@@ -1165,8 +1163,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredHighlightSpecularProgram.mName = "Deferred Highlight Spec Shader";
 		gDeferredHighlightSpecularProgram.mShaderFiles.clear();
-		gDeferredHighlightSpecularProgram.mShaderFiles.push_back(std::make_pair("interface/highlightSpecV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredHighlightSpecularProgram.mShaderFiles.push_back(std::make_pair("deferred/highlightF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredHighlightSpecularProgram.mShaderFiles.emplace_back("interface/highlightSpecV.glsl", GL_VERTEX_SHADER_ARB);
+		gDeferredHighlightSpecularProgram.mShaderFiles.emplace_back("deferred/highlightF.glsl", GL_FRAGMENT_SHADER_ARB);
 		gDeferredHighlightSpecularProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];		
 		success = gDeferredHighlightSpecularProgram.createShader(NULL, NULL);
 	}
@@ -1175,8 +1173,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredDiffuseProgram.mName = "Deferred Diffuse Shader";
 		gDeferredDiffuseProgram.mShaderFiles.clear();
-		gDeferredDiffuseProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER));
-		gDeferredDiffuseProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseIndexedF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredDiffuseProgram.mShaderFiles.emplace_back("deferred/diffuseV.glsl", GL_VERTEX_SHADER);
+		gDeferredDiffuseProgram.mShaderFiles.emplace_back("deferred/diffuseIndexedF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredDiffuseProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
 		gDeferredDiffuseProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredDiffuseProgram.createShader(nullptr, nullptr);
@@ -1186,8 +1184,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredDiffuseAlphaMaskProgram.mName = "Deferred Diffuse Alpha Mask Shader";
 		gDeferredDiffuseAlphaMaskProgram.mShaderFiles.clear();
-		gDeferredDiffuseAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER));
-		gDeferredDiffuseAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseAlphaMaskIndexedF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredDiffuseAlphaMaskProgram.mShaderFiles.emplace_back("deferred/diffuseV.glsl", GL_VERTEX_SHADER);
+		gDeferredDiffuseAlphaMaskProgram.mShaderFiles.emplace_back("deferred/diffuseAlphaMaskIndexedF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredDiffuseAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
 		gDeferredDiffuseAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredDiffuseAlphaMaskProgram.createShader(nullptr, nullptr);
@@ -1197,8 +1195,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredNonIndexedDiffuseAlphaMaskProgram.mName = "Deferred Diffuse Non-Indexed Alpha Mask Shader";
 		gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.clear();
-		gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER));
-		gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseAlphaMaskF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.emplace_back("deferred/diffuseV.glsl", GL_VERTEX_SHADER);
+		gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderFiles.emplace_back("deferred/diffuseAlphaMaskF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredNonIndexedDiffuseAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredNonIndexedDiffuseAlphaMaskProgram.createShader(nullptr, nullptr);
 	}
@@ -1207,8 +1205,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mName = "Deferred Diffuse Non-Indexed No Color Alpha Mask Shader";
 		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.clear();
-		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseNoColorV.glsl", GL_VERTEX_SHADER));
-		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseAlphaMaskNoColorF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.emplace_back("deferred/diffuseNoColorV.glsl", GL_VERTEX_SHADER);
+		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderFiles.emplace_back("deferred/diffuseAlphaMaskNoColorF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredNonIndexedDiffuseAlphaMaskNoColorProgram.createShader(nullptr, nullptr);
 	}
@@ -1217,8 +1215,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredNonIndexedDiffuseProgram.mName = "Non Indexed Deferred Diffuse Shader";
 		gDeferredNonIndexedDiffuseProgram.mShaderFiles.clear();
-		gDeferredNonIndexedDiffuseProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseV.glsl", GL_VERTEX_SHADER));
-		gDeferredNonIndexedDiffuseProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredNonIndexedDiffuseProgram.mShaderFiles.emplace_back("deferred/diffuseV.glsl", GL_VERTEX_SHADER);
+		gDeferredNonIndexedDiffuseProgram.mShaderFiles.emplace_back("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredNonIndexedDiffuseProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredNonIndexedDiffuseProgram.createShader(nullptr, nullptr);
 	}
@@ -1229,8 +1227,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredSkinnedDiffuseProgram.mName = "Deferred Skinned Diffuse Shader";
 		gDeferredSkinnedDiffuseProgram.mFeatures.hasObjectSkinning = true;
 		gDeferredSkinnedDiffuseProgram.mShaderFiles.clear();
-		gDeferredSkinnedDiffuseProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseSkinnedV.glsl", GL_VERTEX_SHADER));
-		gDeferredSkinnedDiffuseProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredSkinnedDiffuseProgram.mShaderFiles.emplace_back("deferred/diffuseSkinnedV.glsl", GL_VERTEX_SHADER);
+		gDeferredSkinnedDiffuseProgram.mShaderFiles.emplace_back("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredSkinnedDiffuseProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredSkinnedDiffuseProgram.createShader(nullptr, nullptr);
 	}
@@ -1240,8 +1238,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredSkinnedBumpProgram.mName = "Deferred Skinned Bump Shader";
 		gDeferredSkinnedBumpProgram.mFeatures.hasObjectSkinning = true;
 		gDeferredSkinnedBumpProgram.mShaderFiles.clear();
-		gDeferredSkinnedBumpProgram.mShaderFiles.push_back(std::make_pair("deferred/bumpSkinnedV.glsl", GL_VERTEX_SHADER));
-		gDeferredSkinnedBumpProgram.mShaderFiles.push_back(std::make_pair("deferred/bumpF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredSkinnedBumpProgram.mShaderFiles.emplace_back("deferred/bumpSkinnedV.glsl", GL_VERTEX_SHADER);
+		gDeferredSkinnedBumpProgram.mShaderFiles.emplace_back("deferred/bumpF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredSkinnedBumpProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredSkinnedBumpProgram.createShader(nullptr, nullptr);
 	}
@@ -1255,8 +1253,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredSkinnedAlphaProgram.mFeatures.isAlphaLighting = true;
 		gDeferredSkinnedAlphaProgram.mFeatures.disableTextureIndex = true;
 		gDeferredSkinnedAlphaProgram.mShaderFiles.clear();
-		gDeferredSkinnedAlphaProgram.mShaderFiles.push_back(std::make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER));
-		gDeferredSkinnedAlphaProgram.mShaderFiles.push_back(std::make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredSkinnedAlphaProgram.mShaderFiles.emplace_back("deferred/alphaV.glsl", GL_VERTEX_SHADER);
+		gDeferredSkinnedAlphaProgram.mShaderFiles.emplace_back("deferred/alphaF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredSkinnedAlphaProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredSkinnedAlphaProgram.addPermutation("USE_DIFFUSE_TEX", "1");
 		gDeferredSkinnedAlphaProgram.addPermutation("HAS_SKIN", "1");
@@ -1273,8 +1271,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredBumpProgram.mName = "Deferred Bump Shader";
 		gDeferredBumpProgram.mShaderFiles.clear();
-		gDeferredBumpProgram.mShaderFiles.push_back(std::make_pair("deferred/bumpV.glsl", GL_VERTEX_SHADER));
-		gDeferredBumpProgram.mShaderFiles.push_back(std::make_pair("deferred/bumpF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredBumpProgram.mShaderFiles.emplace_back("deferred/bumpV.glsl", GL_VERTEX_SHADER);
+		gDeferredBumpProgram.mShaderFiles.emplace_back("deferred/bumpF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredBumpProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredBumpProgram.createShader(nullptr, nullptr);
 	}
@@ -1306,8 +1304,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 			U32 alpha_mode = i & 0x3;
 
 			gDeferredMaterialProgram[i].mShaderFiles.clear();
-			gDeferredMaterialProgram[i].mShaderFiles.push_back(std::make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER));
-			gDeferredMaterialProgram[i].mShaderFiles.push_back(std::make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER));
+			gDeferredMaterialProgram[i].mShaderFiles.emplace_back("deferred/materialV.glsl", GL_VERTEX_SHADER);
+			gDeferredMaterialProgram[i].mShaderFiles.emplace_back("deferred/materialF.glsl", GL_FRAGMENT_SHADER);
 			gDeferredMaterialProgram[i].mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 			gDeferredMaterialProgram[i].addPermutation("HAS_NORMAL_MAP", i & 0x8? "1" : "0");
 			gDeferredMaterialProgram[i].addPermutation("HAS_SPECULAR_MAP", i & 0x4 ? "1" : "0");
@@ -1331,8 +1329,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 			U32 alpha_mode = i & 0x3;
 
 			gDeferredMaterialWaterProgram[i].mShaderFiles.clear();
-			gDeferredMaterialWaterProgram[i].mShaderFiles.push_back(std::make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER));
-			gDeferredMaterialWaterProgram[i].mShaderFiles.push_back(std::make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER));
+			gDeferredMaterialWaterProgram[i].mShaderFiles.emplace_back("deferred/materialV.glsl", GL_VERTEX_SHADER);
+			gDeferredMaterialWaterProgram[i].mShaderFiles.emplace_back("deferred/materialF.glsl", GL_FRAGMENT_SHADER);
 			gDeferredMaterialWaterProgram[i].mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 			gDeferredMaterialWaterProgram[i].mShaderGroup = LLGLSLShader::SG_WATER;
 
@@ -1376,8 +1374,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredTreeProgram.mName = "Deferred Tree Shader";
 		gDeferredTreeProgram.mShaderFiles.clear();
-		gDeferredTreeProgram.mShaderFiles.push_back(std::make_pair("deferred/treeV.glsl", GL_VERTEX_SHADER));
-		gDeferredTreeProgram.mShaderFiles.push_back(std::make_pair("deferred/treeF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredTreeProgram.mShaderFiles.emplace_back("deferred/treeV.glsl", GL_VERTEX_SHADER);
+		gDeferredTreeProgram.mShaderFiles.emplace_back("deferred/treeF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredTreeProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredTreeProgram.createShader(nullptr, nullptr);
 	}
@@ -1386,8 +1384,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredTreeShadowProgram.mName = "Deferred Tree Shadow Shader";
 		gDeferredTreeShadowProgram.mShaderFiles.clear();
-		gDeferredTreeShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/treeShadowV.glsl", GL_VERTEX_SHADER));
-		gDeferredTreeShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/treeShadowF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredTreeShadowProgram.mShaderFiles.emplace_back("deferred/treeShadowV.glsl", GL_VERTEX_SHADER);
+		gDeferredTreeShadowProgram.mShaderFiles.emplace_back("deferred/treeShadowF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredTreeShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredTreeShadowProgram.addPermutation("DEPTH_CLAMP", /*gGLManager.mHasDepthClamp ? "1" :*/ "0");
 		success = gDeferredTreeShadowProgram.createShader(nullptr, nullptr);
@@ -1397,8 +1395,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredImpostorProgram.mName = "Deferred Impostor Shader";
 		gDeferredImpostorProgram.mShaderFiles.clear();
-		gDeferredImpostorProgram.mShaderFiles.push_back(std::make_pair("deferred/impostorV.glsl", GL_VERTEX_SHADER));
-		gDeferredImpostorProgram.mShaderFiles.push_back(std::make_pair("deferred/impostorF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredImpostorProgram.mShaderFiles.emplace_back("deferred/impostorV.glsl", GL_VERTEX_SHADER);
+		gDeferredImpostorProgram.mShaderFiles.emplace_back("deferred/impostorF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredImpostorProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredImpostorProgram.createShader(nullptr, nullptr);
 	}
@@ -1407,8 +1405,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{		
 		gDeferredLightProgram.mName = "Deferred Light Shader";
 		gDeferredLightProgram.mShaderFiles.clear();
-		gDeferredLightProgram.mShaderFiles.push_back(std::make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER));
-		gDeferredLightProgram.mShaderFiles.push_back(std::make_pair("deferred/pointLightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredLightProgram.mShaderFiles.emplace_back("deferred/pointLightV.glsl", GL_VERTEX_SHADER);
+		gDeferredLightProgram.mShaderFiles.emplace_back("deferred/pointLightF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredLightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 
 		success = gDeferredLightProgram.createShader(nullptr, nullptr);
@@ -1420,8 +1418,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 			gDeferredMultiLightProgram[i].mName = llformat("Deferred MultiLight Shader %d", i);
 			gDeferredMultiLightProgram[i].mShaderFiles.clear();
-			gDeferredMultiLightProgram[i].mShaderFiles.push_back(std::make_pair("deferred/multiPointLightV.glsl", GL_VERTEX_SHADER));
-			gDeferredMultiLightProgram[i].mShaderFiles.push_back(std::make_pair("deferred/multiPointLightF.glsl", GL_FRAGMENT_SHADER));
+			gDeferredMultiLightProgram[i].mShaderFiles.emplace_back("deferred/multiPointLightV.glsl", GL_VERTEX_SHADER);
+			gDeferredMultiLightProgram[i].mShaderFiles.emplace_back("deferred/multiPointLightF.glsl", GL_FRAGMENT_SHADER);
 			gDeferredMultiLightProgram[i].mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 			gDeferredMultiLightProgram[i].addPermutation("LIGHT_COUNT", llformat("%d", i+1));
 			success = gDeferredMultiLightProgram[i].createShader(nullptr, nullptr);
@@ -1432,8 +1430,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredSpotLightProgram.mName = "Deferred SpotLight Shader";
 		gDeferredSpotLightProgram.mShaderFiles.clear();
-		gDeferredSpotLightProgram.mShaderFiles.push_back(std::make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER));
-		gDeferredSpotLightProgram.mShaderFiles.push_back(std::make_pair("deferred/spotLightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredSpotLightProgram.mShaderFiles.emplace_back("deferred/pointLightV.glsl", GL_VERTEX_SHADER);
+		gDeferredSpotLightProgram.mShaderFiles.emplace_back("deferred/spotLightF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredSpotLightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 
 		success = gDeferredSpotLightProgram.createShader(nullptr, nullptr);
@@ -1443,8 +1441,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredMultiSpotLightProgram.mName = "Deferred MultiSpotLight Shader";
 		gDeferredMultiSpotLightProgram.mShaderFiles.clear();
-		gDeferredMultiSpotLightProgram.mShaderFiles.push_back(std::make_pair("deferred/multiPointLightV.glsl", GL_VERTEX_SHADER));
-		gDeferredMultiSpotLightProgram.mShaderFiles.push_back(std::make_pair("deferred/multiSpotLightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredMultiSpotLightProgram.mShaderFiles.emplace_back("deferred/multiPointLightV.glsl", GL_VERTEX_SHADER);
+		gDeferredMultiSpotLightProgram.mShaderFiles.emplace_back("deferred/multiSpotLightF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredMultiSpotLightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 
 		success = gDeferredMultiSpotLightProgram.createShader(nullptr, nullptr);
@@ -1470,8 +1468,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 
 		gDeferredSunProgram.mName = "Deferred Sun Shader";
 		gDeferredSunProgram.mShaderFiles.clear();
-		gDeferredSunProgram.mShaderFiles.push_back(std::make_pair(vertex, GL_VERTEX_SHADER));
-		gDeferredSunProgram.mShaderFiles.push_back(std::make_pair(fragment, GL_FRAGMENT_SHADER));
+		gDeferredSunProgram.mShaderFiles.emplace_back(vertex, GL_VERTEX_SHADER);
+		gDeferredSunProgram.mShaderFiles.emplace_back(fragment, GL_FRAGMENT_SHADER);
 		gDeferredSunProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 
 		success = gDeferredSunProgram.createShader(nullptr, nullptr);
@@ -1483,8 +1481,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		{
 			gDeferredSSAOProgram.mName = "Deferred Ambient Occlusion Shader";
 			gDeferredSSAOProgram.mShaderFiles.clear();
-			gDeferredSSAOProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER_ARB));
-			gDeferredSSAOProgram.mShaderFiles.push_back(std::make_pair("deferred/SSAOF.glsl", GL_FRAGMENT_SHADER_ARB));
+			gDeferredSSAOProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER_ARB);
+			gDeferredSSAOProgram.mShaderFiles.emplace_back("deferred/SSAOF.glsl", GL_FRAGMENT_SHADER_ARB);
 			gDeferredSSAOProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 			success = gDeferredSSAOProgram.createShader(nullptr, nullptr);
 		}
@@ -1493,8 +1491,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		{
 			gDeferredDownsampleDepthNearestProgram.mName = "Deferred Nearest Downsample Depth Shader";
 			gDeferredDownsampleDepthNearestProgram.mShaderFiles.clear();
-			gDeferredDownsampleDepthNearestProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER_ARB));
-			gDeferredDownsampleDepthNearestProgram.mShaderFiles.push_back(std::make_pair("deferred/downsampleDepthNearestF.glsl", GL_FRAGMENT_SHADER_ARB));
+			gDeferredDownsampleDepthNearestProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER_ARB);
+			gDeferredDownsampleDepthNearestProgram.mShaderFiles.emplace_back("deferred/downsampleDepthNearestF.glsl", GL_FRAGMENT_SHADER_ARB);
 			gDeferredDownsampleDepthNearestProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 			success = gDeferredDownsampleDepthNearestProgram.createShader(nullptr, nullptr);
 		}
@@ -1504,8 +1502,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredBlurLightProgram.mName = "Deferred Blur Light Shader";
 		gDeferredBlurLightProgram.mShaderFiles.clear();
-		gDeferredBlurLightProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredBlurLightProgram.mShaderFiles.push_back(std::make_pair("deferred/blurLightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredBlurLightProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER);
+		gDeferredBlurLightProgram.mShaderFiles.emplace_back("deferred/blurLightF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredBlurLightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 
 		success = gDeferredBlurLightProgram.createShader(nullptr, nullptr);
@@ -1529,8 +1527,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		}
 			
 		gDeferredAlphaProgram.mShaderFiles.clear();
-		gDeferredAlphaProgram.mShaderFiles.push_back(std::make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER));
-		gDeferredAlphaProgram.mShaderFiles.push_back(std::make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredAlphaProgram.mShaderFiles.emplace_back("deferred/alphaV.glsl", GL_VERTEX_SHADER);
+		gDeferredAlphaProgram.mShaderFiles.emplace_back("deferred/alphaF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredAlphaProgram.addPermutation("USE_INDEXED_TEX", "1");
 		gDeferredAlphaProgram.addPermutation("HAS_SHADOW", mVertexShaderLevel[SHADER_DEFERRED] > 1 ? "1" : "0");
 		gDeferredAlphaProgram.addPermutation("USE_VERTEX_COLOR", "1");
@@ -1561,8 +1559,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		}
 
 		gDeferredAlphaImpostorProgram.mShaderFiles.clear();
-		gDeferredAlphaImpostorProgram.mShaderFiles.push_back(std::make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER));
-		gDeferredAlphaImpostorProgram.mShaderFiles.push_back(std::make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredAlphaImpostorProgram.mShaderFiles.emplace_back("deferred/alphaV.glsl", GL_VERTEX_SHADER);
+		gDeferredAlphaImpostorProgram.mShaderFiles.emplace_back("deferred/alphaF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredAlphaImpostorProgram.addPermutation("USE_INDEXED_TEX", "1");
 		gDeferredAlphaImpostorProgram.addPermutation("HAS_SHADOW", mVertexShaderLevel[SHADER_DEFERRED] > 1 ? "1" : "0");
 		gDeferredAlphaImpostorProgram.addPermutation("USE_VERTEX_COLOR", "1");
@@ -1594,8 +1592,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		}
 		gDeferredAlphaWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		gDeferredAlphaWaterProgram.mShaderFiles.clear();
-		gDeferredAlphaWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER));
-		gDeferredAlphaWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredAlphaWaterProgram.mShaderFiles.emplace_back("deferred/alphaV.glsl", GL_VERTEX_SHADER);
+		gDeferredAlphaWaterProgram.mShaderFiles.emplace_back("deferred/alphaF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredAlphaWaterProgram.addPermutation("USE_INDEXED_TEX", "1");
 		gDeferredAlphaWaterProgram.addPermutation("WATER_FOG", "1");
 		gDeferredAlphaWaterProgram.addPermutation("USE_VERTEX_COLOR", "1");
@@ -1617,8 +1615,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAvatarEyesProgram.mFeatures.hasTransport = true;
 		gDeferredAvatarEyesProgram.mFeatures.disableTextureIndex = true;
 		gDeferredAvatarEyesProgram.mShaderFiles.clear();
-		gDeferredAvatarEyesProgram.mShaderFiles.push_back(std::make_pair("deferred/avatarEyesV.glsl", GL_VERTEX_SHADER));
-		gDeferredAvatarEyesProgram.mShaderFiles.push_back(std::make_pair("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredAvatarEyesProgram.mShaderFiles.emplace_back("deferred/avatarEyesV.glsl", GL_VERTEX_SHADER);
+		gDeferredAvatarEyesProgram.mShaderFiles.emplace_back("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredAvatarEyesProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredAvatarEyesProgram.createShader(nullptr, nullptr);
 	}
@@ -1631,8 +1629,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredFullbrightProgram.mFeatures.hasTransport = true;
 		gDeferredFullbrightProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
 		gDeferredFullbrightProgram.mShaderFiles.clear();
-		gDeferredFullbrightProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gDeferredFullbrightProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredFullbrightProgram.mShaderFiles.emplace_back("deferred/fullbrightV.glsl", GL_VERTEX_SHADER);
+		gDeferredFullbrightProgram.mShaderFiles.emplace_back("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredFullbrightProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredFullbrightProgram.createShader(nullptr, nullptr);
 	}
@@ -1645,8 +1643,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredFullbrightAlphaMaskProgram.mFeatures.hasTransport = true;
 		gDeferredFullbrightAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
 		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.clear();
-		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.emplace_back("deferred/fullbrightV.glsl", GL_VERTEX_SHADER);
+		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.emplace_back("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredFullbrightAlphaMaskProgram.addPermutation("HAS_ALPHA_MASK","1");
 		gDeferredFullbrightAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredFullbrightAlphaMaskProgram.createShader(nullptr, nullptr);
@@ -1660,8 +1658,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredFullbrightWaterProgram.mFeatures.hasTransport = true;
 		gDeferredFullbrightWaterProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
 		gDeferredFullbrightWaterProgram.mShaderFiles.clear();
-		gDeferredFullbrightWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gDeferredFullbrightWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredFullbrightWaterProgram.mShaderFiles.emplace_back("deferred/fullbrightV.glsl", GL_VERTEX_SHADER);
+		gDeferredFullbrightWaterProgram.mShaderFiles.emplace_back("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredFullbrightWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredFullbrightWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		gDeferredFullbrightWaterProgram.addPermutation("WATER_FOG","1");
@@ -1676,8 +1674,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.hasTransport = true;
 		gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
 		gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.clear();
-		gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.emplace_back("deferred/fullbrightV.glsl", GL_VERTEX_SHADER);
+		gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.emplace_back("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredFullbrightAlphaMaskWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredFullbrightAlphaMaskWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		gDeferredFullbrightAlphaMaskWaterProgram.addPermutation("HAS_ALPHA_MASK","1");
@@ -1693,8 +1691,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredFullbrightShinyProgram.mFeatures.hasTransport = true;
 		gDeferredFullbrightShinyProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels-1;
 		gDeferredFullbrightShinyProgram.mShaderFiles.clear();
-		gDeferredFullbrightShinyProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightShinyV.glsl", GL_VERTEX_SHADER));
-		gDeferredFullbrightShinyProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredFullbrightShinyProgram.mShaderFiles.emplace_back("deferred/fullbrightShinyV.glsl", GL_VERTEX_SHADER);
+		gDeferredFullbrightShinyProgram.mShaderFiles.emplace_back("deferred/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredFullbrightShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredFullbrightShinyProgram.createShader(nullptr, nullptr);
 	}
@@ -1708,8 +1706,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredSkinnedFullbrightProgram.mFeatures.hasObjectSkinning = true;
 		gDeferredSkinnedFullbrightProgram.mFeatures.disableTextureIndex = true;
 		gDeferredSkinnedFullbrightProgram.mShaderFiles.clear();
-		gDeferredSkinnedFullbrightProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightSkinnedV.glsl", GL_VERTEX_SHADER));
-		gDeferredSkinnedFullbrightProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredSkinnedFullbrightProgram.mShaderFiles.emplace_back("objects/fullbrightSkinnedV.glsl", GL_VERTEX_SHADER);
+		gDeferredSkinnedFullbrightProgram.mShaderFiles.emplace_back("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredSkinnedFullbrightProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gDeferredSkinnedFullbrightProgram.createShader(nullptr, nullptr);
 	}
@@ -1723,8 +1721,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredSkinnedFullbrightShinyProgram.mFeatures.hasObjectSkinning = true;
 		gDeferredSkinnedFullbrightShinyProgram.mFeatures.disableTextureIndex = true;
 		gDeferredSkinnedFullbrightShinyProgram.mShaderFiles.clear();
-		gDeferredSkinnedFullbrightShinyProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinySkinnedV.glsl", GL_VERTEX_SHADER));
-		gDeferredSkinnedFullbrightShinyProgram.mShaderFiles.push_back(std::make_pair("deferred/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredSkinnedFullbrightShinyProgram.mShaderFiles.emplace_back("objects/fullbrightShinySkinnedV.glsl", GL_VERTEX_SHADER);
+		gDeferredSkinnedFullbrightShinyProgram.mShaderFiles.emplace_back("deferred/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredSkinnedFullbrightShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gDeferredSkinnedFullbrightShinyProgram.createShader(nullptr, nullptr);
 	}
@@ -1737,8 +1735,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredEmissiveProgram.mFeatures.hasTransport = true;
 		gDeferredEmissiveProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
 		gDeferredEmissiveProgram.mShaderFiles.clear();
-		gDeferredEmissiveProgram.mShaderFiles.push_back(std::make_pair("deferred/emissiveV.glsl", GL_VERTEX_SHADER));
-		gDeferredEmissiveProgram.mShaderFiles.push_back(std::make_pair("deferred/emissiveF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredEmissiveProgram.mShaderFiles.emplace_back("deferred/emissiveV.glsl", GL_VERTEX_SHADER);
+		gDeferredEmissiveProgram.mShaderFiles.emplace_back("deferred/emissiveF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredEmissiveProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredEmissiveProgram.createShader(nullptr, nullptr);
 	}
@@ -1751,8 +1749,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredWaterProgram.mFeatures.hasGamma = true;
 		gDeferredWaterProgram.mFeatures.hasTransport = true;
 		gDeferredWaterProgram.mShaderFiles.clear();
-		gDeferredWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/waterV.glsl", GL_VERTEX_SHADER));
-		gDeferredWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/waterF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredWaterProgram.mShaderFiles.emplace_back("deferred/waterV.glsl", GL_VERTEX_SHADER);
+		gDeferredWaterProgram.mShaderFiles.emplace_back("deferred/waterF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredWaterProgram.createShader(nullptr, nullptr);
 	}
@@ -1765,8 +1763,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredUnderWaterProgram.mFeatures.hasGamma = true;
 		gDeferredUnderWaterProgram.mFeatures.hasTransport = true;
 		gDeferredUnderWaterProgram.mShaderFiles.clear();
-		gDeferredUnderWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/waterV.glsl", GL_VERTEX_SHADER));
-		gDeferredUnderWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/underWaterF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredUnderWaterProgram.mShaderFiles.emplace_back("deferred/waterV.glsl", GL_VERTEX_SHADER);
+		gDeferredUnderWaterProgram.mShaderFiles.emplace_back("deferred/underWaterF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredUnderWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredUnderWaterProgram.createShader(nullptr, nullptr);
 	}
@@ -1775,8 +1773,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredSoftenProgram.mName = "Deferred Soften Shader";
 		gDeferredSoftenProgram.mShaderFiles.clear();
-		gDeferredSoftenProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredSoftenProgram.mShaderFiles.push_back(std::make_pair("deferred/softenLightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredSoftenProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER);
+		gDeferredSoftenProgram.mShaderFiles.emplace_back("deferred/softenLightF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredSoftenProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 
 		if (gSavedSettings.getBOOL("RenderDeferredSSAO"))
@@ -1791,8 +1789,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredSoftenWaterProgram.mName = "Deferred Soften Underwater Shader";
 		gDeferredSoftenWaterProgram.mShaderFiles.clear();
-		gDeferredSoftenWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredSoftenWaterProgram.mShaderFiles.push_back(std::make_pair("deferred/softenLightF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredSoftenWaterProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER);
+		gDeferredSoftenWaterProgram.mShaderFiles.emplace_back("deferred/softenLightF.glsl", GL_FRAGMENT_SHADER);
 
 		gDeferredSoftenWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredSoftenWaterProgram.addPermutation("WATER_FOG", "1");
@@ -1810,8 +1808,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredShadowProgram.mName = "Deferred Shadow Shader";
 		gDeferredShadowProgram.mShaderFiles.clear();
-		gDeferredShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/shadowV.glsl", GL_VERTEX_SHADER));
-		gDeferredShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/shadowF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredShadowProgram.mShaderFiles.emplace_back("deferred/shadowV.glsl", GL_VERTEX_SHADER);
+		gDeferredShadowProgram.mShaderFiles.emplace_back("deferred/shadowF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredShadowProgram.addPermutation("DEPTH_CLAMP", /*gGLManager.mHasDepthClamp ? "1" :*/ "0");
 		success = gDeferredShadowProgram.createShader(nullptr, nullptr);
@@ -1821,8 +1819,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredShadowCubeProgram.mName = "Deferred Shadow Cube Shader";
 		gDeferredShadowCubeProgram.mShaderFiles.clear();
-		gDeferredShadowCubeProgram.mShaderFiles.push_back(std::make_pair("deferred/shadowCubeV.glsl", GL_VERTEX_SHADER));
-		gDeferredShadowCubeProgram.mShaderFiles.push_back(std::make_pair("deferred/shadowF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredShadowCubeProgram.mShaderFiles.emplace_back("deferred/shadowCubeV.glsl", GL_VERTEX_SHADER);
+		gDeferredShadowCubeProgram.mShaderFiles.emplace_back("deferred/shadowF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredShadowCubeProgram.addPermutation("DEPTH_CLAMP", /*gGLManager.mHasDepthClamp ? "1" :*/ "0");
 		gDeferredShadowCubeProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredShadowCubeProgram.createShader(nullptr, nullptr);
@@ -1833,8 +1831,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredShadowAlphaMaskProgram.mName = "Deferred Shadow Alpha Mask Shader";
 		gDeferredShadowAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
 		gDeferredShadowAlphaMaskProgram.mShaderFiles.clear();
-		gDeferredShadowAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("deferred/shadowAlphaMaskV.glsl", GL_VERTEX_SHADER));
-		gDeferredShadowAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("deferred/shadowAlphaMaskF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredShadowAlphaMaskProgram.mShaderFiles.emplace_back("deferred/shadowAlphaMaskV.glsl", GL_VERTEX_SHADER);
+		gDeferredShadowAlphaMaskProgram.mShaderFiles.emplace_back("deferred/shadowAlphaMaskF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredShadowAlphaMaskProgram.addPermutation("DEPTH_CLAMP", /*gGLManager.mHasDepthClamp ? "1" :*/ "0");
 		gDeferredShadowAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredShadowAlphaMaskProgram.createShader(nullptr, nullptr);
@@ -1845,8 +1843,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAvatarShadowProgram.mName = "Deferred Avatar Shadow Shader";
 		gDeferredAvatarShadowProgram.mFeatures.hasSkinning = true;
 		gDeferredAvatarShadowProgram.mShaderFiles.clear();
-		gDeferredAvatarShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/avatarShadowV.glsl", GL_VERTEX_SHADER));
-		gDeferredAvatarShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/avatarShadowF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredAvatarShadowProgram.mShaderFiles.emplace_back("deferred/avatarShadowV.glsl", GL_VERTEX_SHADER);
+		gDeferredAvatarShadowProgram.mShaderFiles.emplace_back("deferred/avatarShadowF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredAvatarShadowProgram.addPermutation("DEPTH_CLAMP", /*gGLManager.mHasDepthClamp ? "1" :*/ "0");
 		gDeferredAvatarShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredAvatarShadowProgram.createShader(nullptr, nullptr);
@@ -1857,8 +1855,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAvatarAlphaShadowProgram.mName = "Deferred Avatar Alpha Shadow Shader";
 		gDeferredAvatarAlphaShadowProgram.mFeatures.hasSkinning = true;
 		gDeferredAvatarAlphaShadowProgram.mShaderFiles.clear();
-		gDeferredAvatarAlphaShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/avatarAlphaShadowV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredAvatarAlphaShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/avatarAlphaShadowF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredAvatarAlphaShadowProgram.mShaderFiles.emplace_back("deferred/avatarAlphaShadowV.glsl", GL_VERTEX_SHADER_ARB);
+		gDeferredAvatarAlphaShadowProgram.mShaderFiles.emplace_back("deferred/avatarAlphaShadowF.glsl", GL_FRAGMENT_SHADER_ARB);
 		gDeferredAvatarAlphaShadowProgram.addPermutation("DEPTH_CLAMP", /*gGLManager.mHasDepthClamp ? "1" :*/ "0");
 		gDeferredAvatarAlphaShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredAvatarAlphaShadowProgram.createShader(NULL, NULL);
@@ -1869,8 +1867,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAvatarAlphaMaskShadowProgram.mName = "Deferred Avatar Alpha Mask Shadow Shader";
 		gDeferredAvatarAlphaMaskShadowProgram.mFeatures.hasSkinning  = true;
 		gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.clear();
-		gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/avatarAlphaShadowV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/avatarAlphaMaskShadowF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.emplace_back("deferred/avatarAlphaShadowV.glsl", GL_VERTEX_SHADER_ARB);
+		gDeferredAvatarAlphaMaskShadowProgram.mShaderFiles.emplace_back("deferred/avatarAlphaMaskShadowF.glsl", GL_FRAGMENT_SHADER_ARB);
 		gDeferredAvatarAlphaMaskShadowProgram.addPermutation("DEPTH_CLAMP", /*gGLManager.mHasDepthClamp ? "1" :*/ "0");
 		gDeferredAvatarAlphaMaskShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredAvatarAlphaMaskShadowProgram.createShader(NULL, NULL);
@@ -1881,8 +1879,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAttachmentShadowProgram.mName = "Deferred Attachment Shadow Shader";
 		gDeferredAttachmentShadowProgram.mFeatures.hasObjectSkinning = true;
 		gDeferredAttachmentShadowProgram.mShaderFiles.clear();
-		gDeferredAttachmentShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/attachmentShadowV.glsl", GL_VERTEX_SHADER));
-		gDeferredAttachmentShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/attachmentShadowF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredAttachmentShadowProgram.mShaderFiles.emplace_back("deferred/attachmentShadowV.glsl", GL_VERTEX_SHADER);
+		gDeferredAttachmentShadowProgram.mShaderFiles.emplace_back("deferred/attachmentShadowF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredAttachmentShadowProgram.addPermutation("DEPTH_CLAMP", /*gGLManager.mHasDepthClamp ? "1" :*/ "0");
 		gDeferredAttachmentShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredAttachmentShadowProgram.createShader(nullptr, nullptr);
@@ -1893,8 +1891,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAttachmentAlphaShadowProgram.mName = "Deferred Attachment Alpha Shadow Shader";
 		gDeferredAttachmentAlphaShadowProgram.mFeatures.hasObjectSkinning = true;
 		gDeferredAttachmentAlphaShadowProgram.mShaderFiles.clear();
-		gDeferredAttachmentAlphaShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/attachmentAlphaShadowV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredAttachmentAlphaShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/attachmentAlphaShadowF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredAttachmentAlphaShadowProgram.mShaderFiles.emplace_back("deferred/attachmentAlphaShadowV.glsl", GL_VERTEX_SHADER_ARB);
+		gDeferredAttachmentAlphaShadowProgram.mShaderFiles.emplace_back("deferred/attachmentAlphaShadowF.glsl", GL_FRAGMENT_SHADER_ARB);
 		gDeferredAttachmentAlphaShadowProgram.addPermutation("DEPTH_CLAMP", /*gGLManager.mHasDepthClamp ? "1" :*/ "0");
 		gDeferredAttachmentAlphaShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredAttachmentAlphaShadowProgram.createShader(NULL, NULL);
@@ -1905,8 +1903,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAttachmentAlphaMaskShadowProgram.mName = "Deferred Attachment Alpha Mask Shadow Shader";
 		gDeferredAttachmentAlphaMaskShadowProgram.mFeatures.hasObjectSkinning = true;
 		gDeferredAttachmentAlphaMaskShadowProgram.mShaderFiles.clear();
-		gDeferredAttachmentAlphaMaskShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/attachmentAlphaShadowV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredAttachmentAlphaMaskShadowProgram.mShaderFiles.push_back(std::make_pair("deferred/attachmentAlphaMaskShadowF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredAttachmentAlphaMaskShadowProgram.mShaderFiles.emplace_back("deferred/attachmentAlphaShadowV.glsl", GL_VERTEX_SHADER_ARB);
+		gDeferredAttachmentAlphaMaskShadowProgram.mShaderFiles.emplace_back("deferred/attachmentAlphaMaskShadowF.glsl", GL_FRAGMENT_SHADER_ARB);
 		gDeferredAttachmentAlphaMaskShadowProgram.addPermutation("DEPTH_CLAMP", /*gGLManager.mHasDepthClamp ? "1" :*/ "0");
 		gDeferredAttachmentAlphaMaskShadowProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredAttachmentAlphaMaskShadowProgram.createShader(NULL, NULL);
@@ -1916,8 +1914,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gTerrainProgram.mName = "Deferred Terrain Shader";
 		gDeferredTerrainProgram.mShaderFiles.clear();
-		gDeferredTerrainProgram.mShaderFiles.push_back(std::make_pair("deferred/terrainV.glsl", GL_VERTEX_SHADER));
-		gDeferredTerrainProgram.mShaderFiles.push_back(std::make_pair("deferred/terrainF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredTerrainProgram.mShaderFiles.emplace_back("deferred/terrainV.glsl", GL_VERTEX_SHADER);
+		gDeferredTerrainProgram.mShaderFiles.emplace_back("deferred/terrainF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredTerrainProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredTerrainProgram.createShader(nullptr, nullptr);
 	}
@@ -1927,8 +1925,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAvatarProgram.mName = "Deferred Avatar Shader";
 		gDeferredAvatarProgram.mFeatures.hasSkinning = true;
 		gDeferredAvatarProgram.mShaderFiles.clear();
-		gDeferredAvatarProgram.mShaderFiles.push_back(std::make_pair("deferred/avatarV.glsl", GL_VERTEX_SHADER));
-		gDeferredAvatarProgram.mShaderFiles.push_back(std::make_pair("deferred/avatarF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredAvatarProgram.mShaderFiles.emplace_back("deferred/avatarV.glsl", GL_VERTEX_SHADER);
+		gDeferredAvatarProgram.mShaderFiles.emplace_back("deferred/avatarF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredAvatarProgram.addPermutation("AVATAR_CLOTH", (mVertexShaderLevel[SHADER_AVATAR] == 3) ? "1" : "0");
 		gDeferredAvatarProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredAvatarProgram.createShader(nullptr, nullptr);
@@ -1943,8 +1941,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAvatarAlphaProgram.mFeatures.isAlphaLighting = true;
 		gDeferredAvatarAlphaProgram.mFeatures.disableTextureIndex = true;
 		gDeferredAvatarAlphaProgram.mShaderFiles.clear();
-		gDeferredAvatarAlphaProgram.mShaderFiles.push_back(std::make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER));
-		gDeferredAvatarAlphaProgram.mShaderFiles.push_back(std::make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredAvatarAlphaProgram.mShaderFiles.emplace_back("deferred/alphaV.glsl", GL_VERTEX_SHADER);
+		gDeferredAvatarAlphaProgram.mShaderFiles.emplace_back("deferred/alphaF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredAvatarAlphaProgram.addPermutation("USE_DIFFUSE_TEX", "1");
 		gDeferredAvatarAlphaProgram.addPermutation("IS_AVATAR_SKIN", "1");
 		gDeferredAvatarAlphaProgram.addPermutation("HAS_SHADOW", mVertexShaderLevel[SHADER_DEFERRED] > 1 ? "1" : "0");
@@ -1960,8 +1958,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredPostGammaCorrectProgram.mName = "Deferred Gamma Correction Post Process";
 		gDeferredPostGammaCorrectProgram.mShaderFiles.clear();
-		gDeferredPostGammaCorrectProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredPostGammaCorrectProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredGammaCorrectF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredPostGammaCorrectProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER);
+		gDeferredPostGammaCorrectProgram.mShaderFiles.emplace_back("deferred/postDeferredGammaCorrectF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredPostGammaCorrectProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredPostGammaCorrectProgram.createShader(nullptr, nullptr);
 	}
@@ -1970,8 +1968,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gFXAAProgram.mName = "FXAA Shader";
 		gFXAAProgram.mShaderFiles.clear();
-		gFXAAProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gFXAAProgram.mShaderFiles.push_back(std::make_pair("deferred/fxaaF.glsl", GL_FRAGMENT_SHADER));
+		gFXAAProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER);
+		gFXAAProgram.mShaderFiles.emplace_back("deferred/fxaaF.glsl", GL_FRAGMENT_SHADER);
 		gFXAAProgram.addPermutation("FXAA_QUALITY_PRESET", fmt::to_string(gSavedSettings.getU32("RenderDeferredFXAAQuality"))); // <alchemy/>
 		gFXAAProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gFXAAProgram.createShader(nullptr, nullptr);
@@ -1981,8 +1979,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredPostProgram.mName = "Deferred Post Shader";
 		gDeferredPostProgram.mShaderFiles.clear();
-		gDeferredPostProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredPostProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredPostProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER);
+		gDeferredPostProgram.mShaderFiles.emplace_back("deferred/postDeferredF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredPostProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredPostProgram.createShader(nullptr, nullptr);
 	}
@@ -1991,8 +1989,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredCoFProgram.mName = "Deferred CoF Shader";
 		gDeferredCoFProgram.mShaderFiles.clear();
-		gDeferredCoFProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredCoFProgram.mShaderFiles.push_back(std::make_pair("deferred/cofF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredCoFProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER);
+		gDeferredCoFProgram.mShaderFiles.emplace_back("deferred/cofF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredCoFProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredCoFProgram.createShader(nullptr, nullptr);
 	}
@@ -2001,8 +1999,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredDoFCombineProgram.mName = "Deferred DoFCombine Shader";
 		gDeferredDoFCombineProgram.mShaderFiles.clear();
-		gDeferredDoFCombineProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredDoFCombineProgram.mShaderFiles.push_back(std::make_pair("deferred/dofCombineF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredDoFCombineProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER);
+		gDeferredDoFCombineProgram.mShaderFiles.emplace_back("deferred/dofCombineF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredDoFCombineProgram.addPermutation("USE_FILM_GRAIN", gSavedSettings.getBOOL("RenderDeferredDoFGrain") ? "1" : "0");
 		gDeferredDoFCombineProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredDoFCombineProgram.createShader(nullptr, nullptr);
@@ -2012,8 +2010,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredPostNoDoFProgram.mName = "Deferred Post No DoF Shader";
 		gDeferredPostNoDoFProgram.mShaderFiles.clear();
-		gDeferredPostNoDoFProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER));
-		gDeferredPostNoDoFProgram.mShaderFiles.push_back(std::make_pair("deferred/postDeferredNoDoFF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredPostNoDoFProgram.mShaderFiles.emplace_back("deferred/postDeferredNoTCV.glsl", GL_VERTEX_SHADER);
+		gDeferredPostNoDoFProgram.mShaderFiles.emplace_back("deferred/postDeferredNoDoFF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredPostNoDoFProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredPostNoDoFProgram.createShader(nullptr, nullptr);
 	}
@@ -2023,8 +2021,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredWLSkyProgram.mName = "Deferred Windlight Sky Shader";
 		//gWLSkyProgram.mFeatures.hasGamma = true;
 		gDeferredWLSkyProgram.mShaderFiles.clear();
-		gDeferredWLSkyProgram.mShaderFiles.push_back(std::make_pair("deferred/skyV.glsl", GL_VERTEX_SHADER));
-		gDeferredWLSkyProgram.mShaderFiles.push_back(std::make_pair("deferred/skyF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredWLSkyProgram.mShaderFiles.emplace_back("deferred/skyV.glsl", GL_VERTEX_SHADER);
+		gDeferredWLSkyProgram.mShaderFiles.emplace_back("deferred/skyF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredWLSkyProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredWLSkyProgram.mShaderGroup = LLGLSLShader::SG_SKY;
 		success = gDeferredWLSkyProgram.createShader(nullptr, nullptr);
@@ -2034,8 +2032,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gDeferredWLCloudProgram.mName = "Deferred Windlight Cloud Program";
 		gDeferredWLCloudProgram.mShaderFiles.clear();
-		gDeferredWLCloudProgram.mShaderFiles.push_back(std::make_pair("deferred/cloudsV.glsl", GL_VERTEX_SHADER));
-		gDeferredWLCloudProgram.mShaderFiles.push_back(std::make_pair("deferred/cloudsF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredWLCloudProgram.mShaderFiles.emplace_back("deferred/cloudsV.glsl", GL_VERTEX_SHADER);
+		gDeferredWLCloudProgram.mShaderFiles.emplace_back("deferred/cloudsF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredWLCloudProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredWLCloudProgram.mShaderGroup = LLGLSLShader::SG_SKY;
 		success = gDeferredWLCloudProgram.createShader(nullptr, nullptr);
@@ -2046,8 +2044,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredStarProgram.mName = "Deferred Star Program";
 		static std::vector<LLStaticHashedString> shaderUniforms = { LLStaticHashedString("custom_alpha") };
 		gDeferredStarProgram.mShaderFiles.clear();
-		gDeferredStarProgram.mShaderFiles.push_back(std::make_pair("deferred/starsV.glsl", GL_VERTEX_SHADER));
-		gDeferredStarProgram.mShaderFiles.push_back(std::make_pair("deferred/starsF.glsl", GL_FRAGMENT_SHADER));
+		gDeferredStarProgram.mShaderFiles.emplace_back("deferred/starsV.glsl", GL_VERTEX_SHADER);
+		gDeferredStarProgram.mShaderFiles.emplace_back("deferred/starsF.glsl", GL_FRAGMENT_SHADER);
 		gDeferredStarProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredStarProgram.mShaderGroup = LLGLSLShader::SG_SKY;
 		success = gDeferredStarProgram.createShader(nullptr, &shaderUniforms);
@@ -2057,8 +2055,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	{
 		gNormalMapGenProgram.mName = "Normal Map Generation Program";
 		gNormalMapGenProgram.mShaderFiles.clear();
-		gNormalMapGenProgram.mShaderFiles.push_back(std::make_pair("deferred/normgenV.glsl", GL_VERTEX_SHADER));
-		gNormalMapGenProgram.mShaderFiles.push_back(std::make_pair("deferred/normgenF.glsl", GL_FRAGMENT_SHADER));
+		gNormalMapGenProgram.mShaderFiles.emplace_back("deferred/normgenV.glsl", GL_VERTEX_SHADER);
+		gNormalMapGenProgram.mShaderFiles.emplace_back("deferred/normgenF.glsl", GL_FRAGMENT_SHADER);
 		gNormalMapGenProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gNormalMapGenProgram.mShaderGroup = LLGLSLShader::SG_SKY;
 		success = gNormalMapGenProgram.createShader(nullptr, nullptr);
@@ -2135,8 +2133,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectSimpleNonIndexedProgram.mFeatures.disableTextureIndex = true;
 		gObjectSimpleNonIndexedProgram.mFeatures.hasAlphaMask = true;
 		gObjectSimpleNonIndexedProgram.mShaderFiles.clear();
-		gObjectSimpleNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
-		gObjectSimpleNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
+		gObjectSimpleNonIndexedProgram.mShaderFiles.emplace_back("objects/simpleV.glsl", GL_VERTEX_SHADER);
+		gObjectSimpleNonIndexedProgram.mShaderFiles.emplace_back("objects/simpleF.glsl", GL_FRAGMENT_SHADER);
 		gObjectSimpleNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectSimpleNonIndexedProgram.createShader(nullptr, nullptr);
 	}
@@ -2151,8 +2149,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectSimpleNonIndexedTexGenProgram.mFeatures.hasLighting = true;
 		gObjectSimpleNonIndexedTexGenProgram.mFeatures.disableTextureIndex = true;
 		gObjectSimpleNonIndexedTexGenProgram.mShaderFiles.clear();
-		gObjectSimpleNonIndexedTexGenProgram.mShaderFiles.push_back(std::make_pair("objects/simpleTexGenV.glsl", GL_VERTEX_SHADER));
-		gObjectSimpleNonIndexedTexGenProgram.mShaderFiles.push_back(std::make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
+		gObjectSimpleNonIndexedTexGenProgram.mShaderFiles.emplace_back("objects/simpleTexGenV.glsl", GL_VERTEX_SHADER);
+		gObjectSimpleNonIndexedTexGenProgram.mShaderFiles.emplace_back("objects/simpleF.glsl", GL_FRAGMENT_SHADER);
 		gObjectSimpleNonIndexedTexGenProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectSimpleNonIndexedTexGenProgram.createShader(nullptr, nullptr);
 	}
@@ -2168,8 +2166,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectSimpleNonIndexedWaterProgram.mFeatures.hasLighting = true;
 		gObjectSimpleNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
 		gObjectSimpleNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectSimpleNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
-		gObjectSimpleNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectSimpleNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/simpleV.glsl", GL_VERTEX_SHADER);
+		gObjectSimpleNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectSimpleNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectSimpleNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectSimpleNonIndexedWaterProgram.createShader(nullptr, nullptr);
@@ -2185,8 +2183,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectSimpleNonIndexedTexGenWaterProgram.mFeatures.hasLighting = true;
 		gObjectSimpleNonIndexedTexGenWaterProgram.mFeatures.disableTextureIndex = true;
 		gObjectSimpleNonIndexedTexGenWaterProgram.mShaderFiles.clear();
-		gObjectSimpleNonIndexedTexGenWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleTexGenV.glsl", GL_VERTEX_SHADER));
-		gObjectSimpleNonIndexedTexGenWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectSimpleNonIndexedTexGenWaterProgram.mShaderFiles.emplace_back("objects/simpleTexGenV.glsl", GL_VERTEX_SHADER);
+		gObjectSimpleNonIndexedTexGenWaterProgram.mShaderFiles.emplace_back("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectSimpleNonIndexedTexGenWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectSimpleNonIndexedTexGenWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectSimpleNonIndexedTexGenWaterProgram.createShader(nullptr, nullptr);
@@ -2203,8 +2201,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectAlphaMaskNonIndexedProgram.mFeatures.disableTextureIndex = true;
 		gObjectAlphaMaskNonIndexedProgram.mFeatures.hasAlphaMask = true;
 		gObjectAlphaMaskNonIndexedProgram.mShaderFiles.clear();
-		gObjectAlphaMaskNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/simpleNonIndexedV.glsl", GL_VERTEX_SHADER));
-		gObjectAlphaMaskNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
+		gObjectAlphaMaskNonIndexedProgram.mShaderFiles.emplace_back("objects/simpleNonIndexedV.glsl", GL_VERTEX_SHADER);
+		gObjectAlphaMaskNonIndexedProgram.mShaderFiles.emplace_back("objects/simpleF.glsl", GL_FRAGMENT_SHADER);
 		gObjectAlphaMaskNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectAlphaMaskNonIndexedProgram.createShader(nullptr, nullptr);
 	}
@@ -2220,8 +2218,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
 		gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.hasAlphaMask = true;
 		gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleNonIndexedV.glsl", GL_VERTEX_SHADER));
-		gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/simpleNonIndexedV.glsl", GL_VERTEX_SHADER);
+		gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectAlphaMaskNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectAlphaMaskNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectAlphaMaskNonIndexedWaterProgram.createShader(nullptr, nullptr);
@@ -2238,8 +2236,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectAlphaMaskNoColorProgram.mFeatures.disableTextureIndex = true;
 		gObjectAlphaMaskNoColorProgram.mFeatures.hasAlphaMask = true;
 		gObjectAlphaMaskNoColorProgram.mShaderFiles.clear();
-		gObjectAlphaMaskNoColorProgram.mShaderFiles.push_back(std::make_pair("objects/simpleNoColorV.glsl", GL_VERTEX_SHADER));
-		gObjectAlphaMaskNoColorProgram.mShaderFiles.push_back(std::make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
+		gObjectAlphaMaskNoColorProgram.mShaderFiles.emplace_back("objects/simpleNoColorV.glsl", GL_VERTEX_SHADER);
+		gObjectAlphaMaskNoColorProgram.mShaderFiles.emplace_back("objects/simpleF.glsl", GL_FRAGMENT_SHADER);
 		gObjectAlphaMaskNoColorProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectAlphaMaskNoColorProgram.createShader(nullptr, nullptr);
 	}
@@ -2255,8 +2253,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectAlphaMaskNoColorWaterProgram.mFeatures.disableTextureIndex = true;
 		gObjectAlphaMaskNoColorWaterProgram.mFeatures.hasAlphaMask = true;
 		gObjectAlphaMaskNoColorWaterProgram.mShaderFiles.clear();
-		gObjectAlphaMaskNoColorWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleNoColorV.glsl", GL_VERTEX_SHADER));
-		gObjectAlphaMaskNoColorWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectAlphaMaskNoColorWaterProgram.mShaderFiles.emplace_back("objects/simpleNoColorV.glsl", GL_VERTEX_SHADER);
+		gObjectAlphaMaskNoColorWaterProgram.mShaderFiles.emplace_back("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectAlphaMaskNoColorWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectAlphaMaskNoColorWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectAlphaMaskNoColorWaterProgram.createShader(nullptr, nullptr);
@@ -2273,8 +2271,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gTreeProgram.mFeatures.disableTextureIndex = true;
 		gTreeProgram.mFeatures.hasAlphaMask = true;
 		gTreeProgram.mShaderFiles.clear();
-		gTreeProgram.mShaderFiles.push_back(std::make_pair("objects/treeV.glsl", GL_VERTEX_SHADER));
-		gTreeProgram.mShaderFiles.push_back(std::make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
+		gTreeProgram.mShaderFiles.emplace_back("objects/treeV.glsl", GL_VERTEX_SHADER);
+		gTreeProgram.mShaderFiles.emplace_back("objects/simpleF.glsl", GL_FRAGMENT_SHADER);
 		gTreeProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gTreeProgram.createShader(nullptr, nullptr);
 	}
@@ -2290,8 +2288,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gTreeWaterProgram.mFeatures.disableTextureIndex = true;
 		gTreeWaterProgram.mFeatures.hasAlphaMask = true;
 		gTreeWaterProgram.mShaderFiles.clear();
-		gTreeWaterProgram.mShaderFiles.push_back(std::make_pair("objects/treeV.glsl", GL_VERTEX_SHADER));
-		gTreeWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
+		gTreeWaterProgram.mShaderFiles.emplace_back("objects/treeV.glsl", GL_VERTEX_SHADER);
+		gTreeWaterProgram.mShaderFiles.emplace_back("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER);
 		gTreeWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gTreeWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gTreeWaterProgram.createShader(nullptr, nullptr);
@@ -2306,8 +2304,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightNonIndexedProgram.mFeatures.isFullbright = true;
 		gObjectFullbrightNonIndexedProgram.mFeatures.disableTextureIndex = true;
 		gObjectFullbrightNonIndexedProgram.mShaderFiles.clear();
-		gObjectFullbrightNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightNonIndexedProgram.mShaderFiles.emplace_back("objects/fullbrightV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightNonIndexedProgram.mShaderFiles.emplace_back("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectFullbrightNonIndexedProgram.createShader(nullptr, nullptr);
 	}
@@ -2321,8 +2319,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightNonIndexedWaterProgram.mFeatures.hasTransport = true;
 		gObjectFullbrightNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
 		gObjectFullbrightNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectFullbrightNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/fullbrightV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectFullbrightNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectFullbrightNonIndexedWaterProgram.createShader(nullptr, nullptr);
@@ -2337,8 +2335,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectEmissiveNonIndexedProgram.mFeatures.isFullbright = true;
 		gObjectEmissiveNonIndexedProgram.mFeatures.disableTextureIndex = true;
 		gObjectEmissiveNonIndexedProgram.mShaderFiles.clear();
-		gObjectEmissiveNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/emissiveV.glsl", GL_VERTEX_SHADER));
-		gObjectEmissiveNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gObjectEmissiveNonIndexedProgram.mShaderFiles.emplace_back("objects/emissiveV.glsl", GL_VERTEX_SHADER);
+		gObjectEmissiveNonIndexedProgram.mShaderFiles.emplace_back("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gObjectEmissiveNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectEmissiveNonIndexedProgram.createShader(nullptr, nullptr);
 	}
@@ -2352,8 +2350,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectEmissiveNonIndexedWaterProgram.mFeatures.hasTransport = true;
 		gObjectEmissiveNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
 		gObjectEmissiveNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectEmissiveNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/emissiveV.glsl", GL_VERTEX_SHADER));
-		gObjectEmissiveNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectEmissiveNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/emissiveV.glsl", GL_VERTEX_SHADER);
+		gObjectEmissiveNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectEmissiveNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectEmissiveNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectEmissiveNonIndexedWaterProgram.createShader(nullptr, nullptr);
@@ -2368,8 +2366,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightNoColorProgram.mFeatures.isFullbright = true;
 		gObjectFullbrightNoColorProgram.mFeatures.disableTextureIndex = true;
 		gObjectFullbrightNoColorProgram.mShaderFiles.clear();
-		gObjectFullbrightNoColorProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightNoColorV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightNoColorProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightNoColorProgram.mShaderFiles.emplace_back("objects/fullbrightNoColorV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightNoColorProgram.mShaderFiles.emplace_back("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightNoColorProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectFullbrightNoColorProgram.createShader(nullptr, nullptr);
 	}
@@ -2383,8 +2381,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightNoColorWaterProgram.mFeatures.hasTransport = true;
 		gObjectFullbrightNoColorWaterProgram.mFeatures.disableTextureIndex = true;
 		gObjectFullbrightNoColorWaterProgram.mShaderFiles.clear();
-		gObjectFullbrightNoColorWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightNoColorV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightNoColorWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightNoColorWaterProgram.mShaderFiles.emplace_back("objects/fullbrightNoColorV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightNoColorWaterProgram.mShaderFiles.emplace_back("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightNoColorWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectFullbrightNoColorWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectFullbrightNoColorWaterProgram.createShader(nullptr, nullptr);
@@ -2400,8 +2398,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectShinyNonIndexedProgram.mFeatures.isShiny = true;
 		gObjectShinyNonIndexedProgram.mFeatures.disableTextureIndex = true;
 		gObjectShinyNonIndexedProgram.mShaderFiles.clear();
-		gObjectShinyNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER));
-		gObjectShinyNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER));		
+		gObjectShinyNonIndexedProgram.mShaderFiles.emplace_back("objects/shinyV.glsl", GL_VERTEX_SHADER);
+		gObjectShinyNonIndexedProgram.mShaderFiles.emplace_back("objects/shinyF.glsl", GL_FRAGMENT_SHADER);		
 		gObjectShinyNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectShinyNonIndexedProgram.createShader(nullptr, nullptr);
 	}
@@ -2416,8 +2414,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectShinyNonIndexedWaterProgram.mFeatures.hasAtmospherics = true;
 		gObjectShinyNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
 		gObjectShinyNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectShinyNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER));
-		gObjectShinyNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER));
+		gObjectShinyNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER);
+		gObjectShinyNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/shinyV.glsl", GL_VERTEX_SHADER);
 		gObjectShinyNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectShinyNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectShinyNonIndexedWaterProgram.createShader(nullptr, nullptr);
@@ -2433,8 +2431,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightShinyNonIndexedProgram.mFeatures.hasTransport = true;
 		gObjectFullbrightShinyNonIndexedProgram.mFeatures.disableTextureIndex = true;
 		gObjectFullbrightShinyNonIndexedProgram.mShaderFiles.clear();
-		gObjectFullbrightShinyNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightShinyNonIndexedProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightShinyNonIndexedProgram.mShaderFiles.emplace_back("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightShinyNonIndexedProgram.mShaderFiles.emplace_back("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightShinyNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectFullbrightShinyNonIndexedProgram.createShader(nullptr, nullptr);
 	}
@@ -2450,8 +2448,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightShinyNonIndexedWaterProgram.mFeatures.hasWaterFog = true;
 		gObjectFullbrightShinyNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
 		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderFiles.emplace_back("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectFullbrightShinyNonIndexedWaterProgram.createShader(nullptr, nullptr);
@@ -2462,8 +2460,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gImpostorProgram.mName = "Impostor Shader";
 		gImpostorProgram.mFeatures.disableTextureIndex = true;
 		gImpostorProgram.mShaderFiles.clear();
-		gImpostorProgram.mShaderFiles.push_back(std::make_pair("objects/impostorV.glsl", GL_VERTEX_SHADER));
-		gImpostorProgram.mShaderFiles.push_back(std::make_pair("objects/impostorF.glsl", GL_FRAGMENT_SHADER));
+		gImpostorProgram.mShaderFiles.emplace_back("objects/impostorV.glsl", GL_VERTEX_SHADER);
+		gImpostorProgram.mShaderFiles.emplace_back("objects/impostorF.glsl", GL_FRAGMENT_SHADER);
 		gImpostorProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gImpostorProgram.createShader(nullptr, nullptr);
 	}
@@ -2479,8 +2477,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectPreviewProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectPreviewProgram.mFeatures.disableTextureIndex = true;
 		gObjectPreviewProgram.mShaderFiles.clear();
-		gObjectPreviewProgram.mShaderFiles.push_back(std::make_pair("objects/previewV.glsl", GL_VERTEX_SHADER));
-		gObjectPreviewProgram.mShaderFiles.push_back(std::make_pair("objects/previewF.glsl", GL_FRAGMENT_SHADER));
+		gObjectPreviewProgram.mShaderFiles.emplace_back("objects/previewV.glsl", GL_VERTEX_SHADER);
+		gObjectPreviewProgram.mShaderFiles.emplace_back("objects/previewF.glsl", GL_FRAGMENT_SHADER);
 		gObjectPreviewProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectPreviewProgram.createShader(nullptr, nullptr);
 		gObjectPreviewProgram.mFeatures.hasLighting = true;
@@ -2496,8 +2494,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectSimpleProgram.mFeatures.hasLighting = true;
 		gObjectSimpleProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectSimpleProgram.mShaderFiles.clear();
-		gObjectSimpleProgram.mShaderFiles.push_back(std::make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
-		gObjectSimpleProgram.mShaderFiles.push_back(std::make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
+		gObjectSimpleProgram.mShaderFiles.emplace_back("objects/simpleV.glsl", GL_VERTEX_SHADER);
+		gObjectSimpleProgram.mShaderFiles.emplace_back("objects/simpleF.glsl", GL_FRAGMENT_SHADER);
 		gObjectSimpleProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectSimpleProgram.createShader(nullptr, nullptr);
 	}
@@ -2516,8 +2514,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		//
 		gObjectSimpleImpostorProgram.mFeatures.hasAlphaMask = true; 
 		gObjectSimpleImpostorProgram.mShaderFiles.clear();
-		gObjectSimpleImpostorProgram.mShaderFiles.push_back(std::make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
-		gObjectSimpleImpostorProgram.mShaderFiles.push_back(std::make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
+		gObjectSimpleImpostorProgram.mShaderFiles.emplace_back("objects/simpleV.glsl", GL_VERTEX_SHADER);
+		gObjectSimpleImpostorProgram.mShaderFiles.emplace_back("objects/simpleF.glsl", GL_FRAGMENT_SHADER);
 		gObjectSimpleImpostorProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		
 		success = gObjectSimpleImpostorProgram.createShader(nullptr, nullptr);
@@ -2533,8 +2531,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectSimpleWaterProgram.mFeatures.hasLighting = true;
 		gObjectSimpleWaterProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectSimpleWaterProgram.mShaderFiles.clear();
-		gObjectSimpleWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
-		gObjectSimpleWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectSimpleWaterProgram.mShaderFiles.emplace_back("objects/simpleV.glsl", GL_VERTEX_SHADER);
+		gObjectSimpleWaterProgram.mShaderFiles.emplace_back("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectSimpleWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectSimpleWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectSimpleWaterProgram.createShader(nullptr, nullptr);
@@ -2550,8 +2548,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectBumpProgram.mFeatures.hasLighting = true;
 		gObjectBumpProgram.mFeatures.mIndexedTextureChannels = 0;*/
 		gObjectBumpProgram.mShaderFiles.clear();
-		gObjectBumpProgram.mShaderFiles.push_back(std::make_pair("objects/bumpV.glsl", GL_VERTEX_SHADER));
-		gObjectBumpProgram.mShaderFiles.push_back(std::make_pair("objects/bumpF.glsl", GL_FRAGMENT_SHADER));
+		gObjectBumpProgram.mShaderFiles.emplace_back("objects/bumpV.glsl", GL_VERTEX_SHADER);
+		gObjectBumpProgram.mShaderFiles.emplace_back("objects/bumpF.glsl", GL_FRAGMENT_SHADER);
 		gObjectBumpProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectBumpProgram.createShader(nullptr, nullptr);
 		if (success)
@@ -2575,8 +2573,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectSimpleAlphaMaskProgram.mFeatures.hasAlphaMask = true;
 		gObjectSimpleAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectSimpleAlphaMaskProgram.mShaderFiles.clear();
-		gObjectSimpleAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
-		gObjectSimpleAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
+		gObjectSimpleAlphaMaskProgram.mShaderFiles.emplace_back("objects/simpleV.glsl", GL_VERTEX_SHADER);
+		gObjectSimpleAlphaMaskProgram.mShaderFiles.emplace_back("objects/simpleF.glsl", GL_FRAGMENT_SHADER);
 		gObjectSimpleAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectSimpleAlphaMaskProgram.createShader(nullptr, nullptr);
 	}
@@ -2592,8 +2590,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectSimpleWaterAlphaMaskProgram.mFeatures.hasAlphaMask = true;
 		gObjectSimpleWaterAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.clear();
-		gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER));
-		gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.emplace_back("objects/simpleV.glsl", GL_VERTEX_SHADER);
+		gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.emplace_back("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectSimpleWaterAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectSimpleWaterAlphaMaskProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectSimpleWaterAlphaMaskProgram.createShader(nullptr, nullptr);
@@ -2608,8 +2606,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightProgram.mFeatures.isFullbright = true;
 		gObjectFullbrightProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectFullbrightProgram.mShaderFiles.clear();
-		gObjectFullbrightProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightProgram.mShaderFiles.emplace_back("objects/fullbrightV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightProgram.mShaderFiles.emplace_back("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectFullbrightProgram.createShader(nullptr, nullptr);
 	}
@@ -2623,8 +2621,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightWaterProgram.mFeatures.hasTransport = true;
 		gObjectFullbrightWaterProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectFullbrightWaterProgram.mShaderFiles.clear();
-		gObjectFullbrightWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightWaterProgram.mShaderFiles.emplace_back("objects/fullbrightV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightWaterProgram.mShaderFiles.emplace_back("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectFullbrightWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectFullbrightWaterProgram.createShader(nullptr, nullptr);
@@ -2639,8 +2637,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectEmissiveProgram.mFeatures.isFullbright = true;
 		gObjectEmissiveProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectEmissiveProgram.mShaderFiles.clear();
-		gObjectEmissiveProgram.mShaderFiles.push_back(std::make_pair("objects/emissiveV.glsl", GL_VERTEX_SHADER));
-		gObjectEmissiveProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gObjectEmissiveProgram.mShaderFiles.emplace_back("objects/emissiveV.glsl", GL_VERTEX_SHADER);
+		gObjectEmissiveProgram.mShaderFiles.emplace_back("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gObjectEmissiveProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectEmissiveProgram.createShader(nullptr, nullptr);
 	}
@@ -2654,8 +2652,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectEmissiveWaterProgram.mFeatures.hasTransport = true;
 		gObjectEmissiveWaterProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectEmissiveWaterProgram.mShaderFiles.clear();
-		gObjectEmissiveWaterProgram.mShaderFiles.push_back(std::make_pair("objects/emissiveV.glsl", GL_VERTEX_SHADER));
-		gObjectEmissiveWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectEmissiveWaterProgram.mShaderFiles.emplace_back("objects/emissiveV.glsl", GL_VERTEX_SHADER);
+		gObjectEmissiveWaterProgram.mShaderFiles.emplace_back("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectEmissiveWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectEmissiveWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectEmissiveWaterProgram.createShader(nullptr, nullptr);
@@ -2671,8 +2669,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightAlphaMaskProgram.mFeatures.hasAlphaMask = true;
 		gObjectFullbrightAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectFullbrightAlphaMaskProgram.mShaderFiles.clear();
-		gObjectFullbrightAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightAlphaMaskProgram.mShaderFiles.emplace_back("objects/fullbrightV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightAlphaMaskProgram.mShaderFiles.emplace_back("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectFullbrightAlphaMaskProgram.createShader(nullptr, nullptr);
 	}
@@ -2687,8 +2685,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightWaterAlphaMaskProgram.mFeatures.hasAlphaMask = true;
 		gObjectFullbrightWaterAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.clear();
-		gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.emplace_back("objects/fullbrightV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.emplace_back("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightWaterAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectFullbrightWaterAlphaMaskProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectFullbrightWaterAlphaMaskProgram.createShader(nullptr, nullptr);
@@ -2704,8 +2702,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectShinyProgram.mFeatures.isShiny = true;
 		gObjectShinyProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectShinyProgram.mShaderFiles.clear();
-		gObjectShinyProgram.mShaderFiles.push_back(std::make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER));
-		gObjectShinyProgram.mShaderFiles.push_back(std::make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER));		
+		gObjectShinyProgram.mShaderFiles.emplace_back("objects/shinyV.glsl", GL_VERTEX_SHADER);
+		gObjectShinyProgram.mShaderFiles.emplace_back("objects/shinyF.glsl", GL_FRAGMENT_SHADER);		
 		gObjectShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectShinyProgram.createShader(nullptr, nullptr);
 	}
@@ -2720,8 +2718,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectShinyWaterProgram.mFeatures.hasAtmospherics = true;
 		gObjectShinyWaterProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectShinyWaterProgram.mShaderFiles.clear();
-		gObjectShinyWaterProgram.mShaderFiles.push_back(std::make_pair("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER));
-		gObjectShinyWaterProgram.mShaderFiles.push_back(std::make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER));
+		gObjectShinyWaterProgram.mShaderFiles.emplace_back("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER);
+		gObjectShinyWaterProgram.mShaderFiles.emplace_back("objects/shinyV.glsl", GL_VERTEX_SHADER);
 		gObjectShinyWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectShinyWaterProgram.createShader(nullptr, nullptr);
@@ -2737,8 +2735,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightShinyProgram.mFeatures.hasTransport = true;
 		gObjectFullbrightShinyProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectFullbrightShinyProgram.mShaderFiles.clear();
-		gObjectFullbrightShinyProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightShinyProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightShinyProgram.mShaderFiles.emplace_back("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightShinyProgram.mShaderFiles.emplace_back("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		success = gObjectFullbrightShinyProgram.createShader(nullptr, nullptr);
 	}
@@ -2754,8 +2752,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightShinyWaterProgram.mFeatures.hasWaterFog = true;
 		gObjectFullbrightShinyWaterProgram.mFeatures.mIndexedTextureChannels = 0;
 		gObjectFullbrightShinyWaterProgram.mShaderFiles.clear();
-		gObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER));
-		gObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER));
+		gObjectFullbrightShinyWaterProgram.mShaderFiles.emplace_back("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER);
+		gObjectFullbrightShinyWaterProgram.mShaderFiles.emplace_back("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER);
 		gObjectFullbrightShinyWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 		gObjectFullbrightShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 		success = gObjectFullbrightShinyWaterProgram.createShader(nullptr, nullptr);
@@ -2775,8 +2773,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectSimpleProgram.mFeatures.hasAlphaMask = true;
 			gSkinnedObjectSimpleProgram.mFeatures.disableTextureIndex = true;
 			gSkinnedObjectSimpleProgram.mShaderFiles.clear();
-			gSkinnedObjectSimpleProgram.mShaderFiles.push_back(std::make_pair("objects/simpleSkinnedV.glsl", GL_VERTEX_SHADER));
-			gSkinnedObjectSimpleProgram.mShaderFiles.push_back(std::make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER));
+			gSkinnedObjectSimpleProgram.mShaderFiles.emplace_back("objects/simpleSkinnedV.glsl", GL_VERTEX_SHADER);
+			gSkinnedObjectSimpleProgram.mShaderFiles.emplace_back("objects/simpleF.glsl", GL_FRAGMENT_SHADER);
 			gSkinnedObjectSimpleProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 			success = gSkinnedObjectSimpleProgram.createShader(nullptr, nullptr);
 		}
@@ -2792,8 +2790,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectFullbrightProgram.mFeatures.hasAlphaMask = true;			
 			gSkinnedObjectFullbrightProgram.mFeatures.disableTextureIndex = true;
 			gSkinnedObjectFullbrightProgram.mShaderFiles.clear();
-			gSkinnedObjectFullbrightProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightSkinnedV.glsl", GL_VERTEX_SHADER));
-			gSkinnedObjectFullbrightProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+			gSkinnedObjectFullbrightProgram.mShaderFiles.emplace_back("objects/fullbrightSkinnedV.glsl", GL_VERTEX_SHADER);
+			gSkinnedObjectFullbrightProgram.mShaderFiles.emplace_back("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 			gSkinnedObjectFullbrightProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 			success = gSkinnedObjectFullbrightProgram.createShader(nullptr, nullptr);
 		}
@@ -2808,8 +2806,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectEmissiveProgram.mFeatures.hasObjectSkinning = true;
 			gSkinnedObjectEmissiveProgram.mFeatures.disableTextureIndex = true;
 			gSkinnedObjectEmissiveProgram.mShaderFiles.clear();
-			gSkinnedObjectEmissiveProgram.mShaderFiles.push_back(std::make_pair("objects/emissiveSkinnedV.glsl", GL_VERTEX_SHADER));
-			gSkinnedObjectEmissiveProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER));
+			gSkinnedObjectEmissiveProgram.mShaderFiles.emplace_back("objects/emissiveSkinnedV.glsl", GL_VERTEX_SHADER);
+			gSkinnedObjectEmissiveProgram.mShaderFiles.emplace_back("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER);
 			gSkinnedObjectEmissiveProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 			success = gSkinnedObjectEmissiveProgram.createShader(nullptr, nullptr);
 		}
@@ -2825,8 +2823,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectEmissiveWaterProgram.mFeatures.disableTextureIndex = true;
 			gSkinnedObjectEmissiveWaterProgram.mFeatures.hasWaterFog = true;
 			gSkinnedObjectEmissiveWaterProgram.mShaderFiles.clear();
-			gSkinnedObjectEmissiveWaterProgram.mShaderFiles.push_back(std::make_pair("objects/emissiveSkinnedV.glsl", GL_VERTEX_SHADER));
-			gSkinnedObjectEmissiveWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
+			gSkinnedObjectEmissiveWaterProgram.mShaderFiles.emplace_back("objects/emissiveSkinnedV.glsl", GL_VERTEX_SHADER);
+			gSkinnedObjectEmissiveWaterProgram.mShaderFiles.emplace_back("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER);
 			gSkinnedObjectEmissiveWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 			success = gSkinnedObjectEmissiveWaterProgram.createShader(nullptr, nullptr);
 		}
@@ -2843,8 +2841,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectFullbrightShinyProgram.mFeatures.hasAlphaMask = true;
 			gSkinnedObjectFullbrightShinyProgram.mFeatures.disableTextureIndex = true;
 			gSkinnedObjectFullbrightShinyProgram.mShaderFiles.clear();
-			gSkinnedObjectFullbrightShinyProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinySkinnedV.glsl", GL_VERTEX_SHADER));
-			gSkinnedObjectFullbrightShinyProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER));
+			gSkinnedObjectFullbrightShinyProgram.mShaderFiles.emplace_back("objects/fullbrightShinySkinnedV.glsl", GL_VERTEX_SHADER);
+			gSkinnedObjectFullbrightShinyProgram.mShaderFiles.emplace_back("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER);
 			gSkinnedObjectFullbrightShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 			success = gSkinnedObjectFullbrightShinyProgram.createShader(nullptr, nullptr);
 		}
@@ -2861,8 +2859,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectShinySimpleProgram.mFeatures.isShiny = true;
 			gSkinnedObjectShinySimpleProgram.mFeatures.disableTextureIndex = true;
 			gSkinnedObjectShinySimpleProgram.mShaderFiles.clear();
-			gSkinnedObjectShinySimpleProgram.mShaderFiles.push_back(std::make_pair("objects/shinySimpleSkinnedV.glsl", GL_VERTEX_SHADER));
-			gSkinnedObjectShinySimpleProgram.mShaderFiles.push_back(std::make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER));
+			gSkinnedObjectShinySimpleProgram.mShaderFiles.emplace_back("objects/shinySimpleSkinnedV.glsl", GL_VERTEX_SHADER);
+			gSkinnedObjectShinySimpleProgram.mShaderFiles.emplace_back("objects/shinyF.glsl", GL_FRAGMENT_SHADER);
 			gSkinnedObjectShinySimpleProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 			success = gSkinnedObjectShinySimpleProgram.createShader(nullptr, nullptr);
 		}
@@ -2882,8 +2880,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectSimpleWaterProgram.mFeatures.disableTextureIndex = true;
 			gSkinnedObjectSimpleWaterProgram.mFeatures.hasAlphaMask = true;
 			gSkinnedObjectSimpleWaterProgram.mShaderFiles.clear();
-			gSkinnedObjectSimpleWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleSkinnedV.glsl", GL_VERTEX_SHADER));
-			gSkinnedObjectSimpleWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
+			gSkinnedObjectSimpleWaterProgram.mShaderFiles.emplace_back("objects/simpleSkinnedV.glsl", GL_VERTEX_SHADER);
+			gSkinnedObjectSimpleWaterProgram.mShaderFiles.emplace_back("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER);
 			gSkinnedObjectSimpleWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 			success = gSkinnedObjectSimpleWaterProgram.createShader(nullptr, nullptr);
 		}
@@ -2901,8 +2899,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectFullbrightWaterProgram.mFeatures.disableTextureIndex = true;
 			gSkinnedObjectFullbrightWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 			gSkinnedObjectFullbrightWaterProgram.mShaderFiles.clear();
-			gSkinnedObjectFullbrightWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightSkinnedV.glsl", GL_VERTEX_SHADER));
-			gSkinnedObjectFullbrightWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER));
+			gSkinnedObjectFullbrightWaterProgram.mShaderFiles.emplace_back("objects/fullbrightSkinnedV.glsl", GL_VERTEX_SHADER);
+			gSkinnedObjectFullbrightWaterProgram.mShaderFiles.emplace_back("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER);
 			gSkinnedObjectFullbrightWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 			success = gSkinnedObjectFullbrightWaterProgram.createShader(nullptr, nullptr);
 		}
@@ -2921,8 +2919,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectFullbrightShinyWaterProgram.mFeatures.disableTextureIndex = true;
 			gSkinnedObjectFullbrightShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 			gSkinnedObjectFullbrightShinyWaterProgram.mShaderFiles.clear();
-			gSkinnedObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinySkinnedV.glsl", GL_VERTEX_SHADER));
-			gSkinnedObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(std::make_pair("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER));
+			gSkinnedObjectFullbrightShinyWaterProgram.mShaderFiles.emplace_back("objects/fullbrightShinySkinnedV.glsl", GL_VERTEX_SHADER);
+			gSkinnedObjectFullbrightShinyWaterProgram.mShaderFiles.emplace_back("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER);
 			gSkinnedObjectFullbrightShinyWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 			success = gSkinnedObjectFullbrightShinyWaterProgram.createShader(nullptr, nullptr);
 		}
@@ -2941,8 +2939,8 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gSkinnedObjectShinySimpleWaterProgram.mFeatures.disableTextureIndex = true;
 			gSkinnedObjectShinySimpleWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 			gSkinnedObjectShinySimpleWaterProgram.mShaderFiles.clear();
-			gSkinnedObjectShinySimpleWaterProgram.mShaderFiles.push_back(std::make_pair("objects/shinySimpleSkinnedV.glsl", GL_VERTEX_SHADER));
-			gSkinnedObjectShinySimpleWaterProgram.mShaderFiles.push_back(std::make_pair("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER));
+			gSkinnedObjectShinySimpleWaterProgram.mShaderFiles.emplace_back("objects/shinySimpleSkinnedV.glsl", GL_VERTEX_SHADER);
+			gSkinnedObjectShinySimpleWaterProgram.mShaderFiles.emplace_back("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER);
 			gSkinnedObjectShinySimpleWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
 			success = gSkinnedObjectShinySimpleWaterProgram.createShader(nullptr, nullptr);
 		}
@@ -2981,8 +2979,8 @@ BOOL LLViewerShaderMgr::loadShadersAvatar()
 		gAvatarProgram.mFeatures.hasAlphaMask = true;
 		gAvatarProgram.mFeatures.disableTextureIndex = true;
 		gAvatarProgram.mShaderFiles.clear();
-		gAvatarProgram.mShaderFiles.push_back(std::make_pair("avatar/avatarV.glsl", GL_VERTEX_SHADER));
-		gAvatarProgram.mShaderFiles.push_back(std::make_pair("avatar/avatarF.glsl", GL_FRAGMENT_SHADER));
+		gAvatarProgram.mShaderFiles.emplace_back("avatar/avatarV.glsl", GL_VERTEX_SHADER);
+		gAvatarProgram.mShaderFiles.emplace_back("avatar/avatarF.glsl", GL_FRAGMENT_SHADER);
 		gAvatarProgram.mShaderLevel = mVertexShaderLevel[SHADER_AVATAR];
 		success = gAvatarProgram.createShader(nullptr, nullptr);
 			
@@ -2998,8 +2996,8 @@ BOOL LLViewerShaderMgr::loadShadersAvatar()
 			gAvatarWaterProgram.mFeatures.hasAlphaMask = true;
 			gAvatarWaterProgram.mFeatures.disableTextureIndex = true;
 			gAvatarWaterProgram.mShaderFiles.clear();
-			gAvatarWaterProgram.mShaderFiles.push_back(std::make_pair("avatar/avatarV.glsl", GL_VERTEX_SHADER));
-			gAvatarWaterProgram.mShaderFiles.push_back(std::make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER));
+			gAvatarWaterProgram.mShaderFiles.emplace_back("avatar/avatarV.glsl", GL_VERTEX_SHADER);
+			gAvatarWaterProgram.mShaderFiles.emplace_back("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER);
 			// Note: no cloth under water:
 			gAvatarWaterProgram.mShaderLevel = llmin(mVertexShaderLevel[SHADER_AVATAR], 1);	
 			gAvatarWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;				
@@ -3019,8 +3017,8 @@ BOOL LLViewerShaderMgr::loadShadersAvatar()
 		gAvatarPickProgram.mFeatures.hasSkinning = true;
 		gAvatarPickProgram.mFeatures.disableTextureIndex = true;
 		gAvatarPickProgram.mShaderFiles.clear();
-		gAvatarPickProgram.mShaderFiles.push_back(std::make_pair("avatar/pickAvatarV.glsl", GL_VERTEX_SHADER));
-		gAvatarPickProgram.mShaderFiles.push_back(std::make_pair("avatar/pickAvatarF.glsl", GL_FRAGMENT_SHADER));
+		gAvatarPickProgram.mShaderFiles.emplace_back("avatar/pickAvatarV.glsl", GL_VERTEX_SHADER);
+		gAvatarPickProgram.mShaderFiles.emplace_back("avatar/pickAvatarF.glsl", GL_FRAGMENT_SHADER);
 		gAvatarPickProgram.mShaderLevel = mVertexShaderLevel[SHADER_AVATAR];
 		success = gAvatarPickProgram.createShader(nullptr, nullptr);
 	}
@@ -3049,8 +3047,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gHighlightProgram.mName = "Highlight Shader";
 		gHighlightProgram.mShaderFiles.clear();
-		gHighlightProgram.mShaderFiles.push_back(std::make_pair("interface/highlightV.glsl", GL_VERTEX_SHADER));
-		gHighlightProgram.mShaderFiles.push_back(std::make_pair("interface/highlightF.glsl", GL_FRAGMENT_SHADER));
+		gHighlightProgram.mShaderFiles.emplace_back("interface/highlightV.glsl", GL_VERTEX_SHADER);
+		gHighlightProgram.mShaderFiles.emplace_back("interface/highlightF.glsl", GL_FRAGMENT_SHADER);
 		gHighlightProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];		
 		success = gHighlightProgram.createShader(nullptr, nullptr);
 	}
@@ -3059,8 +3057,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gHighlightNormalProgram.mName = "Highlight Normals Shader";
 		gHighlightNormalProgram.mShaderFiles.clear();
-		gHighlightNormalProgram.mShaderFiles.push_back(std::make_pair("interface/highlightNormV.glsl", GL_VERTEX_SHADER));
-		gHighlightNormalProgram.mShaderFiles.push_back(std::make_pair("interface/highlightF.glsl", GL_FRAGMENT_SHADER));
+		gHighlightNormalProgram.mShaderFiles.emplace_back("interface/highlightNormV.glsl", GL_VERTEX_SHADER);
+		gHighlightNormalProgram.mShaderFiles.emplace_back("interface/highlightF.glsl", GL_FRAGMENT_SHADER);
 		gHighlightNormalProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];		
 		success = gHighlightNormalProgram.createShader(nullptr, nullptr);
 	}
@@ -3069,8 +3067,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gHighlightSpecularProgram.mName = "Highlight Spec Shader";
 		gHighlightSpecularProgram.mShaderFiles.clear();
-		gHighlightSpecularProgram.mShaderFiles.push_back(std::make_pair("interface/highlightSpecV.glsl", GL_VERTEX_SHADER));
-		gHighlightSpecularProgram.mShaderFiles.push_back(std::make_pair("interface/highlightF.glsl", GL_FRAGMENT_SHADER));
+		gHighlightSpecularProgram.mShaderFiles.emplace_back("interface/highlightSpecV.glsl", GL_VERTEX_SHADER);
+		gHighlightSpecularProgram.mShaderFiles.emplace_back("interface/highlightF.glsl", GL_FRAGMENT_SHADER);
 		gHighlightSpecularProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];		
 		success = gHighlightSpecularProgram.createShader(nullptr, nullptr);
 	}
@@ -3079,8 +3077,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gUIProgram.mName = "UI Shader";
 		gUIProgram.mShaderFiles.clear();
-		gUIProgram.mShaderFiles.push_back(std::make_pair("interface/uiV.glsl", GL_VERTEX_SHADER));
-		gUIProgram.mShaderFiles.push_back(std::make_pair("interface/uiF.glsl", GL_FRAGMENT_SHADER));
+		gUIProgram.mShaderFiles.emplace_back("interface/uiV.glsl", GL_VERTEX_SHADER);
+		gUIProgram.mShaderFiles.emplace_back("interface/uiF.glsl", GL_FRAGMENT_SHADER);
 		gUIProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gUIProgram.createShader(nullptr, nullptr);
 	}
@@ -3089,8 +3087,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gCustomAlphaProgram.mName = "Custom Alpha Shader";
 		gCustomAlphaProgram.mShaderFiles.clear();
-		gCustomAlphaProgram.mShaderFiles.push_back(std::make_pair("interface/customalphaV.glsl", GL_VERTEX_SHADER));
-		gCustomAlphaProgram.mShaderFiles.push_back(std::make_pair("interface/customalphaF.glsl", GL_FRAGMENT_SHADER));
+		gCustomAlphaProgram.mShaderFiles.emplace_back("interface/customalphaV.glsl", GL_VERTEX_SHADER);
+		gCustomAlphaProgram.mShaderFiles.emplace_back("interface/customalphaF.glsl", GL_FRAGMENT_SHADER);
 		gCustomAlphaProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gCustomAlphaProgram.createShader(nullptr, nullptr);
 	}
@@ -3099,8 +3097,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gSplatTextureRectProgram.mName = "Splat Texture Rect Shader";
 		gSplatTextureRectProgram.mShaderFiles.clear();
-		gSplatTextureRectProgram.mShaderFiles.push_back(std::make_pair("interface/splattexturerectV.glsl", GL_VERTEX_SHADER));
-		gSplatTextureRectProgram.mShaderFiles.push_back(std::make_pair("interface/splattexturerectF.glsl", GL_FRAGMENT_SHADER));
+		gSplatTextureRectProgram.mShaderFiles.emplace_back("interface/splattexturerectV.glsl", GL_VERTEX_SHADER);
+		gSplatTextureRectProgram.mShaderFiles.emplace_back("interface/splattexturerectF.glsl", GL_FRAGMENT_SHADER);
 		gSplatTextureRectProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gSplatTextureRectProgram.createShader(nullptr, nullptr);
 		if (success)
@@ -3115,8 +3113,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gGlowCombineProgram.mName = "Glow Combine Shader";
 		gGlowCombineProgram.mShaderFiles.clear();
-		gGlowCombineProgram.mShaderFiles.push_back(std::make_pair("interface/glowcombineV.glsl", GL_VERTEX_SHADER));
-		gGlowCombineProgram.mShaderFiles.push_back(std::make_pair("interface/glowcombineF.glsl", GL_FRAGMENT_SHADER));
+		gGlowCombineProgram.mShaderFiles.emplace_back("interface/glowcombineV.glsl", GL_VERTEX_SHADER);
+		gGlowCombineProgram.mShaderFiles.emplace_back("interface/glowcombineF.glsl", GL_FRAGMENT_SHADER);
 		gGlowCombineProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gGlowCombineProgram.createShader(nullptr, nullptr);
 		if (success)
@@ -3132,8 +3130,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gGlowCombineFXAAProgram.mName = "Glow CombineFXAA Shader";
 		gGlowCombineFXAAProgram.mShaderFiles.clear();
-		gGlowCombineFXAAProgram.mShaderFiles.push_back(std::make_pair("interface/glowcombineFXAAV.glsl", GL_VERTEX_SHADER));
-		gGlowCombineFXAAProgram.mShaderFiles.push_back(std::make_pair("interface/glowcombineFXAAF.glsl", GL_FRAGMENT_SHADER));
+		gGlowCombineFXAAProgram.mShaderFiles.emplace_back("interface/glowcombineFXAAV.glsl", GL_VERTEX_SHADER);
+		gGlowCombineFXAAProgram.mShaderFiles.emplace_back("interface/glowcombineFXAAF.glsl", GL_FRAGMENT_SHADER);
 		gGlowCombineFXAAProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gGlowCombineFXAAProgram.createShader(nullptr, nullptr);
 		if (success)
@@ -3150,8 +3148,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gTwoTextureAddProgram.mName = "Two Texture Add Shader";
 		gTwoTextureAddProgram.mShaderFiles.clear();
-		gTwoTextureAddProgram.mShaderFiles.push_back(std::make_pair("interface/twotextureaddV.glsl", GL_VERTEX_SHADER));
-		gTwoTextureAddProgram.mShaderFiles.push_back(std::make_pair("interface/twotextureaddF.glsl", GL_FRAGMENT_SHADER));
+		gTwoTextureAddProgram.mShaderFiles.emplace_back("interface/twotextureaddV.glsl", GL_VERTEX_SHADER);
+		gTwoTextureAddProgram.mShaderFiles.emplace_back("interface/twotextureaddF.glsl", GL_FRAGMENT_SHADER);
 		gTwoTextureAddProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gTwoTextureAddProgram.createShader(nullptr, nullptr);
 		if (success)
@@ -3167,8 +3165,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gTwoTextureCompareProgram.mName = "Two Texture Compare Shader";
 		gTwoTextureCompareProgram.mShaderFiles.clear();
-		gTwoTextureCompareProgram.mShaderFiles.push_back(std::make_pair("interface/twotexturecompareV.glsl", GL_VERTEX_SHADER));
-		gTwoTextureCompareProgram.mShaderFiles.push_back(std::make_pair("interface/twotexturecompareF.glsl", GL_FRAGMENT_SHADER));
+		gTwoTextureCompareProgram.mShaderFiles.emplace_back("interface/twotexturecompareV.glsl", GL_VERTEX_SHADER);
+		gTwoTextureCompareProgram.mShaderFiles.emplace_back("interface/twotexturecompareF.glsl", GL_FRAGMENT_SHADER);
 		gTwoTextureCompareProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gTwoTextureCompareProgram.createShader(nullptr, nullptr);
 		if (success)
@@ -3184,8 +3182,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gOneTextureFilterProgram.mName = "One Texture Filter Shader";
 		gOneTextureFilterProgram.mShaderFiles.clear();
-		gOneTextureFilterProgram.mShaderFiles.push_back(std::make_pair("interface/onetexturefilterV.glsl", GL_VERTEX_SHADER));
-		gOneTextureFilterProgram.mShaderFiles.push_back(std::make_pair("interface/onetexturefilterF.glsl", GL_FRAGMENT_SHADER));
+		gOneTextureFilterProgram.mShaderFiles.emplace_back("interface/onetexturefilterV.glsl", GL_VERTEX_SHADER);
+		gOneTextureFilterProgram.mShaderFiles.emplace_back("interface/onetexturefilterF.glsl", GL_FRAGMENT_SHADER);
 		gOneTextureFilterProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gOneTextureFilterProgram.createShader(nullptr, nullptr);
 		if (success)
@@ -3200,8 +3198,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gOneTextureNoColorProgram.mName = "One Texture No Color Shader";
 		gOneTextureNoColorProgram.mShaderFiles.clear();
-		gOneTextureNoColorProgram.mShaderFiles.push_back(std::make_pair("interface/onetexturenocolorV.glsl", GL_VERTEX_SHADER));
-		gOneTextureNoColorProgram.mShaderFiles.push_back(std::make_pair("interface/onetexturenocolorF.glsl", GL_FRAGMENT_SHADER));
+		gOneTextureNoColorProgram.mShaderFiles.emplace_back("interface/onetexturenocolorV.glsl", GL_VERTEX_SHADER);
+		gOneTextureNoColorProgram.mShaderFiles.emplace_back("interface/onetexturenocolorF.glsl", GL_FRAGMENT_SHADER);
 		gOneTextureNoColorProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gOneTextureNoColorProgram.createShader(nullptr, nullptr);
 		if (success)
@@ -3215,8 +3213,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gSolidColorProgram.mName = "Solid Color Shader";
 		gSolidColorProgram.mShaderFiles.clear();
-		gSolidColorProgram.mShaderFiles.push_back(std::make_pair("interface/solidcolorV.glsl", GL_VERTEX_SHADER));
-		gSolidColorProgram.mShaderFiles.push_back(std::make_pair("interface/solidcolorF.glsl", GL_FRAGMENT_SHADER));
+		gSolidColorProgram.mShaderFiles.emplace_back("interface/solidcolorV.glsl", GL_VERTEX_SHADER);
+		gSolidColorProgram.mShaderFiles.emplace_back("interface/solidcolorF.glsl", GL_FRAGMENT_SHADER);
 		gSolidColorProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gSolidColorProgram.createShader(nullptr, nullptr);
 		if (success)
@@ -3231,8 +3229,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gOcclusionProgram.mName = "Occlusion Shader";
 		gOcclusionProgram.mShaderFiles.clear();
-		gOcclusionProgram.mShaderFiles.push_back(std::make_pair("interface/occlusionV.glsl", GL_VERTEX_SHADER));
-		gOcclusionProgram.mShaderFiles.push_back(std::make_pair("interface/occlusionF.glsl", GL_FRAGMENT_SHADER));
+		gOcclusionProgram.mShaderFiles.emplace_back("interface/occlusionV.glsl", GL_VERTEX_SHADER);
+		gOcclusionProgram.mShaderFiles.emplace_back("interface/occlusionF.glsl", GL_FRAGMENT_SHADER);
 		gOcclusionProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gOcclusionProgram.createShader(nullptr, nullptr);
 	}
@@ -3241,8 +3239,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gOcclusionCubeProgram.mName = "Occlusion Cube Shader";
 		gOcclusionCubeProgram.mShaderFiles.clear();
-		gOcclusionCubeProgram.mShaderFiles.push_back(std::make_pair("interface/occlusionCubeV.glsl", GL_VERTEX_SHADER));
-		gOcclusionCubeProgram.mShaderFiles.push_back(std::make_pair("interface/occlusionF.glsl", GL_FRAGMENT_SHADER));
+		gOcclusionCubeProgram.mShaderFiles.emplace_back("interface/occlusionCubeV.glsl", GL_VERTEX_SHADER);
+		gOcclusionCubeProgram.mShaderFiles.emplace_back("interface/occlusionF.glsl", GL_FRAGMENT_SHADER);
 		gOcclusionCubeProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gOcclusionCubeProgram.createShader(nullptr, nullptr);
 	}
@@ -3251,8 +3249,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gDebugProgram.mName = "Debug Shader";
 		gDebugProgram.mShaderFiles.clear();
-		gDebugProgram.mShaderFiles.push_back(std::make_pair("interface/debugV.glsl", GL_VERTEX_SHADER));
-		gDebugProgram.mShaderFiles.push_back(std::make_pair("interface/debugF.glsl", GL_FRAGMENT_SHADER));
+		gDebugProgram.mShaderFiles.emplace_back("interface/debugV.glsl", GL_VERTEX_SHADER);
+		gDebugProgram.mShaderFiles.emplace_back("interface/debugF.glsl", GL_FRAGMENT_SHADER);
 		gDebugProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gDebugProgram.createShader(nullptr, nullptr);
 	}
@@ -3261,8 +3259,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gClipProgram.mName = "Clip Shader";
 		gClipProgram.mShaderFiles.clear();
-		gClipProgram.mShaderFiles.push_back(std::make_pair("interface/clipV.glsl", GL_VERTEX_SHADER));
-		gClipProgram.mShaderFiles.push_back(std::make_pair("interface/clipF.glsl", GL_FRAGMENT_SHADER));
+		gClipProgram.mShaderFiles.emplace_back("interface/clipV.glsl", GL_VERTEX_SHADER);
+		gClipProgram.mShaderFiles.emplace_back("interface/clipF.glsl", GL_FRAGMENT_SHADER);
 		gClipProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gClipProgram.createShader(nullptr, nullptr);
 	}
@@ -3271,8 +3269,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gDownsampleDepthProgram.mName = "DownsampleDepth Shader";
 		gDownsampleDepthProgram.mShaderFiles.clear();
-		gDownsampleDepthProgram.mShaderFiles.push_back(std::make_pair("interface/downsampleDepthV.glsl", GL_VERTEX_SHADER));
-		gDownsampleDepthProgram.mShaderFiles.push_back(std::make_pair("interface/downsampleDepthF.glsl", GL_FRAGMENT_SHADER));
+		gDownsampleDepthProgram.mShaderFiles.emplace_back("interface/downsampleDepthV.glsl", GL_VERTEX_SHADER);
+		gDownsampleDepthProgram.mShaderFiles.emplace_back("interface/downsampleDepthF.glsl", GL_FRAGMENT_SHADER);
 		gDownsampleDepthProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gDownsampleDepthProgram.createShader(nullptr, nullptr);
 	}
@@ -3281,8 +3279,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gBenchmarkProgram.mName = "Benchmark Shader";
 		gBenchmarkProgram.mShaderFiles.clear();
-		gBenchmarkProgram.mShaderFiles.push_back(std::make_pair("interface/benchmarkV.glsl", GL_VERTEX_SHADER));
-		gBenchmarkProgram.mShaderFiles.push_back(std::make_pair("interface/benchmarkF.glsl", GL_FRAGMENT_SHADER));
+		gBenchmarkProgram.mShaderFiles.emplace_back("interface/benchmarkV.glsl", GL_VERTEX_SHADER);
+		gBenchmarkProgram.mShaderFiles.emplace_back("interface/benchmarkF.glsl", GL_FRAGMENT_SHADER);
 		gBenchmarkProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gBenchmarkProgram.createShader(nullptr, nullptr);
 	}
@@ -3291,8 +3289,8 @@ BOOL LLViewerShaderMgr::loadShadersInterface()
 	{
 		gAlphaMaskProgram.mName = "Alpha Mask Shader";
 		gAlphaMaskProgram.mShaderFiles.clear();
-		gAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("interface/alphamaskV.glsl", GL_VERTEX_SHADER));
-		gAlphaMaskProgram.mShaderFiles.push_back(std::make_pair("interface/alphamaskF.glsl", GL_FRAGMENT_SHADER));
+		gAlphaMaskProgram.mShaderFiles.emplace_back("interface/alphamaskV.glsl", GL_VERTEX_SHADER);
+		gAlphaMaskProgram.mShaderFiles.emplace_back("interface/alphamaskF.glsl", GL_FRAGMENT_SHADER);
 		gAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_INTERFACE];
 		success = gAlphaMaskProgram.createShader(nullptr, nullptr);
 	}
@@ -3322,8 +3320,8 @@ BOOL LLViewerShaderMgr::loadShadersWindLight()
 		gWLSkyProgram.mName = "Windlight Sky Shader";
 		//gWLSkyProgram.mFeatures.hasGamma = true;
 		gWLSkyProgram.mShaderFiles.clear();
-		gWLSkyProgram.mShaderFiles.push_back(std::make_pair("windlight/skyV.glsl", GL_VERTEX_SHADER));
-		gWLSkyProgram.mShaderFiles.push_back(std::make_pair("windlight/skyF.glsl", GL_FRAGMENT_SHADER));
+		gWLSkyProgram.mShaderFiles.emplace_back("windlight/skyV.glsl", GL_VERTEX_SHADER);
+		gWLSkyProgram.mShaderFiles.emplace_back("windlight/skyF.glsl", GL_FRAGMENT_SHADER);
 		gWLSkyProgram.mShaderLevel = mVertexShaderLevel[SHADER_WINDLIGHT];
 		gWLSkyProgram.mShaderGroup = LLGLSLShader::SG_SKY;
 		success = gWLSkyProgram.createShader(nullptr, nullptr);
@@ -3334,8 +3332,8 @@ BOOL LLViewerShaderMgr::loadShadersWindLight()
 		gWLCloudProgram.mName = "Windlight Cloud Program";
 		//gWLCloudProgram.mFeatures.hasGamma = true;
 		gWLCloudProgram.mShaderFiles.clear();
-		gWLCloudProgram.mShaderFiles.push_back(std::make_pair("windlight/cloudsV.glsl", GL_VERTEX_SHADER));
-		gWLCloudProgram.mShaderFiles.push_back(std::make_pair("windlight/cloudsF.glsl", GL_FRAGMENT_SHADER));
+		gWLCloudProgram.mShaderFiles.emplace_back("windlight/cloudsV.glsl", GL_VERTEX_SHADER);
+		gWLCloudProgram.mShaderFiles.emplace_back("windlight/cloudsF.glsl", GL_FRAGMENT_SHADER);
 		gWLCloudProgram.mShaderLevel = mVertexShaderLevel[SHADER_WINDLIGHT];
 		gWLCloudProgram.mShaderGroup = LLGLSLShader::SG_SKY;
 		success = gWLCloudProgram.createShader(nullptr, nullptr);
diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index 10f736f9f99a74c7ce6a647761c3b77a4543a646..1420dcec17d35f0dff08a4100fa5c2f5bf8e72d6 100644
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -3655,7 +3655,7 @@ void LLViewerMediaTexture::addFace(U32 ch, LLFace* facep)
 		LLViewerTexture* tex = gTextureList.findImage(te->getID(), TEX_LIST_STANDARD);
 		if(tex)
 		{
-			mTextureList.push_back(tex);//increase the reference number by one for tex to avoid deleting it.
+			mTextureList.emplace_back(tex);//increase the reference number by one for tex to avoid deleting it.
 			return;
 		}
 	}
@@ -3663,7 +3663,7 @@ void LLViewerMediaTexture::addFace(U32 ch, LLFace* facep)
 	//check if it is a parcel media
 	if(facep->getTexture() && facep->getTexture() != this && facep->getTexture()->getID() == mID)
 	{
-		mTextureList.push_back(facep->getTexture()); //a parcel media.
+		mTextureList.emplace_back(facep->getTexture()); //a parcel media.
 		return;
 	}
 	
diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp
index b05db96351107c41e23548a728076c9d5a8d6c05..fc9e28fa7a9e8fdb6a416d49d6392a2180abea29 100644
--- a/indra/newview/llviewertexturelist.cpp
+++ b/indra/newview/llviewertexturelist.cpp
@@ -1206,7 +1206,7 @@ void LLViewerTextureList::decodeAllImages(F32 max_time)
 		 iter != mImageList.end(); )
 	{
 		LLViewerFetchedTexture* imagep = *iter++;
-		image_list.push_back(imagep);
+		image_list.emplace_back(imagep);
 		imagep->setInImageList(FALSE) ;
 	}
 
@@ -1737,7 +1737,7 @@ LLUIImagePtr LLUIImageList::loadUIImage(LLViewerFetchedTexture* imagep, const st
 		// all UI images are non-deletable and list does not support deletion
 		imagep->setNoDelete();
 		mUIImages.emplace(name, new_imagep);
-		mUITextureList.push_back(imagep);
+		mUITextureList.emplace_back(imagep);
 	}
 
 	//Note:
diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp
index b087e07d42dce05e2c2c4f7d89173e4ccc036dc2..593b02f65eb510cb57072f6d8f06e304fd123e53 100644
--- a/indra/newview/llvoavatar.cpp
+++ b/indra/newview/llvoavatar.cpp
@@ -7027,7 +7027,7 @@ void LLVOAvatar::addChild(LLViewerObject *childp)
 	}
 	else
 	{
-		mPendingAttachment.push_back(childp);
+		mPendingAttachment.emplace_back(childp);
 	}
 }
 
diff --git a/indra/newview/llvoavatarself.cpp b/indra/newview/llvoavatarself.cpp
index e7973690863cefd87faee81558f2f7b8d8af6853..0152795d82a3525f759a0a9bc3831bfead5ce28b 100644
--- a/indra/newview/llvoavatarself.cpp
+++ b/indra/newview/llvoavatarself.cpp
@@ -2361,7 +2361,7 @@ void LLVOAvatarSelf::appearanceChangeMetricsCoro(std::string url)
     msg["nearby"] = LLSD::emptyArray();
     std::vector<S32> rez_counts;
     LLVOAvatar::getNearbyRezzedStats(rez_counts);
-    for (S32 rez_stat = 0; rez_stat < rez_counts.size(); ++rez_stat)
+    for (auto rez_stat = 0; rez_stat < rez_counts.size(); ++rez_stat)
     {
         std::string rez_status_name = LLVOAvatar::rezStatusToString(rez_stat);
         msg["nearby"][rez_status_name] = rez_counts[rez_stat];
@@ -2369,13 +2369,13 @@ void LLVOAvatarSelf::appearanceChangeMetricsCoro(std::string url)
 
     //	std::vector<std::string> bucket_fields("timer_name","is_self","grid_x","grid_y","is_using_server_bake");
     std::vector<std::string> by_fields;
-    by_fields.push_back("timer_name");
-    by_fields.push_back("completed");
-    by_fields.push_back("grid_x");
-    by_fields.push_back("grid_y");
-    by_fields.push_back("is_using_server_bakes");
-    by_fields.push_back("is_self");
-    by_fields.push_back("central_bake_version");
+    by_fields.emplace_back("timer_name");
+    by_fields.emplace_back("completed");
+    by_fields.emplace_back("grid_x");
+    by_fields.emplace_back("grid_y");
+    by_fields.emplace_back("is_using_server_bakes");
+    by_fields.emplace_back("is_self");
+    by_fields.emplace_back("central_bake_version");
     LLSD summary = summarize_by_buckets(mPendingTimerRecords, by_fields, std::string("elapsed"));
     msg["timers"] = summary;
 
diff --git a/indra/newview/llvosky.cpp b/indra/newview/llvosky.cpp
index 3adfe9562a8339f7b77f7bc6c9c1f4a3951dd1a4..0c0857ad3a54f16461d48ffd4ac2defbb3604b76 100644
--- a/indra/newview/llvosky.cpp
+++ b/indra/newview/llvosky.cpp
@@ -438,7 +438,7 @@ void LLVOSky::initCubeMap()
 	std::vector<LLPointer<LLImageRaw> > images;
 	for (S32 side = 0; side < 6; side++)
 	{
-		images.push_back(mShinyTex[side].getImageRaw());
+		images.emplace_back(mShinyTex[side].getImageRaw());
 	}
 	if (mCubeMap)
 	{
diff --git a/indra/newview/llwaterparamset.h b/indra/newview/llwaterparamset.h
index cdfb2eb34f04e089ff73754446c387b4c61b0099..c8648d5f70b0418bba787ed348f94e2451692b18 100644
--- a/indra/newview/llwaterparamset.h
+++ b/indra/newview/llwaterparamset.h
@@ -147,7 +147,7 @@ inline void LLWaterParamSet::updateHashedNames()
 	// Iterate through values
 	for(LLSD::map_iterator iter = mParamValues.beginMap(); iter != mParamValues.endMap(); ++iter)
 	{
-		mParamHashedNames.push_back(LLStaticHashedString(iter->first));
+		mParamHashedNames.emplace_back(iter->first);
 	}
 }
 
diff --git a/indra/newview/llwlparamset.cpp b/indra/newview/llwlparamset.cpp
index 5aaa20aabced7268bd0aed358692af4ea1d847be..eca649e45fd8f11b785f50af0d85d8e3cb163bc0 100644
--- a/indra/newview/llwlparamset.cpp
+++ b/indra/newview/llwlparamset.cpp
@@ -398,9 +398,9 @@ void LLWLParamSet::updateHashedNames()
 {
 	mParamHashedNames.clear();
 	// Iterate through values
-	for(LLSD::map_iterator iter = mParamValues.beginMap(); iter != mParamValues.endMap(); ++iter)
+	for(auto iter = mParamValues.beginMap(); iter != mParamValues.endMap(); ++iter)
 	{
-		mParamHashedNames.push_back(LLStaticHashedString(iter->first));
+		mParamHashedNames.emplace_back(iter->first);
 	}
 }
 
diff --git a/indra/newview/qtoolalign.cpp b/indra/newview/qtoolalign.cpp
index 08d1a425a409a40ad40e83bdf0533dc97146edd7..5e1ef0cc3dd5b1b106410a39f20d8a1b6f4c12c1 100644
--- a/indra/newview/qtoolalign.cpp
+++ b/indra/newview/qtoolalign.cpp
@@ -425,7 +425,7 @@ void QToolAlign::align()
 					bbox.addBBoxAgent(child->getBoundingBoxAgent());
 				}
 
-				objects.push_back(object);
+				objects.emplace_back(object);
 				original_bboxes[object] = bbox;
 			}
 		}