The concept of “node” is a very fundamental concept to graph theory, which is ubiquitous in computer science. Graphs and trees are used in implementing many, many important data structures, like linked lists and binary trees, and all of them use the concept of “node” in one way or another.
As you say, “A node is when two ropes node together and gets stuck.” Think of a fisherman’s net. It’s made of lots of ropes tied together into a grid. At each intersection point of two ropes crossing, the ropes are tied together in a little knot; this is a “node” of the net.
In a mathematical graph, which is a connection of lines in a mesh kind of like a net, each crossing point of lines is called a “node”. That’s what a “node” is in mathematics.
In the Panda scene graph, we use a graph to represent drawable objects. We call each drawable object in Panda a “node”. Then you can hook up nodes together by drawing lines between them and making a graph. You can also hook up empty nodes that aren’t themselves drawable; but these are used to connect other nodes together.
The top of the scene graph is an empty node called “render”. There’s nothing in render itself to be drawn, it’s just the starting point of the graph. When you load a model, the object you get back is a node. If you make the call:
you have just drawn a line between render and your model. This connects your model into the scene graph, and means that Panda will start drawing it.
You can control the state and position of your model by setting attributes on your model’s node directly. For instance, you can change its position or orientation by calling model.setPos() or model.setHpr(). You can also change its texture or color by calling model.setTexture() or model.setColor().
If you don’t want to take advantage of the organizational power of Panda’s scene graph, you can stop there. You don’t really need to understand Panda’s scene graph to use Panda.
But, you can go deeper. Instead of hooking your node directly up to render, you can hook it up to another node, which is itself hooked up to render:
dummy = NodePath('dummy')
Now you’ve got three nodes in your graph: render, dummy, and model, and there is a line between render and dummy, and another line between dummy and model. The kicker here is that Panda propagates state and transforms down the graph (away from render), so that if you apply a setPos() on dummy, it automatically applies to model as well. If you also to a setPos() on model, then both transforms accumulate and apply together to the model. The same is true for setHpr(), setTexture(), setColor(), and most other operations you do on nodes.
This all means that you can group together models under a single node and move them together as a unit. For instance, if your had a spaceship model that you had to load as two separate pieces, a front half and a back half, you could attach both of them to “dummy” and just move dummy around, instead of having to move your two halves separately.
You can also do more advanced tricks like having Panda compute the total transform between any two nodes in the graph, especially the transform between render and your model (which is also called the worldspace transform of your model).
Does this help you understand the concept of nodes better?