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; } }