The LodeStone Manifesto.

Background:

For just about every 2D image file format, there is an OpenSourced loader library. libpng, libjpeg, libimage, libgif to name but a few.

However, it is notable that there is no similar set of 3D model file loaders. The reason for that is that whilst almost any application can accept an image in memory as a two dimensional array of pixels, and every image file loader can produce data in that format, there is no such 'defacto standard' for the interface between a 3D file loader and the application.

This makes life very difficult for developers of 3D applications. In the end, just about every user either writes their own loader, or reaches for one of the MANY so-called "Scene Graph API" libraries.

However, for every scene graph API, there is another set of loaders. Each one implements a different subset of the 3D formats - and each ends up missing a different set of flags and options for those files.

The result is that if you construct a model in some particular modeller, it not only will look different when it's finally loaded into the application, but it may also look different still when it's loaded into a different application.

The LodeStone Project:

There are an INSANE number of Scene Graph API's out there. In early August 2001, Dirk Reiners (author of OpenSG) suggested that one thing we might do to foster some degree of cooperation between the dozens of Scene Graph API's and Game Engines would be to set up a standard interface for simple 3D model loaders.

At SigGraph 2001's OpenGL Birds-of-a-Feather meeting, there was some discussion amongst the (alarmingly) large number of Scene Graph authors about the usual issues of convergance, commonality, etc and as a result of that conversation, it was decided to start a project which I'm calling 'LodeStone'. That project is registered at SourceForge (addresses below).

Lodestone will have five objectives:

To specify the API for a minimal, hypothetical scene graph API which contains only just enough calls to allow models to be loaded into from typical 3D file formats.
Something like:
```
       lsNewBranch()
       lsAddBranchAttributes(branch,....)
       lsNewLeaf()
       lsAddChild(branch,branch_or_leaf)
       lsAddPolygon(leaf,vx1,vx2,vx3)
       lsAddState(polygon,)
```
...and not much else. The barest minimum needed to load a file into memory. There will be NO unnecessary calls - but we will consider providing some kind of extension mechanism (a'la OpenGL) to allow loaders to query the existance of advanced features. As with OpenGL, these will periodically be rolled into the standard if it emerges that all Scene Graphs can implement them.
This API specification will be royalty-free and maintained communally by its contributors. Use of the LodeStone logo and name would only be allowed for applications and libraries that sucessfully load and appropriately display the conformance models (see below).
To encourage Scene Graph authors to implement LodeStone's API as a (hopefully thin) layer on top of their packages' native API. Each would then provide a native API entry to load a model by dynamically linking to the appropriate libLoadStoneXXX library (where XXX is 3DS, AC, VRML, etc), to call the libraries single entrypoint passing a filename and a table of entrypoints corresponding to the LodeStone API)...resulting in a loaded model in the native Scene Graph.
To implement a VAST selection of model loaders on top of the LodeStone API - maintain them for download at a common web site. It is hoped that these will be donated to the LodeStone group by existing Scene Graph authors so that only a small amount of porting effort will be required for each.
To maintain a library of 'reference files' that conformant implementations should be able to load. Thus, new Scene Graph API implementors can test their implementations by loading each of the models in turn and comparing their appearances to the images we will provide. We may also choose to implement a dummy loader library which exercises the LodeStone entrypoints in a procedural manner.
To support loader authors, there will be a program that calls a particular loader with a filename from the command line, printing out the list of LodeStone calls that it makes in human readable form.

It would be up to each individual scene graph author to provide things like triangle stripping, sharing of state information, etc. Whilst all the loaders would be required to be "OpenSourced" (according to the SourceForge definition of that term), the scene graph API's could remain closed source if desired.

Once we have agreement to port loaders into LodeStone from a reasonable number of Scene Graph authors, I'll undertake to port all of the PLIB/SSG loaders (18 of them) to Lodestone and hand them over to that project so that they should "just work" with other conformant scene graph API's.

However, there is no such thing as a free lunch and I won't port my loaders until other authors make the commitment to port theirs and/or write new loaders to cover formats that PLIB doesn't currently support.

Future Directions:

If LodeStone is a success, I'd like to look into 'SaveStone' - which would provide file output facilities to complement LodeStone's loaders. That's definitely out of scope for this first effort though. Let's get this working and build up the necessary trust and cooperation before we move forward.