Panda3D vs. Python-OGRE

Hi all,

Which one is better? Panda3D or Python-OGRE

Thanks in advance

From first glance, Panda3D appears to be a more mature project (more/better docs) but Python Ogre has more to offer (More wrapped libraries).

Panda3d is a pretty good package -- I did some extensive work with it before getting into the Python-Ogre project...

If you want something that fairly simple to learn, has good docs and a resaonable level of performance then there is nothing wrong with Panda3D..

However I don't believe it has the feature set, performance and user community of Ogre or Python-Ogre..

Cheers
Andy

Thank you for your reply.

Any more comments???

IMO "better" is very subjective and depending on your needs. I would suggest that you write down some of your core requirements, and pick up a number of -let's say max four- tools/engines/libraries and spend a day with each of them to see which one works best for you.

It's hard to be unbiased if you already have experience with technology, but you might be surprised how new (for you) technology might fit your needs better.

But who am i too judge? I choose Ogre for my game because i already knew it for a couple of years, which is -considering my first paragraph- not a very good reason. New technology does take relatively short to learn.

But i did spend quite some time before deciding to use a Python- or a Java- based apprauch.

As Andy notes, community is very important indeed.

Good luck with your decision

We checked into Panda3D, but a few things turned me off to it;
Our official reason is that it seems their support for OS X is less complete than Ogre3D's. Python-Ogre seems to have nominal support for OS X, and this is something that will undoubtedly be improved over time. Support for OS X on Panda3D, to me, is not so certain, though it can be compiled on OS X, official support doesn't seem like a priority. However, one could also argue that point with the fact that Python-Ogre is not part of official Ogre3D functionality.
Our unofficial reason is that, like Python-Ogre, our first attempt at compiling it was fraught with complications.
However, Ogre3D seems like a better engine, and although Panda3D documentation is superior, this will undoubtedly be improved over time as we develop our project-- either by you guys, or with our help.

my 2 cents ... I'm not an expert at either, by any means, but I went with python-ogre to teach with primarily because I could successfully compile the maya exporter on linux. also it just looks so good

compiling ogre has its pitfalls, but the two build systems for panda are pretty unique and intricate; and the exporters are not standalone things, they are enmeshed in the whole project build. I got terrific support from both the panda and ogre communities & project leaders trying to port maya exporters to linux; for panda, after a month I had to throw in the towel; with ogre I think it took maybe a day or two. That's a really individual reason but maybe suggests something useful about extensibility, I don't know.

On the other hand, I little quick experimentation with panda gives me the impression that it's a little more approachable for first-time programmers - it feels like there's less infrastructure and complexity that you have to wade through before getting to the interesting part of the code.

Although on the third hand some of that apparently makes it bad and unpythonic.

I'd say, Panda3D is more integrated with their tools, and they're all supported officially. Say, scene exporters like OgreMax and oFusion are all unofficial, but their (nearly) full-functional scene editor/exporter is provided by them officially.

Panda3D seems more mature, too. You can see there quite many commercial games using Panda3D (including that one from Disney), but there're virtually no products made using Python-Ogre...

Well.... Why I'm still staying here? Yep, I think Ogre3D is more extendible and promising.

Panda seems real easy, but getting any kind of specific help is
next to impossible in their forums, and the documentation
is very spotty filled with 'undocumented feature' explanations.

Benefits of Panda:
-easy
-imo better documented
Benefits of PythonOgre:
-Better Performance/Ogres tech is just worlds better/Good Physics
-Better support in forums/growing community
-Continously udated/growing

-> I would say always use PythonOgre. Its harder, but Python is easy enough. The whole rest is of PythonOgre is better.

Ok i see a lot of partial truth and mistakes around there.

As a long time Panda3D user i'll try to make a more documented answer on the panda3D part.

Panda3D is different from most other engine because it's not a C++ engine with scripting features but a Python engine with C++ Horse power behind.

The main features of Panda3D lies in the python layer not on the C++ layer
(which is very efficient and organised but quite low level).

Panda3D is NOT FOR C++ programmer. 99% of the time you dont need to build anything from C++ or to use the build system. You use the python engine . You don't need a single line of C++ knowledge to use Panda3D
(but you need an understanding of Object Oriented Programming)

Panda3D is in constant evolution (new or updated features every 2 weeks in head source code but release are less frequent)
Community is python based not C++ based so Codes,samples and addon are python module, not C++ sourcecode.

What is difficult in Panda3D for long time programmer like myself (coming from C++ then Java background) is that a lot of things that are natural in Python/P3D were nearly unfeasible in C++, so the old programmation tricks and structures are not very efficient in Panda3D.

EG: i now program in Panda3D in real time meaning my program is running always and i can inject new objects, new version of existing object into the game without stopping it ! => dynamic programming to the best....

