mirror of
https://github.com/Xaymar/obs-StreamFX
synced 2024-10-24 05:42:39 +00:00
cd5acd42f4
Previously sources had to manually implement migration code, which resulted in unresolvable regression issues due to the lack of version and commit tagging. With the new migration code, all sources automatically have this version and commit tagging at all times, and as such can now have a temporary regression fixed without the user needing to change any values manually.
882 lines
35 KiB
C++
882 lines
35 KiB
C++
/*
|
|
* Modern effects for a modern Streamer
|
|
* Copyright (C) 2017-2018 Michael Fabian Dirks
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "filter-blur.hpp"
|
|
#include "strings.hpp"
|
|
#include <cfloat>
|
|
#include <cinttypes>
|
|
#include <cmath>
|
|
#include <map>
|
|
#include <stdexcept>
|
|
#include "gfx/blur/gfx-blur-box-linear.hpp"
|
|
#include "gfx/blur/gfx-blur-box.hpp"
|
|
#include "gfx/blur/gfx-blur-dual-filtering.hpp"
|
|
#include "gfx/blur/gfx-blur-gaussian-linear.hpp"
|
|
#include "gfx/blur/gfx-blur-gaussian.hpp"
|
|
#include "obs/gs/gs-helper.hpp"
|
|
#include "obs/obs-source-tracker.hpp"
|
|
#include "util-math.hpp"
|
|
|
|
// OBS
|
|
#ifdef _MSC_VER
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4201)
|
|
#endif
|
|
#include <callback/signal.h>
|
|
#include <graphics/graphics.h>
|
|
#include <graphics/matrix4.h>
|
|
#include <util/platform.h>
|
|
#ifdef _MSC_VER
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
// Translation Strings
|
|
#define ST "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_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"
|
|
|
|
using namespace filter;
|
|
|
|
struct local_blur_type_t {
|
|
std::function<::gfx::blur::ifactory&()> fn;
|
|
const char* name;
|
|
};
|
|
struct local_blur_subtype_t {
|
|
::gfx::blur::type type;
|
|
const char* name;
|
|
};
|
|
|
|
static std::map<std::string, local_blur_type_t> list_of_types = {
|
|
{"box", {&::gfx::blur::box_factory::get, S_BLUR_TYPE_BOX}},
|
|
{"box_linear", {&::gfx::blur::box_linear_factory::get, S_BLUR_TYPE_BOX_LINEAR}},
|
|
{"gaussian", {&::gfx::blur::gaussian_factory::get, S_BLUR_TYPE_GAUSSIAN}},
|
|
{"gaussian_linear", {&::gfx::blur::gaussian_linear_factory::get, S_BLUR_TYPE_GAUSSIAN_LINEAR}},
|
|
{"dual_filtering", {&::gfx::blur::dual_filtering_factory::get, S_BLUR_TYPE_DUALFILTERING}},
|
|
};
|
|
static std::map<std::string, local_blur_subtype_t> list_of_subtypes = {
|
|
{"area", {::gfx::blur::type::Area, S_BLUR_SUBTYPE_AREA}},
|
|
{"directional", {::gfx::blur::type::Directional, S_BLUR_SUBTYPE_DIRECTIONAL}},
|
|
{"rotational", {::gfx::blur::type::Rotational, S_BLUR_SUBTYPE_ROTATIONAL}},
|
|
{"zoom", {::gfx::blur::type::Zoom, S_BLUR_SUBTYPE_ZOOM}},
|
|
};
|
|
|
|
std::shared_ptr<blur::blur_factory> blur::blur_factory::factory_instance = nullptr;
|
|
|
|
blur::blur_instance::blur_instance(obs_data_t* settings, obs_source_t* self)
|
|
: obs::source_instance(settings, self), _source_rendered(false), _output_rendered(false)
|
|
{
|
|
{
|
|
auto gctx = gs::context();
|
|
|
|
// Create RenderTargets
|
|
this->_source_rt = std::make_shared<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
|
|
this->_output_rt = std::make_shared<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
|
|
|
|
// Load Effects
|
|
{
|
|
char* file = obs_module_file("effects/mask.effect");
|
|
try {
|
|
_effect_mask = gs::effect::create(file);
|
|
} catch (std::runtime_error& ex) {
|
|
LOG_ERROR("<filter-blur> Loading _effect '%s' failed with error(s): %s", file, ex.what());
|
|
}
|
|
|
|
bfree(file);
|
|
}
|
|
}
|
|
|
|
update(settings);
|
|
}
|
|
|
|
blur::blur_instance::~blur_instance() {}
|
|
|
|
bool blur::blur_instance::apply_mask_parameters(gs::effect effect, gs_texture_t* original_texture,
|
|
gs_texture_t* blurred_texture)
|
|
{
|
|
if (effect.has_parameter("image_orig")) {
|
|
effect.get_parameter("image_orig").set_texture(original_texture);
|
|
}
|
|
if (effect.has_parameter("image_blur")) {
|
|
effect.get_parameter("image_blur").set_texture(blurred_texture);
|
|
}
|
|
|
|
// Region
|
|
if (_mask.type == mask_type::Region) {
|
|
if (effect.has_parameter("mask_region_left")) {
|
|
effect.get_parameter("mask_region_left").set_float(_mask.region.left);
|
|
}
|
|
if (effect.has_parameter("mask_region_right")) {
|
|
effect.get_parameter("mask_region_right").set_float(_mask.region.right);
|
|
}
|
|
if (effect.has_parameter("mask_region_top")) {
|
|
effect.get_parameter("mask_region_top").set_float(_mask.region.top);
|
|
}
|
|
if (effect.has_parameter("mask_region_bottom")) {
|
|
effect.get_parameter("mask_region_bottom").set_float(_mask.region.bottom);
|
|
}
|
|
if (effect.has_parameter("mask_region_feather")) {
|
|
effect.get_parameter("mask_region_feather").set_float(_mask.region.feather);
|
|
}
|
|
if (effect.has_parameter("mask_region_feather_shift")) {
|
|
effect.get_parameter("mask_region_feather_shift").set_float(_mask.region.feather_shift);
|
|
}
|
|
}
|
|
|
|
// Image
|
|
if (_mask.type == mask_type::Image) {
|
|
if (effect.has_parameter("mask_image")) {
|
|
if (_mask.image.texture) {
|
|
effect.get_parameter("mask_image").set_texture(_mask.image.texture);
|
|
} else {
|
|
effect.get_parameter("mask_image").set_texture(nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Source
|
|
if (_mask.type == mask_type::Source) {
|
|
if (effect.has_parameter("mask_image")) {
|
|
if (_mask.source.texture) {
|
|
effect.get_parameter("mask_image").set_texture(_mask.source.texture);
|
|
} else {
|
|
effect.get_parameter("mask_image").set_texture(nullptr);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Shared
|
|
if (effect.has_parameter("mask_color")) {
|
|
effect.get_parameter("mask_color").set_float4(_mask.color.r, _mask.color.g, _mask.color.b, _mask.color.a);
|
|
}
|
|
if (effect.has_parameter("mask_multiplier")) {
|
|
effect.get_parameter("mask_multiplier").set_float(_mask.multiplier);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void blur::blur_instance::load(obs_data_t* settings)
|
|
{
|
|
update(settings);
|
|
}
|
|
|
|
void filter::blur::blur_instance::migrate(obs_data_t* settings, std::uint64_t version)
|
|
{
|
|
// Now we use a fall-through switch to gradually upgrade each known version change.
|
|
switch (version) {
|
|
case 0:
|
|
/// 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");
|
|
} else if (old_blur == 1) { // Gaussian
|
|
obs_data_set_string(settings, ST_TYPE, "gaussian");
|
|
} else if (old_blur == 2) { // Bilateral, no longer included.
|
|
obs_data_set_string(settings, ST_TYPE, "box");
|
|
} else if (old_blur == 3) { // Box Linear
|
|
obs_data_set_string(settings, ST_TYPE, "box_linear");
|
|
} else if (old_blur == 4) { // Gaussian Linear
|
|
obs_data_set_string(settings, ST_TYPE, "gaussian_linear");
|
|
} else {
|
|
obs_data_set_string(settings, ST_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");
|
|
} else {
|
|
obs_data_set_string(settings, ST_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_unset_user_value(settings, "Filter.Blur.Directional.Angle");
|
|
}
|
|
}
|
|
|
|
void blur::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");
|
|
|
|
auto type_found = list_of_types.find(blur_type);
|
|
if (type_found != list_of_types.end()) {
|
|
auto subtype_found = list_of_subtypes.find(blur_subtype);
|
|
if (subtype_found != list_of_subtypes.end()) {
|
|
if ((strcmp(last_blur_type, blur_type) != 0) || (_blur->get_type() != subtype_found->second.type)) {
|
|
if (type_found->second.fn().is_type_supported(subtype_found->second.type)) {
|
|
_blur = type_found->second.fn().create(subtype_found->second.type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
{ // 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;
|
|
|
|
// 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;
|
|
}
|
|
|
|
{ // Masking
|
|
_mask.enabled = obs_data_get_bool(settings, ST_MASK);
|
|
if (_mask.enabled) {
|
|
_mask.type = static_cast<blur::mask_type>(obs_data_get_int(settings, ST_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.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);
|
|
break;
|
|
case mask_type::Image:
|
|
_mask.image.path = obs_data_get_string(settings, ST_MASK_IMAGE);
|
|
break;
|
|
case mask_type::Source:
|
|
_mask.source.name = obs_data_get_string(settings, ST_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));
|
|
_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));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void blur::blur_instance::video_tick(float)
|
|
{
|
|
// Blur
|
|
if (_blur) {
|
|
_blur->set_size(_blur_size);
|
|
if (_blur_step_scaling) {
|
|
_blur->set_step_scale(_blur_step_scale.first, _blur_step_scale.second);
|
|
} else {
|
|
_blur->set_step_scale(1.0, 1.0);
|
|
}
|
|
if ((_blur->get_type() == ::gfx::blur::type::Directional)
|
|
|| (_blur->get_type() == ::gfx::blur::type::Rotational)) {
|
|
auto obj = std::dynamic_pointer_cast<::gfx::blur::base_angle>(_blur);
|
|
obj->set_angle(_blur_angle);
|
|
}
|
|
if ((_blur->get_type() == ::gfx::blur::type::Zoom) || (_blur->get_type() == ::gfx::blur::type::Rotational)) {
|
|
auto obj = std::dynamic_pointer_cast<::gfx::blur::base_center>(_blur);
|
|
obj->set_center(_blur_center.first, _blur_center.second);
|
|
}
|
|
}
|
|
|
|
// Load Mask
|
|
if (_mask.type == mask_type::Image) {
|
|
if (_mask.image.path_old != _mask.image.path) {
|
|
try {
|
|
_mask.image.texture = std::make_shared<gs::texture>(_mask.image.path);
|
|
_mask.image.path_old = _mask.image.path;
|
|
} catch (...) {
|
|
LOG_ERROR("<filter-blur> Instance '%s' failed to load image '%s'.", obs_source_get_name(_self),
|
|
_mask.image.path.c_str());
|
|
}
|
|
}
|
|
} else if (_mask.type == mask_type::Source) {
|
|
if (_mask.source.name_old != _mask.source.name) {
|
|
try {
|
|
_mask.source.source_texture = std::make_shared<gfx::source_texture>(_mask.source.name, _self);
|
|
_mask.source.is_scene = (obs_scene_from_source(_mask.source.source_texture->get_object()) != nullptr);
|
|
_mask.source.name_old = _mask.source.name;
|
|
} catch (...) {
|
|
LOG_ERROR("<filter-blur> Instance '%s' failed to grab source '%s'.", obs_source_get_name(_self),
|
|
_mask.source.name.c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
_source_rendered = false;
|
|
_output_rendered = false;
|
|
}
|
|
|
|
void blur::blur_instance::video_render(gs_effect_t* effect)
|
|
{
|
|
obs_source_t* parent = obs_filter_get_parent(this->_self);
|
|
obs_source_t* target = obs_filter_get_target(this->_self);
|
|
gs_effect_t* defaultEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT);
|
|
uint32_t baseW = obs_source_get_base_width(target);
|
|
uint32_t baseH = obs_source_get_base_height(target);
|
|
vec4 black = {};
|
|
|
|
// Verify that we can actually run first.
|
|
if (!target || !parent || !this->_self || !this->_blur || (baseW == 0) || (baseH == 0)) {
|
|
obs_source_skip_video_filter(this->_self);
|
|
return;
|
|
}
|
|
|
|
if (!_source_rendered) {
|
|
// Source To Texture
|
|
{
|
|
if (obs_source_process_filter_begin(this->_self, GS_RGBA, OBS_ALLOW_DIRECT_RENDERING)) {
|
|
{
|
|
auto op = this->_source_rt->render(baseW, baseH);
|
|
|
|
gs_blend_state_push();
|
|
gs_reset_blend_state();
|
|
gs_enable_blending(false);
|
|
gs_blend_function(GS_BLEND_ONE, GS_BLEND_ZERO);
|
|
|
|
gs_set_cull_mode(GS_NEITHER);
|
|
gs_enable_color(true, true, true, true);
|
|
|
|
gs_enable_depth_test(false);
|
|
gs_depth_function(GS_ALWAYS);
|
|
|
|
gs_enable_stencil_test(false);
|
|
gs_enable_stencil_write(false);
|
|
gs_stencil_function(GS_STENCIL_BOTH, GS_ALWAYS);
|
|
gs_stencil_op(GS_STENCIL_BOTH, GS_KEEP, GS_KEEP, GS_KEEP);
|
|
|
|
// Orthographic Camera and clear RenderTarget.
|
|
gs_ortho(0, (float)baseW, 0, (float)baseH, -1., 1.);
|
|
//gs_clear(GS_CLEAR_COLOR | GS_CLEAR_DEPTH, &black, 0, 0);
|
|
|
|
// Render
|
|
obs_source_process_filter_end(this->_self, defaultEffect, baseW, baseH);
|
|
|
|
gs_blend_state_pop();
|
|
}
|
|
|
|
_source_texture = this->_source_rt->get_texture();
|
|
if (!_source_texture) {
|
|
obs_source_skip_video_filter(this->_self);
|
|
return;
|
|
}
|
|
} else {
|
|
obs_source_skip_video_filter(this->_self);
|
|
return;
|
|
}
|
|
}
|
|
|
|
_source_rendered = true;
|
|
}
|
|
|
|
if (!_output_rendered) {
|
|
_blur->set_input(_source_texture);
|
|
_output_texture = _blur->render();
|
|
|
|
// Mask
|
|
if (_mask.enabled) {
|
|
gs_blend_state_push();
|
|
gs_reset_blend_state();
|
|
gs_enable_color(true, true, true, true);
|
|
gs_enable_blending(false);
|
|
gs_enable_depth_test(false);
|
|
gs_enable_stencil_test(false);
|
|
gs_enable_stencil_write(false);
|
|
gs_set_cull_mode(GS_NEITHER);
|
|
gs_depth_function(GS_ALWAYS);
|
|
gs_blend_function(GS_BLEND_ONE, GS_BLEND_ZERO);
|
|
gs_stencil_function(GS_STENCIL_BOTH, GS_ALWAYS);
|
|
gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO);
|
|
|
|
std::string technique = "";
|
|
switch (this->_mask.type) {
|
|
case mask_type::Region:
|
|
if (this->_mask.region.feather > std::numeric_limits<float_t>::epsilon()) {
|
|
if (this->_mask.region.invert) {
|
|
technique = "RegionFeatherInverted";
|
|
} else {
|
|
technique = "RegionFeather";
|
|
}
|
|
} else {
|
|
if (this->_mask.region.invert) {
|
|
technique = "RegionInverted";
|
|
} else {
|
|
technique = "Region";
|
|
}
|
|
}
|
|
break;
|
|
case mask_type::Image:
|
|
case mask_type::Source:
|
|
technique = "Image";
|
|
break;
|
|
}
|
|
|
|
if (_mask.source.source_texture) {
|
|
uint32_t source_width = obs_source_get_width(this->_mask.source.source_texture->get_object());
|
|
uint32_t source_height = obs_source_get_height(this->_mask.source.source_texture->get_object());
|
|
|
|
if (source_width == 0) {
|
|
source_width = baseW;
|
|
}
|
|
if (source_height == 0) {
|
|
source_height = baseH;
|
|
}
|
|
if (this->_mask.source.is_scene) {
|
|
obs_video_info ovi;
|
|
if (obs_get_video_info(&ovi)) {
|
|
source_width = ovi.base_width;
|
|
source_height = ovi.base_height;
|
|
}
|
|
}
|
|
|
|
this->_mask.source.texture = this->_mask.source.source_texture->render(source_width, source_height);
|
|
}
|
|
|
|
apply_mask_parameters(_effect_mask, _source_texture->get_object(), _output_texture->get_object());
|
|
|
|
try {
|
|
auto op = this->_output_rt->render(baseW, baseH);
|
|
gs_ortho(0, (float)baseW, 0, (float)baseH, -1, 1);
|
|
|
|
// Render
|
|
while (gs_effect_loop(_effect_mask.get_object(), technique.c_str())) {
|
|
gs_draw_sprite(_output_texture->get_object(), 0, baseW, baseH);
|
|
}
|
|
} catch (const std::exception&) {
|
|
gs_blend_state_pop();
|
|
obs_source_skip_video_filter(this->_self);
|
|
return;
|
|
}
|
|
gs_blend_state_pop();
|
|
|
|
if (!(_output_texture = this->_output_rt->get_texture())) {
|
|
obs_source_skip_video_filter(this->_self);
|
|
return;
|
|
}
|
|
}
|
|
|
|
_output_rendered = true;
|
|
}
|
|
|
|
// Draw source
|
|
{
|
|
// It is important that we do not modify the blend state here, as it is set correctly by OBS
|
|
gs_set_cull_mode(GS_NEITHER);
|
|
gs_enable_color(true, true, true, true);
|
|
gs_enable_depth_test(false);
|
|
gs_depth_function(GS_ALWAYS);
|
|
gs_enable_stencil_test(false);
|
|
gs_enable_stencil_write(false);
|
|
gs_stencil_function(GS_STENCIL_BOTH, GS_ALWAYS);
|
|
gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO);
|
|
|
|
gs_effect_t* finalEffect = effect ? effect : defaultEffect;
|
|
const char* technique = "Draw";
|
|
|
|
gs_eparam_t* param = gs_effect_get_param_by_name(finalEffect, "image");
|
|
if (!param) {
|
|
LOG_ERROR("<filter-blur:%s> Failed to set image param.", obs_source_get_name(this->_self));
|
|
obs_source_skip_video_filter(_self);
|
|
return;
|
|
} else {
|
|
gs_effect_set_texture(param, _output_texture->get_object());
|
|
}
|
|
while (gs_effect_loop(finalEffect, technique)) {
|
|
gs_draw_sprite(_output_texture->get_object(), 0, baseW, baseH);
|
|
}
|
|
}
|
|
}
|
|
|
|
blur::blur_factory::blur_factory()
|
|
{
|
|
_info.id = "obs-stream-effects-filter-blur";
|
|
_info.type = OBS_SOURCE_TYPE_FILTER;
|
|
_info.output_flags = OBS_SOURCE_VIDEO;
|
|
|
|
set_resolution_enabled(false);
|
|
finish_setup();
|
|
}
|
|
|
|
blur::blur_factory::~blur_factory() {}
|
|
|
|
const char* blur::blur_factory::get_name()
|
|
{
|
|
return D_TRANSLATE(ST);
|
|
}
|
|
|
|
void blur::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");
|
|
|
|
// 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.);
|
|
|
|
// 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);
|
|
{
|
|
char* default_file = obs_module_file("white.png");
|
|
obs_data_set_default_string(settings, ST_MASK_IMAGE, default_file);
|
|
bfree(default_file);
|
|
}
|
|
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);
|
|
}
|
|
|
|
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);
|
|
|
|
// Find new Type
|
|
auto type_found = list_of_types.find(vtype);
|
|
if (type_found == list_of_types.end()) {
|
|
return false;
|
|
}
|
|
|
|
// Find new Subtype
|
|
auto subtype_found = list_of_subtypes.find(vsubtype);
|
|
if (subtype_found == list_of_subtypes.end()) {
|
|
return false;
|
|
}
|
|
|
|
// Blur Type
|
|
if (strcmp(propname, ST_TYPE) == 0) {
|
|
obs_property_t* prop_subtype = obs_properties_get(props, ST_SUBTYPE);
|
|
|
|
/// Disable unsupported items.
|
|
size_t subvalue_idx = 0;
|
|
for (size_t idx = 0, edx = obs_property_list_item_count(prop_subtype); idx < edx; idx++) {
|
|
const char* subtype = obs_property_list_item_string(prop_subtype, idx);
|
|
bool disabled = false;
|
|
|
|
auto subtype_found_idx = list_of_subtypes.find(subtype);
|
|
if (subtype_found_idx != list_of_subtypes.end()) {
|
|
disabled = !type_found->second.fn().is_type_supported(subtype_found_idx->second.type);
|
|
} else {
|
|
disabled = true;
|
|
}
|
|
|
|
obs_property_list_item_disable(prop_subtype, idx, disabled);
|
|
if (strcmp(subtype, vsubtype) == 0) {
|
|
subvalue_idx = idx;
|
|
}
|
|
}
|
|
|
|
/// Ensure that there is a valid item selected.
|
|
if (obs_property_list_item_disabled(prop_subtype, subvalue_idx)) {
|
|
for (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));
|
|
|
|
// Find new Subtype
|
|
auto subtype_found2 = list_of_subtypes.find(vsubtype);
|
|
if (subtype_found2 == list_of_subtypes.end()) {
|
|
subtype_found = list_of_subtypes.end();
|
|
} else {
|
|
subtype_found = subtype_found2;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update hover text with new descriptions.
|
|
if (type_found != list_of_types.end()) {
|
|
if (type_found->first == "box") {
|
|
obs_property_set_long_description(obs_properties_get(props, ST_TYPE), D_TRANSLATE(D_DESC(S_BLUR_TYPE_BOX)));
|
|
} else if (type_found->first == "box_linear") {
|
|
obs_property_set_long_description(obs_properties_get(props, ST_TYPE),
|
|
D_TRANSLATE(D_DESC(S_BLUR_TYPE_BOX_LINEAR)));
|
|
} else if (type_found->first == "gaussian") {
|
|
obs_property_set_long_description(obs_properties_get(props, ST_TYPE),
|
|
D_TRANSLATE(D_DESC(S_BLUR_TYPE_GAUSSIAN)));
|
|
} else if (type_found->first == "gaussian_linear") {
|
|
obs_property_set_long_description(obs_properties_get(props, ST_TYPE),
|
|
D_TRANSLATE(D_DESC(S_BLUR_TYPE_GAUSSIAN_LINEAR)));
|
|
}
|
|
} else {
|
|
obs_property_set_long_description(obs_properties_get(props, ST_TYPE), D_TRANSLATE(D_DESC(ST_TYPE)));
|
|
}
|
|
if (subtype_found != list_of_subtypes.end()) {
|
|
if (subtype_found->first == "area") {
|
|
obs_property_set_long_description(obs_properties_get(props, ST_SUBTYPE),
|
|
D_TRANSLATE(D_DESC(S_BLUR_SUBTYPE_AREA)));
|
|
} else if (subtype_found->first == "directional") {
|
|
obs_property_set_long_description(obs_properties_get(props, ST_SUBTYPE),
|
|
D_TRANSLATE(D_DESC(S_BLUR_SUBTYPE_DIRECTIONAL)));
|
|
} else if (subtype_found->first == "rotational") {
|
|
obs_property_set_long_description(obs_properties_get(props, ST_SUBTYPE),
|
|
D_TRANSLATE(D_DESC(S_BLUR_SUBTYPE_ROTATIONAL)));
|
|
} else if (subtype_found->first == "zoom") {
|
|
obs_property_set_long_description(obs_properties_get(props, ST_SUBTYPE),
|
|
D_TRANSLATE(D_DESC(S_BLUR_SUBTYPE_ZOOM)));
|
|
}
|
|
} else {
|
|
obs_property_set_long_description(obs_properties_get(props, ST_SUBTYPE), D_TRANSLATE(D_DESC(ST_SUBTYPE)));
|
|
}
|
|
|
|
// Blur Sub-Type
|
|
{
|
|
bool has_angle_support = (subtype_found->second.type == ::gfx::blur::type::Directional)
|
|
|| (subtype_found->second.type == ::gfx::blur::type::Rotational);
|
|
bool has_center_support = (subtype_found->second.type == ::gfx::blur::type::Rotational)
|
|
|| (subtype_found->second.type == ::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;
|
|
|
|
/// Size
|
|
p = obs_properties_get(props, ST_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);
|
|
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);
|
|
|
|
/// 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(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);
|
|
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));
|
|
}
|
|
|
|
{ // Masking
|
|
using namespace 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_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);
|
|
}
|
|
|
|
return true;
|
|
} catch (...) {
|
|
LOG_ERROR("Unexpected exception in modified_properties callback.");
|
|
return false;
|
|
}
|
|
|
|
obs_properties_t* blur::blur_factory::get_properties2(blur::blur_instance* data)
|
|
{
|
|
obs_properties_t* pr = obs_properties_create();
|
|
obs_property_t* p = NULL;
|
|
|
|
// 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);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_TYPE)));
|
|
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");
|
|
obs_property_list_add_string(p, D_TRANSLATE(S_BLUR_TYPE_GAUSSIAN), "gaussian");
|
|
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,
|
|
OBS_COMBO_FORMAT_STRING);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_SUBTYPE)));
|
|
obs_property_set_modified_callback2(p, modified_properties, this);
|
|
obs_property_list_add_string(p, D_TRANSLATE(S_BLUR_SUBTYPE_AREA), "area");
|
|
obs_property_list_add_string(p, D_TRANSLATE(S_BLUR_SUBTYPE_DIRECTIONAL), "directional");
|
|
obs_property_list_add_string(p, D_TRANSLATE(S_BLUR_SUBTYPE_ROTATIONAL), "rotational");
|
|
obs_property_list_add_string(p, D_TRANSLATE(S_BLUR_SUBTYPE_ZOOM), "zoom");
|
|
}
|
|
|
|
// Blur Parameters
|
|
{
|
|
p = obs_properties_add_float_slider(pr, ST_SIZE, D_TRANSLATE(ST_SIZE), 1, 32767, 1);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_SIZE)));
|
|
|
|
p = obs_properties_add_float_slider(pr, ST_ANGLE, D_TRANSLATE(ST_ANGLE), -180.0, 180.0, 0.01);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_ANGLE)));
|
|
|
|
p = obs_properties_add_float_slider(pr, ST_CENTER_X, D_TRANSLATE(ST_CENTER_X), 0.00, 100.0, 0.01);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_CENTER_X)));
|
|
p = obs_properties_add_float_slider(pr, ST_CENTER_Y, D_TRANSLATE(ST_CENTER_Y), 0.00, 100.0, 0.01);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_CENTER_Y)));
|
|
|
|
p = obs_properties_add_bool(pr, ST_STEPSCALE, D_TRANSLATE(ST_STEPSCALE));
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_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);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_STEPSCALE_X)));
|
|
p = obs_properties_add_float_slider(pr, ST_STEPSCALE_Y, D_TRANSLATE(ST_STEPSCALE_Y), 0.0, 1000.0, 0.01);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_STEPSCALE_Y)));
|
|
}
|
|
|
|
// Masking
|
|
{
|
|
p = obs_properties_add_bool(pr, ST_MASK, D_TRANSLATE(ST_MASK));
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_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,
|
|
OBS_COMBO_FORMAT_INT);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_TYPE)));
|
|
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));
|
|
/// Region
|
|
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_LEFT, D_TRANSLATE(ST_MASK_REGION_LEFT), 0.0, 100.0,
|
|
0.01);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_REGION_LEFT)));
|
|
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_TOP, D_TRANSLATE(ST_MASK_REGION_TOP), 0.0, 100.0, 0.01);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_REGION_TOP)));
|
|
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_RIGHT, D_TRANSLATE(ST_MASK_REGION_RIGHT), 0.0, 100.0,
|
|
0.01);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_REGION_RIGHT)));
|
|
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_BOTTOM, D_TRANSLATE(ST_MASK_REGION_BOTTOM), 0.0, 100.0,
|
|
0.01);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_REGION_BOTTOM)));
|
|
p = obs_properties_add_float_slider(pr, ST_MASK_REGION_FEATHER, D_TRANSLATE(ST_MASK_REGION_FEATHER), 0.0, 50.0,
|
|
0.01);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_REGION_FEATHER)));
|
|
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);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_REGION_FEATHER_SHIFT)));
|
|
p = obs_properties_add_bool(pr, ST_MASK_REGION_INVERT, D_TRANSLATE(ST_MASK_REGION_INVERT));
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_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,
|
|
_translation_cache.back().c_str(), nullptr);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_IMAGE)));
|
|
}
|
|
/// Source
|
|
p = obs_properties_add_list(pr, ST_MASK_SOURCE, D_TRANSLATE(ST_MASK_SOURCE), OBS_COMBO_TYPE_LIST,
|
|
OBS_COMBO_FORMAT_STRING);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_SOURCE)));
|
|
obs_property_list_add_string(p, "", "");
|
|
obs::source_tracker::get()->enumerate(
|
|
[&p](std::string name, obs_source_t*) {
|
|
obs_property_list_add_string(p, std::string(name + " (Source)").c_str(), name.c_str());
|
|
return false;
|
|
},
|
|
obs::source_tracker::filter_video_sources);
|
|
obs::source_tracker::get()->enumerate(
|
|
[&p](std::string name, obs_source_t*) {
|
|
obs_property_list_add_string(p, std::string(name + " (Scene)").c_str(), name.c_str());
|
|
return false;
|
|
},
|
|
obs::source_tracker::filter_scenes);
|
|
|
|
/// Shared
|
|
p = obs_properties_add_color(pr, ST_MASK_COLOR, D_TRANSLATE(ST_MASK_COLOR));
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_COLOR)));
|
|
p = obs_properties_add_float_slider(pr, ST_MASK_ALPHA, D_TRANSLATE(ST_MASK_ALPHA), 0.0, 100.0, 0.1);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_ALPHA)));
|
|
p = obs_properties_add_float_slider(pr, ST_MASK_MULTIPLIER, D_TRANSLATE(ST_MASK_MULTIPLIER), 0.0, 10.0, 0.01);
|
|
obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_MULTIPLIER)));
|
|
}
|
|
|
|
return pr;
|
|
}
|
|
|
|
std::string blur::blur_factory::translate_string(const char* format, ...)
|
|
{
|
|
va_list vargs;
|
|
va_start(vargs, format);
|
|
std::vector<char> buffer(2048);
|
|
size_t len = static_cast<size_t>(vsnprintf(buffer.data(), buffer.size(), format, vargs));
|
|
va_end(vargs);
|
|
return std::string(buffer.data(), buffer.data() + len);
|
|
}
|