Free 3d graphics software for linux

Mesa is a 3-D graphics library with an API which is very similar to that of OpenGL. To the extent that Mesa utilizes the OpenGL command syntax or state machine, it is being used with authorization from Silicon Graphics, Inc.(SGI). However, the author does not possess an OpenGL license from SGI, and makes no claim that Mesa is in any way a compatible replacement for OpenGL or associated with SGI. Those who want a licensed implementation of OpenGL should contact a licensed vendor.
Please do not refer to the library as MesaGL (for legal reasons). Its just Mesa or The Mesa 3-D graphics libraryand thats all.
Enhancements:
New features
- OpenGL 2.0 and 2.1 API support.
Bug fixes
- Fixed a few fog-related bugs.
- Fixed broken GLSL mix() function.
- Fixed broken GLSL exp() functions.
- Fixed GLSL mod4(vec4, vec4) bug.
- Implemented GLSL asin(), acos(), atan() functions.
- Fixed an R300 driver bug that caused Xorg composite manager to crash
- Fixed R300 vertex program/matrix bug (10848)
- GLSL dFdx() and dFdy() work for fragment program inputs now (texcoords)
- Specifying an invalid texture unit as a sampler could lead to a crash
- The GLX protocol request for glXDestroyPBuffer() was incorrect (bug 10983)
- ARB vp state.light[n].half value was incorrect (bug 10987)
- Fixed a positional light source bug (bug 11009)
- Fixed point size attenuation problem (bug 11042)
- glPopAttrib didnt restore texture objects LOD bias (bug 11049)
- Fixed a TLS / TEXTREL problem (bug 7459)
Internal code changes
- Some texture code consolidation and simplifiction (Ian Romanick)
- R300 driver clean-ups.
Driver Status
- Driver Status
---------------------- ----------------------
- DRI drivers varies with the driver
- XMesa/GLX (on Xlib) implements OpenGL 2.1
- OSMesa (off-screen) implements OpenGL 2.1
- Windows/Win32 implements OpenGL 2.1
- Glide (3dfx Voodoo1/2) implements OpenGL 1.3
- SVGA unsupported
- Wind River UGL unsupported
- DJGPP unsupported
- GGI unsupported
- BeOS unsupported
- Allegro unsupported
- D3D unsupported

Graphico is an open source 3D graphics application programming interface.

Graphico works with either Java or C++. The design of Graphico is based on OpenGL. Two independent Java versions of Graphico exist. The first version renders to a Java image that can be displayed in a Java application or any internet browser capable of executing Java 1.1 code. The second version uses Java 3D for increased performance. The C++ version uses OpenGL.

The different versions of Graphico are known as:

GoJava

This version uses Java to do all of the rendering. The Java 3D extension is not utilized. Using this version of Graphico allows for displaying in any browser capable of executing Java 1.1 code, which includes Internet Explorer and Netscape. With this version of Graphico it is possible to integrate Graphico into HTML documents. Since this version is the most portable and integrates well with the internet, all examples with this distribution use this version of Graphico. While this version is suitable for many things, it is not suitable for rendering complex large scenes at high animation frame rates. When better animation performance is required, the same Java applet/application can run with the GoJava3D implementation of Graphico.

GoJava3D

This version makes use of Java 3D. If you have have special 3D graphics hardware and an implementation of Java 3D that is set up to work with the graphics hardware, then this is the best way to run a Graphico applet/application. With this version it is more difficult to reach all internet users with Graphico graphics and to incorporate Graphico into an HTML document, which is why the GoJava implementation exists.

GoCpp

This version is a C++ version that uses OpenGL as the Graphico rendering engine. It serves as an easy way to move Graphico graphics code between Java and C++. This version is not implemented with any special GUI (Graphical User Interface) in mind. While all the C++ example in this distribution use the GLUT (OpenGL Utility Toolkit) via GoGlutInterface, it is not necessary to do so. Just like OpenGL, Graphico leaves all GUI specific code up to the programmer.

PDL::Graphics::TriD is a PDL 3D interface.

SYNOPSIS

use PDL::Graphics::TriD;

# After each graph, let the user rotate is and # wait for him to press q, then make new graph line3d($coords); # $coords = (3,n,...) line3d($coords,$colors); # $colors = (3,n,...) line3d([$x,$y,$z]); imagrgb([$r,$g,$b]); lattice3d([$x,$y,$z]); # 2-d piddles points3d([$x,$y,$z]);
hold3d(); # the following graphs are on top of each other and the previous line3d([$x,$y,$z]); line3d([$x,$y,$z+1]); $pic = grabpic3d(); # Returns the picture in a (3,$x,$y) float piddle (0..1).
release3d(); # the next graph will again wipe out things.

WARNING

These modules are still in a somewhat unfocused state: dont use them yet if you dont know how to make them work if they happen to do something strange.

This module implements a generic 3D plotting interface for PDL. Points, lines and surfaces (among other objects) are supported.

With OpenGL, it is easy to manipulate the resulting 3D objects with the mouse in real time - this helps data visualization a lot.

The Graphics Muse Tools are a collection of plug-ins and scripts for use with GIMP. The package now includes a set of C plugins (GFXArrows, GFXCards, GFXTrans, GFXLayers, GFXMerge, and GFXShapes) and a set of Perl scripts (GFXDodge, GFXGallery, GFXLayerSave, and GFXLayerOffsets).

Bio::Graphics::FeatureFile is a set of Bio::Graphics features, stored in a file.

SYNOPSIS

use Bio::Graphics::FeatureFile;
my $data = Bio::Graphics::FeatureFile->new(-file => features.txt);


# create a new panel and render contents of the file onto it
my $panel = $data->new_panel;
my $tracks_rendered = $data->render($panel);

# or do it all in one step
my ($tracks_rendered,$panel) = $data->render;

# for more control, render tracks individually
my @feature_types = $data->types;
for my $type (@feature_types) {
my $features = $data->features($type);
my %options = $data->style($type);
$panel->add_track($features,%options); # assuming we have a Bio::Graphics::Panel
}

# get individual settings
my $est_fg_color = $data->setting(EST => fgcolor);

# or create the FeatureFile by hand

# add a type
$data->add_type(EST => {fgcolor=>blue,height=>12});

# add a feature
my $feature = Bio::Graphics::Feature->new(
# params
); # or some other SeqI
$data->add_feature($feature=>EST);

The Bio::Graphics::FeatureFile module reads and parses files that describe sequence features and their renderings. It accepts both GFF format and a more human-friendly file format described below. Once a FeatureFile object has been initialized, you can interrogate it for its consistuent features and their settings, or render the entire file onto a Bio::Graphics::Panel.

This moduel is a precursor of Jason Stajichs Bio::Annotation::Collection class, and fulfills a similar function of storing a collection of sequence features. However, it also stores rendering information about the features, and does not currently follow the CollectionI interface.

Physics 3D project is a 3D physics simulation program.

It simulates gravitational attraction, momentum, and collisions of rigid bodies.

It is written using Java and the Java3D API.

3D Pong project is a simple Xlib vector-based ping-pong game.
3D Pong is is a very small and fast ping-pong or handball game for one or two players. It uses simple 3D vector graphics in Xlib.
Multiple views are possible, and red/blue separation is available for users with 3D movie glasses.
Main features:
Game Play:
- 1 player against the computer
- 1 player in "handball" mode
- 2 players, networked
- User-defined gravity level
- With or without a deflective "net"
Display Modes:
- Red/Blue split mode for true 3D using 3D glasses!!!
- Six viewing positions:
- First Person POV from behind your paddle
- "Bleacher" view from the side of the game arenta.
- Above view.
- Freely rotatable mode (using the mouse)
- A dizzying "follow the ball" mode
- Follow the paddle mode