locale: Add missing and remove unused strings

data/locale/en-US.ini

@@ -46,23 +46,23 @@ UI.About.Role.Creator="Content Creator"
 
 # Blur
 Blur.Type.Box="Box"
-Blur.Type.Box.Description="Box blur (named for its distinct shape) is a simple average over a number of pixels, resulting in a box like look."
+Blur.Type.Box.Description="The 'Box' blur takes the average of all pixels in the given area, which results in its distinct box shape."
 Blur.Type.BoxLinear="Box Linear"
-Blur.Type.BoxLinear.Description="Box blur (named for its distinct shape) is a simple average over a number of pixels, resulting in a box like look.\nThis is a linear optimized version of the normal Box blur."
+Blur.Type.BoxLinear.Description="This is a slightly optimized version of the 'Box' blur, which attempts to halve the required samples at the cost of some quality."
 Blur.Type.Gaussian="Gaussian"
-Blur.Type.Gaussian.Description="Gaussian blur uses the Gaussian Bell curve as a weight for each sampled pixel, resulting in a smooth look."
+Blur.Type.Gaussian.Description="The 'Gaussian' uses the gaussian bell curve as a weight for each pixel to add in the given area, which results in a smooth shape. This is a very expensive blur, and should be avoided unless necessary - consider using 'Dual Filtering' for larger blur sizes instead."
 Blur.Type.GaussianLinear="Gaussian Linear"
-Blur.Type.GaussianLinear.Description="Gaussian blur uses the Gaussian Bell curve as a weight for each sampled pixel, resulting in a smooth look.\nThis is a linear optimized version of the normal Gaussian blur, but might look slightly worse."
+Blur.Type.GaussianLinear.Description="This is a slightly optimized version of the 'Gaussian' blur, which attempts to halve the required samples at the cost of quality. In almost all cases it is recommended to instead use 'Dual Filtering' if performance matters."
 Blur.Type.DualFiltering="Dual Filtering"
-Blur.Type.DualFiltering.Description="Dual Filtering is a Gaussian approximation that is able to get similar results as Gaussian blur at much lower cost."
+Blur.Type.DualFiltering.Description="The 'Dual Filtering' method is an approximation of 'Gaussian' blur which achieves a ~95% identical image to 'Gaussian' blur, though has less features available. It's performance impact should be minimal to unnoticable, which makes it perfect for large blur sizes."
 Blur.Subtype.Area="Area"
-Blur.Subtype.Area.Description="Area blur is a two dimensional blur that smoothes out all pixels evenly.\nIt can be compared with an object that is out of focus in a camera."
+Blur.Subtype.Area.Description="Area blurring is the default way to blur and blurs both horizontally and vertically.\nThe effect can be compared to an object that is out of focus in a camera."
 Blur.Subtype.Directional="Directional"
-Blur.Subtype.Directional.Description="Directional blur is a one dimensional blur that smoothes out all pixels in the same direction.\nIt can be compared with moving a camera in one direction."
+Blur.Subtype.Directional.Description="Directional blurring allows control of the exact direction in which blur should happen.\nThe effect is similar to a camera in motion, or an object being in motion."
 Blur.Subtype.Rotational="Rotational"
-Blur.Subtype.Rotational.Description="Rotational blur is a multi dimensional blur that smoothes out pixels by rotating around a center point.\nIt can be compared to rolling a camera in place."
+Blur.Subtype.Rotational.Description="Rotational blurring performs blurring in a circle around a center point.\nThe effect is very similar to rolling a camera around the center point of its sensor."
 Blur.Subtype.Zoom="Zoom"
-Blur.Subtype.Zoom.Description="Zoom blur is a directional blur where the direction and strength of the blur is determined by the position and distance to a center point.\nIt can be compared with moving a camera forwards and backwards."
+Blur.Subtype.Zoom.Description="Zoom blurring performs blurring in a line towards a center point.\nThe effect is similar to moving a camera forward towards to or backwards away from something."
 
 # Mip Generator
 MipGenerator="Mip-Map Generator"
@@ -85,11 +85,15 @@ Shader="Shader"
 Shader.Refresh="Refresh Options and Parameters"
 Shader.Shader="Shader Options"
 Shader.Shader.File="File"
+Shader.Shader.File.Description="Which file should be loaded as a shader?"
 Shader.Shader.Technique="Technique"
+Shader.Shader.Technique.Description="What shader technique should be drawn?"
 Shader.Shader.Size="Size"
