etc/obs-StreamFX
0
0
Fork 0
mirror of https://github.com/Xaymar/obs-StreamFX synced 2024-12-29 11:01:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

filter/blur: Apply coding guidelines

Browse source
This commit is contained in:
Michael Fabian 'Xaymar' Dirks 2021-06-08 05:30:43 +02:00
parent 5cdf3d1201
commit 66ecc90988
1 changed files with 170 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

312
source/filters/filter-blur.cpp
View file

@ -46,35 +46,58 @@
#endif
// Translation Strings
#define ST "Filter.Blur"
#define ST_I18N "Filter.Blur"
#define ST_TYPE "Filter.Blur.Type"
#define ST_SUBTYPE "Filter.Blur.SubType"
#define ST_SIZE "Filter.Blur.Size"
#define ST_ANGLE "Filter.Blur.Angle"
#define ST_I18N_TYPE "Filter.Blur.Type"
#define ST_KEY_TYPE "Filter.Blur.Type"
#define ST_I18N_SUBTYPE "Filter.Blur.SubType"
#define ST_KEY_SUBTYPE "Filter.Blur.SubType"
#define ST_I18N_SIZE "Filter.Blur.Size"
#define ST_KEY_SIZE "Filter.Blur.Size"
#define ST_I18N_ANGLE "Filter.Blur.Angle"
#define ST_KEY_ANGLE "Filter.Blur.Angle"
#define ST_CENTER "Filter.Blur.Center"
#define ST_CENTER_X "Filter.Blur.Center.X"
#define ST_CENTER_Y "Filter.Blur.Center.Y"
#define ST_STEPSCALE "Filter.Blur.StepScale"
#define ST_STEPSCALE_X "Filter.Blur.StepScale.X"
#define ST_STEPSCALE_Y "Filter.Blur.StepScale.Y"
#define ST_MASK "Filter.Blur.Mask"
#define ST_MASK_TYPE "Filter.Blur.Mask.Type"
#define ST_MASK_TYPE_REGION "Filter.Blur.Mask.Type.Region"
#define ST_MASK_TYPE_IMAGE "Filter.Blur.Mask.Type.Image"
#define ST_MASK_TYPE_SOURCE "Filter.Blur.Mask.Type.Source"
#define ST_MASK_REGION_LEFT "Filter.Blur.Mask.Region.Left"
#define ST_MASK_REGION_RIGHT "Filter.Blur.Mask.Region.Right"
#define ST_MASK_REGION_TOP "Filter.Blur.Mask.Region.Top"
#define ST_MASK_REGION_BOTTOM "Filter.Blur.Mask.Region.Bottom"
#define ST_MASK_REGION_FEATHER "Filter.Blur.Mask.Region.Feather"
#define ST_MASK_REGION_FEATHER_SHIFT "Filter.Blur.Mask.Region.Feather.Shift"
#define ST_MASK_REGION_INVERT "Filter.Blur.Mask.Region.Invert"
#define ST_MASK_IMAGE "Filter.Blur.Mask.Image"
#define ST_MASK_SOURCE "Filter.Blur.Mask.Source"
#define ST_MASK_COLOR "Filter.Blur.Mask.Color"
#define ST_MASK_ALPHA "Filter.Blur.Mask.Alpha"
#define ST_MASK_MULTIPLIER "Filter.Blur.Mask.Multiplier"
#define ST_I18N_CENTER_X "Filter.Blur.Center.X"
#define ST_KEY_CENTER_X "Filter.Blur.Center.X"
#define ST_I18N_CENTER_Y "Filter.Blur.Center.Y"
#define ST_KEY_CENTER_Y "Filter.Blur.Center.Y"
#define ST_I18N_STEPSCALE "Filter.Blur.StepScale"
#define ST_KEY_STEPSCALE "Filter.Blur.StepScale"
#define ST_I18N_STEPSCALE_X "Filter.Blur.StepScale.X"
#define ST_KEY_STEPSCALE_X "Filter.Blur.StepScale.X"
#define ST_I18N_STEPSCALE_Y "Filter.Blur.StepScale.Y"
#define ST_KEY_STEPSCALE_Y "Filter.Blur.StepScale.Y"
#define ST_I18N_MASK "Filter.Blur.Mask"
#define ST_KEY_MASK "Filter.Blur.Mask"
#define ST_I18N_MASK_TYPE "Filter.Blur.Mask.Type"
#define ST_KEY_MASK_TYPE "Filter.Blur.Mask.Type"
#define ST_I18N_MASK_TYPE_REGION "Filter.Blur.Mask.Type.Region"
#define ST_I18N_MASK_TYPE_IMAGE "Filter.Blur.Mask.Type.Image"
#define ST_I18N_MASK_TYPE_SOURCE "Filter.Blur.Mask.Type.Source"
#define ST_I18N_MASK_REGION_LEFT "Filter.Blur.Mask.Region.Left"
#define ST_KEY_MASK_REGION_LEFT "Filter.Blur.Mask.Region.Left"
#define ST_I18N_MASK_REGION_RIGHT "Filter.Blur.Mask.Region.Right"
#define ST_KEY_MASK_REGION_RIGHT "Filter.Blur.Mask.Region.Right"
#define ST_I18N_MASK_REGION_TOP "Filter.Blur.Mask.Region.Top"
#define ST_KEY_MASK_REGION_TOP "Filter.Blur.Mask.Region.Top"
#define ST_I18N_MASK_REGION_BOTTOM "Filter.Blur.Mask.Region.Bottom"
#define ST_KEY_MASK_REGION_BOTTOM "Filter.Blur.Mask.Region.Bottom"
#define ST_I18N_MASK_REGION_FEATHER "Filter.Blur.Mask.Region.Feather"
#define ST_KEY_MASK_REGION_FEATHER "Filter.Blur.Mask.Region.Feather"
#define ST_I18N_MASK_REGION_FEATHER_SHIFT "Filter.Blur.Mask.Region.Feather.Shift"
#define ST_KEY_MASK_REGION_FEATHER_SHIFT "Filter.Blur.Mask.Region.Feather.Shift"
#define ST_I18N_MASK_REGION_INVERT "Filter.Blur.Mask.Region.Invert"
#define ST_KEY_MASK_REGION_INVERT "Filter.Blur.Mask.Region.Invert"
#define ST_I18N_MASK_IMAGE "Filter.Blur.Mask.Image"
#define ST_KEY_MASK_IMAGE "Filter.Blur.Mask.Image"
#define ST_I18N_MASK_SOURCE "Filter.Blur.Mask.Source"
#define ST_KEY_MASK_SOURCE "Filter.Blur.Mask.Source"
#define ST_I18N_MASK_COLOR "Filter.Blur.Mask.Color"
#define ST_KEY_MASK_COLOR "Filter.Blur.Mask.Color"
#define ST_I18N_MASK_ALPHA "Filter.Blur.Mask.Alpha"
#define ST_KEY_MASK_ALPHA "Filter.Blur.Mask.Alpha"
#define ST_I18N_MASK_MULTIPLIER "Filter.Blur.Mask.Multiplier"
#define ST_KEY_MASK_MULTIPLIER "Filter.Blur.Mask.Multiplier"
using namespace streamfx::filter::blur;
@ -207,32 +230,32 @@ void blur_instance::migrate(obs_data_t* settings, uint64_t version)
/// Blur Type
int64_t old_blur = obs_data_get_int(settings, "Filter.Blur.Type");
if (old_blur == 0) { // Box
obs_data_set_string(settings, ST_TYPE, "box");
obs_data_set_string(settings, ST_KEY_TYPE, "box");
} else if (old_blur == 1) { // Gaussian
obs_data_set_string(settings, ST_TYPE, "gaussian");
obs_data_set_string(settings, ST_KEY_TYPE, "gaussian");
} else if (old_blur == 2) { // Bilateral, no longer included.
obs_data_set_string(settings, ST_TYPE, "box");
obs_data_set_string(settings, ST_KEY_TYPE, "box");
} else if (old_blur == 3) { // Box Linear
obs_data_set_string(settings, ST_TYPE, "box_linear");
obs_data_set_string(settings, ST_KEY_TYPE, "box_linear");
} else if (old_blur == 4) { // Gaussian Linear
obs_data_set_string(settings, ST_TYPE, "gaussian_linear");
obs_data_set_string(settings, ST_KEY_TYPE, "gaussian_linear");
} else {
obs_data_set_string(settings, ST_TYPE, "box");
obs_data_set_string(settings, ST_KEY_TYPE, "box");
}
obs_data_unset_user_value(settings, "Filter.Blur.Type");
/// Directional Blur
bool directional = obs_data_get_bool(settings, "Filter.Blur.Directional");
if (directional) {
obs_data_set_string(settings, ST_SUBTYPE, "directional");
obs_data_set_string(settings, ST_KEY_SUBTYPE, "directional");
} else {
obs_data_set_string(settings, ST_SUBTYPE, "area");
obs_data_set_string(settings, ST_KEY_SUBTYPE, "area");
}
obs_data_unset_user_value(settings, "Filter.Blur.Directional");
/// Directional Blur Angle
double_t angle = obs_data_get_double(settings, "Filter.Blur.Directional.Angle");
obs_data_set_double(settings, ST_ANGLE, angle);
obs_data_set_double(settings, ST_KEY_ANGLE, angle);
obs_data_unset_user_value(settings, "Filter.Blur.Directional.Angle");
}
}
@ -240,9 +263,9 @@ void blur_instance::migrate(obs_data_t* settings, uint64_t version)
void blur_instance::update(obs_data_t* settings)
{
{ // Blur Type
const char* blur_type = obs_data_get_string(settings, ST_TYPE);
const char* blur_subtype = obs_data_get_string(settings, ST_SUBTYPE);
const char* last_blur_type = obs_data_get_string(settings, ST_TYPE ".last");
const char* blur_type = obs_data_get_string(settings, ST_KEY_TYPE);
const char* blur_subtype = obs_data_get_string(settings, ST_KEY_SUBTYPE);
const char* last_blur_type = obs_data_get_string(settings, ST_KEY_TYPE ".last");
auto type_found = list_of_types.find(blur_type);
if (type_found != list_of_types.end()) {
@ -258,46 +281,46 @@ void blur_instance::update(obs_data_t* settings)
}
{ // Blur Parameters
this->_blur_size = obs_data_get_double(settings, ST_SIZE);
this->_blur_angle = obs_data_get_double(settings, ST_ANGLE);
this->_blur_center.first = obs_data_get_double(settings, ST_CENTER_X) / 100.0;
this->_blur_center.second = obs_data_get_double(settings, ST_CENTER_Y) / 100.0;
this->_blur_size = obs_data_get_double(settings, ST_KEY_SIZE);
this->_blur_angle = obs_data_get_double(settings, ST_KEY_ANGLE);
this->_blur_center.first = obs_data_get_double(settings, ST_KEY_CENTER_X) / 100.0;
this->_blur_center.second = obs_data_get_double(settings, ST_KEY_CENTER_Y) / 100.0;
// Scaling
this->_blur_step_scaling = obs_data_get_bool(settings, ST_STEPSCALE);
this->_blur_step_scale.first = obs_data_get_double(settings, ST_STEPSCALE_X) / 100.0;
this->_blur_step_scale.second = obs_data_get_double(settings, ST_STEPSCALE_Y) / 100.0;
this->_blur_step_scaling = obs_data_get_bool(settings, ST_KEY_STEPSCALE);
this->_blur_step_scale.first = obs_data_get_double(settings, ST_KEY_STEPSCALE_X) / 100.0;
this->_blur_step_scale.second = obs_data_get_double(settings, ST_KEY_STEPSCALE_Y) / 100.0;
}
{ // Masking
_mask.enabled = obs_data_get_bool(settings, ST_MASK);
_mask.enabled = obs_data_get_bool(settings, ST_KEY_MASK);
if (_mask.enabled) {
_mask.type = static_cast<mask_type>(obs_data_get_int(settings, ST_MASK_TYPE));
_mask.type = static_cast<mask_type>(obs_data_get_int(settings, ST_KEY_MASK_TYPE));
switch (_mask.type) {
case mask_type::Region:
_mask.region.left = float_t(obs_data_get_double(settings, ST_MASK_REGION_LEFT) / 100.0);
_mask.region.top = float_t(obs_data_get_double(settings, ST_MASK_REGION_TOP) / 100.0);
_mask.region.right = 1.0f - float_t(obs_data_get_double(settings, ST_MASK_REGION_RIGHT) / 100.0);
_mask.region.bottom = 1.0f - float_t(obs_data_get_double(settings, ST_MASK_REGION_BOTTOM) / 100.0);
_mask.region.feather = float_t(obs_data_get_double(settings, ST_MASK_REGION_FEATHER) / 100.0);
_mask.region.left = float_t(obs_data_get_double(settings, ST_KEY_MASK_REGION_LEFT) / 100.0);
_mask.region.top = float_t(obs_data_get_double(settings, ST_KEY_MASK_REGION_TOP) / 100.0);
_mask.region.right = 1.0f - float_t(obs_data_get_double(settings, ST_KEY_MASK_REGION_RIGHT) / 100.0);
_mask.region.bottom = 1.0f - float_t(obs_data_get_double(settings, ST_KEY_MASK_REGION_BOTTOM) / 100.0);
_mask.region.feather = float_t(obs_data_get_double(settings, ST_KEY_MASK_REGION_FEATHER) / 100.0);
_mask.region.feather_shift =
float_t(obs_data_get_double(settings, ST_MASK_REGION_FEATHER_SHIFT) / 100.0);
_mask.region.invert = obs_data_get_bool(settings, ST_MASK_REGION_INVERT);
float_t(obs_data_get_double(settings, ST_KEY_MASK_REGION_FEATHER_SHIFT) / 100.0);
_mask.region.invert = obs_data_get_bool(settings, ST_KEY_MASK_REGION_INVERT);
break;
case mask_type::Image:
_mask.image.path = obs_data_get_string(settings, ST_MASK_IMAGE);
_mask.image.path = obs_data_get_string(settings, ST_KEY_MASK_IMAGE);
break;
case mask_type::Source:
_mask.source.name = obs_data_get_string(settings, ST_MASK_SOURCE);
_mask.source.name = obs_data_get_string(settings, ST_KEY_MASK_SOURCE);
break;
}
if ((_mask.type == mask_type::Image) || (_mask.type == mask_type::Source)) {
uint32_t color = static_cast<uint32_t>(obs_data_get_int(settings, ST_MASK_COLOR));
uint32_t color = static_cast<uint32_t>(obs_data_get_int(settings, ST_KEY_MASK_COLOR));
_mask.color.r = ((color >> 0) & 0xFF) / 255.0f;
_mask.color.g = ((color >> 8) & 0xFF) / 255.0f;
_mask.color.b = ((color >> 16) & 0xFF) / 255.0f;
_mask.color.a = static_cast<float_t>(obs_data_get_double(settings, ST_MASK_ALPHA));
_mask.multiplier = float_t(obs_data_get_double(settings, ST_MASK_MULTIPLIER));
_mask.color.a = static_cast<float_t>(obs_data_get_double(settings, ST_KEY_MASK_ALPHA));
_mask.multiplier = float_t(obs_data_get_double(settings, ST_KEY_MASK_MULTIPLIER));
}
}
}
@ -575,46 +598,46 @@ blur_factory::~blur_factory() {}
const char* blur_factory::get_name()
{
return D_TRANSLATE(ST);
return D_TRANSLATE(ST_I18N);
}
void blur_factory::get_defaults2(obs_data_t* settings)
{
// Type, Subtype
obs_data_set_default_string(settings, ST_TYPE, "box");
obs_data_set_default_string(settings, ST_SUBTYPE, "area");
obs_data_set_default_string(settings, ST_KEY_TYPE, "box");
obs_data_set_default_string(settings, ST_KEY_SUBTYPE, "area");
// Parameters
obs_data_set_default_int(settings, ST_SIZE, 5);
obs_data_set_default_double(settings, ST_ANGLE, 0.);
obs_data_set_default_double(settings, ST_CENTER_X, 50.);
obs_data_set_default_double(settings, ST_CENTER_Y, 50.);
obs_data_set_default_bool(settings, ST_STEPSCALE, false);
obs_data_set_default_double(settings, ST_STEPSCALE_X, 1.);
obs_data_set_default_double(settings, ST_STEPSCALE_Y, 1.);
obs_data_set_default_int(settings, ST_KEY_SIZE, 5);
obs_data_set_default_double(settings, ST_KEY_ANGLE, 0.);
obs_data_set_default_double(settings, ST_KEY_CENTER_X, 50.);
obs_data_set_default_double(settings, ST_KEY_CENTER_Y, 50.);
obs_data_set_default_bool(settings, ST_KEY_STEPSCALE, false);
obs_data_set_default_double(settings, ST_KEY_STEPSCALE_X, 1.);
obs_data_set_default_double(settings, ST_KEY_STEPSCALE_Y, 1.);
// Masking
obs_data_set_default_bool(settings, ST_MASK, false);
obs_data_set_default_int(settings, ST_MASK_TYPE, static_cast<int64_t>(mask_type::Region));
obs_data_set_default_double(settings, ST_MASK_REGION_LEFT, 0.0);
obs_data_set_default_double(settings, ST_MASK_REGION_RIGHT, 0.0);
obs_data_set_default_double(settings, ST_MASK_REGION_TOP, 0.0);
obs_data_set_default_double(settings, ST_MASK_REGION_BOTTOM, 0.0);
obs_data_set_default_double(settings, ST_MASK_REGION_FEATHER, 0.0);
obs_data_set_default_double(settings, ST_MASK_REGION_FEATHER_SHIFT, 0.0);
obs_data_set_default_bool(settings, ST_MASK_REGION_INVERT, false);
obs_data_set_default_string(settings, ST_MASK_IMAGE, streamfx::data_file_path("white.png").u8string().c_str());
obs_data_set_default_string(settings, ST_MASK_SOURCE, "");
obs_data_set_default_int(settings, ST_MASK_COLOR, 0xFFFFFFFFull);
obs_data_set_default_double(settings, ST_MASK_MULTIPLIER, 1.0);
obs_data_set_default_bool(settings, ST_KEY_MASK, false);
obs_data_set_default_int(settings, ST_KEY_MASK_TYPE, static_cast<int64_t>(mask_type::Region));
obs_data_set_default_double(settings, ST_KEY_MASK_REGION_LEFT, 0.0);
obs_data_set_default_double(settings, ST_KEY_MASK_REGION_RIGHT, 0.0);
obs_data_set_default_double(settings, ST_KEY_MASK_REGION_TOP, 0.0);
obs_data_set_default_double(settings, ST_KEY_MASK_REGION_BOTTOM, 0.0);
obs_data_set_default_double(settings, ST_KEY_MASK_REGION_FEATHER, 0.0);
obs_data_set_default_double(settings, ST_KEY_MASK_REGION_FEATHER_SHIFT, 0.0);
obs_data_set_default_bool(settings, ST_KEY_MASK_REGION_INVERT, false);
obs_data_set_default_string(settings, ST_KEY_MASK_IMAGE, streamfx::data_file_path("white.png").u8string().c_str());
obs_data_set_default_string(settings, ST_KEY_MASK_SOURCE, "");
obs_data_set_default_int(settings, ST_KEY_MASK_COLOR, 0xFFFFFFFFull);
obs_data_set_default_double(settings, ST_KEY_MASK_MULTIPLIER, 1.0);
}
bool modified_properties(void*, obs_properties_t* props, obs_property* prop, obs_data_t* settings) noexcept
try {
obs_property_t* p;
const char* propname = obs_property_name(prop);
const char* vtype = obs_data_get_string(settings, ST_TYPE);
const char* vsubtype = obs_data_get_string(settings, ST_SUBTYPE);
const char* vtype = obs_data_get_string(settings, ST_KEY_TYPE);
const char* vsubtype = obs_data_get_string(settings, ST_KEY_SUBTYPE);
// Find new Type
auto type_found = list_of_types.find(vtype);
@ -629,8 +652,8 @@ try {
}
// Blur Type
if (strcmp(propname, ST_TYPE) == 0) {
obs_property_t* prop_subtype = obs_properties_get(props, ST_SUBTYPE);
if (strcmp(propname, ST_KEY_TYPE) == 0) {
obs_property_t* prop_subtype = obs_properties_get(props, ST_KEY_SUBTYPE);
/// Disable unsupported items.
std::size_t subvalue_idx = 0;
@ -655,7 +678,7 @@ try {
if (obs_property_list_item_disabled(prop_subtype, subvalue_idx)) {
for (std::size_t idx = 0, edx = obs_property_list_item_count(prop_subtype); idx < edx; idx++) {
if (!obs_property_list_item_disabled(prop_subtype, idx)) {
obs_data_set_string(settings, ST_SUBTYPE, obs_property_list_item_string(prop_subtype, idx));
obs_data_set_string(settings, ST_KEY_SUBTYPE, obs_property_list_item_string(prop_subtype, idx));
// Find new Subtype
auto subtype_found2 = list_of_subtypes.find(vsubtype);
@ -678,33 +701,33 @@ try {
bool has_center_support = (subtype_found->second.type == ::streamfx::gfx::blur::type::Rotational)
|| (subtype_found->second.type == ::streamfx::gfx::blur::type::Zoom);
bool has_stepscale_support = type_found->second.fn().is_step_scale_supported(subtype_found->second.type);
bool show_scaling = obs_data_get_bool(settings, ST_STEPSCALE) && has_stepscale_support;
bool show_scaling = obs_data_get_bool(settings, ST_KEY_STEPSCALE) && has_stepscale_support;
/// Size
p = obs_properties_get(props, ST_SIZE);
p = obs_properties_get(props, ST_KEY_SIZE);
obs_property_float_set_limits(p, type_found->second.fn().get_min_size(subtype_found->second.type),
type_found->second.fn().get_max_size(subtype_found->second.type),
type_found->second.fn().get_step_size(subtype_found->second.type));
/// Angle
p = obs_properties_get(props, ST_ANGLE);
p = obs_properties_get(props, ST_KEY_ANGLE);
obs_property_set_visible(p, has_angle_support);
obs_property_float_set_limits(p, type_found->second.fn().get_min_angle(subtype_found->second.type),
type_found->second.fn().get_max_angle(subtype_found->second.type),
type_found->second.fn().get_step_angle(subtype_found->second.type));
/// Center, Radius
obs_property_set_visible(obs_properties_get(props, ST_CENTER_X), has_center_support);
obs_property_set_visible(obs_properties_get(props, ST_CENTER_Y), has_center_support);
obs_property_set_visible(obs_properties_get(props, ST_KEY_CENTER_X), has_center_support);
obs_property_set_visible(obs_properties_get(props, ST_KEY_CENTER_Y), has_center_support);
/// Step Scaling
obs_property_set_visible(obs_properties_get(props, ST_STEPSCALE), has_stepscale_support);
p = obs_properties_get(props, ST_STEPSCALE_X);
obs_property_set_visible(obs_properties_get(props, ST_KEY_STEPSCALE), has_stepscale_support);
p = obs_properties_get(props, ST_KEY_STEPSCALE_X);
obs_property_set_visible(p, show_scaling);
obs_property_float_set_limits(p, type_found->second.fn().get_min_step_scale_x(subtype_found->second.type),
type_found->second.fn().get_max_step_scale_x(subtype_found->second.type),
type_found->second.fn().get_step_step_scale_x(subtype_found->second.type));
p = obs_properties_get(props, ST_STEPSCALE_Y);
p = obs_properties_get(props, ST_KEY_STEPSCALE_Y);
obs_property_set_visible(p, show_scaling);
obs_property_float_set_limits(p, type_found->second.fn().get_min_step_scale_x(subtype_found->second.type),
type_found->second.fn().get_max_step_scale_x(subtype_found->second.type),
@ -713,24 +736,24 @@ try {
{ // Masking
using namespace ::streamfx::gfx::blur;
bool show_mask = obs_data_get_bool(settings, ST_MASK);
mask_type mtype = static_cast<mask_type>(obs_data_get_int(settings, ST_MASK_TYPE));
bool show_mask = obs_data_get_bool(settings, ST_KEY_MASK);
mask_type mtype = static_cast<mask_type>(obs_data_get_int(settings, ST_KEY_MASK_TYPE));
bool show_region = (mtype == mask_type::Region) && show_mask;
bool show_image = (mtype == mask_type::Image) && show_mask;
bool show_source = (mtype == mask_type::Source) && show_mask;
obs_property_set_visible(obs_properties_get(props, ST_MASK_TYPE), show_mask);
obs_property_set_visible(obs_properties_get(props, ST_MASK_REGION_LEFT), show_region);
obs_property_set_visible(obs_properties_get(props, ST_MASK_REGION_TOP), show_region);
obs_property_set_visible(obs_properties_get(props, ST_MASK_REGION_RIGHT), show_region);
obs_property_set_visible(obs_properties_get(props, ST_MASK_REGION_BOTTOM), show_region);
obs_property_set_visible(obs_properties_get(props, ST_MASK_REGION_FEATHER), show_region);
obs_property_set_visible(obs_properties_get(props, ST_MASK_REGION_FEATHER_SHIFT), show_region);
obs_property_set_visible(obs_properties_get(props, ST_MASK_REGION_INVERT), show_region);
obs_property_set_visible(obs_properties_get(props, ST_MASK_IMAGE), show_image);
obs_property_set_visible(obs_properties_get(props, ST_MASK_SOURCE), show_source);
obs_property_set_visible(obs_properties_get(props, ST_MASK_COLOR), show_image || show_source);
obs_property_set_visible(obs_properties_get(props, ST_MASK_ALPHA), show_image || show_source);
obs_property_set_visible(obs_properties_get(props, ST_MASK_MULTIPLIER), show_image || show_source);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_TYPE), show_mask);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_REGION_LEFT), show_region);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_REGION_TOP), show_region);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_REGION_RIGHT), show_region);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_REGION_BOTTOM), show_region);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_REGION_FEATHER), show_region);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_REGION_FEATHER_SHIFT), show_region);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_REGION_INVERT), show_region);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_IMAGE), show_image);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_SOURCE), show_source);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_COLOR), show_image || show_source);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_ALPHA), show_image || show_source);
obs_property_set_visible(obs_properties_get(props, ST_KEY_MASK_MULTIPLIER), show_image || show_source);
}
return true;
@ -753,7 +776,8 @@ obs_properties_t* blur_factory::get_properties2(blur_instance* data)
// Blur Type and Sub-Type
{
p = obs_properties_add_list(pr, ST_TYPE, D_TRANSLATE(ST_TYPE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
p = obs_properties_add_list(pr, ST_KEY_TYPE, D_TRANSLATE(ST_I18N_TYPE), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_STRING);
obs_property_set_modified_callback2(p, modified_properties, this);
obs_property_list_add_string(p, D_TRANSLATE(S_BLUR_TYPE_BOX), "box");
obs_property_list_add_string(p, D_TRANSLATE(S_BLUR_TYPE_BOX_LINEAR), "box_linear");
@ -761,7 +785,7 @@ obs_properties_t* blur_factory::get_properties2(blur_instance* data)
obs_property_list_add_string(p, D_TRANSLATE(S_BLUR_TYPE_GAUSSIAN_LINEAR), "gaussian_linear");
obs_property_list_add_string(p, D_TRANSLATE(S_BLUR_TYPE_DUALFILTERING), "dual_filtering");
p = obs_properties_add_list(pr, ST_SUBTYPE, D_TRANSLATE(ST_SUBTYPE), OBS_COMBO_TYPE_LIST,
p = obs_properties_add_list(pr, ST_KEY_SUBTYPE, D_TRANSLATE(ST_I18N_SUBTYPE), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_STRING);
obs_property_set_modified_callback2(p, modified_properties, this);
obs_property_list_add_string(p, D_TRANSLATE(S_BLUR_SUBTYPE_AREA), "area");
@ -772,50 +796,53 @@ obs_properties_t* blur_factory::get_properties2(blur_instance* data)
// Blur Parameters
{
p = obs_properties_add_float_slider(pr, ST_SIZE, D_TRANSLATE(ST_SIZE), 1, 32767, 1);
p = obs_properties_add_float_slider(pr, ST_ANGLE, D_TRANSLATE(ST_ANGLE), -180.0, 180.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_CENTER_X, D_TRANSLATE(ST_CENTER_X), 0.00, 100.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_CENTER_Y, D_TRANSLATE(ST_CENTER_Y), 0.00, 100.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_KEY_SIZE, D_TRANSLATE(ST_I18N_SIZE), 1, 32767, 1);
p = obs_properties_add_float_slider(pr, ST_KEY_ANGLE, D_TRANSLATE(ST_I18N_ANGLE), -180.0, 180.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_KEY_CENTER_X, D_TRANSLATE(ST_I18N_CENTER_X), 0.00, 100.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_KEY_CENTER_Y, D_TRANSLATE(ST_I18N_CENTER_Y), 0.00, 100.0, 0.01);
p = obs_properties_add_bool(pr, ST_STEPSCALE, D_TRANSLATE(ST_STEPSCALE));
p = obs_properties_add_bool(pr, ST_KEY_STEPSCALE, D_TRANSLATE(ST_I18N_STEPSCALE));
obs_property_set_modified_callback2(p, modified_properties, this);
p = obs_properties_add_float_slider(pr, ST_STEPSCALE_X, D_TRANSLATE(ST_STEPSCALE_X), 0.0, 1000.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_STEPSCALE_Y, D_TRANSLATE(ST_STEPSCALE_Y), 0.0, 1000.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_KEY_STEPSCALE_X, D_TRANSLATE(ST_I18N_STEPSCALE_X), 0.0, 1000.0,
0.01);
p = obs_properties_add_float_slider(pr, ST_KEY_STEPSCALE_Y, D_TRANSLATE(ST_I18N_STEPSCALE_Y), 0.0, 1000.0,
0.01);
}
// Masking
{
p = obs_properties_add_bool(pr, ST_MASK, D_TRANSLATE(ST_MASK));
p = obs_properties_add_bool(pr, ST_KEY_MASK, D_TRANSLATE(ST_I18N_MASK));
obs_property_set_modified_callback2(p, modified_properties, this);
p = obs_properties_add_list(pr, ST_MASK_TYPE, D_TRANSLATE(ST_MASK_TYPE), OBS_COMBO_TYPE_LIST,
p = obs_properties_add_list(pr, ST_KEY_MASK_TYPE, D_TRANSLATE(ST_I18N_MASK_TYPE), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_INT);
obs_property_set_modified_callback2(p, modified_properties, this);
obs_property_list_add_int(p, D_TRANSLATE(ST_MASK_TYPE_REGION), static_cast<int64_t>(mask_type::Region));
obs_property_list_add_int(p, D_TRANSLATE(ST_MASK_TYPE_IMAGE), static_cast<int64_t>(mask_type::Image));
obs_property_list_add_int(p, D_TRANSLATE(ST_MASK_TYPE_SOURCE), static_cast<int64_t>(mask_type::Source));
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_MASK_TYPE_REGION), static_cast<int64_t>(mask_type::Region));
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_MASK_TYPE_IMAGE), static_cast<int64_t>(mask_type::Image));
obs_property_list_add_int(p, D_TRANSLATE(ST_I18N_MASK_TYPE_SOURCE), static_cast<int64_t>(mask_type::Source));
/// Region
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_LEFT, D_TRANSLATE(ST_MASK_REGION_LEFT), 0.0, 100.0,
0.01);
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_TOP, D_TRANSLATE(ST_MASK_REGION_TOP), 0.0, 100.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_RIGHT, D_TRANSLATE(ST_MASK_REGION_RIGHT), 0.0, 100.0,
0.01);
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_BOTTOM, D_TRANSLATE(ST_MASK_REGION_BOTTOM), 0.0, 100.0,
0.01);
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_FEATHER, D_TRANSLATE(ST_MASK_REGION_FEATHER), 0.0, 50.0,
0.01);
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_FEATHER_SHIFT, D_TRANSLATE(ST_MASK_REGION_FEATHER_SHIFT),
-100.0, 100.0, 0.01);
p = obs_properties_add_bool(pr, ST_MASK_REGION_INVERT, D_TRANSLATE(ST_MASK_REGION_INVERT));
p = obs_properties_add_float_slider(pr, ST_KEY_MASK_REGION_LEFT, D_TRANSLATE(ST_I18N_MASK_REGION_LEFT), 0.0,
100.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_KEY_MASK_REGION_TOP, D_TRANSLATE(ST_I18N_MASK_REGION_TOP), 0.0,
100.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_KEY_MASK_REGION_RIGHT, D_TRANSLATE(ST_I18N_MASK_REGION_RIGHT), 0.0,
100.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_KEY_MASK_REGION_BOTTOM, D_TRANSLATE(ST_I18N_MASK_REGION_BOTTOM), 0.0,
100.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_KEY_MASK_REGION_FEATHER, D_TRANSLATE(ST_I18N_MASK_REGION_FEATHER),
0.0, 50.0, 0.01);
p = obs_properties_add_float_slider(pr, ST_KEY_MASK_REGION_FEATHER_SHIFT,
D_TRANSLATE(ST_I18N_MASK_REGION_FEATHER_SHIFT), -100.0, 100.0, 0.01);
p = obs_properties_add_bool(pr, ST_KEY_MASK_REGION_INVERT, D_TRANSLATE(ST_I18N_MASK_REGION_INVERT));
/// Image
{
std::string filter =
translate_string("%s (%s);;* (*.*)", D_TRANSLATE(S_FILETYPE_IMAGES), S_FILEFILTERS_TEXTURE);
_translation_cache.push_back(filter);
p = obs_properties_add_path(pr, ST_MASK_IMAGE, D_TRANSLATE(ST_MASK_IMAGE), OBS_PATH_FILE,
p = obs_properties_add_path(pr, ST_KEY_MASK_IMAGE, D_TRANSLATE(ST_I18N_MASK_IMAGE), OBS_PATH_FILE,
_translation_cache.back().c_str(), nullptr);
}
/// Source
p = obs_properties_add_list(pr, ST_MASK_SOURCE, D_TRANSLATE(ST_MASK_SOURCE), OBS_COMBO_TYPE_LIST,
p = obs_properties_add_list(pr, ST_KEY_MASK_SOURCE, D_TRANSLATE(ST_I18N_MASK_SOURCE), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_STRING);
obs_property_list_add_string(p, "", "");
obs::source_tracker::get()->enumerate(
@ -832,9 +859,10 @@ obs_properties_t* blur_factory::get_properties2(blur_instance* data)
obs::source_tracker::filter_scenes);
/// Shared
p = obs_properties_add_color(pr, ST_MASK_COLOR, D_TRANSLATE(ST_MASK_COLOR));
p = obs_properties_add_float_slider(pr, ST_MASK_ALPHA, D_TRANSLATE(ST_MASK_ALPHA), 0.0, 100.0, 0.1);
p = obs_properties_add_float_slider(pr, ST_MASK_MULTIPLIER, D_TRANSLATE(ST_MASK_MULTIPLIER), 0.0, 10.0, 0.01);
p = obs_properties_add_color(pr, ST_KEY_MASK_COLOR, D_TRANSLATE(ST_I18N_MASK_COLOR));
p = obs_properties_add_float_slider(pr, ST_KEY_MASK_ALPHA, D_TRANSLATE(ST_I18N_MASK_ALPHA), 0.0, 100.0, 0.1);
p = obs_properties_add_float_slider(pr, ST_KEY_MASK_MULTIPLIER, D_TRANSLATE(ST_I18N_MASK_MULTIPLIER), 0.0, 10.0,
0.01);
}
return pr;