Free vrml software for linux

OpenVRML provides VRML97 and Classic VRML X3D parsers, a runtime, and an OpenGL renderer as C++ libraries. The renderer is fully separate from the runtime library so that users can also provide their own renderer.

Enhancements: Fixed resolution of the Java virtual machine library for ppc and ppc64.

Requirements:

• The Boost Libraries (required)
• Font Configuration Library (recommended)
• Freetype (recommended)
• GNU Compiler for Java (recommended)
• GTK+ (recommended)
• libjpeg (recommended)
• libpng (recommended)
• Mesa (recommended)
• Mozilla Firefox (recommended)
• Simple DirectMedia Layer (recommended)
• ANTLR (optional)
• Blackdown Java 2 Standard Edition for Linux (optional)
• IBM JDK for Linux (optional)
• Mozilla (optional)
• Sun Java 2 Platform, Standard Edition (optional)

XMud project is a distributed 3D MOO engine written in Java.
XMud is an extensible MUD, inspired by LambdaMOO and LPMUD. It allows users to extend the system at run-time by creating new objects.
Objects are Java classes that follow certain rules with respect to manipulating the state. It was designed with with scalability in mind; the system may be composed of N servers and M clients.
Each server is nothing more that a state manager that controls reading, writing, and locking state elements.
Methods are executed at the client level and generate state change requests that are sent to the server.
The current implementation of XMud provides the core infrastructure for server/server server/client communications, state management through object serialization and Mysql, a graphics engine written entirely in Java3D capable of importing VRML models, Never Winter Nights models, animation engine, particle system, and a very limited library of game objects including players and monsters based on the d20 rpg system.
Enhancements:
- Full support for NWN terrain tiles. You can now create a map with nwn toolset and import it into xmud.
- Added animation to avatars.
- Improved graphics engine performance by moving collision detection and terrain following to the cell level.
- Prioritized request/response queue at the client and server level.
- Position updater delay according to clients ping time.
- Limited the number of requests per client per second

