[Bf-blender-cvs] [17672efa0e0] master: Geometry Nodes: initial attribute interpolation between domains
Jacques Lucke
noreply at git.blender.org
Tue Feb 9 11:46:32 CET 2021
Commit: 17672efa0e02172b77eed95bfb977c914a5305b9
Author: Jacques Lucke
Date: Tue Feb 9 11:44:58 2021 +0100
Branches: master
https://developer.blender.org/rB17672efa0e02172b77eed95bfb977c914a5305b9
Geometry Nodes: initial attribute interpolation between domains
This patch adds support for accessing corner attributes on the point domain.
The immediate benefit of this is that now (interpolated) uv coordinates are
available on points without having to use the Point Distribute node.
This is also very useful for parts of T84297, because once we have vertex
colors, those will also be available on points, even though they are stored
per corner.
Differential Revision: https://developer.blender.org/D10305
===================================================================
M source/blender/blenkernel/BKE_attribute_math.hh
M source/blender/blenkernel/BKE_geometry_set.hh
M source/blender/blenkernel/CMakeLists.txt
M source/blender/blenkernel/intern/attribute_access.cc
A source/blender/blenkernel/intern/attribute_math.cc
===================================================================
diff --git a/source/blender/blenkernel/BKE_attribute_math.hh b/source/blender/blenkernel/BKE_attribute_math.hh
index b8bb2048d9d..606811ca12d 100644
--- a/source/blender/blenkernel/BKE_attribute_math.hh
+++ b/source/blender/blenkernel/BKE_attribute_math.hh
@@ -14,9 +14,11 @@
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+#include "BLI_array.hh"
#include "BLI_color.hh"
#include "BLI_float2.hh"
#include "BLI_float3.hh"
+
#include "DNA_customdata_types.h"
namespace blender::attribute_math {
@@ -52,7 +54,12 @@ void convert_to_static_type(const CustomDataType data_type, const Func &func)
}
}
-/* Interpolate between three values. */
+/* -------------------------------------------------------------------- */
+/** \name Mix three values of the same type.
+ *
+ * This is typically used to interpolate values within a triangle.
+ * \{ */
+
template<typename T> T mix3(const float3 &weights, const T &v0, const T &v1, const T &v2);
template<> inline bool mix3(const float3 &weights, const bool &v0, const bool &v1, const bool &v2)
@@ -91,4 +98,159 @@ inline Color4f mix3(const float3 &weights, const Color4f &v0, const Color4f &v1,
return result;
}
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Mix a dynamic amount of values with weights for many elements.
+ *
+ * This section provides an abstraction for "mixers". The abstraction encapsulates details about
+ * how different types should be mixed. Usually #DefaultMixer<T> should be used to get a mixer for
+ * a specific type.
+ * \{ */
+
+template<typename T> class SimpleMixer {
+ private:
+ MutableSpan<T> buffer_;
+ T default_value_;
+ Array<float> total_weights_;
+
+ public:
+ /**
+ * \param buffer: Span where the interpolated values should be stored.
+ * \param default_value: Output value for an element that has not been affected by a #mix_in.
+ */
+ SimpleMixer(MutableSpan<T> buffer, T default_value = {})
+ : buffer_(buffer), default_value_(default_value), total_weights_(buffer.size(), 0.0f)
+ {
+ BLI_STATIC_ASSERT(std::is_trivial_v<T>, "");
+ memset(buffer_.data(), 0, sizeof(T) * buffer_.size());
+ }
+
+ /**
+ * Mix a #value into the element with the given #index.
+ */
+ void mix_in(const int64_t index, const T &value, const float weight = 1.0f)
+ {
+ BLI_assert(weight >= 0.0f);
+ buffer_[index] += value * weight;
+ total_weights_[index] += weight;
+ }
+
+ /**
+ * Has to be called before the buffer provided in the constructor is used.
+ */
+ void finalize()
+ {
+ for (const int64_t i : buffer_.index_range()) {
+ const float weight = total_weights_[i];
+ if (weight > 0.0f) {
+ buffer_[i] *= 1.0f / weight;
+ }
+ else {
+ buffer_[i] = default_value_;
+ }
+ }
+ }
+};
+
+/** This mixer accumulates values in a type that is different from the one that is mixed. Some
+ * types cannot encode the floating point weights in their values (e.g. int and bool). */
+template<typename T, typename AccumulationT, T (*ConvertToT)(const AccumulationT &value)>
+class SimpleMixerWithAccumulationType {
+ private:
+ struct Item {
+ /* Store both values together, because they are accessed together. */
+ AccumulationT value = {0};
+ float weight = 0.0f;
+ };
+
+ MutableSpan<T> buffer_;
+ T default_value_;
+ Array<Item> accumulation_buffer_;
+
+ public:
+ SimpleMixerWithAccumulationType(MutableSpan<T> buffer, T default_value = {})
+ : buffer_(buffer), default_value_(default_value), accumulation_buffer_(buffer.size())
+ {
+ }
+
+ void mix_in(const int64_t index, const T &value, const float weight = 1.0f)
+ {
+ const AccumulationT converted_value = static_cast<AccumulationT>(value);
+ Item &item = accumulation_buffer_[index];
+ item.value += converted_value * weight;
+ item.weight += weight;
+ }
+
+ void finalize()
+ {
+ for (const int64_t i : buffer_.index_range()) {
+ const Item &item = accumulation_buffer_[i];
+ if (item.weight > 0.0f) {
+ const float weight_inv = 1.0f / item.weight;
+ const T converted_value = ConvertToT(item.value * weight_inv);
+ buffer_[i] = converted_value;
+ }
+ else {
+ buffer_[i] = default_value_;
+ }
+ }
+ }
+};
+
+class Color4fMixer {
+ private:
+ MutableSpan<Color4f> buffer_;
+ Color4f default_color_;
+ Array<float> total_weights_;
+
+ public:
+ Color4fMixer(MutableSpan<Color4f> buffer, Color4f default_color = {0, 0, 0, 1});
+ void mix_in(const int64_t index, const Color4f &color, const float weight = 1.0f);
+ void finalize();
+};
+
+template<typename T> struct DefaultMixerStruct {
+ /* Use void by default. This can be check for in `if constexpr` statements. */
+ using type = void;
+};
+template<> struct DefaultMixerStruct<float> {
+ using type = SimpleMixer<float>;
+};
+template<> struct DefaultMixerStruct<float2> {
+ using type = SimpleMixer<float2>;
+};
+template<> struct DefaultMixerStruct<float3> {
+ using type = SimpleMixer<float3>;
+};
+template<> struct DefaultMixerStruct<Color4f> {
+ /* Use a special mixer for colors. Color4f can't be added/multiplied, because this is not
+ * something one should usually do with colors. */
+ using type = Color4fMixer;
+};
+template<> struct DefaultMixerStruct<int> {
+ static int double_to_int(const double &value)
+ {
+ return static_cast<int>(value);
+ }
+ /* Store interpolated ints in a double temporarily, so that weights are handled correctly. It
+ * uses double instead of float so that it is accurate for all 32 bit integers. */
+ using type = SimpleMixerWithAccumulationType<int, double, double_to_int>;
+};
+template<> struct DefaultMixerStruct<bool> {
+ static bool float_to_bool(const float &value)
+ {
+ return value >= 0.5f;
+ }
+ /* Store interpolated bools in a float temporary. Otherwise information provided by weights is
+ * easily rounded away. */
+ using type = SimpleMixerWithAccumulationType<bool, float, float_to_bool>;
+};
+
+/* Utility to get a good default mixer for a given type. This is `void` when there is no default
+ * mixer for the given type. */
+template<typename T> using DefaultMixer = typename DefaultMixerStruct<T>::type;
+
+/** \} */
+
} // namespace blender::attribute_math
diff --git a/source/blender/blenkernel/BKE_geometry_set.hh b/source/blender/blenkernel/BKE_geometry_set.hh
index 9a871574f6f..6a987ee51e0 100644
--- a/source/blender/blenkernel/BKE_geometry_set.hh
+++ b/source/blender/blenkernel/BKE_geometry_set.hh
@@ -174,7 +174,7 @@ class GeometryComponent {
* interpolate from one domain to another.
* Returns null if the interpolation is not implemented. */
virtual blender::bke::ReadAttributePtr attribute_try_adapt_domain(
- blender::bke::ReadAttributePtr attribute, const AttributeDomain domain) const;
+ blender::bke::ReadAttributePtr attribute, const AttributeDomain new_domain) const;
/* Returns true when the attribute has been deleted. */
bool attribute_try_delete(const blender::StringRef attribute_name);
@@ -368,6 +368,8 @@ class MeshComponent : public GeometryComponent {
Mesh *get_for_write();
int attribute_domain_size(const AttributeDomain domain) const final;
+ blender::bke::ReadAttributePtr attribute_try_adapt_domain(
+ blender::bke::ReadAttributePtr attribute, const AttributeDomain new_domain) const final;
bool is_empty() const final;
diff --git a/source/blender/blenkernel/CMakeLists.txt b/source/blender/blenkernel/CMakeLists.txt
index 3f22612652c..6b6d2b45d02 100644
--- a/source/blender/blenkernel/CMakeLists.txt
+++ b/source/blender/blenkernel/CMakeLists.txt
@@ -81,6 +81,7 @@ set(SRC
intern/asset.cc
intern/attribute.c
intern/attribute_access.cc
+ intern/attribute_math.cc
intern/autoexec.c
intern/blender.c
intern/blender_copybuffer.c
diff --git a/source/blender/blenkernel/intern/attribute_access.cc b/source/blender/blenkernel/intern/attribute_access.cc
index 772309349ff..cc833e094c8 100644
--- a/source/blender/blenkernel/intern/attribute_access.cc
+++ b/source/blender/blenkernel/intern/attribute_access.cc
@@ -17,6 +17,7 @@
#include <utility>
#include "BKE_attribute_access.hh"
+#include "BKE_attribute_math.hh"
#include "BKE_customdata.h"
#include "BKE_deform.h"
#include "BKE_geometry_set.hh"
@@ -323,6 +324,29 @@ template<typename T> class ArrayReadAttribute final : public ReadAttribute {
}
};
+template<typename T> class OwnedArrayReadAttribute final : public ReadAttribute {
+ private:
+ Array<T> data_;
+
+ public:
+ OwnedArrayReadAttribute(AttributeDomain domain, Array<T> data)
+ : ReadAttribute(domain, CPPType::get<T>(), data.size()), data_(std::move(data))
+ {
+ }
+
+ void get_internal(const int64_t index, void *r_value) const override
+ {
+ new (r_value) T(data_[index]);
+ }
+
+ void initialize_span() const override
+ {
+ /* The data will not be modified, so this const_cast is fine. */
+ array_buffer_ = const_cast<T *>(data_.data());
+ array_is_temporary_ = false;
+ }
+};
+
template<typename StructT,
typename ElemT,
ElemT (*GetFunc)(const StructT &),
@@ -1344,10 +1368,10 @@ ReadAttributePtr GeometryComponent::attribute_try_get_for_read(
return {};
}
-ReadAttributePtr GeometryComponent::attribute_try_adapt_domain(ReadAttributePtr attribute,
- const AttributeDomain domain) const
+ReadAttributePtr GeometryComponent::attribute_try_adapt_domain(
+ ReadAttributePtr attribute, const AttributeDomain new_domain) const
{
- if (attribute && attribute->domain() == domain) {
+ if (attribute && attribute->domain() == new_domain) {
return attribute;
}
return {};
@@ -1765,4 +1789,75 @@ int MeshComponent::attribute_domain_size(const AttributeDomain domain) const
return 0;
}
+namespace blender::bke {
+
+template<typename T>
+void adapt_mesh_domain_corner_to_point_impl(const Mesh &mesh,
+ const TypedReadAttribute<T> &attribute,
+ MutableSpan<T> r_values)
+{
+ BLI_assert(r_values.size() == mesh.totvert);
+ attrib
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list