Cleanup: spelling

6 files changed, 22 insertions, 22 deletions

diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h
index 6bebf74824d..448f4ae48ad 100644
--- a/source/blender/blenkernel/BKE_node.h
+++ b/source/blender/blenkernel/BKE_node.h
@@ -325,7 +325,7 @@ typedef struct bNodeType {
 
   /* Execute a geometry node. */
   NodeGeometryExecFunction geometry_node_execute;
-  bool geometry_node_execute_supports_lazyness;
+  bool geometry_node_execute_supports_laziness;
 
   /* RNA integration */
   ExtensionRNA rna_ext;
diff --git a/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc b/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
index 77661b4870a..ae530cc010e 100644
--- a/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
+++ b/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
@@ -427,9 +427,9 @@ static int foreach_id_cow_detect_need_for_update_callback(LibraryIDLinkCallbackD
  *
  * NOTE: Currently the only ID types that depsgraph may decide to not evaluate/generate COW
  * copies for, even though they are referenced by other data-blocks, are Collections and Objects
- * (through their various visbility flags, and the ones from LayerCollections too). However, this
+ * (through their various visibility flags, and the ones from LayerCollections too). However, this
  * code is kept generic as it makes it more future-proof, and optimization here would give
- * neglectable performance improvements in typical cases.
+ * negligible performance improvements in typical cases.
  *
  * NOTE: This mechanism may also 'fix' some missing update tagging from non-depsgraph code in
  * some cases. This is slightly unfortunate (as it may hide issues in other parts of Blender
diff --git a/source/blender/modifiers/intern/MOD_nodes_evaluator.cc b/source/blender/modifiers/intern/MOD_nodes_evaluator.cc
index ac5249b40a2..8c000a536d5 100644
--- a/source/blender/modifiers/intern/MOD_nodes_evaluator.cc
+++ b/source/blender/modifiers/intern/MOD_nodes_evaluator.cc
@@ -175,7 +175,7 @@ enum class NodeScheduleState {
 
 struct NodeState {
   /**
-   * Needs to be locked when any data in this state is accessed that is not explicitely marked as
+   * Needs to be locked when any data in this state is accessed that is not explicitly marked as
    * otherwise.
    */
   std::mutex mutex;
@@ -192,12 +192,12 @@ struct NodeState {
   MutableSpan<OutputState> outputs;
 
   /**
-   * Nodes that don't support lazyness have some special handling the first time they are executed.
+   * Nodes that don't support laziness have some special handling the first time they are executed.
    */
   bool non_lazy_node_is_initialized = false;
 
   /**
-   * Used to check that nodes that don't support lazyness do not run more than once.
+   * Used to check that nodes that don't support laziness do not run more than once.
    */
   bool has_been_executed = false;
 
@@ -309,9 +309,9 @@ static const CPPType *get_socket_cpp_type(const SocketRef &socket)
   return nodes::socket_cpp_type_get(*socket.typeinfo());
 }
 
-static bool node_supports_lazyness(const DNode node)
+static bool node_supports_laziness(const DNode node)
 {
-  return node->typeinfo()->geometry_node_execute_supports_lazyness;
+  return node->typeinfo()->geometry_node_execute_supports_laziness;
 }
 
 /** Implements the callbacks that might be called when a node is executed. */
@@ -644,10 +644,10 @@ class GeometryNodesEvaluator {
     if (!this->prepare_node_outputs_for_execution(locked_node)) {
       return false;
     }
-    /* Initialize nodes that don't support lazyness. This is done after at least one output is
+    /* Initialize nodes that don't support laziness. This is done after at least one output is
      * required and before we check that all required inputs are provided. This reduces the
      * number of "round-trips" through the task pool by one for most nodes. */
-    if (!node_state.non_lazy_node_is_initialized && !node_supports_lazyness(node)) {
+    if (!node_state.non_lazy_node_is_initialized && !node_supports_laziness(node)) {
       this->initialize_non_lazy_node(locked_node);
       node_state.non_lazy_node_is_initialized = true;
     }
@@ -722,7 +722,7 @@ class GeometryNodesEvaluator {
         /* Ignore unavailable/non-data sockets. */
         continue;
       }
-      /* Nodes that don't support lazyness require all inputs. */
+      /* Nodes that don't support laziness require all inputs. */
       const DInputSocket input_socket = locked_node.node.input(i);
       this->set_input_required(locked_node, input_socket);
     }
@@ -789,8 +789,8 @@ class GeometryNodesEvaluator {
     const bNode &bnode = *node->bnode();
 
     if (node_state.has_been_executed) {
-      if (!node_supports_lazyness(node)) {
-        /* Nodes that don't support lazyness must not be executed more than once. */
+      if (!node_supports_laziness(node)) {
+        /* Nodes that don't support laziness must not be executed more than once. */
         BLI_assert_unreachable();
       }
     }
@@ -923,12 +923,12 @@ class GeometryNodesEvaluator {
       return;
     }
 
-    const bool supports_lazyness = node_supports_lazyness(locked_node.node);
+    const bool supports_laziness = node_supports_laziness(locked_node.node);
     /* Iterating over sockets instead of the states directly, because that makes it easier to
      * figure out which socket is missing when one of the asserts is hit. */
     for (const OutputSocketRef *socket_ref : locked_node.node->outputs()) {
       OutputState &output_state = locked_node.node_state.outputs[socket_ref->index()];
-      if (supports_lazyness) {
+      if (supports_laziness) {
         /* Expected that at least all required sockets have been computed. If more outputs become
          * required later, the node will be executed again. */
         if (output_state.output_usage_for_execution == ValueUsage::Required) {
@@ -1511,7 +1511,7 @@ void NodeParamsProvider::set_output(StringRef identifier, GMutablePointer value)
 
 bool NodeParamsProvider::lazy_require_input(StringRef identifier)
 {
-  BLI_assert(node_supports_lazyness(this->dnode));
+  BLI_assert(node_supports_laziness(this->dnode));
   const DInputSocket socket = get_input_by_identifier(this->dnode, identifier);
   BLI_assert(socket);
 
@@ -1547,7 +1547,7 @@ bool NodeParamsProvider::output_is_required(StringRef identifier) const
 
 bool NodeParamsProvider::lazy_output_is_required(StringRef identifier) const
 {
-  BLI_assert(node_supports_lazyness(this->dnode));
+  BLI_assert(node_supports_laziness(this->dnode));
   const DOutputSocket socket = get_output_by_identifier(this->dnode, identifier);
   BLI_assert(socket);
 
diff --git a/source/blender/nodes/NOD_geometry_exec.hh b/source/blender/nodes/NOD_geometry_exec.hh
index 52d7e097f0d..7b176b2f395 100644
--- a/source/blender/nodes/NOD_geometry_exec.hh
+++ b/source/blender/nodes/NOD_geometry_exec.hh
@@ -200,7 +200,7 @@ class GeoNodeExecParams {
 
   /**
    * Returns true when the output has to be computed.
-   * Nodes that support lazyness could use the #lazy_output_is_required variant to possibly avoid
+   * Nodes that support laziness could use the #lazy_output_is_required variant to possibly avoid
    * some computations.
    */
   bool output_is_required(StringRef identifier) const
@@ -212,7 +212,7 @@ class GeoNodeExecParams {
    * Tell the evaluator that a specific input is required.
    * This returns true when the input will only be available in the next execution.
    * False is returned if the input is available already.
-   * This can only be used when the node supports lazyness.
+   * This can only be used when the node supports laziness.
    */
   bool lazy_require_input(StringRef identifier)
   {
@@ -222,7 +222,7 @@ class GeoNodeExecParams {
   /**
    * Asks the evaluator if a specific output is required right now. If this returns false, the
    * value might still need to be computed later.
-   * This can only be used when the node supports lazyness.
+   * This can only be used when the node supports laziness.
    */
   bool lazy_output_is_required(StringRef identifier)
   {
diff --git a/source/blender/nodes/geometry/nodes/node_geo_point_separate.cc b/source/blender/nodes/geometry/nodes/node_geo_point_separate.cc
index d2b024b208c..ff7e95e0221 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_point_separate.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_point_separate.cc
@@ -167,6 +167,6 @@ void register_node_type_geo_point_separate()
   geo_node_type_base(&ntype, GEO_NODE_POINT_SEPARATE, "Point Separate", NODE_CLASS_GEOMETRY, 0);
   node_type_socket_templates(&ntype, geo_node_point_instance_in, geo_node_point_instance_out);
   ntype.geometry_node_execute = blender::nodes::geo_node_point_separate_exec;
-  ntype.geometry_node_execute_supports_lazyness = true;
+  ntype.geometry_node_execute_supports_laziness = true;
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/geometry/nodes/node_geo_switch.cc b/source/blender/nodes/geometry/nodes/node_geo_switch.cc
index bb0a20f4561..e0daae0c172 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_switch.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_switch.cc
@@ -171,7 +171,7 @@ void register_node_type_geo_switch()
   node_type_update(&ntype, blender::nodes::geo_node_switch_update);
   node_type_storage(&ntype, "NodeSwitch", node_free_standard_storage, node_copy_standard_storage);
   ntype.geometry_node_execute = blender::nodes::geo_node_switch_exec;
-  ntype.geometry_node_execute_supports_lazyness = true;
+  ntype.geometry_node_execute_supports_laziness = true;
   ntype.draw_buttons = geo_node_switch_layout;
   nodeRegisterType(&ntype);
 }