Free 3d 0.09 software for linux

Goo - stick things together with The Goo.

SYNOPSIS

shell> goo -p Object.pm # show a [P]rofile of Object.pm
shell> goo -l Object.pm # show Back [L]inks to Object.pm
shell> goo -r Object.pm # [R]un Object.pm
shell> goo -i Object.pm # comp[I]le Object.pm
shell> goo -p access.log # show a [P]rofile of access.log
shell> goo -c Object.pm # [C]lone Object.pm into another Thing
shell> goo -o # the Care[O]Meter shows Things you care about while coding (e.g., tasks, bugs)
shell> goo -z # show Things in your working [Z]one or mental buffer

"The Goo" helps you stick "Things" together in your working environment.
Things include Perl modules, Perl scripts, log files, javascripts, configuration files, database tables, templates etc.

The Goo records a "Trail" as you jump quickly from Thing to Thing in a simple, text-based console. It remembers how you associate Things in your environment.

Accelerate your work by quickly traversing the Trail of associations between Things.

METHODS

check_environment

Check and set up the environment.

do_action

Take a command line switch (e.g., -p) and map it to an action handler (e.g., [P]rofile) and perform the action on the Thing.

Soya 3D is a high level 3D engine for Python. It relies on OpenGL, SDL and Cal3D. Soya 3D project is designed with games in mind, focusing both on performance and ease-of-use.
Soya 3D is available under the GPL and currently runs on GNU/Linux, though ports to other OS are planned (Mac OS X, windows,...) since it uses only portable libraries.
Main features:
- Multi-plateform : Linux / Unix, MacOSX, Windows
- Object model, including camera, light, world, volume,...
- Particle systems
- Fullscreen
- Tutorials and demos included
- Trees
- Raypicking
- Landscapes
- 3D character animation (with Cal3D)
- Exportation scripts for Blender, Obj/Mtl, Maya and 3DSmax
- Event management (keyboard, mouse,...)
- Cell-shading
- Shadows
- Environment mapping
Soya 0.6.1 and below were written in C and Python, but version 0.7 and higher are written in Pyrex and Python.

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

Data::Secs2 is a Perl module to pack, unpack, format, transform from Perl data SEMI E5-94 nested data.

SYNOPSIS

#####
# Subroutine interface
#
use Data::Secs2 qw(arrayify config listify neuterify numberify perlify
perl_typify secsify secs_elementify stringify textify transify);

@array = arrayify($ref, @options);

$old_value = config( $option );
$old_value = config( $option => $new_value);

$body = secs_elementify($format, $cells, @options);

@secs_obj = listify(@vars);

@secs_obj = neuterify($binary_secs, @options);

@vars = perlify(@secs_obj, @options);

$ref = perl_typify(@array, @options);

$ascii_secs = secsify( @secs_obj, @options);
$binary_secs = secsify( @secs_obj, type => binary);

$string = stringify(@arg, [@options]);

@secs_obj = transify($acsii_secs, @options);

#####
# Class, Object interface
#
# For class interface, use Data::Secs2 instead of $self
# use Data::Secs2;
#
$secs2 = Data::Secs2 # uses built-in config object

$secs2 = new Data::Secs2( @options );

@array = secs2->arrayify( $ref, @options );

$old_value = secs2->secs_config( $option);
$old_value = secs2->secs_config( $option => $new_value);

$body = secs2->secs_elementify($format, $cells, @options);

@secs_obj = secs2->listify(@vars, @options);

@secs_obj = secs2->neuterify($binary_secs, @options);

@vars = secs2->perlify(@secs_obj, @options);

$ref = secs2->perl_typify(@array, @options);

$ascii_secs = secs2->secsify( @secs_obj, @options);
$binary_secs = secs2->secsify( @secs_obj, type => binary);

$body = secs2->stringify( @arg );

@secs_obj = secs2->transify($acsii_secs, @options);

Generally, if a subroutine will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}. If a subroutine will process an array reference, @options, [@options], that subroutine will also process a hash reference, %options, {@options}. See the description for a subroutine for details and exceptions.

