Free uses opengl software for linux

OpenCSG project is a library that does image-based CSG rendering using OpenGL. OpenCSG is written in C++ and supports most modern graphics hardware using Microsoft Windows or the Linux operating system. OpenCSG-1.1.0 is the current version.
What is CSG, anyway? CSG is short for Constructive Solid Geometry and denotes an approach to model complex 3D-shapes using simpler ones. I.e., two shapes can be combined by taking the union of them, by intersecting them, or by subtracting one shape of the other. The most basic shapes, which are not result of such a CSG operation, are called primitives. Primitives must be solid, i.e., they must have a clearly defined interior and exterior. By construction, a CSG shape is also solid then.
Image-based CSG rendering (also z-buffer CSG rendering) is a term that denotes algorithms for rendering CSG shapes without an explicit calculation of the geometric boundary of a CSG shape. Such algorithms use frame-buffer settings of the graphics hardware, e.g., the depth and stencil buffer, to compose CSG shapes. OpenCSG implements a variety of those algorithms, namely the Goldfeather algorithm and the SCS algorithm, both of them in several variants.
Benefits:
CSG is often used as fundamental modeling technique in CAD/CAM applications. Here, image-based CSG rendering is the key to interactively manipulate CSG shapes. Since OpenCSG renders even complex CSG shapes fast, it can be advantageously used in such applications.
Raytracers such as PovRay have used CSG for shape modeling since long ago. Interactive modeling toolkits for such raytracers normally just ignore CSG commands, though. OpenCSG represents a valuable addition for such applications.
Overall, up to the present CSG rendering has been hardly used in interactive applications, since the necessary algorithms are complicated and error-prone. We hope that by providing a free library that is easy to use, fast, and versatile, CSG rendering can be made more mainstream than it currently is.
Usage:
The interface of OpenCSG is very easy to use. There is only a single abstract class called OpenCSG::Primitive. A Primitive object has an attribute Operation that denotes whether the primitive is intersected or subtracted. To use OpenCSG, create a derived concrete primitive class by implementing the render() method.
To actually do the CSG rendering, there is the function OpenCSG::render() that takes a std::vector as argument. The render function evaluates the CSG expression given by the array of primitives and initializes the z-buffer with the proper values for the CSG expression. The color buffer remains unchanged, so afterwards, you must shade the primitives in the array using a GL_EQUAL depth function.
Note that the render function does not evaluate a generic CSG tree that also would contain unions of CSG shapes. It has been shown that a generic CSG tree can be converted into an equivalent set of CSG expressions that the render function can handle. OpenCSG does not contain the functionality for this conversion since, after all, it is a rendering library.
Enhancements:
- OpenCSG can now use OpenGL frame buffer objects as an alternative to pbuffers to do the internal CSG rendering calculations.
- This potentially reduces the rendering overhead because no switching between different rendering contexts is required.
- Several other bugs have been fixed.

svgl is a library that displays SVG documents using OpenGL, taking advantage of the GPU.

Rendering:

A lot of svg 1.0 features are implemented: simples shapes, path, gradient, clipping, viewBox, opacity, < use >, animations etc.

Fonts are handled by the glft companion library, which allows for autoscaling according to the current scale, and automatic choice between vectorized glyphs or textures based on freetype2 rendering.

Texturized fonts are antialiased by freetype, while every other drawings are FSAA by OpenGL.

Next step is optimization by using various techniques like display list, culling, and cache rendering into textures.

Interacting:

Picking is provided under 2 forms:

- returns the deepest SVG element (leaf) corresponding to the shape designated by the user
- returns the stack of SVG elements under the cursor, so that UI techniques like toolglasses (see screenshot) is easily implemented

PanAndZoom done right (according to me...) : since its fast and usable, we can really use it in an interface

Tansform so-called "consolidation" (concatenation of transform matrices) allows easy implementation of scale-independant DnD.

Programming:

We try to make the api as simple as possible, for creating, manipulating, changing style, loading etc.

See demos/tutorial to see how to code with svgl.

A (pre-alpha) python extension allows for rapid application development and easy integration in wxPython.

OpenGL for Java, formerly known as GL4Java, supports Java with a native OpenGL mapping.
The OS native OpenGL functionality is avaiable from Java for many OS: Linux/GNU+XFree86, Unix/X11, MacOS, Win32.
Enhancements:
- removed the hack (which I put in sometime ago to get VooDoo3 working) that forced gl4java to choose a double buffered pixel format (the demos that used single buffer did not work) (thanks JYB)
- fixed the tessdemo and tesswind applets (thanks JYB).

Nelit2 Engine project is a game engine.
Nelit2 Engine is a game engine that uses a Model-View-Controller concept. All View-s classes was developed by me, and you can dont worrie about this.
Model-s classes also was developed by me, but you can modify it for your game or write new class and use Model class how abstract.
The engine uses some popular libraries such OpenGL and SDL.
It works on Unix systems and on Windows.
Enhancements:
- Decoding png, bmp, jpg texture-file.
- 3D mesh.
- Cubemap texturing.

StressFreeZone RPG project is a massive multiplatform RPG system.

StressFreeZone RPG is a multiplatform RPG system which runs on Linux and Windows (other systems are possible). The client is based on the SDL libraries and uses OpenGL.

The structure is server/client oriented, but the server will probably only run under Linux.

Minimal OpenGL Utility Library (MOGUL) is a library similar to GLUT, only with fewer features. It lets you write window-system-independent OpenGL programs with even fewer lines of code than GLUT.
The project currently supports X11 and Win32. Examples are included in the distribution. It is intended to be easy to learn and simple to use.
Enhancements:
- Compilation of the library has been successful under MS Windows 2000 (SP1) and Debian "sarge".
- However, it should compile on any Linux distribution.
- You may need to adjust the linker options if you are compiling under MS Windows XP or a more recent version of MinGW.

Drome Engine is a 3D game engine thats written in C++ and uses OpenGL for graphics rendering. Its currently under constant development; the main focus at this time is to improve and stabilize the application programming interface (API).