Free sparco steering wheels software for linux

SpacePong is an innovative game that is controlled with the mouse. The gameplay involves steering your spacecraft ball around the screen and picking up speed by bouncing off the walls. The goal is to collect a certain amount of space boxes in a short time.
Enhancements:
- New sounds and music were added.
- A moving stars effect in the background was implemented.
- Packages for Debian and Mandriva were added.

POCO C++ Libraries project are the next generation C++ class libraries for network-centric applications.

POCO, the C++ Portable Components, is a collection of open source C++ class libraries that simplify and accelerate the development of network-centric, portable applications in C++. The libraries integrate perfectly with the C++ Standard Library and fill many of the functional gaps left open by it.

Their modular and efficient design and implementation makes the C++ Portable Components extremely well suited for embedded development, an area where the C++ programming language is becoming increasingly popular, due to its suitability for both low-level (device I/O, interrupt handlers, etc.) and high-level object-oriented development. Of course, POCO is also ready for enterprise-level challenges.

The POCO libraries free developers from re-inventing the wheel, and allow them to spend their time on more worthwhile areas, such as getting things done quickly and working on the features that make their application unique.

POE::Wheel::Audio::Mad is a POE Wheel implementing in-session non-blocking mpeg stream playing.

SYNOPSIS

use POE;
use POE::Wheel::Audio::Mad;

POE::Session->create(
inline_states => {
_start => &am_start,
message => &am_message
}
);

sub am_start {
my ($kernel, $heap) = @_[KERNEL, HEAP];

## you may also specify decoder options, listed below..
$heap->{wheel} = new POE::Wheel::Audio::Mad ( message_event => message );

$kernel->yield( decoder_open, {
filename => /path/to/some/stream.mp3,
play => 1
});
}

sub am_message {
my ($kernel, $message) = @_[KERNEL, ARG0];

if ($message->{id} eq INPUT_EOF_WARNING) {

print "finished..n";

undef $heap->{wheel};

} elsif ($message->{id} eq DECODER_FRAME_DATA) {

if (defined($message->{data}->{played})) {

print "rplayed: $message->{data}->{played}";

}
}
}

$poe_kernel->run();
exit();

POE::Wheel::Audio::Mad is an attempt to bring a naitive perl mpeg decoder into a perl session. This module was written to work as a POE Wheel due to its nature -- it simply playes mpeg streams -- you have to do the job of controlling the player and handling updates. This really isnt your traditional wheel.

Class::Container is a Perl module with Glues object frameworks together transparently.

SYNOPSIS

package Car;
use Class::Container;
@ISA = qw(Class::Container);

__PACKAGE__->valid_params
(
paint => {default => burgundy},
style => {default => coupe},
windshield => {isa => Glass},
radio => {isa => Audio::Device},
);

__PACKAGE__->contained_objects
(
windshield => Glass::Shatterproof,
wheel => { class => Vehicle::Wheel,
delayed => 1 },
radio => Audio::MP3,
);

sub new {
my $package = shift;

# windshield and radio objects are created automatically by
# SUPER::new()
my $self = $package->SUPER::new(@_);

$self->{right_wheel} = $self->create_delayed_object(wheel);
... do any more initialization here ...
return $self;
}

This class facilitates building frameworks of several classes that inter-operate. It was first designed and built for HTML::Mason, in which the Compiler, Lexer, Interpreter, Resolver, Component, Buffer, and several other objects must create each other transparently, passing the appropriate parameters to the right class, possibly substituting other subclasses for any of these objects.

The main features of Class::Container are:

Explicit declaration of containment relationships (aggregation, factory creation, etc.)
Declaration of constructor parameters accepted by each member in a class framework
Transparent passing of constructor parameters to the class that needs them
Ability to create one (automatic) or many (manual) contained objects automatically and transparently

pslange project is a ncurses-based clone of the game snake.
pslange is a clone of an old classic game otherwise known as snake or nibbles.
The object of the game is to steer the snake around the screen eating the food that pops up. Every time the snake eats something it grows. If the snake hits an obstacle either itself or the wall, the game ends.
I wrote pslange as a small learning project in order to learn python. It may not be the most advanced game but I belive it is an entertaining way to spend a few minutes. :-)
Since it does have several features common to many python based command line tools, it may be useful to some people as an example on how to do these things in python.
Main features:
- Internationalization - also known as I18N.
- Python setup.
- Command line handling using the module optparse.
- Using the python curses interface.

IMWheel is a daemon for X11, which watches for mouse wheel actions and outputs them as keypresses.

This is a not so short little ditty that does the simple conversion of mouse button presses into key presses. By grabbing only the 4th and 5th mouse buttons the program is able to receive input from the Intellimouse series mice.

There is also a modified version of gpm included that has, already, support for the Intellimouse, and I added a wheel fifo. The user library may also be used, although this may need to be debugged. See the gpm section below for more.

The wheel button can always be used as middle button, this program does not affect how the XServer, nor GPM, react towards it. A mouse with a wheel button is a 3 button mouse, and should be configured as such!

Installation:

