b4d914b676
The main goal of these changes is to support checking if some data has been changed over time. This is used by the WIP simulation nodes during baking to detect which attributes have to be stored in every frame because they have changed. By using a combination of a weak user count and a version counter, it is possible to detect that an attribute (or any data controlled by implicit sharing) has not been changed with O(1) memory and time. It's still possible that the data has been changed multiple times and is the same in the end and beginning of course. That wouldn't be detected using this mechanism. The `ImplicitSharingInfo` struct has a new weak user count. A weak reference is one that does not keep the referenced data alive, but makes sure that the `ImplicitSharingInfo` itself is not deleted. If some piece of data has one strong and multiple weak users, it is still mutable. If the strong user count goes down to zero, the referenced data is freed. Remaining weak users can check for this condition using `is_expired`. This is a bit similar to `std::weak_ptr` but there is an important difference: a weak user can not become a strong user while one can create a `shared_ptr` from a `weak_ptr`. This restriction is necessary, because some code might be changing the referenced data assuming that it is the only owner. If another thread suddenly adds a new owner, the data would be shared again and the first thread would not have been allowed to modify the data in the first place. There is also a new integer version counter in `ImplicitSharingInfo`. It is incremented whenever some code wants to modify the referenced data. Obviously, this can only be done when the data is not shared because then it would be immutable. By comparing an old and new version number of the same sharing info, one can check if the data has been modified. One has to keep a weak reference to the sharing info together with the old version number to ensure that the new sharing info is still the same as the old one. Without this, it can happen that the sharing info was freed and a new one was allocated at the same pointer address. Using a strong reference for this purpose does not work, because then the data would never be modified because it's shared.
642 lines
22 KiB
C++
642 lines
22 KiB
C++
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
|
|
#pragma once
|
|
|
|
/** \file
|
|
* \ingroup bke
|
|
*/
|
|
|
|
#include <atomic>
|
|
#include <iostream>
|
|
#include <mutex>
|
|
|
|
#include "BLI_function_ref.hh"
|
|
#include "BLI_map.hh"
|
|
#include "BLI_vector_set.hh"
|
|
|
|
#include "BKE_attribute.hh"
|
|
#include "BKE_geometry_set.h"
|
|
|
|
struct Curves;
|
|
struct Curve;
|
|
struct Mesh;
|
|
struct PointCloud;
|
|
struct Volume;
|
|
|
|
enum class GeometryOwnershipType {
|
|
/* The geometry is owned. This implies that it can be changed. */
|
|
Owned = 0,
|
|
/* The geometry can be changed, but someone else is responsible for freeing it. */
|
|
Editable = 1,
|
|
/* The geometry cannot be changed and someone else is responsible for freeing it. */
|
|
ReadOnly = 2,
|
|
};
|
|
|
|
namespace blender::bke {
|
|
class ComponentAttributeProviders;
|
|
class CurvesEditHints;
|
|
class Instances;
|
|
} // namespace blender::bke
|
|
|
|
class GeometryComponent;
|
|
using GeometryComponentPtr = blender::ImplicitSharingPtr<GeometryComponent>;
|
|
|
|
/**
|
|
* This is the base class for specialized geometry component types. A geometry component uses
|
|
* implicit sharing to avoid read-only copies. It also integrates with attribute API, which
|
|
* generalizes storing and modifying generic information on a geometry.
|
|
*/
|
|
class GeometryComponent : public blender::ImplicitSharingMixin {
|
|
private:
|
|
GeometryComponentType type_;
|
|
|
|
public:
|
|
GeometryComponent(GeometryComponentType type);
|
|
virtual ~GeometryComponent() = default;
|
|
static GeometryComponentPtr create(GeometryComponentType component_type);
|
|
|
|
int attribute_domain_size(eAttrDomain domain) const;
|
|
|
|
/**
|
|
* Get access to the attributes in this geometry component. May return none if the geometry does
|
|
* not support the attribute system.
|
|
*/
|
|
virtual std::optional<blender::bke::AttributeAccessor> attributes() const;
|
|
virtual std::optional<blender::bke::MutableAttributeAccessor> attributes_for_write();
|
|
|
|
/* The returned component should be of the same type as the type this is called on. */
|
|
virtual GeometryComponent *copy() const = 0;
|
|
|
|
/** Remove referenced data from the geometry component. */
|
|
virtual void clear() = 0;
|
|
|
|
/* Direct data is everything except for instances of objects/collections.
|
|
* If this returns true, the geometry set can be cached and is still valid after e.g. modifier
|
|
* evaluation ends. Instances can only be valid as long as the data they instance is valid. */
|
|
virtual bool owns_direct_data() const = 0;
|
|
virtual void ensure_owns_direct_data() = 0;
|
|
|
|
GeometryComponentType type() const;
|
|
|
|
virtual bool is_empty() const;
|
|
|
|
private:
|
|
void delete_self() override;
|
|
void delete_data_only() override;
|
|
};
|
|
|
|
template<typename T>
|
|
inline constexpr bool is_geometry_component_v = std::is_base_of_v<GeometryComponent, T>;
|
|
|
|
/**
|
|
* A geometry set is a container for multiple kinds of geometry. It does not own geometry directly
|
|
* itself, instead geometry is owned by multiple #GeometryComponents, and the geometry set
|
|
* increases the user count of each component, so they avoid losing the data. This means
|
|
* individual components might be shared between multiple geometries and other code. Shared
|
|
* components are copied automatically when write access is requested.
|
|
*
|
|
* The components usually do not store data directly, but keep a reference to a data
|
|
* structure defined elsewhere. There is at most one component of each type:
|
|
* - #MeshComponent
|
|
* - #CurveComponent
|
|
* - #PointCloudComponent
|
|
* - #InstancesComponent
|
|
* - #VolumeComponent
|
|
*
|
|
* Copying a geometry set is a relatively cheap operation, because it does not copy the referenced
|
|
* geometry components, so #GeometrySet can often be passed or moved by value.
|
|
*/
|
|
struct GeometrySet {
|
|
private:
|
|
/* Indexed by #GeometryComponentType. */
|
|
std::array<GeometryComponentPtr, GEO_COMPONENT_TYPE_ENUM_SIZE> components_;
|
|
|
|
public:
|
|
/**
|
|
* The methods are defaulted here so that they are not instantiated in every translation unit.
|
|
*/
|
|
GeometrySet();
|
|
GeometrySet(const GeometrySet &other);
|
|
GeometrySet(GeometrySet &&other);
|
|
~GeometrySet();
|
|
GeometrySet &operator=(const GeometrySet &other);
|
|
GeometrySet &operator=(GeometrySet &&other);
|
|
|
|
/**
|
|
* This method can only be used when the geometry set is mutable. It returns a mutable geometry
|
|
* component of the given type.
|
|
*/
|
|
GeometryComponent &get_component_for_write(GeometryComponentType component_type);
|
|
template<typename Component> Component &get_component_for_write()
|
|
{
|
|
BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
|
|
return static_cast<Component &>(this->get_component_for_write(Component::static_type));
|
|
}
|
|
|
|
/**
|
|
* Get the component of the given type. Might return null if the component does not exist yet.
|
|
*/
|
|
const GeometryComponent *get_component_for_read(GeometryComponentType component_type) const;
|
|
template<typename Component> const Component *get_component_for_read() const
|
|
{
|
|
BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
|
|
return static_cast<const Component *>(get_component_for_read(Component::static_type));
|
|
}
|
|
|
|
bool has(const GeometryComponentType component_type) const;
|
|
template<typename Component> bool has() const
|
|
{
|
|
BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
|
|
return this->has(Component::static_type);
|
|
}
|
|
|
|
void remove(const GeometryComponentType component_type);
|
|
template<typename Component> void remove()
|
|
{
|
|
BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
|
|
return this->remove(Component::static_type);
|
|
}
|
|
|
|
/**
|
|
* Remove all geometry components with types that are not in the provided list.
|
|
*/
|
|
void keep_only(const blender::Span<GeometryComponentType> component_types);
|
|
/**
|
|
* Keeps the provided geometry types, but also instances and edit data.
|
|
* Instances must not be removed while using #modify_geometry_sets.
|
|
*/
|
|
void keep_only_during_modify(const blender::Span<GeometryComponentType> component_types);
|
|
void remove_geometry_during_modify();
|
|
|
|
void add(const GeometryComponent &component);
|
|
|
|
/**
|
|
* Get all geometry components in this geometry set for read-only access.
|
|
*/
|
|
blender::Vector<const GeometryComponent *> get_components_for_read() const;
|
|
|
|
bool compute_boundbox_without_instances(blender::float3 *r_min, blender::float3 *r_max) const;
|
|
|
|
friend std::ostream &operator<<(std::ostream &stream, const GeometrySet &geometry_set);
|
|
|
|
/**
|
|
* Remove all geometry components from the geometry set.
|
|
*/
|
|
void clear();
|
|
|
|
bool owns_direct_data() const;
|
|
/**
|
|
* Make sure that the geometry can be cached. This does not ensure ownership of object/collection
|
|
* instances. This is necessary because sometimes components only have read-only or editing
|
|
* access to their data, which might be freed later if this geometry set outlasts the data.
|
|
*/
|
|
void ensure_owns_direct_data();
|
|
|
|
using AttributeForeachCallback =
|
|
blender::FunctionRef<void(const blender::bke::AttributeIDRef &attribute_id,
|
|
const blender::bke::AttributeMetaData &meta_data,
|
|
const GeometryComponent &component)>;
|
|
|
|
void attribute_foreach(blender::Span<GeometryComponentType> component_types,
|
|
bool include_instances,
|
|
AttributeForeachCallback callback) const;
|
|
|
|
void gather_attributes_for_propagation(
|
|
blender::Span<GeometryComponentType> component_types,
|
|
GeometryComponentType dst_component_type,
|
|
bool include_instances,
|
|
const blender::bke::AnonymousAttributePropagationInfo &propagation_info,
|
|
blender::Map<blender::bke::AttributeIDRef, blender::bke::AttributeKind> &r_attributes) const;
|
|
|
|
blender::Vector<GeometryComponentType> gather_component_types(bool include_instances,
|
|
bool ignore_empty) const;
|
|
|
|
using ForeachSubGeometryCallback = blender::FunctionRef<void(GeometrySet &geometry_set)>;
|
|
|
|
/**
|
|
* Modify every (recursive) instance separately. This is often more efficient than realizing all
|
|
* instances just to change the same thing on all of them.
|
|
*/
|
|
void modify_geometry_sets(ForeachSubGeometryCallback callback);
|
|
|
|
/* Utility methods for creation. */
|
|
/**
|
|
* Create a new geometry set that only contains the given mesh.
|
|
*/
|
|
static GeometrySet create_with_mesh(
|
|
Mesh *mesh, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Create a new geometry set that only contains the given volume.
|
|
*/
|
|
static GeometrySet create_with_volume(
|
|
Volume *volume, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Create a new geometry set that only contains the given point cloud.
|
|
*/
|
|
static GeometrySet create_with_pointcloud(
|
|
PointCloud *pointcloud, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Create a new geometry set that only contains the given curves.
|
|
*/
|
|
static GeometrySet create_with_curves(
|
|
Curves *curves, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Create a new geometry set that only contains the given instances.
|
|
*/
|
|
static GeometrySet create_with_instances(
|
|
blender::bke::Instances *instances,
|
|
GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
|
|
/* Utility methods for access. */
|
|
/**
|
|
* Returns true when the geometry set has a mesh component that has a mesh.
|
|
*/
|
|
bool has_mesh() const;
|
|
/**
|
|
* Returns true when the geometry set has a point cloud component that has a point cloud.
|
|
*/
|
|
bool has_pointcloud() const;
|
|
/**
|
|
* Returns true when the geometry set has an instances component that has at least one instance.
|
|
*/
|
|
bool has_instances() const;
|
|
/**
|
|
* Returns true when the geometry set has a volume component that has a volume.
|
|
*/
|
|
bool has_volume() const;
|
|
/**
|
|
* Returns true when the geometry set has a curves component that has a curves data-block.
|
|
*/
|
|
bool has_curves() const;
|
|
/**
|
|
* Returns true when the geometry set has any data that is not an instance.
|
|
*/
|
|
bool has_realized_data() const;
|
|
/**
|
|
* Return true if the geometry set has any component that isn't empty.
|
|
*/
|
|
bool is_empty() const;
|
|
|
|
/**
|
|
* Returns a read-only mesh or null.
|
|
*/
|
|
const Mesh *get_mesh_for_read() const;
|
|
/**
|
|
* Returns a read-only point cloud of null.
|
|
*/
|
|
const PointCloud *get_pointcloud_for_read() const;
|
|
/**
|
|
* Returns a read-only volume or null.
|
|
*/
|
|
const Volume *get_volume_for_read() const;
|
|
/**
|
|
* Returns a read-only curves data-block or null.
|
|
*/
|
|
const Curves *get_curves_for_read() const;
|
|
/**
|
|
* Returns read-only instances or null.
|
|
*/
|
|
const blender::bke::Instances *get_instances_for_read() const;
|
|
/**
|
|
* Returns read-only curve edit hints or null.
|
|
*/
|
|
const blender::bke::CurvesEditHints *get_curve_edit_hints_for_read() const;
|
|
|
|
/**
|
|
* Returns a mutable mesh or null. No ownership is transferred.
|
|
*/
|
|
Mesh *get_mesh_for_write();
|
|
/**
|
|
* Returns a mutable point cloud or null. No ownership is transferred.
|
|
*/
|
|
PointCloud *get_pointcloud_for_write();
|
|
/**
|
|
* Returns a mutable volume or null. No ownership is transferred.
|
|
*/
|
|
Volume *get_volume_for_write();
|
|
/**
|
|
* Returns a mutable curves data-block or null. No ownership is transferred.
|
|
*/
|
|
Curves *get_curves_for_write();
|
|
/**
|
|
* Returns mutable instances or null. No ownership is transferred.
|
|
*/
|
|
blender::bke::Instances *get_instances_for_write();
|
|
/**
|
|
* Returns mutable curve edit hints or null.
|
|
*/
|
|
blender::bke::CurvesEditHints *get_curve_edit_hints_for_write();
|
|
|
|
/* Utility methods for replacement. */
|
|
/**
|
|
* Clear the existing mesh and replace it with the given one.
|
|
*/
|
|
void replace_mesh(Mesh *mesh, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Clear the existing point cloud and replace with the given one.
|
|
*/
|
|
void replace_pointcloud(PointCloud *pointcloud,
|
|
GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Clear the existing volume and replace with the given one.
|
|
*/
|
|
void replace_volume(Volume *volume,
|
|
GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Clear the existing curves data-block and replace it with the given one.
|
|
*/
|
|
void replace_curves(Curves *curves,
|
|
GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Clear the existing instances and replace them with the given one.
|
|
*/
|
|
void replace_instances(blender::bke::Instances *instances,
|
|
GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
|
|
private:
|
|
/**
|
|
* Retrieve the pointer to a component without creating it if it does not exist,
|
|
* unlike #get_component_for_write.
|
|
*/
|
|
GeometryComponent *get_component_ptr(GeometryComponentType type);
|
|
template<typename Component> Component *get_component_ptr()
|
|
{
|
|
BLI_STATIC_ASSERT(is_geometry_component_v<Component>, "");
|
|
return static_cast<Component *>(get_component_ptr(Component::static_type));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* A geometry component that can store a mesh, using the #Mesh data-block.
|
|
*
|
|
* Attributes are stored, on any of the four attribute domains. Generic attributes are stored in
|
|
* contiguous arrays, but often built-in attributes are stored in an array of structs fashion for
|
|
* historical reasons, requiring more complex attribute access.
|
|
*/
|
|
class MeshComponent : public GeometryComponent {
|
|
private:
|
|
Mesh *mesh_ = nullptr;
|
|
GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
|
|
|
|
public:
|
|
MeshComponent();
|
|
~MeshComponent();
|
|
GeometryComponent *copy() const override;
|
|
|
|
void clear() override;
|
|
bool has_mesh() const;
|
|
/**
|
|
* Clear the component and replace it with the new mesh.
|
|
*/
|
|
void replace(Mesh *mesh, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Return the mesh and clear the component. The caller takes over responsibility for freeing the
|
|
* mesh (if the component was responsible before).
|
|
*/
|
|
Mesh *release();
|
|
|
|
/**
|
|
* Get the mesh from this component. This method can be used by multiple threads at the same
|
|
* time. Therefore, the returned mesh should not be modified. No ownership is transferred.
|
|
*/
|
|
const Mesh *get_for_read() const;
|
|
/**
|
|
* Get the mesh from this component. This method can only be used when the component is mutable,
|
|
* i.e. it is not shared. The returned mesh can be modified. No ownership is transferred.
|
|
*/
|
|
Mesh *get_for_write();
|
|
|
|
bool is_empty() const final;
|
|
|
|
bool owns_direct_data() const override;
|
|
void ensure_owns_direct_data() override;
|
|
|
|
static constexpr inline GeometryComponentType static_type = GEO_COMPONENT_TYPE_MESH;
|
|
|
|
std::optional<blender::bke::AttributeAccessor> attributes() const final;
|
|
std::optional<blender::bke::MutableAttributeAccessor> attributes_for_write() final;
|
|
};
|
|
|
|
/**
|
|
* A geometry component that stores a point cloud, corresponding to the #PointCloud data structure.
|
|
* While a point cloud is technically a subset of a mesh in some respects, it is useful because of
|
|
* its simplicity, partly on a conceptual level for the user, but also in the code, though partly
|
|
* for historical reasons. Point clouds can also be rendered in special ways, based on the built-in
|
|
* `radius` attribute.
|
|
*
|
|
* Attributes on point clouds are all stored in contiguous arrays in its #CustomData,
|
|
* which makes them efficient to process, relative to some legacy built-in mesh attributes.
|
|
*/
|
|
class PointCloudComponent : public GeometryComponent {
|
|
private:
|
|
PointCloud *pointcloud_ = nullptr;
|
|
GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
|
|
|
|
public:
|
|
PointCloudComponent();
|
|
~PointCloudComponent();
|
|
GeometryComponent *copy() const override;
|
|
|
|
void clear() override;
|
|
bool has_pointcloud() const;
|
|
/**
|
|
* Clear the component and replace it with the new point cloud.
|
|
*/
|
|
void replace(PointCloud *pointcloud,
|
|
GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Return the point cloud and clear the component. The caller takes over responsibility for
|
|
* freeing the point cloud (if the component was responsible before).
|
|
*/
|
|
PointCloud *release();
|
|
|
|
/**
|
|
* Get the point cloud from this component. This method can be used by multiple threads at the
|
|
* same time. Therefore, the returned point cloud should not be modified. No ownership is
|
|
* transferred.
|
|
*/
|
|
const PointCloud *get_for_read() const;
|
|
/**
|
|
* Get the point cloud from this component. This method can only be used when the component is
|
|
* mutable, i.e. it is not shared. The returned point cloud can be modified. No ownership is
|
|
* transferred.
|
|
*/
|
|
PointCloud *get_for_write();
|
|
|
|
bool is_empty() const final;
|
|
|
|
bool owns_direct_data() const override;
|
|
void ensure_owns_direct_data() override;
|
|
|
|
std::optional<blender::bke::AttributeAccessor> attributes() const final;
|
|
std::optional<blender::bke::MutableAttributeAccessor> attributes_for_write() final;
|
|
|
|
static constexpr inline GeometryComponentType static_type = GEO_COMPONENT_TYPE_POINT_CLOUD;
|
|
|
|
private:
|
|
};
|
|
|
|
/**
|
|
* A geometry component that stores a group of curves, corresponding the #Curves data-block
|
|
* and the #CurvesGeometry type. Attributes are stored on the control point domain and the
|
|
* curve domain.
|
|
*/
|
|
class CurveComponent : public GeometryComponent {
|
|
private:
|
|
Curves *curves_ = nullptr;
|
|
GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
|
|
|
|
/**
|
|
* Because rendering #Curves isn't fully working yet, we must provide a #Curve for the render
|
|
* engine and depsgraph object iterator in some cases. This allows using the old curve rendering
|
|
* even when the new curve data structure is used.
|
|
*/
|
|
mutable Curve *curve_for_render_ = nullptr;
|
|
mutable std::mutex curve_for_render_mutex_;
|
|
|
|
public:
|
|
CurveComponent();
|
|
~CurveComponent();
|
|
GeometryComponent *copy() const override;
|
|
|
|
void clear() override;
|
|
bool has_curves() const;
|
|
/**
|
|
* Clear the component and replace it with the new curve.
|
|
*/
|
|
void replace(Curves *curve, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
Curves *release();
|
|
|
|
const Curves *get_for_read() const;
|
|
Curves *get_for_write();
|
|
|
|
bool is_empty() const final;
|
|
|
|
bool owns_direct_data() const override;
|
|
void ensure_owns_direct_data() override;
|
|
|
|
/**
|
|
* Create empty curve data used for rendering the spline's wire edges.
|
|
* \note See comment on #curve_for_render_ for further explanation.
|
|
*/
|
|
const Curve *get_curve_for_render() const;
|
|
|
|
std::optional<blender::bke::AttributeAccessor> attributes() const final;
|
|
std::optional<blender::bke::MutableAttributeAccessor> attributes_for_write() final;
|
|
|
|
static constexpr inline GeometryComponentType static_type = GEO_COMPONENT_TYPE_CURVE;
|
|
};
|
|
|
|
/**
|
|
* A geometry component that stores #Instances.
|
|
*/
|
|
class InstancesComponent : public GeometryComponent {
|
|
private:
|
|
blender::bke::Instances *instances_ = nullptr;
|
|
GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
|
|
|
|
public:
|
|
InstancesComponent();
|
|
~InstancesComponent();
|
|
GeometryComponent *copy() const override;
|
|
|
|
void clear() override;
|
|
|
|
const blender::bke::Instances *get_for_read() const;
|
|
blender::bke::Instances *get_for_write();
|
|
|
|
void replace(blender::bke::Instances *instances,
|
|
GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
|
|
bool is_empty() const final;
|
|
|
|
bool owns_direct_data() const override;
|
|
void ensure_owns_direct_data() override;
|
|
|
|
std::optional<blender::bke::AttributeAccessor> attributes() const final;
|
|
std::optional<blender::bke::MutableAttributeAccessor> attributes_for_write() final;
|
|
|
|
static constexpr inline GeometryComponentType static_type = GEO_COMPONENT_TYPE_INSTANCES;
|
|
};
|
|
|
|
/**
|
|
* A geometry component that stores volume grids, corresponding to the #Volume data structure.
|
|
* This component does not implement an attribute API, partly because storage of sparse volume
|
|
* information in grids is much more complicated than it is for other types
|
|
*/
|
|
class VolumeComponent : public GeometryComponent {
|
|
private:
|
|
Volume *volume_ = nullptr;
|
|
GeometryOwnershipType ownership_ = GeometryOwnershipType::Owned;
|
|
|
|
public:
|
|
VolumeComponent();
|
|
~VolumeComponent();
|
|
GeometryComponent *copy() const override;
|
|
|
|
void clear() override;
|
|
bool has_volume() const;
|
|
/**
|
|
* Clear the component and replace it with the new volume.
|
|
*/
|
|
void replace(Volume *volume, GeometryOwnershipType ownership = GeometryOwnershipType::Owned);
|
|
/**
|
|
* Return the volume and clear the component. The caller takes over responsibility for freeing
|
|
* the volume (if the component was responsible before).
|
|
*/
|
|
Volume *release();
|
|
|
|
/**
|
|
* Get the volume from this component. This method can be used by multiple threads at the same
|
|
* time. Therefore, the returned volume should not be modified. No ownership is transferred.
|
|
*/
|
|
const Volume *get_for_read() const;
|
|
/**
|
|
* Get the volume from this component. This method can only be used when the component is
|
|
* mutable, i.e. it is not shared. The returned volume can be modified. No ownership is
|
|
* transferred.
|
|
*/
|
|
Volume *get_for_write();
|
|
|
|
bool owns_direct_data() const override;
|
|
void ensure_owns_direct_data() override;
|
|
|
|
static constexpr inline GeometryComponentType static_type = GEO_COMPONENT_TYPE_VOLUME;
|
|
};
|
|
|
|
/**
|
|
* When the original data is in some edit mode, we want to propagate some additional information
|
|
* through object evaluation. This information can be used by edit modes to support working on
|
|
* evaluated data.
|
|
*
|
|
* This component is added at the beginning of modifier evaluation.
|
|
*/
|
|
class GeometryComponentEditData final : public GeometryComponent {
|
|
public:
|
|
/**
|
|
* Information about how original curves are manipulated during evaluation. This data is used so
|
|
* that curve sculpt tools can work on evaluated data. It is not stored in #CurveComponent
|
|
* because the data remains valid even when there is no actual curves geometry anymore, for
|
|
* example, when the curves have been converted to a mesh.
|
|
*/
|
|
std::unique_ptr<blender::bke::CurvesEditHints> curves_edit_hints_;
|
|
|
|
GeometryComponentEditData();
|
|
|
|
GeometryComponent *copy() const final;
|
|
bool owns_direct_data() const final;
|
|
void ensure_owns_direct_data() final;
|
|
|
|
void clear() override;
|
|
|
|
/**
|
|
* The first node that does topology changing operations on curves should store the curve point
|
|
* positions it retrieved as input. Without this, information about the deformed positions is
|
|
* lost, which would make curves sculpt mode fall back to using original curve positions instead
|
|
* of deformed ones.
|
|
*/
|
|
static void remember_deformed_curve_positions_if_necessary(GeometrySet &geometry);
|
|
|
|
static constexpr inline GeometryComponentType static_type = GEO_COMPONENT_TYPE_EDIT;
|
|
};
|