Hans Goudey
c6069c439c
Compare the start of the range to zero to figure out whether the indices for the instances to keep starts at zero. Also rename the selection argument, since it made it seem like the selected indices should be removed rather than kept.
516 lines
16 KiB
C++
516 lines
16 KiB
C++
/*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <mutex>
|
|
|
|
#include "BLI_float4x4.hh"
|
|
#include "BLI_index_mask.hh"
|
|
#include "BLI_map.hh"
|
|
#include "BLI_rand.hh"
|
|
#include "BLI_set.hh"
|
|
#include "BLI_span.hh"
|
|
#include "BLI_task.hh"
|
|
#include "BLI_vector.hh"
|
|
|
|
#include "DNA_collection_types.h"
|
|
|
|
#include "BKE_attribute_access.hh"
|
|
#include "BKE_attribute_math.hh"
|
|
#include "BKE_geometry_set.hh"
|
|
#include "BKE_geometry_set_instances.hh"
|
|
|
|
#include "attribute_access_intern.hh"
|
|
|
|
#include "FN_cpp_type_make.hh"
|
|
|
|
using blender::float4x4;
|
|
using blender::IndexMask;
|
|
using blender::Map;
|
|
using blender::MutableSpan;
|
|
using blender::Set;
|
|
using blender::Span;
|
|
using blender::VectorSet;
|
|
using blender::fn::GSpan;
|
|
|
|
MAKE_CPP_TYPE(InstanceReference, InstanceReference, CPPTypeFlags::None)
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
/** \name Geometry Component Implementation
|
|
* \{ */
|
|
|
|
InstancesComponent::InstancesComponent() : GeometryComponent(GEO_COMPONENT_TYPE_INSTANCES)
|
|
{
|
|
}
|
|
|
|
GeometryComponent *InstancesComponent::copy() const
|
|
{
|
|
InstancesComponent *new_component = new InstancesComponent();
|
|
new_component->instance_reference_handles_ = instance_reference_handles_;
|
|
new_component->instance_transforms_ = instance_transforms_;
|
|
new_component->references_ = references_;
|
|
new_component->attributes_ = attributes_;
|
|
return new_component;
|
|
}
|
|
|
|
void InstancesComponent::reserve(int min_capacity)
|
|
{
|
|
instance_reference_handles_.reserve(min_capacity);
|
|
instance_transforms_.reserve(min_capacity);
|
|
attributes_.reallocate(min_capacity);
|
|
}
|
|
|
|
void InstancesComponent::resize(int capacity)
|
|
{
|
|
instance_reference_handles_.resize(capacity);
|
|
instance_transforms_.resize(capacity);
|
|
attributes_.reallocate(capacity);
|
|
}
|
|
|
|
void InstancesComponent::clear()
|
|
{
|
|
instance_reference_handles_.clear();
|
|
instance_transforms_.clear();
|
|
attributes_.clear();
|
|
references_.clear();
|
|
}
|
|
|
|
void InstancesComponent::add_instance(const int instance_handle, const float4x4 &transform)
|
|
{
|
|
BLI_assert(instance_handle >= 0);
|
|
BLI_assert(instance_handle < references_.size());
|
|
instance_reference_handles_.append(instance_handle);
|
|
instance_transforms_.append(transform);
|
|
attributes_.reallocate(this->instances_amount());
|
|
}
|
|
|
|
blender::Span<int> InstancesComponent::instance_reference_handles() const
|
|
{
|
|
return instance_reference_handles_;
|
|
}
|
|
|
|
blender::MutableSpan<int> InstancesComponent::instance_reference_handles()
|
|
{
|
|
return instance_reference_handles_;
|
|
}
|
|
|
|
blender::MutableSpan<blender::float4x4> InstancesComponent::instance_transforms()
|
|
{
|
|
return instance_transforms_;
|
|
}
|
|
blender::Span<blender::float4x4> InstancesComponent::instance_transforms() const
|
|
{
|
|
return instance_transforms_;
|
|
}
|
|
|
|
GeometrySet &InstancesComponent::geometry_set_from_reference(const int reference_index)
|
|
{
|
|
/* If this assert fails, it means #ensure_geometry_instances must be called first or that the
|
|
* reference can't be converted to a geometry set. */
|
|
BLI_assert(references_[reference_index].type() == InstanceReference::Type::GeometrySet);
|
|
|
|
/* The const cast is okay because the instance's hash in the set
|
|
* is not changed by adjusting the data inside the geometry set. */
|
|
return const_cast<GeometrySet &>(references_[reference_index].geometry_set());
|
|
}
|
|
|
|
int InstancesComponent::add_reference(const InstanceReference &reference)
|
|
{
|
|
return references_.index_of_or_add_as(reference);
|
|
}
|
|
|
|
blender::Span<InstanceReference> InstancesComponent::references() const
|
|
{
|
|
return references_;
|
|
}
|
|
|
|
template<typename T>
|
|
static void copy_data_based_on_mask(Span<T> src, MutableSpan<T> dst, IndexMask mask)
|
|
{
|
|
BLI_assert(src.data() != dst.data());
|
|
using namespace blender;
|
|
threading::parallel_for(mask.index_range(), 1024, [&](IndexRange range) {
|
|
for (const int i : range) {
|
|
dst[i] = src[mask[i]];
|
|
}
|
|
});
|
|
}
|
|
|
|
void InstancesComponent::remove_instances(const IndexMask mask)
|
|
{
|
|
using namespace blender;
|
|
if (mask.is_range() && mask.as_range().start() == 0) {
|
|
/* Deleting from the end of the array can be much faster since no data has to be shifted. */
|
|
this->resize(mask.size());
|
|
this->remove_unused_references();
|
|
return;
|
|
}
|
|
|
|
Vector<int> new_handles(mask.size());
|
|
copy_data_based_on_mask<int>(this->instance_reference_handles(), new_handles, mask);
|
|
instance_reference_handles_ = std::move(new_handles);
|
|
Vector<float4x4> new_transforms(mask.size());
|
|
copy_data_based_on_mask<float4x4>(this->instance_transforms(), new_transforms, mask);
|
|
instance_transforms_ = std::move(new_transforms);
|
|
|
|
const bke::CustomDataAttributes &src_attributes = attributes_;
|
|
|
|
bke::CustomDataAttributes dst_attributes;
|
|
dst_attributes.reallocate(mask.size());
|
|
|
|
src_attributes.foreach_attribute(
|
|
[&](const bke::AttributeIDRef &id, const AttributeMetaData &meta_data) {
|
|
if (!id.should_be_kept()) {
|
|
return true;
|
|
}
|
|
|
|
GSpan src = *src_attributes.get_for_read(id);
|
|
dst_attributes.create(id, meta_data.data_type);
|
|
fn::GMutableSpan dst = *dst_attributes.get_for_write(id);
|
|
|
|
attribute_math::convert_to_static_type(src.type(), [&](auto dummy) {
|
|
using T = decltype(dummy);
|
|
copy_data_based_on_mask<T>(src.typed<T>(), dst.typed<T>(), mask);
|
|
});
|
|
return true;
|
|
},
|
|
ATTR_DOMAIN_INSTANCE);
|
|
|
|
attributes_ = std::move(dst_attributes);
|
|
this->remove_unused_references();
|
|
}
|
|
|
|
void InstancesComponent::remove_unused_references()
|
|
{
|
|
using namespace blender;
|
|
using namespace blender::bke;
|
|
|
|
const int tot_instances = this->instances_amount();
|
|
const int tot_references_before = references_.size();
|
|
|
|
if (tot_instances == 0) {
|
|
/* If there are no instances, no reference is needed. */
|
|
references_.clear();
|
|
return;
|
|
}
|
|
if (tot_references_before == 1) {
|
|
/* There is only one reference and at least one instance. So the only existing reference is
|
|
* used. Nothing to do here. */
|
|
return;
|
|
}
|
|
|
|
Array<bool> usage_by_handle(tot_references_before, false);
|
|
std::mutex mutex;
|
|
|
|
/* Loop over all instances to see which references are used. */
|
|
threading::parallel_for(IndexRange(tot_instances), 1000, [&](IndexRange range) {
|
|
/* Use local counter to avoid lock contention. */
|
|
Array<bool> local_usage_by_handle(tot_references_before, false);
|
|
|
|
for (const int i : range) {
|
|
const int handle = instance_reference_handles_[i];
|
|
BLI_assert(handle >= 0 && handle < tot_references_before);
|
|
local_usage_by_handle[handle] = true;
|
|
}
|
|
|
|
std::lock_guard lock{mutex};
|
|
for (const int i : IndexRange(tot_references_before)) {
|
|
usage_by_handle[i] |= local_usage_by_handle[i];
|
|
}
|
|
});
|
|
|
|
if (!usage_by_handle.as_span().contains(false)) {
|
|
/* All references are used. */
|
|
return;
|
|
}
|
|
|
|
/* Create new references and a mapping for the handles. */
|
|
Vector<int> handle_mapping;
|
|
VectorSet<InstanceReference> new_references;
|
|
int next_new_handle = 0;
|
|
bool handles_have_to_be_updated = false;
|
|
for (const int old_handle : IndexRange(tot_references_before)) {
|
|
if (!usage_by_handle[old_handle]) {
|
|
/* Add some dummy value. It won't be read again. */
|
|
handle_mapping.append(-1);
|
|
}
|
|
else {
|
|
const InstanceReference &reference = references_[old_handle];
|
|
handle_mapping.append(next_new_handle);
|
|
new_references.add_new(reference);
|
|
if (old_handle != next_new_handle) {
|
|
handles_have_to_be_updated = true;
|
|
}
|
|
next_new_handle++;
|
|
}
|
|
}
|
|
references_ = new_references;
|
|
|
|
if (!handles_have_to_be_updated) {
|
|
/* All remaining handles are the same as before, so they don't have to be updated. This happens
|
|
* when unused handles are only at the end. */
|
|
return;
|
|
}
|
|
|
|
/* Update handles of instances. */
|
|
threading::parallel_for(IndexRange(tot_instances), 1000, [&](IndexRange range) {
|
|
for (const int i : range) {
|
|
instance_reference_handles_[i] = handle_mapping[instance_reference_handles_[i]];
|
|
}
|
|
});
|
|
}
|
|
|
|
int InstancesComponent::instances_amount() const
|
|
{
|
|
return instance_transforms_.size();
|
|
}
|
|
|
|
int InstancesComponent::references_amount() const
|
|
{
|
|
return references_.size();
|
|
}
|
|
|
|
bool InstancesComponent::is_empty() const
|
|
{
|
|
return this->instance_reference_handles_.size() == 0;
|
|
}
|
|
|
|
bool InstancesComponent::owns_direct_data() const
|
|
{
|
|
for (const InstanceReference &reference : references_) {
|
|
if (!reference.owns_direct_data()) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void InstancesComponent::ensure_owns_direct_data()
|
|
{
|
|
BLI_assert(this->is_mutable());
|
|
for (const InstanceReference &const_reference : references_) {
|
|
/* Const cast is fine because we are not changing anything that would change the hash of the
|
|
* reference. */
|
|
InstanceReference &reference = const_cast<InstanceReference &>(const_reference);
|
|
reference.ensure_owns_direct_data();
|
|
}
|
|
}
|
|
|
|
static blender::Array<int> generate_unique_instance_ids(Span<int> original_ids)
|
|
{
|
|
using namespace blender;
|
|
Array<int> unique_ids(original_ids.size());
|
|
|
|
Set<int> used_unique_ids;
|
|
used_unique_ids.reserve(original_ids.size());
|
|
Vector<int> instances_with_id_collision;
|
|
for (const int instance_index : original_ids.index_range()) {
|
|
const int original_id = original_ids[instance_index];
|
|
if (used_unique_ids.add(original_id)) {
|
|
/* The original id has not been used by another instance yet. */
|
|
unique_ids[instance_index] = original_id;
|
|
}
|
|
else {
|
|
/* The original id of this instance collided with a previous instance, it needs to be looked
|
|
* at again in a second pass. Don't generate a new random id here, because this might collide
|
|
* with other existing ids. */
|
|
instances_with_id_collision.append(instance_index);
|
|
}
|
|
}
|
|
|
|
Map<int, RandomNumberGenerator> generator_by_original_id;
|
|
for (const int instance_index : instances_with_id_collision) {
|
|
const int original_id = original_ids[instance_index];
|
|
RandomNumberGenerator &rng = generator_by_original_id.lookup_or_add_cb(original_id, [&]() {
|
|
RandomNumberGenerator rng;
|
|
rng.seed_random(original_id);
|
|
return rng;
|
|
});
|
|
|
|
const int max_iteration = 100;
|
|
for (int iteration = 0;; iteration++) {
|
|
/* Try generating random numbers until an unused one has been found. */
|
|
const int random_id = rng.get_int32();
|
|
if (used_unique_ids.add(random_id)) {
|
|
/* This random id is not used by another instance. */
|
|
unique_ids[instance_index] = random_id;
|
|
break;
|
|
}
|
|
if (iteration == max_iteration) {
|
|
/* It seems to be very unlikely that we ever run into this case (assuming there are less
|
|
* than 2^30 instances). However, if that happens, it's better to use an id that is not
|
|
* unique than to be stuck in an infinite loop. */
|
|
unique_ids[instance_index] = original_id;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return unique_ids;
|
|
}
|
|
|
|
blender::Span<int> InstancesComponent::almost_unique_ids() const
|
|
{
|
|
std::lock_guard lock(almost_unique_ids_mutex_);
|
|
std::optional<GSpan> instance_ids_gspan = attributes_.get_for_read("id");
|
|
if (instance_ids_gspan) {
|
|
Span<int> instance_ids = instance_ids_gspan->typed<int>();
|
|
if (almost_unique_ids_.size() != instance_ids.size()) {
|
|
almost_unique_ids_ = generate_unique_instance_ids(instance_ids);
|
|
}
|
|
}
|
|
else {
|
|
almost_unique_ids_.reinitialize(this->instances_amount());
|
|
for (const int i : almost_unique_ids_.index_range()) {
|
|
almost_unique_ids_[i] = i;
|
|
}
|
|
}
|
|
return almost_unique_ids_;
|
|
}
|
|
|
|
int InstancesComponent::attribute_domain_size(const AttributeDomain domain) const
|
|
{
|
|
if (domain != ATTR_DOMAIN_INSTANCE) {
|
|
return 0;
|
|
}
|
|
return this->instances_amount();
|
|
}
|
|
|
|
blender::bke::CustomDataAttributes &InstancesComponent::attributes()
|
|
{
|
|
return this->attributes_;
|
|
}
|
|
|
|
const blender::bke::CustomDataAttributes &InstancesComponent::attributes() const
|
|
{
|
|
return this->attributes_;
|
|
}
|
|
|
|
namespace blender::bke {
|
|
|
|
static float3 get_transform_position(const float4x4 &transform)
|
|
{
|
|
return transform.translation();
|
|
}
|
|
|
|
static void set_transform_position(float4x4 &transform, const float3 position)
|
|
{
|
|
copy_v3_v3(transform.values[3], position);
|
|
}
|
|
|
|
class InstancePositionAttributeProvider final : public BuiltinAttributeProvider {
|
|
public:
|
|
InstancePositionAttributeProvider()
|
|
: BuiltinAttributeProvider(
|
|
"position", ATTR_DOMAIN_INSTANCE, CD_PROP_FLOAT3, NonCreatable, Writable, NonDeletable)
|
|
{
|
|
}
|
|
|
|
GVArray try_get_for_read(const GeometryComponent &component) const final
|
|
{
|
|
const InstancesComponent &instances_component = static_cast<const InstancesComponent &>(
|
|
component);
|
|
Span<float4x4> transforms = instances_component.instance_transforms();
|
|
return VArray<float3>::ForDerivedSpan<float4x4, get_transform_position>(transforms);
|
|
}
|
|
|
|
WriteAttributeLookup try_get_for_write(GeometryComponent &component) const final
|
|
{
|
|
InstancesComponent &instances_component = static_cast<InstancesComponent &>(component);
|
|
MutableSpan<float4x4> transforms = instances_component.instance_transforms();
|
|
return {VMutableArray<float3>::ForDerivedSpan<float4x4,
|
|
get_transform_position,
|
|
set_transform_position>(transforms),
|
|
domain_};
|
|
}
|
|
|
|
bool try_delete(GeometryComponent &UNUSED(component)) const final
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool try_create(GeometryComponent &UNUSED(component),
|
|
const AttributeInit &UNUSED(initializer)) const final
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool exists(const GeometryComponent &UNUSED(component)) const final
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
static GVArray make_array_read_attribute(const void *data, const int domain_size)
|
|
{
|
|
return VArray<T>::ForSpan(Span<T>((const T *)data, domain_size));
|
|
}
|
|
|
|
template<typename T>
|
|
static GVMutableArray make_array_write_attribute(void *data, const int domain_size)
|
|
{
|
|
return VMutableArray<T>::ForSpan(MutableSpan<T>((T *)data, domain_size));
|
|
}
|
|
|
|
static ComponentAttributeProviders create_attribute_providers_for_instances()
|
|
{
|
|
static InstancePositionAttributeProvider position;
|
|
static CustomDataAccessInfo instance_custom_data_access = {
|
|
[](GeometryComponent &component) -> CustomData * {
|
|
InstancesComponent &inst = static_cast<InstancesComponent &>(component);
|
|
return &inst.attributes().data;
|
|
},
|
|
[](const GeometryComponent &component) -> const CustomData * {
|
|
const InstancesComponent &inst = static_cast<const InstancesComponent &>(component);
|
|
return &inst.attributes().data;
|
|
},
|
|
nullptr};
|
|
|
|
/**
|
|
* IDs of the instances. They are used for consistency over multiple frames for things like
|
|
* motion blur. Proper stable ID data that actually helps when rendering can only be generated
|
|
* in some situations, so this vector is allowed to be empty, in which case the index of each
|
|
* instance will be used for the final ID.
|
|
*/
|
|
static BuiltinCustomDataLayerProvider id("id",
|
|
ATTR_DOMAIN_INSTANCE,
|
|
CD_PROP_INT32,
|
|
CD_PROP_INT32,
|
|
BuiltinAttributeProvider::Creatable,
|
|
BuiltinAttributeProvider::Writable,
|
|
BuiltinAttributeProvider::Deletable,
|
|
instance_custom_data_access,
|
|
make_array_read_attribute<int>,
|
|
make_array_write_attribute<int>,
|
|
nullptr);
|
|
|
|
static CustomDataAttributeProvider instance_custom_data(ATTR_DOMAIN_INSTANCE,
|
|
instance_custom_data_access);
|
|
|
|
return ComponentAttributeProviders({&position, &id}, {&instance_custom_data});
|
|
}
|
|
} // namespace blender::bke
|
|
|
|
const blender::bke::ComponentAttributeProviders *InstancesComponent::get_attribute_providers()
|
|
const
|
|
{
|
|
static blender::bke::ComponentAttributeProviders providers =
|
|
blender::bke::create_attribute_providers_for_instances();
|
|
return &providers;
|
|
}
|
|
|
|
/** \} */
|