Panda node confusing??

I have some confusing about Panda3D node, can anyone answer?
I know that panda3D has saveral node like:
collision node
node itself

I don’t know “Are there any other node?”
Can anyone clearify more “What is the difference between nodePath and node itself”
I think i know but not clear then I usually found problem
Thank you for your attention ^^
See you soon

you can always do type(thing) and find its type.

There are tons of nodes in panda3d looki here

node() just returners a node that the thing was derived from
n = NodePath(NodePath(‘hi’))
n.node() would be the NodePath(‘hi’)

if there wasn’t such thing i think it would return the first child which happens to be GeomNode in most cases.

If i would attempt to summarize the difference between node and node path i would say that
=>Node are the concrete Object in the scenegraph
ex: Geom Node

=> Nodepath are the relationship between object in the scenegraph
ex: who is child of ?

It’s a kind of URL in the Scenegraph for the Node. This URL store the node pointer and some additionnal information used for scenegraph queries, user properties etc…

Be careful that Nodepath are a bit transient. It’s a C++ proxy behind so they don’t persist as python object.
Also you can request several nodepaths pointing to the same node and they are not warranted to be equal…

There are several different concrete node classes: PandaNode, GeomNode, CollisionNode, TextNode, and so on. (They don’t all end in the name “Node”; for instance, Camera and Character are also concrete node classes.)

Instances of these classes are used to construct the scene graph. Most of the meat of the scene graph is PandaNode, which is the most generic type. The leaves are generally GeomNode, which is where all the vertices are stored.

NodePath is just a general handle to a node class of any type. Any node can have a NodePath associated with it. Once you have a NodePath, you can do convenient operations like nodePath.setPos() or nodePath.reparentTo(). These operations can also be done without a NodePath, but it’s clumsier. So we normally keep a NodePath around to any object we’re going to manipulating a lot.

Actually, this isn’t true. At least it shouldn’t be. In general, if two NodePaths reference the same instance of a given node, then npA == npB. We go out of our way to ensure this in C++, and it should be true in Python as well.

It might not be the case if you are deriving a custom class from NodePath, though, for instance, Actor. In this case, you might have an Actor A and a NodePath B that reference the same node, but A != B because they are different class types. That’s just a Python thing, though.

Note that a node may have multiple different instances, e.g. multiple parents, or multiple grandparents, or whatever–this means that you might have two different NodePaths which both refer to the same node, but each is a different instance. This possibility is the whole reason we have the NodePath class in the first place: a NodePath encapsulates a unique path to the node from the root, hence its name.

That 's what i was trying to convey.