Vertex Modeler

Java-based programmatic model generator

License: LGPL (license.txt)
API Docs: Can be found here
Changelog: Can be found here
Screenshots: Can be found here

Short Description:
    Vertex Modeler is a 3D modeler designed for use by programmers, as well as a simple scene graph API that is easy to use.

Long Description:
    I really needed some manner of building 3D models for The Deimos Project, but all the modelers I've looked at have a counter-intuitive user interface that was probably designed for an artist's point of view. I needed something built from a more logical stand-point, something that appeals to a programmer instead. Vertex Modeler is the solution to this problem.
    Vertex Modeler allows a programmer to construct a model from java source code. To accomplish this, it takes a source file and compiles it using an embedded java compiler called Janino (http://janino.net or http://janino.codehaus.org). This source file is assumed to have a class in it called "VisibleFactoryImpl", which is an implementation of the interface VisibleFactory. The class is also assumed to have a no-argument constructor.
    An instance of VisibleFactoryImpl is created and then it's newVisible() method is called. This produces an object that implements Visible, an interface that describes methods required to build any OpenGL object in a manner that it can be used with this program.
    If you're going to be doing 3D modeling, you'll be interested in the Model class. You should also review the VertexUtil class, as it is very useful for constructing the vertex arrays used for building Model objects.
    I've typed up some notes on model design that you can find here.

Features:
    Object Oriented approach to OpenGL without preventing access to low-level APIs. In other words, this augments your OpenGL work, instead of replacing it.
    Build models without a crappy 3D GUI getting in the way.
    Build models using a program instead of just data. Suddenly, your trigonometry and geometry classes aren't so useless...
    Texture and paint your models, too.
    Multiple colorations (the paint) can be stored in a single model and switched as needed.
    Height-mapped terrain or spheres built from images.
    Handy OpenGL helper classes.
    Automatic normal calculation, or you can supply your own normals.
    Use triangles, triangle strips, triangle fans, quads, quad strips, lines, line strips, and line loops to build your models.
    XML files for model import/export.
    Exports to Wavefront .obj format or to a POV-Ray Mesh2 structure.
    Automatically uses OpenGL display lists to accelerate rendering your models.
    Simple generation of auras for models.
    Simple generation of line-based versions of any model.
    Easy to use split screen rendering system.

Usage:
    Just type the following in a console window:
"java -jar vmodeler.jar file.java"
    file.java refers to the model source file you wish to view. There are several example models in the models directory. These model sources are also governed by the LGPL license, except ColorCube.java, TestBed.java and VariableSceneGraph, which I have decided are public domain. That way, you can build models (or your own test programs) from an example without having to worry about the license.
    You might want to try the "-help" switch sometime, too; it will show you all the options and a little information about them.
    Also, while the Modeler is running, you can press the S key to take a screen shot. You'll have to configure the "directory" property in the "capture" node of the configuration file if you want it to save files somewhere other than the current directory.

Configuration:
    Many options that affect rendering and the window can be found in the file vmodeler-config.xml. This default configuration file must be in the same directory as the main jar file. All of the currently used options are defined to have a value in this file, most often with an explanatory comment. Alternate configuration files can be specified at runtime using the -config switch. Cameras and lights are specified via this file.
    I strongly suggest that you read all the comments and experiment with all the options in the "origin" node of the configuration file. This is one of the more counterintuitive sections of the file, but it's important, because the grid origin type is about the only thing you can use to get a solid reference on the comparative size of your models.
    Take heed of the fact that the axis lines for either origin display method are red, green, and blue. The red line is displayed along the X axis, the green line is the Y axis and the blue line is the Z axis. For "origin" type, each line points from the origin in the positive direction. For "grid" type, the darkened half of each line points in the negative direction.

Special Note About Source Code and Required Libraries
    The source to this library/application is available in The Deimos Project's main distribution archive. If you downloaded just the modeler, you only received binaries, API docs, some other miscellaneous files required to run and documnetation to explain how things work. You'll also need to obtain copies of JOGL and Janino. Please read this for more information.

Packaged Model Format:
    Regular Jar file
        Manifest.xml
            Holds data on the models and textures
        Models/ModelA.xml
        Models/ModelB.xml
        Textures/Tex1.png
        Textures/Tex2.png

Hosting for this project generously provided by: