diff options
Diffstat (limited to 'source/blender/functions')
16 files changed, 266 insertions, 260 deletions
diff --git a/source/blender/functions/FN_array_spans.hh b/source/blender/functions/FN_array_spans.hh index 3f71b36c49c..c362fef3630 100644 --- a/source/blender/functions/FN_array_spans.hh +++ b/source/blender/functions/FN_array_spans.hh @@ -39,17 +39,17 @@ enum class VArraySpanCategory { template<typename T> class VArraySpanBase { protected: - uint virtual_size_; + int64_t virtual_size_; VArraySpanCategory category_; union { struct { const T *start; - uint size; + int64_t size; } single_array; struct { const T *const *starts; - const uint *sizes; + const int64_t *sizes; } starts_and_sizes; } data_; @@ -71,7 +71,7 @@ template<typename T> class VArraySpanBase { return this->virtual_size_ == 0; } - uint size() const + int64_t size() const { return this->virtual_size_; } @@ -99,15 +99,16 @@ template<typename T> class VArraySpan : public VArraySpanBase<T> { this->data_.starts_and_sizes.sizes = nullptr; } - VArraySpan(Span<T> span, uint virtual_size) + VArraySpan(Span<T> span, int64_t virtual_size) { + BLI_assert(virtual_size >= 0); this->virtual_size_ = virtual_size; this->category_ = VArraySpanCategory::SingleArray; this->data_.single_array.start = span.data(); this->data_.single_array.size = span.size(); } - VArraySpan(Span<const T *> starts, Span<uint> sizes) + VArraySpan(Span<const T *> starts, Span<int64_t> sizes) { BLI_assert(starts.size() == sizes.size()); this->virtual_size_ = starts.size(); @@ -116,8 +117,9 @@ template<typename T> class VArraySpan : public VArraySpanBase<T> { this->data_.starts_and_sizes.sizes = sizes.begin(); } - VSpan<T> operator[](uint index) const + VSpan<T> operator[](int64_t index) const { + BLI_assert(index >= 0); BLI_assert(index < this->virtual_size_); switch (this->category_) { case VArraySpanCategory::SingleArray: @@ -151,7 +153,7 @@ class GVArraySpan : public VArraySpanBase<void> { this->data_.starts_and_sizes.sizes = nullptr; } - GVArraySpan(GSpan array, uint virtual_size) + GVArraySpan(GSpan array, int64_t virtual_size) { this->type_ = &array.type(); this->virtual_size_ = virtual_size; @@ -160,7 +162,7 @@ class GVArraySpan : public VArraySpanBase<void> { this->data_.single_array.size = array.size(); } - GVArraySpan(const CPPType &type, Span<const void *> starts, Span<uint> sizes) + GVArraySpan(const CPPType &type, Span<const void *> starts, Span<int64_t> sizes) { BLI_assert(starts.size() == sizes.size()); this->type_ = &type; @@ -187,7 +189,7 @@ class GVArraySpan : public VArraySpanBase<void> { return VArraySpan<T>(*this); } - GVSpan operator[](uint index) const + GVSpan operator[](int64_t index) const { BLI_assert(index < virtual_size_); switch (category_) { diff --git a/source/blender/functions/FN_attributes_ref.hh b/source/blender/functions/FN_attributes_ref.hh index cf5ef2af8a6..2af35317827 100644 --- a/source/blender/functions/FN_attributes_ref.hh +++ b/source/blender/functions/FN_attributes_ref.hh @@ -65,7 +65,7 @@ class AttributesInfoBuilder : NonCopyable, NonMovable { class AttributesInfo : NonCopyable, NonMovable { private: LinearAllocator<> allocator_; - Map<StringRefNull, uint> index_by_name_; + Map<StringRefNull, int> index_by_name_; Vector<StringRefNull> name_by_index_; Vector<const CPPType *> type_by_index_; Vector<void *> defaults_; @@ -75,7 +75,7 @@ class AttributesInfo : NonCopyable, NonMovable { AttributesInfo(const AttributesInfoBuilder &builder); ~AttributesInfo(); - uint size() const + int size() const { return name_by_index_.size(); } @@ -85,17 +85,17 @@ class AttributesInfo : NonCopyable, NonMovable { return name_by_index_.index_range(); } - StringRefNull name_of(uint index) const + StringRefNull name_of(int index) const { return name_by_index_[index]; } - uint index_of(StringRef name) const + int index_of(StringRef name) const { return index_by_name_.lookup_as(name); } - const void *default_of(uint index) const + const void *default_of(int index) const { return defaults_[index]; } @@ -105,7 +105,7 @@ class AttributesInfo : NonCopyable, NonMovable { return this->default_of(this->index_of(name)); } - template<typename T> const T &default_of(uint index) const + template<typename T> const T &default_of(int index) const { BLI_assert(type_by_index_[index]->is<T>()); return *(T *)defaults_[index]; @@ -116,7 +116,7 @@ class AttributesInfo : NonCopyable, NonMovable { return this->default_of<T>(this->index_of(name)); } - const CPPType &type_of(uint index) const + const CPPType &type_of(int index) const { return *type_by_index_[index]; } @@ -133,7 +133,7 @@ class AttributesInfo : NonCopyable, NonMovable { int try_index_of(StringRef name) const { - return (int)index_by_name_.lookup_default_as(name, -1); + return index_by_name_.lookup_default_as(name, -1); } int try_index_of(StringRef name, const CPPType &type) const @@ -142,7 +142,7 @@ class AttributesInfo : NonCopyable, NonMovable { if (index == -1) { return -1; } - else if (this->type_of((uint)index) == type) { + else if (this->type_of(index) == type) { return index; } else { @@ -164,7 +164,7 @@ class MutableAttributesRef { friend class AttributesRef; public: - MutableAttributesRef(const AttributesInfo &info, Span<void *> buffers, uint size) + MutableAttributesRef(const AttributesInfo &info, Span<void *> buffers, int64_t size) : MutableAttributesRef(info, buffers, IndexRange(size)) { } @@ -174,7 +174,7 @@ class MutableAttributesRef { { } - uint size() const + int64_t size() const { return range_.size(); } @@ -184,7 +184,7 @@ class MutableAttributesRef { return *info_; } - GMutableSpan get(uint index) const + GMutableSpan get(int index) const { const CPPType &type = info_->type_of(index); void *ptr = POINTER_OFFSET(buffers_[index], type.size() * range_.start()); @@ -196,7 +196,7 @@ class MutableAttributesRef { return this->get(info_->index_of(name)); } - template<typename T> MutableSpan<T> get(uint index) const + template<typename T> MutableSpan<T> get(int index) const { BLI_assert(info_->type_of(index).is<T>()); return MutableSpan<T>((T *)buffers_[index] + range_.start(), range_.size()); @@ -214,7 +214,7 @@ class MutableAttributesRef { return {}; } else { - return this->get((uint)index); + return this->get(index); } } @@ -224,8 +224,8 @@ class MutableAttributesRef { if (index == -1) { return {}; } - else if (info_->type_of((uint)index).is<T>()) { - return this->get<T>((uint)index); + else if (info_->type_of(index).is<T>()) { + return this->get<T>(index); } else { return {}; @@ -237,7 +237,7 @@ class MutableAttributesRef { return this->slice(range.start(), range.size()); } - MutableAttributesRef slice(uint start, uint size) const + MutableAttributesRef slice(int64_t start, int64_t size) const { return MutableAttributesRef(*info_, buffers_, range_.slice(start, size)); } @@ -250,7 +250,7 @@ class AttributesRef { IndexRange range_; public: - AttributesRef(const AttributesInfo &info, Span<const void *> buffers, uint size) + AttributesRef(const AttributesInfo &info, Span<const void *> buffers, int64_t size) : AttributesRef(info, buffers, IndexRange(size)) { } @@ -265,7 +265,7 @@ class AttributesRef { { } - uint size() const + int64_t size() const { return range_.size(); } @@ -275,7 +275,7 @@ class AttributesRef { return *info_; } - GSpan get(uint index) const + GSpan get(int index) const { const CPPType &type = info_->type_of(index); const void *ptr = POINTER_OFFSET(buffers_[index], type.size() * range_.start()); @@ -287,7 +287,7 @@ class AttributesRef { return this->get(info_->index_of(name)); } - template<typename T> Span<T> get(uint index) const + template<typename T> Span<T> get(int index) const { BLI_assert(info_->type_of(index).is<T>()); return Span<T>((T *)buffers_[index] + range_.start(), range_.size()); @@ -300,12 +300,12 @@ class AttributesRef { std::optional<GSpan> try_get(StringRef name, const CPPType &type) const { - int index = info_->try_index_of(name, type); + int64_t index = info_->try_index_of(name, type); if (index == -1) { return {}; } else { - return this->get((uint)index); + return this->get(index); } } @@ -315,8 +315,8 @@ class AttributesRef { if (index == -1) { return {}; } - else if (info_->type_of((uint)index).is<T>()) { - return this->get<T>((uint)index); + else if (info_->type_of(index).is<T>()) { + return this->get<T>(index); } else { return {}; @@ -328,7 +328,7 @@ class AttributesRef { return this->slice(range.start(), range.size()); } - AttributesRef slice(uint start, uint size) const + AttributesRef slice(int64_t start, int64_t size) const { return AttributesRef(*info_, buffers_, range_.slice(start, size)); } diff --git a/source/blender/functions/FN_cpp_type.hh b/source/blender/functions/FN_cpp_type.hh index ce02bfd05be..594890e353a 100644 --- a/source/blender/functions/FN_cpp_type.hh +++ b/source/blender/functions/FN_cpp_type.hh @@ -38,7 +38,7 @@ * methods come in three variants. Using the construct-default methods as example: * - construct_default(void *ptr): * Constructs a single instance of that type at the given pointer. - * - construct_default_n(void *ptr, uint n): + * - construct_default_n(void *ptr, int64_t n): * Constructs n instances of that type in an array that starts at the given pointer. * - construct_default_indices(void *ptr, IndexMask mask): * Constructs multiple instances of that type in an array that starts at the given pointer. @@ -77,42 +77,42 @@ namespace blender::fn { class CPPType : NonCopyable, NonMovable { public: using ConstructDefaultF = void (*)(void *ptr); - using ConstructDefaultNF = void (*)(void *ptr, uint n); + using ConstructDefaultNF = void (*)(void *ptr, int64_t n); using ConstructDefaultIndicesF = void (*)(void *ptr, IndexMask mask); using DestructF = void (*)(void *ptr); - using DestructNF = void (*)(void *ptr, uint n); + using DestructNF = void (*)(void *ptr, int64_t n); using DestructIndicesF = void (*)(void *ptr, IndexMask mask); using CopyToInitializedF = void (*)(const void *src, void *dst); - using CopyToInitializedNF = void (*)(const void *src, void *dst, uint n); + using CopyToInitializedNF = void (*)(const void *src, void *dst, int64_t n); using CopyToInitializedIndicesF = void (*)(const void *src, void *dst, IndexMask mask); using CopyToUninitializedF = void (*)(const void *src, void *dst); - using CopyToUninitializedNF = void (*)(const void *src, void *dst, uint n); + using CopyToUninitializedNF = void (*)(const void *src, void *dst, int64_t n); using CopyToUninitializedIndicesF = void (*)(const void *src, void *dst, IndexMask mask); using RelocateToInitializedF = void (*)(void *src, void *dst); - using RelocateToInitializedNF = void (*)(void *src, void *dst, uint n); + using RelocateToInitializedNF = void (*)(void *src, void *dst, int64_t n); using RelocateToInitializedIndicesF = void (*)(void *src, void *dst, IndexMask mask); using RelocateToUninitializedF = void (*)(void *src, void *dst); - using RelocateToUninitializedNF = void (*)(void *src, void *dst, uint n); + using RelocateToUninitializedNF = void (*)(void *src, void *dst, int64_t n); using RelocateToUninitializedIndicesF = void (*)(void *src, void *dst, IndexMask mask); - using FillInitializedF = void (*)(const void *value, void *dst, uint n); + using FillInitializedF = void (*)(const void *value, void *dst, int64_t n); using FillInitializedIndicesF = void (*)(const void *value, void *dst, IndexMask mask); - using FillUninitializedF = void (*)(const void *value, void *dst, uint n); + using FillUninitializedF = void (*)(const void *value, void *dst, int64_t n); using FillUninitializedIndicesF = void (*)(const void *value, void *dst, IndexMask mask); using DebugPrintF = void (*)(const void *value, std::stringstream &ss); using IsEqualF = bool (*)(const void *a, const void *b); - using HashF = uint32_t (*)(const void *value); + using HashF = uint64_t (*)(const void *value); private: - uint size_; - uint alignment_; + int64_t size_; + int64_t alignment_; uintptr_t alignment_mask_; bool is_trivially_destructible_; @@ -155,8 +155,8 @@ class CPPType : NonCopyable, NonMovable { public: CPPType(std::string name, - uint size, - uint alignment, + int64_t size, + int64_t alignment, bool is_trivially_destructible, ConstructDefaultF construct_default, ConstructDefaultNF construct_default_n, @@ -250,7 +250,7 @@ class CPPType : NonCopyable, NonMovable { * C++ equivalent: * sizeof(T); */ - uint size() const + int64_t size() const { return size_; } @@ -261,7 +261,7 @@ class CPPType : NonCopyable, NonMovable { * C++ equivalent: * alignof(T); */ - uint alignment() const + int64_t alignment() const { return alignment_; } @@ -306,7 +306,7 @@ class CPPType : NonCopyable, NonMovable { construct_default_(ptr); } - void construct_default_n(void *ptr, uint n) const + void construct_default_n(void *ptr, int64_t n) const { BLI_assert(n == 0 || this->pointer_can_point_to_instance(ptr)); @@ -335,7 +335,7 @@ class CPPType : NonCopyable, NonMovable { destruct_(ptr); } - void destruct_n(void *ptr, uint n) const + void destruct_n(void *ptr, int64_t n) const { BLI_assert(n == 0 || this->pointer_can_point_to_instance(ptr)); @@ -369,7 +369,7 @@ class CPPType : NonCopyable, NonMovable { copy_to_initialized_(src, dst); } - void copy_to_initialized_n(const void *src, void *dst, uint n) const + void copy_to_initialized_n(const void *src, void *dst, int64_t n) const { BLI_assert(src != dst); BLI_assert(n == 0 || this->pointer_can_point_to_instance(src)); @@ -404,7 +404,7 @@ class CPPType : NonCopyable, NonMovable { copy_to_uninitialized_(src, dst); } - void copy_to_uninitialized_n(const void *src, void *dst, uint n) const + void copy_to_uninitialized_n(const void *src, void *dst, int64_t n) const { BLI_assert(src != dst); BLI_assert(n == 0 || this->pointer_can_point_to_instance(src)); @@ -439,7 +439,7 @@ class CPPType : NonCopyable, NonMovable { relocate_to_initialized_(src, dst); } - void relocate_to_initialized_n(void *src, void *dst, uint n) const + void relocate_to_initialized_n(void *src, void *dst, int64_t n) const { BLI_assert(src != dst); BLI_assert(n == 0 || this->pointer_can_point_to_instance(src)); @@ -474,7 +474,7 @@ class CPPType : NonCopyable, NonMovable { relocate_to_uninitialized_(src, dst); } - void relocate_to_uninitialized_n(void *src, void *dst, uint n) const + void relocate_to_uninitialized_n(void *src, void *dst, int64_t n) const { BLI_assert(src != dst); BLI_assert(n == 0 || this->pointer_can_point_to_instance(src)); @@ -497,7 +497,7 @@ class CPPType : NonCopyable, NonMovable { * * Other instances of the same type should live in the array before this method is called. */ - void fill_initialized(const void *value, void *dst, uint n) const + void fill_initialized(const void *value, void *dst, int64_t n) const { BLI_assert(n == 0 || this->pointer_can_point_to_instance(value)); BLI_assert(n == 0 || this->pointer_can_point_to_instance(dst)); @@ -518,7 +518,7 @@ class CPPType : NonCopyable, NonMovable { * * The array should be uninitialized before this method is called. */ - void fill_uninitialized(const void *value, void *dst, uint n) const + void fill_uninitialized(const void *value, void *dst, int64_t n) const { BLI_assert(n == 0 || this->pointer_can_point_to_instance(value)); BLI_assert(n == 0 || this->pointer_can_point_to_instance(dst)); @@ -547,7 +547,7 @@ class CPPType : NonCopyable, NonMovable { return is_equal_(a, b); } - uint32_t hash(const void *value) const + uint64_t hash(const void *value) const { BLI_assert(this->pointer_can_point_to_instance(value)); return hash_(value); @@ -562,7 +562,7 @@ class CPPType : NonCopyable, NonMovable { return default_value_; } - uint32_t hash() const + uint64_t hash() const { return DefaultHash<const CPPType *>{}(this); } @@ -583,39 +583,39 @@ template<typename T> void construct_default_cb(void *ptr) { new (ptr) T; } -template<typename T> void construct_default_n_cb(void *ptr, uint n) +template<typename T> void construct_default_n_cb(void *ptr, int64_t n) { blender::default_construct_n((T *)ptr, n); } template<typename T> void construct_default_indices_cb(void *ptr, IndexMask mask) { - mask.foreach_index([&](uint i) { new ((T *)ptr + i) T; }); + mask.foreach_index([&](int64_t i) { new ((T *)ptr + i) T; }); } template<typename T> void destruct_cb(void *ptr) { ((T *)ptr)->~T(); } -template<typename T> void destruct_n_cb(void *ptr, uint n) +template<typename T> void destruct_n_cb(void *ptr, int64_t n) { blender::destruct_n((T *)ptr, n); } template<typename T> void destruct_indices_cb(void *ptr, IndexMask mask) { T *ptr_ = (T *)ptr; - mask.foreach_index([&](uint i) { ptr_[i].~T(); }); + mask.foreach_index([&](int64_t i) { ptr_[i].~T(); }); } template<typename T> void copy_to_initialized_cb(const void *src, void *dst) { *(T *)dst = *(T *)src; } -template<typename T> void copy_to_initialized_n_cb(const void *src, void *dst, uint n) +template<typename T> void copy_to_initialized_n_cb(const void *src, void *dst, int64_t n) { const T *src_ = (const T *)src; T *dst_ = (T *)dst; - for (uint i = 0; i < n; i++) { + for (int64_t i = 0; i < n; i++) { dst_[i] = src_[i]; } } @@ -625,14 +625,14 @@ void copy_to_initialized_indices_cb(const void *src, void *dst, IndexMask mask) const T *src_ = (const T *)src; T *dst_ = (T *)dst; - mask.foreach_index([&](uint i) { dst_[i] = src_[i]; }); + mask.foreach_index([&](int64_t i) { dst_[i] = src_[i]; }); } template<typename T> void copy_to_uninitialized_cb(const void *src, void *dst) { blender::uninitialized_copy_n((T *)src, 1, (T *)dst); } -template<typename T> void copy_to_uninitialized_n_cb(const void *src, void *dst, uint n) +template<typename T> void copy_to_uninitialized_n_cb(const void *src, void *dst, int64_t n) { blender::uninitialized_copy_n((T *)src, n, (T *)dst); } @@ -642,7 +642,7 @@ void copy_to_uninitialized_indices_cb(const void *src, void *dst, IndexMask mask const T *src_ = (const T *)src; T *dst_ = (T *)dst; - mask.foreach_index([&](uint i) { new (dst_ + i) T(src_[i]); }); + mask.foreach_index([&](int64_t i) { new (dst_ + i) T(src_[i]); }); } template<typename T> void relocate_to_initialized_cb(void *src, void *dst) @@ -653,7 +653,7 @@ template<typename T> void relocate_to_initialized_cb(void *src, void *dst) *dst_ = std::move(*src_); src_->~T(); } -template<typename T> void relocate_to_initialized_n_cb(void *src, void *dst, uint n) +template<typename T> void relocate_to_initialized_n_cb(void *src, void *dst, int64_t n) { blender::initialized_relocate_n((T *)src, n, (T *)dst); } @@ -662,7 +662,7 @@ template<typename T> void relocate_to_initialized_indices_cb(void *src, void *ds T *src_ = (T *)src; T *dst_ = (T *)dst; - mask.foreach_index([&](uint i) { + mask.foreach_index([&](int64_t i) { dst_[i] = std::move(src_[i]); src_[i].~T(); }); @@ -676,7 +676,7 @@ template<typename T> void relocate_to_uninitialized_cb(void *src, void *dst) new (dst_) T(std::move(*src_)); src_->~T(); } -template<typename T> void relocate_to_uninitialized_n_cb(void *src, void *dst, uint n) +template<typename T> void relocate_to_uninitialized_n_cb(void *src, void *dst, int64_t n) { blender::uninitialized_relocate_n((T *)src, n, (T *)dst); } @@ -686,18 +686,18 @@ void relocate_to_uninitialized_indices_cb(void *src, void *dst, IndexMask mask) T *src_ = (T *)src; T *dst_ = (T *)dst; - mask.foreach_index([&](uint i) { + mask.foreach_index([&](int64_t i) { new (dst_ + i) T(std::move(src_[i])); src_[i].~T(); }); } -template<typename T> void fill_initialized_cb(const void *value, void *dst, uint n) +template<typename T> void fill_initialized_cb(const void *value, void *dst, int64_t n) { const T &value_ = *(const T *)value; T *dst_ = (T *)dst; - for (uint i = 0; i < n; i++) { + for (int64_t i = 0; i < n; i++) { dst_[i] = value_; } } @@ -706,15 +706,15 @@ template<typename T> void fill_initialized_indices_cb(const void *value, void *d const T &value_ = *(const T *)value; T *dst_ = (T *)dst; - mask.foreach_index([&](uint i) { dst_[i] = value_; }); + mask.foreach_index([&](int64_t i) { dst_[i] = value_; }); } -template<typename T> void fill_uninitialized_cb(const void *value, void *dst, uint n) +template<typename T> void fill_uninitialized_cb(const void *value, void *dst, int64_t n) { const T &value_ = *(const T *)value; T *dst_ = (T *)dst; - for (uint i = 0; i < n; i++) { + for (int64_t i = 0; i < n; i++) { new (dst_ + i) T(value_); } } @@ -724,7 +724,7 @@ void fill_uninitialized_indices_cb(const void *value, void *dst, IndexMask mask) const T &value_ = *(const T *)value; T *dst_ = (T *)dst; - mask.foreach_index([&](uint i) { new (dst_ + i) T(value_); }); + mask.foreach_index([&](int64_t i) { new (dst_ + i) T(value_); }); } template<typename T> void debug_print_cb(const void *value, std::stringstream &ss) @@ -740,7 +740,7 @@ template<typename T> bool is_equal_cb(const void *a, const void *b) return a_ == b_; } -template<typename T> uint32_t hash_cb(const void *value) +template<typename T> uint64_t hash_cb(const void *value) { const T &value_ = *(const T *)value; return DefaultHash<T>{}(value_); diff --git a/source/blender/functions/FN_generic_vector_array.hh b/source/blender/functions/FN_generic_vector_array.hh index 2672484c184..ee67db000e5 100644 --- a/source/blender/functions/FN_generic_vector_array.hh +++ b/source/blender/functions/FN_generic_vector_array.hh @@ -42,10 +42,10 @@ template<typename T> class GVectorArrayRef; class GVectorArray : NonCopyable, NonMovable { private: const CPPType &type_; - uint element_size_; + int64_t element_size_; Array<void *, 1> starts_; - Array<uint, 1> lengths_; - Array<uint, 1> capacities_; + Array<int64_t, 1> lengths_; + Array<int64_t, 1> capacities_; LinearAllocator<> allocator_; template<typename T> friend class GVectorArrayRef; @@ -53,16 +53,16 @@ class GVectorArray : NonCopyable, NonMovable { public: GVectorArray() = delete; - GVectorArray(const CPPType &type, uint array_size) + GVectorArray(const CPPType &type, int64_t array_size) : type_(type), element_size_(type.size()), starts_(array_size), lengths_(array_size), capacities_(array_size) { - starts_.fill(nullptr); - lengths_.fill(0); - capacities_.fill(0); + starts_.as_mutable_span().fill(nullptr); + lengths_.as_mutable_span().fill(0); + capacities_.as_mutable_span().fill(0); } ~GVectorArray() @@ -71,7 +71,7 @@ class GVectorArray : NonCopyable, NonMovable { return; } - for (uint i : starts_.index_range()) { + for (int64_t i : starts_.index_range()) { type_.destruct_n(starts_[i], lengths_[i]); } } @@ -86,7 +86,7 @@ class GVectorArray : NonCopyable, NonMovable { return starts_.size() == 0; } - uint size() const + int64_t size() const { return starts_.size(); } @@ -101,14 +101,14 @@ class GVectorArray : NonCopyable, NonMovable { return starts_; } - Span<uint> lengths() const + Span<int64_t> lengths() const { return lengths_; } - void append(uint index, const void *src) + void append(int64_t index, const void *src) { - uint old_length = lengths_[index]; + int64_t old_length = lengths_[index]; if (old_length == capacities_[index]) { this->grow_at_least_one(index); } @@ -118,10 +118,10 @@ class GVectorArray : NonCopyable, NonMovable { lengths_[index]++; } - void extend(uint index, GVSpan span) + void extend(int64_t index, GVSpan span) { BLI_assert(type_ == span.type()); - for (uint i = 0; i < span.size(); i++) { + for (int64_t i = 0; i < span.size(); i++) { this->append(index, span[i]); } } @@ -130,12 +130,12 @@ class GVectorArray : NonCopyable, NonMovable { { BLI_assert(type_ == array_span.type()); BLI_assert(mask.min_array_size() <= array_span.size()); - for (uint i : mask) { + for (int64_t i : mask) { this->extend(i, array_span[i]); } } - GMutableSpan operator[](uint index) + GMutableSpan operator[](int64_t index) { BLI_assert(index < starts_.size()); return GMutableSpan(type_, starts_[index], lengths_[index]); @@ -146,10 +146,10 @@ class GVectorArray : NonCopyable, NonMovable { } private: - void grow_at_least_one(uint index) + void grow_at_least_one(int64_t index) { BLI_assert(lengths_[index] == capacities_[index]); - uint new_capacity = lengths_[index] * 2 + 1; + int64_t new_capacity = lengths_[index] * 2 + 1; void *new_buffer = allocator_.allocate(element_size_ * new_capacity, type_.alignment()); type_.relocate_to_uninitialized_n(starts_[index], new_buffer, lengths_[index]); @@ -169,28 +169,28 @@ template<typename T> class GVectorArrayRef { BLI_assert(vector_array.type_.is<T>()); } - void append(uint index, const T &value) + void append(int64_t index, const T &value) { vector_array_->append(index, &value); } - void extend(uint index, Span<T> values) + void extend(int64_t index, Span<T> values) { vector_array_->extend(index, values); } - void extend(uint index, VSpan<T> values) + void extend(int64_t index, VSpan<T> values) { vector_array_->extend(index, GVSpan(values)); } - MutableSpan<T> operator[](uint index) + MutableSpan<T> operator[](int64_t index) { BLI_assert(index < vector_array_->starts_.size()); return MutableSpan<T>((T *)vector_array_->starts_[index], vector_array_->lengths_[index]); } - uint size() const + int64_t size() const { return vector_array_->size(); } diff --git a/source/blender/functions/FN_multi_function.hh b/source/blender/functions/FN_multi_function.hh index 35f144368ac..77ab2749377 100644 --- a/source/blender/functions/FN_multi_function.hh +++ b/source/blender/functions/FN_multi_function.hh @@ -63,7 +63,7 @@ class MultiFunction { virtual void call(IndexMask mask, MFParams params, MFContext context) const = 0; - virtual uint32_t hash() const + virtual uint64_t hash() const { return DefaultHash<const MultiFunction *>{}(this); } @@ -73,7 +73,7 @@ class MultiFunction { return false; } - uint param_amount() const + int param_amount() const { return signature_.param_types.size(); } @@ -83,12 +83,12 @@ class MultiFunction { return signature_.param_types.index_range(); } - MFParamType param_type(uint param_index) const + MFParamType param_type(int param_index) const { return signature_.param_types[param_index]; } - StringRefNull param_name(uint param_index) const + StringRefNull param_name(int param_index) const { return signature_.param_names[param_index]; } @@ -111,7 +111,7 @@ class MultiFunction { } }; -inline MFParamsBuilder::MFParamsBuilder(const class MultiFunction &fn, uint min_array_size) +inline MFParamsBuilder::MFParamsBuilder(const class MultiFunction &fn, int64_t min_array_size) : MFParamsBuilder(fn.signature(), min_array_size) { } diff --git a/source/blender/functions/FN_multi_function_builder.hh b/source/blender/functions/FN_multi_function_builder.hh index c2c95f7c355..95e216558e7 100644 --- a/source/blender/functions/FN_multi_function_builder.hh +++ b/source/blender/functions/FN_multi_function_builder.hh @@ -59,7 +59,7 @@ template<typename In1, typename Out1> class CustomMF_SI_SO : public MultiFunctio template<typename ElementFuncT> static FunctionT create_function(ElementFuncT element_fn) { return [=](IndexMask mask, VSpan<In1> in1, MutableSpan<Out1> out1) { - mask.foreach_index([&](uint i) { new ((void *)&out1[i]) Out1(element_fn(in1[i])); }); + mask.foreach_index([&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i])); }); }; } @@ -101,7 +101,7 @@ class CustomMF_SI_SI_SO : public MultiFunction { template<typename ElementFuncT> static FunctionT create_function(ElementFuncT element_fn) { return [=](IndexMask mask, VSpan<In1> in1, VSpan<In2> in2, MutableSpan<Out1> out1) { - mask.foreach_index([&](uint i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i])); }); + mask.foreach_index([&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i])); }); }; } @@ -152,7 +152,7 @@ class CustomMF_SI_SI_SI_SO : public MultiFunction { VSpan<In3> in3, MutableSpan<Out1> out1) { mask.foreach_index( - [&](uint i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i], in3[i])); }); + [&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i], in3[i])); }); }; } @@ -191,7 +191,7 @@ template<typename Mut1> class CustomMF_SM : public MultiFunction { template<typename ElementFuncT> static FunctionT create_function(ElementFuncT element_fn) { return [=](IndexMask mask, MutableSpan<Mut1> mut1) { - mask.foreach_index([&](uint i) { element_fn(mut1[i]); }); + mask.foreach_index([&](int i) { element_fn(mut1[i]); }); }; } @@ -220,7 +220,7 @@ template<typename From, typename To> class CustomMF_Convert : public MultiFuncti VSpan<From> inputs = params.readonly_single_input<From>(0); MutableSpan<To> outputs = params.uninitialized_single_output<To>(1); - for (uint i : mask) { + for (int64_t i : mask) { new ((void *)&outputs[i]) To(inputs[i]); } } @@ -240,7 +240,7 @@ class CustomMF_GenericConstant : public MultiFunction { public: CustomMF_GenericConstant(const CPPType &type, const void *value); void call(IndexMask mask, MFParams params, MFContext context) const override; - uint32_t hash() const override; + uint64_t hash() const override; bool equals(const MultiFunction &other) const override; }; @@ -276,10 +276,10 @@ template<typename T> class CustomMF_Constant : public MultiFunction { void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override { MutableSpan<T> output = params.uninitialized_single_output<T>(0); - mask.foreach_index([&](uint i) { new (&output[i]) T(value_); }); + mask.foreach_index([&](int i) { new (&output[i]) T(value_); }); } - uint32_t hash() const override + uint64_t hash() const override { return DefaultHash<T>{}(value_); } @@ -304,7 +304,7 @@ template<typename T> class CustomMF_Constant : public MultiFunction { class CustomMF_DefaultOutput : public MultiFunction { private: - uint output_amount_; + int output_amount_; public: CustomMF_DefaultOutput(StringRef name, diff --git a/source/blender/functions/FN_multi_function_data_type.hh b/source/blender/functions/FN_multi_function_data_type.hh index 57aea046006..23a1c0e5680 100644 --- a/source/blender/functions/FN_multi_function_data_type.hh +++ b/source/blender/functions/FN_multi_function_data_type.hh @@ -109,9 +109,9 @@ class MFDataType { return ""; } - uint hash() const + uint64_t hash() const { - return DefaultHash<CPPType>{}(*type_) + (uint32_t)category_; + return DefaultHash<CPPType>{}(*type_) + (uint64_t)category_; } }; diff --git a/source/blender/functions/FN_multi_function_network.hh b/source/blender/functions/FN_multi_function_network.hh index 91eb5bb65dc..f6d6c7417e7 100644 --- a/source/blender/functions/FN_multi_function_network.hh +++ b/source/blender/functions/FN_multi_function_network.hh @@ -62,14 +62,14 @@ class MFNode : NonCopyable, NonMovable { Span<MFInputSocket *> inputs_; Span<MFOutputSocket *> outputs_; bool is_dummy_; - uint id_; + int id_; friend MFNetwork; public: StringRefNull name() const; - uint id() const; + int id() const; MFNetwork &network(); const MFNetwork &network() const; @@ -83,11 +83,11 @@ class MFNode : NonCopyable, NonMovable { MFFunctionNode &as_function(); const MFFunctionNode &as_function() const; - MFInputSocket &input(uint index); - const MFInputSocket &input(uint index) const; + MFInputSocket &input(int index); + const MFInputSocket &input(int index) const; - MFOutputSocket &output(uint index); - const MFOutputSocket &output(uint index) const; + MFOutputSocket &output(int index); + const MFOutputSocket &output(int index) const; Span<MFInputSocket *> inputs(); Span<const MFInputSocket *> inputs() const; @@ -104,8 +104,8 @@ class MFNode : NonCopyable, NonMovable { class MFFunctionNode : public MFNode { private: const MultiFunction *function_; - Span<uint> input_param_indices_; - Span<uint> output_param_indices_; + Span<int> input_param_indices_; + Span<int> output_param_indices_; friend MFNetwork; @@ -114,8 +114,8 @@ class MFFunctionNode : public MFNode { const MultiFunction &function() const; - const MFInputSocket &input_for_param(uint param_index) const; - const MFOutputSocket &output_for_param(uint param_index) const; + const MFInputSocket &input_for_param(int param_index) const; + const MFOutputSocket &output_for_param(int param_index) const; }; class MFDummyNode : public MFNode { @@ -137,9 +137,9 @@ class MFSocket : NonCopyable, NonMovable { protected: MFNode *node_; bool is_output_; - uint index_; + int index_; MFDataType data_type_; - uint id_; + int id_; StringRefNull name_; friend MFNetwork; @@ -147,8 +147,8 @@ class MFSocket : NonCopyable, NonMovable { public: StringRefNull name() const; - uint id() const; - uint index() const; + int id() const; + int index() const; const MFDataType &data_type() const; @@ -217,17 +217,17 @@ class MFNetwork : NonCopyable, NonMovable { void remove(MFNode &node); void remove(Span<MFNode *> nodes); - uint socket_id_amount() const; - uint node_id_amount() const; + int socket_id_amount() const; + int node_id_amount() const; Span<MFDummyNode *> dummy_nodes(); Span<MFFunctionNode *> function_nodes(); - MFNode *node_or_null_by_id(uint id); - const MFNode *node_or_null_by_id(uint id) const; + MFNode *node_or_null_by_id(int id); + const MFNode *node_or_null_by_id(int id) const; - MFSocket *socket_or_null_by_id(uint id); - const MFSocket *socket_or_null_by_id(uint id) const; + MFSocket *socket_or_null_by_id(int id); + const MFSocket *socket_or_null_by_id(int id) const; void find_dependencies(Span<const MFInputSocket *> sockets, VectorSet<const MFOutputSocket *> &r_dummy_sockets, @@ -252,7 +252,7 @@ inline StringRefNull MFNode::name() const } } -inline uint MFNode::id() const +inline int MFNode::id() const { return id_; } @@ -301,22 +301,22 @@ inline const MFFunctionNode &MFNode::as_function() const return *(const MFFunctionNode *)this; } -inline MFInputSocket &MFNode::input(uint index) +inline MFInputSocket &MFNode::input(int index) { return *inputs_[index]; } -inline const MFInputSocket &MFNode::input(uint index) const +inline const MFInputSocket &MFNode::input(int index) const { return *inputs_[index]; } -inline MFOutputSocket &MFNode::output(uint index) +inline MFOutputSocket &MFNode::output(int index) { return *outputs_[index]; } -inline const MFOutputSocket &MFNode::output(uint index) const +inline const MFOutputSocket &MFNode::output(int index) const { return *outputs_[index]; } @@ -365,12 +365,12 @@ inline const MultiFunction &MFFunctionNode::function() const return *function_; } -inline const MFInputSocket &MFFunctionNode::input_for_param(uint param_index) const +inline const MFInputSocket &MFFunctionNode::input_for_param(int param_index) const { return this->input(input_param_indices_.first_index(param_index)); } -inline const MFOutputSocket &MFFunctionNode::output_for_param(uint param_index) const +inline const MFOutputSocket &MFFunctionNode::output_for_param(int param_index) const { return this->output(output_param_indices_.first_index(param_index)); } @@ -403,12 +403,12 @@ inline StringRefNull MFSocket::name() const return name_; } -inline uint MFSocket::id() const +inline int MFSocket::id() const { return id_; } -inline uint MFSocket::index() const +inline int MFSocket::index() const { return index_; } @@ -504,32 +504,32 @@ inline Span<MFFunctionNode *> MFNetwork::function_nodes() return function_nodes_; } -inline MFNode *MFNetwork::node_or_null_by_id(uint id) +inline MFNode *MFNetwork::node_or_null_by_id(int id) { return node_or_null_by_id_[id]; } -inline const MFNode *MFNetwork::node_or_null_by_id(uint id) const +inline const MFNode *MFNetwork::node_or_null_by_id(int id) const { return node_or_null_by_id_[id]; } -inline MFSocket *MFNetwork::socket_or_null_by_id(uint id) +inline MFSocket *MFNetwork::socket_or_null_by_id(int id) { return socket_or_null_by_id_[id]; } -inline const MFSocket *MFNetwork::socket_or_null_by_id(uint id) const +inline const MFSocket *MFNetwork::socket_or_null_by_id(int id) const { return socket_or_null_by_id_[id]; } -inline uint MFNetwork::socket_id_amount() const +inline int MFNetwork::socket_id_amount() const { return socket_or_null_by_id_.size(); } -inline uint MFNetwork::node_id_amount() const +inline int MFNetwork::node_id_amount() const { return node_or_null_by_id_.size(); } diff --git a/source/blender/functions/FN_multi_function_params.hh b/source/blender/functions/FN_multi_function_params.hh index e6683693a0a..9cce8bb7401 100644 --- a/source/blender/functions/FN_multi_function_params.hh +++ b/source/blender/functions/FN_multi_function_params.hh @@ -34,7 +34,7 @@ namespace blender::fn { class MFParamsBuilder { private: const MFSignature *signature_; - uint min_array_size_; + int64_t min_array_size_; Vector<GVSpan> virtual_spans_; Vector<GMutableSpan> mutable_spans_; Vector<GVArraySpan> virtual_array_spans_; @@ -43,12 +43,12 @@ class MFParamsBuilder { friend class MFParams; public: - MFParamsBuilder(const MFSignature &signature, uint min_array_size) + MFParamsBuilder(const MFSignature &signature, int64_t min_array_size) : signature_(&signature), min_array_size_(min_array_size) { } - MFParamsBuilder(const class MultiFunction &fn, uint min_array_size); + MFParamsBuilder(const class MultiFunction &fn, int64_t min_array_size); template<typename T> void add_readonly_single_input(const T *value) { @@ -96,21 +96,21 @@ class MFParamsBuilder { vector_arrays_.append(&vector_array); } - GMutableSpan computed_array(uint param_index) + GMutableSpan computed_array(int param_index) { BLI_assert(ELEM(signature_->param_types[param_index].category(), MFParamType::SingleOutput, MFParamType::SingleMutable)); - uint data_index = signature_->data_index(param_index); + int data_index = signature_->data_index(param_index); return mutable_spans_[data_index]; } - GVectorArray &computed_vector_array(uint param_index) + GVectorArray &computed_vector_array(int param_index) { BLI_assert(ELEM(signature_->param_types[param_index].category(), MFParamType::VectorOutput, MFParamType::VectorMutable)); - uint data_index = signature_->data_index(param_index); + int data_index = signature_->data_index(param_index); return *vector_arrays_[data_index]; } @@ -119,13 +119,13 @@ class MFParamsBuilder { { UNUSED_VARS_NDEBUG(param_type); #ifdef DEBUG - uint param_index = this->current_param_index(); + int param_index = this->current_param_index(); MFParamType expected_type = signature_->param_types[param_index]; BLI_assert(expected_type == param_type); #endif } - uint current_param_index() const + int current_param_index() const { return virtual_spans_.size() + mutable_spans_.size() + virtual_array_spans_.size() + vector_arrays_.size(); @@ -141,75 +141,75 @@ class MFParams { { } - template<typename T> VSpan<T> readonly_single_input(uint param_index, StringRef name = "") + template<typename T> VSpan<T> readonly_single_input(int param_index, StringRef name = "") { return this->readonly_single_input(param_index, name).typed<T>(); } - GVSpan readonly_single_input(uint param_index, StringRef name = "") + GVSpan readonly_single_input(int param_index, StringRef name = "") { this->assert_correct_param(param_index, name, MFParamType::SingleInput); - uint data_index = builder_->signature_->data_index(param_index); + int data_index = builder_->signature_->data_index(param_index); return builder_->virtual_spans_[data_index]; } template<typename T> - MutableSpan<T> uninitialized_single_output(uint param_index, StringRef name = "") + MutableSpan<T> uninitialized_single_output(int param_index, StringRef name = "") { return this->uninitialized_single_output(param_index, name).typed<T>(); } - GMutableSpan uninitialized_single_output(uint param_index, StringRef name = "") + GMutableSpan uninitialized_single_output(int param_index, StringRef name = "") { this->assert_correct_param(param_index, name, MFParamType::SingleOutput); - uint data_index = builder_->signature_->data_index(param_index); + int data_index = builder_->signature_->data_index(param_index); return builder_->mutable_spans_[data_index]; } - template<typename T> VArraySpan<T> readonly_vector_input(uint param_index, StringRef name = "") + template<typename T> VArraySpan<T> readonly_vector_input(int param_index, StringRef name = "") { return this->readonly_vector_input(param_index, name).typed<T>(); } - GVArraySpan readonly_vector_input(uint param_index, StringRef name = "") + GVArraySpan readonly_vector_input(int param_index, StringRef name = "") { this->assert_correct_param(param_index, name, MFParamType::VectorInput); - uint data_index = builder_->signature_->data_index(param_index); + int data_index = builder_->signature_->data_index(param_index); return builder_->virtual_array_spans_[data_index]; } - template<typename T> GVectorArrayRef<T> vector_output(uint param_index, StringRef name = "") + template<typename T> GVectorArrayRef<T> vector_output(int param_index, StringRef name = "") { return this->vector_output(param_index, name).typed<T>(); } - GVectorArray &vector_output(uint param_index, StringRef name = "") + GVectorArray &vector_output(int param_index, StringRef name = "") { this->assert_correct_param(param_index, name, MFParamType::VectorOutput); - uint data_index = builder_->signature_->data_index(param_index); + int data_index = builder_->signature_->data_index(param_index); return *builder_->vector_arrays_[data_index]; } - template<typename T> MutableSpan<T> single_mutable(uint param_index, StringRef name = "") + template<typename T> MutableSpan<T> single_mutable(int param_index, StringRef name = "") { return this->single_mutable(param_index, name).typed<T>(); } - GMutableSpan single_mutable(uint param_index, StringRef name = "") + GMutableSpan single_mutable(int param_index, StringRef name = "") { this->assert_correct_param(param_index, name, MFParamType::SingleMutable); - uint data_index = builder_->signature_->data_index(param_index); + int data_index = builder_->signature_->data_index(param_index); return builder_->mutable_spans_[data_index]; } - template<typename T> GVectorArrayRef<T> vector_mutable(uint param_index, StringRef name = "") + template<typename T> GVectorArrayRef<T> vector_mutable(int param_index, StringRef name = "") { return this->vector_mutable(param_index, name).typed<T>(); } - GVectorArray &vector_mutable(uint param_index, StringRef name = "") + GVectorArray &vector_mutable(int param_index, StringRef name = "") { this->assert_correct_param(param_index, name, MFParamType::VectorMutable); - uint data_index = builder_->signature_->data_index(param_index); + int data_index = builder_->signature_->data_index(param_index); return *builder_->vector_arrays_[data_index]; } private: - void assert_correct_param(uint param_index, StringRef name, MFParamType param_type) + void assert_correct_param(int param_index, StringRef name, MFParamType param_type) { UNUSED_VARS_NDEBUG(param_index, name, param_type); #ifdef DEBUG @@ -220,7 +220,7 @@ class MFParams { #endif } - void assert_correct_param(uint param_index, StringRef name, MFParamType::Category category) + void assert_correct_param(int param_index, StringRef name, MFParamType::Category category) { UNUSED_VARS_NDEBUG(param_index, name, category); #ifdef DEBUG diff --git a/source/blender/functions/FN_multi_function_signature.hh b/source/blender/functions/FN_multi_function_signature.hh index e2cf783753e..4ccceb39503 100644 --- a/source/blender/functions/FN_multi_function_signature.hh +++ b/source/blender/functions/FN_multi_function_signature.hh @@ -35,9 +35,9 @@ struct MFSignature { /* Use RawAllocator so that a MultiFunction can have static storage duration. */ Vector<std::string, 4, RawAllocator> param_names; Vector<MFParamType, 4, RawAllocator> param_types; - Vector<uint, 4, RawAllocator> param_data_indices; + Vector<int, 4, RawAllocator> param_data_indices; - uint data_index(uint param_index) const + int data_index(int param_index) const { return param_data_indices[param_index]; } @@ -46,10 +46,10 @@ struct MFSignature { class MFSignatureBuilder { private: MFSignature &data_; - uint span_count_ = 0; - uint virtual_span_count_ = 0; - uint virtual_array_span_count_ = 0; - uint vector_array_count_ = 0; + int span_count_ = 0; + int virtual_span_count_ = 0; + int virtual_array_span_count_ = 0; + int vector_array_count_ = 0; public: MFSignatureBuilder(MFSignature &data) : data_(data) diff --git a/source/blender/functions/FN_spans.hh b/source/blender/functions/FN_spans.hh index c8c98d66628..d8b381199cc 100644 --- a/source/blender/functions/FN_spans.hh +++ b/source/blender/functions/FN_spans.hh @@ -52,12 +52,13 @@ class GSpan { private: const CPPType *type_; const void *buffer_; - uint size_; + int64_t size_; public: - GSpan(const CPPType &type, const void *buffer, uint size) + GSpan(const CPPType &type, const void *buffer, int64_t size) : type_(&type), buffer_(buffer), size_(size) { + BLI_assert(size >= 0); BLI_assert(buffer != nullptr || size == 0); BLI_assert(type.pointer_has_valid_alignment(buffer)); } @@ -81,7 +82,7 @@ class GSpan { return size_ == 0; } - uint size() const + int64_t size() const { return size_; } @@ -91,7 +92,7 @@ class GSpan { return buffer_; } - const void *operator[](uint index) const + const void *operator[](int64_t index) const { BLI_assert(index < size_); return POINTER_OFFSET(buffer_, type_->size() * index); @@ -112,12 +113,13 @@ class GMutableSpan { private: const CPPType *type_; void *buffer_; - uint size_; + int64_t size_; public: - GMutableSpan(const CPPType &type, void *buffer, uint size) + GMutableSpan(const CPPType &type, void *buffer, int64_t size) : type_(&type), buffer_(buffer), size_(size) { + BLI_assert(size >= 0); BLI_assert(buffer != nullptr || size == 0); BLI_assert(type.pointer_has_valid_alignment(buffer)); } @@ -147,7 +149,7 @@ class GMutableSpan { return size_ == 0; } - uint size() const + int64_t size() const { return size_; } @@ -157,7 +159,7 @@ class GMutableSpan { return buffer_; } - void *operator[](uint index) + void *operator[](int64_t index) { BLI_assert(index < size_); return POINTER_OFFSET(buffer_, type_->size() * index); @@ -178,7 +180,7 @@ enum class VSpanCategory { template<typename T> struct VSpanBase { protected: - uint virtual_size_; + int64_t virtual_size_; VSpanCategory category_; union { struct { @@ -212,7 +214,7 @@ template<typename T> struct VSpanBase { return this->virtual_size_ == 0; } - uint size() const + int64_t size() const { return this->virtual_size_; } @@ -259,7 +261,7 @@ template<typename T> class VSpan : public VSpanBase<T> { this->data_.full_pointer_array.data = values.begin(); } - static VSpan FromSingle(const T *value, uint virtual_size) + static VSpan FromSingle(const T *value, int64_t virtual_size) { VSpan ref; ref.virtual_size_ = virtual_size; @@ -268,8 +270,9 @@ template<typename T> class VSpan : public VSpanBase<T> { return ref; } - const T &operator[](uint index) const + const T &operator[](int64_t index) const { + BLI_assert(index >= 0); BLI_assert(index < this->virtual_size_); switch (this->category_) { case VSpanCategory::Single: @@ -329,7 +332,7 @@ class GVSpan : public VSpanBase<void> { { } - static GVSpan FromSingle(const CPPType &type, const void *value, uint virtual_size) + static GVSpan FromSingle(const CPPType &type, const void *value, int64_t virtual_size) { GVSpan ref; ref.type_ = &type; @@ -341,7 +344,7 @@ class GVSpan : public VSpanBase<void> { static GVSpan FromSingleWithMaxSize(const CPPType &type, const void *value) { - return GVSpan::FromSingle(type, value, UINT32_MAX); + return GVSpan::FromSingle(type, value, INT64_MAX); } static GVSpan FromDefault(const CPPType &type) @@ -349,7 +352,7 @@ class GVSpan : public VSpanBase<void> { return GVSpan::FromSingleWithMaxSize(type, type.default_value()); } - static GVSpan FromFullPointerArray(const CPPType &type, const void *const *values, uint size) + static GVSpan FromFullPointerArray(const CPPType &type, const void *const *values, int64_t size) { GVSpan ref; ref.type_ = &type; @@ -364,8 +367,9 @@ class GVSpan : public VSpanBase<void> { return *this->type_; } - const void *operator[](uint index) const + const void *operator[](int64_t index) const { + BLI_assert(index >= 0); BLI_assert(index < this->virtual_size_); switch (this->category_) { case VSpanCategory::Single: @@ -400,8 +404,8 @@ class GVSpan : public VSpanBase<void> { { BLI_assert(this->size() >= mask.min_array_size()); - uint element_size = type_->size(); - for (uint i : mask) { + int64_t element_size = type_->size(); + for (int64_t i : mask) { type_->copy_to_uninitialized((*this)[i], POINTER_OFFSET(dst, element_size * i)); } } diff --git a/source/blender/functions/intern/attributes_ref.cc b/source/blender/functions/intern/attributes_ref.cc index f61a9165c47..7bfcc69671a 100644 --- a/source/blender/functions/intern/attributes_ref.cc +++ b/source/blender/functions/intern/attributes_ref.cc @@ -20,7 +20,7 @@ namespace blender::fn { AttributesInfoBuilder::~AttributesInfoBuilder() { - for (uint i : defaults_.index_range()) { + for (int i : defaults_.index_range()) { types_[i]->destruct(defaults_[i]); } } @@ -45,7 +45,7 @@ void AttributesInfoBuilder::add(StringRef name, const CPPType &type, const void AttributesInfo::AttributesInfo(const AttributesInfoBuilder &builder) { - for (uint i : builder.types_.index_range()) { + for (int i : builder.types_.index_range()) { StringRefNull name = allocator_.copy_string(builder.names_[i]); const CPPType &type = *builder.types_[i]; const void *default_value = builder.defaults_[i]; @@ -62,7 +62,7 @@ AttributesInfo::AttributesInfo(const AttributesInfoBuilder &builder) AttributesInfo::~AttributesInfo() { - for (uint i : defaults_.index_range()) { + for (int i : defaults_.index_range()) { type_by_index_[i]->destruct(defaults_[i]); } } diff --git a/source/blender/functions/intern/multi_function_builder.cc b/source/blender/functions/intern/multi_function_builder.cc index 7797c19d563..06084247e66 100644 --- a/source/blender/functions/intern/multi_function_builder.cc +++ b/source/blender/functions/intern/multi_function_builder.cc @@ -37,7 +37,7 @@ void CustomMF_GenericConstant::call(IndexMask mask, type_.fill_uninitialized_indices(value_, output.buffer(), mask); } -uint CustomMF_GenericConstant::hash() const +uint64_t CustomMF_GenericConstant::hash() const { return type_.hash(value_); } @@ -58,8 +58,8 @@ static std::string gspan_to_string(GSpan array) { std::stringstream ss; ss << "["; - uint max_amount = 5; - for (uint i : IndexRange(std::min(max_amount, array.size()))) { + const int64_t max_amount = 5; + for (int64_t i : IndexRange(std::min(max_amount, array.size()))) { array.type().debug_print(array[i], ss); ss << ", "; } @@ -82,7 +82,7 @@ void CustomMF_GenericConstantArray::call(IndexMask mask, MFContext UNUSED(context)) const { GVectorArray &vectors = params.vector_output(0); - for (uint i : mask) { + for (int64_t i : mask) { vectors.extend(i, array_); } } @@ -102,7 +102,7 @@ CustomMF_DefaultOutput::CustomMF_DefaultOutput(StringRef name, } void CustomMF_DefaultOutput::call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const { - for (uint param_index : this->param_indices()) { + for (int param_index : this->param_indices()) { MFParamType param_type = this->param_type(param_index); if (!param_type.is_output()) { continue; diff --git a/source/blender/functions/intern/multi_function_network.cc b/source/blender/functions/intern/multi_function_network.cc index 1d3d3a8b5f2..cd3c38dd09f 100644 --- a/source/blender/functions/intern/multi_function_network.cc +++ b/source/blender/functions/intern/multi_function_network.cc @@ -50,9 +50,9 @@ void MFNode::destruct_sockets() */ MFFunctionNode &MFNetwork::add_function(const MultiFunction &function) { - Vector<uint, 16> input_param_indices, output_param_indices; + Vector<int, 16> input_param_indices, output_param_indices; - for (uint param_index : function.param_indices()) { + for (int param_index : function.param_indices()) { switch (function.param_type(param_index).interface_type()) { case MFParamType::Input: { input_param_indices.append(param_index); @@ -77,16 +77,16 @@ MFFunctionNode &MFNetwork::add_function(const MultiFunction &function) node.is_dummy_ = false; node.id_ = node_or_null_by_id_.append_and_get_index(&node); node.function_ = &function; - node.input_param_indices_ = allocator_.construct_array_copy<uint>(input_param_indices); - node.output_param_indices_ = allocator_.construct_array_copy<uint>(output_param_indices); + node.input_param_indices_ = allocator_.construct_array_copy<int>(input_param_indices); + node.output_param_indices_ = allocator_.construct_array_copy<int>(output_param_indices); node.inputs_ = allocator_.construct_elements_and_pointer_array<MFInputSocket>( input_param_indices.size()); node.outputs_ = allocator_.construct_elements_and_pointer_array<MFOutputSocket>( output_param_indices.size()); - for (uint i : input_param_indices.index_range()) { - uint param_index = input_param_indices[i]; + for (int i : input_param_indices.index_range()) { + int param_index = input_param_indices[i]; MFParamType param = function.param_type(param_index); BLI_assert(param.is_input_or_mutable()); @@ -100,8 +100,8 @@ MFFunctionNode &MFNetwork::add_function(const MultiFunction &function) socket.id_ = socket_or_null_by_id_.append_and_get_index(&socket); } - for (uint i : output_param_indices.index_range()) { - uint param_index = output_param_indices[i]; + for (int i : output_param_indices.index_range()) { + int param_index = output_param_indices[i]; MFParamType param = function.param_type(param_index); BLI_assert(param.is_output_or_mutable()); @@ -145,7 +145,7 @@ MFDummyNode &MFNetwork::add_dummy(StringRef name, node.input_names_ = allocator_.allocate_array<StringRefNull>(input_types.size()); node.output_names_ = allocator_.allocate_array<StringRefNull>(output_types.size()); - for (uint i : input_types.index_range()) { + for (int i : input_types.index_range()) { MFInputSocket &socket = *node.inputs_[i]; socket.data_type_ = input_types[i]; socket.node_ = &node; @@ -156,7 +156,7 @@ MFDummyNode &MFNetwork::add_dummy(StringRef name, node.input_names_[i] = socket.name_; } - for (uint i : output_types.index_range()) { + for (int i : output_types.index_range()) { MFOutputSocket &socket = *node.outputs_[i]; socket.data_type_ = output_types[i]; socket.node_ = &node; diff --git a/source/blender/functions/intern/multi_function_network_evaluation.cc b/source/blender/functions/intern/multi_function_network_evaluation.cc index b59cbc6a1a2..a7e1a2f42af 100644 --- a/source/blender/functions/intern/multi_function_network_evaluation.cc +++ b/source/blender/functions/intern/multi_function_network_evaluation.cc @@ -55,10 +55,10 @@ class MFNetworkEvaluationStorage { LinearAllocator<> allocator_; IndexMask mask_; Array<Value *> value_per_output_id_; - uint min_array_size_; + int64_t min_array_size_; public: - MFNetworkEvaluationStorage(IndexMask mask, uint socket_id_amount); + MFNetworkEvaluationStorage(IndexMask mask, int socket_id_amount); ~MFNetworkEvaluationStorage(); /* Add the values that have been provided by the caller of the multi-function network. */ @@ -155,8 +155,8 @@ void MFNetworkEvaluator::call(IndexMask mask, MFParams params, MFContext context BLI_NOINLINE void MFNetworkEvaluator::copy_inputs_to_storage(MFParams params, Storage &storage) const { - for (uint input_index : inputs_.index_range()) { - uint param_index = input_index + 0; + for (int input_index : inputs_.index_range()) { + int param_index = input_index + 0; const MFOutputSocket &socket = *inputs_[input_index]; switch (socket.data_type().category()) { case MFDataType::Single: { @@ -178,8 +178,8 @@ BLI_NOINLINE void MFNetworkEvaluator::copy_outputs_to_storage( Storage &storage, Vector<const MFInputSocket *> &outputs_to_initialize_in_the_end) const { - for (uint output_index : outputs_.index_range()) { - uint param_index = output_index + inputs_.size(); + for (int output_index : outputs_.index_range()) { + int param_index = output_index + inputs_.size(); const MFInputSocket &socket = *outputs_[output_index]; const MFOutputSocket &origin = *socket.origin(); @@ -263,7 +263,7 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex * function only on a single element. This can avoid many duplicate computations. */ MFParamsBuilder params{function, 1}; - for (uint param_index : function.param_indices()) { + for (int param_index : function.param_indices()) { MFParamType param_type = function.param_type(param_index); switch (param_type.category()) { case MFParamType::SingleInput: { @@ -312,7 +312,7 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex else { MFParamsBuilder params{function, storage.mask().min_array_size()}; - for (uint param_index : function.param_indices()) { + for (int param_index : function.param_indices()) { MFParamType param_type = function.param_type(param_index); switch (param_type.category()) { case MFParamType::SingleInput: { @@ -384,7 +384,7 @@ BLI_NOINLINE void MFNetworkEvaluator::initialize_remaining_outputs( MFParams params, Storage &storage, Span<const MFInputSocket *> remaining_outputs) const { for (const MFInputSocket *socket : remaining_outputs) { - uint param_index = inputs_.size() + outputs_.first_index_of(socket); + int param_index = inputs_.size() + outputs_.first_index_of(socket); switch (socket->data_type().category()) { case MFDataType::Single: { @@ -506,7 +506,7 @@ struct OwnVectorValue : public Value { /** \name Storage methods * \{ */ -MFNetworkEvaluationStorage::MFNetworkEvaluationStorage(IndexMask mask, uint socket_id_amount) +MFNetworkEvaluationStorage::MFNetworkEvaluationStorage(IndexMask mask, int socket_id_amount) : mask_(mask), value_per_output_id_(socket_id_amount, nullptr), min_array_size_(mask.min_array_size()) diff --git a/source/blender/functions/intern/multi_function_network_optimization.cc b/source/blender/functions/intern/multi_function_network_optimization.cc index 849b24a318f..e76b2f51a15 100644 --- a/source/blender/functions/intern/multi_function_network_optimization.cc +++ b/source/blender/functions/intern/multi_function_network_optimization.cc @@ -107,7 +107,7 @@ static Vector<MFNode *> find_nodes_based_on_mask(MFNetwork &network, bool mask_value) { Vector<MFNode *> nodes; - for (uint id : id_mask.index_range()) { + for (int id : id_mask.index_range()) { if (id_mask[id] == mask_value) { MFNode *node = network.node_or_null_by_id(id); if (node != nullptr) { @@ -212,7 +212,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn, MFParamsBuilder ¶ms, ResourceCollector &resources) { - for (uint param_index : network_fn.param_indices()) { + for (int param_index : network_fn.param_indices()) { MFParamType param_type = network_fn.param_type(param_index); MFDataType data_type = param_type.data_type(); @@ -244,7 +244,7 @@ static Array<MFOutputSocket *> add_constant_folded_sockets(const MultiFunction & { Array<MFOutputSocket *> folded_sockets{network_fn.param_indices().size(), nullptr}; - for (uint param_index : network_fn.param_indices()) { + for (int param_index : network_fn.param_indices()) { MFParamType param_type = network_fn.param_type(param_index); MFDataType data_type = param_type.data_type(); @@ -302,7 +302,7 @@ void constant_folding(MFNetwork &network, ResourceCollector &resources) Array<MFOutputSocket *> folded_sockets = compute_constant_sockets_and_add_folded_nodes( network, inputs_to_fold, resources); - for (uint i : inputs_to_fold.index_range()) { + for (int i : inputs_to_fold.index_range()) { MFOutputSocket &original_socket = *inputs_to_fold[i]->origin(); network.relink(original_socket, *folded_sockets[i]); } @@ -317,12 +317,12 @@ void constant_folding(MFNetwork &network, ResourceCollector &resources) * * \{ */ -static uint32_t compute_node_hash(MFFunctionNode &node, RNG *rng, Span<uint32_t> node_hashes) +static uint64_t compute_node_hash(MFFunctionNode &node, RNG *rng, Span<uint64_t> node_hashes) { - uint32_t combined_inputs_hash = 394659347u; + uint64_t combined_inputs_hash = 394659347u; for (MFInputSocket *input_socket : node.inputs()) { MFOutputSocket *origin_socket = input_socket->origin(); - uint32_t input_hash; + uint64_t input_hash; if (origin_socket == nullptr) { input_hash = BLI_rng_get_uint(rng); } @@ -333,8 +333,8 @@ static uint32_t compute_node_hash(MFFunctionNode &node, RNG *rng, Span<uint32_t> combined_inputs_hash = BLI_ghashutil_combine_hash(combined_inputs_hash, input_hash); } - uint32_t function_hash = node.function().hash(); - uint32_t node_hash = BLI_ghashutil_combine_hash(combined_inputs_hash, function_hash); + uint64_t function_hash = node.function().hash(); + uint64_t node_hash = BLI_ghashutil_combine_hash(combined_inputs_hash, function_hash); return node_hash; } @@ -342,15 +342,15 @@ static uint32_t compute_node_hash(MFFunctionNode &node, RNG *rng, Span<uint32_t> * Produces a hash for every node. Two nodes with the same hash should have a high probability of * outputting the same values. */ -static Array<uint32_t> compute_node_hashes(MFNetwork &network) +static Array<uint64_t> compute_node_hashes(MFNetwork &network) { RNG *rng = BLI_rng_new(0); - Array<uint32_t> node_hashes(network.node_id_amount()); + Array<uint64_t> node_hashes(network.node_id_amount()); Array<bool> node_is_hashed(network.node_id_amount(), false); /* No dummy nodes are not assumed to output the same values. */ for (MFDummyNode *node : network.dummy_nodes()) { - uint32_t node_hash = BLI_rng_get_uint(rng); + uint64_t node_hash = BLI_rng_get_uint(rng); node_hashes[node->id()] = node_hash; node_is_hashed[node->id()] = true; } @@ -381,7 +381,7 @@ static Array<uint32_t> compute_node_hashes(MFNetwork &network) continue; } - uint32_t node_hash = compute_node_hash(node, rng, node_hashes); + uint64_t node_hash = compute_node_hash(node, rng, node_hashes); node_hashes[node.id()] = node_hash; node_is_hashed[node.id()] = true; nodes_to_check.pop(); @@ -391,14 +391,14 @@ static Array<uint32_t> compute_node_hashes(MFNetwork &network) return node_hashes; } -static Map<uint32_t, Vector<MFNode *, 1>> group_nodes_by_hash(MFNetwork &network, - Span<uint32_t> node_hashes) +static Map<uint64_t, Vector<MFNode *, 1>> group_nodes_by_hash(MFNetwork &network, + Span<uint64_t> node_hashes) { - Map<uint32_t, Vector<MFNode *, 1>> nodes_by_hash; - for (uint id : IndexRange(network.node_id_amount())) { + Map<uint64_t, Vector<MFNode *, 1>> nodes_by_hash; + for (int id : IndexRange(network.node_id_amount())) { MFNode *node = network.node_or_null_by_id(id); if (node != nullptr) { - uint32_t node_hash = node_hashes[id]; + uint64_t node_hash = node_hashes[id]; nodes_by_hash.lookup_or_add_default(node_hash).append(node); } } @@ -428,7 +428,7 @@ static bool nodes_output_same_values(DisjointSet &cache, const MFNode &a, const if (!functions_are_equal(a.as_function().function(), b.as_function().function())) { return false; } - for (uint i : a.inputs().index_range()) { + for (int i : a.inputs().index_range()) { const MFOutputSocket *origin_a = a.input(i).origin(); const MFOutputSocket *origin_b = b.input(i).origin(); if (origin_a == nullptr || origin_b == nullptr) { @@ -444,7 +444,7 @@ static bool nodes_output_same_values(DisjointSet &cache, const MFNode &a, const } static void relink_duplicate_nodes(MFNetwork &network, - Map<uint32_t, Vector<MFNode *, 1>> &nodes_by_hash) + Map<uint64_t, Vector<MFNode *, 1>> &nodes_by_hash) { DisjointSet same_node_cache{network.node_id_amount()}; @@ -462,7 +462,7 @@ static void relink_duplicate_nodes(MFNetwork &network, /* This is true with fairly high probability, but hash collisions can happen. So we have to * check if the node actually output the same values. */ if (nodes_output_same_values(same_node_cache, deduplicated_node, *node)) { - for (uint i : deduplicated_node.outputs().index_range()) { + for (int i : deduplicated_node.outputs().index_range()) { network.relink(node->output(i), deduplicated_node.output(i)); } } @@ -481,8 +481,8 @@ static void relink_duplicate_nodes(MFNetwork &network, */ void common_subnetwork_elimination(MFNetwork &network) { - Array<uint32_t> node_hashes = compute_node_hashes(network); - Map<uint32_t, Vector<MFNode *, 1>> nodes_by_hash = group_nodes_by_hash(network, node_hashes); + Array<uint64_t> node_hashes = compute_node_hashes(network); + Map<uint64_t, Vector<MFNode *, 1>> nodes_by_hash = group_nodes_by_hash(network, node_hashes); relink_duplicate_nodes(network, nodes_by_hash); } |