Free descent 2 opengl software for linux

XML::Descent is a Perl module for recursive descent XML parsing.

SYNOPSIS

use XML::Descent;

# Create parser
my $p = XML::Descent->new({
Input => $xml
});

# Setup handlers
$p->on(folder => sub {
my ($elem, $attr) = @_;

$p->on(url => sub {
my ($elem, $attr) = @_;
my $link = {
name => $attr->{name},
url => $p->text()
};
$p->stash(link => $link);
});

my $folder = $p->walk();
$folder->{name} = $attr->{name};

$p->stash(folder => $folder);
});

# Parse
my $res = $p->walk();

The conventional models for parsing XML are either DOM (a data structure representing the entire document tree is created) or SAX (callbacks are issued for each element in the XML).

XML grammar is recursive - so its nice to be able to write recursive parsers for it. XML::Descent allows such parsers to be created.

Typically a new XML::Descent is created and handlers are defined for elements were interested in

my $p = XML::Descent->new({ Input => $xml });
$p->on(link => sub {
my ($elem, $attr) = @_;
print "Found link: ", $attr->{url}, "n";
$p->walk(); # recurse
});
$p->walk(); # parse

A handler provides a convenient lexical scope that lasts until the closing tag of the element that triggered the handler is reached.

When called at the top level the parsing methods walk(), text() and xml() parse the whole XML document. When called recursively within a handler they parse the portion of the document nested inside node that triggered the handler.

New handlers may be defined within a handler and their scope will be limited to the XML inside the node that triggered the handler.

Parse::RecDescent is a Perl module to generate Recursive-Descent Parsers.
SYNOPSIS
use Parse::RecDescent;
# Generate a parser from the specification in $grammar:
$parser = new Parse::RecDescent ($grammar);
# Generate a parser from the specification in $othergrammar
$anotherparser = new Parse::RecDescent ($othergrammar);
# Parse $text using rule startrule (which must be
# defined in $grammar):
$parser->startrule($text);
# Parse $text using rule otherrule (which must also
# be defined in $grammar):
$parser->otherrule($text);
# Change the universal token prefix pattern
# (the default is: s*):
$Parse::RecDescent::skip = [ t]+;
# Replace productions of existing rules (or create new ones)
# with the productions defined in $newgrammar:
$parser->Replace($newgrammar);
# Extend existing rules (or create new ones)
# by adding extra productions defined in $moregrammar:
$parser->Extend($moregrammar);
# Global flags (useful as command line arguments under -s):
$::RD_ERRORS # unless undefined, report fatal errors
$::RD_WARN # unless undefined, also report non-fatal problems
$::RD_HINT # if defined, also suggestion remedies
$::RD_TRACE # if defined, also trace parsers behaviour
$::RD_AUTOSTUB # if defined, generates "stubs" for undefined rules
$::RD_AUTOACTION # if defined, appends specified action to productions
Parse::RecDescent incrementally generates top-down recursive-descent text parsers from simple yacc-like grammar specifications.
Main features:
- Regular expressions or literal strings as terminals (tokens),
- Multiple (non-contiguous) productions for any rule,
- Repeated and optional subrules within productions,
- Full access to Perl within actions specified as part of the grammar,
- Simple automated error reporting during parser generation and parsing,
- The ability to commit to, uncommit to, or reject particular productions during a parse,
- The ability to pass data up and down the parse tree ("down" via subrule argument lists, "up" via subrule return values)
- Incremental extension of the parsing grammar (even during a parse),
- Precompilation of parser objects,
- User-definable reduce-reduce conflict resolution via "scoring" of matching productions.

3D-Desktop is an OpenGL program for switching virtual desktops in a seamless 3-dimensional manner on Linux. The current desktop is mapped into a fullscreen 3D environment where you may choose other screens. Several different visualization modes are available.

The transition from working desktop to fullscreen 3D environment is seamless. In other words when the pager activates you see your current desktop appear to zoom out to a point in space where you can see your other virtual desktops allowing you to select another. The best way to understand is to try it out and get the full effect!

