griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Refactor: Geometry Nodes: use SocketValueVariant to get value from socket

Browse Source 
This moves us closer to removing `geometry_nodes_cpp_type` which is
always `SocketValueVariant` now.

Pull Request: https://projects.blender.org/blender/blender/pulls/144445
This commit is contained in:
Jacques Lucke
2025-08-12 19:11:05 +02:00
parent 5f721c2e2e
commit 69cf5e1ad7
5 changed files with 82 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/BKE_node.hh
View File

@@ -124,7 +124,7 @@ using NodeDeclareDynamicFunction = void (*)(const bNodeTree &tree,
const bNode &node,
blender::nodes::NodeDeclarationBuilder &builder);
using SocketGetCPPValueFunction = void (*)(const void *socket_value, void *r_value);
using SocketGetGeometryNodesCPPValueFunction = void (*)(const void *socket_value, void *r_value);
using SocketGetGeometryNodesCPPValueFunction = SocketValueVariant (*)(const void *socket_value);
/* Adds socket link operations that are specific to this node type. */
using NodeGatherSocketLinkOperationsFunction =

119
source/blender/nodes/intern/geometry_nodes_execute.cc
View File

@@ -477,9 +477,8 @@ PropertiesVectorSet build_properties_vector_set(const IDProperty *properties)
return set;
}
static void init_socket_cpp_value_from_property(const IDProperty &property,
const eNodeSocketDatatype socket_value_type,
void *r_value)
static bke::SocketValueVariant init_socket_cpp_value_from_property(
const IDProperty &property, const eNodeSocketDatatype socket_value_type)
{
switch (socket_value_type) {
case SOCK_FLOAT: {
@@ -490,13 +489,11 @@ static void init_socket_cpp_value_from_property(const IDProperty &property,
else if (property.type == IDP_DOUBLE) {
value = float(IDP_Double(&property));
}
new (r_value) bke::SocketValueVariant(value);
break;
return bke::SocketValueVariant(value);
}
case SOCK_INT: {
int value = IDP_Int(&property);
new (r_value) bke::SocketValueVariant(value);
break;
return bke::SocketValueVariant(value);
}
case SOCK_VECTOR: {
const void *property_array = IDP_Array(&property);
@@ -523,8 +520,7 @@ static void init_socket_cpp_value_from_property(const IDProperty &property,
}
/* Only float3 vectors are supported for now. */
new (r_value) bke::SocketValueVariant(float3(values));
break;
return bke::SocketValueVariant(float3(values));
}
case SOCK_RGBA: {
const void *property_array = IDP_Array(&property);
@@ -540,13 +536,11 @@ static void init_socket_cpp_value_from_property(const IDProperty &property,
vec = float4(double4(static_cast<const double *>(property_array)));
}
ColorGeometry4f value(vec);
new (r_value) bke::SocketValueVariant(value);
break;
return bke::SocketValueVariant(value);
}
case SOCK_BOOLEAN: {
const bool value = IDP_Bool(&property);
new (r_value) bke::SocketValueVariant(value);
break;
return bke::SocketValueVariant(value);
}
case SOCK_ROTATION: {
const void *property_array = IDP_Array(&property);
@@ -562,52 +556,44 @@ static void init_socket_cpp_value_from_property(const IDProperty &property,
vec = float3(double3(static_cast<const double *>(property_array)));
}
const math::EulerXYZ euler_value = math::EulerXYZ(vec);
new (r_value) bke::SocketValueVariant(math::to_quaternion(euler_value));
break;
return bke::SocketValueVariant(math::to_quaternion(euler_value));
}
case SOCK_STRING: {
std::string value = IDP_String(&property);
bke::SocketValueVariant::ConstructIn(r_value, std::move(value));
break;
return bke::SocketValueVariant::From(std::move(value));
}
case SOCK_MENU: {
int value = IDP_Int(&property);
new (r_value) bke::SocketValueVariant(std::move(value));
break;
return bke::SocketValueVariant(std::move(value));
}
case SOCK_OBJECT: {
ID *id = IDP_Id(&property);
Object *object = (id && GS(id->name) == ID_OB) ? (Object *)id : nullptr;
bke::SocketValueVariant::ConstructIn(r_value, object);
break;
return bke::SocketValueVariant::From(object);
}
case SOCK_COLLECTION: {
ID *id = IDP_Id(&property);
Collection *collection = (id && GS(id->name) == ID_GR) ? (Collection *)id : nullptr;
bke::SocketValueVariant::ConstructIn(r_value, collection);
break;
return bke::SocketValueVariant::From(collection);
}
case SOCK_TEXTURE: {
ID *id = IDP_Id(&property);
Tex *texture = (id && GS(id->name) == ID_TE) ? (Tex *)id : nullptr;
bke::SocketValueVariant::ConstructIn(r_value, texture);
break;
return bke::SocketValueVariant::From(texture);
}
case SOCK_IMAGE: {
ID *id = IDP_Id(&property);
Image *image = (id && GS(id->name) == ID_IM) ? (Image *)id : nullptr;
bke::SocketValueVariant::ConstructIn(r_value, image);
break;
return bke::SocketValueVariant::From(image);
}
case SOCK_MATERIAL: {
ID *id = IDP_Id(&property);
Material *material = (id && GS(id->name) == ID_MA) ? (Material *)id : nullptr;
bke::SocketValueVariant::ConstructIn(r_value, material);
break;
return bke::SocketValueVariant::From(material);
}
default: {
BLI_assert_unreachable();
break;
return {};
}
}
}
@@ -637,45 +623,39 @@ std::optional<StringRef> input_attribute_name_get(const PropertiesVectorSet &pro
return IDP_String(property_attribute_name);
}
static void initialize_group_input(const bNodeTree &tree,
const PropertiesVectorSet &properties,
const int input_index,
void *r_value)
static bke::SocketValueVariant initialize_group_input(const bNodeTree &tree,
const PropertiesVectorSet &properties,
const int input_index)
{
const bNodeTreeInterfaceSocket &io_input = *tree.interface_inputs()[input_index];
const bke::bNodeSocketType *typeinfo = io_input.socket_typeinfo();
const eNodeSocketDatatype socket_data_type = typeinfo ? typeinfo->type : SOCK_CUSTOM;
const IDProperty *property = properties.lookup_key_default_as(io_input.identifier, nullptr);
if (property == nullptr) {
typeinfo->get_geometry_nodes_cpp_value(io_input.socket_data, r_value);
return;
return typeinfo->get_geometry_nodes_cpp_value(io_input.socket_data);
}
if (!id_property_type_matches_socket(io_input, *property)) {
typeinfo->get_geometry_nodes_cpp_value(io_input.socket_data, r_value);
return;
return typeinfo->get_geometry_nodes_cpp_value(io_input.socket_data);
}
if (!input_has_attribute_toggle(tree, input_index)) {
init_socket_cpp_value_from_property(*property, socket_data_type, r_value);
return;
return init_socket_cpp_value_from_property(*property, socket_data_type);
}
const std::optional<StringRef> attribute_name = input_attribute_name_get(properties, io_input);
if (attribute_name && bke::allow_procedural_attribute_access(*attribute_name)) {
fn::GField attribute_field = bke::AttributeFieldInput::from(*attribute_name,
*typeinfo->base_cpp_type);
bke::SocketValueVariant::ConstructIn(r_value, std::move(attribute_field));
return bke::SocketValueVariant::From(std::move(attribute_field));
}
else if (is_layer_selection_field(io_input)) {
if (is_layer_selection_field(io_input)) {
const IDProperty *property_layer_name = properties.lookup_key_as(io_input.identifier);
StringRef layer_name = IDP_String(property_layer_name);
fn::GField selection_field(std::make_shared<bke::NamedLayerSelectionFieldInput>(layer_name),
0);
bke::SocketValueVariant::ConstructIn(r_value, std::move(selection_field));
}
else {
init_socket_cpp_value_from_property(*property, socket_data_type, r_value);
return bke::SocketValueVariant::From(std::move(selection_field));
}
return init_socket_cpp_value_from_property(*property, socket_data_type);
}
struct OutputAttributeInfo {
@@ -894,8 +874,8 @@ bke::GeometrySet execute_geometry_nodes_on_geometry(const bNodeTree &btree,
user_data.compute_context = &base_compute_context;
LinearAllocator<> allocator;
Vector<GMutablePointer> inputs_to_destruct;
ResourceScope scope;
LinearAllocator<> &allocator = scope.allocator();
btree.ensure_interface_cache();
@@ -905,19 +885,15 @@ bke::GeometrySet execute_geometry_nodes_on_geometry(const bNodeTree &btree,
const bke::bNodeSocketType *typeinfo = interface_socket.socket_typeinfo();
const eNodeSocketDatatype socket_type = typeinfo ? typeinfo->type : SOCK_CUSTOM;
if (socket_type == SOCK_GEOMETRY && i == 0) {
bke::SocketValueVariant *value = allocator.construct<bke::SocketValueVariant>().release();
value->set(input_geometry);
param_inputs[function.inputs.main[0]] = value;
inputs_to_destruct.append(value);
bke::SocketValueVariant &value = scope.construct<bke::SocketValueVariant>();
value.set(input_geometry);
param_inputs[function.inputs.main[0]] = &value;
continue;
}
const CPPType *type = typeinfo->geometry_nodes_cpp_type;
BLI_assert(type != nullptr);
void *value = allocator.allocate(*type);
initialize_group_input(btree, properties_set, i, value);
param_inputs[function.inputs.main[i]] = {type, value};
inputs_to_destruct.append({type, value});
bke::SocketValueVariant value = initialize_group_input(btree, properties_set, i);
param_inputs[function.inputs.main[i]] = &scope.construct<bke::SocketValueVariant>(
std::move(value));
}
/* Prepare used-outputs inputs. */
@@ -956,10 +932,6 @@ bke::GeometrySet execute_geometry_nodes_on_geometry(const bNodeTree &btree,
}
lazy_function.destruct_storage(lf_context.storage);
for (GMutablePointer &ptr : inputs_to_destruct) {
ptr.destruct();
}
bke::GeometrySet output_geometry =
param_outputs[0].get<bke::SocketValueVariant>()->extract<bke::GeometrySet>();
store_output_attributes(output_geometry, btree, properties_set, param_outputs);
@@ -1108,7 +1080,7 @@ void get_geometry_nodes_input_base_values(const bNodeTree &btree,
continue;
}
const eNodeSocketDatatype socket_type = stype->type;
if (!stype->base_cpp_type || !stype->geometry_nodes_cpp_type) {
if (!stype->base_cpp_type || !stype->geometry_nodes_default_value) {
continue;
}
const IDProperty *property = properties.lookup_key_default_as(io_input.identifier, nullptr);
@@ -1127,23 +1099,14 @@ void get_geometry_nodes_input_base_values(const bNodeTree &btree,
continue;
}
void *value_buffer = scope.allocate_owned(*stype->geometry_nodes_cpp_type);
init_socket_cpp_value_from_property(*property, socket_type, value_buffer);
if (stype->geometry_nodes_cpp_type == stype->base_cpp_type) {
r_values[input_i] = {stype->base_cpp_type, value_buffer};
continue;
}
if (stype->geometry_nodes_cpp_type == &CPPType::get<bke::SocketValueVariant>()) {
const bke::SocketValueVariant &socket_value = *static_cast<const bke::SocketValueVariant *>(
value_buffer);
if (!socket_value.is_single()) {
continue;
}
const GPointer single_value = socket_value.get_single_ptr();
BLI_assert(single_value.type() == stype->base_cpp_type);
r_values[input_i] = single_value;
bke::SocketValueVariant &value = scope.construct<bke::SocketValueVariant>(
init_socket_cpp_value_from_property(*property, socket_type));
if (!value.is_single()) {
continue;
}
const GPointer single_value = value.get_single_ptr();
BLI_assert(single_value.type() == stype->base_cpp_type);
r_values[input_i] = single_value;
}
}

18
source/blender/nodes/intern/geometry_nodes_foreach_geometry_element_zone.cc
View File

@@ -796,19 +796,13 @@ LazyFunctionForReduceForeachGeometryElement::LazyFunctionForReduceForeachGeometr
/* Add parameters for main items. */
for (const int item_i : IndexRange(node_storage.main_items.items_num)) {
const NodeForeachGeometryElementMainItem &item = node_storage.main_items.items[item_i];
const bNodeSocket &socket = parent.output_bnode_.input_socket(
parent_.indices_.main.bsocket_inner[item_i]);
inputs_.append_as(
item.name, *socket.typeinfo->geometry_nodes_cpp_type, lf::ValueUsage::Used);
inputs_.append_as(item.name, CPPType::get<SocketValueVariant>(), lf::ValueUsage::Used);
}
/* Add parameters for generation items. */
for (const int item_i : IndexRange(node_storage.generation_items.items_num)) {
const NodeForeachGeometryElementGenerationItem &item =
node_storage.generation_items.items[item_i];
const bNodeSocket &socket = parent.output_bnode_.input_socket(
parent_.indices_.generation.bsocket_inner[item_i]);
inputs_.append_as(
item.name, *socket.typeinfo->geometry_nodes_cpp_type, lf::ValueUsage::Maybe);
inputs_.append_as(item.name, CPPType::get<SocketValueVariant>(), lf::ValueUsage::Maybe);
}
}
@@ -817,17 +811,13 @@ LazyFunctionForReduceForeachGeometryElement::LazyFunctionForReduceForeachGeometr
/* Add outputs for main items. */
for (const int item_i : IndexRange(node_storage.main_items.items_num)) {
const NodeForeachGeometryElementMainItem &item = node_storage.main_items.items[item_i];
const bNodeSocket &socket = parent.output_bnode_.output_socket(
parent_.indices_.main.bsocket_outer[item_i]);
outputs_.append_as(item.name, *socket.typeinfo->geometry_nodes_cpp_type);
outputs_.append_as(item.name, CPPType::get<SocketValueVariant>());
}
/* Add outputs for generation items. */
for (const int item_i : IndexRange(node_storage.generation_items.items_num)) {
const NodeForeachGeometryElementGenerationItem &item =
node_storage.generation_items.items[item_i];
const bNodeSocket &socket = parent.output_bnode_.output_socket(
parent_.indices_.generation.bsocket_outer[item_i]);
outputs_.append_as(item.name, *socket.typeinfo->geometry_nodes_cpp_type);
outputs_.append_as(item.name, CPPType::get<SocketValueVariant>());
}
}

24
source/blender/nodes/intern/geometry_nodes_lazy_function.cc
View File

@@ -1267,19 +1267,6 @@ class LazyFunctionForGroupNode : public LazyFunction {
}
};
static GMutablePointer get_socket_default_value(LinearAllocator<> &allocator,
const bNodeSocket &bsocket)
{
const bke::bNodeSocketType &typeinfo = *bsocket.typeinfo;
const CPPType *type = get_socket_cpp_type(typeinfo);
if (type == nullptr) {
return {};
}
void *buffer = allocator.allocate(*type);
typeinfo.get_geometry_nodes_cpp_value(bsocket.default_value, buffer);
return {type, buffer};
}
LazyFunctionForLogicalOr::LazyFunctionForLogicalOr(const int inputs_num)
{
debug_name_ = "Logical Or";
@@ -3911,15 +3898,8 @@ struct GeometryNodesLazyFunctionBuilder {
if (this->try_add_implicit_input(input_bsocket, input_lf_socket, graph_params)) {
return;
}
GMutablePointer value = get_socket_default_value(scope_.allocator(), input_bsocket);
if (value.get() == nullptr) {
/* Not possible to add a default value. */
return;
}
input_lf_socket.set_default_value(value.get());
if (!value.type()->is_trivially_destructible) {
scope_.add_destruct_call([value]() mutable { value.destruct(); });
}
input_lf_socket.set_default_value(&scope_.add_value(
input_bsocket.typeinfo->get_geometry_nodes_cpp_value(input_bsocket.default_value)));
}
bool try_add_implicit_input(const bNodeSocket &input_bsocket,

68
source/blender/nodes/intern/node_socket.cc
View File

@@ -969,9 +969,9 @@ static bke::bNodeSocketType *make_socket_type_bool()
*(bool *)r_value = ((bNodeSocketValueBoolean *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
const bool value = ((bNodeSocketValueBoolean *)socket_value)->value;
new (r_value) SocketValueVariant(value);
return SocketValueVariant(value);
};
static SocketValueVariant default_value{false};
socktype->geometry_nodes_default_value = &default_value;
@@ -988,11 +988,11 @@ static bke::bNodeSocketType *make_socket_type_rotation()
*static_cast<math::Quaternion *>(r_value) = math::to_quaternion(euler);
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
const auto &typed_value = *(bNodeSocketValueRotation *)socket_value;
const math::EulerXYZ euler(float3(typed_value.value_euler));
const math::Quaternion value = math::to_quaternion(euler);
new (r_value) SocketValueVariant(value);
return SocketValueVariant(value);
};
static SocketValueVariant default_value{math::Quaternion::identity()};
socktype->geometry_nodes_default_value = &default_value;
@@ -1007,8 +1007,8 @@ static bke::bNodeSocketType *make_socket_type_matrix()
*static_cast<float4x4 *>(r_value) = float4x4::identity();
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void * /*socket_value*/, void *r_value) {
new (r_value) SocketValueVariant(float4x4::identity());
socktype->get_geometry_nodes_cpp_value = [](const void * /*socket_value*/) {
return SocketValueVariant(float4x4::identity());
};
static SocketValueVariant default_value{float4x4::identity()};
socktype->geometry_nodes_default_value = &default_value;
@@ -1023,8 +1023,8 @@ static bke::bNodeSocketType *make_socket_type_bundle()
new (r_value) nodes::BundlePtr();
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void * /*socket_value*/, void *r_value) {
SocketValueVariant::ConstructIn(r_value, nodes::BundlePtr());
socktype->get_geometry_nodes_cpp_value = [](const void * /*socket_value*/) {
return SocketValueVariant::From(nodes::BundlePtr());
};
static SocketValueVariant default_value = SocketValueVariant::From(nodes::BundlePtr());
socktype->geometry_nodes_default_value = &default_value;
@@ -1039,8 +1039,8 @@ static bke::bNodeSocketType *make_socket_type_closure()
new (r_value) nodes::ClosurePtr();
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void * /*socket_value*/, void *r_value) {
SocketValueVariant::ConstructIn(r_value, nodes::ClosurePtr());
socktype->get_geometry_nodes_cpp_value = [](const void * /*socket_value*/) {
return SocketValueVariant::From(nodes::ClosurePtr());
};
static SocketValueVariant default_value = SocketValueVariant::From(nodes::ClosurePtr());
socktype->geometry_nodes_default_value = &default_value;
@@ -1055,9 +1055,9 @@ static bke::bNodeSocketType *make_socket_type_float(PropertySubType subtype)
*(float *)r_value = ((bNodeSocketValueFloat *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
const float value = ((bNodeSocketValueFloat *)socket_value)->value;
new (r_value) SocketValueVariant(value);
return SocketValueVariant(value);
};
static SocketValueVariant default_value{0.0f};
socktype->geometry_nodes_default_value = &default_value;
@@ -1072,9 +1072,9 @@ static bke::bNodeSocketType *make_socket_type_int(PropertySubType subtype)
*(int *)r_value = ((bNodeSocketValueInt *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
const int value = ((bNodeSocketValueInt *)socket_value)->value;
new (r_value) SocketValueVariant(value);
return SocketValueVariant(value);
};
static SocketValueVariant default_value{0};
socktype->geometry_nodes_default_value = &default_value;
@@ -1089,9 +1089,9 @@ static bke::bNodeSocketType *make_socket_type_vector(PropertySubType subtype, co
*(blender::float3 *)r_value = ((bNodeSocketValueVector *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
const blender::float3 value = ((bNodeSocketValueVector *)socket_value)->value;
new (r_value) SocketValueVariant(value);
return SocketValueVariant(value);
};
static SocketValueVariant default_value{blender::float3(0, 0, 0)};
socktype->geometry_nodes_default_value = &default_value;
@@ -1106,9 +1106,9 @@ static bke::bNodeSocketType *make_socket_type_rgba()
*(blender::ColorGeometry4f *)r_value = ((bNodeSocketValueRGBA *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
const blender::ColorGeometry4f value = ((bNodeSocketValueRGBA *)socket_value)->value;
new (r_value) SocketValueVariant(value);
return SocketValueVariant(value);
};
static SocketValueVariant default_value{blender::ColorGeometry4f(0, 0, 0, 0)};
socktype->geometry_nodes_default_value = &default_value;
@@ -1123,9 +1123,9 @@ static bke::bNodeSocketType *make_socket_type_string(PropertySubType subtype)
new (r_value) std::string(((bNodeSocketValueString *)socket_value)->value);
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
std::string value = ((bNodeSocketValueString *)socket_value)->value;
new (r_value) SocketValueVariant(value);
return SocketValueVariant(value);
};
static SocketValueVariant default_value{std::string()};
socktype->geometry_nodes_default_value = &default_value;
@@ -1140,9 +1140,9 @@ static bke::bNodeSocketType *make_socket_type_menu()
*(int *)r_value = ((bNodeSocketValueMenu *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
const int value = ((bNodeSocketValueMenu *)socket_value)->value;
new (r_value) SocketValueVariant(value);
return SocketValueVariant(value);
};
static SocketValueVariant default_value{0};
socktype->geometry_nodes_default_value = &default_value;
@@ -1157,9 +1157,9 @@ static bke::bNodeSocketType *make_socket_type_object()
*(Object **)r_value = ((bNodeSocketValueObject *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
Object *object = static_cast<const bNodeSocketValueObject *>(socket_value)->value;
SocketValueVariant::ConstructIn(r_value, object);
return SocketValueVariant::From(object);
};
static SocketValueVariant default_value = SocketValueVariant::From(
static_cast<Object *>(nullptr));
@@ -1175,8 +1175,8 @@ static bke::bNodeSocketType *make_socket_type_geometry()
new (r_value) blender::bke::GeometrySet();
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void * /*socket_value*/, void *r_value) {
SocketValueVariant::ConstructIn(r_value, bke::GeometrySet());
socktype->get_geometry_nodes_cpp_value = [](const void * /*socket_value*/) {
return SocketValueVariant::From(bke::GeometrySet());
};
static SocketValueVariant default_value = SocketValueVariant::From(bke::GeometrySet());
socktype->geometry_nodes_default_value = &default_value;
@@ -1191,9 +1191,9 @@ static bke::bNodeSocketType *make_socket_type_collection()
*(Collection **)r_value = ((bNodeSocketValueCollection *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
Collection *collection = static_cast<const bNodeSocketValueCollection *>(socket_value)->value;
SocketValueVariant::ConstructIn(r_value, collection);
return SocketValueVariant::From(collection);
};
static SocketValueVariant default_value = SocketValueVariant::From(
static_cast<Collection *>(nullptr));
@@ -1209,9 +1209,9 @@ static bke::bNodeSocketType *make_socket_type_texture()
*(Tex **)r_value = ((bNodeSocketValueTexture *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
Tex *texture = static_cast<const bNodeSocketValueTexture *>(socket_value)->value;
SocketValueVariant::ConstructIn(r_value, texture);
return SocketValueVariant::From(texture);
};
static SocketValueVariant default_value = SocketValueVariant::From(static_cast<Tex *>(nullptr));
socktype->geometry_nodes_default_value = &default_value;
@@ -1226,9 +1226,9 @@ static bke::bNodeSocketType *make_socket_type_image()
*(Image **)r_value = ((bNodeSocketValueImage *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
Image *image = static_cast<const bNodeSocketValueImage *>(socket_value)->value;
SocketValueVariant::ConstructIn(r_value, image);
return SocketValueVariant::From(image);
};
static SocketValueVariant default_value = SocketValueVariant::From(
static_cast<Image *>(nullptr));
@@ -1244,9 +1244,9 @@ static bke::bNodeSocketType *make_socket_type_material()
*(Material **)r_value = ((bNodeSocketValueMaterial *)socket_value)->value;
};
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<SocketValueVariant>();
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value, void *r_value) {
socktype->get_geometry_nodes_cpp_value = [](const void *socket_value) {
Material *material = static_cast<const bNodeSocketValueMaterial *>(socket_value)->value;
SocketValueVariant::ConstructIn(r_value, material);
return SocketValueVariant::From(material);
};
static SocketValueVariant default_value = SocketValueVariant::From(
static_cast<Material *>(nullptr));