BRL-CAD project is a powerful Constructive Solid Geometry (CSG) solid modeling system. BRL-CAD includes an interactive geometry editor, ray tracing support for rendering and geometric analysis, network distributed framebuffer support, image-processing and signal-processing tools. The entire package is distributed in source code form.
Since the late 1950s, computers have been used to assist with the design and study of combat vehicle systems. The result has been a reduction in the amount of time and money required to take a system from the drawing board to full-scale production as well as increased efficiency in testing and evaluation.
In 1979, the U.S. Army Ballistic Research Laboratory (BRL) (now the U.S. Army Research Laboratory [ARL]) expressed a need for tools that could assist with the computer simulation and engineering analysis of combat vehicle systems and environments. When no existing computer-aided design (CAD) package was found to be adequate for this purpose, BRL software developers began assembling a suite of utilities capable of interactively displaying, editing, and interrogating geometric models. This suite became known as BRL-CAD.
Now comprising over one-half million lines of C code, BRL-CAD has become a powerful constructive solid geometry (CSG) modeling package that has been licensed at over 2,000 sites throughout the world. It contains a large collection of tools, utilities, and libraries including an interactive geometry editor, raytracing and generic framebuffer libraries, a network-distributed image-processing and signal-processing capability, and a customizable embedded scripting language. In addition, BRL-CAD simultaneously supports dual interaction methods, one using a command line and one using a graphical user interface (GUI).
A particular strength of the package lies in its ability to build and analyze realistic models of complex objects using a relatively small set of "primitive shapes." To do this, the shapes are manipulated by employing the basic Boolean operations of union, subtraction, and intersection. Another strength of the package is the speed of its raytracer, which is one of the fastest in existence. Finally, BRL-CAD users can accurately model objects on scales ranging from the subatomic through the galactic and get "all the details, all the time."
The application side of BRL-CAD also offers a number of tools and utilities. They primarily concern (1) geometric conversion, (2) geometric interrogation, (3) image format conversion, and (4) command-line-oriented image manipulation. The following is a list of the major BRL-CAD tools and utilities.
- MGED (Multiple-Device Geometry Editor) ? BRL-CADs graphics editor. (For detailed guidance on the use of MGED as well as a list of all the MGED commands currently available, see Butler et al. [2001].)
- Tools for raytracing and interrogating raytraced geometric objects.
- rt ? the main raytracer for rendering images in BRL-CAD.
- nirt ? a package for firing rays interactively and getting information about what the rays run into.
- remrt ? a network-distributed raytracing package.
- An assortment of geometric converters to convert to and/or from other geometry formats, including Euclid, ACAD, AutoCAD DXF, TANKILL, Wavefront OBJ, Pro/ENGINEER, JACK (the human factors model for doing workload/usability studies), Viewpoint Data Lab, NASTRAN, Digital Equipments Object File Format (OFF), Virtual Reality Mark-up Language (VRML), Stereo Lithography (STL), Cyberware Digitizer data, and FASTGEN4.
- bwish ? a Tcl/Tk interpreter in a windowing shell with enhancements compiled into it for accessing BRL-CAD libraries. It also includes various other extensions to the Tcl language.
- irprep ? produces input to the PRISM (Physically Realistic Infrared Simulation Model) code.
- JOVE (Jonathans Own Version of Emacs) ? a fast, light implementation of Emacs.
- Applications for displaying images of various types on the framebuffer application and retrieving data from that framebuffer into images of various types.
- Tools for generating geometry for common objects such as fences, walls, and geometric mathematical oddities (e.g., the sphereflake shown in Figure 2 in Section 4).
- Data manipulation programs to (1) convert integers to floats, floats to doubles, etc. (e.g., cv); (2) perform mathematical operations on file elements (e.g., imod, umod, and dmod); (3) compute statistics of file elements (e.g., istat, ustat, and dstat); etc.
- Utilities for building animation scripts ? keeping track of columnar data and interpolating it to allow one to produce input to the rt program to render multiple items for animation.
- Utah Raster Tool Kit ? image manipulation of all RLE-based images.
- Programs for manipulating images and converting between different image file types. The two primary BRL-CAD types are pix (24-bit red, green, and blue [RGB] color images) and bw (8-bit greyscale images). Converters exist for various image formats including alias, png, ppm, etc.
- Programs for filtering images, doing histograms on the image data, and extracting rectangles from the images.
- Tools for combining two images and blending them together. (These tools were created before good image editing tools for video production were available; today users would typically load the images directly into a video editing package.)
Enhancements:
- fixed -i argument bug in g-acad, g-dxf, g-nff, g-obj - Shawn Baker
- framebuffer toggle added to raytrace panel in mged - Sean Morrison
- fixed rtedge multithreaded output render bug - Erik Greenwald
- fixed jove/termcap issues on Mac OS X - Sean Morrison
- updated bundled libtermcap to NetBSD version 0.6 - Sean Morrison
- increased output precision on mged analyze command - Sean Morrison
- prevent mged shutdown on DSP objects with no data - Sean Morrison
- integration into the Arch Linux packaging system - Loui Chang
- upgrade of bundled tcl/tk from 8.4.6 to 8.5a5 - Sean Morrison
- improved EOL processing in 70+ tools - Sean Morrison, John Anderson
- rewrote pixcmp providing improved I/O format options - Sean Morrison
- added new manual page for pixcmp utility - Sean Morrison
- updated bundled zlib to version 1.2.3 - Sean Morrison
- updated bundled libpng to version 1.2.16 - Sean Morrison
- fixed Windows line-ending bug in dxf-g - John Anderson
- g_qa manual page documents the -t tolerance option - Lee Butler
- updated bundled blt to blt2.4z-patch-2 - Sean Morrison
- dxf-g turns 2D entities into sketches instead of nmg - John Anderson
- removed advertising clause from BSD code - Sean Morrison
- fix index bug, allow material ID of zero in rtweight - Karel Kulhavy
- fixed multiple frame render bug in raytracers - Karel Kulhavy
- mged help command now shows help for all args listed - Sean Morrison

