Free 3d model editor software for linux

Vertex 3D Model Assembler project is a polygon-based live-end modeller.

The Vertex 3D Model Assembler is a 3D modeller geared towards making high performance models for games and other live-end requirements.

It uses the V3D format to maximize efficiency with OpenGL rendering, and can view/edit any V3D hybrid data.

Misfit Model 3D is an OpenGL-based 3D model editor that works with triangle-based models. Misfit Model 3D supports multi-level undo, skeletal animations, simple texturing, scripting, command-line batch processing, and a plugin system for adding new model and image filters.
Complete online help is included. It is designed to be easy to use and easy to extend with plugins and scripts.
Misfit Model 3D was written and tested on Linux (2.4 and 2.6 kernels) and has been compiled and tested on most major Linux distributions.
It is not endian-safe so it is unlikely to run on non-x86 hardware platforms--this will probably not change soon unless I get requests for a version thats usable on big-endian archs.
Enhancements:
- The menus have been re-organized. There is a new command to make normals face outward. The texture coordinate window now has a rotate tool. Material support for COB has been improved. Many animation bugs have been fixed. A "File | Export" command has been added to indicate which formats have less reliable write support.

Query-Oriented Model for XML is a lightweight XML processing framework for Java that promotes the use of XPath instead of Java code for consuming XML.

The resulting code from Query-Oriented Model for XML, is simple and expressive with no meaningless objects and no meaningless parameters - just pure business code.

Heres a sample of usage (from a testcase -- heres the used XML document):

public class BigTest extends TestCase {
public static final String[] CONTEXT = {"c urn:catalog", "n urn:name"};

@QUseContext("CONTEXT") // Use the namespace context specified by the CONTEXT field.
public void test() {

InputStream xml = QomTestResources.getTestXml("catalog.xml"); // Get the source.

QLocation root = new QBuilder().build(xml); // Build the root location.

// Test a deep query.
Assert.assertEquals("Harold", root.value("//c:maintainer/n:name[n:first_name = Elliotte]/n:last_name"));


QLocation[] composers = root.locateAll("c:composer"); // Test a multi-query.

Assert.assertEquals(4, composers.length);

String[] names = {"Julie", "Margaret", "Beth", "Linda"};

for (int i = 0; i < composers.length; ++i) {

Assert.assertEquals(names[i], composers[i].value("n:name/n:first_name")); // Test relative queries.

}
}
}

Installation: The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system.
2. Running `configure might take a while. While running, it prints some messages telling which features it is checking for.
3. Type `make to compile the package.
4. Optionally, type `make check to run any self-tests that come with the package.
5. Type `make install to install the programs and any data files and
6. documentation.
7. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make disclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

Config::Model provides a framework to help in validating the semantic content of configuration data. The project can also be used to provide a semantic check of options of a complex program like mplayer or transcode.
For most complex software, configuration upgrade is a difficult task for most people. By using Config::Model, a software can provide a smooth upgrade path for their users.
How does this work ?
Using this project, a typical configuration validation tool will be made of 3 parts :
The user interface
The validation engine which is in charge of validating all the configuration information provided by the user.
The storage facility that store the configuration information
Dont we already have some configuration validation tools ?
Youre probably thinking of tools like webmin. Yes, these tools exist and work fine, but they have their set of drawbacks.
Usually, the validation of configuration data is done with a script which performs semantic validation and often ends up being quite complex (e.g. 2500 lines for Debians xserver-xorg.config script which handles xorg.conf file).
In most cases, the configuration model is expressed in instructions (whatever programming language is used) and interspersed with a lot of processing to handle the actual configuration data.
Whats the advantage of this project ?
The Config::Model projects provide a way to get a validation engine where the configuration model is completely separated from the actual processing instruction.
The configuration model is expressed in a declarative form (i.e. a Perl data structure) which is always easier to maintain than a lot of code.
The declaration specifies:
the structure of the configuration data (which can be queried by generic user interfaces)
the properties of each element (boundaries, check, integer or string, enum like type ...)
the default values of parameters (if any)
mandatory parameters
the targeted audience (intermediate, advance, master)
on-line help (for ach parameter or value of parameter)
the level of expertise of each parameter (to hide expert parameters from newbie eyes)
So, in the end:
maintenance and evolution of the configuration content is easier
user will see a *common* interface for *all* programs using this project.
user will not see advanced parameters
upgrade of configuration data is easier and sanity check is performed
audit of configuration is possible to check what was modified by the user compated to default values
What about the user interface ?
Config::Model will also come with a Curses::UI interface that queries the users model and generate the relevant user screens.
What about data storage ?
Since the syntax of configuration files vary wildly form one program to another, most people who want to use this framework will have to provide a dedicated parser/writer.
Nevertheless, this project can also provide a writer/parser for most common format: like ini style file, or provide an interface to the Elektra or debconf projects. This point is open for discussion.
It is entirely possible for a single configuration model to use several parsers and writers so one model will ensure the consistency of several configuration files together.
Enhancements:
- The Xorg model was updated to Config::model version 0.609.
- Some bugs were fixed.

3D Python OpenGL Chess Game project is a 3D chess game in Python with OpenGL.

3D Python OpenGL Chess Game is a normal chess game that has no computer player (yet). You can play against a friend on your PC.