Hans Goudey
e8f4010611
Bounding box calculation can be a large in some situations, especially instancing. This patch caches the min and max of the bounding box in runtime data of meshes, point clouds, and curves, implementing part of T96968. Bounds are now calculated lazily-- only after they are tagged dirty. Also, cached bounds are also shared when copying geometry data-blocks that have equivalent data. When bounds are calculated on an evaluated data-block, they are also accessible on the original, and the next evaluated ID will also share them. A geometry will stop sharing bounds as soon as its positions (or radii) are changed. Just caching the bounds gave a 2-3x speedup with thousands of mesh geometry instances in the viewport. Sharing the bounds can eliminate recalculations entirely in cases like copying meshes in geometry nodes or the selection paint brush in curves sculpt mode, which causes a reevaluation but doesn't change the positions. **Implementation** The sharing is achieved with a `shared_ptr` that points to a cache mutex (from D16419) and the cached bounds data. When geometries are copied, the bounds are shared by default, and only "un-shared" when the bounds are tagged dirty. Point clouds have a new runtime struct to store this data. Functions for tagging the data dirty are improved for added for point clouds and improved for curves. A missing tag has also been fixed for mesh sculpt mode. **Future** There are further improvements which can be worked on next - Apply changes to volume objects and other types where it makes sense - Continue cleanup changes described in T96968 - Apply shared cache design to more expensive data like triangulation or normals Differential Revision: https://developer.blender.org/D16204
74 lines
2.0 KiB
C++
74 lines
2.0 KiB
C++
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
#pragma once
|
|
|
|
/** \file
|
|
* \ingroup bli
|
|
*
|
|
* Generic algorithms for finding the largest and smallest elements in a span.
|
|
*/
|
|
|
|
#include <optional>
|
|
|
|
#include "BLI_bounds_types.hh"
|
|
#include "BLI_math_vector.hh"
|
|
#include "BLI_task.hh"
|
|
|
|
namespace blender::bounds {
|
|
|
|
/**
|
|
* Find the smallest and largest values element-wise in the span.
|
|
*/
|
|
template<typename T> static std::optional<Bounds<T>> min_max(Span<T> values)
|
|
{
|
|
if (values.is_empty()) {
|
|
return std::nullopt;
|
|
}
|
|
const Bounds<T> init{values.first(), values.first()};
|
|
return threading::parallel_reduce(
|
|
values.index_range(),
|
|
1024,
|
|
init,
|
|
[&](IndexRange range, const Bounds<T> &init) {
|
|
Bounds<T> result = init;
|
|
for (const int i : range) {
|
|
math::min_max(values[i], result.min, result.max);
|
|
}
|
|
return result;
|
|
},
|
|
[](const Bounds<T> &a, const Bounds<T> &b) {
|
|
return Bounds<T>{math::min(a.min, b.min), math::max(a.max, b.max)};
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Find the smallest and largest values element-wise in the span, adding the radius to each element
|
|
* first. The template type T is expected to have an addition operator implemented with RadiusT.
|
|
*/
|
|
template<typename T, typename RadiusT>
|
|
static std::optional<Bounds<T>> min_max_with_radii(Span<T> values, Span<RadiusT> radii)
|
|
{
|
|
BLI_assert(values.size() == radii.size());
|
|
if (values.is_empty()) {
|
|
return std::nullopt;
|
|
}
|
|
const Bounds<T> init{values.first(), values.first()};
|
|
return threading::parallel_reduce(
|
|
values.index_range(),
|
|
1024,
|
|
init,
|
|
[&](IndexRange range, const Bounds<T> &init) {
|
|
Bounds<T> result = init;
|
|
for (const int i : range) {
|
|
result.min = math::min(values[i] - radii[i], result.min);
|
|
result.max = math::max(values[i] + radii[i], result.max);
|
|
}
|
|
return result;
|
|
},
|
|
[](const Bounds<T> &a, const Bounds<T> &b) {
|
|
return Bounds<T>{math::min(a.min, b.min), math::max(a.max, b.max)};
|
|
});
|
|
}
|
|
|
|
} // namespace blender::bounds
|