[Bf-blender-cvs] [f3a63be474d] temp-geometry-nodes-evaluator-refactor: improve naming
Jacques Lucke
noreply at git.blender.org
Mon Jul 18 23:12:58 CEST 2022
Commit: f3a63be474d16adae870d816774fbf4fc65fca00
Author: Jacques Lucke
Date: Mon Jul 18 22:57:09 2022 +0200
Branches: temp-geometry-nodes-evaluator-refactor
https://developer.blender.org/rBf3a63be474d16adae870d816774fbf4fc65fca00
improve naming
===================================================================
M source/blender/functions/FN_lazy_function.hh
M source/blender/functions/FN_lazy_function_execute.hh
M source/blender/functions/FN_lazy_function_graph.hh
M source/blender/functions/FN_lazy_function_graph_executor.hh
M source/blender/functions/intern/lazy_function.cc
M source/blender/functions/intern/lazy_function_execute.cc
M source/blender/functions/intern/lazy_function_graph.cc
M source/blender/functions/intern/lazy_function_graph_executor.cc
M source/blender/functions/tests/FN_lazy_function_test.cc
M source/blender/modifiers/intern/MOD_nodes.cc
M source/blender/nodes/NOD_geometry_exec.hh
M source/blender/nodes/NOD_geometry_nodes_to_lazy_function_graph.hh
M source/blender/nodes/intern/geometry_nodes_to_lazy_function_graph.cc
===================================================================
diff --git a/source/blender/functions/FN_lazy_function.hh b/source/blender/functions/FN_lazy_function.hh
index d8463510483..7fde531f4b7 100644
--- a/source/blender/functions/FN_lazy_function.hh
+++ b/source/blender/functions/FN_lazy_function.hh
@@ -11,7 +11,7 @@
#include "BLI_linear_allocator.hh"
#include "BLI_vector.hh"
-namespace blender::fn {
+namespace blender::fn::lazy_function {
enum class ValueUsage {
Used,
@@ -21,22 +21,22 @@ enum class ValueUsage {
class LazyFunction;
-class LFUserData {
+class UserData {
public:
- virtual ~LFUserData() = default;
+ virtual ~UserData() = default;
};
-struct LFContext {
+struct Context {
void *storage;
- LFUserData *user_data;
+ UserData *user_data;
};
-class LFParams {
+class Params {
protected:
const LazyFunction &fn_;
public:
- LFParams(const LazyFunction &fn);
+ Params(const LazyFunction &fn);
/**
* Get a pointer to an input value if the value is available already.
@@ -93,22 +93,22 @@ class LFParams {
virtual void set_input_unused_impl(int index) = 0;
};
-struct LFInput {
+struct Input {
const char *static_name;
const CPPType *type;
ValueUsage usage;
- LFInput(const char *static_name, const CPPType &type, const ValueUsage usage = ValueUsage::Used)
+ Input(const char *static_name, const CPPType &type, const ValueUsage usage = ValueUsage::Used)
: static_name(static_name), type(&type), usage(usage)
{
}
};
-struct LFOutput {
+struct Output {
const char *static_name;
const CPPType *type = nullptr;
- LFOutput(const char *static_name, const CPPType &type) : static_name(static_name), type(&type)
+ Output(const char *static_name, const CPPType &type) : static_name(static_name), type(&type)
{
}
};
@@ -116,8 +116,8 @@ struct LFOutput {
class LazyFunction {
protected:
const char *static_name_ = "Unnamed Function";
- Vector<LFInput> inputs_;
- Vector<LFOutput> outputs_;
+ Vector<Input> inputs_;
+ Vector<Output> outputs_;
public:
virtual ~LazyFunction() = default;
@@ -129,32 +129,32 @@ class LazyFunction {
virtual void *init_storage(LinearAllocator<> &allocator) const;
virtual void destruct_storage(void *storage) const;
- Span<LFInput> inputs() const;
- Span<LFOutput> outputs() const;
+ Span<Input> inputs() const;
+ Span<Output> outputs() const;
- void execute(LFParams ¶ms, const LFContext &context) const;
+ void execute(Params ¶ms, const Context &context) const;
- bool valid_params_for_execution(const LFParams ¶ms) const;
+ bool valid_params_for_execution(const Params ¶ms) const;
private:
- virtual void execute_impl(LFParams ¶ms, const LFContext &context) const = 0;
+ virtual void execute_impl(Params ¶ms, const Context &context) const = 0;
};
/* -------------------------------------------------------------------- */
/** \name #LazyFunction Inline Methods
* \{ */
-inline Span<LFInput> LazyFunction::inputs() const
+inline Span<Input> LazyFunction::inputs() const
{
return inputs_;
}
-inline Span<LFOutput> LazyFunction::outputs() const
+inline Span<Output> LazyFunction::outputs() const
{
return outputs_;
}
-inline void LazyFunction::execute(LFParams ¶ms, const LFContext &context) const
+inline void LazyFunction::execute(Params ¶ms, const Context &context) const
{
BLI_assert(this->valid_params_for_execution(params));
this->execute_impl(params, context);
@@ -163,49 +163,49 @@ inline void LazyFunction::execute(LFParams ¶ms, const LFContext &context) co
/** \} */
/* -------------------------------------------------------------------- */
-/** \name #LFParams Inline Methods
+/** \name #Params Inline Methods
* \{ */
-inline LFParams::LFParams(const LazyFunction &fn) : fn_(fn)
+inline Params::Params(const LazyFunction &fn) : fn_(fn)
{
}
-inline void *LFParams::try_get_input_data_ptr(int index) const
+inline void *Params::try_get_input_data_ptr(int index) const
{
return this->try_get_input_data_ptr_impl(index);
}
-inline void *LFParams::try_get_input_data_ptr_or_request(int index)
+inline void *Params::try_get_input_data_ptr_or_request(int index)
{
return this->try_get_input_data_ptr_or_request_impl(index);
}
-inline void *LFParams::get_output_data_ptr(int index)
+inline void *Params::get_output_data_ptr(int index)
{
return this->get_output_data_ptr_impl(index);
}
-inline void LFParams::output_set(int index)
+inline void Params::output_set(int index)
{
this->output_set_impl(index);
}
-inline bool LFParams::output_was_set(int index) const
+inline bool Params::output_was_set(int index) const
{
return this->output_was_set_impl(index);
}
-inline ValueUsage LFParams::get_output_usage(int index) const
+inline ValueUsage Params::get_output_usage(int index) const
{
return this->get_output_usage_impl(index);
}
-inline void LFParams::set_input_unused(int index)
+inline void Params::set_input_unused(int index)
{
this->set_input_unused_impl(index);
}
-template<typename T> inline T LFParams::extract_input(int index)
+template<typename T> inline T Params::extract_input(int index)
{
void *data = this->try_get_input_data_ptr(index);
BLI_assert(data != nullptr);
@@ -213,14 +213,14 @@ template<typename T> inline T LFParams::extract_input(int index)
return return_value;
}
-template<typename T> inline const T &LFParams::get_input(int index)
+template<typename T> inline const T &Params::get_input(int index)
{
const void *data = this->try_get_input_data_ptr(index);
BLI_assert(data != nullptr);
return *static_cast<const T *>(data);
}
-template<typename T> inline void LFParams::set_output(int index, T &&value)
+template<typename T> inline void Params::set_output(int index, T &&value)
{
using DecayT = std::decay_t<T>;
void *data = this->get_output_data_ptr(index);
@@ -230,4 +230,4 @@ template<typename T> inline void LFParams::set_output(int index, T &&value)
/** \} */
-} // namespace blender::fn
+} // namespace blender::fn::lazy_function
diff --git a/source/blender/functions/FN_lazy_function_execute.hh b/source/blender/functions/FN_lazy_function_execute.hh
index ebfdd726d10..c378e5fe2ac 100644
--- a/source/blender/functions/FN_lazy_function_execute.hh
+++ b/source/blender/functions/FN_lazy_function_execute.hh
@@ -10,9 +10,9 @@
#include "FN_lazy_function.hh"
-namespace blender::fn {
+namespace blender::fn::lazy_function {
-class BasicLFParams : public LFParams {
+class BasicParams : public Params {
private:
const Span<GMutablePointer> inputs_;
const Span<GMutablePointer> outputs_;
@@ -21,12 +21,12 @@ class BasicLFParams : public LFParams {
MutableSpan<bool> set_outputs_;
public:
- BasicLFParams(const LazyFunction &fn,
- const Span<GMutablePointer> inputs,
- const Span<GMutablePointer> outputs,
- MutableSpan<std::optional<ValueUsage>> input_usages,
- Span<ValueUsage> output_usages,
- MutableSpan<bool> set_outputs);
+ BasicParams(const LazyFunction &fn,
+ const Span<GMutablePointer> inputs,
+ const Span<GMutablePointer> outputs,
+ MutableSpan<std::optional<ValueUsage>> input_usages,
+ Span<ValueUsage> output_usages,
+ MutableSpan<bool> set_outputs);
void *try_get_input_data_ptr_impl(const int index) const override;
void *try_get_input_data_ptr_or_request_impl(const int index) override;
@@ -42,7 +42,7 @@ namespace detail {
template<typename... Inputs, typename... Outputs, size_t... InIndices, size_t... OutIndices>
inline void execute_lazy_function_eagerly_impl(
const LazyFunction &fn,
- LFUserData *user_data,
+ UserData *user_data,
std::tuple<Inputs...> &inputs,
std::tuple<Outputs *...> &outputs,
std::index_sequence<InIndices...> /* in_indices */,
@@ -74,9 +74,9 @@ inline void execute_lazy_function_eagerly_impl(
output_usages.fill(ValueUsage::Used);
set_outputs.fill(false);
LinearAllocator<> allocator;
- LFContext context;
+ Context context;
context.storage = fn.init_storage(allocator);
- BasicLFParams params{
+ BasicParams params{
fn, input_pointers, output_pointers, input_usages, output_usages, set_outputs};
fn.execute(params, context);
fn.destruct_storage(context.storage);
@@ -86,7 +86,7 @@ inline void execute_lazy_function_eagerly_impl(
template<typename... Inputs, typename... Outputs>
inline void execute_lazy_function_eagerly(const LazyFunction &fn,
- LFUserData *user_data,
+ UserData *user_data,
std::tuple<Inputs...> inputs,
std::tuple<Outputs *...> outputs)
{
@@ -100,4 +100,4 @@ inline void execute_lazy_function_eagerly(const LazyFunction &fn,
std::make_index_sequence<sizeof...(Outputs)>());
}
-} // namespace blender::fn
+} // namespace blender::fn::lazy_function
diff --git a/source/blender/functions/FN_lazy_function_graph.hh b/source/blender/functions/FN_lazy_function_graph.hh
index 1744423829e..753b1620752 100644
--- a/source/blender/functions/FN_lazy_function_graph.hh
+++ b/source/blender/functions/FN_lazy_function_graph.hh
@@ -10,17 +10,17 @@
#include "FN_lazy_function.hh"
-namespace blender::fn {
+namespace blender::fn::lazy_function {
-class LFSocket;
-class LFInputSocket;
-class LFOutputSocket;
-class LFNode;
+class Socket;
+class InputSocket;
+class OutputSocket;
+class Node;
class LazyFunctionGraph;
-class LFSocket : NonCopyable, NonMovable {
+class Socket : NonCopyable, NonMovable {
protected:
- LFNode *node_;
+ Node *node_;
const CPPType *type_;
bool is_input_;
int index_in_node_;
@@ -33,50 +33,50 @@ class LFSocket : NonCopyable, NonMovable {
int index_in_node() const;
- LFInputSocket &as_input();
- LFOutputSocket &as_output();
- const LFInputSocket &as_input() const;
- const LFOutputSocket &as_output() const;
+ InputSocket &as_input();
+ OutputSocket &as_output();
+ const InputSocket &as_input() const;
+ const OutputSocket &as_output() const;
-
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list