GLT OpenGL C++ Toolkit 0.7 project contains classes and routines for programming interactive 3D graphics with OpenGL.
The aim of Glt is to augment the OpenGL API with convenient mechanisms for manipulating the OpenGL state machine.
Glt is a work in progress, and by no means covers the entire OpenGL specification. However, it already includes several useful classes and is designed so that additional classes can be added easily. In addition to Glt, the GlutMaster classes provide C++ wrappers for the GLUT API.
Main features:
- GltFrameBuffer
- Read and write from frame buffer
- Save to PPM, TGA, BMP or PNG image files
- GltFrameBufferRGB
- GltFrameBufferZ
- GltFrameBufferStencil
- GltColor
- RGBA Color
- Over 600 predefined colors
- Color interpolation and arithmetic
- GltTexture
- Read from PPM, TGA, BMP or PNG image files
- Automatic texture binding
- Support for compressed compiled textures
- Support for procedural textures
- GltFont
- GltFontAscii Bitmapped ASCII font. Ten fonts included.
- GltFontUnicode Bitmapped Unicode font. Includes English, Chinese, Japanese and Korean.
- Vector, Matrix, Plane and BoundingBox
- Vector math functions: dot and cross products and arithmetic
- Transformation matrices, inverse, transpose and determinant
- Plane equation evaluation, ray-plane intersection
- Full OpenGL integration
- Random Number Generation
- GltRandomLCG Park and Miller LCG generator
- GltRandomLFSRMix Linear Feedback Shift Register generator
- GltRandomDouble, GltRandomInteger with configurable range
- GltRandomSphere point-on-sphere generator
- GltRandomOrientation orientation frame generator
- GltLight OpenGL Light Source.
- GltLightModel OpenGL Lighting Model.
- GltMaterial OpenGL Material Settings.
- OpenGL Matrix Manipulation
- GltOrtho Orthographic Projection.
- GltTextOverlay Text-box overlay.
- GltViewport Viewport settings.
- GltShape Scenegraph node class
- Transformation matrix
- Predefined shapes: GlutSphere,GlutCube,GlutCylinder, etc...
- GltShapes container class

Games::OpenGL::Font::2D module can load/render 2D colored bitmap fonts via OpenGL.

SYNOPSIS

use Games::OpenGL::Font::2D;

my $font = Games::OpenGL::Font::2D->new(
file => font.bmp );

use SDL::App::FPS;

my $app = SDL::App::FPS->new( ... );

# dont forget to change these on resize events!
$font->screen_width( $app->width() );
$font->screen_height( $app->width() );

$font->pre_output(); # setup rendering for font

$font->color( [ 0,1,0] ); # yellow as array ref
$font->color( 1,0,0 ); # or red
$font->alpha( 0.8 ); # nearly opaque

# half-transparent, red
$font->output (100,100, Hello OpenGL!, [ 1,0,0], 0.5 );
# using the $fonts color and alpha
$font->output (100,200, Hello OpenGL! );

$font->transparent( 1 ); # render font background transparent

$font->spacing_y( 16 ); # render vertical (costly rebuild!)
$font->spacing_x( 0 ); # (costly rebuild!)
$font->output (100,200, Hello OpenGL! );

$font->post_output(); # if wanted, you can reset OpenGL

EXPORTS

Exports nothing on default. Can export on demand the following:

FONT_ALIGN_LEFT
FONT_ALIGN_RIGHT
FONT_ALIGN_CENTER
FONT_ALIGN_TOP
FONT_ALIGN_BOTTOM

Landscape is a program that creates and renders fractal landscapes, with an interactive OpenGL preview of the final image.
Enhancements:
- This minor update fixes compilation under Linux and (fingers crossed) the occasional crash during rendering some people were experiencing.

Into Cerberon :: Descent Into Doom is a Descent style mod for Doom3.

Into Cerberon is a mod for Doom 3 that will bring the six-degrees-of-freedom action of the classic FPS game series Descent into the high-powered graphics engine of Doom 3.

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.