From 0a761b97a2075c9c550e847997f7617c943abd25 Mon Sep 17 00:00:00 2001 From: Michael Fabian 'Xaymar' Dirks Date: Wed, 18 Dec 2019 06:37:38 +0100 Subject: [PATCH] gfx-shader-param*: Initial code --- source/gfx/shader/gfx-shader-param-basic.cpp | 192 +++++++++++++++++++ source/gfx/shader/gfx-shader-param-basic.hpp | 77 ++++++++ source/gfx/shader/gfx-shader-param.cpp | 56 ++++++ source/gfx/shader/gfx-shader-param.hpp | 55 ++++++ 4 files changed, 380 insertions(+) diff --git a/source/gfx/shader/gfx-shader-param-basic.cpp b/source/gfx/shader/gfx-shader-param-basic.cpp index e69de29b..60d912e8 100644 --- a/source/gfx/shader/gfx-shader-param-basic.cpp +++ b/source/gfx/shader/gfx-shader-param-basic.cpp @@ -0,0 +1,192 @@ +// Modern effects for a modern Streamer +// Copyright (C) 2019 Michael Fabian Dirks +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + +#include "gfx-shader-param-basic.hpp" +#include +#include "strings.hpp" + +inline bool get_annotation_string(gs::effect_parameter param, std::string anno_name, std::string& out) +{ + if (!param) + return false; + + if (auto el = param.get_annotation(anno_name); el != nullptr) { + if (auto val = el.get_default_string(); val.length() > 0) { + out = val; + return true; + } + } + + return false; +} + +inline bool get_annotation_float(gs::effect_parameter param, std::string anno_name, float_t& out) +{ + if (!param) { + return false; + } + + if (auto el = param.get_annotation(anno_name); el != nullptr) { + out = el.get_default_float(); + return true; + } + + return false; +} + +gfx::shader::bool_parameter::bool_parameter(gs::effect_parameter param, std::string prefix) : parameter(param) +{ + std::stringstream ss; + ss << prefix << "." << param.get_name(); + + _key = ss.str(); + _name = _key; + _desc = ""; + + get_annotation_string(_param, "name", _name); + get_annotation_string(_param, "description", _desc); +} + +gfx::shader::bool_parameter::~bool_parameter() {} + +void gfx::shader::bool_parameter::properties(obs_properties_t* props, obs_data_t* settings) +{ + auto p = obs_properties_add_list(props, _key.c_str(), _name.c_str(), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT); + if (_desc.length() > 0) + obs_property_set_long_description(p, _desc.c_str()); + obs_property_list_add_int(p, D_TRANSLATE(S_STATE_DISABLED), 0); + obs_property_list_add_int(p, D_TRANSLATE(S_STATE_ENABLED), 1); + + obs_data_set_default_bool(settings, _key.c_str(), _param.get_default_bool()); +} + +void gfx::shader::bool_parameter::update(obs_data_t* settings) +{ + _value = obs_data_get_int(settings, _key.c_str()) != 0; +} + +void gfx::shader::bool_parameter::assign() +{ + _param.set_bool(_value); +} + +gfx::shader::float_parameter::float_parameter(gs::effect_parameter param, std::string prefix) : parameter(param) +{ + switch (_param.get_type()) { + case gs::effect_parameter::type::Float: + _len = 1; + break; + case gs::effect_parameter::type::Float2: + _len = 2; + break; + case gs::effect_parameter::type::Float3: + _len = 3; + break; + case gs::effect_parameter::type::Float4: + _len = 4; + break; + default: + _len = 0; + } + + // Build baseline key. + std::stringstream ss; + ss << prefix << "." << param.get_name(); + + // Build primary key. + _key[4] = ss.str(); + _name[4] = _key[4]; + _desc = ""; + get_annotation_string(_param, "name", _name[4]); + get_annotation_string(_param, "description", _desc); + + // Build sub-keys + for (size_t len = 0; len < _len; len++) { + char buf[4]; + snprintf(buf, 4, "[%d]", static_cast(len - 1)); + _name[len] = std::string(buf, buf + sizeof(buf)); + _key[len] = _key[4] + _name[len]; + + _min[len] = std::numeric_limits::min(); + _max[len] = std::numeric_limits::max(); + _step[len] = 0.01f; + } + + if (auto anno = _param.get_annotation("minimum"); (anno != nullptr)) { + if (anno.get_type() == gs::effect_parameter::type::Float) { + for (size_t len = 0; len < _len; len++) { + anno.get_default_value(&_min[len], 1); + } + } else if (anno.get_type() == _param.get_type()) { + anno.get_default_value(_min, _len); + } + } + if (auto anno = _param.get_annotation("maximum"); (anno != nullptr)) { + if (anno.get_type() == gs::effect_parameter::type::Float) { + for (size_t len = 0; len < _len; len++) { + anno.get_default_value(&_max[len], 1); + } + } else if (anno.get_type() == _param.get_type()) { + anno.get_default_value(_max, _len); + } + } + if (auto anno = _param.get_annotation("step"); (anno != nullptr)) { + if (anno.get_type() == gs::effect_parameter::type::Float) { + for (size_t len = 0; len < _len; len++) { + anno.get_default_value(&_step[len], 1); + } + } else if (anno.get_type() == _param.get_type()) { + anno.get_default_value(_step, _len); + } + } +} + +gfx::shader::float_parameter::~float_parameter() {} + +void gfx::shader::float_parameter::properties(obs_properties_t* props, obs_data_t* settings) +{ + auto grp = obs_properties_create(); + obs_properties_add_group(props, _key[4].c_str(), _name[4].c_str(), OBS_GROUP_NORMAL, grp); + + float_t defaults[4] = {0, 0, 0, 0}; + _param.get_default_value(defaults, _len); + + for (size_t len = 0; len < _len; len++) { + auto p = + obs_properties_add_float(props, _key[len].c_str(), _name[len].c_str(), _min[len], _max[len], _step[len]); + obs_property_set_long_description(p, _desc.c_str()); + obs_data_set_default_double(settings, _key[len].c_str(), static_cast(defaults[len])); + } +} + +void gfx::shader::float_parameter::update(obs_data_t* settings) +{ + for (size_t len = 0; len < _len; len++) { + _value[len] = static_cast(obs_data_get_double(settings, _key[len].c_str())); + } +} + +void gfx::shader::float_parameter::assign() +{ + _param.set_value(_value, _len); +} + +gfx::shader::int_parameter::int_parameter(gs::effect_parameter param, std::string prefix) : parameter(param) {} + +gfx::shader::int_parameter::~int_parameter() {} + +void gfx::shader::int_parameter::properties(obs_properties_t* props, obs_data_t* settings) {} diff --git a/source/gfx/shader/gfx-shader-param-basic.hpp b/source/gfx/shader/gfx-shader-param-basic.hpp index e69de29b..e038bfca 100644 --- a/source/gfx/shader/gfx-shader-param-basic.hpp +++ b/source/gfx/shader/gfx-shader-param-basic.hpp @@ -0,0 +1,77 @@ +// Modern effects for a modern Streamer +// Copyright (C) 2019 Michael Fabian Dirks +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + +#pragma once +#include +#include "gfx-shader-param.hpp" +#include "obs/gs/gs-effect-parameter.hpp" + +namespace gfx { + namespace shader { + class bool_parameter : public parameter { + std::string _key; + std::string _name; + std::string _desc; + + bool _value; + + public: + bool_parameter(gs::effect_parameter param, std::string prefix); + virtual ~bool_parameter(); + + public: + virtual void properties(obs_properties_t* props, obs_data_t* settings) override; + + virtual void update(obs_data_t* settings) override; + + virtual void assign() override; + }; + + struct float_parameter : public parameter { + size_t _len; + std::string _key[5]; + std::string _name[5]; + std::string _desc; + + float_t _min[4]; + float_t _max[4]; + float_t _step[4]; + float_t _value[4]; + + public: + float_parameter(gs::effect_parameter param, std::string prefix); + virtual ~float_parameter(); + + public: + virtual void properties(obs_properties_t* props, obs_data_t* settings) override; + + virtual void update(obs_data_t* settings) override; + + virtual void assign() override; + }; + + struct int_parameter : public parameter { + public: + int_parameter(gs::effect_parameter param, std::string prefix); + virtual ~int_parameter(); + + public: + virtual void properties(obs_properties_t* props, obs_data_t* settings) override; + }; + + } // namespace shader +} // namespace gfx diff --git a/source/gfx/shader/gfx-shader-param.cpp b/source/gfx/shader/gfx-shader-param.cpp index e69de29b..71798c49 100644 --- a/source/gfx/shader/gfx-shader-param.cpp +++ b/source/gfx/shader/gfx-shader-param.cpp @@ -0,0 +1,56 @@ +// Modern effects for a modern Streamer +// Copyright (C) 2019 Michael Fabian Dirks +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + +#include "gfx-shader-param.hpp" +#include "gfx-shader-param-basic.hpp" + +void gfx::shader::parameter::properties(obs_properties_t* props, obs_data_t* settings) {} + +void gfx::shader::parameter::update(obs_data_t* settings) {} + +void gfx::shader::parameter::assign() {} + +std::shared_ptr gfx::shader::parameter::make_parameter(gs::effect_parameter param, + std::string prefix) +{ + if (!param) + return nullptr; + + typedef gs::effect_parameter::type eptype; + switch (param.get_type()) { + case eptype::Boolean: { + auto el = std::make_shared(param, prefix); + return el; + } + case eptype::Integer: + case eptype::Integer2: + case eptype::Integer3: + case eptype::Integer4: { + auto el = std::make_shared(param, prefix); + return el; + } + case eptype::Float: + case eptype::Float2: + case eptype::Float3: + case eptype::Float4: { + auto el = std::make_shared(param, prefix); + return el; + } + default: + return nullptr; + } +} diff --git a/source/gfx/shader/gfx-shader-param.hpp b/source/gfx/shader/gfx-shader-param.hpp index e69de29b..97badf0a 100644 --- a/source/gfx/shader/gfx-shader-param.hpp +++ b/source/gfx/shader/gfx-shader-param.hpp @@ -0,0 +1,55 @@ +// Modern effects for a modern Streamer +// Copyright (C) 2019 Michael Fabian Dirks +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + +#pragma once +#include +#include +#include "obs/gs/gs-effect-parameter.hpp" + +// OBS +extern "C" { +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4201) +#endif +#include +#ifdef _MSC_VER +#pragma warning(pop) +#endif +} + +namespace gfx { + namespace shader { + class parameter { + protected: + gs::effect_parameter _param; + + parameter(gs::effect_parameter param) : _param(param){}; + virtual ~parameter(){}; + + public: + virtual void properties(obs_properties_t* props, obs_data_t* settings); + + virtual void update(obs_data_t* settings); + + virtual void assign(); + + public: + static std::shared_ptr make_parameter(gs::effect_parameter param, std::string prefix); + }; + } // namespace shader +} // namespace gfx