+Shader.Shader.Size.Description="Size of the source, can be one of the following units:\n- '###.##%' which is relative to the parent source, filter or scene.\n- '###' to specify the size in pixels. (Default)\nIf the value can't be parsed, it will be treated as 100%."
 Shader.Shader.Size.Width="Width"
 Shader.Shader.Size.Height="Height"
 Shader.Parameters="Shader Parameters"
+Shader.Parameters.Description="All the shader parameters that the loaded shader offers.\nMake sure to refresh these every now and then."
 Filter.Shader="Shader"
 Source.Shader="Shader"
 Transition.Shader="Shader"
@@ -197,6 +201,7 @@ Filter.ColorGrade.Correction.Contrast="Contrast"
 # Filter - Displacement
 Filter.Displacement="Displacement Mapping"
 Filter.Displacement.File="File"
+Filter.Displacement.File.Description="Image file to use as the displacement map."
 Filter.Displacement.Scale="Scale"
 Filter.Displacement.Scale.Description="Scale of the displacement, either in pixels (Scale Type = 100.0) or in UVs (Scale Type = 0.0)."
 Filter.Displacement.Scale.Type="Scaling Type"
@@ -205,14 +210,14 @@ Filter.Displacement.Scale.Type.Description="Type of the displacement scale, with
 # Filter - Dynamic Mask
 Filter.DynamicMask="Dynamic Mask"
 Filter.DynamicMask.Input="Input Source"
-Filter.DynamicMask.Input.Description="The source to use for the complex math that is happening in the filter."
+Filter.DynamicMask.Input.Description="Input source to use for all further calculations, may also be left blank to use itself as the input.\nSets 'source' in the calculation 'mask[%s] = (base[%s] + value[%s][Red] * source[Red] + value[%s][Green] * source[Green] + value[%s][Blue] * source[Blue] + value[%s] * source[Alpha]) * multiplier[%s]'."
 Filter.DynamicMask.Channel="%s Channel"
 Filter.DynamicMask.Channel.Value="Base Value"
-Filter.DynamicMask.Channel.Value.Description="Initial Value for the mask, added to the channel mask."
+Filter.DynamicMask.Channel.Value.Description="The base value before everything else is added to it.\nSets 'base[%s]' in the calculation 'mask[%s] = (base[%s] + value[%s][Red] * source[Red] + value[%s][Green] * source[Green] + value[%s][Blue] * source[Blue] + value[%s] * source[Alpha]) * multiplier[%s]'."
 Filter.DynamicMask.Channel.Multiplier="Multiplier"
-Filter.DynamicMask.Channel.Multiplier.Description="TODO"
+Filter.DynamicMask.Channel.Multiplier.Description="The multiplier value that everything is multiplied with.\nSets 'multiplier[%s]' in the calculation 'mask[%s] = (base[%s] + value[%s][Red] * source[Red] + value[%s][Green] * source[Green] + value[%s][Blue] * source[Blue] + value[%s] * source[Alpha]) * multiplier[%s]'."
 Filter.DynamicMask.Channel.Input="%s Input Value"
-Filter.DynamicMask.Channel.Input.Description="TODO"
+Filter.DynamicMask.Channel.Input.Description="The input value for channel %s.\nSets 'value[%s][%s]' in the calculation 'mask[%s] = (base[%s] + value[%s][Red] * source[Red] + value[%s][Green] * source[Green] + value[%s][Blue] * source[Blue] + value[%s] * source[Alpha]) * multiplier[%s]'."
 
 # Filter - Nvidia Face Tracking
 Filter.Nvidia.FaceTracking="Nvidia Face Tracking"
@@ -323,8 +328,6 @@ Filter.Transform.Mipmapping.Description="Generate mipmaps for the source, so tha
 Source.Mirror="Source Mirror"
 Source.Mirror.Source="Source"
 Source.Mirror.Source.Description="Which Source should be mirrored?"
-Source.Mirror.Source.Size="Source Size"
-Source.Mirror.Source.Size.Description="The size of the source being mirrored. (Automatically updated)"
 Source.Mirror.Source.Audio="Enable Audio"
 Source.Mirror.Source.Audio.Description="Enables audio mirroring from this source."
 Source.Mirror.Source.Audio.Layout="Audio Layout"
