2023-08-15 16:20:26 +02:00
|
|
|
/* SPDX-FileCopyrightText: 2023 Blender Authors
|
2023-05-31 16:19:06 +02:00
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
2021-01-15 12:00:30 +01:00
|
|
|
|
Geometry Nodes: Initial basic curve data support
This patch adds initial curve support to geometry nodes. Currently
there is only one node available, the "Curve to Mesh" node, T87428.
However, the aim of the changes here is larger than just supporting
curve data in nodes-- it also uses the opportunity to add better spline
data structures, intended to replace the existing curve evaluation code.
The curve code in Blender is quite old, and it's generally regarded as
some of the messiest, hardest-to-understand code as well. The classes
in `BKE_spline.hh` aim to be faster, more extensible, and much more
easily understandable. Further explanation can be found in comments in
that file.
Initial builtin spline attributes are supported-- reading and writing
from the `cyclic` and `resolution` attributes works with any of the
attribute nodes. Also, only Z-up normal calculation is implemented
at the moment, and tilts do not apply yet.
**Limitations**
- For now, you must bring curves into the node tree with an "Object
Info" node. Changes to the curve modifier stack will come later.
- Converting to a mesh is necessary to visualize the curve data.
Further progress can be tracked in: T87245
Higher level design document: https://wiki.blender.org/wiki/Modules/Physics_Nodes/Projects/EverythingNodes/CurveNodes
Differential Revision: https://developer.blender.org/D11091
2021-05-03 19:29:17 +02:00
|
|
|
#pragma once
|
|
|
|
|
2021-02-09 11:44:58 +01:00
|
|
|
#include "BLI_array.hh"
|
2021-01-15 12:00:30 +01:00
|
|
|
#include "BLI_color.hh"
|
2022-03-18 10:57:45 +01:00
|
|
|
#include "BLI_cpp_type.hh"
|
2023-05-12 14:44:39 +02:00
|
|
|
#include "BLI_generic_span.hh"
|
|
|
|
#include "BLI_generic_virtual_array.hh"
|
2023-06-12 15:49:50 +02:00
|
|
|
#include "BLI_math_axis_angle.hh"
|
2022-04-21 16:11:26 +02:00
|
|
|
#include "BLI_math_color.hh"
|
2023-06-12 15:49:50 +02:00
|
|
|
#include "BLI_math_quaternion.hh"
|
2022-02-15 17:27:03 +01:00
|
|
|
#include "BLI_math_vector.h"
|
|
|
|
#include "BLI_math_vector.hh"
|
2023-11-22 21:45:42 +01:00
|
|
|
#include "BLI_offset_indices.hh"
|
2021-02-09 11:44:58 +01:00
|
|
|
|
2023-11-16 11:41:55 +01:00
|
|
|
#include "BKE_customdata.hh"
|
2021-01-15 12:00:30 +01:00
|
|
|
|
2023-05-03 18:07:01 +02:00
|
|
|
namespace blender::bke::attribute_math {
|
2021-01-15 12:00:30 +01:00
|
|
|
|
|
|
|
/**
|
2022-03-19 10:57:40 +01:00
|
|
|
* Utility function that simplifies calling a templated function based on a run-time data type.
|
2021-01-15 12:00:30 +01:00
|
|
|
*/
|
|
|
|
template<typename Func>
|
2022-03-19 10:57:40 +01:00
|
|
|
inline void convert_to_static_type(const CPPType &cpp_type, const Func &func)
|
2021-01-15 12:00:30 +01:00
|
|
|
{
|
2022-04-21 16:11:26 +02:00
|
|
|
cpp_type.to_static_type_tag<float,
|
|
|
|
float2,
|
|
|
|
float3,
|
|
|
|
int,
|
2023-04-14 16:08:05 +02:00
|
|
|
int2,
|
2022-04-21 16:11:26 +02:00
|
|
|
bool,
|
|
|
|
int8_t,
|
|
|
|
ColorGeometry4f,
|
2023-06-12 15:49:50 +02:00
|
|
|
ColorGeometry4b,
|
|
|
|
math::Quaternion>([&](auto type_tag) {
|
2022-04-21 16:11:26 +02:00
|
|
|
using T = typename decltype(type_tag)::type;
|
|
|
|
if constexpr (std::is_same_v<T, void>) {
|
|
|
|
/* It's expected that the given cpp type is one of the supported ones. */
|
|
|
|
BLI_assert_unreachable();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
func(T());
|
|
|
|
}
|
|
|
|
});
|
2021-01-15 12:00:30 +01:00
|
|
|
}
|
|
|
|
|
2021-04-21 17:02:19 +02:00
|
|
|
template<typename Func>
|
2022-06-01 06:38:06 +02:00
|
|
|
inline void convert_to_static_type(const eCustomDataType data_type, const Func &func)
|
2021-04-21 16:57:43 +02:00
|
|
|
{
|
2022-03-19 10:57:40 +01:00
|
|
|
const CPPType &cpp_type = *bke::custom_data_type_to_cpp_type(data_type);
|
|
|
|
convert_to_static_type(cpp_type, func);
|
2021-04-21 16:57:43 +02:00
|
|
|
}
|
|
|
|
|
2022-09-18 04:53:58 +02:00
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/** \name Mix two values of the same type.
|
|
|
|
*
|
|
|
|
* This is just basic linear interpolation.
|
|
|
|
* \{ */
|
|
|
|
|
|
|
|
template<typename T> T mix2(float factor, const T &a, const T &b);
|
|
|
|
|
|
|
|
template<> inline bool mix2(const float factor, const bool &a, const bool &b)
|
|
|
|
{
|
|
|
|
return ((1.0f - factor) * a + factor * b) >= 0.5f;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<> inline int8_t mix2(const float factor, const int8_t &a, const int8_t &b)
|
|
|
|
{
|
2022-09-26 09:38:25 +02:00
|
|
|
return int8_t(std::round((1.0f - factor) * a + factor * b));
|
2022-09-18 04:53:58 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
template<> inline int mix2(const float factor, const int &a, const int &b)
|
|
|
|
{
|
2022-09-26 09:38:25 +02:00
|
|
|
return int(std::round((1.0f - factor) * a + factor * b));
|
2022-09-18 04:53:58 +02:00
|
|
|
}
|
|
|
|
|
2023-04-14 16:08:05 +02:00
|
|
|
template<> inline int2 mix2(const float factor, const int2 &a, const int2 &b)
|
|
|
|
{
|
|
|
|
return math::interpolate(a, b, factor);
|
|
|
|
}
|
|
|
|
|
2022-09-18 04:53:58 +02:00
|
|
|
template<> inline float mix2(const float factor, const float &a, const float &b)
|
|
|
|
{
|
|
|
|
return (1.0f - factor) * a + factor * b;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<> inline float2 mix2(const float factor, const float2 &a, const float2 &b)
|
|
|
|
{
|
|
|
|
return math::interpolate(a, b, factor);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<> inline float3 mix2(const float factor, const float3 &a, const float3 &b)
|
|
|
|
{
|
|
|
|
return math::interpolate(a, b, factor);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<>
|
|
|
|
inline ColorGeometry4f mix2(const float factor, const ColorGeometry4f &a, const ColorGeometry4f &b)
|
|
|
|
{
|
|
|
|
return math::interpolate(a, b, factor);
|
|
|
|
}
|
|
|
|
|
|
|
|
template<>
|
|
|
|
inline ColorGeometry4b mix2(const float factor, const ColorGeometry4b &a, const ColorGeometry4b &b)
|
|
|
|
{
|
|
|
|
return math::interpolate(a, b, factor);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** \} */
|
|
|
|
|
2021-02-09 11:44:58 +01:00
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/** \name Mix three values of the same type.
|
|
|
|
*
|
|
|
|
* This is typically used to interpolate values within a triangle.
|
|
|
|
* \{ */
|
|
|
|
|
2021-01-15 12:00:30 +01:00
|
|
|
template<typename T> T mix3(const float3 &weights, const T &v0, const T &v1, const T &v2);
|
|
|
|
|
2022-02-04 17:29:11 +01:00
|
|
|
template<>
|
|
|
|
inline int8_t mix3(const float3 &weights, const int8_t &v0, const int8_t &v1, const int8_t &v2)
|
|
|
|
{
|
2022-09-26 09:38:25 +02:00
|
|
|
return int8_t(std::round(weights.x * v0 + weights.y * v1 + weights.z * v2));
|
2022-02-04 17:29:11 +01:00
|
|
|
}
|
|
|
|
|
2021-01-15 12:00:30 +01:00
|
|
|
template<> inline bool mix3(const float3 &weights, const bool &v0, const bool &v1, const bool &v2)
|
|
|
|
{
|
|
|
|
return (weights.x * v0 + weights.y * v1 + weights.z * v2) >= 0.5f;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<> inline int mix3(const float3 &weights, const int &v0, const int &v1, const int &v2)
|
|
|
|
{
|
2022-09-26 09:38:25 +02:00
|
|
|
return int(std::round(weights.x * v0 + weights.y * v1 + weights.z * v2));
|
2021-01-15 12:00:30 +01:00
|
|
|
}
|
|
|
|
|
2023-04-14 16:08:05 +02:00
|
|
|
template<> inline int2 mix3(const float3 &weights, const int2 &v0, const int2 &v1, const int2 &v2)
|
|
|
|
{
|
|
|
|
return int2(weights.x * float2(v0) + weights.y * float2(v1) + weights.z * float2(v2));
|
|
|
|
}
|
|
|
|
|
2021-01-15 12:00:30 +01:00
|
|
|
template<>
|
|
|
|
inline float mix3(const float3 &weights, const float &v0, const float &v1, const float &v2)
|
|
|
|
{
|
|
|
|
return weights.x * v0 + weights.y * v1 + weights.z * v2;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<>
|
|
|
|
inline float2 mix3(const float3 &weights, const float2 &v0, const float2 &v1, const float2 &v2)
|
|
|
|
{
|
|
|
|
return weights.x * v0 + weights.y * v1 + weights.z * v2;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<>
|
|
|
|
inline float3 mix3(const float3 &weights, const float3 &v0, const float3 &v1, const float3 &v2)
|
|
|
|
{
|
|
|
|
return weights.x * v0 + weights.y * v1 + weights.z * v2;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<>
|
2021-05-25 17:16:35 +02:00
|
|
|
inline ColorGeometry4f mix3(const float3 &weights,
|
|
|
|
const ColorGeometry4f &v0,
|
|
|
|
const ColorGeometry4f &v1,
|
|
|
|
const ColorGeometry4f &v2)
|
2021-01-15 12:00:30 +01:00
|
|
|
{
|
2021-05-25 17:16:35 +02:00
|
|
|
ColorGeometry4f result;
|
2021-01-15 12:00:30 +01:00
|
|
|
interp_v4_v4v4v4(result, v0, v1, v2, weights);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2022-04-21 16:11:26 +02:00
|
|
|
template<>
|
|
|
|
inline ColorGeometry4b mix3(const float3 &weights,
|
|
|
|
const ColorGeometry4b &v0,
|
|
|
|
const ColorGeometry4b &v1,
|
|
|
|
const ColorGeometry4b &v2)
|
|
|
|
{
|
|
|
|
const float4 v0_f{&v0.r};
|
|
|
|
const float4 v1_f{&v1.r};
|
|
|
|
const float4 v2_f{&v2.r};
|
|
|
|
const float4 mixed = v0_f * weights[0] + v1_f * weights[1] + v2_f * weights[2];
|
2022-09-26 09:38:25 +02:00
|
|
|
return ColorGeometry4b{
|
|
|
|
uint8_t(mixed[0]), uint8_t(mixed[1]), uint8_t(mixed[2]), uint8_t(mixed[3])};
|
2022-04-21 16:11:26 +02:00
|
|
|
}
|
|
|
|
|
2021-02-09 11:44:58 +01:00
|
|
|
/** \} */
|
|
|
|
|
2021-04-30 04:52:34 +02:00
|
|
|
/* -------------------------------------------------------------------- */
|
2022-09-18 04:53:58 +02:00
|
|
|
/** \name Mix four values of the same type.
|
2021-04-30 04:52:34 +02:00
|
|
|
*
|
|
|
|
* \{ */
|
|
|
|
|
2022-09-18 04:53:58 +02:00
|
|
|
template<typename T>
|
|
|
|
T mix4(const float4 &weights, const T &v0, const T &v1, const T &v2, const T &v3);
|
2021-04-30 04:52:34 +02:00
|
|
|
|
2022-09-18 04:53:58 +02:00
|
|
|
template<>
|
|
|
|
inline int8_t mix4(
|
|
|
|
const float4 &weights, const int8_t &v0, const int8_t &v1, const int8_t &v2, const int8_t &v3)
|
2021-04-30 04:52:34 +02:00
|
|
|
{
|
2022-09-26 09:38:25 +02:00
|
|
|
return int8_t(std::round(weights.x * v0 + weights.y * v1 + weights.z * v2 + weights.w * v3));
|
2021-04-30 04:52:34 +02:00
|
|
|
}
|
|
|
|
|
2022-09-18 04:53:58 +02:00
|
|
|
template<>
|
|
|
|
inline bool mix4(
|
|
|
|
const float4 &weights, const bool &v0, const bool &v1, const bool &v2, const bool &v3)
|
2022-02-04 17:29:11 +01:00
|
|
|
{
|
2022-09-18 04:53:58 +02:00
|
|
|
return (weights.x * v0 + weights.y * v1 + weights.z * v2 + weights.w * v3) >= 0.5f;
|
2022-02-04 17:29:11 +01:00
|
|
|
}
|
|
|
|
|
2022-09-18 04:53:58 +02:00
|
|
|
template<>
|
|
|
|
inline int mix4(const float4 &weights, const int &v0, const int &v1, const int &v2, const int &v3)
|
2021-04-30 04:52:34 +02:00
|
|
|
{
|
2022-09-26 09:38:25 +02:00
|
|
|
return int(std::round(weights.x * v0 + weights.y * v1 + weights.z * v2 + weights.w * v3));
|
2021-04-30 04:52:34 +02:00
|
|
|
}
|
|
|
|
|
2023-04-14 16:08:05 +02:00
|
|
|
template<>
|
|
|
|
inline int2 mix4(
|
|
|
|
const float4 &weights, const int2 &v0, const int2 &v1, const int2 &v2, const int2 &v3)
|
|
|
|
{
|
|
|
|
return int2(weights.x * float2(v0) + weights.y * float2(v1) + weights.z * float2(v2) +
|
|
|
|
weights.w * float2(v3));
|
|
|
|
}
|
|
|
|
|
2022-09-18 04:53:58 +02:00
|
|
|
template<>
|
|
|
|
inline float mix4(
|
|
|
|
const float4 &weights, const float &v0, const float &v1, const float &v2, const float &v3)
|
2021-04-30 04:52:34 +02:00
|
|
|
{
|
2022-09-18 04:53:58 +02:00
|
|
|
return weights.x * v0 + weights.y * v1 + weights.z * v2 + weights.w * v3;
|
2021-04-30 04:52:34 +02:00
|
|
|
}
|
|
|
|
|
2022-09-18 04:53:58 +02:00
|
|
|
template<>
|
|
|
|
inline float2 mix4(
|
|
|
|
const float4 &weights, const float2 &v0, const float2 &v1, const float2 &v2, const float2 &v3)
|
2021-04-30 04:52:34 +02:00
|
|
|
{
|
2022-09-18 04:53:58 +02:00
|
|
|
return weights.x * v0 + weights.y * v1 + weights.z * v2 + weights.w * v3;
|
2021-04-30 04:52:34 +02:00
|
|
|
}
|
|
|
|
|
2022-09-18 04:53:58 +02:00
|
|
|
template<>
|
|
|
|
inline float3 mix4(
|
|
|
|
const float4 &weights, const float3 &v0, const float3 &v1, const float3 &v2, const float3 &v3)
|
2021-04-30 04:52:34 +02:00
|
|
|
{
|
2022-09-18 04:53:58 +02:00
|
|
|
return weights.x * v0 + weights.y * v1 + weights.z * v2 + weights.w * v3;
|
2021-04-30 04:52:34 +02:00
|
|
|
}
|
|
|
|
|
2021-05-25 17:16:35 +02:00
|
|
|
template<>
|
2022-09-18 04:53:58 +02:00
|
|
|
inline ColorGeometry4f mix4(const float4 &weights,
|
|
|
|
const ColorGeometry4f &v0,
|
|
|
|
const ColorGeometry4f &v1,
|
|
|
|
const ColorGeometry4f &v2,
|
|
|
|
const ColorGeometry4f &v3)
|
2021-04-30 04:52:34 +02:00
|
|
|
{
|
2022-09-18 04:53:58 +02:00
|
|
|
ColorGeometry4f result;
|
|
|
|
interp_v4_v4v4v4v4(result, v0, v1, v2, v3, weights);
|
|
|
|
return result;
|
2022-04-21 16:11:26 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
template<>
|
2022-09-18 04:53:58 +02:00
|
|
|
inline ColorGeometry4b mix4(const float4 &weights,
|
|
|
|
const ColorGeometry4b &v0,
|
|
|
|
const ColorGeometry4b &v1,
|
|
|
|
const ColorGeometry4b &v2,
|
|
|
|
const ColorGeometry4b &v3)
|
2022-04-21 16:11:26 +02:00
|
|
|
{
|
2022-09-18 04:53:58 +02:00
|
|
|
const float4 v0_f{&v0.r};
|
|
|
|
const float4 v1_f{&v1.r};
|
|
|
|
const float4 v2_f{&v2.r};
|
|
|
|
const float4 v3_f{&v3.r};
|
|
|
|
float4 mixed;
|
|
|
|
interp_v4_v4v4v4v4(mixed, v0_f, v1_f, v2_f, v3_f, weights);
|
2022-09-26 09:38:25 +02:00
|
|
|
return ColorGeometry4b{
|
|
|
|
uint8_t(mixed[0]), uint8_t(mixed[1]), uint8_t(mixed[2]), uint8_t(mixed[3])};
|
2021-04-30 04:52:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/** \} */
|
|
|
|
|
2021-02-09 11:44:58 +01:00
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/** \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 = {})
|
2022-08-03 17:17:36 +02:00
|
|
|
: SimpleMixer(buffer, buffer.index_range(), default_value)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* \param mask: Only initialize these indices. Other indices in the buffer will be invalid.
|
|
|
|
*/
|
BLI: refactor IndexMask for better performance and memory usage
Goals of this refactor:
* Reduce memory consumption of `IndexMask`. The old `IndexMask` uses an
`int64_t` for each index which is more than necessary in pretty much all
practical cases currently. Using `int32_t` might still become limiting
in the future in case we use this to index e.g. byte buffers larger than
a few gigabytes. We also don't want to template `IndexMask`, because
that would cause a split in the "ecosystem", or everything would have to
be implemented twice or templated.
* Allow for more multi-threading. The old `IndexMask` contains a single
array. This is generally good but has the problem that it is hard to fill
from multiple-threads when the final size is not known from the beginning.
This is commonly the case when e.g. converting an array of bool to an
index mask. Currently, this kind of code only runs on a single thread.
* Allow for efficient set operations like join, intersect and difference.
It should be possible to multi-thread those operations.
* It should be possible to iterate over an `IndexMask` very efficiently.
The most important part of that is to avoid all memory access when iterating
over continuous ranges. For some core nodes (e.g. math nodes), we generate
optimized code for the cases of irregular index masks and simple index ranges.
To achieve these goals, a few compromises had to made:
* Slicing of the mask (at specific indices) and random element access is
`O(log #indices)` now, but with a low constant factor. It should be possible
to split a mask into n approximately equally sized parts in `O(n)` though,
making the time per split `O(1)`.
* Using range-based for loops does not work well when iterating over a nested
data structure like the new `IndexMask`. Therefor, `foreach_*` functions with
callbacks have to be used. To avoid extra code complexity at the call site,
the `foreach_*` methods support multi-threading out of the box.
The new data structure splits an `IndexMask` into an arbitrary number of ordered
`IndexMaskSegment`. Each segment can contain at most `2^14 = 16384` indices. The
indices within a segment are stored as `int16_t`. Each segment has an additional
`int64_t` offset which allows storing arbitrary `int64_t` indices. This approach
has the main benefits that segments can be processed/constructed individually on
multiple threads without a serial bottleneck. Also it reduces the memory
requirements significantly.
For more details see comments in `BLI_index_mask.hh`.
I did a few tests to verify that the data structure generally improves
performance and does not cause regressions:
* Our field evaluation benchmarks take about as much as before. This is to be
expected because we already made sure that e.g. add node evaluation is
vectorized. The important thing here is to check that changes to the way we
iterate over the indices still allows for auto-vectorization.
* Memory usage by a mask is about 1/4 of what it was before in the average case.
That's mainly caused by the switch from `int64_t` to `int16_t` for indices.
In the worst case, the memory requirements can be larger when there are many
indices that are very far away. However, when they are far away from each other,
that indicates that there aren't many indices in total. In common cases, memory
usage can be way lower than 1/4 of before, because sub-ranges use static memory.
* For some more specific numbers I benchmarked `IndexMask::from_bools` in
`index_mask_from_selection` on 10.000.000 elements at various probabilities for
`true` at every index:
```
Probability Old New
0 4.6 ms 0.8 ms
0.001 5.1 ms 1.3 ms
0.2 8.4 ms 1.8 ms
0.5 15.3 ms 3.0 ms
0.8 20.1 ms 3.0 ms
0.999 25.1 ms 1.7 ms
1 13.5 ms 1.1 ms
```
Pull Request: https://projects.blender.org/blender/blender/pulls/104629
2023-05-24 18:11:41 +02:00
|
|
|
SimpleMixer(MutableSpan<T> buffer, const IndexMask &mask, T default_value = {})
|
2021-02-09 11:44:58 +01:00
|
|
|
: buffer_(buffer), default_value_(default_value), total_weights_(buffer.size(), 0.0f)
|
|
|
|
{
|
|
|
|
BLI_STATIC_ASSERT(std::is_trivial_v<T>, "");
|
2022-08-03 17:17:36 +02:00
|
|
|
mask.foreach_index([&](const int64_t i) { buffer_[i] = default_value_; });
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a #value into the element with the given #index.
|
|
|
|
*/
|
|
|
|
void set(const int64_t index, const T &value, const float weight = 1.0f)
|
|
|
|
{
|
|
|
|
buffer_[index] = value * weight;
|
|
|
|
total_weights_[index] = weight;
|
2021-02-09 11:44:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
|
|
|
buffer_[index] += value * weight;
|
|
|
|
total_weights_[index] += weight;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Has to be called before the buffer provided in the constructor is used.
|
|
|
|
*/
|
|
|
|
void finalize()
|
|
|
|
{
|
2022-08-03 17:17:36 +02:00
|
|
|
this->finalize(IndexMask(buffer_.size()));
|
|
|
|
}
|
|
|
|
|
BLI: refactor IndexMask for better performance and memory usage
Goals of this refactor:
* Reduce memory consumption of `IndexMask`. The old `IndexMask` uses an
`int64_t` for each index which is more than necessary in pretty much all
practical cases currently. Using `int32_t` might still become limiting
in the future in case we use this to index e.g. byte buffers larger than
a few gigabytes. We also don't want to template `IndexMask`, because
that would cause a split in the "ecosystem", or everything would have to
be implemented twice or templated.
* Allow for more multi-threading. The old `IndexMask` contains a single
array. This is generally good but has the problem that it is hard to fill
from multiple-threads when the final size is not known from the beginning.
This is commonly the case when e.g. converting an array of bool to an
index mask. Currently, this kind of code only runs on a single thread.
* Allow for efficient set operations like join, intersect and difference.
It should be possible to multi-thread those operations.
* It should be possible to iterate over an `IndexMask` very efficiently.
The most important part of that is to avoid all memory access when iterating
over continuous ranges. For some core nodes (e.g. math nodes), we generate
optimized code for the cases of irregular index masks and simple index ranges.
To achieve these goals, a few compromises had to made:
* Slicing of the mask (at specific indices) and random element access is
`O(log #indices)` now, but with a low constant factor. It should be possible
to split a mask into n approximately equally sized parts in `O(n)` though,
making the time per split `O(1)`.
* Using range-based for loops does not work well when iterating over a nested
data structure like the new `IndexMask`. Therefor, `foreach_*` functions with
callbacks have to be used. To avoid extra code complexity at the call site,
the `foreach_*` methods support multi-threading out of the box.
The new data structure splits an `IndexMask` into an arbitrary number of ordered
`IndexMaskSegment`. Each segment can contain at most `2^14 = 16384` indices. The
indices within a segment are stored as `int16_t`. Each segment has an additional
`int64_t` offset which allows storing arbitrary `int64_t` indices. This approach
has the main benefits that segments can be processed/constructed individually on
multiple threads without a serial bottleneck. Also it reduces the memory
requirements significantly.
For more details see comments in `BLI_index_mask.hh`.
I did a few tests to verify that the data structure generally improves
performance and does not cause regressions:
* Our field evaluation benchmarks take about as much as before. This is to be
expected because we already made sure that e.g. add node evaluation is
vectorized. The important thing here is to check that changes to the way we
iterate over the indices still allows for auto-vectorization.
* Memory usage by a mask is about 1/4 of what it was before in the average case.
That's mainly caused by the switch from `int64_t` to `int16_t` for indices.
In the worst case, the memory requirements can be larger when there are many
indices that are very far away. However, when they are far away from each other,
that indicates that there aren't many indices in total. In common cases, memory
usage can be way lower than 1/4 of before, because sub-ranges use static memory.
* For some more specific numbers I benchmarked `IndexMask::from_bools` in
`index_mask_from_selection` on 10.000.000 elements at various probabilities for
`true` at every index:
```
Probability Old New
0 4.6 ms 0.8 ms
0.001 5.1 ms 1.3 ms
0.2 8.4 ms 1.8 ms
0.5 15.3 ms 3.0 ms
0.8 20.1 ms 3.0 ms
0.999 25.1 ms 1.7 ms
1 13.5 ms 1.1 ms
```
Pull Request: https://projects.blender.org/blender/blender/pulls/104629
2023-05-24 18:11:41 +02:00
|
|
|
void finalize(const IndexMask &mask)
|
2022-08-03 17:17:36 +02:00
|
|
|
{
|
|
|
|
mask.foreach_index([&](const int64_t i) {
|
2021-02-09 11:44:58 +01:00
|
|
|
const float weight = total_weights_[i];
|
|
|
|
if (weight > 0.0f) {
|
|
|
|
buffer_[i] *= 1.0f / weight;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
buffer_[i] = default_value_;
|
|
|
|
}
|
2022-08-03 17:17:36 +02:00
|
|
|
});
|
2021-02-09 11:44:58 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
Geometry Nodes: Extrude Mesh Node
This patch introduces an extrude node with three modes. The vertex mode
is quite simple, and just attaches new edges to the selected vertices.
The edge mode attaches new faces to the selected edges. The faces mode
extrudes patches of selected faces, or each selected face individually,
depending on the "Individual" boolean input.
The default value of the "Offset" input is the mesh's normals, which
can be scaled with the "Offset Scale" input.
**Attribute Propagation**
Attributes are transferred to the new elements with specific rules.
Attributes will never change domains for interpolations. Generally
boolean attributes are propagated with "or", meaning any connected
"true" value that is mixed in for other types will cause the new value
to be "true" as well. The `"id"` attribute does not have any special
handling currently.
Vertex Mode
- Vertex: Copied values of selected vertices.
- Edge: Averaged values of selected edges. For booleans, edges are
selected if any connected edges are selected.
Edge Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected extruded
edges. For booleans, the edges are selected if any connected
extruded edges are selected.
- Duplicate edges: Copied values of selected edges.
- Face: Averaged values of all faces connected to the selected edge.
For booleans, faces are selected if any connected original faces
are selected.
- Corner: Averaged values of corresponding corners in all faces
connected to selected edges. For booleans, corners are selected
if one of those corners are selected.
Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected selected
edges, not including the edges "on top" of extruded regions.
For booleans, edges are selected when any connected extruded edges
were selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
Individual Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of the two neighboring
edges on each extruded face. For booleans, edges are selected
when at least one neighbor on the extruded face was selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
**Differences from edit mode**
In face mode (non-individual), the behavior can be different than the
extrude tools in edit mode-- this node doesn't handle keeping the back-
faces around in the cases that the edit mode tools do. The planned
"Solidify" node will handle that use case instead. Keeping this node
simpler and faster is preferable at this point, especially because that
sort of "smart" behavior is not that predictable and makes less sense
in a procedural context.
In the future, an "Even Offset" option could be added to this node
hopefully fairly simply. For now it is left out in order to keep
the patch simpler.
**Implementation**
For the implementation, the `Mesh` data structure is used directly
rather than converting to `BMesh` and back like D12224. This optimizes
for large extrusion operations rather than many sequential extrusions.
While this is potentially more verbose, it has some important benefits:
First, there is no conversion to and from `BMesh`. The code only has
to fill arrays and it can do that all at once, making each component of
the algorithm much easier to optimize. It also makes the attribute
interpolation more explicit, and likely faster. Only limited topology
maps must be created in most cases.
While there are some necessary loops and allocations with the size of
the entire mesh, I tried to keep everything I could on the order of the
size of the selection rather than the size of the mesh. In that respect,
the individual faces mode is the best, since there is no topology
information necessary, and the amount of work just depends on the size
of the selection.
Modifying an existing mesh instead of generating a new one was a bit
of a toss-up, but has a few potential benefits:
- Avoids manually copying over attribute data for original elements.
- Avoids some overhead of creating a new mesh.
- Can potentially take advantage of future ammortized mesh growth.
This could be changed easily if it turns out to be the wrong choice.
Differential Revision: https://developer.blender.org/D13709
2022-01-24 05:42:49 +01:00
|
|
|
/**
|
|
|
|
* Mixes together booleans with "or" while fitting the same interface as the other
|
|
|
|
* mixers in order to be simpler to use. This mixing method has a few benefits:
|
|
|
|
* - An "average" for selections is relatively meaningless.
|
|
|
|
* - Predictable selection propagation is very super important.
|
|
|
|
* - It's generally easier to remove an element from a selection that is slightly too large than
|
|
|
|
* the opposite.
|
|
|
|
*/
|
|
|
|
class BooleanPropagationMixer {
|
|
|
|
private:
|
|
|
|
MutableSpan<bool> buffer_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* \param buffer: Span where the interpolated values should be stored.
|
|
|
|
*/
|
2022-08-03 17:17:36 +02:00
|
|
|
BooleanPropagationMixer(MutableSpan<bool> buffer)
|
|
|
|
: BooleanPropagationMixer(buffer, buffer.index_range())
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* \param mask: Only initialize these indices. Other indices in the buffer will be invalid.
|
|
|
|
*/
|
BLI: refactor IndexMask for better performance and memory usage
Goals of this refactor:
* Reduce memory consumption of `IndexMask`. The old `IndexMask` uses an
`int64_t` for each index which is more than necessary in pretty much all
practical cases currently. Using `int32_t` might still become limiting
in the future in case we use this to index e.g. byte buffers larger than
a few gigabytes. We also don't want to template `IndexMask`, because
that would cause a split in the "ecosystem", or everything would have to
be implemented twice or templated.
* Allow for more multi-threading. The old `IndexMask` contains a single
array. This is generally good but has the problem that it is hard to fill
from multiple-threads when the final size is not known from the beginning.
This is commonly the case when e.g. converting an array of bool to an
index mask. Currently, this kind of code only runs on a single thread.
* Allow for efficient set operations like join, intersect and difference.
It should be possible to multi-thread those operations.
* It should be possible to iterate over an `IndexMask` very efficiently.
The most important part of that is to avoid all memory access when iterating
over continuous ranges. For some core nodes (e.g. math nodes), we generate
optimized code for the cases of irregular index masks and simple index ranges.
To achieve these goals, a few compromises had to made:
* Slicing of the mask (at specific indices) and random element access is
`O(log #indices)` now, but with a low constant factor. It should be possible
to split a mask into n approximately equally sized parts in `O(n)` though,
making the time per split `O(1)`.
* Using range-based for loops does not work well when iterating over a nested
data structure like the new `IndexMask`. Therefor, `foreach_*` functions with
callbacks have to be used. To avoid extra code complexity at the call site,
the `foreach_*` methods support multi-threading out of the box.
The new data structure splits an `IndexMask` into an arbitrary number of ordered
`IndexMaskSegment`. Each segment can contain at most `2^14 = 16384` indices. The
indices within a segment are stored as `int16_t`. Each segment has an additional
`int64_t` offset which allows storing arbitrary `int64_t` indices. This approach
has the main benefits that segments can be processed/constructed individually on
multiple threads without a serial bottleneck. Also it reduces the memory
requirements significantly.
For more details see comments in `BLI_index_mask.hh`.
I did a few tests to verify that the data structure generally improves
performance and does not cause regressions:
* Our field evaluation benchmarks take about as much as before. This is to be
expected because we already made sure that e.g. add node evaluation is
vectorized. The important thing here is to check that changes to the way we
iterate over the indices still allows for auto-vectorization.
* Memory usage by a mask is about 1/4 of what it was before in the average case.
That's mainly caused by the switch from `int64_t` to `int16_t` for indices.
In the worst case, the memory requirements can be larger when there are many
indices that are very far away. However, when they are far away from each other,
that indicates that there aren't many indices in total. In common cases, memory
usage can be way lower than 1/4 of before, because sub-ranges use static memory.
* For some more specific numbers I benchmarked `IndexMask::from_bools` in
`index_mask_from_selection` on 10.000.000 elements at various probabilities for
`true` at every index:
```
Probability Old New
0 4.6 ms 0.8 ms
0.001 5.1 ms 1.3 ms
0.2 8.4 ms 1.8 ms
0.5 15.3 ms 3.0 ms
0.8 20.1 ms 3.0 ms
0.999 25.1 ms 1.7 ms
1 13.5 ms 1.1 ms
```
Pull Request: https://projects.blender.org/blender/blender/pulls/104629
2023-05-24 18:11:41 +02:00
|
|
|
BooleanPropagationMixer(MutableSpan<bool> buffer, const IndexMask &mask) : buffer_(buffer)
|
2022-08-03 17:17:36 +02:00
|
|
|
{
|
|
|
|
mask.foreach_index([&](const int64_t i) { buffer_[i] = false; });
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a #value into the element with the given #index.
|
|
|
|
*/
|
|
|
|
void set(const int64_t index, const bool value, [[maybe_unused]] const float weight = 1.0f)
|
Geometry Nodes: Extrude Mesh Node
This patch introduces an extrude node with three modes. The vertex mode
is quite simple, and just attaches new edges to the selected vertices.
The edge mode attaches new faces to the selected edges. The faces mode
extrudes patches of selected faces, or each selected face individually,
depending on the "Individual" boolean input.
The default value of the "Offset" input is the mesh's normals, which
can be scaled with the "Offset Scale" input.
**Attribute Propagation**
Attributes are transferred to the new elements with specific rules.
Attributes will never change domains for interpolations. Generally
boolean attributes are propagated with "or", meaning any connected
"true" value that is mixed in for other types will cause the new value
to be "true" as well. The `"id"` attribute does not have any special
handling currently.
Vertex Mode
- Vertex: Copied values of selected vertices.
- Edge: Averaged values of selected edges. For booleans, edges are
selected if any connected edges are selected.
Edge Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected extruded
edges. For booleans, the edges are selected if any connected
extruded edges are selected.
- Duplicate edges: Copied values of selected edges.
- Face: Averaged values of all faces connected to the selected edge.
For booleans, faces are selected if any connected original faces
are selected.
- Corner: Averaged values of corresponding corners in all faces
connected to selected edges. For booleans, corners are selected
if one of those corners are selected.
Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected selected
edges, not including the edges "on top" of extruded regions.
For booleans, edges are selected when any connected extruded edges
were selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
Individual Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of the two neighboring
edges on each extruded face. For booleans, edges are selected
when at least one neighbor on the extruded face was selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
**Differences from edit mode**
In face mode (non-individual), the behavior can be different than the
extrude tools in edit mode-- this node doesn't handle keeping the back-
faces around in the cases that the edit mode tools do. The planned
"Solidify" node will handle that use case instead. Keeping this node
simpler and faster is preferable at this point, especially because that
sort of "smart" behavior is not that predictable and makes less sense
in a procedural context.
In the future, an "Even Offset" option could be added to this node
hopefully fairly simply. For now it is left out in order to keep
the patch simpler.
**Implementation**
For the implementation, the `Mesh` data structure is used directly
rather than converting to `BMesh` and back like D12224. This optimizes
for large extrusion operations rather than many sequential extrusions.
While this is potentially more verbose, it has some important benefits:
First, there is no conversion to and from `BMesh`. The code only has
to fill arrays and it can do that all at once, making each component of
the algorithm much easier to optimize. It also makes the attribute
interpolation more explicit, and likely faster. Only limited topology
maps must be created in most cases.
While there are some necessary loops and allocations with the size of
the entire mesh, I tried to keep everything I could on the order of the
size of the selection rather than the size of the mesh. In that respect,
the individual faces mode is the best, since there is no topology
information necessary, and the amount of work just depends on the size
of the selection.
Modifying an existing mesh instead of generating a new one was a bit
of a toss-up, but has a few potential benefits:
- Avoids manually copying over attribute data for original elements.
- Avoids some overhead of creating a new mesh.
- Can potentially take advantage of future ammortized mesh growth.
This could be changed easily if it turns out to be the wrong choice.
Differential Revision: https://developer.blender.org/D13709
2022-01-24 05:42:49 +01:00
|
|
|
{
|
2022-08-03 17:17:36 +02:00
|
|
|
buffer_[index] = value;
|
Geometry Nodes: Extrude Mesh Node
This patch introduces an extrude node with three modes. The vertex mode
is quite simple, and just attaches new edges to the selected vertices.
The edge mode attaches new faces to the selected edges. The faces mode
extrudes patches of selected faces, or each selected face individually,
depending on the "Individual" boolean input.
The default value of the "Offset" input is the mesh's normals, which
can be scaled with the "Offset Scale" input.
**Attribute Propagation**
Attributes are transferred to the new elements with specific rules.
Attributes will never change domains for interpolations. Generally
boolean attributes are propagated with "or", meaning any connected
"true" value that is mixed in for other types will cause the new value
to be "true" as well. The `"id"` attribute does not have any special
handling currently.
Vertex Mode
- Vertex: Copied values of selected vertices.
- Edge: Averaged values of selected edges. For booleans, edges are
selected if any connected edges are selected.
Edge Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected extruded
edges. For booleans, the edges are selected if any connected
extruded edges are selected.
- Duplicate edges: Copied values of selected edges.
- Face: Averaged values of all faces connected to the selected edge.
For booleans, faces are selected if any connected original faces
are selected.
- Corner: Averaged values of corresponding corners in all faces
connected to selected edges. For booleans, corners are selected
if one of those corners are selected.
Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected selected
edges, not including the edges "on top" of extruded regions.
For booleans, edges are selected when any connected extruded edges
were selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
Individual Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of the two neighboring
edges on each extruded face. For booleans, edges are selected
when at least one neighbor on the extruded face was selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
**Differences from edit mode**
In face mode (non-individual), the behavior can be different than the
extrude tools in edit mode-- this node doesn't handle keeping the back-
faces around in the cases that the edit mode tools do. The planned
"Solidify" node will handle that use case instead. Keeping this node
simpler and faster is preferable at this point, especially because that
sort of "smart" behavior is not that predictable and makes less sense
in a procedural context.
In the future, an "Even Offset" option could be added to this node
hopefully fairly simply. For now it is left out in order to keep
the patch simpler.
**Implementation**
For the implementation, the `Mesh` data structure is used directly
rather than converting to `BMesh` and back like D12224. This optimizes
for large extrusion operations rather than many sequential extrusions.
While this is potentially more verbose, it has some important benefits:
First, there is no conversion to and from `BMesh`. The code only has
to fill arrays and it can do that all at once, making each component of
the algorithm much easier to optimize. It also makes the attribute
interpolation more explicit, and likely faster. Only limited topology
maps must be created in most cases.
While there are some necessary loops and allocations with the size of
the entire mesh, I tried to keep everything I could on the order of the
size of the selection rather than the size of the mesh. In that respect,
the individual faces mode is the best, since there is no topology
information necessary, and the amount of work just depends on the size
of the selection.
Modifying an existing mesh instead of generating a new one was a bit
of a toss-up, but has a few potential benefits:
- Avoids manually copying over attribute data for original elements.
- Avoids some overhead of creating a new mesh.
- Can potentially take advantage of future ammortized mesh growth.
This could be changed easily if it turns out to be the wrong choice.
Differential Revision: https://developer.blender.org/D13709
2022-01-24 05:42:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Mix a #value into the element with the given #index.
|
|
|
|
*/
|
|
|
|
void mix_in(const int64_t index, const bool value, [[maybe_unused]] const float weight = 1.0f)
|
|
|
|
{
|
|
|
|
buffer_[index] |= value;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Does not do anything, since the mixing is trivial.
|
|
|
|
*/
|
2023-03-29 16:50:54 +02:00
|
|
|
void finalize() {}
|
2022-08-03 17:17:36 +02:00
|
|
|
|
BLI: refactor IndexMask for better performance and memory usage
Goals of this refactor:
* Reduce memory consumption of `IndexMask`. The old `IndexMask` uses an
`int64_t` for each index which is more than necessary in pretty much all
practical cases currently. Using `int32_t` might still become limiting
in the future in case we use this to index e.g. byte buffers larger than
a few gigabytes. We also don't want to template `IndexMask`, because
that would cause a split in the "ecosystem", or everything would have to
be implemented twice or templated.
* Allow for more multi-threading. The old `IndexMask` contains a single
array. This is generally good but has the problem that it is hard to fill
from multiple-threads when the final size is not known from the beginning.
This is commonly the case when e.g. converting an array of bool to an
index mask. Currently, this kind of code only runs on a single thread.
* Allow for efficient set operations like join, intersect and difference.
It should be possible to multi-thread those operations.
* It should be possible to iterate over an `IndexMask` very efficiently.
The most important part of that is to avoid all memory access when iterating
over continuous ranges. For some core nodes (e.g. math nodes), we generate
optimized code for the cases of irregular index masks and simple index ranges.
To achieve these goals, a few compromises had to made:
* Slicing of the mask (at specific indices) and random element access is
`O(log #indices)` now, but with a low constant factor. It should be possible
to split a mask into n approximately equally sized parts in `O(n)` though,
making the time per split `O(1)`.
* Using range-based for loops does not work well when iterating over a nested
data structure like the new `IndexMask`. Therefor, `foreach_*` functions with
callbacks have to be used. To avoid extra code complexity at the call site,
the `foreach_*` methods support multi-threading out of the box.
The new data structure splits an `IndexMask` into an arbitrary number of ordered
`IndexMaskSegment`. Each segment can contain at most `2^14 = 16384` indices. The
indices within a segment are stored as `int16_t`. Each segment has an additional
`int64_t` offset which allows storing arbitrary `int64_t` indices. This approach
has the main benefits that segments can be processed/constructed individually on
multiple threads without a serial bottleneck. Also it reduces the memory
requirements significantly.
For more details see comments in `BLI_index_mask.hh`.
I did a few tests to verify that the data structure generally improves
performance and does not cause regressions:
* Our field evaluation benchmarks take about as much as before. This is to be
expected because we already made sure that e.g. add node evaluation is
vectorized. The important thing here is to check that changes to the way we
iterate over the indices still allows for auto-vectorization.
* Memory usage by a mask is about 1/4 of what it was before in the average case.
That's mainly caused by the switch from `int64_t` to `int16_t` for indices.
In the worst case, the memory requirements can be larger when there are many
indices that are very far away. However, when they are far away from each other,
that indicates that there aren't many indices in total. In common cases, memory
usage can be way lower than 1/4 of before, because sub-ranges use static memory.
* For some more specific numbers I benchmarked `IndexMask::from_bools` in
`index_mask_from_selection` on 10.000.000 elements at various probabilities for
`true` at every index:
```
Probability Old New
0 4.6 ms 0.8 ms
0.001 5.1 ms 1.3 ms
0.2 8.4 ms 1.8 ms
0.5 15.3 ms 3.0 ms
0.8 20.1 ms 3.0 ms
0.999 25.1 ms 1.7 ms
1 13.5 ms 1.1 ms
```
Pull Request: https://projects.blender.org/blender/blender/pulls/104629
2023-05-24 18:11:41 +02:00
|
|
|
void finalize(const IndexMask & /*mask*/) {}
|
Geometry Nodes: Extrude Mesh Node
This patch introduces an extrude node with three modes. The vertex mode
is quite simple, and just attaches new edges to the selected vertices.
The edge mode attaches new faces to the selected edges. The faces mode
extrudes patches of selected faces, or each selected face individually,
depending on the "Individual" boolean input.
The default value of the "Offset" input is the mesh's normals, which
can be scaled with the "Offset Scale" input.
**Attribute Propagation**
Attributes are transferred to the new elements with specific rules.
Attributes will never change domains for interpolations. Generally
boolean attributes are propagated with "or", meaning any connected
"true" value that is mixed in for other types will cause the new value
to be "true" as well. The `"id"` attribute does not have any special
handling currently.
Vertex Mode
- Vertex: Copied values of selected vertices.
- Edge: Averaged values of selected edges. For booleans, edges are
selected if any connected edges are selected.
Edge Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected extruded
edges. For booleans, the edges are selected if any connected
extruded edges are selected.
- Duplicate edges: Copied values of selected edges.
- Face: Averaged values of all faces connected to the selected edge.
For booleans, faces are selected if any connected original faces
are selected.
- Corner: Averaged values of corresponding corners in all faces
connected to selected edges. For booleans, corners are selected
if one of those corners are selected.
Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected selected
edges, not including the edges "on top" of extruded regions.
For booleans, edges are selected when any connected extruded edges
were selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
Individual Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of the two neighboring
edges on each extruded face. For booleans, edges are selected
when at least one neighbor on the extruded face was selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
**Differences from edit mode**
In face mode (non-individual), the behavior can be different than the
extrude tools in edit mode-- this node doesn't handle keeping the back-
faces around in the cases that the edit mode tools do. The planned
"Solidify" node will handle that use case instead. Keeping this node
simpler and faster is preferable at this point, especially because that
sort of "smart" behavior is not that predictable and makes less sense
in a procedural context.
In the future, an "Even Offset" option could be added to this node
hopefully fairly simply. For now it is left out in order to keep
the patch simpler.
**Implementation**
For the implementation, the `Mesh` data structure is used directly
rather than converting to `BMesh` and back like D12224. This optimizes
for large extrusion operations rather than many sequential extrusions.
While this is potentially more verbose, it has some important benefits:
First, there is no conversion to and from `BMesh`. The code only has
to fill arrays and it can do that all at once, making each component of
the algorithm much easier to optimize. It also makes the attribute
interpolation more explicit, and likely faster. Only limited topology
maps must be created in most cases.
While there are some necessary loops and allocations with the size of
the entire mesh, I tried to keep everything I could on the order of the
size of the selection rather than the size of the mesh. In that respect,
the individual faces mode is the best, since there is no topology
information necessary, and the amount of work just depends on the size
of the selection.
Modifying an existing mesh instead of generating a new one was a bit
of a toss-up, but has a few potential benefits:
- Avoids manually copying over attribute data for original elements.
- Avoids some overhead of creating a new mesh.
- Can potentially take advantage of future ammortized mesh growth.
This could be changed easily if it turns out to be the wrong choice.
Differential Revision: https://developer.blender.org/D13709
2022-01-24 05:42:49 +01:00
|
|
|
};
|
|
|
|
|
2021-05-12 13:55:25 +02:00
|
|
|
/**
|
|
|
|
* 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).
|
|
|
|
*/
|
2023-06-12 15:49:50 +02:00
|
|
|
template<typename T,
|
|
|
|
typename AccumulationT,
|
|
|
|
AccumulationT (*ValueToAccumulate)(const T &value),
|
|
|
|
T (*AccumulateToValue)(const AccumulationT &value)>
|
2021-02-09 11:44:58 +01:00
|
|
|
class SimpleMixerWithAccumulationType {
|
|
|
|
private:
|
|
|
|
struct Item {
|
|
|
|
/* Store both values together, because they are accessed together. */
|
2023-04-14 16:08:05 +02:00
|
|
|
AccumulationT value = AccumulationT(0);
|
2021-02-09 11:44:58 +01:00
|
|
|
float weight = 0.0f;
|
|
|
|
};
|
|
|
|
|
|
|
|
MutableSpan<T> buffer_;
|
|
|
|
T default_value_;
|
|
|
|
Array<Item> accumulation_buffer_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
SimpleMixerWithAccumulationType(MutableSpan<T> buffer, T default_value = {})
|
2022-08-03 17:17:36 +02:00
|
|
|
: SimpleMixerWithAccumulationType(buffer, buffer.index_range(), default_value)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* \param mask: Only initialize these indices. Other indices in the buffer will be invalid.
|
|
|
|
*/
|
|
|
|
SimpleMixerWithAccumulationType(MutableSpan<T> buffer,
|
BLI: refactor IndexMask for better performance and memory usage
Goals of this refactor:
* Reduce memory consumption of `IndexMask`. The old `IndexMask` uses an
`int64_t` for each index which is more than necessary in pretty much all
practical cases currently. Using `int32_t` might still become limiting
in the future in case we use this to index e.g. byte buffers larger than
a few gigabytes. We also don't want to template `IndexMask`, because
that would cause a split in the "ecosystem", or everything would have to
be implemented twice or templated.
* Allow for more multi-threading. The old `IndexMask` contains a single
array. This is generally good but has the problem that it is hard to fill
from multiple-threads when the final size is not known from the beginning.
This is commonly the case when e.g. converting an array of bool to an
index mask. Currently, this kind of code only runs on a single thread.
* Allow for efficient set operations like join, intersect and difference.
It should be possible to multi-thread those operations.
* It should be possible to iterate over an `IndexMask` very efficiently.
The most important part of that is to avoid all memory access when iterating
over continuous ranges. For some core nodes (e.g. math nodes), we generate
optimized code for the cases of irregular index masks and simple index ranges.
To achieve these goals, a few compromises had to made:
* Slicing of the mask (at specific indices) and random element access is
`O(log #indices)` now, but with a low constant factor. It should be possible
to split a mask into n approximately equally sized parts in `O(n)` though,
making the time per split `O(1)`.
* Using range-based for loops does not work well when iterating over a nested
data structure like the new `IndexMask`. Therefor, `foreach_*` functions with
callbacks have to be used. To avoid extra code complexity at the call site,
the `foreach_*` methods support multi-threading out of the box.
The new data structure splits an `IndexMask` into an arbitrary number of ordered
`IndexMaskSegment`. Each segment can contain at most `2^14 = 16384` indices. The
indices within a segment are stored as `int16_t`. Each segment has an additional
`int64_t` offset which allows storing arbitrary `int64_t` indices. This approach
has the main benefits that segments can be processed/constructed individually on
multiple threads without a serial bottleneck. Also it reduces the memory
requirements significantly.
For more details see comments in `BLI_index_mask.hh`.
I did a few tests to verify that the data structure generally improves
performance and does not cause regressions:
* Our field evaluation benchmarks take about as much as before. This is to be
expected because we already made sure that e.g. add node evaluation is
vectorized. The important thing here is to check that changes to the way we
iterate over the indices still allows for auto-vectorization.
* Memory usage by a mask is about 1/4 of what it was before in the average case.
That's mainly caused by the switch from `int64_t` to `int16_t` for indices.
In the worst case, the memory requirements can be larger when there are many
indices that are very far away. However, when they are far away from each other,
that indicates that there aren't many indices in total. In common cases, memory
usage can be way lower than 1/4 of before, because sub-ranges use static memory.
* For some more specific numbers I benchmarked `IndexMask::from_bools` in
`index_mask_from_selection` on 10.000.000 elements at various probabilities for
`true` at every index:
```
Probability Old New
0 4.6 ms 0.8 ms
0.001 5.1 ms 1.3 ms
0.2 8.4 ms 1.8 ms
0.5 15.3 ms 3.0 ms
0.8 20.1 ms 3.0 ms
0.999 25.1 ms 1.7 ms
1 13.5 ms 1.1 ms
```
Pull Request: https://projects.blender.org/blender/blender/pulls/104629
2023-05-24 18:11:41 +02:00
|
|
|
const IndexMask &mask,
|
2022-08-03 17:17:36 +02:00
|
|
|
T default_value = {})
|
2021-02-09 11:44:58 +01:00
|
|
|
: buffer_(buffer), default_value_(default_value), accumulation_buffer_(buffer.size())
|
|
|
|
{
|
2022-08-03 17:17:36 +02:00
|
|
|
mask.foreach_index([&](const int64_t index) { buffer_[index] = default_value_; });
|
|
|
|
}
|
|
|
|
|
|
|
|
void set(const int64_t index, const T &value, const float weight = 1.0f)
|
|
|
|
{
|
2023-06-12 15:49:50 +02:00
|
|
|
const AccumulationT converted_value = ValueToAccumulate(value);
|
2022-08-03 17:17:36 +02:00
|
|
|
Item &item = accumulation_buffer_[index];
|
|
|
|
item.value = converted_value * weight;
|
|
|
|
item.weight = weight;
|
2021-02-09 11:44:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void mix_in(const int64_t index, const T &value, const float weight = 1.0f)
|
|
|
|
{
|
2023-06-12 15:49:50 +02:00
|
|
|
const AccumulationT converted_value = ValueToAccumulate(value);
|
2021-02-09 11:44:58 +01:00
|
|
|
Item &item = accumulation_buffer_[index];
|
|
|
|
item.value += converted_value * weight;
|
|
|
|
item.weight += weight;
|
|
|
|
}
|
|
|
|
|
|
|
|
void finalize()
|
|
|
|
{
|
2022-08-03 17:17:36 +02:00
|
|
|
this->finalize(buffer_.index_range());
|
|
|
|
}
|
|
|
|
|
BLI: refactor IndexMask for better performance and memory usage
Goals of this refactor:
* Reduce memory consumption of `IndexMask`. The old `IndexMask` uses an
`int64_t` for each index which is more than necessary in pretty much all
practical cases currently. Using `int32_t` might still become limiting
in the future in case we use this to index e.g. byte buffers larger than
a few gigabytes. We also don't want to template `IndexMask`, because
that would cause a split in the "ecosystem", or everything would have to
be implemented twice or templated.
* Allow for more multi-threading. The old `IndexMask` contains a single
array. This is generally good but has the problem that it is hard to fill
from multiple-threads when the final size is not known from the beginning.
This is commonly the case when e.g. converting an array of bool to an
index mask. Currently, this kind of code only runs on a single thread.
* Allow for efficient set operations like join, intersect and difference.
It should be possible to multi-thread those operations.
* It should be possible to iterate over an `IndexMask` very efficiently.
The most important part of that is to avoid all memory access when iterating
over continuous ranges. For some core nodes (e.g. math nodes), we generate
optimized code for the cases of irregular index masks and simple index ranges.
To achieve these goals, a few compromises had to made:
* Slicing of the mask (at specific indices) and random element access is
`O(log #indices)` now, but with a low constant factor. It should be possible
to split a mask into n approximately equally sized parts in `O(n)` though,
making the time per split `O(1)`.
* Using range-based for loops does not work well when iterating over a nested
data structure like the new `IndexMask`. Therefor, `foreach_*` functions with
callbacks have to be used. To avoid extra code complexity at the call site,
the `foreach_*` methods support multi-threading out of the box.
The new data structure splits an `IndexMask` into an arbitrary number of ordered
`IndexMaskSegment`. Each segment can contain at most `2^14 = 16384` indices. The
indices within a segment are stored as `int16_t`. Each segment has an additional
`int64_t` offset which allows storing arbitrary `int64_t` indices. This approach
has the main benefits that segments can be processed/constructed individually on
multiple threads without a serial bottleneck. Also it reduces the memory
requirements significantly.
For more details see comments in `BLI_index_mask.hh`.
I did a few tests to verify that the data structure generally improves
performance and does not cause regressions:
* Our field evaluation benchmarks take about as much as before. This is to be
expected because we already made sure that e.g. add node evaluation is
vectorized. The important thing here is to check that changes to the way we
iterate over the indices still allows for auto-vectorization.
* Memory usage by a mask is about 1/4 of what it was before in the average case.
That's mainly caused by the switch from `int64_t` to `int16_t` for indices.
In the worst case, the memory requirements can be larger when there are many
indices that are very far away. However, when they are far away from each other,
that indicates that there aren't many indices in total. In common cases, memory
usage can be way lower than 1/4 of before, because sub-ranges use static memory.
* For some more specific numbers I benchmarked `IndexMask::from_bools` in
`index_mask_from_selection` on 10.000.000 elements at various probabilities for
`true` at every index:
```
Probability Old New
0 4.6 ms 0.8 ms
0.001 5.1 ms 1.3 ms
0.2 8.4 ms 1.8 ms
0.5 15.3 ms 3.0 ms
0.8 20.1 ms 3.0 ms
0.999 25.1 ms 1.7 ms
1 13.5 ms 1.1 ms
```
Pull Request: https://projects.blender.org/blender/blender/pulls/104629
2023-05-24 18:11:41 +02:00
|
|
|
void finalize(const IndexMask &mask)
|
2022-08-03 17:17:36 +02:00
|
|
|
{
|
|
|
|
mask.foreach_index([&](const int64_t i) {
|
2021-02-09 11:44:58 +01:00
|
|
|
const Item &item = accumulation_buffer_[i];
|
|
|
|
if (item.weight > 0.0f) {
|
|
|
|
const float weight_inv = 1.0f / item.weight;
|
2023-06-12 15:49:50 +02:00
|
|
|
const T converted_value = AccumulateToValue(item.value * weight_inv);
|
2021-02-09 11:44:58 +01:00
|
|
|
buffer_[i] = converted_value;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
buffer_[i] = default_value_;
|
|
|
|
}
|
2022-08-03 17:17:36 +02:00
|
|
|
});
|
2021-02-09 11:44:58 +01:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-04-21 16:11:26 +02:00
|
|
|
class ColorGeometry4fMixer {
|
2021-02-09 11:44:58 +01:00
|
|
|
private:
|
2021-05-25 17:16:35 +02:00
|
|
|
MutableSpan<ColorGeometry4f> buffer_;
|
|
|
|
ColorGeometry4f default_color_;
|
2021-02-09 11:44:58 +01:00
|
|
|
Array<float> total_weights_;
|
|
|
|
|
|
|
|
public:
|
2022-04-21 16:11:26 +02:00
|
|
|
ColorGeometry4fMixer(MutableSpan<ColorGeometry4f> buffer,
|
|
|
|
ColorGeometry4f default_color = ColorGeometry4f(0.0f, 0.0f, 0.0f, 1.0f));
|
2022-08-03 17:17:36 +02:00
|
|
|
/**
|
|
|
|
* \param mask: Only initialize these indices. Other indices in the buffer will be invalid.
|
|
|
|
*/
|
|
|
|
ColorGeometry4fMixer(MutableSpan<ColorGeometry4f> buffer,
|
BLI: refactor IndexMask for better performance and memory usage
Goals of this refactor:
* Reduce memory consumption of `IndexMask`. The old `IndexMask` uses an
`int64_t` for each index which is more than necessary in pretty much all
practical cases currently. Using `int32_t` might still become limiting
in the future in case we use this to index e.g. byte buffers larger than
a few gigabytes. We also don't want to template `IndexMask`, because
that would cause a split in the "ecosystem", or everything would have to
be implemented twice or templated.
* Allow for more multi-threading. The old `IndexMask` contains a single
array. This is generally good but has the problem that it is hard to fill
from multiple-threads when the final size is not known from the beginning.
This is commonly the case when e.g. converting an array of bool to an
index mask. Currently, this kind of code only runs on a single thread.
* Allow for efficient set operations like join, intersect and difference.
It should be possible to multi-thread those operations.
* It should be possible to iterate over an `IndexMask` very efficiently.
The most important part of that is to avoid all memory access when iterating
over continuous ranges. For some core nodes (e.g. math nodes), we generate
optimized code for the cases of irregular index masks and simple index ranges.
To achieve these goals, a few compromises had to made:
* Slicing of the mask (at specific indices) and random element access is
`O(log #indices)` now, but with a low constant factor. It should be possible
to split a mask into n approximately equally sized parts in `O(n)` though,
making the time per split `O(1)`.
* Using range-based for loops does not work well when iterating over a nested
data structure like the new `IndexMask`. Therefor, `foreach_*` functions with
callbacks have to be used. To avoid extra code complexity at the call site,
the `foreach_*` methods support multi-threading out of the box.
The new data structure splits an `IndexMask` into an arbitrary number of ordered
`IndexMaskSegment`. Each segment can contain at most `2^14 = 16384` indices. The
indices within a segment are stored as `int16_t`. Each segment has an additional
`int64_t` offset which allows storing arbitrary `int64_t` indices. This approach
has the main benefits that segments can be processed/constructed individually on
multiple threads without a serial bottleneck. Also it reduces the memory
requirements significantly.
For more details see comments in `BLI_index_mask.hh`.
I did a few tests to verify that the data structure generally improves
performance and does not cause regressions:
* Our field evaluation benchmarks take about as much as before. This is to be
expected because we already made sure that e.g. add node evaluation is
vectorized. The important thing here is to check that changes to the way we
iterate over the indices still allows for auto-vectorization.
* Memory usage by a mask is about 1/4 of what it was before in the average case.
That's mainly caused by the switch from `int64_t` to `int16_t` for indices.
In the worst case, the memory requirements can be larger when there are many
indices that are very far away. However, when they are far away from each other,
that indicates that there aren't many indices in total. In common cases, memory
usage can be way lower than 1/4 of before, because sub-ranges use static memory.
* For some more specific numbers I benchmarked `IndexMask::from_bools` in
`index_mask_from_selection` on 10.000.000 elements at various probabilities for
`true` at every index:
```
Probability Old New
0 4.6 ms 0.8 ms
0.001 5.1 ms 1.3 ms
0.2 8.4 ms 1.8 ms
0.5 15.3 ms 3.0 ms
0.8 20.1 ms 3.0 ms
0.999 25.1 ms 1.7 ms
1 13.5 ms 1.1 ms
```
Pull Request: https://projects.blender.org/blender/blender/pulls/104629
2023-05-24 18:11:41 +02:00
|
|
|
const IndexMask &mask,
|
2022-08-03 17:17:36 +02:00
|
|
|
ColorGeometry4f default_color = ColorGeometry4f(0.0f, 0.0f, 0.0f, 1.0f));
|
|
|
|
void set(int64_t index, const ColorGeometry4f &color, float weight = 1.0f);
|
2022-01-07 01:38:08 +01:00
|
|
|
void mix_in(int64_t index, const ColorGeometry4f &color, float weight = 1.0f);
|
2021-02-09 11:44:58 +01:00
|
|
|
void finalize();
|
BLI: refactor IndexMask for better performance and memory usage
Goals of this refactor:
* Reduce memory consumption of `IndexMask`. The old `IndexMask` uses an
`int64_t` for each index which is more than necessary in pretty much all
practical cases currently. Using `int32_t` might still become limiting
in the future in case we use this to index e.g. byte buffers larger than
a few gigabytes. We also don't want to template `IndexMask`, because
that would cause a split in the "ecosystem", or everything would have to
be implemented twice or templated.
* Allow for more multi-threading. The old `IndexMask` contains a single
array. This is generally good but has the problem that it is hard to fill
from multiple-threads when the final size is not known from the beginning.
This is commonly the case when e.g. converting an array of bool to an
index mask. Currently, this kind of code only runs on a single thread.
* Allow for efficient set operations like join, intersect and difference.
It should be possible to multi-thread those operations.
* It should be possible to iterate over an `IndexMask` very efficiently.
The most important part of that is to avoid all memory access when iterating
over continuous ranges. For some core nodes (e.g. math nodes), we generate
optimized code for the cases of irregular index masks and simple index ranges.
To achieve these goals, a few compromises had to made:
* Slicing of the mask (at specific indices) and random element access is
`O(log #indices)` now, but with a low constant factor. It should be possible
to split a mask into n approximately equally sized parts in `O(n)` though,
making the time per split `O(1)`.
* Using range-based for loops does not work well when iterating over a nested
data structure like the new `IndexMask`. Therefor, `foreach_*` functions with
callbacks have to be used. To avoid extra code complexity at the call site,
the `foreach_*` methods support multi-threading out of the box.
The new data structure splits an `IndexMask` into an arbitrary number of ordered
`IndexMaskSegment`. Each segment can contain at most `2^14 = 16384` indices. The
indices within a segment are stored as `int16_t`. Each segment has an additional
`int64_t` offset which allows storing arbitrary `int64_t` indices. This approach
has the main benefits that segments can be processed/constructed individually on
multiple threads without a serial bottleneck. Also it reduces the memory
requirements significantly.
For more details see comments in `BLI_index_mask.hh`.
I did a few tests to verify that the data structure generally improves
performance and does not cause regressions:
* Our field evaluation benchmarks take about as much as before. This is to be
expected because we already made sure that e.g. add node evaluation is
vectorized. The important thing here is to check that changes to the way we
iterate over the indices still allows for auto-vectorization.
* Memory usage by a mask is about 1/4 of what it was before in the average case.
That's mainly caused by the switch from `int64_t` to `int16_t` for indices.
In the worst case, the memory requirements can be larger when there are many
indices that are very far away. However, when they are far away from each other,
that indicates that there aren't many indices in total. In common cases, memory
usage can be way lower than 1/4 of before, because sub-ranges use static memory.
* For some more specific numbers I benchmarked `IndexMask::from_bools` in
`index_mask_from_selection` on 10.000.000 elements at various probabilities for
`true` at every index:
```
Probability Old New
0 4.6 ms 0.8 ms
0.001 5.1 ms 1.3 ms
0.2 8.4 ms 1.8 ms
0.5 15.3 ms 3.0 ms
0.8 20.1 ms 3.0 ms
0.999 25.1 ms 1.7 ms
1 13.5 ms 1.1 ms
```
Pull Request: https://projects.blender.org/blender/blender/pulls/104629
2023-05-24 18:11:41 +02:00
|
|
|
void finalize(const IndexMask &mask);
|
2021-02-09 11:44:58 +01:00
|
|
|
};
|
|
|
|
|
2022-04-21 16:11:26 +02:00
|
|
|
class ColorGeometry4bMixer {
|
|
|
|
private:
|
|
|
|
MutableSpan<ColorGeometry4b> buffer_;
|
|
|
|
ColorGeometry4b default_color_;
|
|
|
|
Array<float> total_weights_;
|
|
|
|
Array<float4> accumulation_buffer_;
|
|
|
|
|
|
|
|
public:
|
|
|
|
ColorGeometry4bMixer(MutableSpan<ColorGeometry4b> buffer,
|
|
|
|
ColorGeometry4b default_color = ColorGeometry4b(0, 0, 0, 255));
|
2022-08-03 17:17:36 +02:00
|
|
|
/**
|
|
|
|
* \param mask: Only initialize these indices. Other indices in the buffer will be invalid.
|
|
|
|
*/
|
|
|
|
ColorGeometry4bMixer(MutableSpan<ColorGeometry4b> buffer,
|
BLI: refactor IndexMask for better performance and memory usage
Goals of this refactor:
* Reduce memory consumption of `IndexMask`. The old `IndexMask` uses an
`int64_t` for each index which is more than necessary in pretty much all
practical cases currently. Using `int32_t` might still become limiting
in the future in case we use this to index e.g. byte buffers larger than
a few gigabytes. We also don't want to template `IndexMask`, because
that would cause a split in the "ecosystem", or everything would have to
be implemented twice or templated.
* Allow for more multi-threading. The old `IndexMask` contains a single
array. This is generally good but has the problem that it is hard to fill
from multiple-threads when the final size is not known from the beginning.
This is commonly the case when e.g. converting an array of bool to an
index mask. Currently, this kind of code only runs on a single thread.
* Allow for efficient set operations like join, intersect and difference.
It should be possible to multi-thread those operations.
* It should be possible to iterate over an `IndexMask` very efficiently.
The most important part of that is to avoid all memory access when iterating
over continuous ranges. For some core nodes (e.g. math nodes), we generate
optimized code for the cases of irregular index masks and simple index ranges.
To achieve these goals, a few compromises had to made:
* Slicing of the mask (at specific indices) and random element access is
`O(log #indices)` now, but with a low constant factor. It should be possible
to split a mask into n approximately equally sized parts in `O(n)` though,
making the time per split `O(1)`.
* Using range-based for loops does not work well when iterating over a nested
data structure like the new `IndexMask`. Therefor, `foreach_*` functions with
callbacks have to be used. To avoid extra code complexity at the call site,
the `foreach_*` methods support multi-threading out of the box.
The new data structure splits an `IndexMask` into an arbitrary number of ordered
`IndexMaskSegment`. Each segment can contain at most `2^14 = 16384` indices. The
indices within a segment are stored as `int16_t`. Each segment has an additional
`int64_t` offset which allows storing arbitrary `int64_t` indices. This approach
has the main benefits that segments can be processed/constructed individually on
multiple threads without a serial bottleneck. Also it reduces the memory
requirements significantly.
For more details see comments in `BLI_index_mask.hh`.
I did a few tests to verify that the data structure generally improves
performance and does not cause regressions:
* Our field evaluation benchmarks take about as much as before. This is to be
expected because we already made sure that e.g. add node evaluation is
vectorized. The important thing here is to check that changes to the way we
iterate over the indices still allows for auto-vectorization.
* Memory usage by a mask is about 1/4 of what it was before in the average case.
That's mainly caused by the switch from `int64_t` to `int16_t` for indices.
In the worst case, the memory requirements can be larger when there are many
indices that are very far away. However, when they are far away from each other,
that indicates that there aren't many indices in total. In common cases, memory
usage can be way lower than 1/4 of before, because sub-ranges use static memory.
* For some more specific numbers I benchmarked `IndexMask::from_bools` in
`index_mask_from_selection` on 10.000.000 elements at various probabilities for
`true` at every index:
```
Probability Old New
0 4.6 ms 0.8 ms
0.001 5.1 ms 1.3 ms
0.2 8.4 ms 1.8 ms
0.5 15.3 ms 3.0 ms
0.8 20.1 ms 3.0 ms
0.999 25.1 ms 1.7 ms
1 13.5 ms 1.1 ms
```
Pull Request: https://projects.blender.org/blender/blender/pulls/104629
2023-05-24 18:11:41 +02:00
|
|
|
const IndexMask &mask,
|
2022-08-03 17:17:36 +02:00
|
|
|
ColorGeometry4b default_color = ColorGeometry4b(0, 0, 0, 255));
|
|
|
|
void set(int64_t index, const ColorGeometry4b &color, float weight = 1.0f);
|
2022-04-21 16:11:26 +02:00
|
|
|
void mix_in(int64_t index, const ColorGeometry4b &color, float weight = 1.0f);
|
|
|
|
void finalize();
|
BLI: refactor IndexMask for better performance and memory usage
Goals of this refactor:
* Reduce memory consumption of `IndexMask`. The old `IndexMask` uses an
`int64_t` for each index which is more than necessary in pretty much all
practical cases currently. Using `int32_t` might still become limiting
in the future in case we use this to index e.g. byte buffers larger than
a few gigabytes. We also don't want to template `IndexMask`, because
that would cause a split in the "ecosystem", or everything would have to
be implemented twice or templated.
* Allow for more multi-threading. The old `IndexMask` contains a single
array. This is generally good but has the problem that it is hard to fill
from multiple-threads when the final size is not known from the beginning.
This is commonly the case when e.g. converting an array of bool to an
index mask. Currently, this kind of code only runs on a single thread.
* Allow for efficient set operations like join, intersect and difference.
It should be possible to multi-thread those operations.
* It should be possible to iterate over an `IndexMask` very efficiently.
The most important part of that is to avoid all memory access when iterating
over continuous ranges. For some core nodes (e.g. math nodes), we generate
optimized code for the cases of irregular index masks and simple index ranges.
To achieve these goals, a few compromises had to made:
* Slicing of the mask (at specific indices) and random element access is
`O(log #indices)` now, but with a low constant factor. It should be possible
to split a mask into n approximately equally sized parts in `O(n)` though,
making the time per split `O(1)`.
* Using range-based for loops does not work well when iterating over a nested
data structure like the new `IndexMask`. Therefor, `foreach_*` functions with
callbacks have to be used. To avoid extra code complexity at the call site,
the `foreach_*` methods support multi-threading out of the box.
The new data structure splits an `IndexMask` into an arbitrary number of ordered
`IndexMaskSegment`. Each segment can contain at most `2^14 = 16384` indices. The
indices within a segment are stored as `int16_t`. Each segment has an additional
`int64_t` offset which allows storing arbitrary `int64_t` indices. This approach
has the main benefits that segments can be processed/constructed individually on
multiple threads without a serial bottleneck. Also it reduces the memory
requirements significantly.
For more details see comments in `BLI_index_mask.hh`.
I did a few tests to verify that the data structure generally improves
performance and does not cause regressions:
* Our field evaluation benchmarks take about as much as before. This is to be
expected because we already made sure that e.g. add node evaluation is
vectorized. The important thing here is to check that changes to the way we
iterate over the indices still allows for auto-vectorization.
* Memory usage by a mask is about 1/4 of what it was before in the average case.
That's mainly caused by the switch from `int64_t` to `int16_t` for indices.
In the worst case, the memory requirements can be larger when there are many
indices that are very far away. However, when they are far away from each other,
that indicates that there aren't many indices in total. In common cases, memory
usage can be way lower than 1/4 of before, because sub-ranges use static memory.
* For some more specific numbers I benchmarked `IndexMask::from_bools` in
`index_mask_from_selection` on 10.000.000 elements at various probabilities for
`true` at every index:
```
Probability Old New
0 4.6 ms 0.8 ms
0.001 5.1 ms 1.3 ms
0.2 8.4 ms 1.8 ms
0.5 15.3 ms 3.0 ms
0.8 20.1 ms 3.0 ms
0.999 25.1 ms 1.7 ms
1 13.5 ms 1.1 ms
```
Pull Request: https://projects.blender.org/blender/blender/pulls/104629
2023-05-24 18:11:41 +02:00
|
|
|
void finalize(const IndexMask &mask);
|
2022-04-21 16:11:26 +02:00
|
|
|
};
|
|
|
|
|
2021-02-09 11:44:58 +01:00
|
|
|
template<typename T> struct DefaultMixerStruct {
|
Geometry Nodes: Extrude Mesh Node
This patch introduces an extrude node with three modes. The vertex mode
is quite simple, and just attaches new edges to the selected vertices.
The edge mode attaches new faces to the selected edges. The faces mode
extrudes patches of selected faces, or each selected face individually,
depending on the "Individual" boolean input.
The default value of the "Offset" input is the mesh's normals, which
can be scaled with the "Offset Scale" input.
**Attribute Propagation**
Attributes are transferred to the new elements with specific rules.
Attributes will never change domains for interpolations. Generally
boolean attributes are propagated with "or", meaning any connected
"true" value that is mixed in for other types will cause the new value
to be "true" as well. The `"id"` attribute does not have any special
handling currently.
Vertex Mode
- Vertex: Copied values of selected vertices.
- Edge: Averaged values of selected edges. For booleans, edges are
selected if any connected edges are selected.
Edge Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected extruded
edges. For booleans, the edges are selected if any connected
extruded edges are selected.
- Duplicate edges: Copied values of selected edges.
- Face: Averaged values of all faces connected to the selected edge.
For booleans, faces are selected if any connected original faces
are selected.
- Corner: Averaged values of corresponding corners in all faces
connected to selected edges. For booleans, corners are selected
if one of those corners are selected.
Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected selected
edges, not including the edges "on top" of extruded regions.
For booleans, edges are selected when any connected extruded edges
were selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
Individual Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of the two neighboring
edges on each extruded face. For booleans, edges are selected
when at least one neighbor on the extruded face was selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
**Differences from edit mode**
In face mode (non-individual), the behavior can be different than the
extrude tools in edit mode-- this node doesn't handle keeping the back-
faces around in the cases that the edit mode tools do. The planned
"Solidify" node will handle that use case instead. Keeping this node
simpler and faster is preferable at this point, especially because that
sort of "smart" behavior is not that predictable and makes less sense
in a procedural context.
In the future, an "Even Offset" option could be added to this node
hopefully fairly simply. For now it is left out in order to keep
the patch simpler.
**Implementation**
For the implementation, the `Mesh` data structure is used directly
rather than converting to `BMesh` and back like D12224. This optimizes
for large extrusion operations rather than many sequential extrusions.
While this is potentially more verbose, it has some important benefits:
First, there is no conversion to and from `BMesh`. The code only has
to fill arrays and it can do that all at once, making each component of
the algorithm much easier to optimize. It also makes the attribute
interpolation more explicit, and likely faster. Only limited topology
maps must be created in most cases.
While there are some necessary loops and allocations with the size of
the entire mesh, I tried to keep everything I could on the order of the
size of the selection rather than the size of the mesh. In that respect,
the individual faces mode is the best, since there is no topology
information necessary, and the amount of work just depends on the size
of the selection.
Modifying an existing mesh instead of generating a new one was a bit
of a toss-up, but has a few potential benefits:
- Avoids manually copying over attribute data for original elements.
- Avoids some overhead of creating a new mesh.
- Can potentially take advantage of future ammortized mesh growth.
This could be changed easily if it turns out to be the wrong choice.
Differential Revision: https://developer.blender.org/D13709
2022-01-24 05:42:49 +01:00
|
|
|
/* Use void by default. This can be checked for in `if constexpr` statements. */
|
2021-02-09 11:44:58 +01:00
|
|
|
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>;
|
|
|
|
};
|
2021-05-25 17:16:35 +02:00
|
|
|
template<> struct DefaultMixerStruct<ColorGeometry4f> {
|
|
|
|
/* Use a special mixer for colors. ColorGeometry4f can't be added/multiplied, because this is not
|
2021-06-24 07:56:58 +02:00
|
|
|
* something one should usually do with colors. */
|
2022-04-21 16:11:26 +02:00
|
|
|
using type = ColorGeometry4fMixer;
|
|
|
|
};
|
|
|
|
template<> struct DefaultMixerStruct<ColorGeometry4b> {
|
|
|
|
using type = ColorGeometry4bMixer;
|
2021-02-09 11:44:58 +01:00
|
|
|
};
|
|
|
|
template<> struct DefaultMixerStruct<int> {
|
2023-06-12 15:49:50 +02:00
|
|
|
static double int_to_double(const int &value)
|
|
|
|
{
|
|
|
|
return double(value);
|
|
|
|
}
|
2021-02-09 11:44:58 +01:00
|
|
|
static int double_to_int(const double &value)
|
|
|
|
{
|
2022-09-26 09:38:25 +02:00
|
|
|
return int(std::round(value));
|
2021-02-09 11:44:58 +01:00
|
|
|
}
|
|
|
|
/* 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. */
|
2023-06-12 15:49:50 +02:00
|
|
|
using type = SimpleMixerWithAccumulationType<int, double, int_to_double, double_to_int>;
|
2021-02-09 11:44:58 +01:00
|
|
|
};
|
2023-04-14 16:08:05 +02:00
|
|
|
template<> struct DefaultMixerStruct<int2> {
|
2023-06-12 15:49:50 +02:00
|
|
|
static double2 int_to_double(const int2 &value)
|
|
|
|
{
|
|
|
|
return double2(value);
|
|
|
|
}
|
2023-04-14 16:08:05 +02:00
|
|
|
static int2 double_to_int(const double2 &value)
|
|
|
|
{
|
|
|
|
return int2(math::round(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. */
|
2023-06-12 15:49:50 +02:00
|
|
|
using type = SimpleMixerWithAccumulationType<int2, double2, int_to_double, double_to_int>;
|
2023-04-14 16:08:05 +02:00
|
|
|
};
|
2021-02-09 11:44:58 +01:00
|
|
|
template<> struct DefaultMixerStruct<bool> {
|
2023-06-12 15:49:50 +02:00
|
|
|
static float bool_to_float(const bool &value)
|
|
|
|
{
|
|
|
|
return value ? 1.0f : 0.0f;
|
|
|
|
}
|
2021-02-09 11:44:58 +01:00
|
|
|
static bool float_to_bool(const float &value)
|
|
|
|
{
|
|
|
|
return value >= 0.5f;
|
|
|
|
}
|
2021-02-09 21:57:52 +01:00
|
|
|
/* Store interpolated booleans in a float temporary.
|
|
|
|
* Otherwise information provided by weights is easily rounded away. */
|
2023-06-12 15:49:50 +02:00
|
|
|
using type = SimpleMixerWithAccumulationType<bool, float, bool_to_float, float_to_bool>;
|
2021-02-09 11:44:58 +01:00
|
|
|
};
|
|
|
|
|
2022-02-04 17:29:11 +01:00
|
|
|
template<> struct DefaultMixerStruct<int8_t> {
|
2023-06-12 15:49:50 +02:00
|
|
|
static float int8_t_to_float(const int8_t &value)
|
|
|
|
{
|
|
|
|
return float(value);
|
|
|
|
}
|
2022-02-04 17:29:11 +01:00
|
|
|
static int8_t float_to_int8_t(const float &value)
|
|
|
|
{
|
2022-09-26 09:38:25 +02:00
|
|
|
return int8_t(std::round(value));
|
2022-02-04 17:29:11 +01:00
|
|
|
}
|
|
|
|
/* Store interpolated 8 bit integers in a float temporarily to increase accuracy. */
|
2023-06-12 15:49:50 +02:00
|
|
|
using type = SimpleMixerWithAccumulationType<int8_t, float, int8_t_to_float, float_to_int8_t>;
|
|
|
|
};
|
|
|
|
template<> struct DefaultMixerStruct<math::Quaternion> {
|
|
|
|
static float3 quat_to_expmap(const math::Quaternion &value)
|
|
|
|
{
|
|
|
|
return value.expmap();
|
|
|
|
}
|
|
|
|
static math::Quaternion expmap_to_quat(const float3 &value)
|
|
|
|
{
|
|
|
|
return math::Quaternion::expmap(value);
|
|
|
|
}
|
|
|
|
using type =
|
|
|
|
SimpleMixerWithAccumulationType<math::Quaternion, float3, quat_to_expmap, expmap_to_quat>;
|
2022-02-04 17:29:11 +01:00
|
|
|
};
|
|
|
|
|
2022-08-07 19:48:28 +02:00
|
|
|
template<typename T> struct DefaultPropagationMixerStruct {
|
Geometry Nodes: Extrude Mesh Node
This patch introduces an extrude node with three modes. The vertex mode
is quite simple, and just attaches new edges to the selected vertices.
The edge mode attaches new faces to the selected edges. The faces mode
extrudes patches of selected faces, or each selected face individually,
depending on the "Individual" boolean input.
The default value of the "Offset" input is the mesh's normals, which
can be scaled with the "Offset Scale" input.
**Attribute Propagation**
Attributes are transferred to the new elements with specific rules.
Attributes will never change domains for interpolations. Generally
boolean attributes are propagated with "or", meaning any connected
"true" value that is mixed in for other types will cause the new value
to be "true" as well. The `"id"` attribute does not have any special
handling currently.
Vertex Mode
- Vertex: Copied values of selected vertices.
- Edge: Averaged values of selected edges. For booleans, edges are
selected if any connected edges are selected.
Edge Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected extruded
edges. For booleans, the edges are selected if any connected
extruded edges are selected.
- Duplicate edges: Copied values of selected edges.
- Face: Averaged values of all faces connected to the selected edge.
For booleans, faces are selected if any connected original faces
are selected.
- Corner: Averaged values of corresponding corners in all faces
connected to selected edges. For booleans, corners are selected
if one of those corners are selected.
Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected selected
edges, not including the edges "on top" of extruded regions.
For booleans, edges are selected when any connected extruded edges
were selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
Individual Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of the two neighboring
edges on each extruded face. For booleans, edges are selected
when at least one neighbor on the extruded face was selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
**Differences from edit mode**
In face mode (non-individual), the behavior can be different than the
extrude tools in edit mode-- this node doesn't handle keeping the back-
faces around in the cases that the edit mode tools do. The planned
"Solidify" node will handle that use case instead. Keeping this node
simpler and faster is preferable at this point, especially because that
sort of "smart" behavior is not that predictable and makes less sense
in a procedural context.
In the future, an "Even Offset" option could be added to this node
hopefully fairly simply. For now it is left out in order to keep
the patch simpler.
**Implementation**
For the implementation, the `Mesh` data structure is used directly
rather than converting to `BMesh` and back like D12224. This optimizes
for large extrusion operations rather than many sequential extrusions.
While this is potentially more verbose, it has some important benefits:
First, there is no conversion to and from `BMesh`. The code only has
to fill arrays and it can do that all at once, making each component of
the algorithm much easier to optimize. It also makes the attribute
interpolation more explicit, and likely faster. Only limited topology
maps must be created in most cases.
While there are some necessary loops and allocations with the size of
the entire mesh, I tried to keep everything I could on the order of the
size of the selection rather than the size of the mesh. In that respect,
the individual faces mode is the best, since there is no topology
information necessary, and the amount of work just depends on the size
of the selection.
Modifying an existing mesh instead of generating a new one was a bit
of a toss-up, but has a few potential benefits:
- Avoids manually copying over attribute data for original elements.
- Avoids some overhead of creating a new mesh.
- Can potentially take advantage of future ammortized mesh growth.
This could be changed easily if it turns out to be the wrong choice.
Differential Revision: https://developer.blender.org/D13709
2022-01-24 05:42:49 +01:00
|
|
|
/* Use void by default. This can be checked for in `if constexpr` statements. */
|
|
|
|
using type = typename DefaultMixerStruct<T>::type;
|
|
|
|
};
|
|
|
|
|
2022-08-07 19:48:28 +02:00
|
|
|
template<> struct DefaultPropagationMixerStruct<bool> {
|
Geometry Nodes: Extrude Mesh Node
This patch introduces an extrude node with three modes. The vertex mode
is quite simple, and just attaches new edges to the selected vertices.
The edge mode attaches new faces to the selected edges. The faces mode
extrudes patches of selected faces, or each selected face individually,
depending on the "Individual" boolean input.
The default value of the "Offset" input is the mesh's normals, which
can be scaled with the "Offset Scale" input.
**Attribute Propagation**
Attributes are transferred to the new elements with specific rules.
Attributes will never change domains for interpolations. Generally
boolean attributes are propagated with "or", meaning any connected
"true" value that is mixed in for other types will cause the new value
to be "true" as well. The `"id"` attribute does not have any special
handling currently.
Vertex Mode
- Vertex: Copied values of selected vertices.
- Edge: Averaged values of selected edges. For booleans, edges are
selected if any connected edges are selected.
Edge Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected extruded
edges. For booleans, the edges are selected if any connected
extruded edges are selected.
- Duplicate edges: Copied values of selected edges.
- Face: Averaged values of all faces connected to the selected edge.
For booleans, faces are selected if any connected original faces
are selected.
- Corner: Averaged values of corresponding corners in all faces
connected to selected edges. For booleans, corners are selected
if one of those corners are selected.
Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected selected
edges, not including the edges "on top" of extruded regions.
For booleans, edges are selected when any connected extruded edges
were selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
Individual Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of the two neighboring
edges on each extruded face. For booleans, edges are selected
when at least one neighbor on the extruded face was selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
**Differences from edit mode**
In face mode (non-individual), the behavior can be different than the
extrude tools in edit mode-- this node doesn't handle keeping the back-
faces around in the cases that the edit mode tools do. The planned
"Solidify" node will handle that use case instead. Keeping this node
simpler and faster is preferable at this point, especially because that
sort of "smart" behavior is not that predictable and makes less sense
in a procedural context.
In the future, an "Even Offset" option could be added to this node
hopefully fairly simply. For now it is left out in order to keep
the patch simpler.
**Implementation**
For the implementation, the `Mesh` data structure is used directly
rather than converting to `BMesh` and back like D12224. This optimizes
for large extrusion operations rather than many sequential extrusions.
While this is potentially more verbose, it has some important benefits:
First, there is no conversion to and from `BMesh`. The code only has
to fill arrays and it can do that all at once, making each component of
the algorithm much easier to optimize. It also makes the attribute
interpolation more explicit, and likely faster. Only limited topology
maps must be created in most cases.
While there are some necessary loops and allocations with the size of
the entire mesh, I tried to keep everything I could on the order of the
size of the selection rather than the size of the mesh. In that respect,
the individual faces mode is the best, since there is no topology
information necessary, and the amount of work just depends on the size
of the selection.
Modifying an existing mesh instead of generating a new one was a bit
of a toss-up, but has a few potential benefits:
- Avoids manually copying over attribute data for original elements.
- Avoids some overhead of creating a new mesh.
- Can potentially take advantage of future ammortized mesh growth.
This could be changed easily if it turns out to be the wrong choice.
Differential Revision: https://developer.blender.org/D13709
2022-01-24 05:42:49 +01:00
|
|
|
using type = BooleanPropagationMixer;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This mixer is meant for propagating attributes when creating new geometry. A key difference
|
|
|
|
* with the default mixer is that booleans are mixed with "or" instead of "at least half"
|
|
|
|
* (the default mixing for booleans).
|
|
|
|
*/
|
|
|
|
template<typename T>
|
2022-08-07 19:48:28 +02:00
|
|
|
using DefaultPropagationMixer = typename DefaultPropagationMixerStruct<T>::type;
|
Geometry Nodes: Extrude Mesh Node
This patch introduces an extrude node with three modes. The vertex mode
is quite simple, and just attaches new edges to the selected vertices.
The edge mode attaches new faces to the selected edges. The faces mode
extrudes patches of selected faces, or each selected face individually,
depending on the "Individual" boolean input.
The default value of the "Offset" input is the mesh's normals, which
can be scaled with the "Offset Scale" input.
**Attribute Propagation**
Attributes are transferred to the new elements with specific rules.
Attributes will never change domains for interpolations. Generally
boolean attributes are propagated with "or", meaning any connected
"true" value that is mixed in for other types will cause the new value
to be "true" as well. The `"id"` attribute does not have any special
handling currently.
Vertex Mode
- Vertex: Copied values of selected vertices.
- Edge: Averaged values of selected edges. For booleans, edges are
selected if any connected edges are selected.
Edge Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected extruded
edges. For booleans, the edges are selected if any connected
extruded edges are selected.
- Duplicate edges: Copied values of selected edges.
- Face: Averaged values of all faces connected to the selected edge.
For booleans, faces are selected if any connected original faces
are selected.
- Corner: Averaged values of corresponding corners in all faces
connected to selected edges. For booleans, corners are selected
if one of those corners are selected.
Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of connected selected
edges, not including the edges "on top" of extruded regions.
For booleans, edges are selected when any connected extruded edges
were selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
Individual Face Mode
- Vertex: Copied values of extruded vertices.
- Connecting edges (vertical): Average values of the two neighboring
edges on each extruded face. For booleans, edges are selected
when at least one neighbor on the extruded face was selected.
- Duplicate edges: Copied values of extruded edges.
- Face: Copied values of the corresponding selected faces.
- Corner: Copied values of corresponding corners in selected faces.
**Differences from edit mode**
In face mode (non-individual), the behavior can be different than the
extrude tools in edit mode-- this node doesn't handle keeping the back-
faces around in the cases that the edit mode tools do. The planned
"Solidify" node will handle that use case instead. Keeping this node
simpler and faster is preferable at this point, especially because that
sort of "smart" behavior is not that predictable and makes less sense
in a procedural context.
In the future, an "Even Offset" option could be added to this node
hopefully fairly simply. For now it is left out in order to keep
the patch simpler.
**Implementation**
For the implementation, the `Mesh` data structure is used directly
rather than converting to `BMesh` and back like D12224. This optimizes
for large extrusion operations rather than many sequential extrusions.
While this is potentially more verbose, it has some important benefits:
First, there is no conversion to and from `BMesh`. The code only has
to fill arrays and it can do that all at once, making each component of
the algorithm much easier to optimize. It also makes the attribute
interpolation more explicit, and likely faster. Only limited topology
maps must be created in most cases.
While there are some necessary loops and allocations with the size of
the entire mesh, I tried to keep everything I could on the order of the
size of the selection rather than the size of the mesh. In that respect,
the individual faces mode is the best, since there is no topology
information necessary, and the amount of work just depends on the size
of the selection.
Modifying an existing mesh instead of generating a new one was a bit
of a toss-up, but has a few potential benefits:
- Avoids manually copying over attribute data for original elements.
- Avoids some overhead of creating a new mesh.
- Can potentially take advantage of future ammortized mesh growth.
This could be changed easily if it turns out to be the wrong choice.
Differential Revision: https://developer.blender.org/D13709
2022-01-24 05:42:49 +01:00
|
|
|
|
2021-02-09 11:44:58 +01:00
|
|
|
/* 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;
|
|
|
|
|
|
|
|
/** \} */
|
|
|
|
|
2023-05-12 14:44:39 +02:00
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/** \name Generic Array Utils Implementations
|
|
|
|
*
|
|
|
|
* Extra implementations of functions from #BLI_array_utils.hh for all attribute types,
|
|
|
|
* used to avoid templating the same logic for each type in many places.
|
|
|
|
* \{ */
|
|
|
|
|
|
|
|
void gather(GSpan src, Span<int> map, GMutableSpan dst);
|
|
|
|
void gather(const GVArray &src, Span<int> map, GMutableSpan dst);
|
2023-11-22 21:45:42 +01:00
|
|
|
void gather_group_to_group(OffsetIndices<int> src_offsets,
|
|
|
|
OffsetIndices<int> dst_offsets,
|
|
|
|
const IndexMask &selection,
|
|
|
|
GSpan src,
|
|
|
|
GMutableSpan dst);
|
|
|
|
void gather_to_groups(OffsetIndices<int> dst_offsets,
|
|
|
|
const IndexMask &src_selection,
|
|
|
|
GSpan src,
|
|
|
|
GMutableSpan dst);
|
2023-05-12 14:44:39 +02:00
|
|
|
|
|
|
|
/** \} */
|
|
|
|
|
2023-05-03 18:07:01 +02:00
|
|
|
} // namespace blender::bke::attribute_math
|