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
70 lines
2.2 KiB
C++
70 lines
2.2 KiB
C++
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
#pragma once
|
|
|
|
#include "BLI_cache_mutex.hh"
|
|
|
|
namespace blender {
|
|
|
|
/**
|
|
* A `SharedCache` is meant to share lazily computed data between equivalent objects. It allows
|
|
* saving unnecessary computation by making a calculated value accessible from any object that
|
|
* shares the cache. Unlike `CacheMutex`, the cached data is embedded inside of this object.
|
|
*
|
|
* When data is copied (copy-on-write before changing a mesh, for example), the cache is shared,
|
|
* allowing its calculation on either the source or original to make the result available on both
|
|
* objects. As soon as either object is changed in a way that invalidates the cache, the data is
|
|
* "un-shared", and they will no-longer influence each other.
|
|
*
|
|
* One important use case is a typical CoW update loop of a persistent geometry data-block in
|
|
* `Main`. Even if bounds are only calculated on the evaluated *copied* geometry, if nothing
|
|
* changes them, they only need to be calculated on the first evaluation, because the same
|
|
* evaluated bounds are also accessible from the original geometry.
|
|
*
|
|
* The cache is implemented with a shared pointer, so it is relatively cheap, but to avoid
|
|
* unnecessary overhead it should only be used for relatively expensive computations.
|
|
*/
|
|
template<typename T> class SharedCache {
|
|
struct CacheData {
|
|
CacheMutex mutex;
|
|
T data;
|
|
};
|
|
std::shared_ptr<CacheData> cache_;
|
|
|
|
public:
|
|
SharedCache()
|
|
{
|
|
/* The cache should be allocated to trigger sharing of the cached data as early as possible. */
|
|
cache_ = std::make_shared<CacheData>();
|
|
}
|
|
|
|
/** Tag the data for recomputation and stop sharing the cache with other objects. */
|
|
void tag_dirty()
|
|
{
|
|
if (cache_.unique()) {
|
|
cache_->mutex.tag_dirty();
|
|
}
|
|
else {
|
|
cache_ = std::make_shared<CacheData>();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If the cache is dirty, trigger its computation with the provided function which should set
|
|
* the proper data.
|
|
*/
|
|
void ensure(FunctionRef<void(T &data)> compute_cache)
|
|
{
|
|
cache_->mutex.ensure([&]() { compute_cache(this->cache_->data); });
|
|
}
|
|
|
|
/** Retrieve the cached data. */
|
|
const T &data()
|
|
{
|
|
BLI_assert(cache_->mutex.is_cached());
|
|
return cache_->data;
|
|
}
|
|
};
|
|
|
|
} // namespace blender
|