diff options
| -rw-r--r-- | source/blender/functions/CMakeLists.txt | 2 | ||||
| -rw-r--r-- | source/blender/functions/FN_attributes_ref.hh | 246 | ||||
| -rw-r--r-- | source/blender/functions/intern/attributes_ref.cc | 72 | ||||
| -rw-r--r-- | tests/gtests/functions/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | tests/gtests/functions/FN_attributes_ref_test.cc | 114 |
5 files changed, 435 insertions, 0 deletions
diff --git a/source/blender/functions/CMakeLists.txt b/source/blender/functions/CMakeLists.txt index acaef1d146a..5b18dd4258e 100644 --- a/source/blender/functions/CMakeLists.txt +++ b/source/blender/functions/CMakeLists.txt @@ -27,11 +27,13 @@ set(INC_SYS ) set(SRC + intern/attributes_ref.cc intern/cpp_types.cc intern/multi_function_network.cc intern/multi_function_network_evaluation.cc FN_array_spans.hh + FN_attributes_ref.hh FN_cpp_type.hh FN_cpp_types.hh FN_multi_function.hh diff --git a/source/blender/functions/FN_attributes_ref.hh b/source/blender/functions/FN_attributes_ref.hh new file mode 100644 index 00000000000..1a4c1d2aadc --- /dev/null +++ b/source/blender/functions/FN_attributes_ref.hh @@ -0,0 +1,246 @@ +/* + * 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. + */ + +#ifndef __FN_ATTRIBUTES_REF_HH__ +#define __FN_ATTRIBUTES_REF_HH__ + +/** \file + * \ingroup fn + * + * An AttributesRef references multiple arrays of equal length. Each array has a corresponding name + * and index. + */ + +#include "FN_spans.hh" + +#include "BLI_linear_allocator.hh" +#include "BLI_map.hh" +#include "BLI_utility_mixins.hh" +#include "BLI_vector_set.hh" + +namespace blender { +namespace fn { + +class AttributesInfo; + +class AttributesInfoBuilder : NonCopyable, NonMovable { + private: + LinearAllocator<> m_allocator; + VectorSet<std::string> m_names; + Vector<const CPPType *> m_types; + Vector<void *> m_defaults; + + friend AttributesInfo; + + public: + AttributesInfoBuilder() = default; + ~AttributesInfoBuilder(); + + template<typename T> void add(StringRef name, const T &default_value) + { + this->add(name, CPPType::get<T>(), (const void *)&default_value); + } + + void add(StringRef name, const CPPType &type, const void *default_value = nullptr); +}; + +/** + * Stores which attributes are in an AttributesRef. Every attribute has a unique index, a unique + * name, a type and a default value. + */ +class AttributesInfo : NonCopyable, NonMovable { + private: + LinearAllocator<> m_allocator; + Map<StringRefNull, uint> m_index_by_name; + Vector<StringRefNull> m_name_by_index; + Vector<const CPPType *> m_type_by_index; + Vector<void *> m_defaults; + + public: + AttributesInfo() = default; + AttributesInfo(const AttributesInfoBuilder &builder); + ~AttributesInfo(); + + uint size() const + { + return m_name_by_index.size(); + } + + IndexRange index_range() const + { + return m_name_by_index.index_range(); + } + + StringRefNull name_of(uint index) const + { + return m_name_by_index[index]; + } + + uint index_of(StringRef name) const + { + return m_index_by_name.lookup_as(name); + } + + const void *default_of(uint index) const + { + return m_defaults[index]; + } + + const void *default_of(StringRef name) const + { + return this->default_of(this->index_of(name)); + } + + template<typename T> const T &default_of(uint index) const + { + BLI_assert(m_type_by_index[index]->is<T>()); + return *(T *)m_defaults[index]; + } + + template<typename T> const T &default_of(StringRef name) const + { + return this->default_of<T>(this->index_of(name)); + } + + const CPPType &type_of(uint index) const + { + return *m_type_by_index[index]; + } + + const CPPType &type_of(StringRef name) const + { + return this->type_of(this->index_of(name)); + } + + bool has_attribute(StringRef name, const CPPType &type) const + { + return this->try_index_of(name, type) >= 0; + } + + int try_index_of(StringRef name) const + { + return (int)m_index_by_name.lookup_default_as(name, -1); + } + + int try_index_of(StringRef name, const CPPType &type) const + { + int index = this->try_index_of(name); + if (index == -1) { + return -1; + } + else if (this->type_of((uint)index) == type) { + return index; + } + else { + return -1; + } + } +}; + +/** + * References multiple arrays that match the description of an AttributesInfo instance. This class + * is supposed to be relatively cheap to copy. It does not own any of the arrays itself. + */ +class MutableAttributesRef { + private: + const AttributesInfo *m_info; + Span<void *> m_buffers; + IndexRange m_range; + + public: + MutableAttributesRef(const AttributesInfo &info, Span<void *> buffers, uint size) + : MutableAttributesRef(info, buffers, IndexRange(size)) + { + } + + MutableAttributesRef(const AttributesInfo &info, Span<void *> buffers, IndexRange range) + : m_info(&info), m_buffers(buffers), m_range(range) + { + } + + uint size() const + { + return m_range.size(); + } + + const AttributesInfo &info() const + { + return *m_info; + } + + GMutableSpan get(uint index) const + { + const CPPType &type = m_info->type_of(index); + void *ptr = POINTER_OFFSET(m_buffers[index], type.size() * m_range.start()); + return GMutableSpan(type, ptr, m_range.size()); + } + + GMutableSpan get(StringRef name) const + { + return this->get(m_info->index_of(name)); + } + + template<typename T> MutableSpan<T> get(uint index) const + { + BLI_assert(m_info->type_of(index).is<T>()); + return MutableSpan<T>((T *)m_buffers[index] + m_range.start(), m_range.size()); + } + + template<typename T> MutableSpan<T> get(StringRef name) const + { + return this->get<T>(m_info->index_of(name)); + } + + Optional<GMutableSpan> try_get(StringRef name, const CPPType &type) const + { + int index = m_info->try_index_of(name, type); + if (index == -1) { + return {}; + } + else { + return this->get((uint)index); + } + } + + template<typename T> Optional<MutableSpan<T>> try_get(StringRef name) const + { + int index = m_info->try_index_of(name); + if (index == -1) { + return {}; + } + else if (m_info->type_of((uint)index).is<T>()) { + return this->get<T>((uint)index); + } + else { + return {}; + } + } + + MutableAttributesRef slice(IndexRange range) const + { + return this->slice(range.start(), range.size()); + } + + MutableAttributesRef slice(uint start, uint size) const + { + return MutableAttributesRef(*m_info, m_buffers, m_range.slice(start, size)); + } +}; + +} // namespace fn +} // namespace blender + +#endif /* __FN_ATTRIBUTES_REF_HH__ */ diff --git a/source/blender/functions/intern/attributes_ref.cc b/source/blender/functions/intern/attributes_ref.cc new file mode 100644 index 00000000000..dc64f571596 --- /dev/null +++ b/source/blender/functions/intern/attributes_ref.cc @@ -0,0 +1,72 @@ +/* + * 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 "FN_attributes_ref.hh" + +namespace blender { +namespace fn { + +AttributesInfoBuilder::~AttributesInfoBuilder() +{ + for (uint i : m_defaults.index_range()) { + m_types[i]->destruct(m_defaults[i]); + } +} + +void AttributesInfoBuilder::add(StringRef name, const CPPType &type, const void *default_value) +{ + if (m_names.add_as(name)) { + m_types.append(&type); + + if (default_value == nullptr) { + default_value = type.default_value(); + } + void *dst = m_allocator.allocate(type.size(), type.alignment()); + type.copy_to_uninitialized(default_value, dst); + m_defaults.append(dst); + } + else { + /* The same name can be added more than once as long as the type is always the same. */ + BLI_assert(m_types[m_names.index_of_as(name)] == &type); + } +} + +AttributesInfo::AttributesInfo(const AttributesInfoBuilder &builder) +{ + for (uint i : builder.m_types.index_range()) { + StringRefNull name = m_allocator.copy_string(builder.m_names[i]); + const CPPType &type = *builder.m_types[i]; + const void *default_value = builder.m_defaults[i]; + + m_index_by_name.add_new(name, i); + m_name_by_index.append(name); + m_type_by_index.append(&type); + + void *dst = m_allocator.allocate(type.size(), type.alignment()); + type.copy_to_uninitialized(default_value, dst); + m_defaults.append(dst); + } +} + +AttributesInfo::~AttributesInfo() +{ + for (uint i : m_defaults.index_range()) { + m_type_by_index[i]->destruct(m_defaults[i]); + } +} + +} // namespace fn +} // namespace blender diff --git a/tests/gtests/functions/CMakeLists.txt b/tests/gtests/functions/CMakeLists.txt index e52a616bf61..1246bbd5599 100644 --- a/tests/gtests/functions/CMakeLists.txt +++ b/tests/gtests/functions/CMakeLists.txt @@ -37,6 +37,7 @@ if(WITH_BUILDINFO) endif() BLENDER_TEST(FN_array_spans "bf_blenlib;bf_functions;${BUILDINFO}") +BLENDER_TEST(FN_attributes_ref "bf_blenlib;bf_functions;${BUILDINFO}") BLENDER_TEST(FN_cpp_type "bf_blenlib;bf_functions;${BUILDINFO}") BLENDER_TEST(FN_generic_vector_array "bf_blenlib;bf_functions;${BUILDINFO}") BLENDER_TEST(FN_multi_function "bf_blenlib;bf_functions;${BUILDINFO}") diff --git a/tests/gtests/functions/FN_attributes_ref_test.cc b/tests/gtests/functions/FN_attributes_ref_test.cc new file mode 100644 index 00000000000..111190564e5 --- /dev/null +++ b/tests/gtests/functions/FN_attributes_ref_test.cc @@ -0,0 +1,114 @@ +/* + * 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 "BLI_float3.hh" +#include "FN_attributes_ref.hh" +#include "FN_cpp_types.hh" + +#include "testing/testing.h" + +namespace blender { +namespace fn { + +TEST(attributes_info, BuildEmpty) +{ + AttributesInfoBuilder info_builder; + AttributesInfo info{info_builder}; + + EXPECT_EQ(info.size(), 0); +} + +TEST(attributes_info, AddSameNameTwice) +{ + AttributesInfoBuilder info_builder; + info_builder.add<int>("A", 4); + info_builder.add<int>("A", 5); + AttributesInfo info{info_builder}; + EXPECT_EQ(info.size(), 1); + EXPECT_TRUE(info.has_attribute("A", CPPType::get<int>())); + EXPECT_FALSE(info.has_attribute("B", CPPType::get<int>())); + EXPECT_FALSE(info.has_attribute("A", CPPType::get<float>())); + EXPECT_EQ(info.default_of<int>("A"), 4); + EXPECT_EQ(info.name_of(0), "A"); + EXPECT_EQ(info.index_range().start(), 0); + EXPECT_EQ(info.index_range().one_after_last(), 1); +} + +TEST(attributes_info, BuildWithDefaultString) +{ + AttributesInfoBuilder info_builder; + info_builder.add("A", CPPType::get<std::string>()); + AttributesInfo info{info_builder}; + EXPECT_EQ(info.default_of<std::string>("A"), ""); +} + +TEST(attributes_info, BuildWithGivenDefault) +{ + AttributesInfoBuilder info_builder; + info_builder.add<std::string>("A", "hello world"); + AttributesInfo info{info_builder}; + const void *default_value = info.default_of("A"); + EXPECT_EQ(*(const std::string *)default_value, "hello world"); + EXPECT_EQ(info.type_of("A"), CPPType::get<std::string>()); +} + +TEST(mutable_attributes_ref, ComplexTest) +{ + AttributesInfoBuilder info_builder; + info_builder.add<float3>("Position", {0, 0, 10}); + info_builder.add<uint>("ID", 0); + info_builder.add<float>("Size", 0.5f); + info_builder.add<std::string>("Name", "<no name>"); + AttributesInfo info{info_builder}; + + uint amount = 5; + Array<float3> positions(amount); + Array<uint> ids(amount, 0); + Array<float> sizes(amount); + Array<std::string> names(amount); + + Array<void *> buffers = {positions.data(), ids.data(), sizes.data(), names.data()}; + MutableAttributesRef attributes{info, buffers, IndexRange(1, 3)}; + EXPECT_EQ(attributes.size(), 3); + EXPECT_EQ(attributes.info().size(), 4); + EXPECT_EQ(attributes.get("Position").buffer(), positions.data() + 1); + EXPECT_EQ(attributes.get("ID").buffer(), ids.data() + 1); + EXPECT_EQ(attributes.get("Size").buffer(), sizes.data() + 1); + EXPECT_EQ(attributes.get("Name").buffer(), names.data() + 1); + + EXPECT_EQ(attributes.get("ID").size(), 3); + EXPECT_EQ(attributes.get<uint>("ID").size(), 3); + + EXPECT_EQ(ids[2], 0); + MutableSpan<uint> ids_span = attributes.get<uint>("ID"); + ids_span[1] = 42; + EXPECT_EQ(ids[2], 42); + + EXPECT_FALSE(attributes.try_get<int>("not existant").has_value()); + EXPECT_FALSE(attributes.try_get<int>("Position").has_value()); + EXPECT_TRUE(attributes.try_get<float3>("Position").has_value()); + EXPECT_FALSE(attributes.try_get("not existant", CPPType::get<int>()).has_value()); + EXPECT_FALSE(attributes.try_get("Position", CPPType::get<int>()).has_value()); + EXPECT_TRUE(attributes.try_get("Position", CPPType::get<float3>()).has_value()); + + MutableAttributesRef sliced = attributes.slice(IndexRange(1, 2)); + EXPECT_EQ(sliced.size(), 2); + sliced.get<uint>("ID")[0] = 100; + EXPECT_EQ(ids[2], 100); +} + +} // namespace fn +} // namespace blender |