Are there easy Python bindings for This engine?

I would like to get some easy Python bindings for Panda3D that make it easier to write code and hide all the long extra pieces of code, or a set of functions that hide the scene node code , similar to Ursina3D.

There are already Python bindings–or do you mean that you want different bindings…?

(I’m afraid that I’m not familiar with Ursina3D, and so don’t have that comparison to draw from.)

Hello, your post is a little humorous. :slightly_smiling_face:

Yes, I want something with a simple syntax similar to Blitz3d functions.

Ah, okay. I haven’t used Blitz3D, so I’m not familiar with its style, but I think that I follow you.

Unfortunately, I don’t think that anyone has made such a set of bindings, as far as I’m aware.

Indeed, such a thing would be more than a set of bindings, I think–more a wrapper with its own bindings.


Print "Hello World"   ; Prints to the screen.

Python 3

print("Hello World")  # Prints to the screen.

Python 2

print "Hello World"   # Prints to the screen.

I don’t understand what complex python syntax is.

It is not Python syntax but Panda3d syntax which is complex, it is too scene and node based and contains a lot of node related code that makes the code a lot longer and more confusing than it would otherwise be.

Panda contains Python classes and functions that wrap C++code. It doesn’t set programming rules, much less syntax. Your example is a linear interpreter based on basic.


text = OnscreenText()
text['text'] = "text"


text = {'text':"text"}
text['text'] = "text"

This code does not differ in syntax.

I’m curious: how do you envisage a simplified version of Panda working? Could you perhaps give an example of some standard Panda usage followed by your desired simplified version?

He already did.

Yes, but (A) I don’t want to figure out a new engine’s usage right now, and (B) it may well be helpful to have a side-by-side example, not just the other engine alone.

Pay attention to dependencies :slightly_smiling_face:

Panda3d code

self.scene = self.loader.loadmodel( "car.obj")

and simplified code

car = LoadModel("car.obj")
PositionEntity car,x,y,z


car = loader.loadmodel( "car.obj").reparentTo(render)

The class attribute is not needed if the class is not used.


def LoadModel(model):
    return loader.loadmodel(model).reparentTo(render)
car = LoadModel("car.obj")
1 Like

That’s it. That is the kind of wrapper I was talking about. I would make one but it would take a lot of time and the Panda3d API is huge, I presume ?
And I wonder if that is how Ursina3d was made? It was built on top of Panda3d.

This is not good for development, you lose flexibility. What if you need to build a complex node with animations, effects, and collisions? What will you do?

I think you can check this with the developers Ursina3d.

It sounds like you want something like PyGame Zero but for Panda3D instead of PyGame.

Panda3D is designed to offer an API that is powerful enough to be suited for developing commercial games. If you find its syntax too daunting, you might indeed want to look at higher-level libraries on top of Panda3D such as Ursina (though I haven’t really looked at it myself).

Ah, okay, I think that I understand better what you’re looking for.

Indeed, I think that this would be quite a big project! And as Serega indicates, it would very likely come at a significant cost in flexibility–and power, for that matter.

That said, if Ursina is based on Panda, and Ursina has the sort of simplification that you’re looking for, then why not use that?

I had a suspicion that it might be based on Panda3D, as I recall, but I couldn’t be bothered to properly check tonight. ^^;