Cleanup: Use trailing underscore for non-public data members

This makes the code conform better with our style guide.

2 files changed, 140 insertions, 140 deletions

diff --git a/source/blender/blenkernel/intern/derived_node_tree.cc b/source/blender/blenkernel/intern/derived_node_tree.cc
index b53457812ba..83ef45189bc 100644
--- a/source/blender/blenkernel/intern/derived_node_tree.cc
+++ b/source/blender/blenkernel/intern/derived_node_tree.cc
@@ -29,7 +29,7 @@ static const NodeTreeRef &get_tree_ref(NodeTreeRefMap &node_tree_refs, bNodeTree
                                           [&]() { return std::make_unique<NodeTreeRef>(btree); });
 }
 
-DerivedNodeTree::DerivedNodeTree(bNodeTree *btree, NodeTreeRefMap &node_tree_refs) : m_btree(btree)
+DerivedNodeTree::DerivedNodeTree(bNodeTree *btree, NodeTreeRefMap &node_tree_refs) : btree_(btree)
 {
   const NodeTreeRef &main_tree_ref = get_tree_ref(node_tree_refs, btree);
 
@@ -63,8 +63,8 @@ BLI_NOINLINE void DerivedNodeTree::insert_nodes_and_links_in_id_order(const Node
       DInputSocket *to_socket = (DInputSocket *)sockets_map[to_socket_ref->id()];
       for (const OutputSocketRef *from_socket_ref : to_socket_ref->linked_sockets()) {
         DOutputSocket *from_socket = (DOutputSocket *)sockets_map[from_socket_ref->id()];
-        to_socket->m_linked_sockets.append(from_socket);
-        from_socket->m_linked_sockets.append(to_socket);
+        to_socket->linked_sockets_.append(from_socket);
+        from_socket->linked_sockets_.append(to_socket);
       }
     }
   }
