Differential D10269 Diff 33377 source/blender/nodes/geometry/nodes/node_geo_attribute_randomize.cc

Changeset View

Standalone View

source/blender/nodes/geometry/nodes/node_geo_attribute_randomize.cc

/*		/*
* This program is free software; you can redistribute it and/or		* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License		* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2		* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.		* of the License, or (at your option) any later version.
*		*
* This program is distributed in the hope that it will be useful,		* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of		* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.		* GNU General Public License for more details.
*		*
* You should have received a copy of the GNU General Public License		* You should have received initial copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,		* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.		* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/		*/

#include "node_geometry_util.hh"		#include "node_geometry_util.hh"

#include "BLI_hash.h"		#include "BLI_hash.h"
#include "BLI_rand.hh"		#include "BLI_rand.hh"

#include "DNA_mesh_types.h"		#include "DNA_mesh_types.h"
#include "DNA_pointcloud_types.h"		#include "DNA_pointcloud_types.h"

		#include "BKE_attribute_math.hh"

static bNodeSocketTemplate geo_node_attribute_randomize_in[] = {		static bNodeSocketTemplate geo_node_attribute_randomize_in[] = {
{SOCK_GEOMETRY, N_("Geometry")},		{SOCK_GEOMETRY, N_("Geometry")},
{SOCK_STRING, N_("Attribute")},		{SOCK_STRING, N_("Attribute")},
{SOCK_VECTOR, N_("Min"), 0.0f, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX},		{SOCK_VECTOR, N_("Min"), 0.0f, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX},
{SOCK_VECTOR, N_("Max"), 1.0f, 1.0f, 1.0f, 0.0f, -FLT_MAX, FLT_MAX},		{SOCK_VECTOR, N_("Max"), 1.0f, 1.0f, 1.0f, 0.0f, -FLT_MAX, FLT_MAX},
{SOCK_FLOAT, N_("Min"), 0.0f, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX},		{SOCK_FLOAT, N_("Min"), 0.0f, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX},
{SOCK_FLOAT, N_("Max"), 1.0f, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX},		{SOCK_FLOAT, N_("Max"), 1.0f, 0.0f, 0.0f, 0.0f, -FLT_MAX, FLT_MAX},
		{SOCK_INT, N_("Min"), 0.0f, 0.0f, 0.0f, 0.0f, -100000, 100000},
		{SOCK_INT, N_("Max"), 100.0f, 0.0f, 0.0f, 0.0f, -100000, 100000},
		{SOCK_RGBA, N_("Min"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, FLT_MAX},
		{SOCK_RGBA, N_("Max"), 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, FLT_MAX},
{SOCK_INT, N_("Seed"), 0, 0, 0, 0, -10000, 10000},		{SOCK_INT, N_("Seed"), 0, 0, 0, 0, -10000, 10000},
{-1, ""},		{-1, ""},
};		};

static bNodeSocketTemplate geo_node_attribute_randomize_out[] = {		static bNodeSocketTemplate geo_node_attribute_randomize_out[] = {
{SOCK_GEOMETRY, N_("Geometry")},		{SOCK_GEOMETRY, N_("Geometry")},
{-1, ""},		{-1, ""},
};		};

static void geo_node_attribute_randomize_init(bNodeTree UNUSED(tree), bNode node)		static void geo_node_attribute_randomize_init(bNodeTree UNUSED(tree), bNode node)
{		{
node->custom1 = CD_PROP_FLOAT;		NodeAttributeRandomize data = (NodeAttributeRandomize )MEM_callocN(
		sizeof(NodeAttributeRandomize), __func__);
		data->data_type = CD_PROP_FLOAT;
		data->domain = ATTR_DOMAIN_POINT;
		data->operation = GEO_NODE_ATTRIBUTE_RANDOMIZE_REPLACE_CREATE;
		node->storage = data;
}		}

static void geo_node_attribute_randomize_update(bNodeTree UNUSED(ntree), bNode node)		static void geo_node_attribute_randomize_update(bNodeTree UNUSED(ntree), bNode node)
{		{
bNodeSocket sock_min_vector = (bNodeSocket )BLI_findlink(&node->inputs, 2);		bNodeSocket sock_min_vector = (bNodeSocket )BLI_findlink(&node->inputs, 2);
bNodeSocket *sock_max_vector = sock_min_vector->next;		bNodeSocket *sock_max_vector = sock_min_vector->next;
bNodeSocket *sock_min_float = sock_max_vector->next;		bNodeSocket *sock_min_float = sock_max_vector->next;
bNodeSocket *sock_max_float = sock_min_float->next;		bNodeSocket *sock_max_float = sock_min_float->next;
		bNodeSocket *sock_min_int = sock_max_float->next;
		bNodeSocket *sock_max_int = sock_min_int->next;
		bNodeSocket *sock_min_color = sock_max_int->next;
		bNodeSocket *sock_max_color = sock_min_color->next;

const CustomDataType data_type = static_cast<CustomDataType>(node->custom1);		const NodeAttributeRandomize &storage = (const NodeAttributeRandomize )node->storage;
		const CustomDataType data_type = static_cast<CustomDataType>(storage.data_type);
nodeSetSocketAvailability(sock_min_vector, data_type == CD_PROP_FLOAT3);		nodeSetSocketAvailability(sock_min_vector, data_type == CD_PROP_FLOAT3);
nodeSetSocketAvailability(sock_max_vector, data_type == CD_PROP_FLOAT3);		nodeSetSocketAvailability(sock_max_vector, data_type == CD_PROP_FLOAT3);
nodeSetSocketAvailability(sock_min_float, data_type == CD_PROP_FLOAT);		nodeSetSocketAvailability(sock_min_float, data_type == CD_PROP_FLOAT);
nodeSetSocketAvailability(sock_max_float, data_type == CD_PROP_FLOAT);		nodeSetSocketAvailability(sock_max_float, data_type == CD_PROP_FLOAT);
		nodeSetSocketAvailability(sock_min_int, data_type == CD_PROP_INT32);
		nodeSetSocketAvailability(sock_max_int, data_type == CD_PROP_INT32);
		nodeSetSocketAvailability(sock_min_color, data_type == CD_PROP_COLOR);
		nodeSetSocketAvailability(sock_max_color, data_type == CD_PROP_COLOR);
}		}

namespace blender::nodes {		namespace blender::nodes {

/** Rehash to combine the seed with the "id" hash and a mutator for each dimension. */		template<typename T>
static float noise_from_index_and_mutator(const int seed, const int hash, const int mutator)		static void randomize_attribute(MutableSpan<T> span,
{		const T min,
const int combined_hash = BLI_hash_int_3d(seed, hash, mutator);		const T max,
return BLI_hash_int_01(combined_hash);		Span<uint32_t> seeds,
		const GeometryNodeAttributeRandomizeMode operation)
		{
		/* The operations could be templated too, but it make the code much shorter. */
		switch (operation) {
		case GEO_NODE_ATTRIBUTE_RANDOMIZE_REPLACE_CREATE:
		for (const int i : span.index_range()) {
		const T random_value = attribute_math::random_value<T>(seeds[i]) * (max - min) + min;
		span[i] = random_value;
}		}
		break;
/** Rehash to combine the seed with the "id" hash. */		case GEO_NODE_ATTRIBUTE_RANDOMIZE_ADD:
static float noise_from_index(const int seed, const int hash)		for (const int i : span.index_range()) {
{		const T random_value = attribute_math::random_value<T>(seeds[i]) * (max - min) + min;
const int combined_hash = BLI_hash_int_2d(seed, hash);		span[i] = span[i] + random_value;
return BLI_hash_int_01(combined_hash);
}		}
		break;
static void randomize_attribute_bool(BooleanWriteAttribute attribute,		case GEO_NODE_ATTRIBUTE_RANDOMIZE_SUBTRACT:
Span<uint32_t> hashes,		for (const int i : span.index_range()) {
const int seed)		const T random_value = attribute_math::random_value<T>(seeds[i]) * (max - min) + min;
{		span[i] = span[i] - random_value;
MutableSpan<bool> attribute_span = attribute.get_span();		}
for (const int i : IndexRange(attribute.size())) {		break;
const bool value = noise_from_index(seed, (int)hashes[i]) > 0.5f;		case GEO_NODE_ATTRIBUTE_RANDOMIZE_MULTIPLY:
attribute_span[i] = value;		for (const int i : span.index_range()) {
}		const T random_value = attribute_math::random_value<T>(seeds[i]) * (max - min) + min;
attribute.apply_span();		span[i] = span[i] * random_value;
		}
		break;
		case GEO_NODE_ATTRIBUTE_RANDOMIZE_DIVIDE:
		for (const int i : span.index_range()) {
		const T random_value = attribute_math::random_value<T>(seeds[i]) * (max - min) + min;
		span[i] = span[i] / random_value;
		}
		break;
		case GEO_NODE_ATTRIBUTE_RANDOMIZE_DIFFERENCE:
		for (const int i : span.index_range()) {
		const T random_value = attribute_math::random_value<T>(seeds[i]) * (max - min) + min;
		span[i] = random_value - span[i];
		}
		break;
		case GEO_NODE_ATTRIBUTE_RANDOMIZE_AVERAGE:
		for (const int i : span.index_range()) {
		const T random_value = attribute_math::random_value<T>(seeds[i]) * (max - min) + min;
		span[i] = (span[i] + random_value) / 2.0f;
		}
		break;
		default:
		BLI_assert(false);
		break;
		JacquesLuckeUnsubmitted Done Inline Actions What would make the code much shorter? JacquesLucke: What would make the code much shorter?
		HooglyBooglyAuthorUnsubmitted Done Inline Actions Agh, I forgot the word "doesn't" HooglyBoogly: Agh, I forgot the word "doesn't"
}		}

static void randomize_attribute_float(FloatWriteAttribute attribute,
const float min,
const float max,
Span<uint32_t> hashes,
const int seed)
{
MutableSpan<float> attribute_span = attribute.get_span();
for (const int i : IndexRange(attribute.size())) {
const float value = noise_from_index(seed, (int)hashes[i]) * (max - min) + min;
attribute_span[i] = value;
}
attribute.apply_span();
}		}

static void randomize_attribute_float3(Float3WriteAttribute attribute,		/**
const float3 min,		* \note Boolean gets special treatment because the operations
const float3 max,		* are different and don't require a min and max.
Span<uint32_t> hashes,		*/
const int seed)		static void randomize_attribute_bool(MutableSpan<bool> span,
{		Span<uint32_t> seeds,
MutableSpan<float3> attribute_span = attribute.get_span();		const GeometryNodeAttributeRandomizeMode operation)
for (const int i : IndexRange(attribute.size())) {		{
const float x = noise_from_index_and_mutator(seed, (int)hashes[i], 47);		switch (operation) {
const float y = noise_from_index_and_mutator(seed, (int)hashes[i], 8);		case GEO_NODE_ATTRIBUTE_RANDOMIZE_REPLACE_CREATE:
const float z = noise_from_index_and_mutator(seed, (int)hashes[i], 64);		for (const int i : span.index_range()) {
const float3 value = float3(x, y, z) * (max - min) + min;		const bool random_value = attribute_math::random_value<bool>(seeds[i]);
attribute_span[i] = value;		span[i] = random_value;
		}
		break;
		case GEO_NODE_ATTRIBUTE_RANDOMIZE_BOOL_AND:
		for (const int i : span.index_range()) {
		const bool random_value = attribute_math::random_value<bool>(seeds[i]);
		span[i] = span[i] && random_value;
		}
		break;
		case GEO_NODE_ATTRIBUTE_RANDOMIZE_BOOL_OR:
		for (const int i : span.index_range()) {
		const bool random_value = attribute_math::random_value<bool>(seeds[i]);
		span[i] = span[i] \|\| random_value;
		}
		break;
		case GEO_NODE_ATTRIBUTE_RANDOMIZE_BOOL_XOR:
		for (const int i : span.index_range()) {
		const bool random_value = attribute_math::random_value<bool>(seeds[i]);
		span[i] = span[i] != random_value;
		}
		break;
		default:
		BLI_assert(false);
		break;
}		}
attribute.apply_span();
}		}

Array<uint32_t> get_geometry_element_ids_as_uints(const GeometryComponent &component,		Array<uint32_t> get_geometry_element_ids_as_uints(const GeometryComponent &component,
const AttributeDomain domain)		const AttributeDomain domain)
{		{
const int domain_size = component.attribute_domain_size(domain);		const int domain_size = component.attribute_domain_size(domain);

/* Hash the reserved name attribute "id" as a (hopefully) stable seed for each point. */		/* Hash the reserved name attribute "id" as a (hopefully) stable seed for each point. */
Show All 13 Lines	else {
for (const int i : hashes.index_range()) {		for (const int i : hashes.index_range()) {
hashes[i] = rng.get_uint32();		hashes[i] = rng.get_uint32();
}		}
}		}

return hashes;		return hashes;
}		}

static void randomize_attribute(GeometryComponent &component,		static void randomize_attribute_on_component(GeometryComponent &component,
const GeoNodeExecParams &params,		const GeoNodeExecParams &params,
		StringRef attribute_name,
		const CustomDataType data_type,
		const AttributeDomain domain,
		const GeometryNodeAttributeRandomizeMode operation,
const int seed)		const int seed)
{		{
const bNode &node = params.node();
const CustomDataType data_type = static_cast<CustomDataType>(node.custom1);
const AttributeDomain domain = static_cast<AttributeDomain>(node.custom2);
const std::string attribute_name = params.get_input<std::string>("Attribute");
if (attribute_name.empty()) {
return;
}

OutputAttributePtr attribute = component.attribute_try_get_for_output(		OutputAttributePtr attribute = component.attribute_try_get_for_output(
attribute_name, domain, data_type);		attribute_name, domain, data_type);
if (!attribute) {		if (!attribute) {
return;		return;
}		}

		fn::GMutableSpan span = (operation == GEO_NODE_ATTRIBUTE_RANDOMIZE_REPLACE_CREATE) ?
		attribute->get_span_for_write_only() :
		attribute->get_span();

Array<uint32_t> hashes = get_geometry_element_ids_as_uints(component, domain);		Array<uint32_t> hashes = get_geometry_element_ids_as_uints(component, domain);

		/* Rehash to combine the seed with the "id" hash. */
		for (const int i : hashes.index_range()) {
		hashes[i] = BLI_hash_int_2d(hashes[i], seed);
		}

switch (data_type) {		switch (data_type) {
case CD_PROP_FLOAT: {		case CD_PROP_FLOAT3: {
const float min_value = params.get_input<float>("Min_001");		const float3 min = params.get_input<float3>("Min");
const float max_value = params.get_input<float>("Max_001");		const float3 max = params.get_input<float3>("Max");
randomize_attribute_float(*attribute, min_value, max_value, hashes, seed);		randomize_attribute<float3>(span.typed<float3>(), min, max, hashes, operation);
break;		break;
}		}
case CD_PROP_FLOAT3: {		case CD_PROP_FLOAT: {
const float3 min_value = params.get_input<float3>("Min");		const float min = params.get_input<float>("Min_001");
const float3 max_value = params.get_input<float3>("Max");		const float max = params.get_input<float>("Max_001");
randomize_attribute_float3(*attribute, min_value, max_value, hashes, seed);		randomize_attribute<float>(span.typed<float>(), min, max, hashes, operation);
break;		break;
}		}
case CD_PROP_BOOL: {		case CD_PROP_BOOL: {
randomize_attribute_bool(*attribute, hashes, seed);		randomize_attribute_bool(span.typed<bool>(), hashes, operation);
break;		break;
}		}
default:		case CD_PROP_INT32: {
		const int min = params.get_input<int>("Min_002");
		const int max = params.get_input<int>("Max_002");
		randomize_attribute<int>(span.typed<int>(), min, max, hashes, operation);
		return;
		}
		case CD_PROP_COLOR: {
		const Color4f min = params.get_input<Color4f>("Min_003");
		const Color4f max = params.get_input<Color4f>("Max_003");
		randomize_attribute<Color4f>(span.typed<Color4f>(), min, max, hashes, operation);
		return;
		}
		default: {
		BLI_assert(false);
break;		break;
}		}
		}

attribute.save();		attribute.apply_span_and_save();
}		}

static void geo_node_random_attribute_exec(GeoNodeExecParams params)		static void geo_node_random_attribute_exec(GeoNodeExecParams params)
{		{
GeometrySet geometry_set = params.extract_input<GeometrySet>("Geometry");		GeometrySet geometry_set = params.extract_input<GeometrySet>("Geometry");
		const std::string attribute_name = params.get_input<std::string>("Attribute");
		if (attribute_name.empty()) {
		params.set_output("Geometry", geometry_set);
		return;
		}
const int seed = params.get_input<int>("Seed");		const int seed = params.get_input<int>("Seed");
		const NodeAttributeRandomize &storage = (const NodeAttributeRandomize )params.node().storage;
		const CustomDataType data_type = static_cast<CustomDataType>(storage.data_type);
		const AttributeDomain domain = static_cast<AttributeDomain>(storage.domain);
		const GeometryNodeAttributeRandomizeMode operation =
		static_cast<GeometryNodeAttributeRandomizeMode>(storage.operation);

if (geometry_set.has<MeshComponent>()) {		if (geometry_set.has<MeshComponent>()) {
randomize_attribute(geometry_set.get_component_for_write<MeshComponent>(), params, seed);		randomize_attribute_on_component(geometry_set.get_component_for_write<MeshComponent>(),
		params,
		attribute_name,
		data_type,
		domain,
		operation,
		seed);
}		}
if (geometry_set.has<PointCloudComponent>()) {		if (geometry_set.has<PointCloudComponent>()) {
randomize_attribute(geometry_set.get_component_for_write<PointCloudComponent>(), params, seed);		randomize_attribute_on_component(geometry_set.get_component_for_write<PointCloudComponent>(),
		params,
		attribute_name,
		data_type,
		domain,
		operation,
		seed);
}		}

params.set_output("Geometry", geometry_set);		params.set_output("Geometry", geometry_set);
}		}

} // namespace blender::nodes		} // namespace blender::nodes

void register_node_type_geo_attribute_randomize()		void register_node_type_geo_attribute_randomize()
{		{
static bNodeType ntype;		static bNodeType ntype;

geo_node_type_base(		geo_node_type_base(
&ntype, GEO_NODE_ATTRIBUTE_RANDOMIZE, "Attribute Randomize", NODE_CLASS_ATTRIBUTE, 0);		&ntype, GEO_NODE_ATTRIBUTE_RANDOMIZE, "Attribute Randomize", NODE_CLASS_ATTRIBUTE, 0);
node_type_socket_templates(		node_type_socket_templates(
&ntype, geo_node_attribute_randomize_in, geo_node_attribute_randomize_out);		&ntype, geo_node_attribute_randomize_in, geo_node_attribute_randomize_out);
node_type_init(&ntype, geo_node_attribute_randomize_init);		node_type_init(&ntype, geo_node_attribute_randomize_init);
node_type_update(&ntype, geo_node_attribute_randomize_update);		node_type_update(&ntype, geo_node_attribute_randomize_update);
ntype.geometry_node_execute = blender::nodes::geo_node_random_attribute_exec;		ntype.geometry_node_execute = blender::nodes::geo_node_random_attribute_exec;
		node_type_storage(
		&ntype, "NodeAttributeRandomize", node_free_standard_storage, node_copy_standard_storage);
nodeRegisterType(&ntype);		nodeRegisterType(&ntype);
}		}