diff options
author | Jacques Lucke <jacques@blender.org> | 2020-08-07 19:24:59 +0300 |
---|---|---|
committer | Jacques Lucke <jacques@blender.org> | 2020-08-07 19:42:21 +0300 |
commit | c50e5fcc344d00b03eb4a3141b5b45944c3570fd (patch) | |
tree | f683ae1a1f38551d160a5be2ee86561d51faca26 /source/blender/functions | |
parent | 28b10224346a9a2e55267f98357991a841eeda5b (diff) |
Cleanup: use C++ style casts in various places
Diffstat (limited to 'source/blender/functions')
11 files changed, 115 insertions, 105 deletions
diff --git a/source/blender/functions/FN_attributes_ref.hh b/source/blender/functions/FN_attributes_ref.hh index 0cac8d82d26..a9236f73549 100644 --- a/source/blender/functions/FN_attributes_ref.hh +++ b/source/blender/functions/FN_attributes_ref.hh @@ -51,7 +51,7 @@ class AttributesInfoBuilder : NonCopyable, NonMovable { template<typename T> bool add(StringRef name, const T &default_value) { - return this->add(name, CPPType::get<T>(), (const void *)&default_value); + return this->add(name, CPPType::get<T>(), static_cast<const void *>(&default_value)); } bool add(StringRef name, const CPPType &type, const void *default_value = nullptr); @@ -107,7 +107,7 @@ class AttributesInfo : NonCopyable, NonMovable { template<typename T> const T &default_of(int index) const { BLI_assert(type_by_index_[index]->is<T>()); - return *(T *)defaults_[index]; + return *static_cast<T *>(defaults_[index]); } template<typename T> const T &default_of(StringRef name) const @@ -203,7 +203,7 @@ class MutableAttributesRef { 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()); + return MutableSpan<T>(static_cast<T *>(buffers_[index]) + range_.start(), range_.size()); } template<typename T> MutableSpan<T> get(StringRef name) const @@ -294,7 +294,7 @@ class AttributesRef { 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()); + return Span<T>(static_cast<T *>(buffers_[index]) + range_.start(), range_.size()); } template<typename T> Span<T> get(StringRef name) const diff --git a/source/blender/functions/FN_cpp_type.hh b/source/blender/functions/FN_cpp_type.hh index 2f1d3f83c63..5f3981826c5 100644 --- a/source/blender/functions/FN_cpp_type.hh +++ b/source/blender/functions/FN_cpp_type.hh @@ -584,35 +584,35 @@ template<typename T> void construct_default_cb(void *ptr) } template<typename T> void construct_default_n_cb(void *ptr, int64_t n) { - blender::default_construct_n((T *)ptr, n); + blender::default_construct_n(static_cast<T *>(ptr), n); } template<typename T> void construct_default_indices_cb(void *ptr, IndexMask mask) { - mask.foreach_index([&](int64_t i) { new ((T *)ptr + i) T; }); + mask.foreach_index([&](int64_t i) { new (static_cast<T *>(ptr) + i) T; }); } template<typename T> void destruct_cb(void *ptr) { - ((T *)ptr)->~T(); + (static_cast<T *>(ptr))->~T(); } template<typename T> void destruct_n_cb(void *ptr, int64_t n) { - blender::destruct_n((T *)ptr, n); + blender::destruct_n(static_cast<T *>(ptr), n); } template<typename T> void destruct_indices_cb(void *ptr, IndexMask mask) { - T *ptr_ = (T *)ptr; + T *ptr_ = static_cast<T *>(ptr); 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; + *static_cast<T *>(dst) = *static_cast<const T *>(src); } 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; + const T *src_ = static_cast<const T *>(src); + T *dst_ = static_cast<T *>(dst); for (int64_t i = 0; i < n; i++) { dst_[i] = src_[i]; @@ -621,45 +621,45 @@ template<typename T> void copy_to_initialized_n_cb(const void *src, void *dst, i template<typename T> void copy_to_initialized_indices_cb(const void *src, void *dst, IndexMask mask) { - const T *src_ = (const T *)src; - T *dst_ = (T *)dst; + const T *src_ = static_cast<const T *>(src); + T *dst_ = static_cast<T *>(dst); 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); + blender::uninitialized_copy_n(static_cast<const T *>(src), 1, static_cast<T *>(dst)); } 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); + blender::uninitialized_copy_n(static_cast<const T *>(src), n, static_cast<T *>(dst)); } template<typename T> void copy_to_uninitialized_indices_cb(const void *src, void *dst, IndexMask mask) { - const T *src_ = (const T *)src; - T *dst_ = (T *)dst; + const T *src_ = static_cast<const T *>(src); + T *dst_ = static_cast<T *>(dst); mask.foreach_index([&](int64_t i) { new (dst_ + i) T(src_[i]); }); } template<typename T> void relocate_to_initialized_cb(void *src, void *dst) { - T *src_ = (T *)src; - T *dst_ = (T *)dst; + T *src_ = static_cast<T *>(src); + T *dst_ = static_cast<T *>(dst); *dst_ = std::move(*src_); src_->~T(); } 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); + blender::initialized_relocate_n(static_cast<T *>(src), n, static_cast<T *>(dst)); } template<typename T> void relocate_to_initialized_indices_cb(void *src, void *dst, IndexMask mask) { - T *src_ = (T *)src; - T *dst_ = (T *)dst; + T *src_ = static_cast<T *>(src); + T *dst_ = static_cast<T *>(dst); mask.foreach_index([&](int64_t i) { dst_[i] = std::move(src_[i]); @@ -669,21 +669,21 @@ template<typename T> void relocate_to_initialized_indices_cb(void *src, void *ds template<typename T> void relocate_to_uninitialized_cb(void *src, void *dst) { - T *src_ = (T *)src; - T *dst_ = (T *)dst; + T *src_ = static_cast<T *>(src); + T *dst_ = static_cast<T *>(dst); new (dst_) T(std::move(*src_)); src_->~T(); } 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); + blender::uninitialized_relocate_n(static_cast<T *>(src), n, static_cast<T *>(dst)); } template<typename T> void relocate_to_uninitialized_indices_cb(void *src, void *dst, IndexMask mask) { - T *src_ = (T *)src; - T *dst_ = (T *)dst; + T *src_ = static_cast<T *>(src); + T *dst_ = static_cast<T *>(dst); mask.foreach_index([&](int64_t i) { new (dst_ + i) T(std::move(src_[i])); @@ -693,8 +693,8 @@ void relocate_to_uninitialized_indices_cb(void *src, void *dst, IndexMask mask) 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; + const T &value_ = *static_cast<const T *>(value); + T *dst_ = static_cast<T *>(dst); for (int64_t i = 0; i < n; i++) { dst_[i] = value_; @@ -702,16 +702,16 @@ template<typename T> void fill_initialized_cb(const void *value, void *dst, int6 } template<typename T> void fill_initialized_indices_cb(const void *value, void *dst, IndexMask mask) { - const T &value_ = *(const T *)value; - T *dst_ = (T *)dst; + const T &value_ = *static_cast<const T *>(value); + T *dst_ = static_cast<T *>(dst); mask.foreach_index([&](int64_t i) { dst_[i] = value_; }); } 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; + const T &value_ = *static_cast<const T *>(value); + T *dst_ = static_cast<T *>(dst); for (int64_t i = 0; i < n; i++) { new (dst_ + i) T(value_); @@ -720,28 +720,28 @@ template<typename T> void fill_uninitialized_cb(const void *value, void *dst, in template<typename T> void fill_uninitialized_indices_cb(const void *value, void *dst, IndexMask mask) { - const T &value_ = *(const T *)value; - T *dst_ = (T *)dst; + const T &value_ = *static_cast<const T *>(value); + T *dst_ = static_cast<T *>(dst); mask.foreach_index([&](int64_t i) { new (dst_ + i) T(value_); }); } template<typename T> void debug_print_cb(const void *value, std::stringstream &ss) { - const T &value_ = *(const T *)value; + const T &value_ = *static_cast<const T *>(value); ss << value_; } template<typename T> bool is_equal_cb(const void *a, const void *b) { - const T &a_ = *(T *)a; - const T &b_ = *(T *)b; + const T &a_ = *static_cast<const T *>(a); + const T &b_ = *static_cast<const T *>(b); return a_ == b_; } template<typename T> uint64_t hash_cb(const void *value) { - const T &value_ = *(const T *)value; + const T &value_ = *static_cast<const T *>(value); return DefaultHash<T>{}(value_); } @@ -780,7 +780,7 @@ inline std::unique_ptr<const CPPType> create_cpp_type(StringRef name, const T &d debug_print_cb<T>, is_equal_cb<T>, hash_cb<T>, - (const void *)&default_value); + static_cast<const void *>(&default_value)); return std::unique_ptr<const CPPType>(type); } diff --git a/source/blender/functions/FN_generic_vector_array.hh b/source/blender/functions/FN_generic_vector_array.hh index 0a173d1fbc6..dc5ad3c36ab 100644 --- a/source/blender/functions/FN_generic_vector_array.hh +++ b/source/blender/functions/FN_generic_vector_array.hh @@ -186,7 +186,8 @@ template<typename T> class GVectorArrayRef { 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]); + return MutableSpan<T>(static_cast<T *>(vector_array_->starts_[index]), + vector_array_->lengths_[index]); } int64_t size() const diff --git a/source/blender/functions/FN_multi_function_builder.hh b/source/blender/functions/FN_multi_function_builder.hh index dee0938eb3a..6d5ca7f64ad 100644 --- a/source/blender/functions/FN_multi_function_builder.hh +++ b/source/blender/functions/FN_multi_function_builder.hh @@ -58,7 +58,8 @@ 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([&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i])); }); + mask.foreach_index( + [&](int i) { new (static_cast<void *>(&out1[i])) Out1(element_fn(in1[i])); }); }; } @@ -100,7 +101,8 @@ 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([&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i])); }); + mask.foreach_index( + [&](int i) { new (static_cast<void *>(&out1[i])) Out1(element_fn(in1[i], in2[i])); }); }; } @@ -150,8 +152,9 @@ class CustomMF_SI_SI_SI_SO : public MultiFunction { VSpan<In2> in2, VSpan<In3> in3, MutableSpan<Out1> out1) { - mask.foreach_index( - [&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i], in3[i])); }); + mask.foreach_index([&](int i) { + new (static_cast<void *>(&out1[i])) Out1(element_fn(in1[i], in2[i], in3[i])); + }); }; } @@ -220,7 +223,7 @@ template<typename From, typename To> class CustomMF_Convert : public MultiFuncti MutableSpan<To> outputs = params.uninitialized_single_output<To>(1); for (int64_t i : mask) { - new ((void *)&outputs[i]) To(inputs[i]); + new (static_cast<void *>(&outputs[i])) To(inputs[i]); } } }; @@ -294,7 +297,7 @@ template<typename T> class CustomMF_Constant : public MultiFunction { if (other2 != nullptr) { const CPPType &type = CPPType::get<T>(); if (type == other2->type_) { - return type.is_equal((const void *)&value_, other2->value_); + return type.is_equal(static_cast<const void *>(&value_), other2->value_); } } return false; diff --git a/source/blender/functions/FN_multi_function_context.hh b/source/blender/functions/FN_multi_function_context.hh index eec6b21ae7c..1d3ed726c4a 100644 --- a/source/blender/functions/FN_multi_function_context.hh +++ b/source/blender/functions/FN_multi_function_context.hh @@ -43,7 +43,7 @@ class MFContextBuilder { public: template<typename T> void add_global_context(std::string name, const T *context) { - global_contexts_.add_new(std::move(name), (const void *)context); + global_contexts_.add_new(std::move(name), static_cast<const void *>(context)); } }; @@ -60,7 +60,7 @@ class MFContext { { const void *context = builder_.global_contexts_.lookup_default_as(name, nullptr); /* TODO: Implement type checking. */ - return (const T *)context; + return static_cast<const T *>(context); } }; diff --git a/source/blender/functions/FN_multi_function_data_type.hh b/source/blender/functions/FN_multi_function_data_type.hh index 34997703432..713f73c2b5a 100644 --- a/source/blender/functions/FN_multi_function_data_type.hh +++ b/source/blender/functions/FN_multi_function_data_type.hh @@ -110,7 +110,7 @@ class MFDataType { uint64_t hash() const { - return DefaultHash<CPPType>{}(*type_) + (uint64_t)category_; + return DefaultHash<CPPType>{}(*type_) + static_cast<uint64_t>(category_); } }; diff --git a/source/blender/functions/FN_multi_function_network.hh b/source/blender/functions/FN_multi_function_network.hh index 7a9f5b4cfaf..b303589106a 100644 --- a/source/blender/functions/FN_multi_function_network.hh +++ b/source/blender/functions/FN_multi_function_network.hh @@ -118,7 +118,7 @@ class MFFunctionNode : public MFNode { }; class MFDummyNode : public MFNode { - private: + protected: StringRefNull name_; MutableSpan<StringRefNull> input_names_; MutableSpan<StringRefNull> output_names_; @@ -279,25 +279,25 @@ inline bool MFNode::is_function() const inline MFDummyNode &MFNode::as_dummy() { BLI_assert(is_dummy_); - return *(MFDummyNode *)this; + return static_cast<MFDummyNode &>(*this); } inline const MFDummyNode &MFNode::as_dummy() const { BLI_assert(is_dummy_); - return *(const MFDummyNode *)this; + return static_cast<const MFDummyNode &>(*this); } inline MFFunctionNode &MFNode::as_function() { BLI_assert(!is_dummy_); - return *(MFFunctionNode *)this; + return static_cast<MFFunctionNode &>(*this); } inline const MFFunctionNode &MFNode::as_function() const { BLI_assert(!is_dummy_); - return *(const MFFunctionNode *)this; + return static_cast<const MFFunctionNode &>(*this); } inline MFInputSocket &MFNode::input(int index) @@ -440,25 +440,25 @@ inline bool MFSocket::is_output() const inline MFInputSocket &MFSocket::as_input() { BLI_assert(this->is_input()); - return *(MFInputSocket *)this; + return static_cast<MFInputSocket &>(*this); } inline const MFInputSocket &MFSocket::as_input() const { BLI_assert(this->is_input()); - return *(const MFInputSocket *)this; + return static_cast<const MFInputSocket &>(*this); } inline MFOutputSocket &MFSocket::as_output() { BLI_assert(this->is_output()); - return *(MFOutputSocket *)this; + return static_cast<MFOutputSocket &>(*this); } inline const MFOutputSocket &MFSocket::as_output() const { BLI_assert(this->is_output()); - return *(const MFOutputSocket *)this; + return static_cast<const MFOutputSocket &>(*this); } /* -------------------------------------------------------------------- diff --git a/source/blender/functions/FN_spans.hh b/source/blender/functions/FN_spans.hh index 76380f46e91..2c1257f9ad2 100644 --- a/source/blender/functions/FN_spans.hh +++ b/source/blender/functions/FN_spans.hh @@ -67,7 +67,8 @@ class GSpan { } template<typename T> - GSpan(Span<T> array) : GSpan(CPPType::get<T>(), (const void *)array.data(), array.size()) + GSpan(Span<T> array) + : GSpan(CPPType::get<T>(), static_cast<const void *>(array.data()), array.size()) { } @@ -100,7 +101,7 @@ class GSpan { template<typename T> Span<T> typed() const { BLI_assert(type_->is<T>()); - return Span<T>((const T *)data_, size_); + return Span<T>(static_cast<const T *>(data_), size_); } }; @@ -129,7 +130,7 @@ class GMutableSpan { template<typename T> GMutableSpan(MutableSpan<T> array) - : GMutableSpan(CPPType::get<T>(), (void *)array.begin(), array.size()) + : GMutableSpan(CPPType::get<T>(), static_cast<void *>(array.begin()), array.size()) { } @@ -167,7 +168,7 @@ class GMutableSpan { template<typename T> MutableSpan<T> typed() { BLI_assert(type_->is<T>()); - return MutableSpan<T>((T *)data_, size_); + return MutableSpan<T>(static_cast<T *>(data_), size_); } }; diff --git a/source/blender/functions/intern/multi_function_network.cc b/source/blender/functions/intern/multi_function_network.cc index cd3c38dd09f..77c8ba6373f 100644 --- a/source/blender/functions/intern/multi_function_network.cc +++ b/source/blender/functions/intern/multi_function_network.cc @@ -285,8 +285,8 @@ std::string MFNetwork::to_dot(Span<const MFNode *> marked_nodes) const Map<const MFNode *, dot::NodeWithSocketsRef> dot_nodes; Vector<const MFNode *> all_nodes; - all_nodes.extend(function_nodes_.as_span()); - all_nodes.extend(dummy_nodes_.as_span()); + all_nodes.extend(function_nodes_.as_span().cast<const MFNode *>()); + all_nodes.extend(dummy_nodes_.as_span().cast<const MFNode *>()); for (const MFNode *node : all_nodes) { dot::Node &dot_node = digraph.new_node(""); diff --git a/source/blender/functions/intern/multi_function_network_evaluation.cc b/source/blender/functions/intern/multi_function_network_evaluation.cc index 480a048b510..c543d86ad34 100644 --- a/source/blender/functions/intern/multi_function_network_evaluation.cc +++ b/source/blender/functions/intern/multi_function_network_evaluation.cc @@ -520,7 +520,7 @@ MFNetworkEvaluationStorage::~MFNetworkEvaluationStorage() continue; } if (any_value->type == ValueType::OwnSingle) { - OwnSingleValue *value = (OwnSingleValue *)any_value; + OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value); GMutableSpan span = value->span; const CPPType &type = span.type(); if (value->is_single_allocated) { @@ -532,7 +532,7 @@ MFNetworkEvaluationStorage::~MFNetworkEvaluationStorage() } } else if (any_value->type == ValueType::OwnVector) { - OwnVectorValue *value = (OwnVectorValue *)any_value; + OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value); delete value->vector_array; } } @@ -550,7 +550,7 @@ bool MFNetworkEvaluationStorage::socket_is_computed(const MFOutputSocket &socket return false; } if (ELEM(any_value->type, ValueType::OutputSingle, ValueType::OutputVector)) { - return ((OutputValue *)any_value)->is_computed; + return static_cast<OutputValue *>(any_value)->is_computed; } return true; } @@ -560,17 +560,17 @@ bool MFNetworkEvaluationStorage::is_same_value_for_every_index(const MFOutputSoc Value *any_value = value_per_output_id_[socket.id()]; switch (any_value->type) { case ValueType::OwnSingle: - return ((OwnSingleValue *)any_value)->span.size() == 1; + return static_cast<OwnSingleValue *>(any_value)->span.size() == 1; case ValueType::OwnVector: - return ((OwnVectorValue *)any_value)->vector_array->size() == 1; + return static_cast<OwnVectorValue *>(any_value)->vector_array->size() == 1; case ValueType::InputSingle: - return ((InputSingleValue *)any_value)->virtual_span.is_single_element(); + return static_cast<InputSingleValue *>(any_value)->virtual_span.is_single_element(); case ValueType::InputVector: - return ((InputVectorValue *)any_value)->virtual_array_span.is_single_array(); + return static_cast<InputVectorValue *>(any_value)->virtual_array_span.is_single_array(); case ValueType::OutputSingle: - return ((OutputSingleValue *)any_value)->span.size() == 1; + return static_cast<OutputSingleValue *>(any_value)->span.size() == 1; case ValueType::OutputVector: - return ((OutputVectorValue *)any_value)->vector_array->size() == 1; + return static_cast<OutputVectorValue *>(any_value)->vector_array->size() == 1; } BLI_assert(false); return false; @@ -605,7 +605,7 @@ void MFNetworkEvaluationStorage::finish_output_socket(const MFOutputSocket &sock } if (ELEM(any_value->type, ValueType::OutputSingle, ValueType::OutputVector)) { - ((OutputValue *)any_value)->is_computed = true; + static_cast<OutputValue *>(any_value)->is_computed = true; } } @@ -627,7 +627,7 @@ void MFNetworkEvaluationStorage::finish_input_socket(const MFInputSocket &socket break; } case ValueType::OwnSingle: { - OwnSingleValue *value = (OwnSingleValue *)any_value; + OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value); BLI_assert(value->max_remaining_users >= 1); value->max_remaining_users--; if (value->max_remaining_users == 0) { @@ -645,7 +645,7 @@ void MFNetworkEvaluationStorage::finish_input_socket(const MFInputSocket &socket break; } case ValueType::OwnVector: { - OwnVectorValue *value = (OwnVectorValue *)any_value; + OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value); BLI_assert(value->max_remaining_users >= 1); value->max_remaining_users--; if (value->max_remaining_users == 0) { @@ -712,7 +712,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_single_output__full(const MFOutputS } BLI_assert(any_value->type == ValueType::OutputSingle); - return ((OutputSingleValue *)any_value)->span; + return static_cast<OutputSingleValue *>(any_value)->span; } GMutableSpan MFNetworkEvaluationStorage::get_single_output__single(const MFOutputSocket &socket) @@ -730,7 +730,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_single_output__single(const MFOutpu } BLI_assert(any_value->type == ValueType::OutputSingle); - GMutableSpan span = ((OutputSingleValue *)any_value)->span; + GMutableSpan span = static_cast<OutputSingleValue *>(any_value)->span; BLI_assert(span.size() == 1); return span; } @@ -749,7 +749,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_vector_output__full(const MFOutput } BLI_assert(any_value->type == ValueType::OutputVector); - return *((OutputVectorValue *)any_value)->vector_array; + return *static_cast<OutputVectorValue *>(any_value)->vector_array; } GVectorArray &MFNetworkEvaluationStorage::get_vector_output__single(const MFOutputSocket &socket) @@ -766,7 +766,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_vector_output__single(const MFOutp } BLI_assert(any_value->type == ValueType::OutputVector); - GVectorArray &vector_array = *((OutputVectorValue *)any_value)->vector_array; + GVectorArray &vector_array = *static_cast<OutputVectorValue *>(any_value)->vector_array; BLI_assert(vector_array.size() == 1); return vector_array; } @@ -785,14 +785,14 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS if (to_any_value != nullptr) { BLI_assert(to_any_value->type == ValueType::OutputSingle); - GMutableSpan span = ((OutputSingleValue *)to_any_value)->span; + GMutableSpan span = static_cast<OutputSingleValue *>(to_any_value)->span; GVSpan virtual_span = this->get_single_input__full(input); virtual_span.materialize_to_uninitialized(mask_, span.data()); return span; } if (from_any_value->type == ValueType::OwnSingle) { - OwnSingleValue *value = (OwnSingleValue *)from_any_value; + OwnSingleValue *value = static_cast<OwnSingleValue *>(from_any_value); if (value->max_remaining_users == 1 && !value->is_single_allocated) { value_per_output_id_[to.id()] = value; value_per_output_id_[from.id()] = nullptr; @@ -826,7 +826,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu if (to_any_value != nullptr) { BLI_assert(to_any_value->type == ValueType::OutputSingle); - GMutableSpan span = ((OutputSingleValue *)to_any_value)->span; + GMutableSpan span = static_cast<OutputSingleValue *>(to_any_value)->span; BLI_assert(span.size() == 1); GVSpan virtual_span = this->get_single_input__single(input); type.copy_to_uninitialized(virtual_span.as_single_element(), span[0]); @@ -834,7 +834,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu } if (from_any_value->type == ValueType::OwnSingle) { - OwnSingleValue *value = (OwnSingleValue *)from_any_value; + OwnSingleValue *value = static_cast<OwnSingleValue *>(from_any_value); if (value->max_remaining_users == 1) { value_per_output_id_[to.id()] = value; value_per_output_id_[from.id()] = nullptr; @@ -870,14 +870,14 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput if (to_any_value != nullptr) { BLI_assert(to_any_value->type == ValueType::OutputVector); - GVectorArray &vector_array = *((OutputVectorValue *)to_any_value)->vector_array; + GVectorArray &vector_array = *static_cast<OutputVectorValue *>(to_any_value)->vector_array; GVArraySpan virtual_array_span = this->get_vector_input__full(input); vector_array.extend(mask_, virtual_array_span); return vector_array; } if (from_any_value->type == ValueType::OwnVector) { - OwnVectorValue *value = (OwnVectorValue *)from_any_value; + OwnVectorValue *value = static_cast<OwnVectorValue *>(from_any_value); if (value->max_remaining_users == 1) { value_per_output_id_[to.id()] = value; value_per_output_id_[from.id()] = nullptr; @@ -912,7 +912,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp if (to_any_value != nullptr) { BLI_assert(to_any_value->type == ValueType::OutputVector); - GVectorArray &vector_array = *((OutputVectorValue *)to_any_value)->vector_array; + GVectorArray &vector_array = *static_cast<OutputVectorValue *>(to_any_value)->vector_array; BLI_assert(vector_array.size() == 1); GVArraySpan virtual_array_span = this->get_vector_input__single(input); vector_array.extend(0, virtual_array_span[0]); @@ -920,7 +920,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp } if (from_any_value->type == ValueType::OwnVector) { - OwnVectorValue *value = (OwnVectorValue *)from_any_value; + OwnVectorValue *value = static_cast<OwnVectorValue *>(from_any_value); if (value->max_remaining_users == 1) { value_per_output_id_[to.id()] = value; value_per_output_id_[from.id()] = nullptr; @@ -947,7 +947,7 @@ GVSpan MFNetworkEvaluationStorage::get_single_input__full(const MFInputSocket &s BLI_assert(any_value != nullptr); if (any_value->type == ValueType::OwnSingle) { - OwnSingleValue *value = (OwnSingleValue *)any_value; + OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value); if (value->is_single_allocated) { return GVSpan::FromSingle(value->span.type(), value->span.data(), min_array_size_); } @@ -955,11 +955,11 @@ GVSpan MFNetworkEvaluationStorage::get_single_input__full(const MFInputSocket &s return value->span; } if (any_value->type == ValueType::InputSingle) { - InputSingleValue *value = (InputSingleValue *)any_value; + InputSingleValue *value = static_cast<InputSingleValue *>(any_value); return value->virtual_span; } if (any_value->type == ValueType::OutputSingle) { - OutputSingleValue *value = (OutputSingleValue *)any_value; + OutputSingleValue *value = static_cast<OutputSingleValue *>(any_value); BLI_assert(value->is_computed); return value->span; } @@ -975,17 +975,17 @@ GVSpan MFNetworkEvaluationStorage::get_single_input__single(const MFInputSocket BLI_assert(any_value != nullptr); if (any_value->type == ValueType::OwnSingle) { - OwnSingleValue *value = (OwnSingleValue *)any_value; + OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value); BLI_assert(value->span.size() == 1); return value->span; } if (any_value->type == ValueType::InputSingle) { - InputSingleValue *value = (InputSingleValue *)any_value; + InputSingleValue *value = static_cast<InputSingleValue *>(any_value); BLI_assert(value->virtual_span.is_single_element()); return value->virtual_span; } if (any_value->type == ValueType::OutputSingle) { - OutputSingleValue *value = (OutputSingleValue *)any_value; + OutputSingleValue *value = static_cast<OutputSingleValue *>(any_value); BLI_assert(value->is_computed); BLI_assert(value->span.size() == 1); return value->span; @@ -1002,7 +1002,7 @@ GVArraySpan MFNetworkEvaluationStorage::get_vector_input__full(const MFInputSock BLI_assert(any_value != nullptr); if (any_value->type == ValueType::OwnVector) { - OwnVectorValue *value = (OwnVectorValue *)any_value; + OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value); if (value->vector_array->size() == 1) { GSpan span = (*value->vector_array)[0]; return GVArraySpan(span, min_array_size_); @@ -1011,11 +1011,11 @@ GVArraySpan MFNetworkEvaluationStorage::get_vector_input__full(const MFInputSock return *value->vector_array; } if (any_value->type == ValueType::InputVector) { - InputVectorValue *value = (InputVectorValue *)any_value; + InputVectorValue *value = static_cast<InputVectorValue *>(any_value); return value->virtual_array_span; } if (any_value->type == ValueType::OutputVector) { - OutputVectorValue *value = (OutputVectorValue *)any_value; + OutputVectorValue *value = static_cast<OutputVectorValue *>(any_value); return *value->vector_array; } @@ -1030,17 +1030,17 @@ GVArraySpan MFNetworkEvaluationStorage::get_vector_input__single(const MFInputSo BLI_assert(any_value != nullptr); if (any_value->type == ValueType::OwnVector) { - OwnVectorValue *value = (OwnVectorValue *)any_value; + OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value); BLI_assert(value->vector_array->size() == 1); return *value->vector_array; } if (any_value->type == ValueType::InputVector) { - InputVectorValue *value = (InputVectorValue *)any_value; + InputVectorValue *value = static_cast<InputVectorValue *>(any_value); BLI_assert(value->virtual_array_span.is_single_array()); return value->virtual_array_span; } if (any_value->type == ValueType::OutputVector) { - OutputVectorValue *value = (OutputVectorValue *)any_value; + OutputVectorValue *value = static_cast<OutputVectorValue *>(any_value); BLI_assert(value->vector_array->size() == 1); return *value->vector_array; } diff --git a/source/blender/functions/intern/multi_function_network_optimization.cc b/source/blender/functions/intern/multi_function_network_optimization.cc index e53b9a2c648..e24f157d4f9 100644 --- a/source/blender/functions/intern/multi_function_network_optimization.cc +++ b/source/blender/functions/intern/multi_function_network_optimization.cc @@ -130,7 +130,8 @@ static Vector<MFNode *> find_nodes_based_on_mask(MFNetwork &network, */ void dead_node_removal(MFNetwork &network) { - Array<bool> node_is_used_mask = mask_nodes_to_the_left(network, network.dummy_nodes()); + Array<bool> node_is_used_mask = mask_nodes_to_the_left(network, + network.dummy_nodes().cast<MFNode *>()); Vector<MFNode *> nodes_to_remove = find_nodes_based_on_mask(network, node_is_used_mask, false); network.remove(nodes_to_remove); } @@ -156,7 +157,7 @@ static bool function_node_can_be_constant(MFFunctionNode *node) static Vector<MFNode *> find_non_constant_nodes(MFNetwork &network) { Vector<MFNode *> non_constant_nodes; - non_constant_nodes.extend(network.dummy_nodes()); + non_constant_nodes.extend(network.dummy_nodes().cast<MFNode *>()); for (MFFunctionNode *node : network.function_nodes()) { if (!function_node_can_be_constant(node)) { @@ -299,6 +300,10 @@ static Array<MFOutputSocket *> compute_constant_sockets_and_add_folded_nodes( return add_constant_folded_sockets(network_fn, params, resources, network); } +class MyClass { + MFDummyNode node; +}; + /** * Find function nodes that always output the same value and replace those with constant nodes. */ @@ -318,7 +323,7 @@ void constant_folding(MFNetwork &network, ResourceCollector &resources) network.relink(original_socket, *folded_sockets[i]); } - network.remove(temporary_nodes); + network.remove(temporary_nodes.as_span().cast<MFNode *>()); } /** \} */ |