CGI::WML is a Perl module with subclass LDSs "CGI.pm" for WML output and WML methods.

SYNOPSIS

use CGI::WML;

$query = new CGI::WML;

$content = $query->p("Hello WAP world");

print
$query->header(),
$query->start_wml(),
$query->template(-content=>$query->prev()),
$query->card(-id=>"first_card",
-title=>"First card",
-content=>$content),
$query->end_wml();

print
$query->wml_to_wmlc(-wml=>$wml_buffer,
-errorcontext=>2);

($page_title,$content) = $query->html_to_wml($buffer);

This is a library of perl functions to allow CGI.pm-style programming to be applied to WAP/WML. Since this is a subclass of Lincoln Steins CGI.pm all the normal CGI.pm methods are available. See perldoc CGI if you are not familiar with CGI.pm

wmifinfo is a simple applet showing basic network info for all available interfaces. It shows IP address, netmask, gateway and MAC address.

Left-button click moves to the next interface, right-button click calls ifup/ifdown scripts.

Please report bugs if you find any.

Left-button click moves to the next interface, right-button click calls ifup/ifdown scripts. These can be set with the -u and -d options. The %s variable is replaced with the interface name.

Example:

$ wmifinfo -i ppp0 -u "/sbin/ifup %s" -d "/sbin/ifdown %s"

(ifup/ifdown or the wmifinfo binaries should be suid root for this to work)

Led color Meaning
-------------------------------------------------------------------
red interface is down
yellow ifup/ifdown script is busy
dark green interface is up, no traffic
light green interface is up, and sending or receiving

Embedix::ECD is a Perl module with Embedix Component Descriptions as objects.

SYNOPSIS

instantiate from a file
my $ecd = Embedix::ECD->newFromFile(busybox.ecd);
my $other_ecd = Embedix::ECD->newFromFile(tinylogin.ecd);
access nodes
my $busybox = $ecd->System->Utilities->busybox;
build from scratch
my $server = Embedix::ECD::Group->new(name => Server);
my $www = Embedix::ECD::Group->new(name => WWW);
my $apache = Embedix::ECD::Component->new (
name => apache,
srpm => apache,
prompt => Include apache web server?,
help => The most popular http server on the internet,
);
$ecd->addChild($server);
$ecd->Server->addChild($www);
$ecd->Server->WWW->addChild($apache);
get/set attributes
my $srpm = $busybox->srpm();

$busybox->help(i am busybox of borg -- unix will be assimilated.);

$busybox->requires([
libc.so.6,
ld-linux.so.2,
skellinux,
]);
combine Embedix::ECD objects together
$ecd->mergeWith($other_ecd);
print as text
print $ecd->toString;
print as XML
use Embedix::ECD::XMLv1 qw(xml_from_cons);

print $ecd->toXML(shiftwidth => 4, dtd => yes);

my $cons = Embedix::ECD->consFromFile(minicom.ecd);
print xml_from_cons($cons);

Embedix::ECD allows one to represent ECD files as a tree of perl objects. One can construct objects by parsing an ECD file, or one can build an ECD object from scratch by combining instances of Embedix::ECD and its subclasses. These objects can then be turned back into ECD files via the toString() method.

ECD stands for Embedix Component Description, and its purpose is to contain meta-data regarding packages (aka components) in the Embedix distribution. ECD files contain much of the same data a .spec file does for an RPM. A major difference however is that ECD files do not contain building instructions whereas .spec files do. Another major difference between .spec files and ECD files is the structure. ECD files are hierarchically structured whereas .spec files are comparatively flat.

The ECD format reminds me of the syntax for Apache configuration files. Items are tag-delimited (like in XML) and attributes are found between these tags. Comments are written by prefixing them with /^s*#/. Unlike apache configurations, attribute names and values are separated by an "=" sign, whereas in apache the first token is the attribute name and everything after that (sans leading whitespace) and up to the end of the line is the attributes value. Also, unlike apache configurations, attributes may also be enclosed in tags, whereas in apache tags are used only to describe nodes.

ECD files look like pseudo-XML with shell-styled comments.