BLI: move CPPType to blenlib
For more detail about `CPPType`, see `BLI_cpp_type.hh` and D14367. Differential Revision: https://developer.blender.org/D14367
This commit is contained in:
parent
7509a74116
commit
2252bc6a55
Notes:
blender-bot
2023-02-14 08:24:03 +01:00
Referenced by commit 3e16f3b3ef
, BLI: move generic data structures to blenlib
Referenced by issue #101660, Blender crash for mesh with string attribute.
|
@ -4,7 +4,6 @@
|
|||
|
||||
#include <mutex>
|
||||
|
||||
#include "FN_cpp_type.hh"
|
||||
#include "FN_generic_span.hh"
|
||||
#include "FN_generic_virtual_array.hh"
|
||||
|
||||
|
@ -166,7 +165,6 @@ using AttributeForeachCallback = blender::FunctionRef<bool(
|
|||
|
||||
namespace blender::bke {
|
||||
|
||||
using fn::CPPType;
|
||||
using fn::GVArray;
|
||||
using fn::GVMutableArray;
|
||||
|
||||
|
@ -390,7 +388,7 @@ class CustomDataAttributes {
|
|||
template<typename T>
|
||||
blender::VArray<T> get_for_read(const AttributeIDRef &attribute_id, const T &default_value) const
|
||||
{
|
||||
const blender::fn::CPPType &cpp_type = blender::fn::CPPType::get<T>();
|
||||
const blender::CPPType &cpp_type = blender::CPPType::get<T>();
|
||||
const CustomDataType type = blender::bke::cpp_type_to_custom_data_type(cpp_type);
|
||||
GVArray varray = this->get_for_read(attribute_id, type, &default_value);
|
||||
return varray.typed<T>();
|
||||
|
|
|
@ -4,17 +4,14 @@
|
|||
|
||||
#include "BLI_array.hh"
|
||||
#include "BLI_color.hh"
|
||||
#include "BLI_cpp_type.hh"
|
||||
#include "BLI_math_vector.h"
|
||||
#include "BLI_math_vector.hh"
|
||||
|
||||
#include "DNA_customdata_types.h"
|
||||
|
||||
#include "FN_cpp_type.hh"
|
||||
|
||||
namespace blender::attribute_math {
|
||||
|
||||
using fn::CPPType;
|
||||
|
||||
/**
|
||||
* Utility function that simplifies calling a templated function based on a custom data type.
|
||||
*/
|
||||
|
@ -50,7 +47,7 @@ inline void convert_to_static_type(const CustomDataType data_type, const Func &f
|
|||
}
|
||||
|
||||
template<typename Func>
|
||||
inline void convert_to_static_type(const fn::CPPType &cpp_type, const Func &func)
|
||||
inline void convert_to_static_type(const CPPType &cpp_type, const Func &func)
|
||||
{
|
||||
if (cpp_type.is<float>()) {
|
||||
func(float());
|
||||
|
|
|
@ -212,7 +212,7 @@ class GeometryComponent {
|
|||
const AttributeDomain domain,
|
||||
const T &default_value) const
|
||||
{
|
||||
const blender::fn::CPPType &cpp_type = blender::fn::CPPType::get<T>();
|
||||
const blender::CPPType &cpp_type = blender::CPPType::get<T>();
|
||||
const CustomDataType type = blender::bke::cpp_type_to_custom_data_type(cpp_type);
|
||||
return this->attribute_get_for_read(attribute_id, domain, type, &default_value)
|
||||
.template typed<T>();
|
||||
|
@ -240,7 +240,7 @@ class GeometryComponent {
|
|||
const AttributeDomain domain,
|
||||
const T default_value)
|
||||
{
|
||||
const blender::fn::CPPType &cpp_type = blender::fn::CPPType::get<T>();
|
||||
const blender::CPPType &cpp_type = blender::CPPType::get<T>();
|
||||
const CustomDataType data_type = blender::bke::cpp_type_to_custom_data_type(cpp_type);
|
||||
return this->attribute_try_get_for_output(attribute_id, domain, data_type, &default_value);
|
||||
}
|
||||
|
@ -260,7 +260,7 @@ class GeometryComponent {
|
|||
blender::bke::OutputAttribute_Typed<T> attribute_try_get_for_output_only(
|
||||
const blender::bke::AttributeIDRef &attribute_id, const AttributeDomain domain)
|
||||
{
|
||||
const blender::fn::CPPType &cpp_type = blender::fn::CPPType::get<T>();
|
||||
const blender::CPPType &cpp_type = blender::CPPType::get<T>();
|
||||
const CustomDataType data_type = blender::bke::cpp_type_to_custom_data_type(cpp_type);
|
||||
return this->attribute_try_get_for_output_only(attribute_id, domain, data_type);
|
||||
}
|
||||
|
|
|
@ -21,7 +21,6 @@ class OutputAttribute;
|
|||
|
||||
namespace blender::bke::mesh_surface_sample {
|
||||
|
||||
using fn::CPPType;
|
||||
using fn::GMutableSpan;
|
||||
using fn::GSpan;
|
||||
using fn::GVArray;
|
||||
|
|
|
@ -99,6 +99,7 @@ typedef struct bNodeSocketTemplate {
|
|||
* However, achieving this requires quite a few changes currently. */
|
||||
#ifdef __cplusplus
|
||||
namespace blender {
|
||||
class CPPType;
|
||||
namespace nodes {
|
||||
class NodeMultiFunctionBuilder;
|
||||
class GeoNodeExecParams;
|
||||
|
@ -106,12 +107,11 @@ class NodeDeclarationBuilder;
|
|||
class GatherLinkSearchOpParams;
|
||||
} // namespace nodes
|
||||
namespace fn {
|
||||
class CPPType;
|
||||
class MFDataType;
|
||||
} // namespace fn
|
||||
} // namespace blender
|
||||
|
||||
using CPPTypeHandle = blender::fn::CPPType;
|
||||
using CPPTypeHandle = blender::CPPType;
|
||||
using NodeMultiFunctionBuildFunction = void (*)(blender::nodes::NodeMultiFunctionBuilder &builder);
|
||||
using NodeGeometryExecFunction = void (*)(blender::nodes::GeoNodeExecParams params);
|
||||
using NodeDeclareFunction = void (*)(blender::nodes::NodeDeclarationBuilder &builder);
|
||||
|
|
|
@ -6,8 +6,6 @@
|
|||
|
||||
namespace blender::bke {
|
||||
|
||||
using fn::CPPType;
|
||||
|
||||
struct ConversionFunctions {
|
||||
const fn::MultiFunction *multi_function;
|
||||
void (*convert_single_to_initialized)(const void *src, void *dst);
|
||||
|
|
|
@ -54,7 +54,7 @@ std::ostream &operator<<(std::ostream &stream, const AttributeIDRef &attribute_i
|
|||
return stream;
|
||||
}
|
||||
|
||||
const blender::fn::CPPType *custom_data_type_to_cpp_type(const CustomDataType type)
|
||||
const blender::CPPType *custom_data_type_to_cpp_type(const CustomDataType type)
|
||||
{
|
||||
switch (type) {
|
||||
case CD_PROP_FLOAT:
|
||||
|
@ -77,7 +77,7 @@ const blender::fn::CPPType *custom_data_type_to_cpp_type(const CustomDataType ty
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
CustomDataType cpp_type_to_custom_data_type(const blender::fn::CPPType &type)
|
||||
CustomDataType cpp_type_to_custom_data_type(const blender::CPPType &type)
|
||||
{
|
||||
if (type.is<float>()) {
|
||||
return CD_PROP_FLOAT;
|
||||
|
@ -1102,7 +1102,7 @@ std::optional<AttributeMetaData> GeometryComponent::attribute_get_meta_data(
|
|||
}
|
||||
|
||||
static blender::fn::GVArray try_adapt_data_type(blender::fn::GVArray varray,
|
||||
const blender::fn::CPPType &to_type)
|
||||
const blender::CPPType &to_type)
|
||||
{
|
||||
const blender::bke::DataTypeConversions &conversions =
|
||||
blender::bke::get_implicit_type_conversions();
|
||||
|
@ -1127,7 +1127,7 @@ blender::fn::GVArray GeometryComponent::attribute_try_get_for_read(
|
|||
}
|
||||
}
|
||||
|
||||
const blender::fn::CPPType *cpp_type = blender::bke::custom_data_type_to_cpp_type(data_type);
|
||||
const blender::CPPType *cpp_type = blender::bke::custom_data_type_to_cpp_type(data_type);
|
||||
BLI_assert(cpp_type != nullptr);
|
||||
if (varray.type() != *cpp_type) {
|
||||
varray = try_adapt_data_type(std::move(varray), *cpp_type);
|
||||
|
@ -1165,7 +1165,7 @@ blender::bke::ReadAttributeLookup GeometryComponent::attribute_try_get_for_read(
|
|||
if (!attribute) {
|
||||
return {};
|
||||
}
|
||||
const blender::fn::CPPType *type = blender::bke::custom_data_type_to_cpp_type(data_type);
|
||||
const blender::CPPType *type = blender::bke::custom_data_type_to_cpp_type(data_type);
|
||||
BLI_assert(type != nullptr);
|
||||
if (attribute.varray.type() == *type) {
|
||||
return attribute;
|
||||
|
@ -1184,7 +1184,7 @@ blender::fn::GVArray GeometryComponent::attribute_get_for_read(const AttributeID
|
|||
if (varray) {
|
||||
return varray;
|
||||
}
|
||||
const blender::fn::CPPType *type = blender::bke::custom_data_type_to_cpp_type(data_type);
|
||||
const blender::CPPType *type = blender::bke::custom_data_type_to_cpp_type(data_type);
|
||||
if (default_value == nullptr) {
|
||||
default_value = type->default_value();
|
||||
}
|
||||
|
|
|
@ -20,7 +20,7 @@
|
|||
|
||||
#include "attribute_access_intern.hh"
|
||||
|
||||
#include "FN_cpp_type_make.hh"
|
||||
#include "BLI_cpp_type_make.hh"
|
||||
|
||||
using blender::float4x4;
|
||||
using blender::IndexMask;
|
||||
|
@ -31,7 +31,7 @@ using blender::Span;
|
|||
using blender::VectorSet;
|
||||
using blender::fn::GSpan;
|
||||
|
||||
MAKE_CPP_TYPE(InstanceReference, InstanceReference, CPPTypeFlags::None)
|
||||
BLI_CPP_TYPE_MAKE(InstanceReference, InstanceReference, CPPTypeFlags::None)
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Geometry Component Implementation
|
||||
|
|
|
@ -3,28 +3,46 @@
|
|||
#pragma once
|
||||
|
||||
/** \file
|
||||
* \ingroup fn
|
||||
* \ingroup bli
|
||||
*
|
||||
* The `CPPType` class is the core of a runtime-type-system. It allows working with arbitrary C++
|
||||
* types in a generic way. An instance of `CPPType` wraps exactly one type like `int` or
|
||||
* `std::string`.
|
||||
* The `CPPType` class allows working with arbitrary C++ types in a generic way. An instance of
|
||||
* #CPPType wraps exactly one type like `int` or `std::string`.
|
||||
*
|
||||
* With #CPPType one can write generic data structures and algorithms. That is similar to what C++
|
||||
* templates allow. The difference is that when using templates, the types have to be known at
|
||||
* compile time and the code has to be instantiated multiple times. On the other hand, when using
|
||||
* #CPPType, the data type only has to be known at run-time, and the code only has to be compiled
|
||||
* once. Whether #CPPType or classic c++ templates should be used depends on the context:
|
||||
* - If the data type is not known at run-time, #CPPType should be used.
|
||||
* - If the data type is known to be one of a few, it depends on how performance sensitive the code
|
||||
* is.
|
||||
* - If it it's a small hot loop, a template can be used to optimize for every type (at the
|
||||
* cost of longer compile time, a larger binary and the complexity that comes from using
|
||||
* templates).
|
||||
* - If the code is not performance sensitive, it usually makes sense to use #CPPType instead.
|
||||
* - Sometimes a combination can make sense. Optimized code can be be generated at compile-time for
|
||||
* some types, while there is a fallback code path using #CPPType for all other types.
|
||||
*
|
||||
* Under some circumstances, #CPPType serves a similar role as #std::type_info. However, #CPPType
|
||||
* has much more utility because it contains methods for actually working with instances of the
|
||||
* type.
|
||||
*
|
||||
* Every type has a size and an alignment. Every function dealing with C++ types in a generic way,
|
||||
* has to make sure that alignment rules are followed. The methods provided by a CPPType instance
|
||||
* has to make sure that alignment rules are followed. The methods provided by a #CPPType instance
|
||||
* will check for correct alignment as well.
|
||||
*
|
||||
* Every type has a name that is for debugging purposes only. It should not be used as identifier.
|
||||
*
|
||||
* To check if two instances of CPPType represent the same type, only their pointers have to be
|
||||
* compared. Any C++ type has at most one corresponding CPPType instance.
|
||||
* To check if two instances of #CPPType represent the same type, only their pointers have to be
|
||||
* compared. Any C++ type has at most one corresponding #CPPType instance.
|
||||
*
|
||||
* A CPPType instance comes with many methods that allow dealing with types in a generic way. Most
|
||||
* methods come in three variants. Using the construct-default methods as example:
|
||||
* - default_construct(void *ptr):
|
||||
* A #CPPType instance comes with many methods that allow dealing with types in a generic way. Most
|
||||
* methods come in three variants. Using the default-construct methods as an example:
|
||||
* - `default_construct(void *ptr)`:
|
||||
* Constructs a single instance of that type at the given pointer.
|
||||
* - default_construct_n(void *ptr, int64_t n):
|
||||
* - `default_construct_n(void *ptr, int64_t n)`:
|
||||
* Constructs n instances of that type in an array that starts at the given pointer.
|
||||
* - default_construct_indices(void *ptr, IndexMask mask):
|
||||
* - `default_construct_indices(void *ptr, IndexMask mask)`:
|
||||
* Constructs multiple instances of that type in an array that starts at the given pointer.
|
||||
* Only the indices referenced by `mask` will by constructed.
|
||||
*
|
||||
|
@ -39,8 +57,9 @@
|
|||
* Concepts like inheritance are currently not captured by this system. This is not because it is
|
||||
* not possible, but because it was not necessary to add this complexity yet.
|
||||
*
|
||||
* One could also implement CPPType itself using virtual inheritance. However, I found the approach
|
||||
* used now with explicit function pointers to work better. Here are some reasons:
|
||||
* One could also implement CPPType itself using virtual methods and a child class for every
|
||||
* wrapped type. However, the approach used now with explicit function pointers to works better.
|
||||
* Here are some reasons:
|
||||
* - If CPPType would be inherited once for every used C++ type, we would get a lot of classes
|
||||
* that would only be instanced once each.
|
||||
* - Methods like `default_construct` that operate on a single instance have to be fast. Even this
|
||||
|
@ -71,7 +90,7 @@ enum class CPPTypeFlags {
|
|||
};
|
||||
ENUM_OPERATORS(CPPTypeFlags, CPPTypeFlags::EqualityComparable)
|
||||
|
||||
namespace blender::fn {
|
||||
namespace blender {
|
||||
|
||||
/** Utility class to pass template parameters to constructor of `CPPType`. */
|
||||
template<typename T, CPPTypeFlags Flags> struct CPPTypeParam {
|
||||
|
@ -142,7 +161,7 @@ class CPPType : NonCopyable, NonMovable {
|
|||
/**
|
||||
* Get the `CPPType` that corresponds to a specific static type.
|
||||
* This only works for types that actually implement the template specialization using
|
||||
* `MAKE_CPP_TYPE`.
|
||||
* `BLI_CPP_TYPE_MAKE`.
|
||||
*/
|
||||
template<typename T> static const CPPType &get()
|
||||
{
|
||||
|
@ -626,7 +645,7 @@ class CPPType : NonCopyable, NonMovable {
|
|||
}
|
||||
};
|
||||
|
||||
} // namespace blender::fn
|
||||
} // namespace blender
|
||||
|
||||
/* Utility for allocating an uninitialized buffer for a single value of the given #CPPType. */
|
||||
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name) \
|
|
@ -3,13 +3,13 @@
|
|||
#pragma once
|
||||
|
||||
/** \file
|
||||
* \ingroup fn
|
||||
* \ingroup bli
|
||||
*/
|
||||
|
||||
#include "BLI_cpp_type.hh"
|
||||
#include "BLI_utildefines.h"
|
||||
#include "FN_cpp_type.hh"
|
||||
|
||||
namespace blender::fn::cpp_type_util {
|
||||
namespace blender::cpp_type_util {
|
||||
|
||||
template<typename T> void default_construct_cb(void *ptr)
|
||||
{
|
||||
|
@ -169,9 +169,9 @@ template<typename T> uint64_t hash_cb(const void *value)
|
|||
return get_default_hash(value_);
|
||||
}
|
||||
|
||||
} // namespace blender::fn::cpp_type_util
|
||||
} // namespace blender::cpp_type_util
|
||||
|
||||
namespace blender::fn {
|
||||
namespace blender {
|
||||
|
||||
template<typename T, CPPTypeFlags Flags>
|
||||
CPPType::CPPType(CPPTypeParam<T, Flags> /* unused */, StringRef debug_name)
|
||||
|
@ -240,12 +240,11 @@ CPPType::CPPType(CPPTypeParam<T, Flags> /* unused */, StringRef debug_name)
|
|||
move_construct_ && move_assign_ && destruct_);
|
||||
}
|
||||
|
||||
} // namespace blender::fn
|
||||
} // namespace blender
|
||||
|
||||
#define MAKE_CPP_TYPE(IDENTIFIER, TYPE_NAME, FLAGS) \
|
||||
template<> const blender::fn::CPPType &blender::fn::CPPType::get_impl<TYPE_NAME>() \
|
||||
#define BLI_CPP_TYPE_MAKE(IDENTIFIER, TYPE_NAME, FLAGS) \
|
||||
template<> const blender::CPPType &blender::CPPType::get_impl<TYPE_NAME>() \
|
||||
{ \
|
||||
static CPPType cpp_type{blender::fn::CPPTypeParam<TYPE_NAME, FLAGS>(), \
|
||||
STRINGIFY(IDENTIFIER)}; \
|
||||
static CPPType cpp_type{blender::CPPTypeParam<TYPE_NAME, FLAGS>(), STRINGIFY(IDENTIFIER)}; \
|
||||
return cpp_type; \
|
||||
}
|
|
@ -50,6 +50,7 @@ set(SRC
|
|||
intern/boxpack_2d.c
|
||||
intern/buffer.c
|
||||
intern/convexhull_2d.c
|
||||
intern/cpp_type.cc
|
||||
intern/delaunay_2d.cc
|
||||
intern/dot_export.cc
|
||||
intern/dynlib.c
|
||||
|
@ -170,6 +171,8 @@ set(SRC
|
|||
BLI_compiler_typecheck.h
|
||||
BLI_console.h
|
||||
BLI_convexhull_2d.h
|
||||
BLI_cpp_type_make.hh
|
||||
BLI_cpp_type.hh
|
||||
BLI_delaunay_2d.h
|
||||
BLI_dial_2d.h
|
||||
BLI_disjoint_set.hh
|
||||
|
@ -403,6 +406,7 @@ if(WITH_GTESTS)
|
|||
tests/BLI_array_utils_test.cc
|
||||
tests/BLI_bounds_test.cc
|
||||
tests/BLI_color_test.cc
|
||||
tests/BLI_cpp_type_test.cc
|
||||
tests/BLI_delaunay_2d_test.cc
|
||||
tests/BLI_disjoint_set_test.cc
|
||||
tests/BLI_edgehash_test.cc
|
||||
|
|
|
@ -0,0 +1,23 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
||||
|
||||
#include "BLI_color.hh"
|
||||
#include "BLI_cpp_type_make.hh"
|
||||
#include "BLI_float4x4.hh"
|
||||
#include "BLI_math_vec_types.hh"
|
||||
|
||||
BLI_CPP_TYPE_MAKE(bool, bool, CPPTypeFlags::BasicType)
|
||||
|
||||
BLI_CPP_TYPE_MAKE(float, float, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(float2, blender::float2, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(float3, blender::float3, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(float4x4, blender::float4x4, CPPTypeFlags::BasicType)
|
||||
|
||||
BLI_CPP_TYPE_MAKE(int32, int32_t, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(int8, int8_t, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(uint32, uint32_t, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(uint8, uint8_t, CPPTypeFlags::BasicType)
|
||||
|
||||
BLI_CPP_TYPE_MAKE(ColorGeometry4f, blender::ColorGeometry4f, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(ColorGeometry4b, blender::ColorGeometry4b, CPPTypeFlags::BasicType)
|
||||
|
||||
BLI_CPP_TYPE_MAKE(string, std::string, CPPTypeFlags::BasicType)
|
|
@ -2,10 +2,10 @@
|
|||
|
||||
#include "testing/testing.h"
|
||||
|
||||
#include "FN_cpp_type.hh"
|
||||
#include "FN_cpp_type_make.hh"
|
||||
#include "BLI_cpp_type.hh"
|
||||
#include "BLI_cpp_type_make.hh"
|
||||
|
||||
namespace blender::fn::tests {
|
||||
namespace blender::tests {
|
||||
|
||||
static const int default_constructed_value = 1;
|
||||
static const int copy_constructed_value = 2;
|
||||
|
@ -74,11 +74,11 @@ struct TestType {
|
|||
}
|
||||
};
|
||||
|
||||
} // namespace blender::fn::tests
|
||||
} // namespace blender::tests
|
||||
|
||||
MAKE_CPP_TYPE(TestType, blender::fn::tests::TestType, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(TestType, blender::tests::TestType, CPPTypeFlags::BasicType)
|
||||
|
||||
namespace blender::fn::tests {
|
||||
namespace blender::tests {
|
||||
|
||||
static const CPPType &CPPType_TestType = CPPType::get<TestType>();
|
||||
|
||||
|
@ -323,4 +323,4 @@ TEST(cpp_type, DebugPrint)
|
|||
EXPECT_EQ(text, "42");
|
||||
}
|
||||
|
||||
} // namespace blender::fn::tests
|
||||
} // namespace blender::tests
|
|
@ -36,7 +36,6 @@
|
|||
|
||||
namespace blender::ed::geometry {
|
||||
|
||||
using fn::CPPType;
|
||||
using fn::GArray;
|
||||
using fn::GVArray;
|
||||
|
||||
|
|
|
@ -69,7 +69,6 @@ bool CURVES_SCULPT_mode_poll_view3d(bContext *C)
|
|||
namespace blender::ed::sculpt_paint {
|
||||
|
||||
using blender::bke::CurvesGeometry;
|
||||
using blender::fn::CPPType;
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name * SCULPT_CURVES_OT_brush_stroke
|
||||
|
|
|
@ -73,7 +73,6 @@
|
|||
|
||||
#include "node_intern.hh" /* own include */
|
||||
|
||||
using blender::fn::CPPType;
|
||||
using blender::fn::FieldCPPType;
|
||||
using blender::fn::FieldInput;
|
||||
using blender::fn::GField;
|
||||
|
|
|
@ -5,6 +5,7 @@
|
|||
#include "MEM_guardedalloc.h"
|
||||
|
||||
#include "BLI_color.hh"
|
||||
#include "BLI_cpp_type.hh"
|
||||
#include "BLI_hash.hh"
|
||||
#include "BLI_math_vec_types.hh"
|
||||
#include "BLI_string.h"
|
||||
|
@ -12,14 +13,12 @@
|
|||
|
||||
#include "BKE_geometry_set.hh"
|
||||
|
||||
#include "FN_cpp_type.hh"
|
||||
|
||||
#include "spreadsheet_column.hh"
|
||||
#include "spreadsheet_column_values.hh"
|
||||
|
||||
namespace blender::ed::spreadsheet {
|
||||
|
||||
eSpreadsheetColumnValueType cpp_type_to_column_type(const fn::CPPType &type)
|
||||
eSpreadsheetColumnValueType cpp_type_to_column_type(const CPPType &type)
|
||||
{
|
||||
if (type.is<bool>()) {
|
||||
return SPREADSHEET_VALUE_TYPE_BOOL;
|
||||
|
|
|
@ -12,7 +12,7 @@ namespace blender::ed::spreadsheet {
|
|||
|
||||
struct CellDrawParams;
|
||||
|
||||
eSpreadsheetColumnValueType cpp_type_to_column_type(const fn::CPPType &type);
|
||||
eSpreadsheetColumnValueType cpp_type_to_column_type(const CPPType &type);
|
||||
|
||||
/**
|
||||
* This represents a column in a spreadsheet. It has a name and provides a value for all the cells
|
||||
|
|
|
@ -24,8 +24,6 @@ set(SRC
|
|||
intern/multi_function_procedure_executor.cc
|
||||
intern/multi_function_procedure_optimization.cc
|
||||
|
||||
FN_cpp_type.hh
|
||||
FN_cpp_type_make.hh
|
||||
FN_field.hh
|
||||
FN_field_cpp_type.hh
|
||||
FN_generic_array.hh
|
||||
|
@ -72,7 +70,6 @@ blender_add_lib(bf_functions "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
|
|||
|
||||
if(WITH_GTESTS)
|
||||
set(TEST_SRC
|
||||
tests/FN_cpp_type_test.cc
|
||||
tests/FN_field_test.cc
|
||||
tests/FN_generic_array_test.cc
|
||||
tests/FN_generic_span_test.cc
|
||||
|
|
|
@ -119,7 +119,7 @@ template<typename NodePtr> class GFieldBase {
|
|||
return get_default_hash_2(*node_, node_output_index_);
|
||||
}
|
||||
|
||||
const fn::CPPType &cpp_type() const
|
||||
const CPPType &cpp_type() const
|
||||
{
|
||||
return node_->output_cpp_type(node_output_index_);
|
||||
}
|
||||
|
@ -476,13 +476,13 @@ template<typename T> T evaluate_constant_field(const Field<T> &field)
|
|||
return value;
|
||||
}
|
||||
|
||||
GField make_constant_field(const CPPType &type, const void *value);
|
||||
|
||||
template<typename T> Field<T> make_constant_field(T value)
|
||||
{
|
||||
return make_constant_field(CPPType::get<T>(), &value);
|
||||
}
|
||||
|
||||
GField make_constant_field(const CPPType &type, const void *value);
|
||||
|
||||
/**
|
||||
* If the field depends on some input, the same field is returned.
|
||||
* Otherwise the field is evaluated and a new field is created that just computes this constant.
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
* \ingroup fn
|
||||
*/
|
||||
|
||||
#include "FN_cpp_type_make.hh"
|
||||
#include "BLI_cpp_type_make.hh"
|
||||
#include "FN_field.hh"
|
||||
|
||||
namespace blender::fn {
|
||||
|
@ -127,16 +127,14 @@ class ValueOrFieldCPPType : public CPPType {
|
|||
} // namespace blender::fn
|
||||
|
||||
#define MAKE_FIELD_CPP_TYPE(DEBUG_NAME, FIELD_TYPE) \
|
||||
template<> \
|
||||
const blender::fn::CPPType &blender::fn::CPPType::get_impl<blender::fn::Field<FIELD_TYPE>>() \
|
||||
template<> const blender::CPPType &blender::CPPType::get_impl<blender::fn::Field<FIELD_TYPE>>() \
|
||||
{ \
|
||||
static blender::fn::FieldCPPType cpp_type{ \
|
||||
blender::fn::FieldCPPTypeParam<blender::fn::Field<FIELD_TYPE>>(), STRINGIFY(DEBUG_NAME)}; \
|
||||
return cpp_type; \
|
||||
} \
|
||||
template<> \
|
||||
const blender::fn::CPPType & \
|
||||
blender::fn::CPPType::get_impl<blender::fn::ValueOrField<FIELD_TYPE>>() \
|
||||
const blender::CPPType &blender::CPPType::get_impl<blender::fn::ValueOrField<FIELD_TYPE>>() \
|
||||
{ \
|
||||
static blender::fn::ValueOrFieldCPPType cpp_type{ \
|
||||
blender::fn::FieldCPPTypeParam<blender::fn::ValueOrField<FIELD_TYPE>>(), \
|
||||
|
|
|
@ -14,8 +14,8 @@
|
|||
*/
|
||||
|
||||
#include "BLI_allocator.hh"
|
||||
#include "BLI_cpp_type.hh"
|
||||
|
||||
#include "FN_cpp_type.hh"
|
||||
#include "FN_generic_span.hh"
|
||||
|
||||
namespace blender::fn {
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include "FN_cpp_type.hh"
|
||||
#include "BLI_cpp_type.hh"
|
||||
|
||||
namespace blender::fn {
|
||||
|
||||
|
|
|
@ -6,10 +6,9 @@
|
|||
* \ingroup fn
|
||||
*/
|
||||
|
||||
#include "BLI_cpp_type.hh"
|
||||
#include "BLI_span.hh"
|
||||
|
||||
#include "FN_cpp_type.hh"
|
||||
|
||||
namespace blender::fn {
|
||||
|
||||
/**
|
||||
|
|
|
@ -154,7 +154,6 @@ inline MFParamsBuilder::MFParamsBuilder(const MultiFunction &fn, const IndexMask
|
|||
}
|
||||
|
||||
namespace multi_function_types {
|
||||
using fn::CPPType;
|
||||
using fn::GMutableSpan;
|
||||
using fn::GSpan;
|
||||
using fn::MFContext;
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
* is possible when necessary.
|
||||
*/
|
||||
|
||||
#include "FN_cpp_type.hh"
|
||||
#include "BLI_cpp_type.hh"
|
||||
|
||||
namespace blender::fn {
|
||||
|
||||
|
|
|
@ -1,38 +1,17 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
||||
|
||||
#include "FN_cpp_type_make.hh"
|
||||
#include "FN_field_cpp_type.hh"
|
||||
|
||||
#include "BLI_color.hh"
|
||||
#include "BLI_cpp_type_make.hh"
|
||||
#include "BLI_float4x4.hh"
|
||||
#include "BLI_math_vec_types.hh"
|
||||
|
||||
namespace blender::fn {
|
||||
|
||||
MAKE_CPP_TYPE(bool, bool, CPPTypeFlags::BasicType)
|
||||
|
||||
MAKE_CPP_TYPE(float, float, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(float2, blender::float2, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(float3, blender::float3, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(float4x4, blender::float4x4, CPPTypeFlags::BasicType)
|
||||
|
||||
MAKE_CPP_TYPE(int32, int32_t, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(int8, int8_t, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(uint32, uint32_t, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(uint8, uint8_t, CPPTypeFlags::BasicType)
|
||||
|
||||
MAKE_CPP_TYPE(ColorGeometry4f, blender::ColorGeometry4f, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(ColorGeometry4b, blender::ColorGeometry4b, CPPTypeFlags::BasicType)
|
||||
|
||||
MAKE_CPP_TYPE(string, std::string, CPPTypeFlags::BasicType)
|
||||
#include "FN_field_cpp_type.hh"
|
||||
|
||||
MAKE_FIELD_CPP_TYPE(FloatField, float);
|
||||
MAKE_FIELD_CPP_TYPE(Float2Field, float2);
|
||||
MAKE_FIELD_CPP_TYPE(Float3Field, float3);
|
||||
MAKE_FIELD_CPP_TYPE(Float2Field, blender::float2);
|
||||
MAKE_FIELD_CPP_TYPE(Float3Field, blender::float3);
|
||||
MAKE_FIELD_CPP_TYPE(ColorGeometry4fField, blender::ColorGeometry4f);
|
||||
MAKE_FIELD_CPP_TYPE(BoolField, bool);
|
||||
MAKE_FIELD_CPP_TYPE(Int8Field, int8_t);
|
||||
MAKE_FIELD_CPP_TYPE(Int32Field, int32_t);
|
||||
MAKE_FIELD_CPP_TYPE(StringField, std::string);
|
||||
|
||||
} // namespace blender::fn
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
#include "testing/testing.h"
|
||||
|
||||
#include "FN_cpp_type.hh"
|
||||
#include "BLI_cpp_type.hh"
|
||||
#include "FN_field.hh"
|
||||
#include "FN_multi_function_builder.hh"
|
||||
#include "FN_multi_function_test_common.hh"
|
||||
|
|
|
@ -29,7 +29,6 @@ using blender::bke::object_get_evaluated_geometry_set;
|
|||
using blender::bke::OutputAttribute;
|
||||
using blender::bke::OutputAttribute_Typed;
|
||||
using blender::bke::ReadAttributeLookup;
|
||||
using blender::fn::CPPType;
|
||||
using blender::fn::GArray;
|
||||
using blender::fn::GMutableSpan;
|
||||
using blender::fn::GSpan;
|
||||
|
|
|
@ -89,6 +89,7 @@
|
|||
|
||||
using blender::Array;
|
||||
using blender::ColorGeometry4f;
|
||||
using blender::CPPType;
|
||||
using blender::destruct_ptr;
|
||||
using blender::float3;
|
||||
using blender::FunctionRef;
|
||||
|
|
|
@ -26,7 +26,6 @@
|
|||
|
||||
namespace blender::modifiers::geometry_nodes {
|
||||
|
||||
using fn::CPPType;
|
||||
using fn::Field;
|
||||
using fn::GField;
|
||||
using fn::GValueMap;
|
||||
|
|
|
@ -32,7 +32,6 @@ using bke::ReadAttributeLookup;
|
|||
using bke::StrongAnonymousAttributeID;
|
||||
using bke::WeakAnonymousAttributeID;
|
||||
using bke::WriteAttributeLookup;
|
||||
using fn::CPPType;
|
||||
using fn::Field;
|
||||
using fn::FieldContext;
|
||||
using fn::FieldEvaluator;
|
||||
|
|
|
@ -67,7 +67,7 @@ class GenericValueLog : public ValueLog {
|
|||
class GFieldValueLog : public ValueLog {
|
||||
private:
|
||||
fn::GField field_;
|
||||
const fn::CPPType &type_;
|
||||
const CPPType &type_;
|
||||
Vector<std::string> input_tooltips_;
|
||||
|
||||
public:
|
||||
|
@ -83,7 +83,7 @@ class GFieldValueLog : public ValueLog {
|
|||
return input_tooltips_;
|
||||
}
|
||||
|
||||
const fn::CPPType &type() const
|
||||
const CPPType &type() const
|
||||
{
|
||||
return type_;
|
||||
}
|
||||
|
|
|
@ -1,10 +1,6 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
||||
|
||||
#include "FN_cpp_type_make.hh"
|
||||
#include "BLI_cpp_type_make.hh"
|
||||
#include "NOD_geometry_exec.hh"
|
||||
|
||||
MAKE_CPP_TYPE(GeometrySet, GeometrySet, CPPTypeFlags::Printable);
|
||||
|
||||
namespace blender::nodes {
|
||||
|
||||
}
|
||||
BLI_CPP_TYPE_MAKE(GeometrySet, GeometrySet, CPPTypeFlags::Printable);
|
||||
|
|
|
@ -15,7 +15,6 @@
|
|||
|
||||
namespace blender::nodes::geometry_nodes_eval_log {
|
||||
|
||||
using fn::CPPType;
|
||||
using fn::FieldCPPType;
|
||||
using fn::FieldInput;
|
||||
using fn::GField;
|
||||
|
|
|
@ -10,6 +10,7 @@
|
|||
#include "DNA_node_types.h"
|
||||
|
||||
#include "BLI_color.hh"
|
||||
#include "BLI_cpp_type_make.hh"
|
||||
#include "BLI_listbase.h"
|
||||
#include "BLI_math_vec_types.hh"
|
||||
#include "BLI_string.h"
|
||||
|
@ -30,7 +31,6 @@
|
|||
#include "NOD_node_declaration.hh"
|
||||
#include "NOD_socket.h"
|
||||
|
||||
#include "FN_cpp_type_make.hh"
|
||||
#include "FN_field.hh"
|
||||
|
||||
using namespace blender;
|
||||
|
@ -683,11 +683,11 @@ static bNodeSocketType *make_socket_type_virtual()
|
|||
static bNodeSocketType *make_socket_type_bool()
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_BOOLEAN, PROP_NONE);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<bool>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<bool>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
*(bool *)r_value = ((bNodeSocketValueBoolean *)socket.default_value)->value;
|
||||
};
|
||||
socktype->geometry_nodes_cpp_type = &blender::fn::CPPType::get<ValueOrField<bool>>();
|
||||
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<ValueOrField<bool>>();
|
||||
socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
bool value;
|
||||
socket.typeinfo->get_base_cpp_value(socket, &value);
|
||||
|
@ -699,11 +699,11 @@ static bNodeSocketType *make_socket_type_bool()
|
|||
static bNodeSocketType *make_socket_type_float(PropertySubType subtype)
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_FLOAT, subtype);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<float>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<float>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
*(float *)r_value = ((bNodeSocketValueFloat *)socket.default_value)->value;
|
||||
};
|
||||
socktype->geometry_nodes_cpp_type = &blender::fn::CPPType::get<ValueOrField<float>>();
|
||||
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<ValueOrField<float>>();
|
||||
socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
float value;
|
||||
socket.typeinfo->get_base_cpp_value(socket, &value);
|
||||
|
@ -715,11 +715,11 @@ static bNodeSocketType *make_socket_type_float(PropertySubType subtype)
|
|||
static bNodeSocketType *make_socket_type_int(PropertySubType subtype)
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_INT, subtype);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<int>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<int>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
*(int *)r_value = ((bNodeSocketValueInt *)socket.default_value)->value;
|
||||
};
|
||||
socktype->geometry_nodes_cpp_type = &blender::fn::CPPType::get<ValueOrField<int>>();
|
||||
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<ValueOrField<int>>();
|
||||
socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
int value;
|
||||
socket.typeinfo->get_base_cpp_value(socket, &value);
|
||||
|
@ -731,11 +731,11 @@ static bNodeSocketType *make_socket_type_int(PropertySubType subtype)
|
|||
static bNodeSocketType *make_socket_type_vector(PropertySubType subtype)
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_VECTOR, subtype);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<blender::float3>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<blender::float3>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
*(blender::float3 *)r_value = ((bNodeSocketValueVector *)socket.default_value)->value;
|
||||
};
|
||||
socktype->geometry_nodes_cpp_type = &blender::fn::CPPType::get<ValueOrField<blender::float3>>();
|
||||
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<ValueOrField<blender::float3>>();
|
||||
socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
blender::float3 value;
|
||||
socket.typeinfo->get_base_cpp_value(socket, &value);
|
||||
|
@ -747,12 +747,12 @@ static bNodeSocketType *make_socket_type_vector(PropertySubType subtype)
|
|||
static bNodeSocketType *make_socket_type_rgba()
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_RGBA, PROP_NONE);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<blender::ColorGeometry4f>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<blender::ColorGeometry4f>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
*(blender::ColorGeometry4f *)r_value = ((bNodeSocketValueRGBA *)socket.default_value)->value;
|
||||
};
|
||||
socktype->geometry_nodes_cpp_type =
|
||||
&blender::fn::CPPType::get<ValueOrField<blender::ColorGeometry4f>>();
|
||||
&blender::CPPType::get<ValueOrField<blender::ColorGeometry4f>>();
|
||||
socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
blender::ColorGeometry4f value;
|
||||
socket.typeinfo->get_base_cpp_value(socket, &value);
|
||||
|
@ -764,11 +764,11 @@ static bNodeSocketType *make_socket_type_rgba()
|
|||
static bNodeSocketType *make_socket_type_string()
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_STRING, PROP_NONE);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<std::string>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<std::string>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
new (r_value) std::string(((bNodeSocketValueString *)socket.default_value)->value);
|
||||
};
|
||||
socktype->geometry_nodes_cpp_type = &blender::fn::CPPType::get<ValueOrField<std::string>>();
|
||||
socktype->geometry_nodes_cpp_type = &blender::CPPType::get<ValueOrField<std::string>>();
|
||||
socktype->get_geometry_nodes_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
std::string value;
|
||||
value.~basic_string();
|
||||
|
@ -778,16 +778,16 @@ static bNodeSocketType *make_socket_type_string()
|
|||
return socktype;
|
||||
}
|
||||
|
||||
MAKE_CPP_TYPE(Object, Object *, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(Collection, Collection *, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(Texture, Tex *, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(Image, Image *, CPPTypeFlags::BasicType)
|
||||
MAKE_CPP_TYPE(Material, Material *, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(Object, Object *, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(Collection, Collection *, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(Texture, Tex *, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(Image, Image *, CPPTypeFlags::BasicType)
|
||||
BLI_CPP_TYPE_MAKE(Material, Material *, CPPTypeFlags::BasicType)
|
||||
|
||||
static bNodeSocketType *make_socket_type_object()
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_OBJECT, PROP_NONE);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<Object *>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<Object *>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
*(Object **)r_value = ((bNodeSocketValueObject *)socket.default_value)->value;
|
||||
};
|
||||
|
@ -799,7 +799,7 @@ static bNodeSocketType *make_socket_type_object()
|
|||
static bNodeSocketType *make_socket_type_geometry()
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_GEOMETRY, PROP_NONE);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<GeometrySet>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<GeometrySet>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &UNUSED(socket), void *r_value) {
|
||||
new (r_value) GeometrySet();
|
||||
};
|
||||
|
@ -811,7 +811,7 @@ static bNodeSocketType *make_socket_type_geometry()
|
|||
static bNodeSocketType *make_socket_type_collection()
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_COLLECTION, PROP_NONE);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<Collection *>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<Collection *>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
*(Collection **)r_value = ((bNodeSocketValueCollection *)socket.default_value)->value;
|
||||
};
|
||||
|
@ -823,7 +823,7 @@ static bNodeSocketType *make_socket_type_collection()
|
|||
static bNodeSocketType *make_socket_type_texture()
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_TEXTURE, PROP_NONE);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<Tex *>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<Tex *>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
*(Tex **)r_value = ((bNodeSocketValueTexture *)socket.default_value)->value;
|
||||
};
|
||||
|
@ -835,7 +835,7 @@ static bNodeSocketType *make_socket_type_texture()
|
|||
static bNodeSocketType *make_socket_type_image()
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_IMAGE, PROP_NONE);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<Image *>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<Image *>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
*(Image **)r_value = ((bNodeSocketValueImage *)socket.default_value)->value;
|
||||
};
|
||||
|
@ -847,7 +847,7 @@ static bNodeSocketType *make_socket_type_image()
|
|||
static bNodeSocketType *make_socket_type_material()
|
||||
{
|
||||
bNodeSocketType *socktype = make_standard_socket_type(SOCK_MATERIAL, PROP_NONE);
|
||||
socktype->base_cpp_type = &blender::fn::CPPType::get<Material *>();
|
||||
socktype->base_cpp_type = &blender::CPPType::get<Material *>();
|
||||
socktype->get_base_cpp_value = [](const bNodeSocket &socket, void *r_value) {
|
||||
*(Material **)r_value = ((bNodeSocketValueMaterial *)socket.default_value)->value;
|
||||
};
|
||||
|
|
Loading…
Reference in New Issue