etc/obs-StreamFX
0
0
Fork 0
mirror of https://github.com/Xaymar/obs-StreamFX synced 2024-11-15 08:15:06 +00:00
Code Issues Projects Releases Packages Wiki Activity

gfx/shader/param/basic: Fix bool and suffixes, add enums and optimize

Browse source 
Adds support for enumerations, a different way of selecting how something should behave in a shader. Enumerations rely on a continuous list of values, and will automatically detect how many values there are in the enumeration. Only non-vector types are supported as enumeration entries, and array/vector parameters can have each member set to a different enumeration value.

Furthermore suffixes now are properly assigned, and 'bool' no longer causes shaders to stop rendering. Additionally by inlining some functions and using std::string_view we can achieve a slightly better performance than before.
This commit is contained in:
Michael Fabian 'Xaymar' Dirks 2020-05-13 08:43:37 +02:00 committed by Michael Fabian Dirks
parent 7b8774b834
commit eaf89193fb
2 changed files with 113 additions and 119 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

202
source/gfx/shader/gfx-shader-param-basic.cpp
View file

@ -22,14 +22,14 @@
#include <sstream> #include <sstream>
#include <stdexcept> #include <stdexcept>
#define ANNO_FIELD_TYPE "field_type" static const std::string_view _annotation_field_type = "field_type";
#define ANNO_SUFFIX "suffix" static const std::string_view _annotation_suffix = "suffix";
#define ANNO_VALUE_MINIMUM "minimum" static const std::string_view _annotation_minimum = "minimum";
#define ANNO_VALUE_MAXIMUM "maximum" static const std::string_view _annotation_maximum = "maximum";
#define ANNO_VALUE_STEP "step" static const std::string_view _annotation_step = "step";
#define ANNO_VALUE_SCALE "scale" static const std::string_view _annotation_scale = "scale";
#define ANNO_ENUM_VALUES "values" static const std::string_view _annotation_enum_entry = "enum_%zu";
#define ANNO_ENUM_VALUE "value" static const std::string_view _annotation_enum_entry_name = "enum_%zu_name";
inline bool get_annotation_string(gs::effect_parameter param, std::string anno_name, std::string& out) inline bool get_annotation_string(gs::effect_parameter param, std::string anno_name, std::string& out)
{ {
@ -98,45 +98,55 @@ gfx::shader::basic_parameter::basic_parameter(gs::effect_parameter param, std::s
for (std::size_t idx = 0; idx < get_size(); idx++) { for (std::size_t idx = 0; idx < get_size(); idx++) {
snprintf(string_buffer, sizeof(string_buffer), "[%d]", static_cast<int32_t>(idx)); snprintf(string_buffer, sizeof(string_buffer), "[%d]", static_cast<int32_t>(idx));
_names[idx] = std::string(string_buffer, string_buffer + strnlen(string_buffer, sizeof(string_buffer))); _names[idx] = std::string(string_buffer, string_buffer + strnlen(string_buffer, sizeof(string_buffer)));
snprintf(string_buffer, sizeof(string_buffer), "%s[%d]", get_key().c_str(), static_cast<int32_t>(idx)); snprintf(string_buffer, sizeof(string_buffer), "%s[%d]", get_key().data(), static_cast<int32_t>(idx));
_keys[idx] = std::string(string_buffer, string_buffer + strnlen(string_buffer, sizeof(string_buffer))); _keys[idx] = std::string(string_buffer, string_buffer + strnlen(string_buffer, sizeof(string_buffer)));
} }
} }
// Detect Field Types // Detect Field Types
if (auto anno = get_parameter().get_annotation(ANNO_FIELD_TYPE); anno) { if (auto anno = get_parameter().get_annotation(_annotation_field_type); anno) {
_field_type = get_field_type_from_string(anno.get_default_string()); _field_type = get_field_type_from_string(anno.get_default_string());
} }
// Read Suffix Data // Read Suffix Data
if (auto anno = get_parameter().get_annotation(ANNO_SUFFIX); anno) { if (auto anno = get_parameter().get_annotation(_annotation_suffix); anno) {
if (anno.get_type() == gs::effect_parameter::type::String) if (anno.get_type() == gs::effect_parameter::type::String)
_suffix = anno.get_default_string(); _suffix = anno.get_default_string();
} }
// Read Enumeration Data if Enumeration // Read Enumeration Data if Enumeration
if (get_field_type() == basic_field_type::Enum) { if (field_type() == basic_field_type::Enum) {
if (auto anno = get_parameter().get_annotation(ANNO_ENUM_VALUES); for (std::size_t idx = 0; idx < std::numeric_limits<std::size_t>::max(); idx++) {
anno && (anno.get_type() == gs::effect_parameter::type::Integer)) { // Build key.
_values.resize(static_cast<size_t>(std::max(anno.get_default_int(), 0))); std::string key_name;
for (std::size_t idx = 0; idx < _values.size(); idx++) { std::string key_value;
auto& entry = _values[idx]; {
snprintf(string_buffer, sizeof(string_buffer), "_%zu", idx); snprintf(string_buffer, sizeof(string_buffer), _annotation_enum_entry.data(), idx);
std::string key = key_value = std::string(string_buffer);
std::string(string_buffer, string_buffer + strnlen(string_buffer, sizeof(string_buffer))); snprintf(string_buffer, sizeof(string_buffer), _annotation_enum_entry_name.data(), idx);
if (auto annoe = anno.get_annotation(key); key_name = std::string(string_buffer);
annoe && (annoe.get_type() == gs::effect_parameter::type::String)) {
entry.name = annoe.get_default_string();
if (auto annoev = annoe.get_annotation(ANNO_ENUM_VALUE); annoev) {
load_parameter_data(annoev, entry.data);
}
} else {
LOG_WARNING("[%s] Parameter enumeration entry '%s' is of invalid type, must be string.",
get_name().c_str(), string_buffer);
}
} }
} else {
LOG_WARNING("[%s] Enumeration is missing entries.", get_name().c_str()); // Value must be given, name is optional.
if (auto eanno = get_parameter().get_annotation(key_value);
eanno && (get_type_from_effect_type(eanno.get_type()) == get_type())) {
basic_enum_data entry;
load_parameter_data(eanno, entry.data);
if (auto nanno = get_parameter().get_annotation(key_name);
nanno && (nanno.get_type() == gs::effect_parameter::type::String)) {
entry.name = nanno.get_default_string();
} else {
entry.name = "Unnamed Entry";
}
_values.push_back(entry);
} else {
break;
}
}
if (_values.size() == 0) {
_field_type = basic_field_type::Input; _field_type = basic_field_type::Input;
} }
} }
@ -149,30 +159,6 @@ void gfx::shader::basic_parameter::load_parameter_data(gs::effect_parameter para
parameter.get_default_value(&data.i32, 1); parameter.get_default_value(&data.i32, 1);
} }
gfx::shader::basic_field_type gfx::shader::basic_parameter::get_field_type()
{
return _field_type;
}
const std::string& gfx::shader::basic_parameter::get_suffix()
{
return _suffix;
}
const std::string& gfx::shader::basic_parameter::get_keys(std::size_t idx)
{
if (idx >= get_size())
throw std::out_of_range("Index out of range.");
return _keys[idx];
}
const std::string& gfx::shader::basic_parameter::get_names(std::size_t idx)
{
if (idx >= get_size())
throw std::out_of_range("Index out of range.");
return _names[idx];
}
gfx::shader::bool_parameter::bool_parameter(gs::effect_parameter param, std::string prefix) gfx::shader::bool_parameter::bool_parameter(gs::effect_parameter param, std::string prefix)
: basic_parameter(param, prefix) : basic_parameter(param, prefix)
{ {
@ -181,7 +167,7 @@ gfx::shader::bool_parameter::bool_parameter(gs::effect_parameter param, std::str
_step.resize(0); _step.resize(0);
_scale.resize(0); _scale.resize(0);
_data.resize(get_size(), true); _data.resize(get_size(), 1);
} }
gfx::shader::bool_parameter::~bool_parameter() {} gfx::shader::bool_parameter::~bool_parameter() {}
@ -190,7 +176,7 @@ void gfx::shader::bool_parameter::defaults(obs_data_t* settings)
{ {
// TODO: Support for bool[] // TODO: Support for bool[]
if (get_size() == 1) { if (get_size() == 1) {
obs_data_set_default_bool(settings, get_key().c_str(), get_parameter().get_default_bool()); obs_data_set_default_int(settings, get_key().data(), get_parameter().get_default_bool() ? 1 : 0);
} }
} }
@ -201,10 +187,10 @@ void gfx::shader::bool_parameter::properties(obs_properties_t* props, obs_data_t
// TODO: Support for bool[] // TODO: Support for bool[]
if (get_size() == 1) { if (get_size() == 1) {
auto p = obs_properties_add_list(props, get_key().c_str(), get_name().c_str(), OBS_COMBO_TYPE_LIST, auto p = obs_properties_add_list(props, get_key().data(), get_name().data(), OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_INT); OBS_COMBO_FORMAT_INT);
if (has_description()) if (has_description())
obs_property_set_long_description(p, get_description().c_str()); obs_property_set_long_description(p, get_description().data());
obs_property_list_add_int(p, D_TRANSLATE(S_STATE_DISABLED), 0); 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_property_list_add_int(p, D_TRANSLATE(S_STATE_ENABLED), 1);
} }
@ -217,13 +203,13 @@ void gfx::shader::bool_parameter::update(obs_data_t* settings)
// TODO: Support for bool[] // TODO: Support for bool[]
if (get_size() == 1) { if (get_size() == 1) {
_data[0] = static_cast<bool>(obs_data_get_int(settings, get_key().c_str())); _data[0] = obs_data_get_int(settings, get_key().data());
} }
} }
void gfx::shader::bool_parameter::assign() void gfx::shader::bool_parameter::assign()
{ {
get_parameter().set_value(_data.data(), sizeof(std::uint8_t)); get_parameter().set_value(_data.data(), _data.size());
} }
gfx::shader::float_parameter::float_parameter(gs::effect_parameter param, std::string prefix) gfx::shader::float_parameter::float_parameter(gs::effect_parameter param, std::string prefix)
@ -240,22 +226,22 @@ gfx::shader::float_parameter::float_parameter(gs::effect_parameter param, std::s
} }
// Load Limits // Load Limits
if (auto anno = get_parameter().get_annotation(ANNO_VALUE_MINIMUM); anno) { if (auto anno = get_parameter().get_annotation(_annotation_minimum); anno) {
if (anno.get_type() == get_parameter().get_type()) { if (anno.get_type() == get_parameter().get_type()) {
anno.get_default_value(_min.data(), get_size()); anno.get_default_value(_min.data(), get_size());
} }
} }
if (auto anno = get_parameter().get_annotation(ANNO_VALUE_MAXIMUM); anno) { if (auto anno = get_parameter().get_annotation(_annotation_maximum); anno) {
if (anno.get_type() == get_parameter().get_type()) { if (anno.get_type() == get_parameter().get_type()) {
anno.get_default_value(_max.data(), get_size()); anno.get_default_value(_max.data(), get_size());
} }
} }
if (auto anno = get_parameter().get_annotation(ANNO_VALUE_STEP); anno) { if (auto anno = get_parameter().get_annotation(_annotation_step); anno) {
if (anno.get_type() == get_parameter().get_type()) { if (anno.get_type() == get_parameter().get_type()) {
anno.get_default_value(_step.data(), get_size()); anno.get_default_value(_step.data(), get_size());
} }
} }
if (auto anno = get_parameter().get_annotation(ANNO_VALUE_SCALE); anno) { if (auto anno = get_parameter().get_annotation(_annotation_scale); anno) {
if (anno.get_type() == get_parameter().get_type()) { if (anno.get_type() == get_parameter().get_type()) {
anno.get_default_value(_scale.data(), get_size()); anno.get_default_value(_scale.data(), get_size());
} }
@ -271,19 +257,18 @@ void gfx::shader::float_parameter::defaults(obs_data_t* settings)
get_parameter().get_default_value(defaults.data(), get_size()); get_parameter().get_default_value(defaults.data(), get_size());
for (std::size_t idx = 0; idx < get_size(); idx++) { for (std::size_t idx = 0; idx < get_size(); idx++) {
obs_data_set_default_double(settings, get_keys(idx).c_str(), static_cast<double_t>(defaults[idx])); obs_data_set_default_double(settings, key_at(idx).data(), static_cast<double_t>(defaults[idx]));
} }
} }
static inline obs_property_t* build_float_property(gfx::shader::basic_field_type ft, obs_properties_t* props, static inline obs_property_t* build_float_property(gfx::shader::basic_field_type ft, obs_properties_t* props,
const char* key, const char* name, float_t min, float_t max, const char* key, const char* name, float_t min, float_t max,
float_t step, std::vector<gfx::shader::basic_enum_data> edata) float_t step, std::list<gfx::shader::basic_enum_data> edata)
{ {
switch (ft) { switch (ft) {
case gfx::shader::basic_field_type::Enum: { case gfx::shader::basic_field_type::Enum: {
auto p = obs_properties_add_list(props, key, name, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_FLOAT); auto p = obs_properties_add_list(props, key, name, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_FLOAT);
for (std::size_t idx = 0; idx < edata.size(); idx++) { for (auto& el : edata) {
auto& el = edata.at(idx);
obs_property_list_add_float(p, el.name.c_str(), el.data.f32); obs_property_list_add_float(p, el.name.c_str(), el.data.f32);
} }
return p; return p;
@ -301,31 +286,28 @@ void gfx::shader::float_parameter::properties(obs_properties_t* props, obs_data_
if (!is_visible()) if (!is_visible())
return; return;
if (get_size() == 1) { obs_properties_t* pr = props;
auto p = build_float_property(_field_type, props, _keys[0].c_str(), _names[0].c_str(), _min[0].f32, _max[0].f32, if (get_size() > 1) {
_step[0].f32, _values); pr = obs_properties_create();
auto p = obs_properties_add_group(props, get_key().data(), has_name() ? get_name().data() : get_key().data(),
OBS_GROUP_NORMAL, pr);
if (has_description()) if (has_description())
obs_property_set_long_description(p, get_description().c_str()); obs_property_set_long_description(p, get_description().data());
} else { }
auto grp = obs_properties_create();
auto p = obs_properties_add_group(props, get_key().c_str(), has_name() ? get_name().c_str() : get_key().c_str(),
OBS_GROUP_NORMAL, grp);
if (has_description())
obs_property_set_long_description(p, get_description().c_str());
for (std::size_t idx = 0; idx < get_size(); idx++) { for (std::size_t idx = 0; idx < get_size(); idx++) {
p = build_float_property(_field_type, grp, _keys[idx].c_str(), _names[idx].c_str(), _min[idx].f32, auto p = build_float_property(field_type(), pr, key_at(idx).data(), name_at(idx).data(), _min[idx].f32,
_max[idx].f32, _step[idx].f32, _values); _max[idx].f32, _step[idx].f32, _values);
if (has_description()) if (has_description())
obs_property_set_long_description(p, get_description().c_str()); obs_property_set_long_description(p, get_description().data());
} obs_property_float_set_suffix(p, suffix().data());
} }
} }
void gfx::shader::float_parameter::update(obs_data_t* settings) void gfx::shader::float_parameter::update(obs_data_t* settings)
{ {
for (std::size_t idx = 0; idx < get_size(); idx++) { for (std::size_t idx = 0; idx < get_size(); idx++) {
_data[idx].f32 = static_cast<float_t>(obs_data_get_double(settings, _keys[idx].c_str())) * _scale[idx].f32; _data[idx].f32 = static_cast<float_t>(obs_data_get_double(settings, key_at(idx).data())) * _scale[idx].f32;
} }
} }
@ -338,13 +320,12 @@ void gfx::shader::float_parameter::assign()
} }
static inline obs_property_t* build_int_property(gfx::shader::basic_field_type ft, obs_properties_t* props, static inline obs_property_t* build_int_property(gfx::shader::basic_field_type ft, obs_properties_t* props,
const char* key, const char* name, int32_t min, int32_t max, const char* key, const char* name, int32_t min, int32_t max,
int32_t step, std::vector<gfx::shader::basic_enum_data> edata) int32_t step, std::list<gfx::shader::basic_enum_data> edata)
{ {
switch (ft) { switch (ft) {
case gfx::shader::basic_field_type::Enum: { case gfx::shader::basic_field_type::Enum: {
auto p = obs_properties_add_list(props, key, name, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT); auto p = obs_properties_add_list(props, key, name, OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_INT);
for (std::size_t idx = 0; idx < edata.size(); idx++) { for (auto& el : edata) {
auto& el = edata.at(idx);
obs_property_list_add_int(p, el.name.c_str(), el.data.i32); obs_property_list_add_int(p, el.name.c_str(), el.data.i32);
} }
return p; return p;
@ -371,22 +352,22 @@ gfx::shader::int_parameter::int_parameter(gs::effect_parameter param, std::strin
} }
// Load Limits // Load Limits
if (auto anno = get_parameter().get_annotation(ANNO_VALUE_MINIMUM); anno) { if (auto anno = get_parameter().get_annotation(_annotation_minimum); anno) {
if (anno.get_type() == get_parameter().get_type()) { if (anno.get_type() == get_parameter().get_type()) {
anno.get_default_value(_min.data(), get_size()); anno.get_default_value(_min.data(), get_size());
} }
} }
if (auto anno = get_parameter().get_annotation(ANNO_VALUE_MAXIMUM); anno) { if (auto anno = get_parameter().get_annotation(_annotation_maximum); anno) {
if (anno.get_type() == get_parameter().get_type()) { if (anno.get_type() == get_parameter().get_type()) {
anno.get_default_value(_max.data(), get_size()); anno.get_default_value(_max.data(), get_size());
} }
} }
if (auto anno = get_parameter().get_annotation(ANNO_VALUE_STEP); anno) { if (auto anno = get_parameter().get_annotation(_annotation_step); anno) {
if (anno.get_type() == get_parameter().get_type()) { if (anno.get_type() == get_parameter().get_type()) {
anno.get_default_value(_step.data(), get_size()); anno.get_default_value(_step.data(), get_size());
} }
} }
if (auto anno = get_parameter().get_annotation(ANNO_VALUE_SCALE); anno) { if (auto anno = get_parameter().get_annotation(_annotation_scale); anno) {
if (anno.get_type() == get_parameter().get_type()) { if (anno.get_type() == get_parameter().get_type()) {
anno.get_default_value(_scale.data(), get_size()); anno.get_default_value(_scale.data(), get_size());
} }
@ -401,7 +382,7 @@ void gfx::shader::int_parameter::defaults(obs_data_t* settings)
defaults.resize(get_size()); defaults.resize(get_size());
get_parameter().get_default_value(defaults.data(), get_size()); get_parameter().get_default_value(defaults.data(), get_size());
for (std::size_t idx = 0; idx < get_size(); idx++) { for (std::size_t idx = 0; idx < get_size(); idx++) {
obs_data_set_default_int(settings, get_keys(idx).c_str(), defaults[idx]); obs_data_set_default_int(settings, key_at(idx).data(), defaults[idx]);
} }
} }
@ -410,31 +391,28 @@ void gfx::shader::int_parameter::properties(obs_properties_t* props, obs_data_t*
if (!is_visible()) if (!is_visible())
return; return;
if (get_size() == 1) { obs_properties_t* pr = props;
auto p = build_int_property(_field_type, props, _keys[0].c_str(), _names[0].c_str(), _min[0].i32, _max[0].i32, if (get_size() > 1) {
_step[0].i32, _values); pr = obs_properties_create();
auto p = obs_properties_add_group(props, get_key().data(), has_name() ? get_name().data() : get_key().data(),
OBS_GROUP_NORMAL, pr);
if (has_description()) if (has_description())
obs_property_set_long_description(p, get_description().c_str()); obs_property_set_long_description(p, get_description().data());
} else { }
auto grp = obs_properties_create();
auto p = obs_properties_add_group(props, get_key().c_str(), has_name() ? get_name().c_str() : get_key().c_str(),
OBS_GROUP_NORMAL, grp);
if (has_description())
obs_property_set_long_description(p, get_description().c_str());
for (std::size_t idx = 0; idx < get_size(); idx++) { for (std::size_t idx = 0; idx < get_size(); idx++) {
p = build_int_property(_field_type, grp, _keys[idx].c_str(), _names[idx].c_str(), _min[idx].i32, auto p = build_int_property(field_type(), pr, key_at(idx).data(), name_at(idx).data(), _min[idx].i32,
_max[idx].i32, _step[idx].i32, _values); _max[idx].i32, _step[idx].i32, _values);
if (has_description()) if (has_description())
obs_property_set_long_description(p, get_description().c_str()); obs_property_set_long_description(p, get_description().data());
} obs_property_int_set_suffix(p, suffix().data());
} }
} }
void gfx::shader::int_parameter::update(obs_data_t* settings) void gfx::shader::int_parameter::update(obs_data_t* settings)
{ {
for (std::size_t idx = 0; idx < get_size(); idx++) { for (std::size_t idx = 0; idx < get_size(); idx++) {
_data[idx].i32 = static_cast<int32_t>(obs_data_get_int(settings, _keys[idx].c_str()) * _scale[idx].i32); _data[idx].i32 = static_cast<int32_t>(obs_data_get_int(settings, key_at(idx).data()) * _scale[idx].i32);
} }
} }

30
source/gfx/shader/gfx-shader-param-basic.hpp
View file

@ -44,7 +44,7 @@ namespace gfx {
basic_data data; basic_data data;
}; };
struct basic_parameter : public parameter { class basic_parameter : public parameter {
// Descriptor // Descriptor
basic_field_type _field_type; basic_field_type _field_type;
std::string _suffix; std::string _suffix;
@ -59,7 +59,7 @@ namespace gfx {
std::vector<basic_data> _scale; std::vector<basic_data> _scale;
// Enumeration Information // Enumeration Information
std::vector<basic_enum_data> _values; std::list<basic_enum_data> _values;
public: public:
basic_parameter(gs::effect_parameter param, std::string prefix); basic_parameter(gs::effect_parameter param, std::string prefix);
@ -68,18 +68,34 @@ namespace gfx {
virtual void load_parameter_data(gs::effect_parameter parameter, basic_data& data); virtual void load_parameter_data(gs::effect_parameter parameter, basic_data& data);
public: public:
basic_field_type get_field_type(); inline basic_field_type field_type()
{
return _field_type;
}
const std::string& get_suffix(); inline std::string_view suffix()
{
return _suffix;
}
const std::string& get_keys(std::size_t idx); inline std::string_view key_at(std::size_t idx)
{
if (idx >= get_size())
throw std::out_of_range("Index out of range.");
return _keys[idx];
}
const std::string& get_names(std::size_t idx); inline std::string_view name_at(std::size_t idx)
{
if (idx >= get_size())
throw std::out_of_range("Index out of range.");
return _names[idx];
}
}; };
struct bool_parameter : public basic_parameter { struct bool_parameter : public basic_parameter {
// std::vector<bool> doesn't allow .data() // std::vector<bool> doesn't allow .data()
std::vector<std::uint8_t> _data; std::vector<std::int32_t> _data;
public: public:
bool_parameter(gs::effect_parameter param, std::string prefix); bool_parameter(gs::effect_parameter param, std::string prefix);