@@ -74,34 +74,34 @@ DNode &DerivedNodeTree::create_node(const NodeRef &node_ref,
                                     DParentNode *parent,
                                     MutableSpan<DSocket *> r_sockets_map)
 {
-  DNode &node = *m_allocator.construct<DNode>();
-  node.m_node_ref = &node_ref;
-  node.m_parent = parent;
-  node.m_id = UNINITIALIZED_ID;
+  DNode &node = *allocator_.construct<DNode>();
+  node.node_ref_ = &node_ref;
+  node.parent_ = parent;
+  node.id_ = UNINITIALIZED_ID;
 
-  node.m_inputs = m_allocator.construct_elements_and_pointer_array<DInputSocket>(
+  node.inputs_ = allocator_.construct_elements_and_pointer_array<DInputSocket>(
       node_ref.inputs().size());
-  node.m_outputs = m_allocator.construct_elements_and_pointer_array<DOutputSocket>(
+  node.outputs_ = allocator_.construct_elements_and_pointer_array<DOutputSocket>(
       node_ref.outputs().size());
 
-  for (uint i : node.m_inputs.index_range()) {
+  for (uint i : node.inputs_.index_range()) {
     const InputSocketRef &socket_ref = node_ref.input(i);
-    DInputSocket &socket = *node.m_inputs[i];
+    DInputSocket &socket = *node.inputs_[i];
 
-    socket.m_id = UNINITIALIZED_ID;
-    socket.m_node = &node;
-    socket.m_socket_ref = &socket_ref;
+    socket.id_ = UNINITIALIZED_ID;
+    socket.node_ = &node;
+    socket.socket_ref_ = &socket_ref;
 
     r_sockets_map[socket_ref.id()] = &socket;
   }
 
-  for (uint i : node.m_outputs.index_range()) {
+  for (uint i : node.outputs_.index_range()) {
     const OutputSocketRef &socket_ref = node_ref.output(i);
-    DOutputSocket &socket = *node.m_outputs[i];
+    DOutputSocket &socket = *node.outputs_[i];
 
-    socket.m_id = UNINITIALIZED_ID;
-    socket.m_node = &node;
-    socket.m_socket_ref = &socket_ref;
+    socket.id_ = UNINITIALIZED_ID;
+    socket.node_ = &node;
+    socket.socket_ref_ = &socket_ref;
 
     r_sockets_map[socket_ref.id()] = &socket;
   }
@@ -116,7 +116,7 @@ BLI_NOINLINE void DerivedNodeTree::expand_groups(Vector<DNode *> &all_nodes,
 {
   for (uint i = 0; i < all_nodes.size(); i++) {
     DNode &node = *all_nodes[i];
-    if (node.m_node_ref->is_group_node()) {
+    if (node.node_ref_->is_group_node()) {
       this->expand_group_node(node, all_nodes, all_group_inputs, all_parent_nodes, node_tree_refs);
     }
   }
@@ -128,7 +128,7 @@ BLI_NOINLINE void DerivedNodeTree::expand_group_node(DNode &group_node,
                                                      Vector<DParentNode *> &all_parent_nodes,
                                                      NodeTreeRefMap &node_tree_refs)
 {
-  const NodeRef &group_node_ref = *group_node.m_node_ref;
+  const NodeRef &group_node_ref = *group_node.node_ref_;
   BLI_assert(group_node_ref.is_group_node());
 
   bNodeTree *btree = (bNodeTree *)group_node_ref.bnode()->id;
@@ -138,10 +138,10 @@ BLI_NOINLINE void DerivedNodeTree::expand_group_node(DNode &group_node,
 
   const NodeTreeRef &group_ref = get_tree_ref(node_tree_refs, btree);
 
-  DParentNode &parent = *m_allocator.construct<DParentNode>();
-  parent.m_id = all_parent_nodes.append_and_get_index(&parent);
-  parent.m_parent = group_node.m_parent;
-  parent.m_node_ref = &group_node_ref;
+  DParentNode &parent = *allocator_.construct<DParentNode>();
+  parent.id_ = all_parent_nodes.append_and_get_index(&parent);
+  parent.parent_ = group_node.parent_;
+  parent.node_ref_ = &group_node_ref;
 
   this->insert_nodes_and_links_in_id_order(group_ref, &parent, all_nodes);
   Span<DNode *> new_nodes_by_id = all_nodes.as_span().take_back(group_ref.nodes().size());
@@ -154,18 +154,18 @@ BLI_NOINLINE void DerivedNodeTree::expand_group_node(DNode &group_node,
 BLI_NOINLINE void DerivedNodeTree::create_group_inputs_for_unlinked_inputs(
     DNode &node, Vector<DGroupInput *> &all_group_inputs)
 {
-  for (DInputSocket *input_socket : node.m_inputs) {
+  for (DInputSocket *input_socket : node.inputs_) {
     if (input_socket->is_linked()) {
       continue;
     }
 
-    DGroupInput &group_input = *m_allocator.construct<DGroupInput>();
-    group_input.m_id = UNINITIALIZED_ID;
-    group_input.m_socket_ref = &input_socket->socket_ref();
-    group_input.m_parent = node.m_parent;
+    DGroupInput &group_input = *allocator_.construct<DGroupInput>();
+    group_input.id_ = UNINITIALIZED_ID;
+    group_input.socket_ref_ = &input_socket->socket_ref();
+    group_input.parent_ = node.parent_;
 
-    group_input.m_linked_sockets.append(input_socket);
-    input_socket->m_linked_group_inputs.append(&group_input);
+    group_input.linked_sockets_.append(input_socket);
+    input_socket->linked_group_inputs_.append(&group_input);
     all_group_inputs.append(&group_input);
   }
 }
@@ -186,34 +186,34 @@ BLI_NOINLINE void DerivedNodeTree::relink_group_inputs(const NodeTreeRef &group_
   BLI_assert(input_amount == input_node_ref.outputs().size() - 1);
 
   for (uint input_index : IndexRange(input_amount)) {
-    DInputSocket *outside_group = group_node.m_inputs[input_index];
-    DOutputSocket *inside_group = input_node.m_outputs[input_index];
+    DInputSocket *outside_group = group_node.inputs_[input_index];
+    DOutputSocket *inside_group = input_node.outputs_[input_index];
 
-    for (DOutputSocket *outside_connected : outside_group->m_linked_sockets) {
-      outside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(outside_group);
+    for (DOutputSocket *outside_connected : outside_group->linked_sockets_) {
+      outside_connected->linked_sockets_.remove_first_occurrence_and_reorder(outside_group);
     }
 
-    for (DGroupInput *outside_connected : outside_group->m_linked_group_inputs) {
-      outside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(outside_group);
+    for (DGroupInput *outside_connected : outside_group->linked_group_inputs_) {
+      outside_connected->linked_sockets_.remove_first_occurrence_and_reorder(outside_group);
     }
 
-    for (DInputSocket *inside_connected : inside_group->m_linked_sockets) {
-      inside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(inside_group);
+    for (DInputSocket *inside_connected : inside_group->linked_sockets_) {
+      inside_connected->linked_sockets_.remove_first_occurrence_and_reorder(inside_group);
 
-      for (DOutputSocket *outside_connected : outside_group->m_linked_sockets) {
-        inside_connected->m_linked_sockets.append(outside_connected);
-        outside_connected->m_linked_sockets.append(inside_connected);
+      for (DOutputSocket *outside_connected : outside_group->linked_sockets_) {
+        inside_connected->linked_sockets_.append(outside_connected);
+        outside_connected->linked_sockets_.append(inside_connected);
       }
 
-      for (DGroupInput *outside_connected : outside_group->m_linked_group_inputs) {
-        inside_connected->m_linked_group_inputs.append(outside_connected);
-        outside_connected->m_linked_sockets.append(inside_connected);
+      for (DGroupInput *outside_connected : outside_group->linked_group_inputs_) {
+        inside_connected->linked_group_inputs_.append(outside_connected);
+        outside_connected->linked_sockets_.append(inside_connected);
       }
     }
 
-    inside_group->m_linked_sockets.clear();
-    outside_group->m_linked_sockets.clear();
-    outside_group->m_linked_group_inputs.clear();
+    inside_group->linked_sockets_.clear();
+    outside_group->linked_sockets_.clear();
+    outside_group->linked_group_inputs_.clear();
   }
 }
 
@@ -233,33 +233,33 @@ BLI_NOINLINE void DerivedNodeTree::relink_group_outputs(const NodeTreeRef &group
   BLI_assert(output_amount == output_node_ref.inputs().size() - 1);
 
   for (uint output_index : IndexRange(output_amount)) {
-    DOutputSocket *outside_group = group_node.m_outputs[output_index];
-    DInputSocket *inside_group = output_node.m_inputs[output_index];
+    DOutputSocket *outside_group = group_node.outputs_[output_index];
+    DInputSocket *inside_group = output_node.inputs_[output_index];
 
-    for (DInputSocket *outside_connected : outside_group->m_linked_sockets) {
-      outside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(outside_group);
+    for (DInputSocket *outside_connected : outside_group->linked_sockets_) {
+      outside_connected->linked_sockets_.remove_first_occurrence_and_reorder(outside_group);
     }
 
-    for (DOutputSocket *inside_connected : inside_group->m_linked_sockets) {
-      inside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(inside_group);
+    for (DOutputSocket *inside_connected : inside_group->linked_sockets_) {
+      inside_connected->linked_sockets_.remove_first_occurrence_and_reorder(inside_group);
 
-      for (DInputSocket *outside_connected : outside_group->m_linked_sockets) {
-        inside_connected->m_linked_sockets.append(outside_connected);
-        outside_connected->m_linked_sockets.append(inside_connected);
+      for (DInputSocket *outside_connected : outside_group->linked_sockets_) {
+        inside_connected->linked_sockets_.append(outside_connected);
+        outside_connected->linked_sockets_.append(inside_connected);
       }
     }
 
-    for (DGroupInput *inside_connected : inside_group->m_linked_group_inputs) {
-      inside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(inside_group);
+    for (DGroupInput *inside_connected : inside_group->linked_group_inputs_) {
+      inside_connected->linked_sockets_.remove_first_occurrence_and_reorder(inside_group);
 
-      for (DInputSocket *outside_connected : outside_group->m_linked_sockets) {
-        inside_connected->m_linked_sockets.append(outside_connected);
-        outside_connected->m_linked_group_inputs.append(inside_connected);
+      for (DInputSocket *outside_connected : outside_group->linked_sockets_) {
+        inside_connected->linked_sockets_.append(outside_connected);
+        outside_connected->linked_group_inputs_.append(inside_connected);
       }
     }
 
-    outside_group->m_linked_sockets.clear();
-    inside_group->m_linked_sockets.clear();
+    outside_group->linked_sockets_.clear();
+    inside_group->linked_sockets_.clear();
   }
 }
 
@@ -268,9 +268,9 @@ BLI_NOINLINE void DerivedNodeTree::remove_expanded_group_interfaces(Vector<DNode
   int index = 0;
   while (index < all_nodes.size()) {
     DNode &node = *all_nodes[index];
-    const NodeRef &node_ref = *node.m_node_ref;
+    const NodeRef &node_ref = *node.node_ref_;
     if (node_ref.is_group_node() ||
-        (node.m_parent != nullptr &&
+        (node.parent_ != nullptr &&
          (node_ref.is_group_input_node() || node_ref.is_group_output_node()))) {
       all_nodes.remove_and_reorder(index);
       node.destruct_with_sockets();
@@ -287,7 +287,7 @@ BLI_NOINLINE void DerivedNodeTree::remove_unused_group_inputs(
   int index = 0;
   while (index < all_group_inputs.size()) {
     DGroupInput &group_input = *all_group_inputs[index];
-    if (group_input.m_linked_sockets.is_empty()) {
+    if (group_input.linked_sockets_.is_empty()) {
       all_group_inputs.remove_and_reorder(index);
       group_input.~DGroupInput();
     }
@@ -299,10 +299,10 @@ BLI_NOINLINE void DerivedNodeTree::remove_unused_group_inputs(
 
 void DNode::destruct_with_sockets()
 {
-  for (DInputSocket *socket : m_inputs) {
+  for (DInputSocket *socket : inputs_) {
     socket->~DInputSocket();
   }
-  for (DOutputSocket *socket : m_outputs) {
+  for (DOutputSocket *socket : outputs_) {
     socket->~DOutputSocket();
   }
   this->~DNode();
@@ -313,47 +313,47 @@ BLI_NOINLINE void DerivedNodeTree::store_in_this_and_init_ids(
     Vector<DGroupInput *> &&all_group_inputs,
     Vector<DParentNode *> &&all_parent_nodes)
 {
-  m_nodes_by_id = std::move(all_nodes);
-  m_group_inputs = std::move(all_group_inputs);
-  m_parent_nodes = std::move(all_parent_nodes);
+  nodes_by_id_ = std::move(all_nodes);
+  group_inputs_ = std::move(all_group_inputs);
+  parent_nodes_ = std::move(all_parent_nodes);
 
-  for (uint node_index : m_nodes_by_id.index_range()) {
-    DNode *node = m_nodes_by_id[node_index];
-    node->m_id = node_index;
+  for (uint node_index : nodes_by_id_.index_range()) {
+    DNode *node = nodes_by_id_[node_index];
+    node->id_ = node_index;
 
-    const bNodeType *nodetype = node->m_node_ref->bnode()->typeinfo;
-    m_nodes_by_type.lookup_or_add_default(nodetype).append(node);
+    const bNodeType *nodetype = node->node_ref_->bnode()->typeinfo;
+    nodes_by_type_.lookup_or_add_default(nodetype).append(node);
 
-    for (DInputSocket *socket : node->m_inputs) {
-      socket->m_id = m_sockets_by_id.append_and_get_index(socket);
-      m_input_sockets.append(socket);
+    for (DInputSocket *socket : node->inputs_) {
+      socket->id_ = sockets_by_id_.append_and_get_index(socket);
+      input_sockets_.append(socket);
     }
-    for (DOutputSocket *socket : node->m_outputs) {
-      socket->m_id = m_sockets_by_id.append_and_get_index(socket);
-      m_output_sockets.append(socket);
+    for (DOutputSocket *socket : node->outputs_) {
+      socket->id_ = sockets_by_id_.append_and_get_index(socket);
+      output_sockets_.append(socket);
     }
   }
 
-  for (uint i : m_group_inputs.index_range()) {
-    m_group_inputs[i]->m_id = i;
+  for (uint i : group_inputs_.index_range()) {
+    group_inputs_[i]->id_ = i;
   }
 }
 
 DerivedNodeTree::~DerivedNodeTree()
 {
-  for (DInputSocket *socket : m_input_sockets) {
+  for (DInputSocket *socket : input_sockets_) {
     socket->~DInputSocket();
   }
-  for (DOutputSocket *socket : m_output_sockets) {
+  for (DOutputSocket *socket : output_sockets_) {
     socket->~DOutputSocket();
   }
-  for (DNode *node : m_nodes_by_id) {
+  for (DNode *node : nodes_by_id_) {
     node->~DNode();
   }
-  for (DGroupInput *group_input : m_group_inputs) {
+  for (DGroupInput *group_input : group_inputs_) {
     group_input->~DGroupInput();
   }
-  for (DParentNode *parent : m_parent_nodes) {
+  for (DParentNode *parent : parent_nodes_) {
     parent->~DParentNode();
   }
 }
@@ -384,7 +384,7 @@ std::string DerivedNodeTree::to_dot() const
   Map<const DGroupInput *, dot::NodeWithSocketsRef> dot_group_inputs;
   Map<const DParentNode *, dot::Cluster *> dot_clusters;
 
-  for (const DNode *node : m_nodes_by_id) {
+  for (const DNode *node : nodes_by_id_) {
     dot::Node &dot_node = digraph.new_node("");
     dot_node.set_background_color("white");
 
@@ -404,7 +404,7 @@ std::string DerivedNodeTree::to_dot() const
     dot_node.set_parent_cluster(cluster);
   }
 
-  for (const DGroupInput *group_input : m_group_inputs) {
+  for (const DGroupInput *group_input : group_inputs_) {
     dot::Node &dot_node = digraph.new_node("");
     dot_node.set_background_color("white");
 
@@ -416,7 +416,7 @@ std::string DerivedNodeTree::to_dot() const
     dot_node.set_parent_cluster(cluster);
   }
 
-  for (const DNode *to_node : m_nodes_by_id) {
+  for (const DNode *to_node : nodes_by_id_) {
     dot::NodeWithSocketsRef &to_dot_node = dot_nodes.lookup(to_node);
 
     for (const DInputSocket *to_socket : to_node->inputs()) {
diff --git a/source/blender/blenkernel/intern/node_tree_ref.cc b/source/blender/blenkernel/intern/node_tree_ref.cc
index 6bd3e2d2e5a..1803243d4cc 100644
--- a/source/blender/blenkernel/intern/node_tree_ref.cc
+++ b/source/blender/blenkernel/intern/node_tree_ref.cc
@@ -21,40 +21,40 @@
 namespace blender {
 namespace bke {
 
-NodeTreeRef::NodeTreeRef(bNodeTree *btree) : m_btree(btree)
+NodeTreeRef::NodeTreeRef(bNodeTree *btree) : btree_(btree)
 {
   Map<bNode *, NodeRef *> node_mapping;
 
   LISTBASE_FOREACH (bNode *, bnode, &btree->nodes) {
-    NodeRef &node = *m_allocator.construct<NodeRef>();
+    NodeRef &node = *allocator_.construct<NodeRef>();
 
-    node.m_tree = this;
-    node.m_bnode = bnode;
-    node.m_id = m_nodes_by_id.append_and_get_index(&node);
-    RNA_pointer_create(&btree->id, &RNA_Node, bnode, &node.m_rna);
+    node.tree_ = this;
+    node.bnode_ = bnode;
+    node.id_ = nodes_by_id_.append_and_get_index(&node);
+    RNA_pointer_create(&btree->id, &RNA_Node, bnode, &node.rna_);
 
     LISTBASE_FOREACH (bNodeSocket *, bsocket, &bnode->inputs) {
-      InputSocketRef &socket = *m_allocator.construct<InputSocketRef>();
-      socket.m_node = &node;
-      socket.m_index = node.m_inputs.append_and_get_index(&socket);
-      socket.m_is_input = true;
-      socket.m_bsocket = bsocket;
-      socket.m_id = m_sockets_by_id.append_and_get_index(&socket);
-      RNA_pointer_create(&btree->id, &RNA_NodeSocket, bsocket, &socket.m_rna);
+      InputSocketRef &socket = *allocator_.construct<InputSocketRef>();
+      socket.node_ = &node;
+      socket.index_ = node.inputs_.append_and_get_index(&socket);
+      socket.is_input_ = true;
+      socket.bsocket_ = bsocket;
+      socket.id_ = sockets_by_id_.append_and_get_index(&socket);
+      RNA_pointer_create(&btree->id, &RNA_NodeSocket, bsocket, &socket.rna_);
     }
 
     LISTBASE_FOREACH (bNodeSocket *, bsocket, &bnode->outputs) {
-      OutputSocketRef &socket = *m_allocator.construct<OutputSocketRef>();
-      socket.m_node = &node;
-      socket.m_index = node.m_outputs.append_and_get_index(&socket);
-      socket.m_is_input = false;
-      socket.m_bsocket = bsocket;
-      socket.m_id = m_sockets_by_id.append_and_get_index(&socket);
-      RNA_pointer_create(&btree->id, &RNA_NodeSocket, bsocket, &socket.m_rna);
+      OutputSocketRef &socket = *allocator_.construct<OutputSocketRef>();
+      socket.node_ = &node;
+      socket.index_ = node.outputs_.append_and_get_index(&socket);
+      socket.is_input_ = false;
+      socket.bsocket_ = bsocket;
+      socket.id_ = sockets_by_id_.append_and_get_index(&socket);
+      RNA_pointer_create(&btree->id, &RNA_NodeSocket, bsocket, &socket.rna_);
     }
 
-    m_input_sockets.extend(node.m_inputs);
-    m_output_sockets.extend(node.m_outputs);
+    input_sockets_.extend(node.inputs_);
+    output_sockets_.extend(node.outputs_);
 
     node_mapping.add_new(bnode, &node);
   }
@@ -65,34 +65,34 @@ NodeTreeRef::NodeTreeRef(bNodeTree *btree) : m_btree(btree)
     InputSocketRef &to_socket = this->find_input_socket(
         node_mapping, blink->tonode, blink->tosock);
 
-    from_socket.m_directly_linked_sockets.append(&to_socket);
-    to_socket.m_directly_linked_sockets.append(&from_socket);
+    from_socket.directly_linked_sockets_.append(&to_socket);
+    to_socket.directly_linked_sockets_.append(&from_socket);
   }
 
-  for (OutputSocketRef *socket : m_output_sockets) {
-    if (!socket->m_node->is_reroute_node()) {
-      this->find_targets_skipping_reroutes(*socket, socket->m_linked_sockets);
-      for (SocketRef *target : socket->m_linked_sockets) {
-        target->m_linked_sockets.append(socket);
+  for (OutputSocketRef *socket : output_sockets_) {
+    if (!socket->node_->is_reroute_node()) {
+      this->find_targets_skipping_reroutes(*socket, socket->linked_sockets_);
+      for (SocketRef *target : socket->linked_sockets_) {
+        target->linked_sockets_.append(socket);
       }
     }
   }
 
-  for (NodeRef *node : m_nodes_by_id) {
-    const bNodeType *nodetype = node->m_bnode->typeinfo;
-    m_nodes_by_type.lookup_or_add_default(nodetype).append(node);
+  for (NodeRef *node : nodes_by_id_) {
+    const bNodeType *nodetype = node->bnode_->typeinfo;
+    nodes_by_type_.lookup_or_add_default(nodetype).append(node);
   }
 }
 
 NodeTreeRef::~NodeTreeRef()
 {
-  for (NodeRef *node : m_nodes_by_id) {
+  for (NodeRef *node : nodes_by_id_) {
     node->~NodeRef();
   }
-  for (InputSocketRef *socket : m_input_sockets) {
+  for (InputSocketRef *socket : input_sockets_) {
     socket->~InputSocketRef();
   }
-  for (OutputSocketRef *socket : m_output_sockets) {
+  for (OutputSocketRef *socket : output_sockets_) {
     socket->~OutputSocketRef();
   }
 }
@@ -102,13 +102,13 @@ InputSocketRef &NodeTreeRef::find_input_socket(Map<bNode *, NodeRef *> &node_map
                                                bNodeSocket *bsocket)
 {
   NodeRef *node = node_mapping.lookup(bnode);
-  for (SocketRef *socket : node->m_inputs) {
-    if (socket->m_bsocket == bsocket) {
+  for (SocketRef *socket : node->inputs_) {
+    if (socket->bsocket_ == bsocket) {
       return *(InputSocketRef *)socket;
     }
   }
   BLI_assert(false);
-  return *node->m_inputs[0];
+  return *node->inputs_[0];
 }
 
 OutputSocketRef &NodeTreeRef::find_output_socket(Map<bNode *, NodeRef *> &node_mapping,
@@ -116,21 +116,21 @@ OutputSocketRef &NodeTreeRef::find_output_socket(Map<bNode *, NodeRef *> &node_m
                                                  bNodeSocket *bsocket)
 {
   NodeRef *node = node_mapping.lookup(bnode);
-  for (SocketRef *socket : node->m_outputs) {
-    if (socket->m_bsocket == bsocket) {
+  for (SocketRef *socket : node->outputs_) {
+    if (socket->bsocket_ == bsocket) {
       return *(OutputSocketRef *)socket;
     }
   }
   BLI_assert(false);
-  return *node->m_outputs[0];
+  return *node->outputs_[0];
 }
 
 void NodeTreeRef::find_targets_skipping_reroutes(OutputSocketRef &socket,
                                                  Vector<SocketRef *> &r_targets)
 {
-  for (SocketRef *direct_target : socket.m_directly_linked_sockets) {
-    if (direct_target->m_node->is_reroute_node()) {
-      this->find_targets_skipping_reroutes(*direct_target->m_node->m_outputs[0], r_targets);
+  for (SocketRef *direct_target : socket.directly_linked_sockets_) {
+    if (direct_target->node_->is_reroute_node()) {
+      this->find_targets_skipping_reroutes(*direct_target->node_->outputs_[0], r_targets);
     }
     else {
       r_targets.append_non_duplicates(direct_target);
@@ -145,7 +145,7 @@ std::string NodeTreeRef::to_dot() const
 
   Map<const NodeRef *, dot::NodeWithSocketsRef> dot_nodes;
 
-  for (const NodeRef *node : m_nodes_by_id) {
+  for (const NodeRef *node : nodes_by_id_) {
     dot::Node &dot_node = digraph.new_node("");
     dot_node.set_background_color("white");
 
@@ -162,7 +162,7 @@ std::string NodeTreeRef::to_dot() const
                       dot::NodeWithSocketsRef(dot_node, node->name(), input_names, output_names));
   }
 
-  for (const OutputSocketRef *from_socket : m_output_sockets) {
+  for (const OutputSocketRef *from_socket : output_sockets_) {
     for (const InputSocketRef *to_socket : from_socket->directly_linked_sockets()) {
       dot::NodeWithSocketsRef &from_dot_node = dot_nodes.lookup(&from_socket->node());
       dot::NodeWithSocketsRef &to_dot_node = dot_nodes.lookup(&to_socket->node());