@@ -337,33 +340,6 @@ Source.Mirror.Source.Audio.Layout.Quadraphonic="Quadraphonic"
 Source.Mirror.Source.Audio.Layout.QuadraphonicLFE="Quadraphonic With LFE"
 Source.Mirror.Source.Audio.Layout.Surround="Surround"
 Source.Mirror.Source.Audio.Layout.FullSurround="Full Surround"
-Source.Mirror.Scaling="Rescale Source"
-Source.Mirror.Scaling.Description="Should the source be rescaled?"
-Source.Mirror.Scaling.Method="Filter"
-Source.Mirror.Scaling.Method.Description="Which filter should be used for rescaling?"
-Source.Mirror.Scaling.Method.Point="Point"
-Source.Mirror.Scaling.Method.Bilinear="Bilinear"
-Source.Mirror.Scaling.Method.BilinearLowRes="Bilinear (Low Resolution)"
-Source.Mirror.Scaling.Method.Bicubic="Bicubic"
-Source.Mirror.Scaling.Method.Lanczos="Lanczos"
-Source.Mirror.Scaling.Size="Size"
-Source.Mirror.Scaling.Size.Description="What size should we rescale to? (WxH format)"
-Source.Mirror.Scaling.TransformKeepOriginal="Use Original Size for Transforms"
-Source.Mirror.Scaling.TransformKeepOriginal.Description="Should the filter not modify the size of the source?"
-Source.Mirror.Scaling.Bounds="Bounds Type"
-Source.Mirror.Scaling.Bounds.Description="How should the source be rescaled?"
-Source.Mirror.Scaling.Bounds.Stretch="Stretch"
-Source.Mirror.Scaling.Bounds.Stretch.Description="Stretch will rescale the source to match exactly the width and height of the given area.\nThis option will destroy Aspect Ratio."
-Source.Mirror.Scaling.Bounds.Fit="Fit"
-Source.Mirror.Scaling.Bounds.Fit.Description="Fit will rescale the source to match either the height or width, whichever is smaller, of the given area.\nThis option will keep Aspect Ratio."
-Source.Mirror.Scaling.Bounds.Fill="Fill"
-Source.Mirror.Scaling.Bounds.Fill.Description="Fill will rescale the source to match either the height or width, whichever is larger, of the given area.\nThis option will keep Aspect Ratio."
-Source.Mirror.Scaling.Bounds.FillWidth="Fill to Width"
-Source.Mirror.Scaling.Bounds.FillWidth.Description="Fill to Width will rescale the source to match the width of the given area.\nThis option will keep Aspect Ratio."
-Source.Mirror.Scaling.Bounds.FillHeight="Fill to Height"
-Source.Mirror.Scaling.Bounds.FillHeight.Description="Fill to Height will rescale the source to match the height of the given area.\nThis option will keep Aspect Ratio."
-Source.Mirror.Scaling.Alignment="Bounds Alignment"
-Source.Mirror.Scaling.Alignment.Description="How should the source be aligned within the rendering bounds?"
 
 # Codec: H264
 Codec.H264="H264"

source/filters/filter-dynamic-mask.cpp

@@ -179,32 +179,6 @@ void dynamic_mask_instance::input_renamed(obs::deprecated_source*, std::string o
 	obs_source_update(_self, settings);
 }
 
-bool dynamic_mask_instance::modified(void*, obs_properties_t* properties, obs_property_t*,
-									 obs_data_t* settings) noexcept
-try {
-	channel mask = static_cast<channel>(obs_data_get_int(settings, ST_CHANNEL));
-
-	for (auto kv1 : channel_translations) {
-		std::string chv_key = std::string(ST_CHANNEL_VALUE) + "." + kv1.second;
-		obs_property_set_visible(obs_properties_get(properties, chv_key.c_str()), (mask == kv1.first));
-		std::string chm_key = std::string(ST_CHANNEL_MULTIPLIER) + "." + kv1.second;
-		obs_property_set_visible(obs_properties_get(properties, chm_key.c_str()), (mask == kv1.first));
-
-		for (auto kv2 : channel_translations) {
-			std::string io_key = std::string(ST_CHANNEL_INPUT) + "." + kv1.second + "." + kv2.second;
-			obs_property_set_visible(obs_properties_get(properties, io_key.c_str()), (mask == kv1.first));
-		}
-	}
-
-	return true;
-} catch (const std::exception& ex) {
-	LOG_ERROR("Unexpected exception in function '%s': %s.", __FUNCTION_NAME__, ex.what());
-	return false;
-} catch (...) {
-	LOG_ERROR("Unexpected exception in modified_properties callback.");
-	return false;
-}
-
 void dynamic_mask_instance::video_tick(float)
 {
 	_have_input_texture  = false;
@@ -416,7 +390,11 @@ obs_properties_t* dynamic_mask_factory::get_properties2(dynamic_mask_instance* d
 			std::string buf = std::string(ST_CHANNEL_VALUE) + "." + pri_ch;
 			p = obs_properties_add_float_slider(grp, buf.c_str(), _translation_cache.back().c_str(), -100.0, 100.0,
 												0.01);
-			obs_property_set_long_description(p, D_TRANSLATE(ST_CHANNEL_VALUE));
+			_translation_cache.push_back(translate_string(D_TRANSLATE(D_DESC(ST_CHANNEL_VALUE)), D_TRANSLATE(pri_ch),
+														  D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch),
+														  D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch),
+														  D_TRANSLATE(pri_ch)));
+			obs_property_set_long_description(p, _translation_cache.back().c_str());
 		}
 
 		const char* sec_chs[] = {S_CHANNEL_RED, S_CHANNEL_GREEN, S_CHANNEL_BLUE, S_CHANNEL_ALPHA};