MayaVi is a free, easy to use scientific data visualizer. It is written in Python and uses the amazing Visualization Toolkit (VTK) for the graphics.
It provides a GUI written using Tkinter. MayaVi is free and distributed under the conditions of the BSD license. It is also cross platform and should run on any platform where both Python and VTK are available (which is almost any *nix, Mac OSX or Windows).
Main features:
- An easy to use GUI.
- Can be imported as a Python module from other Python programs and can also be scripted from the Python interpreter.
- Provides modules to:
- Visualize computational grids.
- Visualize scalar, vector and tensor data.
- Quite a few data filters are also provided.
- Supports volume visualization of data via texture and ray cast mappers.
- Support for any VTK dataset using the VTK data format. Works for rectilinear, structured, unstructured grid data and also for polygonal data. Both the original VTK data formats and the new XML formats are supported.
- Support for PLOT3D data. Only the binary structured grid format works because of current limitations in VTKs vtkPLOT3DReader. Simple support for multi-block data is also incorporated.
- Support for EnSight data. EnSight6 and EnSightGold formats are supported. Only single parts are supported at this time.
- Multiple datasets can be used simultaneously. Multiple modules can be viewed simultaneously.
- Support for data files belonging to a time series.
- A pipeline browser with which you can browse and edit objects in the VTK pipeline. A segmented pipeline browser is used to make it easier to look at parts of the VTK pipeline.
- Support for importing a simple VRML or 3D Studio scene. Texturing in VRML is not yet supported due to limitations in VTKs vtkVRMLImporter.
- A modular design so you can add your own modules and filters.
- A Lookup Table editor to customize your lookup tables easily while visualizing data!
- An interactive data picker that lets you probe your data interactively.
- A light manipulation kit that lets you modify the lighting of the visualization.
- The visualization (or a part of it) can be saved and reused in the future.
- Export the visualized scene to a Post Script file, PPM/BMP/TIFF/JPEG/PNG image, Open Inventor, Geomview OOGL, VRML files, Wavefront OBJ or RenderMan RIB files. It is also possible to save the scene to a vector graphic via GL2PS. This is only available if VTK is built with GL2PS support.
- And a lot more! MayaVi can be easily modified to do things differently.
Enhancements:
- This release added a new LUT editor, support for user defined sources, a vorticity filter, support for the VolumeProMapper, and support for VTK-CVS and VTK-5.x.
- A new utility script for searching the VTK documentation using a GUI was included.
- A severe bug in opening data files belonging to a time-series under Win32 was fixed.
- There were also other miscellaneous bugfixes and enhancements.

Libsball is a simple POSIX-based library for communicating with Spaceball 2003, 3000, 3003, and 4000 FLX six-degree-of-freedom motion control devices, via RS-232 serial ports on Unix-like systems.

Spaceballs are excellent controllers for CAD/CAM, scientific visualization, and general 3-D VR work. Libsball library makes it very easy for anyone to incorporate a spaceball into their work.

Applications which support the Spaceball (via LibSBall code)

Call for links! If youve written something cool that uses the Spaceball, send me a WWW link to your code or your WWW page and Id like add it to this list.
FreeWRL: VRML/X3D browser, FreeWRL input device driver
VMD: The molecular visualization program VMD uses libsball for all of its Unix versions.
White Dune VRML97 Editor: White Dune Home Page
VRPN: VRPN Home Page
FreeVR library: FreeVR Home Page
NCSA CAVE library: The NCSA version of the CAVE library incorporates a modified version of the libsball code.
Tachyon parallel ray tracer: Ive written an OpenGL previewer and a spaceball-fly feature for Tachyon which allows you to fly around in a scene using the Spaceball. Its done using a first-person view, and was the code I simplified in order to write the "sballfly" demo which is included with libsball.

mesh2hmap is a simple command line tool for converting 3D meshes to raster heightmaps. mesh2hmap project tool allows you to create terrains in your favourite 3D modeller and then easily convert to a heightmap.
This tool was created for generating terrains in games such as Legends (a Tribes inspired First Person Shooter) and Planet Penguin Racer (the GPLed branch of TuxRacer). However, it can be used in any application that uses heightmaps.
Installation:
This is a very simple program that only uses standard headers and the math library. Therefore you dont need to add any include dirs and you only need to link to the math library.
To compile this program under linux, enter in a console:
$ gcc -o mesh2hmap mesh2hmap.c -lm
This program doesnt contain any exotic function calls or hardware specific magic (I think), so it should compile without any problems on different hardware and Operating Systems. If you get any compilation errors or warnings, report them (see SUPPORT).
Enhancements:
- Makefiles were fixed to work with GCC 4.x.
- The VRML parser was rewritten so that it can handle DEF/USE keywords.

Argyll is an experimental ICC-compatible color management system. Argyll Color Management System supports accurate ICC profile creation for scanners, CMYK printers, film recorders, and display monitors.
Spectral sample data is supported, allowing a selection of illuminants observer types, and paper fluorescent whitener additive compensation. Profiles can also incorporate source-specific gamut mappings for perceptual and saturation intents.
Gamut mapping and profile linking uses the CIECAM02 appearance model, a unique gamut mapping algorithm, and a wide selection of rendering intents.
It also includes code for a fast, portable 8-bit raster color conversion engine, as well as support for fast, fully accurate 16-bit conversion. Device color gamuts can also be viewed and compared using a VRML viewer.
Enhancements:
- Support for the USB-based X-Rite DTP94 (AKA Optix) display colorimeter.
- Comprehensive display control adjustment and calibration support.
- Full multi-monitor support for display adjustment, calibration, and profiling on all supported operating systems (MS Windows, OS X, and Linux/X11). Numerous bugfixes, and many minor feature additions and improvements.