The `configure shell script attempts to guess correct values for various system-dependent variables used during compilation.

It uses those values to create a `Makefile in each directory of the package. It may also create one or more `.h files containing system-dependent definitions.

Finally, it creates a shell script `config.status that you can run in the future to recreate the current configuration, a file `config.cache that saves the results of its tests to speed up
reconfiguring, and a file `config.log containing compiler output (useful mainly for debugging `configure).

If you need to do unusual things to compile the package, please try to figure out how `configure could check whether to do them, and mail diffs or instructions to the address given in the `README so they can be considered for the next release.

If at some point `config.cache contains results you dont want to keep, you may remove or edit it.

The file `configure.in is used to create `configure by a program called `autoconf. You only need `configure.in if you want to change it or regenerate `configure using a newer version of `autoconf.

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.

If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. 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 distclean.

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.

Racer is a free car simulation project, using real car physics to get a realistic feeling. Cars, tracks, scenes and such can be created with relative simplicity in mind (compared to other driving simulations).
The 3D and other file formats are, or should be, documented. Editors and support programs are also available to get a very flexible and expandable simulator. It uses OpenGL for rendering.
It attempts to do well at the physics section, trying to create life-like cars to emphasize car control and doesnt cut back on realism in the interest of fun. If youve played Grand Prix Legends from Papyrus, youll know what Im talking about.
Racer major features:
- Its totally free! (for non-commercial use)
- Available for multiple platforms; Windows 2000/XP (95/98/ME may work but have some trouble with fonts), Linux and Mac OS X.
- 6 DOF models used (the car can move around freely)
- Uses motion formulae from actual engineering documents from SAE for example.
- Total flexibility; almost everything is customizable through ASCII files.
- Commercial-quality rendering engine (with smoke, skidmarks, sparks, sun, flares, vertex-color lit tracks).
- Support for Matrox Surround Gaming. See the corresponding page on Matrox site.
- Lots of addon cars and tracks available on the web.
- Easy integration of your own cars and tracks that you create in ZModeler, 3D Studio Max(tm), Maya etc.
- At least 15 degrees of freedom for a regular car (6 DOF for the car body, 1 for each wheels vertical motion and 1 for each wheel spinning, and 1 for the engine, several more for the driveline). Depending actually on how many wheels you put on the car.
- Real-time internal clock; no physical dependency on framerate. Controller updates are also done independently of the framerate.
- Not limited to 4 wheels; anything from 2 to 8 wheel vehicles are currently supported (but mostly untested, and some problems with hardcoded differentials for example may exist (v0.5.0)).
- Not much constraints on the track data; surface info is taken from polygon data (VRML tracks), and splines are used to smooth out the track surface (polygons are too harsh for driving on just like that).
- Tools to modify the cars & tracks are freely available on this site (though external utilities are recommended for best results).
- Some used algorithms are explained on this site. Also, references are available. If you are programming a carsim, you might find something useful here.
- Save game present!
Main features:
PHYSICS FEATURES
- Full 6 degree of freedom motion of the car chassis.
- Independent suspension for all wheels.
- Suspension features: springs, dampers, anti-rollbar, rollcenter, anti-pitch.
- Wheel features: camber, wheel hop (the wheels have mass), toe.
- Tires: Pacejka tire model, relaxation length.
GRAPHICS FEATURES
- View frustum culling for increased framerate.
- Shader system for Quake-style rendering.
- Fog definable per track.
- Environment mapping for shiny materials.
- Live track environment mapping.

Growler is a C++-based distributed object and event architecture. It is written in C++, and supports serialization of C++ objects as part of its Remote Method Invocation, Event Channels, and in its Interface Definition Language.

Its primary application has been in support of interactive, distributed and collaborative visualization, computational steering, and concurrent visualization.

IDL example:

Growler has an Interface Definition Language (IDL) for generating stub/skeletion code for distributed communications. Growlers IDL is one of its most unique features. The interface definition language for Growler is called PIDL: The Parsifal Interface Definition Language.

Here are some example PIDL files:

This eventchannel definition is used for distributing field data from a live fvGCM run:

%cinclude < lib/buffer.h >
%cinclude < lib/vector.h >
%cinclude < lib/array.h >
%cinclude < lib/utility.h >

enum { DataVectorPort = 10100 };

typedef lib::Array< uint32_t,3 > dimarray;

struct MetaData {
int32_t lat, lon;
uint32_t nymd, nhms;
uint32_t pdt;
uint32_t nsteps;
uint32_t stride;
std::vector fields;
}

eventport DataVectorChannel
{
metadata(MetaData mdat) state;
datavec[16](lib::Vector< float > dv);
}

This is the cpumon.pidl specification used by NodeMon for distributing cpu statistics:
%import < nodemon/nodemon.pidl >
%cinclude < lib/vector.h >

/*
* About /proc/stat:
*

The very first "cpu" line aggregates the numbers in all of the other "cpuN"
lines. These numbers identify the amount of time the CPU has spent performing different kinds of work. Time units are in USER_HZ (typically hundredths of a second). The meanings of the columns are as follows, from left to right:

- user: normal processes executing in user mode
- nice: niced processes executing in user mode
- system: processes executing in kernel mode
- idle: twiddling thumbs
- iowait: waiting for I/O to complete
- irq: servicing interrupts
- softirq: servicing softirqs
*/

struct CPUData {
uint32_t v[7]; // the seven columns
}

// CPUDataVector: array of cpu data rows from /proc/stat
typedef std::vector< CPUData > CPUDataVector;

typedef std::vector< uint32_t > CPUSetVector;
typedef std::vector< std::string > CPUSetNameVector;

eventport CPUMonChannel
{
cpu_data(CPUDataVector) nonqueued;
cpuset_data(CPUSetVector) state;
cpuset_names(CPUSetNameVector) state;
}

port CPUMon : nodemon::NodeMonAgent
{
CPUMonChannel_ptr getMonChannel(out uint32_t cpucount);
}