etc
/
obs-StreamFX
mirror of https://github.com/Xaymar/obs-StreamFX
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
obs-StreamFX/source/filter-blur.cpp

1118 lines
39 KiB
C++
Raw Normal View History

filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
/*
* Modern effects for a modern Streamer
filter-blur: Refactoring, formatting and copyright
2018-04-28 11:59:54 +00:00
* Copyright (C) 2017-2018 Michael Fabian Dirks
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
*
* 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.h"
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
#include <inttypes.h>
#include <map>
#include <math.h>
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
#include "strings.h"
filter-blur: Code cleanup, fixes and more - Fixed Gaussian Blur having color issues with radii that aren't a power of 2. - Improved error reporting to better debug problems where Blur doesn't render. - Switched from manual object management to managed classes. - Lots of code cleanup for maintainability.
2017-12-14 00:39:33 +00:00
#include "util-math.h"
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
extern "C" {
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
#pragma warning(push)
#pragma warning(disable : 4201)
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
#include "callback/signal.h"
project: Don't prefix includes with "libobs/"
2018-04-23 15:53:27 +00:00
#include "graphics/graphics.h"
#include "graphics/matrix4.h"
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
#include "util/platform.h"
#pragma warning(pop)
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
// Translation Strings
#define SOURCE_NAME "Filter.Blur"
#define P_TYPE "Filter.Blur.Type"
#define P_TYPE_BOX "Filter.Blur.Type.Box"
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
#define P_TYPE_BOXLINEAR "Filter.Blur.Type.BoxLinear"
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
#define P_TYPE_GAUSSIAN "Filter.Blur.Type.Gaussian"
filter-blur: Add Linear Gaussian Blur Similar to Linear Box Blur, this version of Gaussian Blur reduces the total number of sample by up to n. This results in a total sample count (per pass) of O(n+1) for even radii and O(n+2) for odd radii. The quality sacrificed to do this is higher this time, though careful adjustment of the halfTexelDelta value can bring it much closer to normal Gaussian Blur. The current offset however had no noticable effects on visual quality. See Also: #21 Blur Quality
2018-12-22 21:54:17 +00:00
#define P_TYPE_GAUSSIANLINEAR "Filter.Blur.Type.GaussianLinear"
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
#define P_TYPE_BILATERAL "Filter.Blur.Type.Bilateral"
#define P_SIZE "Filter.Blur.Size"
#define P_BILATERAL_SMOOTHING "Filter.Blur.Bilateral.Smoothing"
#define P_BILATERAL_SHARPNESS "Filter.Blur.Bilateral.Sharpness"
#define P_COLORFORMAT "Filter.Blur.ColorFormat"
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
#define P_MASK "Filter.Blur.Mask"
#define P_MASK_TYPE "Filter.Blur.Mask.Type"
#define P_MASK_TYPE_REGION "Filter.Blur.Mask.Type.Region"
#define P_MASK_TYPE_IMAGE "Filter.Blur.Mask.Type.Image"
#define P_MASK_TYPE_SOURCE "Filter.Blur.Mask.Type.Source"
#define P_MASK_REGION_LEFT "Filter.Blur.Mask.Region.Left"
#define P_MASK_REGION_RIGHT "Filter.Blur.Mask.Region.Right"
#define P_MASK_REGION_TOP "Filter.Blur.Mask.Region.Top"
#define P_MASK_REGION_BOTTOM "Filter.Blur.Mask.Region.Bottom"
#define P_MASK_REGION_FEATHER "Filter.Blur.Mask.Region.Feather"
#define P_MASK_REGION_FEATHER_SHIFT "Filter.Blur.Mask.Region.Feather.Shift"
#define P_MASK_REGION_INVERT "Filter.Blur.Mask.Region.Invert"
#define P_MASK_IMAGE "Filter.Blur.Mask.Image"
#define P_MASK_SOURCE "Filter.Blur.Mask.Source"
#define P_MASK_COLOR "Filter.Blur.Mask.Color"
filter-blur: Fix Mask Type and split Color into Color and Alpha
2018-09-30 22:54:36 +00:00
#define P_MASK_ALPHA "Filter.Blur.Mask.Alpha"
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
#define P_MASK_MULTIPLIER "Filter.Blur.Mask.Multiplier"
filter-blur: Refactoring, formatting and copyright
2018-04-28 11:59:54 +00:00
plugin: Use self-registration code everywhere
2018-01-16 10:47:24 +00:00
// Initializer & Finalizer
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
INITIALIZER(filterBlurFactoryInitializer)
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
initializerFunctions.push_back([] { filter::blur::blur_factory::initialize(); });
finalizerFunctions.push_back([] { filter::blur::blur_factory::finalize(); });
filter-blur: Use self-registration feature
2017-12-13 23:24:37 +00:00
}
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
enum ColorFormat : uint64_t { // ToDo: Refactor into full class.
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
RGB,
YUV, // 701
};
filter-blur: Use self-registration feature
2017-12-13 23:24:37 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
static uint8_t const max_kernel_size = 25;
filter-blur: Initial work on optimization
2017-07-18 14:47:29 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
bool filter::blur::blur_instance::apply_shared_param(gs_texture_t* input, float texelX, float texelY)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
bool result = true;
filter-blur: Multiple changes, see description * Added a 'Bilateral' de-noising blur, currently very resource hungry. It also has two extra sliders called 'Smoothing' and 'Sharpness', the former controls how smooth the output is * Updated effect loading to be global instead of per instance. * Changed default blur size to 5px. * Simplified render loop (see previous effect commit).
2017-07-03 05:20:15 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
result = result && gs_set_param_texture(blur_effect->get_object(), "u_image", input);
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
vec2 imageSize;
vec2_set(&imageSize, (float)gs_texture_get_width(input), (float)gs_texture_get_height(input));
result = result && gs_set_param_float2(blur_effect->get_object(), "u_imageSize", &imageSize);
filter-blur: Use only a single Gaussian Kernel Texture
2018-04-28 12:41:18 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
vec2 imageTexelDelta;
vec2_set(&imageTexelDelta, 1.0f, 1.0f);
vec2_div(&imageTexelDelta, &imageTexelDelta, &imageSize);
result = result && gs_set_param_float2(blur_effect->get_object(), "u_imageTexel", &imageTexelDelta);
filter-blur: Use only a single Gaussian Kernel Texture
2018-04-28 12:41:18 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
vec2 texel;
vec2_set(&texel, texelX, texelY);
result = result && gs_set_param_float2(blur_effect->get_object(), "u_texelDelta", &texel);
filter-blur: Use only a single Gaussian Kernel Texture
2018-04-28 12:41:18 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
result = result && gs_set_param_int(blur_effect->get_object(), "u_radius", (int)size);
result = result && gs_set_param_int(blur_effect->get_object(), "u_diameter", (int)(1 + (size * 2)));
filter-blur: Use only a single Gaussian Kernel Texture
2018-04-28 12:41:18 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
return result;
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
bool filter::blur::blur_instance::apply_bilateral_param()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
if (type != type::Bilateral)
return false;
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
if (blur_effect->has_parameter("bilateralSmoothing")) {
blur_effect->get_parameter("bilateralSmoothing").set_float((float)(bilateral_smoothing * (1 + size * 2)));
}
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
if (blur_effect->has_parameter("bilateralSharpness")) {
blur_effect->get_parameter("bilateralSharpness").set_float((float)(1.0 - bilateral_sharpness));
}
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
return true;
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}
filter-blur: Switch to Kernel Array instead of Kernel Texture This speeds up Gaussian Blur and Linear Gaussian Blur drastically reduces time spent reading textures and instead uses existing registers - maximizing time spent reading the actual image texture. See Also: #21 Blur Quality
2018-12-23 01:00:30 +00:00
bool filter::blur::blur_instance::apply_gaussian_param(uint8_t width)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Switch to Kernel Array instead of Kernel Texture This speeds up Gaussian Blur and Linear Gaussian Blur drastically reduces time spent reading textures and instead uses existing registers - maximizing time spent reading the actual image texture. See Also: #21 Blur Quality
2018-12-23 01:00:30 +00:00
auto kernel = filter::blur::blur_factory::get()->get_gaussian_kernel(width);
filter-blur: Multiple changes, see description * Added a 'Bilateral' de-noising blur, currently very resource hungry. It also has two extra sliders called 'Smoothing' and 'Sharpness', the former controls how smooth the output is * Updated effect loading to be global instead of per instance. * Changed default blur size to 5px. * Simplified render loop (see previous effect commit).
2017-07-03 05:20:15 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
if (blur_effect->has_parameter("kernel")) {
filter-blur: Switch to Kernel Array instead of Kernel Texture This speeds up Gaussian Blur and Linear Gaussian Blur drastically reduces time spent reading textures and instead uses existing registers - maximizing time spent reading the actual image texture. See Also: #21 Blur Quality
2018-12-23 01:00:30 +00:00
blur_effect->get_parameter("kernel").set_float_array(&(kernel->front()), kernel->size());
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
filter-blur: Multiple changes, see description * Added a 'Bilateral' de-noising blur, currently very resource hungry. It also has two extra sliders called 'Smoothing' and 'Sharpness', the former controls how smooth the output is * Updated effect loading to be global instead of per instance. * Changed default blur size to 5px. * Simplified render loop (see previous effect commit).
2017-07-03 05:20:15 +00:00
return true;
}
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
bool filter::blur::blur_instance::apply_mask_parameters(std::shared_ptr<gs::effect> effect,
gs_texture_t* original_texture, gs_texture_t* blurred_texture)
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
{
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")) {
filter-blur: Fix Mask Type and split Color into Color and Alpha
2018-09-30 22:54:36 +00:00
effect->get_parameter("mask_color").set_float4(mask.color.r, mask.color.g, mask.color.b, mask.color.a);
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
}
if (effect->has_parameter("mask_multiplier")) {
effect->get_parameter("mask_multiplier").set_float(mask.multiplier);
}
return true;
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
bool filter::blur::blur_instance::modified_properties(void* ptr, obs_properties_t* props, obs_property* prop,
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
obs_data_t* settings)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
bool showBilateral = (obs_data_get_int(settings, P_TYPE) == type::Bilateral);
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
prop;
ptr;
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
// bilateral blur
obs_property_set_visible(obs_properties_get(props, P_BILATERAL_SMOOTHING), showBilateral);
obs_property_set_visible(obs_properties_get(props, P_BILATERAL_SHARPNESS), showBilateral);
// region
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
bool show_mask = obs_data_get_bool(settings, P_MASK);
mask_type mtype = static_cast<mask_type>(obs_data_get_int(settings, P_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;
filter-blur: Fix Mask Type and split Color into Color and Alpha
2018-09-30 22:54:36 +00:00
obs_property_set_visible(obs_properties_get(props, P_MASK_TYPE), show_mask);
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
obs_property_set_visible(obs_properties_get(props, P_MASK_REGION_LEFT), show_region);
obs_property_set_visible(obs_properties_get(props, P_MASK_REGION_TOP), show_region);
obs_property_set_visible(obs_properties_get(props, P_MASK_REGION_RIGHT), show_region);
obs_property_set_visible(obs_properties_get(props, P_MASK_REGION_BOTTOM), show_region);
obs_property_set_visible(obs_properties_get(props, P_MASK_REGION_FEATHER), show_region);
obs_property_set_visible(obs_properties_get(props, P_MASK_REGION_FEATHER_SHIFT), show_region);
obs_property_set_visible(obs_properties_get(props, P_MASK_REGION_INVERT), show_region);
obs_property_set_visible(obs_properties_get(props, P_MASK_IMAGE), show_image);
obs_property_set_visible(obs_properties_get(props, P_MASK_SOURCE), show_source);
obs_property_set_visible(obs_properties_get(props, P_MASK_COLOR), show_image || show_source);
filter-blur: Fix Mask Type and split Color into Color and Alpha
2018-09-30 22:54:36 +00:00
obs_property_set_visible(obs_properties_get(props, P_MASK_ALPHA), show_image || show_source);
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
obs_property_set_visible(obs_properties_get(props, P_MASK_MULTIPLIER), show_image || show_source);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
// advanced
bool showAdvanced = obs_data_get_bool(settings, S_ADVANCED);
obs_property_set_visible(obs_properties_get(props, P_COLORFORMAT), showAdvanced);
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
return true;
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
bool filter::blur::blur_instance::can_log()
{
// Only allow logging errors every 200ms.
auto now = std::chrono::high_resolution_clock::now();
auto delta = (now - this->last_log);
std::swap(this->last_log, now);
return std::chrono::duration_cast<std::chrono::milliseconds>(delta) > std::chrono::milliseconds(200);
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
filter::blur::blur_instance::blur_instance(obs_data_t* settings, obs_source_t* parent)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
m_source = parent;
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Create RenderTargets
try {
this->rt_source = std::make_shared<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
this->rt_primary = std::make_shared<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
this->rt_secondary = std::make_shared<gs::rendertarget>(GS_RGBA, GS_ZS_NONE);
} catch (std::exception ex) {
P_LOG_ERROR("<filter-blur:%s> Failed to create rendertargets, error %s.", obs_source_get_name(m_source),
ex.what());
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Get initial Blur effect.
blur_effect = filter::blur::blur_factory::get()->get_effect(filter::blur::type::Box);
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
update(settings);
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
filter::blur::blur_instance::~blur_instance()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
this->rt_primary.reset();
this->rt_secondary.reset();
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
obs_properties_t* filter::blur::blur_instance::get_properties()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
obs_properties_t* pr = obs_properties_create();
obs_property_t* p = NULL;
filter-blur: Fix Blur filter occasionally not rendering An earlier commit changed how Blur filter rendered and thus m_technique was no longer being initialized, resulting in the check randomly failing if the memory was just right. This also adds some more extra logging to the instance creation in case things fail and fixed one MSVC warning. Fixes #1
2017-12-14 02:52:29 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
p = obs_properties_add_list(pr, P_TYPE, P_TRANSLATE(P_TYPE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_TYPE)));
obs_property_set_modified_callback2(p, modified_properties, this);
obs_property_list_add_int(p, P_TRANSLATE(P_TYPE_BOX), filter::blur::type::Box);
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
obs_property_list_add_int(p, P_TRANSLATE(P_TYPE_BOXLINEAR), filter::blur::type::BoxLinear);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
obs_property_list_add_int(p, P_TRANSLATE(P_TYPE_GAUSSIAN), filter::blur::type::Gaussian);
filter-blur: Add Linear Gaussian Blur Similar to Linear Box Blur, this version of Gaussian Blur reduces the total number of sample by up to n. This results in a total sample count (per pass) of O(n+1) for even radii and O(n+2) for odd radii. The quality sacrificed to do this is higher this time, though careful adjustment of the halfTexelDelta value can bring it much closer to normal Gaussian Blur. The current offset however had no noticable effects on visual quality. See Also: #21 Blur Quality
2018-12-22 21:54:17 +00:00
obs_property_list_add_int(p, P_TRANSLATE(P_TYPE_GAUSSIANLINEAR), filter::blur::type::GaussianLinear);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
obs_property_list_add_int(p, P_TRANSLATE(P_TYPE_BILATERAL), filter::blur::type::Bilateral);
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
p = obs_properties_add_int_slider(pr, P_SIZE, P_TRANSLATE(P_SIZE), 1, 25, 1);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_SIZE)));
//obs_property_set_modified_callback(p, modified_properties);
// bilateral Only
p = obs_properties_add_float_slider(pr, P_BILATERAL_SMOOTHING, P_TRANSLATE(P_BILATERAL_SMOOTHING), 0.0, 100.0,
0.01);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_BILATERAL_SMOOTHING)));
p = obs_properties_add_float_slider(pr, P_BILATERAL_SHARPNESS, P_TRANSLATE(P_BILATERAL_SHARPNESS), 0.0, 100.0,
0.01);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_BILATERAL_SHARPNESS)));
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
// Mask
p = obs_properties_add_bool(pr, P_MASK, P_TRANSLATE(P_MASK));
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK)));
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
obs_property_set_modified_callback2(p, modified_properties, this);
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
p = obs_properties_add_list(pr, P_MASK_TYPE, P_TRANSLATE(P_MASK_TYPE), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_TYPE)));
obs_property_set_modified_callback2(p, modified_properties, this);
obs_property_list_add_int(p, P_TRANSLATE(P_MASK_TYPE_REGION), mask_type::Region);
obs_property_list_add_int(p, P_TRANSLATE(P_MASK_TYPE_IMAGE), mask_type::Image);
obs_property_list_add_int(p, P_TRANSLATE(P_MASK_TYPE_SOURCE), mask_type::Source);
/// Region
p = obs_properties_add_float_slider(pr, P_MASK_REGION_LEFT, P_TRANSLATE(P_MASK_REGION_LEFT), 0.0, 100.0, 0.01);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_REGION_LEFT)));
p = obs_properties_add_float_slider(pr, P_MASK_REGION_TOP, P_TRANSLATE(P_MASK_REGION_TOP), 0.0, 100.0, 0.01);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_REGION_TOP)));
p = obs_properties_add_float_slider(pr, P_MASK_REGION_RIGHT, P_TRANSLATE(P_MASK_REGION_RIGHT), 0.0, 100.0, 0.01);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_REGION_RIGHT)));
p = obs_properties_add_float_slider(pr, P_MASK_REGION_BOTTOM, P_TRANSLATE(P_MASK_REGION_BOTTOM), 0.0, 100.0, 0.01);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_REGION_BOTTOM)));
p = obs_properties_add_float_slider(pr, P_MASK_REGION_FEATHER, P_TRANSLATE(P_MASK_REGION_FEATHER), 0.0, 50.0, 0.01);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_REGION_FEATHER)));
p = obs_properties_add_float_slider(pr, P_MASK_REGION_FEATHER_SHIFT, P_TRANSLATE(P_MASK_REGION_FEATHER_SHIFT),
-100.0, 100.0, 0.01);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_REGION_FEATHER_SHIFT)));
p = obs_properties_add_bool(pr, P_MASK_REGION_INVERT, P_TRANSLATE(P_MASK_REGION_INVERT));
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_REGION_INVERT)));
/// Image
p = obs_properties_add_path(pr, P_MASK_IMAGE, P_TRANSLATE(P_MASK_IMAGE), OBS_PATH_FILE,
P_TRANSLATE(S_FILEFILTERS_IMAGES), nullptr);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_IMAGE)));
/// Source
p = obs_properties_add_list(pr, P_MASK_SOURCE, P_TRANSLATE(P_MASK_SOURCE), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_STRING);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_SOURCE)));
obs_enum_sources(
[](void* ptr, obs_source_t* source) {
obs_property_t* p = reinterpret_cast<obs_property_t*>(ptr);
filter-blur: Add support for image and source masks (#14)
2018-09-30 22:54:36 +00:00
obs_property_list_add_string(p, std::string(std::string(obs_source_get_name(source)) + " (Source)").c_str(),
obs_source_get_name(source));
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
return true;
},
p);
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
blur_factory::get()->enum_scenes([this, p](obs_scene_t* scene) {
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
struct data {
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
blur_instance* self;
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
obs_property_t* prop;
std::string parent_name;
};
obs_source_t* scene_source = obs_scene_get_source(scene);
P_LOG_DEBUG("<filter-blur> Instance '%s' adding scene '%s'.", obs_source_get_name(m_source),
obs_source_get_name(scene_source));
obs_property_list_add_string(p,
std::string(std::string(obs_source_get_name(scene_source)) + " (Scene)").c_str(),
obs_source_get_name(scene_source));
return true;
});
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
/// Shared
p = obs_properties_add_color(pr, P_MASK_COLOR, P_TRANSLATE(P_MASK_COLOR));
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_COLOR)));
filter-blur: Fix Mask Type and split Color into Color and Alpha
2018-09-30 22:54:36 +00:00
p = obs_properties_add_float_slider(pr, P_MASK_ALPHA, P_TRANSLATE(P_MASK_ALPHA), 0.0, 100.0, 0.1);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_ALPHA)));
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
p = obs_properties_add_float_slider(pr, P_MASK_MULTIPLIER, P_TRANSLATE(P_MASK_MULTIPLIER), 0.0, 10.0, 0.01);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_MASK_MULTIPLIER)));
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
// advanced
p = obs_properties_add_bool(pr, S_ADVANCED, P_TRANSLATE(S_ADVANCED));
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(S_ADVANCED)));
obs_property_set_modified_callback2(p, modified_properties, this);
p = obs_properties_add_list(pr, P_COLORFORMAT, P_TRANSLATE(P_COLORFORMAT), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_INT);
obs_property_set_long_description(p, P_TRANSLATE(P_DESC(P_COLORFORMAT)));
obs_property_list_add_int(p, "RGB", ColorFormat::RGB);
obs_property_list_add_int(p, "YUV", ColorFormat::YUV);
return pr;
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_instance::update(obs_data_t* settings)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
type = (blur::type)obs_data_get_int(settings, P_TYPE);
blur_effect = blur_factory::get()->get_effect(type);
blur_technique = blur_factory::get()->get_technique(type);
size = (uint64_t)obs_data_get_int(settings, P_SIZE);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
// bilateral blur
bilateral_smoothing = obs_data_get_double(settings, P_BILATERAL_SMOOTHING) / 100.0;
bilateral_sharpness = obs_data_get_double(settings, P_BILATERAL_SHARPNESS) / 100.0;
// region
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
mask.enabled = obs_data_get_bool(settings, P_MASK);
if (mask.enabled) {
mask.type = static_cast<mask_type>(obs_data_get_int(settings, P_MASK_TYPE));
switch (mask.type) {
case mask_type::Region:
mask.region.left = float_t(obs_data_get_double(settings, P_MASK_REGION_LEFT) / 100.0);
mask.region.top = float_t(obs_data_get_double(settings, P_MASK_REGION_TOP) / 100.0);
mask.region.right = 1.0f - float_t(obs_data_get_double(settings, P_MASK_REGION_RIGHT) / 100.0);
mask.region.bottom = 1.0f - float_t(obs_data_get_double(settings, P_MASK_REGION_BOTTOM) / 100.0);
mask.region.feather = float_t(obs_data_get_double(settings, P_MASK_REGION_FEATHER) / 100.0);
mask.region.feather_shift = float_t(obs_data_get_double(settings, P_MASK_REGION_FEATHER_SHIFT) / 100.0);
mask.region.invert = obs_data_get_bool(settings, P_MASK_REGION_INVERT);
break;
case mask_type::Image:
mask.image.path = obs_data_get_string(settings, P_MASK_IMAGE);
break;
case mask_type::Source:
mask.source.name = obs_data_get_string(settings, P_MASK_SOURCE);
break;
}
if ((mask.type == mask_type::Image) || (mask.type == mask_type::Source)) {
filter-blur: Fix Mask Type and split Color into Color and Alpha
2018-09-30 22:54:36 +00:00
uint32_t color = static_cast<uint32_t>(obs_data_get_int(settings, P_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, P_MASK_ALPHA));
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
mask.multiplier = float_t(obs_data_get_double(settings, P_MASK_MULTIPLIER));
}
filter-blur: Allow applying Blur to a sub-region of the source only The Blur Filter can now be applied to a region inside the source itself, the inverse of that region, and/or a feathered version of that region. This allows for easier scene setups where only some parts need to be blurred, but the rest can be left as is. Fixes #12
2018-04-28 22:14:29 +00:00
}
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
// advanced
if (obs_data_get_bool(settings, S_ADVANCED)) {
color_format = obs_data_get_int(settings, P_COLORFORMAT);
filter-blur: Allow applying Blur to a sub-region of the source only The Blur Filter can now be applied to a region inside the source itself, the inverse of that region, and/or a feathered version of that region. This allows for easier scene setups where only some parts need to be blurred, but the rest can be left as is. Fixes #12
2018-04-28 22:14:29 +00:00
} else {
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
color_format = obs_data_get_default_int(settings, P_COLORFORMAT);
filter-blur: Allow applying Blur to a sub-region of the source only The Blur Filter can now be applied to a region inside the source itself, the inverse of that region, and/or a feathered version of that region. This allows for easier scene setups where only some parts need to be blurred, but the rest can be left as is. Fixes #12
2018-04-28 22:14:29 +00:00
}
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
uint32_t filter::blur::blur_instance::get_width()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Fix Mask Type and split Color into Color and Alpha
2018-09-30 22:54:36 +00:00
return uint32_t(0);
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
uint32_t filter::blur::blur_instance::get_height()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Fix Mask Type and split Color into Color and Alpha
2018-09-30 22:54:36 +00:00
return uint32_t(0);
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_instance::activate() {}
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_instance::deactivate() {}
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_instance::video_tick(float)
filter-blur: Add support for image and source masks (#14)
2018-09-30 22:54:36 +00:00
{
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 (...) {
P_LOG_ERROR("<filter-blur> Instance '%s' failed to load image '%s'.", obs_source_get_name(m_source),
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, m_source);
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
mask.source.is_scene = (obs_scene_from_source(mask.source.source_texture->get_object()) != nullptr);
filter-blur: Add support for image and source masks (#14)
2018-09-30 22:54:36 +00:00
mask.source.name_old = mask.source.name;
} catch (...) {
P_LOG_ERROR("<filter-blur> Instance '%s' failed to grab source '%s'.", obs_source_get_name(m_source),
mask.source.name.c_str());
}
}
}
}
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_instance::video_render(gs_effect_t* effect)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
obs_source_t* parent = obs_filter_get_parent(this->m_source);
obs_source_t* target = obs_filter_get_target(this->m_source);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
uint32_t baseW = obs_source_get_base_width(target);
uint32_t baseH = obs_source_get_base_height(target);
vec4 black = {0};
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Multiple changes, see description * Added a 'Bilateral' de-noising blur, currently very resource hungry. It also has two extra sliders called 'Smoothing' and 'Sharpness', the former controls how smooth the output is * Updated effect loading to be global instead of per instance. * Changed default blur size to 5px. * Simplified render loop (see previous effect commit).
2017-07-03 05:20:15 +00:00
bool failed = false;
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
std::shared_ptr<gs::effect> colorConversionEffect = blur_factory::get()->get_color_converter_effect();
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Verify that we can actually run first.
if (!target || !parent || !this->m_source) {
if (this->can_log()) {
P_LOG_ERROR("<filter-blur:%s> Invalid context, memory corruption may have happened.",
obs_source_get_name(this->m_source));
}
obs_source_skip_video_filter(this->m_source);
filter-blur: Code cleanup, fixes and more - Fixed Gaussian Blur having color issues with radii that aren't a power of 2. - Improved error reporting to better debug problems where Blur doesn't render. - Switched from manual object management to managed classes. - Lots of code cleanup for maintainability.
2017-12-14 00:39:33 +00:00
return;
}
filter-blur: Fix Mask Type and split Color into Color and Alpha
2018-09-30 22:54:36 +00:00
if ((baseW == 0) || (baseH == 0)) {
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
if (this->can_log()) {
P_LOG_ERROR("<filter-blur:%s> Invalid base size from '%s': %lux%lu.", obs_source_get_name(this->m_source),
obs_source_get_name(target), baseW, baseH);
}
obs_source_skip_video_filter(this->m_source);
filter-blur: Code cleanup, fixes and more - Fixed Gaussian Blur having color issues with radii that aren't a power of 2. - Improved error reporting to better debug problems where Blur doesn't render. - Switched from manual object management to managed classes. - Lots of code cleanup for maintainability.
2017-12-14 00:39:33 +00:00
return;
}
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
if (!this->rt_primary || !this->rt_secondary || !this->blur_effect) {
if (this->can_log()) {
P_LOG_ERROR("<filter-blur:%s> Missing RenderTarget or Effect.", obs_source_get_name(this->m_source));
}
obs_source_skip_video_filter(this->m_source);
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
return;
}
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
gs_effect_t* defaultEffect = obs_get_base_effect(obs_base_effect::OBS_EFFECT_DEFAULT);
std::shared_ptr<gs::texture> tex_source;
std::shared_ptr<gs::texture> tex_intermediate;
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Source To Texture
{
gs_blend_state_push();
gs_reset_blend_state();
gs_enable_color(true, true, true, true);
gs_enable_blending(true);
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_INVSRCALPHA);
gs_stencil_function(GS_STENCIL_BOTH, GS_ALWAYS);
gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO);
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
try {
auto op = this->rt_source->render(baseW, baseH);
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// 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);
filter-blur: Multiple changes, see description * Added a 'Bilateral' de-noising blur, currently very resource hungry. It also has two extra sliders called 'Smoothing' and 'Sharpness', the former controls how smooth the output is * Updated effect loading to be global instead of per instance. * Changed default blur size to 5px. * Simplified render loop (see previous effect commit).
2017-07-03 05:20:15 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Render
if (obs_source_process_filter_begin(this->m_source, GS_RGBA, OBS_NO_DIRECT_RENDERING)) {
obs_source_process_filter_end(this->m_source, defaultEffect, baseW, baseH);
} else {
throw std::exception("Failed to render source");
}
} catch (std::exception ex) {
if (this->can_log()) {
P_LOG_ERROR("<filter-blur:%s> Rendering parent source to texture failed with error: %s.",
obs_source_get_name(this->m_source), ex.what());
}
gs_blend_state_pop();
obs_source_skip_video_filter(this->m_source);
return;
}
gs_blend_state_pop();
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
if (!(tex_source = this->rt_source->get_texture())) {
if (this->can_log()) {
P_LOG_ERROR("<filter-blur> Failed to get source texture.");
}
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
obs_source_skip_video_filter(m_source);
return;
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
}
}
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Color Conversion RGB-YUV
if ((color_format == ColorFormat::YUV) && colorConversionEffect) {
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);
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
try {
auto op = this->rt_primary->render(baseW, baseH);
gs_ortho(0, (float)baseW, 0, (float)baseH, -1, 1);
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
if (colorConversionEffect->has_parameter("image")) {
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
colorConversionEffect->get_parameter("image").set_texture(tex_source->get_object());
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
}
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
while (gs_effect_loop(colorConversionEffect->get_object(), "RGBToYUV")) {
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
gs_draw_sprite(tex_source->get_object(), 0, baseW, baseH);
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
}
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
} catch (std::exception ex) {
if (this->can_log()) {
P_LOG_ERROR("<filter-blur:%s> RGB-YUV conversion failed with error: %s.",
obs_source_get_name(this->m_source), ex.what());
}
gs_blend_state_pop();
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
obs_source_skip_video_filter(m_source);
return;
}
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
gs_blend_state_pop();
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
if (!(tex_source = this->rt_primary->get_texture())) {
if (this->can_log()) {
P_LOG_ERROR("<filter-blur:%s> Failed to get color conversion texture.",
obs_source_get_name(this->m_source));
}
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
obs_source_skip_video_filter(m_source);
return;
}
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Swap RTs for further rendering.
std::swap(this->rt_primary, this->rt_secondary);
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
}
effects, filter-blur: Precalculated Kernel, Formatting, Rendering and more Filter: * Massively improved Rendering loop to reduce overhead and provide cleaner code. Gaussian Blur: * Added precalculated Kernels using Textures. Slightly reduced GPU load. * Added basic attempt at a Nvidia o(n/2+1) gaussian blur implementation. * Fix up LOD for texture sampling. Box Blur: * Halved loop count.
2017-08-19 22:19:58 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Blur
{
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);
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
std::pair<float, float> kvs[] = {{1.0f / baseW, 0.0f}, {0.0f, 1.0f / baseH}};
tex_intermediate = tex_source; // We need the original to work.
effects, filter-blur: Precalculated Kernel, Formatting, Rendering and more Filter: * Massively improved Rendering loop to reduce overhead and provide cleaner code. Gaussian Blur: * Added precalculated Kernels using Textures. Slightly reduced GPU load. * Added basic attempt at a Nvidia o(n/2+1) gaussian blur implementation. * Fix up LOD for texture sampling. Box Blur: * Halved loop count.
2017-08-19 22:19:58 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
try {
for (auto v : kvs) {
float xpel = std::get<0>(v);
float ypel = std::get<1>(v);
{
auto op = this->rt_primary->render(baseW, baseH);
gs_ortho(0, (float)baseW, 0, (float)baseH, -1, 1);
apply_shared_param(tex_intermediate->get_object(), xpel, ypel);
apply_gaussian_param(uint8_t(this->size));
apply_bilateral_param();
// Render
while (gs_effect_loop(this->blur_effect->get_object(), this->blur_technique.c_str())) {
gs_draw_sprite(tex_intermediate->get_object(), 0, baseW, baseH);
}
}
effects, filter-blur: Precalculated Kernel, Formatting, Rendering and more Filter: * Massively improved Rendering loop to reduce overhead and provide cleaner code. Gaussian Blur: * Added precalculated Kernels using Textures. Slightly reduced GPU load. * Added basic attempt at a Nvidia o(n/2+1) gaussian blur implementation. * Fix up LOD for texture sampling. Box Blur: * Halved loop count.
2017-08-19 22:19:58 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
if (!(tex_intermediate = this->rt_primary->get_texture())) {
throw("Failed to get blur texture.");
}
// Swap RTs for further rendering.
std::swap(this->rt_primary, this->rt_secondary);
}
} catch (std::exception ex) {
if (this->can_log()) {
P_LOG_ERROR("<filter-blur:%s> Blur failed with error: %s.", obs_source_get_name(this->m_source),
ex.what());
}
gs_blend_state_pop();
obs_source_skip_video_filter(this->m_source);
return;
effects, filter-blur: Precalculated Kernel, Formatting, Rendering and more Filter: * Massively improved Rendering loop to reduce overhead and provide cleaner code. Gaussian Blur: * Added precalculated Kernels using Textures. Slightly reduced GPU load. * Added basic attempt at a Nvidia o(n/2+1) gaussian blur implementation. * Fix up LOD for texture sampling. Box Blur: * Halved loop count.
2017-08-19 22:19:58 +00:00
}
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
gs_blend_state_pop();
effects, filter-blur: Precalculated Kernel, Formatting, Rendering and more Filter: * Massively improved Rendering loop to reduce overhead and provide cleaner code. Gaussian Blur: * Added precalculated Kernels using Textures. Slightly reduced GPU load. * Added basic attempt at a Nvidia o(n/2+1) gaussian blur implementation. * Fix up LOD for texture sampling. Box Blur: * Halved loop count.
2017-08-19 22:19:58 +00:00
}
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Mask
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
if (mask.enabled) {
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
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);
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
std::string technique = "";
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
switch (this->mask.type) {
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
case Region:
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
if (this->mask.region.feather > 0.001) {
if (this->mask.region.invert) {
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
technique = "RegionFeatherInverted";
} else {
technique = "RegionFeather";
}
} else {
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
if (this->mask.region.invert) {
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
technique = "RegionInverted";
} else {
technique = "Region";
}
}
break;
case Image:
case Source:
technique = "Image";
break;
}
filter-blur: Add support for image and source masks (#14)
2018-09-30 22:54:36 +00:00
if (mask.source.source_texture) {
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
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());
filter-blur: Add support for image and source masks (#14)
2018-09-30 22:54:36 +00:00
if (source_width == 0) {
source_width = baseW;
}
if (source_height == 0) {
source_height = baseH;
}
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
if (this->mask.source.is_scene) {
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
obs_video_info ovi;
if (obs_get_video_info(&ovi)) {
source_width = ovi.base_width;
source_height = ovi.base_height;
}
}
filter-blur: Add support for image and source masks (#14)
2018-09-30 22:54:36 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
this->mask.source.texture = this->mask.source.source_texture->render(source_width, source_height);
filter-blur: Add support for image and source masks (#14)
2018-09-30 22:54:36 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
std::shared_ptr<gs::effect> mask_effect = blur_factory::get()->get_mask_effect();
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
apply_mask_parameters(mask_effect, tex_source->get_object(), tex_intermediate->get_object());
filter-blur: Add support for image and source masks (#14)
2018-09-30 22:54:36 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
try {
auto op = this->rt_primary->render(baseW, baseH);
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
gs_ortho(0, (float)baseW, 0, (float)baseH, -1, 1);
// Render
while (gs_effect_loop(mask_effect->get_object(), technique.c_str())) {
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
gs_draw_sprite(tex_intermediate->get_object(), 0, baseW, baseH);
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
}
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
} catch (std::exception ex) {
if (this->can_log()) {
P_LOG_ERROR("<filter-blur:%s> Masking failed with error: %s.", obs_source_get_name(this->m_source),
ex.what());
}
gs_blend_state_pop();
obs_source_skip_video_filter(this->m_source);
return;
}
gs_blend_state_pop();
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
if (!(tex_intermediate = this->rt_primary->get_texture())) {
if (this->can_log()) {
P_LOG_ERROR("<filter-blur:%s> Failed to get masked texture.", obs_source_get_name(this->m_source));
}
obs_source_skip_video_filter(this->m_source);
return;
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
}
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Swap RTs for further rendering.
std::swap(this->rt_primary, this->rt_secondary);
}
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// Color Conversion RGB-YUV or Straight Draw
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
{
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
// It is important that we do not modify the blend state here, as it is set correctly by OBS
gs_enable_color(true, true, true, true);
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_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;
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
const char* technique = "Draw";
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
if ((color_format == ColorFormat::YUV) && colorConversionEffect) {
finalEffect = colorConversionEffect->get_object();
technique = "YUVToRGB";
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
}
gs_eparam_t* param = gs_effect_get_param_by_name(finalEffect, "image");
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
if (!param) {
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
P_LOG_ERROR("<filter-blur:%s> Failed to set image param.", obs_source_get_name(this->m_source));
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
failed = true;
} else {
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
gs_effect_set_texture(param, tex_intermediate->get_object());
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
}
filter-blur: Add Color Format option This option allows applying the blur to other color formats such as YUV. Bilateral Blur benefits the most from this, resulting in smoother images at lower kernel sizes.
2017-07-06 04:02:41 +00:00
while (gs_effect_loop(finalEffect, technique)) {
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
gs_draw_sprite(tex_intermediate->get_object(), 0, baseW, baseH);
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
}
}
if (failed) {
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
obs_source_skip_video_filter(m_source);
return;
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
}
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
filter::blur::blur_factory::blur_factory()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
memset(&source_info, 0, sizeof(obs_source_info));
source_info.id = "obs-stream-effects-filter-blur";
source_info.type = OBS_SOURCE_TYPE_FILTER;
source_info.output_flags = OBS_SOURCE_VIDEO;
source_info.get_name = get_name;
source_info.get_defaults = get_defaults;
source_info.get_properties = get_properties;
source_info.create = create;
source_info.destroy = destroy;
source_info.update = update;
source_info.activate = activate;
source_info.deactivate = deactivate;
source_info.video_tick = video_tick;
source_info.video_render = video_render;
obs_register_source(&source_info);
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
auto osi = obs_get_signal_handler();
signal_handler_connect(osi, "source_create", scene_create_handler, this);
signal_handler_connect(osi, "source_destroy", scene_destroy_handler, this);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
filter::blur::blur_factory::~blur_factory()
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
{
auto osi = obs_get_signal_handler();
signal_handler_disconnect(osi, "source_create", scene_create_handler, this);
signal_handler_disconnect(osi, "source_destroy", scene_destroy_handler, this);
}
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::on_list_fill()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
obs_enter_graphics();
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
{
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
char* file = obs_module_file("effects/blur.effect");
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
try {
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
blur_effect = std::make_shared<gs::effect>(file);
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
} catch (std::runtime_error ex) {
P_LOG_ERROR("<filter-blur> Loading effect '%s' failed with error(s): %s", file, ex.what());
}
bfree(file);
}
{
char* file = obs_module_file("effects/color-conversion.effect");
try {
color_converter_effect = std::make_shared<gs::effect>(file);
} catch (std::runtime_error ex) {
P_LOG_ERROR("<filter-blur> Loading effect '%s' failed with error(s): %s", file, ex.what());
}
bfree(file);
}
{
char* file = obs_module_file("effects/mask.effect");
try {
mask_effect = std::make_shared<gs::effect>(file);
} catch (std::runtime_error ex) {
P_LOG_ERROR("<filter-blur> Loading effect '%s' failed with error(s): %s", file, ex.what());
}
bfree(file);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
generate_kernel_textures();
obs_leave_graphics();
}
filter-blur: Multiple changes, see description * Added a 'Bilateral' de-noising blur, currently very resource hungry. It also has two extra sliders called 'Smoothing' and 'Sharpness', the former controls how smooth the output is * Updated effect loading to be global instead of per instance. * Changed default blur size to 5px. * Simplified render loop (see previous effect commit).
2017-07-03 05:20:15 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::on_list_empty()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
obs_enter_graphics();
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
blur_effect.reset();
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
kernels.clear();
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
color_converter_effect.reset();
mask_effect.reset();
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
obs_leave_graphics();
}
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::generate_gaussian_kernels()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
// 2D texture, horizontal is value, vertical is kernel size.
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
size_t size_power_of_two = size_t(pow(2, util::math::get_power_of_two_exponent_ceil(max_kernel_size)));
filter-blur: Split off blur rendering into method
2017-07-06 03:57:57 +00:00
filter-blur: Switch to Kernel Array instead of Kernel Texture This speeds up Gaussian Blur and Linear Gaussian Blur drastically reduces time spent reading textures and instead uses existing registers - maximizing time spent reading the actual image texture. See Also: #21 Blur Quality
2018-12-23 01:00:30 +00:00
std::vector<float_t> texture_data(size_power_of_two * size_power_of_two);
std::vector<float_t> math_data(size_power_of_two);
std::shared_ptr<std::vector<float_t>> kernel_data;
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
for (size_t width = 1; width <= max_kernel_size; width++) {
filter-blur: Switch to Kernel Array instead of Kernel Texture This speeds up Gaussian Blur and Linear Gaussian Blur drastically reduces time spent reading textures and instead uses existing registers - maximizing time spent reading the actual image texture. See Also: #21 Blur Quality
2018-12-23 01:00:30 +00:00
size_t v = (width - 1) * size_power_of_two;
kernel_data = std::make_shared<std::vector<float_t>>(size_power_of_two);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
// Calculate and normalize
float_t sum = 0;
for (size_t p = 0; p <= width; p++) {
math_data[p] = float_t(Gaussian1D(double_t(p), double_t(width)));
sum += math_data[p] * (p > 0 ? 2 : 1);
filter-blur: Allow applying Blur to a sub-region of the source only The Blur Filter can now be applied to a region inside the source itself, the inverse of that region, and/or a feathered version of that region. This allows for easier scene setups where only some parts need to be blurred, but the rest can be left as is. Fixes #12
2018-04-28 22:14:29 +00:00
}
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
// Normalize to Texture Buffer
double_t inverse_sum = 1.0 / sum;
for (size_t p = 0; p <= width; p++) {
filter-blur: Switch to Kernel Array instead of Kernel Texture This speeds up Gaussian Blur and Linear Gaussian Blur drastically reduces time spent reading textures and instead uses existing registers - maximizing time spent reading the actual image texture. See Also: #21 Blur Quality
2018-12-23 01:00:30 +00:00
texture_data[v + p] = float_t(math_data[p] * inverse_sum);
kernel_data->at(p) = texture_data[v + p];
filter-blur: Allow applying Blur to a sub-region of the source only The Blur Filter can now be applied to a region inside the source itself, the inverse of that region, and/or a feathered version of that region. This allows for easier scene setups where only some parts need to be blurred, but the rest can be left as is. Fixes #12
2018-04-28 22:14:29 +00:00
}
filter-blur: Switch to Kernel Array instead of Kernel Texture This speeds up Gaussian Blur and Linear Gaussian Blur drastically reduces time spent reading textures and instead uses existing registers - maximizing time spent reading the actual image texture. See Also: #21 Blur Quality
2018-12-23 01:00:30 +00:00
gaussian_kernels.insert({uint8_t(width), kernel_data});
filter-blur: Allow applying Blur to a sub-region of the source only The Blur Filter can now be applied to a region inside the source itself, the inverse of that region, and/or a feathered version of that region. This allows for easier scene setups where only some parts need to be blurred, but the rest can be left as is. Fixes #12
2018-04-28 22:14:29 +00:00
}
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
// Create Texture
try {
filter-blur: Switch to Kernel Array instead of Kernel Texture This speeds up Gaussian Blur and Linear Gaussian Blur drastically reduces time spent reading textures and instead uses existing registers - maximizing time spent reading the actual image texture. See Also: #21 Blur Quality
2018-12-23 01:00:30 +00:00
auto texture_buffer = reinterpret_cast<uint8_t*>(texture_data.data());
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
auto unsafe_buffer = const_cast<const uint8_t**>(&texture_buffer);
filter-blur: Multiple changes, see description * Added a 'Bilateral' de-noising blur, currently very resource hungry. It also has two extra sliders called 'Smoothing' and 'Sharpness', the former controls how smooth the output is * Updated effect loading to be global instead of per instance. * Changed default blur size to 5px. * Simplified render loop (see previous effect commit).
2017-07-03 05:20:15 +00:00
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
kernels.insert_or_assign(filter::blur::type::Gaussian,
std::make_shared<gs::texture>(uint32_t(size_power_of_two), uint32_t(size_power_of_two),
GS_R32F, 1, unsafe_buffer, gs::texture::flags::None));
} catch (std::runtime_error ex) {
P_LOG_ERROR("<filter-blur> Failed to create gaussian kernel texture.");
}
}
filter-blur: Multiple changes, see description * Added a 'Bilateral' de-noising blur, currently very resource hungry. It also has two extra sliders called 'Smoothing' and 'Sharpness', the former controls how smooth the output is * Updated effect loading to be global instead of per instance. * Changed default blur size to 5px. * Simplified render loop (see previous effect commit).
2017-07-03 05:20:15 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::generate_kernel_textures()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
generate_gaussian_kernels();
}
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void* filter::blur::blur_factory::create(obs_data_t* data, obs_source_t* parent)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
if (get()->sources.empty()) {
get()->on_list_fill();
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
filter::blur::blur_instance* ptr = new filter::blur::blur_instance(data, parent);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
get()->sources.push_back(ptr);
return ptr;
}
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::destroy(void* inptr)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
filter::blur::blur_instance* ptr = reinterpret_cast<filter::blur::blur_instance*>(inptr);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
get()->sources.remove(ptr);
if (get()->sources.empty()) {
get()->on_list_empty();
filter-blur: Multiple changes, see description * Added a 'Bilateral' de-noising blur, currently very resource hungry. It also has two extra sliders called 'Smoothing' and 'Sharpness', the former controls how smooth the output is * Updated effect loading to be global instead of per instance. * Changed default blur size to 5px. * Simplified render loop (see previous effect commit).
2017-07-03 05:20:15 +00:00
}
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::get_defaults(obs_data_t* data)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
obs_data_set_default_int(data, P_TYPE, filter::blur::type::Box);
obs_data_set_default_int(data, P_SIZE, 5);
// bilateral Only
obs_data_set_default_double(data, P_BILATERAL_SMOOTHING, 50.0);
obs_data_set_default_double(data, P_BILATERAL_SHARPNESS, 90.0);
// region
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
obs_data_set_default_bool(data, P_MASK, false);
obs_data_set_default_int(data, P_MASK_TYPE, mask_type::Region);
obs_data_set_default_double(data, P_MASK_REGION_LEFT, 0.0f);
obs_data_set_default_double(data, P_MASK_REGION_RIGHT, 0.0f);
obs_data_set_default_double(data, P_MASK_REGION_TOP, 0.0f);
obs_data_set_default_double(data, P_MASK_REGION_BOTTOM, 0.0f);
obs_data_set_default_double(data, P_MASK_REGION_FEATHER, 0.0f);
obs_data_set_default_double(data, P_MASK_REGION_FEATHER_SHIFT, 0.0f);
obs_data_set_default_bool(data, P_MASK_REGION_INVERT, false);
char* default_file = obs_module_file("white.png");
obs_data_set_default_string(data, P_MASK_IMAGE, default_file);
bfree(default_file);
obs_data_set_default_string(data, P_MASK_SOURCE, "");
filter-blur: Fix Mask Type and split Color into Color and Alpha
2018-09-30 22:54:36 +00:00
obs_data_set_default_int(data, P_MASK_COLOR, 0xFFFFFFFFull);
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
obs_data_set_default_double(data, P_MASK_MULTIPLIER, 1.0);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
// advanced
obs_data_set_default_bool(data, S_ADVANCED, false);
obs_data_set_default_int(data, P_COLORFORMAT, ColorFormat::RGB);
effects, filter-blur: Precalculated Kernel, Formatting, Rendering and more Filter: * Massively improved Rendering loop to reduce overhead and provide cleaner code. Gaussian Blur: * Added precalculated Kernels using Textures. Slightly reduced GPU load. * Added basic attempt at a Nvidia o(n/2+1) gaussian blur implementation. * Fix up LOD for texture sampling. Box Blur: * Halved loop count.
2017-08-19 22:19:58 +00:00
}
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
obs_properties_t* filter::blur::blur_factory::get_properties(void* inptr)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
return reinterpret_cast<filter::blur::blur_instance*>(inptr)->get_properties();
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::update(void* inptr, obs_data_t* settings)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
reinterpret_cast<filter::blur::blur_instance*>(inptr)->update(settings);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
effects, filter-blur: Precalculated Kernel, Formatting, Rendering and more Filter: * Massively improved Rendering loop to reduce overhead and provide cleaner code. Gaussian Blur: * Added precalculated Kernels using Textures. Slightly reduced GPU load. * Added basic attempt at a Nvidia o(n/2+1) gaussian blur implementation. * Fix up LOD for texture sampling. Box Blur: * Halved loop count.
2017-08-19 22:19:58 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
const char* filter::blur::blur_factory::get_name(void* inptr)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
inptr;
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
return P_TRANSLATE(SOURCE_NAME);
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
uint32_t filter::blur::blur_factory::get_width(void* inptr)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
return reinterpret_cast<filter::blur::blur_instance*>(inptr)->get_width();
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
uint32_t filter::blur::blur_factory::get_height(void* inptr)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
return reinterpret_cast<filter::blur::blur_instance*>(inptr)->get_height();
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::activate(void* inptr)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
reinterpret_cast<filter::blur::blur_instance*>(inptr)->activate();
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::deactivate(void* inptr)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
reinterpret_cast<filter::blur::blur_instance*>(inptr)->deactivate();
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::video_tick(void* inptr, float delta)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
reinterpret_cast<filter::blur::blur_instance*>(inptr)->video_tick(delta);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::video_render(void* inptr, gs_effect_t* effect)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
reinterpret_cast<filter::blur::blur_instance*>(inptr)->video_render(effect);
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::scene_create_handler(void* ptr, calldata_t* data)
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
filter::blur::blur_factory* self = reinterpret_cast<filter::blur::blur_factory*>(ptr);
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
obs_source_t* source = nullptr;
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
calldata_get_ptr(data, "source", &source);
obs_scene_t* scene = obs_scene_from_source(source);
if (scene) {
self->scenes.insert_or_assign(std::string(obs_source_get_name(source)), scene);
}
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::scene_destroy_handler(void* ptr, calldata_t* data)
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
filter::blur::blur_factory* self = reinterpret_cast<filter::blur::blur_factory*>(ptr);
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
obs_source_t* source = nullptr;
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
calldata_get_ptr(data, "source", &source);
obs_scene_t* scene = obs_scene_from_source(source);
if (scene) {
self->scenes.erase(std::string(obs_source_get_name(source)));
}
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
std::shared_ptr<gs::effect> filter::blur::blur_factory::get_effect(filter::blur::type type)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Fix translucent source rendering and modernize code Translucent sources previously rendered with wrong alpha, which caused sources to look different than they should. With the new code, this is no longer the case and instead now renders the source correctly. Additionally the modernized code should reduce any problems with rendering by reducing the amount of duplicated manually written code and instead using classes.
2018-12-23 17:27:24 +00:00
type;
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
return blur_effect;
}
std::string filter::blur::blur_factory::get_technique(filter::blur::type type)
{
switch (type) {
case type::Box:
return "Box";
case type::Gaussian:
return "Gaussian";
case type::Bilateral:
return "Bilateral";
filter-blur: Add Linear Gaussian Blur Similar to Linear Box Blur, this version of Gaussian Blur reduces the total number of sample by up to n. This results in a total sample count (per pass) of O(n+1) for even radii and O(n+2) for odd radii. The quality sacrificed to do this is higher this time, though careful adjustment of the halfTexelDelta value can bring it much closer to normal Gaussian Blur. The current offset however had no noticable effects on visual quality. See Also: #21 Blur Quality
2018-12-22 21:54:17 +00:00
case type::BoxLinear:
return "BoxLinear";
case type::GaussianLinear:
return "GaussianLinear";
filter-blur: Add Linear Box Blur and combine all effects Linear Box Blur abuses the fact that with Linear Sampling we can sample up to four adjacent texels at the same time and get a correct result for Box Blur back. Using this the total number of sample for Box Blur is reduced by n, making the total either n+1 (Even Radius) or n (Odd Radius). Additionally all blur effect files have been merged into a single blur.effect file to reduce the time required to change a single parameter name. New blur effects should be added as a new technique instead of as a new effect file. See Also: #21 Blur Quality
2018-12-22 21:07:33 +00:00
}
return "";
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
std::shared_ptr<gs::effect> filter::blur::blur_factory::get_color_converter_effect()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
return color_converter_effect;
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
std::shared_ptr<gs::effect> filter::blur::blur_factory::get_mask_effect()
filter-blur: Add proper mask options * Removes the old 'Region' fields and places them under a 'Mask' option that can do much more. * Supported Mask types: Region, Image, Source. * Image and Source mask types allow for a color filter and multiplier.
2018-09-30 20:48:47 +00:00
{
return mask_effect;
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
std::shared_ptr<gs::texture> filter::blur::blur_factory::get_kernel(filter::blur::type type)
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
return kernels.at(type);
}
filter-blur: Switch to Kernel Array instead of Kernel Texture This speeds up Gaussian Blur and Linear Gaussian Blur drastically reduces time spent reading textures and instead uses existing registers - maximizing time spent reading the actual image texture. See Also: #21 Blur Quality
2018-12-23 01:00:30 +00:00
std::shared_ptr<std::vector<float_t>> filter::blur::blur_factory::get_gaussian_kernel(uint8_t size)
{
return gaussian_kernels.at(size);
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
obs_scene_t* filter::blur::blur_factory::get_scene(std::string name)
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
{
auto kv = scenes.find(name);
if (kv != scenes.end()) {
return kv->second;
}
return nullptr;
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::enum_scenes(std::function<bool(obs_scene_t*)> fnc)
filter-blur: Add support for scene as mask input (#14) Adds full support for Scenes as mask input so that you can re-use your overlay scene as a blur input and have the blur follow behind your overlay. Closes #14
2018-09-30 22:54:36 +00:00
{
for (auto kv : scenes) {
if (!fnc(kv.second)) {
break;
}
}
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
static filter::blur::blur_factory* factory_instance = nullptr;
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::initialize()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
factory_instance = new filter::blur::blur_factory();
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
void filter::blur::blur_factory::finalize()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
delete factory_instance;
}
filter-blur: Rename factory and instance to blur_*
2018-11-08 10:16:55 +00:00
filter::blur::blur_factory* filter::blur::blur_factory::get()
filter-blur: Refactor and formatting * Now using a Factory and Instance approach to simplify and beautify the code at the same time. * Additionally we now keep track of created filters and only load data if there is a filter active, and unload data if there are no more filters. This reduces memory and GPU overhead when no filter is active, but adds a first time filter creation overhead. * Variables and functions now use snake_case.
2018-09-30 18:50:00 +00:00
{
return factory_instance;
filter-blur: Add Box and Gaussian Blur Filter This is not very optimized at the moment and will take quite a bit of GPU time. Will have to spend some time later to optimize it and perhaps add directional blur ("Motion Blur" to it).
2017-07-03 00:46:33 +00:00
}