@@ -425,7 +403,11 @@ obs_properties_t* dynamic_mask_factory::get_properties2(dynamic_mask_instance* d
 			std::string buf = std::string(ST_CHANNEL_INPUT) + "." + pri_ch + "." + sec_ch;
 			p = obs_properties_add_float_slider(grp, buf.c_str(), _translation_cache.back().c_str(), -100.0, 100.0,
 												0.01);
-			obs_property_set_long_description(p, D_TRANSLATE(ST_CHANNEL_INPUT));
+			_translation_cache.push_back(translate_string(D_TRANSLATE(D_DESC(ST_CHANNEL_INPUT)), D_TRANSLATE(sec_ch),
+														  D_TRANSLATE(pri_ch), D_TRANSLATE(sec_ch), D_TRANSLATE(pri_ch),
+														  D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch),
+														  D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch)));
+			obs_property_set_long_description(p, _translation_cache.back().c_str());
 		}
 
 		{
@@ -433,7 +415,11 @@ obs_properties_t* dynamic_mask_factory::get_properties2(dynamic_mask_instance* d
 			std::string buf = std::string(ST_CHANNEL_MULTIPLIER) + "." + pri_ch;
 			p = obs_properties_add_float_slider(grp, buf.c_str(), _translation_cache.back().c_str(), -100.0, 100.0,
 												0.01);
-			obs_property_set_long_description(p, D_TRANSLATE(ST_CHANNEL_MULTIPLIER));
+			_translation_cache.push_back(translate_string(D_TRANSLATE(D_DESC(ST_CHANNEL_MULTIPLIER)),
+														  D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch),
+														  D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch),
+														  D_TRANSLATE(pri_ch), D_TRANSLATE(pri_ch)));
+			obs_property_set_long_description(p, _translation_cache.back().c_str());
 		}
 
 		{

source/filters/filter-dynamic-mask.hpp

@@ -72,9 +72,6 @@ namespace streamfx::filter::dynamic_mask {
 
 		void input_renamed(obs::deprecated_source* src, std::string old_name, std::string new_name);
 
-		static bool modified(void* self, obs_properties_t* properties, obs_property_t* property,
-							 obs_data_t* settings) noexcept;
-
 		virtual void video_tick(float_t _time) override;
 		virtual void video_render(gs_effect_t* effect) override;
 	};

source/gfx/shader/gfx-shader.cpp

@@ -229,12 +229,12 @@ void gfx::shader::shader::properties(obs_properties_t* pr)
 			{
 				auto p = obs_properties_add_text(grp2, ST_SHADER_SIZE_WIDTH, D_TRANSLATE(ST_SHADER_SIZE_WIDTH),
 												 OBS_TEXT_DEFAULT);
-				obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_SHADER_SIZE_WIDTH)));
+				obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_SHADER_SIZE)));
 			}
 			{
 				auto p = obs_properties_add_text(grp2, ST_SHADER_SIZE_HEIGHT, D_TRANSLATE(ST_SHADER_SIZE_HEIGHT),
 												 OBS_TEXT_DEFAULT);
-				obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_SHADER_SIZE_HEIGHT)));
+				obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_SHADER_SIZE)));
 			}
 		}
 	}