Now what is included in Panda3D
Core System = very well documented (doc & tutorials & samples)
a rendering system with CG shader features, render to texture, projected texture ,realtime geometry proceduring etc...
an animation system with multipart actors, animation blending etc...
a sound system (2D and 3D sound)
some video playback features
a task system with Parallel, Sequential and Timed task
a Finite State Machine
an event system that allow any object to receive, intercept or send any information to any other object in the system
an arcade based collision system (very efficient but not physics oriented)

Legacy System = poorly documented (samples only)
a low level network system (datastream oriented)
a high level distributed network system (nearly unknown)
a simple physics system (only forces )
interface with physical devices for 3D reality (gloves, pads etc...)

New features = poorly documented (but in progress)
a physics system based on Ode
a glyph vision system (ie you detect object on Webcam ....)
some third party pluging for Novodex Physics engine, terrain rendering etc...

Panda is configured by default to optimize ease of use versus pure performance.
Now there is a bunch (>50) settings that allow to optimise performance
(caching, culliing, texturing, etc....). It is just not activated by default ...

The main drawback of Panda3D are:
- no built in world editor (scene editor is not maintained anymore)
- no built in persistence layer
- no clean inheritance between your object and panda3D object
(easier to say your GameObject have a Panda3Dobject that to say your GameObject is a Panda3DObject )

In term of community contribution to the C++ sourcecode, it's very under control. Your code must live some times around (with release and so on)before it is integrated in the main source code. (it avoid a lot of partial implementation and a lot of duplicated code)

There is also a tutoring program for C++ willing contributor.
In fact you can apply to implement small features already identified and one of the Carmelly Mellon Code maintainer will help you to create and integrate the source code.

I would say that Panda3D adress a different population of people that other engines. I'm a full time IT guys (ex programmer, now project manager)=> I don't want to spend hours working on my game to get it run, i want to spend time on my game concept. I can't afford more than 2 or 3 hours / week on the topic and it is still enough to get results with Panda.
(at least before my first son arrived , 1 month ago )

hh !.

I think Python-Ogre has a good documentation, a very good with those tutorials, since basic to expert, I don't expect more, when I reach the expert level, I thing going to get another new things easily .!

Panda is good, is complete is very nice, but the problem is that you cannot create high quality of games (graphics) because of the performance, just try to do in a modeller like 3d Max or Maya or Blender about 60 cubes, 60 spheres (32 rings), and export them 1, to panda 2, to xmlogre.

Try the engines, you will find panda will run to 15 fps apt. and Ogre will run it at least 40 - 50 fps.

The great disadvantage of Pyhon-Ogre or Ogre, is modules integration , sound, physics, network, collision, etc. While in Panda you limit to program, all modules are built inside the engine.... (may be a tip for Ogre )

As a beginner, I'm not sure if will be hard or easy to integrate them into Python-Ogre.. i hope easy of course, i want to try PO as a game engine ..

i wondered how many poly's i'd need in a plain panda3d run to get down to 15 fps:

on my graphics card (macbook pro, osx 10.6, nvidia geforce 9600m gt) using panda3d nightly build, the proposed model 60 cubes, 60 spheres (32 rings) runs at 150 to 180 fps. i can get down to 15 frames per second by loading this model 60 times, that is 14'601'600 vertices or 7'185'600 triangles.

import random
from pandac.PandaModules import *
loadPrcFileData('', 'show-frame-rate-meter #t') # let me see the frames per second
loadPrcFileData('', 'sync-video #f') # disable v-sync
from direct.directbase import DirectStart # start panda3d
for i in xrange(60):
m = loader.loadModel('test')
m.reparentTo(render)
m.setPos(random.random()*10, random.random()*10, random.random()*10)
render.flattenStrong() # optimize the render structure, equal to loading 1 model containing 60-times as many poly's
base.accept('a', render.analyze) # press a to get the below information
run()

output when pressing 'a':
123 total nodes (including 0 instances); 0 LODNodes.
1 transforms; 0% of nodes have some render attribute.
3660 Geoms, with 3660 GeomVertexDatas and 1 GeomVertexFormats, appear on 60 GeomNodes.
14601600 vertices, 14601600 normals, 0 colors, 0 texture coordinates.
GeomVertexData arrays occupy 342310K memory.
GeomPrimitive arrays occupy 951K memory.
118 GeomVertexArrayDatas are redundant, wasting 83K.
118 GeomPrimitive arrays are redundant, wasting 935K.
7185600 triangles:
43200 of these are on 21600 tristrips (2 average tris per strip).
7142400 of these are independent triangles.
0 textures, estimated minimum 0K texture memory required.

i failed compiling the ogre samples on osx, and dont really know how to load the ogre-xml file i exported from blender. maybe somebody can enlighten me so i can check what fps ogre runs at.
OgreSDK/Samples/../build/Samples.build/Release/Smoke.build/Script-AAD4E9C20C80C90500AE4E5D.sh: line 6: cd: Frameworks: No such file or directory