From b54e95527ace894498bb0b785d1dcc59d42f1c34 Mon Sep 17 00:00:00 2001 From: Michael Fabian 'Xaymar' Dirks Date: Sun, 15 Dec 2019 11:39:57 +0100 Subject: [PATCH] gs-effect*: Finish up refactoring onto std::shared_ptr This is most likely not the last refactor, the entire obs/gs stuff is very very basic right now and likely needs a complete rewrite. --- source/filters/filter-blur.cpp | 74 +-- source/filters/filter-blur.hpp | 6 +- source/filters/filter-color-grade.cpp | 42 +- source/filters/filter-color-grade.hpp | 2 +- source/filters/filter-displacement.cpp | 19 +- source/filters/filter-displacement.hpp | 2 +- source/filters/filter-dynamic-mask.cpp | 16 +- source/filters/filter-dynamic-mask.hpp | 2 +- source/filters/filter-sdf-effects.cpp | 112 ++-- source/filters/filter-sdf-effects.hpp | 4 +- source/filters/filter-shader.hpp | 2 +- source/gfx/blur/gfx-blur-box-linear.cpp | 40 +- source/gfx/blur/gfx-blur-box-linear.hpp | 4 +- source/gfx/blur/gfx-blur-box.cpp | 74 +-- source/gfx/blur/gfx-blur-box.hpp | 4 +- source/gfx/blur/gfx-blur-dual-filtering.cpp | 24 +- source/gfx/blur/gfx-blur-dual-filtering.hpp | 4 +- source/gfx/blur/gfx-blur-gaussian-linear.cpp | 42 +- source/gfx/blur/gfx-blur-gaussian-linear.hpp | 4 +- source/gfx/blur/gfx-blur-gaussian.cpp | 80 +-- source/gfx/blur/gfx-blur-gaussian.hpp | 4 +- source/obs/gs/gs-effect-parameter.cpp | 534 +++++++++++++++++++ source/obs/gs/gs-effect-parameter.hpp | 186 ++++++- source/obs/gs/gs-effect-pass.hpp | 12 +- source/obs/gs/gs-effect-technique.cpp | 7 +- source/obs/gs/gs-effect-technique.hpp | 17 +- source/obs/gs/gs-effect.cpp | 3 +- source/obs/gs/gs-effect.hpp | 15 +- source/obs/gs/gs-mipmapper.cpp | 12 +- source/obs/gs/gs-mipmapper.hpp | 2 +- 30 files changed, 1040 insertions(+), 309 deletions(-) diff --git a/source/filters/filter-blur.cpp b/source/filters/filter-blur.cpp index 438b2e5..d1a51b8 100644 --- a/source/filters/filter-blur.cpp +++ b/source/filters/filter-blur.cpp @@ -130,66 +130,66 @@ filter::blur::blur_instance::blur_instance(obs_data_t* settings, obs_source_t* s filter::blur::blur_instance::~blur_instance() {} -bool filter::blur::blur_instance::apply_mask_parameters(std::shared_ptr effect, - gs_texture_t* original_texture, gs_texture_t* blurred_texture) +bool filter::blur::blur_instance::apply_mask_parameters(gs::effect effect, gs_texture_t* original_texture, + gs_texture_t* blurred_texture) { - if (effect->has_parameter("image_orig")) { - effect->get_parameter("image_orig")->set_texture(original_texture); + if (effect.has_parameter("image_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); + 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_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_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_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_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")) { + 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); + 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 (effect.has_parameter("mask_image")) { if (_mask.image.texture) { - effect->get_parameter("mask_image")->set_texture(_mask.image.texture); + effect.get_parameter("mask_image").set_texture(_mask.image.texture); } else { - effect->get_parameter("mask_image")->set_texture(nullptr); + effect.get_parameter("mask_image").set_texture(nullptr); } } } // Source if (_mask.type == mask_type::Source) { - if (effect->has_parameter("mask_image")) { + if (effect.has_parameter("mask_image")) { if (_mask.source.texture) { - effect->get_parameter("mask_image")->set_texture(_mask.source.texture); + effect.get_parameter("mask_image").set_texture(_mask.source.texture); } else { - effect->get_parameter("mask_image")->set_texture(nullptr); + effect.get_parameter("mask_image").set_texture(nullptr); } } } // Shared - if (effect->has_parameter("mask_color")) { - effect->get_parameter("mask_color")->set_float4(_mask.color.r, _mask.color.g, _mask.color.b, _mask.color.a); + if (effect.has_parameter("mask_color")) { + effect.get_parameter("mask_color").set_float4(_mask.color.r, _mask.color.g, _mask.color.b, _mask.color.a); } - if (effect->has_parameter("mask_multiplier")) { - effect->get_parameter("mask_multiplier")->set_float(_mask.multiplier); + if (effect.has_parameter("mask_multiplier")) { + effect.get_parameter("mask_multiplier").set_float(_mask.multiplier); } return true; @@ -276,7 +276,7 @@ void filter::blur::blur_instance::update(obs_data_t* settings) { // Masking _mask.enabled = obs_data_get_bool(settings, ST_MASK); if (_mask.enabled) { - _mask.type = static_cast(obs_data_get_int(settings, ST_MASK_TYPE)); + _mask.type = static_cast(obs_data_get_int(settings, ST_MASK_TYPE)); switch (_mask.type) { case mask_type::Region: _mask.region.left = float_t(obs_data_get_double(settings, ST_MASK_REGION_LEFT) / 100.0); @@ -444,7 +444,7 @@ void filter::blur::blur_instance::video_render(gs_effect_t* effect) std::string technique = ""; switch (this->_mask.type) { - case Region: + case mask_type::Region: if (this->_mask.region.feather > std::numeric_limits::epsilon()) { if (this->_mask.region.invert) { technique = "RegionFeatherInverted"; @@ -459,8 +459,8 @@ void filter::blur::blur_instance::video_render(gs_effect_t* effect) } } break; - case Image: - case Source: + case mask_type::Image: + case mask_type::Source: technique = "Image"; break; } @@ -493,7 +493,7 @@ void filter::blur::blur_instance::video_render(gs_effect_t* effect) gs_ortho(0, (float)baseW, 0, (float)baseH, -1, 1); // Render - while (gs_effect_loop(_effect_mask->get_object(), technique.c_str())) { + while (gs_effect_loop(_effect_mask.get_object(), technique.c_str())) { gs_draw_sprite(_output_texture->get_object(), 0, baseW, baseH); } } catch (const std::exception&) { @@ -574,7 +574,7 @@ void filter::blur::blur_factory::get_defaults2(obs_data_t* settings) // Masking obs_data_set_default_bool(settings, ST_MASK, false); - obs_data_set_default_int(settings, ST_MASK_TYPE, mask_type::Region); + obs_data_set_default_int(settings, ST_MASK_TYPE, static_cast(mask_type::Region)); obs_data_set_default_double(settings, ST_MASK_REGION_LEFT, 0.0); obs_data_set_default_double(settings, ST_MASK_REGION_RIGHT, 0.0); obs_data_set_default_double(settings, ST_MASK_REGION_TOP, 0.0); @@ -814,9 +814,9 @@ obs_properties_t* filter::blur::blur_factory::get_properties2(filter::blur::blur OBS_COMBO_FORMAT_INT); obs_property_set_long_description(p, D_TRANSLATE(D_DESC(ST_MASK_TYPE))); obs_property_set_modified_callback2(p, modified_properties, this); - obs_property_list_add_int(p, D_TRANSLATE(ST_MASK_TYPE_REGION), mask_type::Region); - obs_property_list_add_int(p, D_TRANSLATE(ST_MASK_TYPE_IMAGE), mask_type::Image); - obs_property_list_add_int(p, D_TRANSLATE(ST_MASK_TYPE_SOURCE), mask_type::Source); + obs_property_list_add_int(p, D_TRANSLATE(ST_MASK_TYPE_REGION), static_cast(mask_type::Region)); + obs_property_list_add_int(p, D_TRANSLATE(ST_MASK_TYPE_IMAGE), static_cast(mask_type::Image)); + obs_property_list_add_int(p, D_TRANSLATE(ST_MASK_TYPE_SOURCE), static_cast(mask_type::Source)); /// Region p = obs_properties_add_float_slider(pr, ST_MASK_REGION_LEFT, D_TRANSLATE(ST_MASK_REGION_LEFT), 0.0, 100.0, 0.01); diff --git a/source/filters/filter-blur.hpp b/source/filters/filter-blur.hpp index 2762948..126a9b4 100644 --- a/source/filters/filter-blur.hpp +++ b/source/filters/filter-blur.hpp @@ -44,7 +44,7 @@ namespace filter { namespace blur { - enum mask_type : int64_t { + enum class mask_type : int64_t { Region, Image, Source, @@ -52,7 +52,7 @@ namespace filter { class blur_instance : public obs::source_instance { // Effects - std::shared_ptr _effect_mask; + gs::effect _effect_mask; // Input std::shared_ptr _source_rt; @@ -118,7 +118,7 @@ namespace filter { virtual void video_render(gs_effect_t* effect) override; private: - bool apply_mask_parameters(std::shared_ptr effect, gs_texture_t* original_texture, + bool apply_mask_parameters(gs::effect effect, gs_texture_t* original_texture, gs_texture_t* blurred_texture); }; diff --git a/source/filters/filter-color-grade.cpp b/source/filters/filter-color-grade.cpp index f440578..e1d70d2 100644 --- a/source/filters/filter-color-grade.cpp +++ b/source/filters/filter-color-grade.cpp @@ -216,32 +216,20 @@ void filter::color_grade::color_grade_instance::video_render(gs_effect_t* effect gs_enable_stencil_write(false); gs_ortho(0, static_cast(width), 0, static_cast(height), -1., 1.); - if (_effect->has_parameter("image")) - _effect->get_parameter("image")->set_texture(_tex_source); - if (_effect->has_parameter("pLift")) - _effect->get_parameter("pLift")->set_float4(_lift); - if (_effect->has_parameter("pGamma")) - _effect->get_parameter("pGamma")->set_float4(_gamma); - if (_effect->has_parameter("pGain")) - _effect->get_parameter("pGain")->set_float4(_gain); - if (_effect->has_parameter("pOffset")) - _effect->get_parameter("pOffset")->set_float4(_offset); - if (_effect->has_parameter("pTintDetection")) - _effect->get_parameter("pTintDetection")->set_int(static_cast(_tint_detection)); - if (_effect->has_parameter("pTintMode")) - _effect->get_parameter("pTintMode")->set_int(static_cast(_tint_luma)); - if (_effect->has_parameter("pTintExponent")) - _effect->get_parameter("pTintExponent")->set_float(_tint_exponent); - if (_effect->has_parameter("pTintLow")) - _effect->get_parameter("pTintLow")->set_float3(_tint_low); - if (_effect->has_parameter("pTintMid")) - _effect->get_parameter("pTintMid")->set_float3(_tint_mid); - if (_effect->has_parameter("pTintHig")) - _effect->get_parameter("pTintHig")->set_float3(_tint_hig); - if (_effect->has_parameter("pCorrection")) - _effect->get_parameter("pCorrection")->set_float4(_correction); + _effect.get_parameter("image").set_texture(_tex_source); + _effect.get_parameter("pLift").set_float4(_lift); + _effect.get_parameter("pGamma").set_float4(_gamma); + _effect.get_parameter("pGain").set_float4(_gain); + _effect.get_parameter("pOffset").set_float4(_offset); + _effect.get_parameter("pTintDetection").set_int(static_cast(_tint_detection)); + _effect.get_parameter("pTintMode").set_int(static_cast(_tint_luma)); + _effect.get_parameter("pTintExponent").set_float(_tint_exponent); + _effect.get_parameter("pTintLow").set_float3(_tint_low); + _effect.get_parameter("pTintMid").set_float3(_tint_mid); + _effect.get_parameter("pTintHig").set_float3(_tint_hig); + _effect.get_parameter("pCorrection").set_float4(_correction); - while (gs_effect_loop(_effect->get_object(), "Draw")) { + while (gs_effect_loop(_effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, width, height); } @@ -387,8 +375,8 @@ obs_properties_t* filter::color_grade::color_grade_factory::get_properties2(colo 0.01); obs_properties_add_float_slider(grp, ST_TINT_(TONE_HIGH, GREEN), D_TRANSLATE(ST_TINT_(TONE_HIGH, GREEN)), 0, 1000.0, 0.01); - obs_properties_add_float_slider(grp, ST_TINT_(TONE_HIGH, BLUE), D_TRANSLATE(ST_TINT_(TONE_HIGH, BLUE)), 0, 1000.0, - 0.01); + obs_properties_add_float_slider(grp, ST_TINT_(TONE_HIGH, BLUE), D_TRANSLATE(ST_TINT_(TONE_HIGH, BLUE)), 0, + 1000.0, 0.01); } { diff --git a/source/filters/filter-color-grade.hpp b/source/filters/filter-color-grade.hpp index 1c7efae..3f7e94e 100644 --- a/source/filters/filter-color-grade.hpp +++ b/source/filters/filter-color-grade.hpp @@ -44,7 +44,7 @@ namespace filter { }; class color_grade_instance : public obs::source_instance { - std::shared_ptr _effect; + gs::effect _effect; // Source std::unique_ptr _rt_source; diff --git a/source/filters/filter-displacement.cpp b/source/filters/filter-displacement.cpp index b1b8c72..bf932d3 100644 --- a/source/filters/filter-displacement.cpp +++ b/source/filters/filter-displacement.cpp @@ -42,7 +42,6 @@ filter::displacement::displacement_instance::displacement_instance(obs_data_t* d filter::displacement::displacement_instance::~displacement_instance() { - _effect.reset(); _texture.reset(); } @@ -78,7 +77,7 @@ void filter::displacement::displacement_instance::update(obs_data_t* settings) std::string new_file = obs_data_get_string(settings, ST_FILE); if (new_file != _texture_file) { try { - _texture = std::make_shared(new_file); + _texture = std::make_shared(new_file); _texture_file = new_file; } catch (...) { _texture.reset(); @@ -103,15 +102,15 @@ void filter::displacement::displacement_instance::video_render(gs_effect_t*) obs_source_skip_video_filter(_self); return; } - - _effect->get_parameter("image_size")->set_float2(static_cast(_width), static_cast(_height)); - _effect->get_parameter("image_inverse_size") - ->set_float2(static_cast(1.0 / _width), static_cast(1.0 / _height)); - _effect->get_parameter("normal")->set_texture(_texture->get_object()); - _effect->get_parameter("scale")->set_float2(_scale[0], _scale[1]); - _effect->get_parameter("scale_type")->set_float(_scale_type); - obs_source_process_filter_end(_self, _effect->get_object(), _width, _height); + _effect.get_parameter("image_size").set_float2(static_cast(_width), static_cast(_height)); + _effect.get_parameter("image_inverse_size") + .set_float2(static_cast(1.0 / _width), static_cast(1.0 / _height)); + _effect.get_parameter("normal").set_texture(_texture->get_object()); + _effect.get_parameter("scale").set_float2(_scale[0], _scale[1]); + _effect.get_parameter("scale_type").set_float(_scale_type); + + obs_source_process_filter_end(_self, _effect.get_object(), _width, _height); } std::string filter::displacement::displacement_instance::get_file() diff --git a/source/filters/filter-displacement.hpp b/source/filters/filter-displacement.hpp index 8fe8e4e..afc6b1a 100644 --- a/source/filters/filter-displacement.hpp +++ b/source/filters/filter-displacement.hpp @@ -38,7 +38,7 @@ namespace filter { namespace displacement { class displacement_instance : public obs::source_instance { - std::shared_ptr _effect; + gs::effect _effect; // Displacement Map std::shared_ptr _texture; diff --git a/source/filters/filter-dynamic-mask.cpp b/source/filters/filter-dynamic-mask.cpp index 45c1c71..54ea2de 100644 --- a/source/filters/filter-dynamic-mask.cpp +++ b/source/filters/filter-dynamic-mask.cpp @@ -51,7 +51,7 @@ static std::pair channel_translation filter::dynamic_mask::dynamic_mask_instance::dynamic_mask_instance(obs_data_t* settings, obs_source_t* self) : obs::source_instance(settings, self), _have_filter_texture(false), _have_input_texture(false), - _have_final_texture(false), _precalc() + _have_final_texture(false), _precalc(), _effect() { this->_filter_rt = std::make_shared(GS_RGBA, GS_ZS_NONE); this->_final_rt = std::make_shared(GS_RGBA, GS_ZS_NONE); @@ -61,7 +61,7 @@ filter::dynamic_mask::dynamic_mask_instance::dynamic_mask_instance(obs_data_t* s try { this->_effect = gs::effect::create(file); } catch (const std::exception& ex) { - P_LOG_ERROR("Loading channel mask _effect failed with error(s):\n%s", ex.what()); + P_LOG_ERROR("Loading channel mask effect failed with error(s):\n%s", ex.what()); } assert(this->_effect != nullptr); bfree(file); @@ -287,14 +287,14 @@ void filter::dynamic_mask::dynamic_mask_instance::video_render(gs_effect_t* in_e gs_stencil_op(GS_STENCIL_BOTH, GS_KEEP, GS_KEEP, GS_KEEP); gs_ortho(0, (float)width, 0, (float)height, -1., 1.); - this->_effect->get_parameter("pMaskInputA")->set_texture(this->_filter_texture); - this->_effect->get_parameter("pMaskInputB")->set_texture(this->_input_texture); + _effect.get_parameter("pMaskInputA").set_texture(this->_filter_texture); + _effect.get_parameter("pMaskInputB").set_texture(this->_input_texture); - this->_effect->get_parameter("pMaskBase")->set_float4(this->_precalc.base); - this->_effect->get_parameter("pMaskMatrix")->set_matrix(this->_precalc.matrix); - this->_effect->get_parameter("pMaskMultiplier")->set_float4(this->_precalc.scale); + _effect.get_parameter("pMaskBase").set_float4(this->_precalc.base); + _effect.get_parameter("pMaskMatrix").set_matrix(this->_precalc.matrix); + _effect.get_parameter("pMaskMultiplier").set_float4(this->_precalc.scale); - while (gs_effect_loop(this->_effect->get_object(), "Mask")) { + while (gs_effect_loop(_effect.get(), "Mask")) { gs_draw_sprite(0, 0, width, height); } diff --git a/source/filters/filter-dynamic-mask.hpp b/source/filters/filter-dynamic-mask.hpp index 37b9849..81a9d13 100644 --- a/source/filters/filter-dynamic-mask.hpp +++ b/source/filters/filter-dynamic-mask.hpp @@ -47,7 +47,7 @@ namespace filter { class dynamic_mask_instance : public obs::source_instance { std::map, std::string> _translation_map; - std::shared_ptr _effect; + gs::effect _effect; bool _have_filter_texture; std::shared_ptr _filter_rt; diff --git a/source/filters/filter-sdf-effects.cpp b/source/filters/filter-sdf-effects.cpp index 087cb50..e16acfd 100644 --- a/source/filters/filter-sdf-effects.cpp +++ b/source/filters/filter-sdf-effects.cpp @@ -94,9 +94,9 @@ filter::sdf_effects::sdf_effects_instance::sdf_effects_instance(obs_data_t* sett gs_clear(GS_CLEAR_COLOR | GS_CLEAR_DEPTH, &transparent, 0, 0); } - std::pair&> load_arr[] = { - {"effects/sdf/sdf-producer.effect", this->_sdf_producer_effect}, - {"effects/sdf/sdf-consumer.effect", this->_sdf_consumer_effect}, + std::pair load_arr[] = { + {"effects/sdf/sdf-producer.effect", _sdf_producer_effect}, + {"effects/sdf/sdf-consumer.effect", _sdf_consumer_effect}, }; for (auto& kv : load_arr) { char* path = obs_module_file(kv.first); @@ -339,8 +339,7 @@ void filter::sdf_effects::sdf_effects_instance::video_render(gs_effect_t* effect throw std::runtime_error("SDF Backbuffer empty"); } - std::shared_ptr sdf_effect = _sdf_producer_effect; - if (!sdf_effect) { + if (!_sdf_producer_effect) { throw std::runtime_error("SDF Effect no loaded"); } @@ -360,12 +359,12 @@ void filter::sdf_effects::sdf_effects_instance::video_render(gs_effect_t* effect gs_ortho(0, (float)sdfW, 0, (float)sdfH, -1, 1); gs_clear(GS_CLEAR_COLOR | GS_CLEAR_DEPTH, &color_transparent, 0, 0); - sdf_effect->get_parameter("_image")->set_texture(this->_source_texture); - sdf_effect->get_parameter("_size")->set_float2(float_t(sdfW), float_t(sdfH)); - sdf_effect->get_parameter("_sdf")->set_texture(this->_sdf_texture); - sdf_effect->get_parameter("_threshold")->set_float(this->_sdf_threshold); + _sdf_producer_effect.get_parameter("_image").set_texture(this->_source_texture); + _sdf_producer_effect.get_parameter("_size").set_float2(float_t(sdfW), float_t(sdfH)); + _sdf_producer_effect.get_parameter("_sdf").set_texture(this->_sdf_texture); + _sdf_producer_effect.get_parameter("_threshold").set_float(this->_sdf_threshold); - while (gs_effect_loop(sdf_effect->get_object(), "Draw")) { + while (gs_effect_loop(_sdf_producer_effect.get_object(), "Draw")) { gs_draw_sprite(this->_sdf_texture->get_object(), 0, uint32_t(sdfW), uint32_t(sdfH)); } } @@ -389,8 +388,7 @@ void filter::sdf_effects::sdf_effects_instance::video_render(gs_effect_t* effect if (!this->_output_rendered) { this->_output_texture = this->_source_texture; - std::shared_ptr consumer_effect = _sdf_consumer_effect; - if (!consumer_effect) { + if (!_sdf_consumer_effect) { obs_source_skip_video_filter(this->_self); return; } @@ -427,67 +425,67 @@ void filter::sdf_effects::sdf_effects_instance::video_render(gs_effect_t* effect gs_enable_blending(true); gs_blend_function_separate(GS_BLEND_SRCALPHA, GS_BLEND_INVSRCALPHA, GS_BLEND_ONE, GS_BLEND_ONE); if (this->_outer_shadow) { - consumer_effect->get_parameter("pSDFTexture")->set_texture(this->_sdf_texture); - consumer_effect->get_parameter("pSDFThreshold")->set_float(this->_sdf_threshold); - consumer_effect->get_parameter("pImageTexture")->set_texture(this->_source_texture->get_object()); - consumer_effect->get_parameter("pShadowColor")->set_float4(this->_outer_shadow_color); - consumer_effect->get_parameter("pShadowMin")->set_float(this->_outer_shadow_range_min); - consumer_effect->get_parameter("pShadowMax")->set_float(this->_outer_shadow_range_max); - consumer_effect->get_parameter("pShadowOffset") - ->set_float2(this->_outer_shadow_offset_x / float_t(baseW), - this->_outer_shadow_offset_y / float_t(baseH)); - while (gs_effect_loop(consumer_effect->get_object(), "ShadowOuter")) { + _sdf_consumer_effect.get_parameter("pSDFTexture").set_texture(this->_sdf_texture); + _sdf_consumer_effect.get_parameter("pSDFThreshold").set_float(this->_sdf_threshold); + _sdf_consumer_effect.get_parameter("pImageTexture").set_texture(this->_source_texture->get_object()); + _sdf_consumer_effect.get_parameter("pShadowColor").set_float4(this->_outer_shadow_color); + _sdf_consumer_effect.get_parameter("pShadowMin").set_float(this->_outer_shadow_range_min); + _sdf_consumer_effect.get_parameter("pShadowMax").set_float(this->_outer_shadow_range_max); + _sdf_consumer_effect.get_parameter("pShadowOffset") + .set_float2(this->_outer_shadow_offset_x / float_t(baseW), + this->_outer_shadow_offset_y / float_t(baseH)); + while (gs_effect_loop(_sdf_consumer_effect.get_object(), "ShadowOuter")) { gs_draw_sprite(0, 0, 1, 1); } } if (this->_inner_shadow) { - consumer_effect->get_parameter("pSDFTexture")->set_texture(this->_sdf_texture); - consumer_effect->get_parameter("pSDFThreshold")->set_float(this->_sdf_threshold); - consumer_effect->get_parameter("pImageTexture")->set_texture(this->_source_texture->get_object()); - consumer_effect->get_parameter("pShadowColor")->set_float4(this->_inner_shadow_color); - consumer_effect->get_parameter("pShadowMin")->set_float(this->_inner_shadow_range_min); - consumer_effect->get_parameter("pShadowMax")->set_float(this->_inner_shadow_range_max); - consumer_effect->get_parameter("pShadowOffset") - ->set_float2(this->_inner_shadow_offset_x / float_t(baseW), - this->_inner_shadow_offset_y / float_t(baseH)); - while (gs_effect_loop(consumer_effect->get_object(), "ShadowInner")) { + _sdf_consumer_effect.get_parameter("pSDFTexture").set_texture(this->_sdf_texture); + _sdf_consumer_effect.get_parameter("pSDFThreshold").set_float(this->_sdf_threshold); + _sdf_consumer_effect.get_parameter("pImageTexture").set_texture(this->_source_texture->get_object()); + _sdf_consumer_effect.get_parameter("pShadowColor").set_float4(this->_inner_shadow_color); + _sdf_consumer_effect.get_parameter("pShadowMin").set_float(this->_inner_shadow_range_min); + _sdf_consumer_effect.get_parameter("pShadowMax").set_float(this->_inner_shadow_range_max); + _sdf_consumer_effect.get_parameter("pShadowOffset") + .set_float2(this->_inner_shadow_offset_x / float_t(baseW), + this->_inner_shadow_offset_y / float_t(baseH)); + while (gs_effect_loop(_sdf_consumer_effect.get_object(), "ShadowInner")) { gs_draw_sprite(0, 0, 1, 1); } } if (this->_outer_glow) { - consumer_effect->get_parameter("pSDFTexture")->set_texture(this->_sdf_texture); - consumer_effect->get_parameter("pSDFThreshold")->set_float(this->_sdf_threshold); - consumer_effect->get_parameter("pImageTexture")->set_texture(this->_source_texture->get_object()); - consumer_effect->get_parameter("pGlowColor")->set_float4(this->_outer_glow_color); - consumer_effect->get_parameter("pGlowWidth")->set_float(this->_outer_glow_width); - consumer_effect->get_parameter("pGlowSharpness")->set_float(this->_outer_glow_sharpness); - consumer_effect->get_parameter("pGlowSharpnessInverse")->set_float(this->_outer_glow_sharpness_inv); - while (gs_effect_loop(consumer_effect->get_object(), "GlowOuter")) { + _sdf_consumer_effect.get_parameter("pSDFTexture").set_texture(this->_sdf_texture); + _sdf_consumer_effect.get_parameter("pSDFThreshold").set_float(this->_sdf_threshold); + _sdf_consumer_effect.get_parameter("pImageTexture").set_texture(this->_source_texture->get_object()); + _sdf_consumer_effect.get_parameter("pGlowColor").set_float4(this->_outer_glow_color); + _sdf_consumer_effect.get_parameter("pGlowWidth").set_float(this->_outer_glow_width); + _sdf_consumer_effect.get_parameter("pGlowSharpness").set_float(this->_outer_glow_sharpness); + _sdf_consumer_effect.get_parameter("pGlowSharpnessInverse").set_float(this->_outer_glow_sharpness_inv); + while (gs_effect_loop(_sdf_consumer_effect.get_object(), "GlowOuter")) { gs_draw_sprite(0, 0, 1, 1); } } if (this->_inner_glow) { - consumer_effect->get_parameter("pSDFTexture")->set_texture(this->_sdf_texture); - consumer_effect->get_parameter("pSDFThreshold")->set_float(this->_sdf_threshold); - consumer_effect->get_parameter("pImageTexture")->set_texture(this->_source_texture->get_object()); - consumer_effect->get_parameter("pGlowColor")->set_float4(this->_inner_glow_color); - consumer_effect->get_parameter("pGlowWidth")->set_float(this->_inner_glow_width); - consumer_effect->get_parameter("pGlowSharpness")->set_float(this->_inner_glow_sharpness); - consumer_effect->get_parameter("pGlowSharpnessInverse")->set_float(this->_inner_glow_sharpness_inv); - while (gs_effect_loop(consumer_effect->get_object(), "GlowInner")) { + _sdf_consumer_effect.get_parameter("pSDFTexture").set_texture(this->_sdf_texture); + _sdf_consumer_effect.get_parameter("pSDFThreshold").set_float(this->_sdf_threshold); + _sdf_consumer_effect.get_parameter("pImageTexture").set_texture(this->_source_texture->get_object()); + _sdf_consumer_effect.get_parameter("pGlowColor").set_float4(this->_inner_glow_color); + _sdf_consumer_effect.get_parameter("pGlowWidth").set_float(this->_inner_glow_width); + _sdf_consumer_effect.get_parameter("pGlowSharpness").set_float(this->_inner_glow_sharpness); + _sdf_consumer_effect.get_parameter("pGlowSharpnessInverse").set_float(this->_inner_glow_sharpness_inv); + while (gs_effect_loop(_sdf_consumer_effect.get_object(), "GlowInner")) { gs_draw_sprite(0, 0, 1, 1); } } if (this->_outline) { - consumer_effect->get_parameter("pSDFTexture")->set_texture(this->_sdf_texture); - consumer_effect->get_parameter("pSDFThreshold")->set_float(this->_sdf_threshold); - consumer_effect->get_parameter("pImageTexture")->set_texture(this->_source_texture->get_object()); - consumer_effect->get_parameter("pOutlineColor")->set_float4(this->_outline_color); - consumer_effect->get_parameter("pOutlineWidth")->set_float(this->_outline_width); - consumer_effect->get_parameter("pOutlineOffset")->set_float(this->_outline_offset); - consumer_effect->get_parameter("pOutlineSharpness")->set_float(this->_outline_sharpness); - consumer_effect->get_parameter("pOutlineSharpnessInverse")->set_float(this->_outline_sharpness_inv); - while (gs_effect_loop(consumer_effect->get_object(), "Outline")) { + _sdf_consumer_effect.get_parameter("pSDFTexture").set_texture(this->_sdf_texture); + _sdf_consumer_effect.get_parameter("pSDFThreshold").set_float(this->_sdf_threshold); + _sdf_consumer_effect.get_parameter("pImageTexture").set_texture(this->_source_texture->get_object()); + _sdf_consumer_effect.get_parameter("pOutlineColor").set_float4(this->_outline_color); + _sdf_consumer_effect.get_parameter("pOutlineWidth").set_float(this->_outline_width); + _sdf_consumer_effect.get_parameter("pOutlineOffset").set_float(this->_outline_offset); + _sdf_consumer_effect.get_parameter("pOutlineSharpness").set_float(this->_outline_sharpness); + _sdf_consumer_effect.get_parameter("pOutlineSharpnessInverse").set_float(this->_outline_sharpness_inv); + while (gs_effect_loop(_sdf_consumer_effect.get_object(), "Outline")) { gs_draw_sprite(0, 0, 1, 1); } } diff --git a/source/filters/filter-sdf-effects.hpp b/source/filters/filter-sdf-effects.hpp index 295a464..0075488 100644 --- a/source/filters/filter-sdf-effects.hpp +++ b/source/filters/filter-sdf-effects.hpp @@ -40,8 +40,8 @@ namespace filter { namespace sdf_effects { class sdf_effects_instance : public obs::source_instance { - std::shared_ptr _sdf_producer_effect; - std::shared_ptr _sdf_consumer_effect; + gs::effect _sdf_producer_effect; + gs::effect _sdf_consumer_effect; // Input std::shared_ptr _source_rt; diff --git a/source/filters/filter-shader.hpp b/source/filters/filter-shader.hpp index 49908ae..0321d0d 100644 --- a/source/filters/filter-shader.hpp +++ b/source/filters/filter-shader.hpp @@ -19,7 +19,7 @@ #pragma once -#include "gfx/gfx-effect-source.hpp" +#include "gfx/shader/gfx-shader.hpp" #include "obs/gs/gs-rendertarget.hpp" #include "plugin.hpp" diff --git a/source/gfx/blur/gfx-blur-box-linear.cpp b/source/gfx/blur/gfx-blur-box-linear.cpp index 7b4b35a..cc1c3ce 100644 --- a/source/gfx/blur/gfx-blur-box-linear.cpp +++ b/source/gfx/blur/gfx-blur-box-linear.cpp @@ -40,7 +40,7 @@ gfx::blur::box_linear_data::box_linear_data() auto gctx = gs::context(); try { char* file = obs_module_file("effects/blur/box-linear.effect"); - _effect = std::make_shared<::gs::effect>(file); + _effect = gs::effect::create(file); bfree(file); } catch (...) { P_LOG_ERROR(" Failed to load _effect."); @@ -53,7 +53,7 @@ gfx::blur::box_linear_data::~box_linear_data() _effect.reset(); } -std::shared_ptr<::gs::effect> gfx::blur::box_linear_data::get_effect() +gs::effect gfx::blur::box_linear_data::get_effect() { return _effect; } @@ -263,31 +263,31 @@ std::shared_ptr<::gs::texture> gfx::blur::box_linear::render() gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); // Two Pass Blur - std::shared_ptr<::gs::effect> effect = _data->get_effect(); + gs::effect effect = _data->get_effect(); if (effect) { // Pass 1 - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pImageTexel")->set_float2(float_t(1.f / width), 0.f); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pSizeInverseMul")->set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pImageTexel").set_float2(float_t(1.f / width), 0.f); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pSizeInverseMul").set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); { auto op = _rendertarget2->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } // Pass 2 - effect->get_parameter("pImage")->set_texture(_rendertarget2->get_texture()); - effect->get_parameter("pImageTexel")->set_float2(0., float_t(1.f / height)); + effect.get_parameter("pImage").set_texture(_rendertarget2->get_texture()); + effect.get_parameter("pImageTexel").set_float2(0., float_t(1.f / height)); { auto op = _rendertarget->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } @@ -340,19 +340,19 @@ std::shared_ptr<::gs::texture> gfx::blur::box_linear_directional::render() gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); // One Pass Blur - std::shared_ptr<::gs::effect> effect = _data->get_effect(); + gs::effect effect = _data->get_effect(); if (effect) { - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pImageTexel") - ->set_float2(float_t(1. / width * cos(_angle)), float_t(1.f / height * sin(_angle))); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pSizeInverseMul")->set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pImageTexel") + .set_float2(float_t(1. / width * cos(_angle)), float_t(1.f / height * sin(_angle))); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pSizeInverseMul").set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); { auto op = _rendertarget->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } diff --git a/source/gfx/blur/gfx-blur-box-linear.hpp b/source/gfx/blur/gfx-blur-box-linear.hpp index 4d95aad..a789fa2 100644 --- a/source/gfx/blur/gfx-blur-box-linear.hpp +++ b/source/gfx/blur/gfx-blur-box-linear.hpp @@ -27,13 +27,13 @@ namespace gfx { namespace blur { class box_linear_data { - std::shared_ptr<::gs::effect> _effect; + gs::effect _effect; public: box_linear_data(); virtual ~box_linear_data(); - std::shared_ptr<::gs::effect> get_effect(); + gs::effect get_effect(); }; class box_linear_factory : public ::gfx::blur::ifactory { diff --git a/source/gfx/blur/gfx-blur-box.cpp b/source/gfx/blur/gfx-blur-box.cpp index e055c15..2d8b8d7 100644 --- a/source/gfx/blur/gfx-blur-box.cpp +++ b/source/gfx/blur/gfx-blur-box.cpp @@ -40,7 +40,7 @@ gfx::blur::box_data::box_data() auto gctx = gs::context(); try { char* file = obs_module_file("effects/blur/box.effect"); - _effect = std::make_shared<::gs::effect>(file); + _effect = gs::effect::create(file); bfree(file); } catch (...) { P_LOG_ERROR(" Failed to load _effect."); @@ -53,7 +53,7 @@ gfx::blur::box_data::~box_data() _effect.reset(); } -std::shared_ptr<::gs::effect> gfx::blur::box_data::get_effect() +gs::effect gfx::blur::box_data::get_effect() { return _effect; } @@ -271,31 +271,31 @@ std::shared_ptr<::gs::texture> gfx::blur::box::render() gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); // Two Pass Blur - std::shared_ptr<::gs::effect> effect = _data->get_effect(); + gs::effect effect = _data->get_effect(); if (effect) { // Pass 1 - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pImageTexel")->set_float2(float_t(1.f / width), 0.f); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pSizeInverseMul")->set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pImageTexel").set_float2(float_t(1.f / width), 0.f); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pSizeInverseMul").set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); { auto op = _rendertarget2->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } // Pass 2 - effect->get_parameter("pImage")->set_texture(_rendertarget2->get_texture()); - effect->get_parameter("pImageTexel")->set_float2(0.f, float_t(1.f / height)); + effect.get_parameter("pImage").set_texture(_rendertarget2->get_texture()); + effect.get_parameter("pImageTexel").set_float2(0.f, float_t(1.f / height)); { auto op = _rendertarget->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } @@ -348,19 +348,19 @@ std::shared_ptr<::gs::texture> gfx::blur::box_directional::render() gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); // One Pass Blur - std::shared_ptr<::gs::effect> effect = _data->get_effect(); + gs::effect effect = _data->get_effect(); if (effect) { - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pImageTexel") - ->set_float2(float_t(1. / width * cos(_angle)), float_t(1.f / height * sin(_angle))); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pSizeInverseMul")->set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pImageTexel") + .set_float2(float_t(1. / width * cos(_angle)), float_t(1.f / height * sin(_angle))); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pSizeInverseMul").set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); { auto op = _rendertarget->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } @@ -418,20 +418,20 @@ std::shared_ptr<::gs::texture> gfx::blur::box_rotational::render() gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); // One Pass Blur - std::shared_ptr<::gs::effect> effect = _data->get_effect(); + gs::effect effect = _data->get_effect(); if (effect) { - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pImageTexel")->set_float2(float_t(1.f / width), float_t(1.f / height)); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pSizeInverseMul")->set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); - effect->get_parameter("pAngle")->set_float(float_t(_angle / _size)); - effect->get_parameter("pCenter")->set_float2(float_t(_center.first), float_t(_center.second)); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pImageTexel").set_float2(float_t(1.f / width), float_t(1.f / height)); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pSizeInverseMul").set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); + effect.get_parameter("pAngle").set_float(float_t(_angle / _size)); + effect.get_parameter("pCenter").set_float2(float_t(_center.first), float_t(_center.second)); { auto op = _rendertarget->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Rotate")) { + while (gs_effect_loop(effect.get_object(), "Rotate")) { gs_draw_sprite(nullptr, 0, 1, 1); } } @@ -479,19 +479,19 @@ std::shared_ptr<::gs::texture> gfx::blur::box_zoom::render() gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); // One Pass Blur - std::shared_ptr<::gs::effect> effect = _data->get_effect(); + gs::effect effect = _data->get_effect(); if (effect) { - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pImageTexel")->set_float2(float_t(1.f / width), float_t(1.f / height)); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pSizeInverseMul")->set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); - effect->get_parameter("pCenter")->set_float2(float_t(_center.first), float_t(_center.second)); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pImageTexel").set_float2(float_t(1.f / width), float_t(1.f / height)); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pSizeInverseMul").set_float(float_t(1.0f / (float_t(_size) * 2.0f + 1.0f))); + effect.get_parameter("pCenter").set_float2(float_t(_center.first), float_t(_center.second)); { auto op = _rendertarget->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Zoom")) { + while (gs_effect_loop(effect.get_object(), "Zoom")) { gs_draw_sprite(nullptr, 0, 1, 1); } } diff --git a/source/gfx/blur/gfx-blur-box.hpp b/source/gfx/blur/gfx-blur-box.hpp index 3e2577a..ad21ba2 100644 --- a/source/gfx/blur/gfx-blur-box.hpp +++ b/source/gfx/blur/gfx-blur-box.hpp @@ -27,13 +27,13 @@ namespace gfx { namespace blur { class box_data { - std::shared_ptr<::gs::effect> _effect; + gs::effect _effect; public: box_data(); virtual ~box_data(); - std::shared_ptr<::gs::effect> get_effect(); + gs::effect get_effect(); }; class box_factory : public ::gfx::blur::ifactory { diff --git a/source/gfx/blur/gfx-blur-dual-filtering.cpp b/source/gfx/blur/gfx-blur-dual-filtering.cpp index 28e71e7..8a7ad9f 100644 --- a/source/gfx/blur/gfx-blur-dual-filtering.cpp +++ b/source/gfx/blur/gfx-blur-dual-filtering.cpp @@ -56,7 +56,7 @@ gfx::blur::dual_filtering_data::dual_filtering_data() auto gctx = gs::context(); try { char* file = obs_module_file("effects/blur/dual-filtering.effect"); - _effect = std::make_shared<::gs::effect>(file); + _effect = gs::effect::create(file); bfree(file); } catch (...) { P_LOG_ERROR(" Failed to load _effect."); @@ -69,7 +69,7 @@ gfx::blur::dual_filtering_data::~dual_filtering_data() _effect.reset(); } -std::shared_ptr<::gs::effect> gfx::blur::dual_filtering_data::get_effect() +gs::effect gfx::blur::dual_filtering_data::get_effect() { return _effect; } @@ -264,15 +264,15 @@ std::shared_ptr<::gs::texture> gfx::blur::dual_filtering::render() } // Apply - effect->get_parameter("pImage")->set_texture(tex_cur); - effect->get_parameter("pImageSize")->set_float2(float_t(width), float_t(height)); - effect->get_parameter("pImageTexel")->set_float2(1.0f / width, 1.0f / height); - effect->get_parameter("pImageHalfTexel")->set_float2(0.5f / width, 0.5f / height); + effect.get_parameter("pImage").set_texture(tex_cur); + effect.get_parameter("pImageSize").set_float2(float_t(width), float_t(height)); + effect.get_parameter("pImageTexel").set_float2(1.0f / width, 1.0f / height); + effect.get_parameter("pImageHalfTexel").set_float2(0.5f / width, 0.5f / height); { auto op = _rendertargets[n]->render(width, height); gs_ortho(0., 1., 0., 1., 0., 1.); - while (gs_effect_loop(effect->get_object(), "Down")) { + while (gs_effect_loop(effect.get_object(), "Down")) { gs_draw_sprite(tex_cur->get_object(), 0, 1, 1); } } @@ -288,10 +288,10 @@ std::shared_ptr<::gs::texture> gfx::blur::dual_filtering::render() uint32_t height = tex_cur->get_height(); // Apply - effect->get_parameter("pImage")->set_texture(tex_cur); - effect->get_parameter("pImageSize")->set_float2(float_t(width), float_t(height)); - effect->get_parameter("pImageTexel")->set_float2(1.0f / width, 1.0f / height); - effect->get_parameter("pImageHalfTexel")->set_float2(0.5f / width, 0.5f / height); + effect.get_parameter("pImage").set_texture(tex_cur); + effect.get_parameter("pImageSize").set_float2(float_t(width), float_t(height)); + effect.get_parameter("pImageTexel").set_float2(1.0f / width, 1.0f / height); + effect.get_parameter("pImageHalfTexel").set_float2(0.5f / width, 0.5f / height); // Increase Size width *= 2; @@ -300,7 +300,7 @@ std::shared_ptr<::gs::texture> gfx::blur::dual_filtering::render() { auto op = _rendertargets[n - 1]->render(width, height); gs_ortho(0., 1., 0., 1., 0., 1.); - while (gs_effect_loop(effect->get_object(), "Up")) { + while (gs_effect_loop(effect.get_object(), "Up")) { gs_draw_sprite(tex_cur->get_object(), 0, 1, 1); } } diff --git a/source/gfx/blur/gfx-blur-dual-filtering.hpp b/source/gfx/blur/gfx-blur-dual-filtering.hpp index a00102b..d23182f 100644 --- a/source/gfx/blur/gfx-blur-dual-filtering.hpp +++ b/source/gfx/blur/gfx-blur-dual-filtering.hpp @@ -28,13 +28,13 @@ namespace gfx { namespace blur { class dual_filtering_data { - std::shared_ptr<::gs::effect> _effect; + gs::effect _effect; public: dual_filtering_data(); virtual ~dual_filtering_data(); - std::shared_ptr<::gs::effect> get_effect(); + gs::effect get_effect(); }; class dual_filtering_factory : public ::gfx::blur::ifactory { diff --git a/source/gfx/blur/gfx-blur-gaussian-linear.cpp b/source/gfx/blur/gfx-blur-gaussian-linear.cpp index db9c7cf..5bf507b 100644 --- a/source/gfx/blur/gfx-blur-gaussian-linear.cpp +++ b/source/gfx/blur/gfx-blur-gaussian-linear.cpp @@ -87,7 +87,7 @@ gfx::blur::gaussian_linear_data::~gaussian_linear_data() _effect.reset(); } -std::shared_ptr<::gs::effect> gfx::blur::gaussian_linear_data::get_effect() +gs::effect gfx::blur::gaussian_linear_data::get_effect() { return _effect; } @@ -293,8 +293,8 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian_linear::render() { auto gctx = gs::context(); - std::shared_ptr<::gs::effect> effect = _data->get_effect(); - auto kernel = _data->get_kernel(size_t(_size)); + gs::effect effect = _data->get_effect(); + auto kernel = _data->get_kernel(size_t(_size)); if (!effect || ((_step_scale.first + _step_scale.second) < std::numeric_limits::epsilon())) { return _input_texture; @@ -317,35 +317,35 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian_linear::render() gs_stencil_function(GS_STENCIL_BOTH, GS_ALWAYS); gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pKernel")->set_float_array(kernel.data(), MAX_KERNEL_SIZE); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pKernel").set_float_array(kernel.data(), MAX_KERNEL_SIZE); // First Pass if (_step_scale.first > std::numeric_limits::epsilon()) { - effect->get_parameter("pImageTexel")->set_float2(float_t(1.f / width), 0.f); + effect.get_parameter("pImageTexel").set_float2(float_t(1.f / width), 0.f); { auto op = _rendertarget2->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } std::swap(_rendertarget, _rendertarget2); - effect->get_parameter("pImage")->set_texture(_rendertarget->get_texture()); + effect.get_parameter("pImage").set_texture(_rendertarget->get_texture()); } // Second Pass if (_step_scale.second > std::numeric_limits::epsilon()) { - effect->get_parameter("pImageTexel")->set_float2(0.f, float_t(1.f / height)); + effect.get_parameter("pImageTexel").set_float2(0.f, float_t(1.f / height)); { auto op = _rendertarget2->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } @@ -386,8 +386,8 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian_linear_directional::render() { auto gctx = gs::context(); - std::shared_ptr<::gs::effect> effect = _data->get_effect(); - auto kernel = _data->get_kernel(size_t(_size)); + gs::effect effect = _data->get_effect(); + auto kernel = _data->get_kernel(size_t(_size)); if (!effect || ((_step_scale.first + _step_scale.second) < std::numeric_limits::epsilon())) { return _input_texture; @@ -410,18 +410,18 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian_linear_directional::render() gs_stencil_function(GS_STENCIL_BOTH, GS_ALWAYS); gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pImageTexel") - ->set_float2(float_t(1.f / width * cos(_angle)), float_t(1.f / height * sin(_angle))); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pKernel")->set_float_array(kernel.data(), MAX_KERNEL_SIZE); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pImageTexel") + .set_float2(float_t(1.f / width * cos(_angle)), float_t(1.f / height * sin(_angle))); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pKernel").set_float_array(kernel.data(), MAX_KERNEL_SIZE); // First Pass { auto op = _rendertarget->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } diff --git a/source/gfx/blur/gfx-blur-gaussian-linear.hpp b/source/gfx/blur/gfx-blur-gaussian-linear.hpp index 0ddee30..6732902 100644 --- a/source/gfx/blur/gfx-blur-gaussian-linear.hpp +++ b/source/gfx/blur/gfx-blur-gaussian-linear.hpp @@ -26,14 +26,14 @@ namespace gfx { namespace blur { class gaussian_linear_data { - std::shared_ptr<::gs::effect> _effect; + gs::effect _effect; std::vector> _kernels; public: gaussian_linear_data(); virtual ~gaussian_linear_data(); - std::shared_ptr<::gs::effect> get_effect(); + gs::effect get_effect(); std::vector const& get_kernel(size_t width); }; diff --git a/source/gfx/blur/gfx-blur-gaussian.cpp b/source/gfx/blur/gfx-blur-gaussian.cpp index b0cc7a7..9408745 100644 --- a/source/gfx/blur/gfx-blur-gaussian.cpp +++ b/source/gfx/blur/gfx-blur-gaussian.cpp @@ -88,7 +88,7 @@ gfx::blur::gaussian_data::~gaussian_data() _effect.reset(); } -std::shared_ptr<::gs::effect> gfx::blur::gaussian_data::get_effect() +gs::effect gfx::blur::gaussian_data::get_effect() { return _effect; } @@ -299,8 +299,8 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian::render() { auto gctx = gs::context(); - std::shared_ptr<::gs::effect> effect = _data->get_effect(); - auto kernel = _data->get_kernel(size_t(_size)); + gs::effect effect = _data->get_effect(); + auto kernel = _data->get_kernel(size_t(_size)); if (!effect || ((_step_scale.first + _step_scale.second) < std::numeric_limits::epsilon())) { return _input_texture; @@ -323,35 +323,35 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian::render() gs_stencil_function(GS_STENCIL_BOTH, GS_ALWAYS); gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pKernel")->set_float_array(kernel.data(), MAX_KERNEL_SIZE); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pKernel").set_float_array(kernel.data(), MAX_KERNEL_SIZE); // First Pass if (_step_scale.first > std::numeric_limits::epsilon()) { - effect->get_parameter("pImageTexel")->set_float2(float_t(1.f / width), 0.f); + effect.get_parameter("pImageTexel").set_float2(float_t(1.f / width), 0.f); { auto op = _rendertarget2->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } std::swap(_rendertarget, _rendertarget2); - effect->get_parameter("pImage")->set_texture(_rendertarget->get_texture()); + effect.get_parameter("pImage").set_texture(_rendertarget->get_texture()); } // Second Pass if (_step_scale.second > std::numeric_limits::epsilon()) { - effect->get_parameter("pImageTexel")->set_float2(0.f, float_t(1.f / height)); + effect.get_parameter("pImageTexel").set_float2(0.f, float_t(1.f / height)); { auto op = _rendertarget2->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } @@ -392,8 +392,8 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian_directional::render() { auto gctx = gs::context(); - std::shared_ptr<::gs::effect> effect = _data->get_effect(); - auto kernel = _data->get_kernel(size_t(_size)); + gs::effect effect = _data->get_effect(); + auto kernel = _data->get_kernel(size_t(_size)); if (!effect || ((_step_scale.first + _step_scale.second) < std::numeric_limits::epsilon())) { return _input_texture; @@ -417,18 +417,18 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian_directional::render() gs_stencil_function(GS_STENCIL_BOTH, GS_ALWAYS); gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pImageTexel") - ->set_float2(float_t(1.f / width * cos(m_angle)), float_t(1.f / height * sin(m_angle))); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pKernel")->set_float_array(kernel.data(), MAX_KERNEL_SIZE); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pImageTexel") + .set_float2(float_t(1.f / width * cos(m_angle)), float_t(1.f / height * sin(m_angle))); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pKernel").set_float_array(kernel.data(), MAX_KERNEL_SIZE); // First Pass { auto op = _rendertarget->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Draw")) { + while (gs_effect_loop(effect.get_object(), "Draw")) { gs_draw_sprite(nullptr, 0, 1, 1); } } @@ -447,8 +447,8 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian_rotational::render() { auto gctx = gs::context(); - std::shared_ptr<::gs::effect> effect = _data->get_effect(); - auto kernel = _data->get_kernel(size_t(_size)); + gs::effect effect = _data->get_effect(); + auto kernel = _data->get_kernel(size_t(_size)); if (!effect || ((_step_scale.first + _step_scale.second) < std::numeric_limits::epsilon())) { return _input_texture; @@ -471,19 +471,19 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian_rotational::render() gs_stencil_function(GS_STENCIL_BOTH, GS_ALWAYS); gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pImageTexel")->set_float2(float_t(1.f / width), float_t(1.f / height)); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pAngle")->set_float(float_t(m_angle / _size)); - effect->get_parameter("pCenter")->set_float2(float_t(m_center.first), float_t(m_center.second)); - effect->get_parameter("pKernel")->set_float_array(kernel.data(), MAX_KERNEL_SIZE); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pImageTexel").set_float2(float_t(1.f / width), float_t(1.f / height)); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pAngle").set_float(float_t(m_angle / _size)); + effect.get_parameter("pCenter").set_float2(float_t(m_center.first), float_t(m_center.second)); + effect.get_parameter("pKernel").set_float_array(kernel.data(), MAX_KERNEL_SIZE); // First Pass { auto op = _rendertarget->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Rotate")) { + while (gs_effect_loop(effect.get_object(), "Rotate")) { gs_draw_sprite(nullptr, 0, 1, 1); } } @@ -524,8 +524,8 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian_zoom::render() { auto gctx = gs::context(); - std::shared_ptr<::gs::effect> effect = _data->get_effect(); - auto kernel = _data->get_kernel(size_t(_size)); + gs::effect effect = _data->get_effect(); + auto kernel = _data->get_kernel(size_t(_size)); if (!effect || ((_step_scale.first + _step_scale.second) < std::numeric_limits::epsilon())) { return _input_texture; @@ -548,18 +548,18 @@ std::shared_ptr<::gs::texture> gfx::blur::gaussian_zoom::render() gs_stencil_function(GS_STENCIL_BOTH, GS_ALWAYS); gs_stencil_op(GS_STENCIL_BOTH, GS_ZERO, GS_ZERO, GS_ZERO); - effect->get_parameter("pImage")->set_texture(_input_texture); - effect->get_parameter("pImageTexel")->set_float2(float_t(1.f / width), float_t(1.f / height)); - effect->get_parameter("pStepScale")->set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); - effect->get_parameter("pSize")->set_float(float_t(_size)); - effect->get_parameter("pCenter")->set_float2(float_t(m_center.first), float_t(m_center.second)); - effect->get_parameter("pKernel")->set_float_array(kernel.data(), MAX_KERNEL_SIZE); + effect.get_parameter("pImage").set_texture(_input_texture); + effect.get_parameter("pImageTexel").set_float2(float_t(1.f / width), float_t(1.f / height)); + effect.get_parameter("pStepScale").set_float2(float_t(_step_scale.first), float_t(_step_scale.second)); + effect.get_parameter("pSize").set_float(float_t(_size)); + effect.get_parameter("pCenter").set_float2(float_t(m_center.first), float_t(m_center.second)); + effect.get_parameter("pKernel").set_float_array(kernel.data(), MAX_KERNEL_SIZE); // First Pass { auto op = _rendertarget->render(uint32_t(width), uint32_t(height)); gs_ortho(0, 1., 0, 1., 0, 1.); - while (gs_effect_loop(effect->get_object(), "Zoom")) { + while (gs_effect_loop(effect.get_object(), "Zoom")) { gs_draw_sprite(nullptr, 0, 1, 1); } } diff --git a/source/gfx/blur/gfx-blur-gaussian.hpp b/source/gfx/blur/gfx-blur-gaussian.hpp index 9221324..2f3bfab 100644 --- a/source/gfx/blur/gfx-blur-gaussian.hpp +++ b/source/gfx/blur/gfx-blur-gaussian.hpp @@ -26,14 +26,14 @@ namespace gfx { namespace blur { class gaussian_data { - std::shared_ptr<::gs::effect> _effect; + gs::effect _effect; std::vector> _kernels; public: gaussian_data(); virtual ~gaussian_data(); - std::shared_ptr<::gs::effect> get_effect(); + gs::effect get_effect(); std::vector const& get_kernel(size_t width); }; diff --git a/source/obs/gs/gs-effect-parameter.cpp b/source/obs/gs/gs-effect-parameter.cpp index d73de01..73d5aea 100644 --- a/source/obs/gs/gs-effect-parameter.cpp +++ b/source/obs/gs/gs-effect-parameter.cpp @@ -23,6 +23,7 @@ #include "gs-effect-pass.hpp" #include +#include gs::effect_parameter::effect_parameter(gs_eparam_t* param) : _effect_parent(nullptr), _pass_parent(nullptr), _param_parent(nullptr) @@ -129,3 +130,536 @@ bool gs::effect_parameter::has_annotation(std::string name, effect_parameter::ty return eprm->get_type() == type; return false; } + +void gs::effect_parameter::set_bool(bool v) +{ + if (get_type() != type::Boolean) + throw std::bad_cast(); + gs_effect_set_bool(get(), v); +} + +void gs::effect_parameter::get_bool(bool& v) +{ + if (get_type() != type::Boolean) + throw std::bad_cast(); + void* ptr = gs_effect_get_val(get()); + if (ptr) { + v = *reinterpret_cast(ptr); + bfree(ptr); + } else { + v = false; + } +} + +void gs::effect_parameter::get_default_bool(bool& v) +{ + if (get_type() != type::Boolean) + throw std::bad_cast(); + void* ptr = gs_effect_get_default_val(get()); + if (ptr) { + v = *reinterpret_cast(ptr); + bfree(ptr); + } else { + v = false; + } +} + +void gs::effect_parameter::set_bool_array(bool v[], size_t sz) +{ + if (get_type() != type::Boolean) + throw std::bad_cast(); + gs_effect_set_val(get(), v, sz); +} + +void gs::effect_parameter::set_float(float_t x) +{ + if (get_type() != type::Float) + throw std::bad_cast(); + gs_effect_set_float(get(), x); +} + +void gs::effect_parameter::get_float(float_t& x) +{ + if (get_type() != type::Float) + throw std::bad_cast(); + void* ptr = gs_effect_get_val(get()); + if (ptr) { + x = *reinterpret_cast(ptr); + bfree(ptr); + } else { + x = 0; + } +} + +void gs::effect_parameter::get_default_float(float_t& x) +{ + if (get_type() != type::Float) + throw std::bad_cast(); + void* ptr = gs_effect_get_default_val(get()); + if (ptr) { + x = *reinterpret_cast(ptr); + bfree(ptr); + } else { + x = 0; + } +} + +void gs::effect_parameter::set_float2(vec2 const& v) +{ + if (get_type() != type::Float2) + throw std::bad_cast(); + gs_effect_set_vec2(get(), &v); +} + +void gs::effect_parameter::get_float2(vec2& v) +{ + get_float2(v.x, v.y); +} + +void gs::effect_parameter::get_default_float2(vec2& v) +{ + get_default_float2(v.x, v.y); +} + +void gs::effect_parameter::set_float2(float_t x, float_t y) +{ + vec2 data; + data.x = x; + data.y = y; + set_float2(data); +} + +void gs::effect_parameter::get_float2(float_t& x, float_t& y) +{ + if (get_type() != type::Float2) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(float_t)); + bfree(ptr); + } else { + x = y = 0; + } +} + +void gs::effect_parameter::get_default_float2(float_t& x, float_t& y) +{ + if (get_type() != type::Float2) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_default_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(float_t)); + bfree(ptr); + } else { + x = y = 0; + } +} + +void gs::effect_parameter::set_float3(vec3 const& v) +{ + if (get_type() != type::Float3) + throw std::bad_cast(); + gs_effect_set_vec3(get(), &v); +} + +void gs::effect_parameter::get_float3(vec3& v) +{ + get_float3(v.x, v.y, v.z); +} + +void gs::effect_parameter::get_default_float3(vec3& v) +{ + get_default_float3(v.x, v.y, v.z); +} + +void gs::effect_parameter::set_float3(float_t x, float_t y, float_t z) +{ + if (get_type() != type::Float3) + throw std::bad_cast(); + vec3 v = {{x, y, z, 0}}; + gs_effect_set_vec3(get(), &v); +} + +void gs::effect_parameter::get_float3(float_t& x, float_t& y, float_t& z) +{ + if (get_type() != type::Float3) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(float_t)); + z = *reinterpret_cast(ptr + sizeof(float_t) * 2); + bfree(ptr); + } else { + x = y = z = 0; + } +} + +void gs::effect_parameter::get_default_float3(float_t& x, float_t& y, float_t& z) +{ + if (get_type() != type::Float3) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_default_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(float_t)); + z = *reinterpret_cast(ptr + sizeof(float_t) * 2); + bfree(ptr); + } else { + x = y = z = 0; + } +} + +void gs::effect_parameter::set_float4(vec4 const& v) +{ + if (get_type() != type::Float4) + throw std::bad_cast(); + gs_effect_set_vec4(get(), &v); +} + +void gs::effect_parameter::get_float4(vec4& v) +{ + get_float4(v.x, v.y, v.z, v.w); +} + +void gs::effect_parameter::get_default_float4(vec4& v) +{ + get_default_float4(v.x, v.y, v.z, v.w); +} + +void gs::effect_parameter::set_float4(float_t x, float_t y, float_t z, float_t w) +{ + if (get_type() != type::Float4) + throw std::bad_cast(); + vec4 v = {{x, y, z, w}}; + gs_effect_set_vec4(get(), &v); +} + +void gs::effect_parameter::get_float4(float_t& x, float_t& y, float_t& z, float_t& w) +{ + if (get_type() != type::Float4) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(float_t)); + z = *reinterpret_cast(ptr + sizeof(float_t) * 2); + w = *reinterpret_cast(ptr + sizeof(float_t) * 3); + bfree(ptr); + } else { + x = y = z = w = 0; + } +} + +void gs::effect_parameter::get_default_float4(float_t& x, float_t& y, float_t& z, float_t& w) +{ + if (get_type() != type::Float4) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_default_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(float_t)); + z = *reinterpret_cast(ptr + sizeof(float_t) * 2); + w = *reinterpret_cast(ptr + sizeof(float_t) * 3); + bfree(ptr); + } else { + x = y = z = w = 0; + } +} + +void gs::effect_parameter::set_float_array(float_t v[], size_t sz) +{ + if ((get_type() != type::Float) && (get_type() != type::Float2) && (get_type() != type::Float3) + && (get_type() != type::Float4)) + throw std::bad_cast(); + gs_effect_set_val(get(), v, sizeof(float_t) * sz); +} + +void gs::effect_parameter::set_int(int32_t x) +{ + if ((get_type() != type::Integer) && (get_type() != type::Unknown)) + throw std::bad_cast(); + gs_effect_set_int(get(), x); +} + +void gs::effect_parameter::get_int(int32_t& x) +{ + if ((get_type() != type::Integer) && (get_type() != type::Unknown)) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + bfree(ptr); + } else { + x = 0; + } +} + +void gs::effect_parameter::get_default_int(int32_t& x) +{ + if ((get_type() != type::Integer) && (get_type() != type::Unknown)) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_default_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + bfree(ptr); + } else { + x = 0; + } +} + +void gs::effect_parameter::set_int2(int32_t x, int32_t y) +{ + if ((get_type() != type::Integer2) && (get_type() != type::Unknown)) + throw std::bad_cast(); + int32_t v[2] = {x, y}; + gs_effect_set_val(get(), v, sizeof(int) * 2); +} + +void gs::effect_parameter::get_int2(int32_t& x, int32_t& y) +{ + if ((get_type() != type::Integer2) && (get_type() != type::Unknown)) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(int32_t)); + bfree(ptr); + } else { + x = y = 0; + } +} + +void gs::effect_parameter::get_default_int2(int32_t& x, int32_t& y) +{ + if ((get_type() != type::Integer2) && (get_type() != type::Unknown)) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_default_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(int32_t)); + bfree(ptr); + } else { + x = y = 0; + } +} + +void gs::effect_parameter::set_int3(int32_t x, int32_t y, int32_t z) +{ + if ((get_type() != type::Integer3) && (get_type() != type::Unknown)) + throw std::bad_cast(); + int32_t v[3] = {x, y, z}; + gs_effect_set_val(get(), v, sizeof(int) * 3); +} + +void gs::effect_parameter::get_int3(int32_t& x, int32_t& y, int32_t& z) +{ + if ((get_type() != type::Integer3) && (get_type() != type::Unknown)) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(int32_t)); + z = *reinterpret_cast(ptr + sizeof(int32_t) * 2); + bfree(ptr); + } else { + x = y = z = 0; + } +} + +void gs::effect_parameter::get_default_int3(int32_t& x, int32_t& y, int32_t& z) +{ + if ((get_type() != type::Integer3) && (get_type() != type::Unknown)) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_default_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(int32_t)); + z = *reinterpret_cast(ptr + sizeof(int32_t) * 2); + bfree(ptr); + } else { + x = y = z = 0; + } +} + +void gs::effect_parameter::set_int4(int32_t x, int32_t y, int32_t z, int32_t w) +{ + if ((get_type() != type::Integer4) && (get_type() != type::Unknown)) + throw std::bad_cast(); + int32_t v[4] = {x, y, z, w}; + gs_effect_set_val(get(), v, sizeof(int) * 4); +} + +void gs::effect_parameter::get_int4(int32_t& x, int32_t& y, int32_t& z, int32_t& w) +{ + if ((get_type() != type::Integer4) && (get_type() != type::Unknown)) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(int32_t)); + z = *reinterpret_cast(ptr + sizeof(int32_t) * 2); + w = *reinterpret_cast(ptr + sizeof(int32_t) * 3); + bfree(ptr); + } else { + x = y = z = w = 0; + } +} + +void gs::effect_parameter::get_default_int4(int32_t& x, int32_t& y, int32_t& z, int32_t& w) +{ + if ((get_type() != type::Integer4) && (get_type() != type::Unknown)) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_default_val(get())); + if (ptr) { + x = *reinterpret_cast(ptr); + y = *reinterpret_cast(ptr + sizeof(int32_t)); + z = *reinterpret_cast(ptr + sizeof(int32_t) * 2); + w = *reinterpret_cast(ptr + sizeof(int32_t) * 3); + bfree(ptr); + } else { + x = y = z = w = 0; + } +} + +void gs::effect_parameter::set_int_array(int32_t v[], size_t sz) +{ + if ((get_type() != type::Integer) && (get_type() != type::Integer2) && (get_type() != type::Integer3) + && (get_type() != type::Integer4) && (get_type() != type::Unknown)) + throw std::bad_cast(); + gs_effect_set_val(get(), v, sizeof(int) * sz); +} + +void gs::effect_parameter::set_matrix(matrix4 const& v) +{ + if (get_type() != type::Matrix) + throw std::bad_cast(); + gs_effect_set_matrix4(get(), &v); +} + +void gs::effect_parameter::get_matrix(matrix4& v) +{ + if (get_type() != type::Matrix) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_val(get())); + if (ptr) { + v.x.x = *reinterpret_cast(ptr + sizeof(float_t) * 0); + v.x.y = *reinterpret_cast(ptr + sizeof(float_t) * 1); + v.x.z = *reinterpret_cast(ptr + sizeof(float_t) * 2); + v.x.w = *reinterpret_cast(ptr + sizeof(float_t) * 3); + v.y.x = *reinterpret_cast(ptr + sizeof(float_t) * 4); + v.y.y = *reinterpret_cast(ptr + sizeof(float_t) * 5); + v.y.z = *reinterpret_cast(ptr + sizeof(float_t) * 6); + v.y.w = *reinterpret_cast(ptr + sizeof(float_t) * 7); + v.z.x = *reinterpret_cast(ptr + sizeof(float_t) * 8); + v.z.y = *reinterpret_cast(ptr + sizeof(float_t) * 9); + v.z.z = *reinterpret_cast(ptr + sizeof(float_t) * 10); + v.z.w = *reinterpret_cast(ptr + sizeof(float_t) * 11); + v.t.x = *reinterpret_cast(ptr + sizeof(float_t) * 12); + v.t.y = *reinterpret_cast(ptr + sizeof(float_t) * 13); + v.t.z = *reinterpret_cast(ptr + sizeof(float_t) * 14); + v.t.w = *reinterpret_cast(ptr + sizeof(float_t) * 15); + bfree(ptr); + } else { + v.x = vec4{}; + v.y = vec4{}; + v.z = vec4{}; + v.t = vec4{}; + } +} + +void gs::effect_parameter::get_default_matrix(matrix4& v) +{ + if (get_type() != type::Matrix) + throw std::bad_cast(); + uint8_t* ptr = static_cast(gs_effect_get_default_val(get())); + if (ptr) { + v.x.x = *reinterpret_cast(ptr + sizeof(float_t) * 0); + v.x.y = *reinterpret_cast(ptr + sizeof(float_t) * 1); + v.x.z = *reinterpret_cast(ptr + sizeof(float_t) * 2); + v.x.w = *reinterpret_cast(ptr + sizeof(float_t) * 3); + v.y.x = *reinterpret_cast(ptr + sizeof(float_t) * 4); + v.y.y = *reinterpret_cast(ptr + sizeof(float_t) * 5); + v.y.z = *reinterpret_cast(ptr + sizeof(float_t) * 6); + v.y.w = *reinterpret_cast(ptr + sizeof(float_t) * 7); + v.z.x = *reinterpret_cast(ptr + sizeof(float_t) * 8); + v.z.y = *reinterpret_cast(ptr + sizeof(float_t) * 9); + v.z.z = *reinterpret_cast(ptr + sizeof(float_t) * 10); + v.z.w = *reinterpret_cast(ptr + sizeof(float_t) * 11); + v.t.x = *reinterpret_cast(ptr + sizeof(float_t) * 12); + v.t.y = *reinterpret_cast(ptr + sizeof(float_t) * 13); + v.t.z = *reinterpret_cast(ptr + sizeof(float_t) * 14); + v.t.w = *reinterpret_cast(ptr + sizeof(float_t) * 15); + bfree(ptr); + } else { + v.x = vec4{}; + v.y = vec4{}; + v.z = vec4{}; + v.t = vec4{}; + } +} + +void gs::effect_parameter::set_texture(std::shared_ptr v) +{ + if (get_type() != type::Texture) + throw std::bad_cast(); + gs_effect_set_texture(get(), v->get_object()); +} + +void gs::effect_parameter::set_texture(gs_texture_t* v) +{ + if (get_type() != type::Texture) + throw std::bad_cast(); + gs_effect_set_texture(get(), v); +} + +void gs::effect_parameter::set_sampler(std::shared_ptr v) +{ + if (get_type() != type::Texture) + throw std::bad_cast(); + gs_effect_set_next_sampler(get(), v->get_object()); +} + +void gs::effect_parameter::set_sampler(gs_sampler_state* v) +{ + if (get_type() != type::Texture) + throw std::bad_cast(); + gs_effect_set_next_sampler(get(), v); +} + +void gs::effect_parameter::set_string(std::string const& v) +{ + if (get_type() != type::String) + throw std::bad_cast(); + gs_effect_set_val(get(), v.c_str(), v.length()); +} + +void gs::effect_parameter::get_string(std::string& v) +{ + if (get_type() != type::String) + throw std::bad_cast(); + size_t ptr_len = gs_effect_get_val_size(get()); + uint8_t* ptr = static_cast(gs_effect_get_val(get())); + if (ptr) { + v = std::string(ptr, ptr + ptr_len - 1); + bfree(ptr); + } else { + v = ""; + } +} + +void gs::effect_parameter::get_default_string(std::string& v) +{ + if (get_type() != type::String) + throw std::bad_cast(); + size_t ptr_len = gs_effect_get_default_val_size(get()); + uint8_t* ptr = static_cast(gs_effect_get_default_val(get())); + if (ptr) { + v = std::string(ptr, ptr + ptr_len - 1); + bfree(ptr); + } else { + v = ""; + } +} diff --git a/source/obs/gs/gs-effect-parameter.hpp b/source/obs/gs/gs-effect-parameter.hpp index 6f7414e..8a301ab 100644 --- a/source/obs/gs/gs-effect-parameter.hpp +++ b/source/obs/gs/gs-effect-parameter.hpp @@ -21,11 +21,24 @@ #include #include #include +#include "gs-sampler.hpp" +#include "gs-texture.hpp" +// OBS +extern "C" { +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4201) +#endif #include +#include +#ifdef _MSC_VER +#pragma warning(pop) +#endif +} namespace gs { - class effect_parameter : protected std::shared_ptr { + class effect_parameter : public std::shared_ptr { std::shared_ptr* _effect_parent; std::shared_ptr* _pass_parent; std::shared_ptr* _param_parent; @@ -65,5 +78,176 @@ namespace gs { std::shared_ptr get_annotation(std::string name); bool has_annotation(std::string name); bool has_annotation(std::string name, effect_parameter::type type); + + public /*value*/: + void set_bool(bool v); + void get_bool(bool& v); + void get_default_bool(bool& v); + + void set_bool_array(bool v[], size_t sz); + + void set_float(float_t x); + void get_float(float_t& x); + void get_default_float(float_t& x); + + void set_float2(vec2 const& v); + void get_float2(vec2& v); + void get_default_float2(vec2& v); + void set_float2(float_t x, float_t y); + void get_float2(float_t& x, float_t& y); + void get_default_float2(float_t& x, float_t& y); + + void set_float3(vec3 const& v); + void get_float3(vec3& v); + void get_default_float3(vec3& v); + void set_float3(float_t x, float_t y, float_t z); + void get_float3(float_t& x, float_t& y, float_t& z); + void get_default_float3(float_t& x, float_t& y, float_t& z); + + void set_float4(vec4 const& v); + void get_float4(vec4& v); + void get_default_float4(vec4& v); + void set_float4(float_t x, float_t y, float_t z, float_t w); + void get_float4(float_t& x, float_t& y, float_t& z, float_t& w); + void get_default_float4(float_t& x, float_t& y, float_t& z, float_t& w); + + void set_float_array(float_t v[], size_t sz); + + void set_int(int32_t x); + void get_int(int32_t& x); + void get_default_int(int32_t& x); + + void set_int2(int32_t x, int32_t y); + void get_int2(int32_t& x, int32_t& y); + void get_default_int2(int32_t& x, int32_t& y); + + void set_int3(int32_t x, int32_t y, int32_t z); + void get_int3(int32_t& x, int32_t& y, int32_t& z); + void get_default_int3(int32_t& x, int32_t& y, int32_t& z); + + void set_int4(int32_t x, int32_t y, int32_t z, int32_t w); + void get_int4(int32_t& x, int32_t& y, int32_t& z, int32_t& w); + void get_default_int4(int32_t& x, int32_t& y, int32_t& z, int32_t& w); + + void set_int_array(int32_t v[], size_t sz); + + void set_matrix(matrix4 const& v); + void get_matrix(matrix4& v); + void get_default_matrix(matrix4& v); + + void set_texture(std::shared_ptr v); + void set_texture(gs_texture_t* v); + + void set_sampler(std::shared_ptr v); + void set_sampler(gs_sampler_state* v); + + void set_string(std::string const& v); + void get_string(std::string& v); + void get_default_string(std::string& v); + + public /* Helpers */: + inline float_t get_bool() + { + bool v; + get_bool(v); + return v; + }; + inline bool get_default_bool() + { + bool v; + get_default_bool(v); + return v; + }; + + inline float_t get_float() + { + float_t v; + get_float(v); + return v; + }; + inline float_t get_default_float() + { + float_t v; + get_default_float(v); + return v; + }; + + inline vec2 get_float2() + { + vec2 v; + get_float2(v); + return v; + }; + inline vec2 get_default_float2() + { + vec2 v; + get_default_float2(v); + return v; + }; + + inline vec3 get_float3() + { + vec3 v; + get_float3(v); + return v; + }; + inline vec3 get_default_float3() + { + vec3 v; + get_default_float3(v); + return v; + }; + + inline vec4 get_float4() + { + vec4 v; + get_float4(v); + return v; + }; + inline vec4 get_default_float4() + { + vec4 v; + get_default_float4(v); + return v; + }; + + inline int32_t get_int() + { + int32_t v; + get_int(v); + return v; + }; + inline int32_t get_default_int() + { + int32_t v; + get_default_int(v); + return v; + }; + + inline matrix4 get_matrix() + { + matrix4 v; + get_matrix(v); + return v; + }; + inline matrix4 get_default_matrix() + { + matrix4 v; + get_default_matrix(v); + return v; + }; + + inline std::string get_string() + { + std::string v; + get_string(v); + return v; + }; + inline std::string get_default_string() + { + std::string v; + get_default_string(v); + return v; + }; }; } // namespace gs diff --git a/source/obs/gs/gs-effect-pass.hpp b/source/obs/gs/gs-effect-pass.hpp index c558b6a..6fd11ea 100644 --- a/source/obs/gs/gs-effect-pass.hpp +++ b/source/obs/gs/gs-effect-pass.hpp @@ -22,10 +22,20 @@ #include #include +// OBS +extern "C" { +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4201) +#endif #include +#ifdef _MSC_VER +#pragma warning(pop) +#endif +} namespace gs { - class effect_pass : protected std::shared_ptr { + class effect_pass : public std::shared_ptr { std::shared_ptr* _parent; public: diff --git a/source/obs/gs/gs-effect-technique.cpp b/source/obs/gs/gs-effect-technique.cpp index 5ecc570..2e7cafc 100644 --- a/source/obs/gs/gs-effect-technique.cpp +++ b/source/obs/gs/gs-effect-technique.cpp @@ -63,10 +63,7 @@ gs::effect_pass gs::effect_technique::get_pass(std::string name) bool gs::effect_technique::has_pass(std::string name) { - for (size_t idx = 0; idx < get()->passes.num; idx++) { - auto ptr = get()->passes.array + idx; - if (strcmp(ptr->name, name.c_str()) == 0) - return true; - } + if (get_pass(name) != nullptr) + return true; return false; } diff --git a/source/obs/gs/gs-effect-technique.hpp b/source/obs/gs/gs-effect-technique.hpp index d5e2780..639741d 100644 --- a/source/obs/gs/gs-effect-technique.hpp +++ b/source/obs/gs/gs-effect-technique.hpp @@ -23,10 +23,20 @@ #include #include "gs-effect-pass.hpp" +// OBS +extern "C" { +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4201) +#endif #include +#ifdef _MSC_VER +#pragma warning(pop) +#endif +} namespace gs { - class effect_technique : protected std::shared_ptr { + class effect_technique : public std::shared_ptr { std::shared_ptr* _parent; public: @@ -35,10 +45,9 @@ namespace gs { std::string name(); - size_t count_passes(); + size_t count_passes(); gs::effect_pass get_pass(size_t idx); gs::effect_pass get_pass(std::string name); - bool has_pass(std::string name); - + bool has_pass(std::string name); }; } // namespace gs diff --git a/source/obs/gs/gs-effect.cpp b/source/obs/gs/gs-effect.cpp index 6cd9dcd..ada1a22 100644 --- a/source/obs/gs/gs-effect.cpp +++ b/source/obs/gs/gs-effect.cpp @@ -34,8 +34,7 @@ #pragma warning(pop) #endif -//#define OBS_LOAD_EFFECT_FILE -#define MAX_EFFECT_SIZE 32 * 1024 * 1024; +#define MAX_EFFECT_SIZE 32 * 1024 * 1024 static std::string load_file_as_code(std::filesystem::path file) { diff --git a/source/obs/gs/gs-effect.hpp b/source/obs/gs/gs-effect.hpp index 67c766c..ff77b09 100644 --- a/source/obs/gs/gs-effect.hpp +++ b/source/obs/gs/gs-effect.hpp @@ -26,9 +26,22 @@ #include "gs-effect-parameter.hpp" #include "gs-effect-technique.hpp" +// OBS +extern "C" { +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4201) +#endif +#include +#ifdef _MSC_VER +#pragma warning(pop) +#endif +} + namespace gs { - class effect : private std::shared_ptr { + class effect : public std::shared_ptr { public: + effect() {}; effect(std::string code, std::string name); effect(std::filesystem::path file); ~effect(); diff --git a/source/obs/gs/gs-mipmapper.cpp b/source/obs/gs/gs-mipmapper.cpp index ffa02b5..04692bd 100644 --- a/source/obs/gs/gs-mipmapper.cpp +++ b/source/obs/gs/gs-mipmapper.cpp @@ -110,7 +110,7 @@ gs::mipmapper::mipmapper() _vb->update(); char* effect_file = obs_module_file("effects/mipgen.effect"); - _effect = std::make_unique(effect_file); + _effect = gs::effect::create(effect_file); bfree(effect_file); } @@ -253,12 +253,12 @@ void gs::mipmapper::rebuild(std::shared_ptr source, std::shared_ptr vec4_zero(&black); gs_clear(GS_CLEAR_COLOR | GS_CLEAR_DEPTH, &black, 0, 0); - _effect->get_parameter("image")->set_texture(target); - _effect->get_parameter("level")->set_int(int32_t(mip - 1)); - _effect->get_parameter("imageTexel")->set_float2(texel_width, texel_height); - _effect->get_parameter("strength")->set_float(strength); + _effect.get_parameter("image").set_texture(target); + _effect.get_parameter("level").set_int(int32_t(mip - 1)); + _effect.get_parameter("imageTexel").set_float2(texel_width, texel_height); + _effect.get_parameter("strength").set_float(strength); - while (gs_effect_loop(_effect->get_object(), technique.c_str())) { + while (gs_effect_loop(_effect.get_object(), technique.c_str())) { gs_draw(gs_draw_mode::GS_TRIS, 0, _vb->size()); } } catch (...) { diff --git a/source/obs/gs/gs-mipmapper.hpp b/source/obs/gs/gs-mipmapper.hpp index c74c56b..127d95d 100644 --- a/source/obs/gs/gs-mipmapper.hpp +++ b/source/obs/gs/gs-mipmapper.hpp @@ -37,7 +37,7 @@ namespace gs { class mipmapper { std::unique_ptr _vb; std::unique_ptr _rt; - std::unique_ptr _effect; + gs::effect _effect; public: enum class generator : uint8_t {