Free faceted software for linux

Facetnav is an indexing, free text search, and faceted navigation engine. It is usable as an independent service.

The project is usable in high traffic environments with huge amounts of data, along the lines of more than 100 searches a second with a data set of 100,000 objects with 10 facets

TEKlib is a games operating system and cross-development SDK for games.

TEKlib is an open-source library and operating system effort under the terms of the free MIT software license. This project has a many of facets; it is a

virtual operating system that runs hosted on platforms such as Linux, Windows, BSD and MorphOS,
freestanding operating system on architectures such as the Playstation 2, where it runs on a thin layer of ROM calls,
middleware providing a constistent interface across all hosting environments,
component library in that it is not strictly limited to OS services,
development platform that comes with a cross-platform build system and documentation tools.

TEKlib was started around the year 1999 out of frustration from the ended lifecycle of the AmigaOS and the lack of a worthy successor for its most basic principle, excellence by simplicity. Today, TEKlib is a virtual operating system, distributed over a set of portable libraries. You can use it as your sole environment on the Playstation 2 (provided that you are hardcore enough); most people however will use it as a development platform under Linux or Windows.

By picking from its facilities, it can serve as

a games operating system and cross-development SDK for games and everything multimedia,
a hosting environment for libraries that depend on non-trivial features like plugins and threads, striving for portability and durability,
a virtual OS target as a backend for applications that would have to be ported to many individual hosts,
a toolkit to provide an extensible virtual filesystem,
an ubiquitous component architecture that allows plugins and their host to compile from the same source on all platforms,
a small and powerful replacement for standard C libraries in embedded applications.

TEKlib is both an architecture and component library. In short, it can be embedded into any kind of library and application, and conversely, any kind of library and application can be based on TEKlib.

livecoding 2.01 is yet another excellent utility for any developers It actually provides code reloading support library for Python.

There are two key facets this library:

• The code reloading functionality it provides.
• The bypassing of the standard module system with a custom one.

The standard module system is still there and continues to work with the custom one, but only the custom one is covered by the code reloading functionality of this library.

In order to decide whether you want the flexibility of the code reloading that this library provides, you need to decide whether you can live with writing the reloadable scripts within the custom module system.

Major Features:

1. Automatic code reloading on script file changes.
2. Less interruptions to developer workflow.
3. Code reloading allows a running application to change its behaviour in response to changes in the Python scripts it uses. When the library detects a Python script has been modified, it reloads that script and replaces the objects it had previously made available for use with newly reloaded versions.
4. As a tool, it allows a programmer to avoid interruption to their workflow and a corresponding loss of focus. It enables them to remain in a state of flow. Where previously they might have needed to restart the application in order to put changed code into effect, those changes can be applied immediately.

Requirements:

• Python

stl2pov reads an STL (Standard Triangulation Language) file and outputs a POVray mesh.
stl2pov has been tested with STL files generated by Pro/Engineer.
BUILDING THE PROGRAM
For building on FreeBSD and other systems with the GNU toolset, see the instructions in the file INSTALL. After installation, a manual page for this program can be read with man stl2pov. Additional documentation is available in the documentation directory. See the Makefile.
I have set up a cross-compiler to produce a win32 binary. You can find it in the file stl2pov-2.3.0.zip on my website; http://www.xs4all.nl/~rsmith/software/
If anyone wants to donate makefiles or project files for other systems and compilers I will be happy to include them in the distribution.
Enhancements:
- Follow the new syntax for povray: use triangle instead of facet.

Lib3df is a C++ library to load 3D world. It works under Windows,MacOS,Linux and most Unixes.

HLIB is a C++ library intended to facilitate the use of ".MAP" files in applications. ".MAP" files are produced by the "Valve Hammer Editor" availlable at: http://collective.valve-erc.com/ . This is the editor used to create Half-Life, Team Fortress Classic, Counter-Strike and Day of Defeat maps. A lot of models are availlable in this format on the internet and the abillity to read such format may greatly help game programmer. HLIB is intended to be portable accross many platforms including: GNU/Linux, All UNIX*S, MS-Windows > 95.

HOW IT WORKS:

HLIB doesnt impose you anything about how the map data will be presented in memory. Instead the library calls the methods of a "builder" object you supplied, to inform your program that some kind of 3D objects has been found in the map file. For instance when the library finds a polygon it calls:

BeginPolygon(); then all subsequent method call will refer to this polygon.

When there is no more data about the polygon, the library calls: EndPolygon();

A map is made of many entities. Each entity can have many key-value pairs (such as: "classname" "player", which says: this entity is of class player). In addition, an entity can have some brushes. A brush is a convex set of polygons. Each polygon has:

- one texture name
- at least 3 vertex
- one normal per vertex
- one UV coordinate per vertex

First you have to create a "builder". You do this by subclassing the
HLMapBuilder class:

class MyBuilder
: public HLMapBuilder
{
public:
MyBuilder(void) {}
virtual ~MyBuilder(void) {}
}

Then you have to create an HLMap object and a builder and link them together:

HLMap theMap;
MyBuilder theBuilder
theMap.SetBuilder(theBuilder);

std::ifstream theMapFile("mymap.map");
theMap.BuildFromStream(theMapFile);

The HLMap object will parse the file and call the following methods of the builder
object:

// Cancel everything (error)
virtual void BuildError(void);
// Begins a map building
virtual void BuildBeginMap(void);
// Begins an entity building
virtual void BuildBeginEntity(void);
// Builds an option
virtual void BuildOption(const char* option, const char* value);
// Begins a brush building (an entity may have many brushes)
virtual void BuildBeginBrush(void);

// Builds a facet (deprecated)
virtual void BuildFacet(sgVec3 A, sgVec3 B, sgVec3 C, const char* texture, sgVec3 U, int ushift, sgVec3 V, int vshift, float rotation, float xscale, float yscale);

// Begins a polygon building
virtual void BuildBeginPolygon(void);
// Builds the polygons texture
virtual void BuildTexture(const char* texture);
// Get the last built texture height and width
virtual void GetTextureDimension(int* w, int* h);
// Builds one polygons vertex
virtual void BuildNormal(sgVec3 v);
// Builds one polygons vertex
virtual void BuildVertex(sgVec3 v);
// Builds the vertex UV mapping
virtual void BuildUVMapping(sgVec3 uv);
// Ends a polygon building
virtual void BuildEndPolygon(void);
// Ends a brush building (an entity may have many brushes)
virtual void BuildEndBrush(void);
// Ends an entity building
virtual void BuildEndEntity(void);
// Ends a map building
virtual void BuildEndMap(void);

Here is the list of method call produced for a map containing only a single
pyramidal object:

BuildBeginMap(); // this is a new map
BuildBeginEntity(); // this is a new entity
BuildOption("classname", "pyramid"); // this entitys classname is: "pyramid"
BuildOption("name", "The Big Pyramid"); // this entitys name is: "The Big Pyramid"
BuildBeginBrush(); // this entity contains a brush
BuildBeginPolygon(); // lets go for the brushs first polygon
BuildTexture("GoodOldPyramid"); // it uses the good old pyramid texture
GetTextureDimension(&w, &h); // the builder has to give the with and height
// of the texture
/// it is needed because the HLMap object doesnt
// know anything about image file format
BuildVertex(v); // the first vertex
BuildNormal(n); // its normal
BuildUVMapping(uv); // its UV corrdinate

BuildVertex(v); // the second vertex
BuildNormal(n); // its normal
BuildUVMapping(uv); // its UV corrdinate

...
BuildEndPolygon(); // this polygon is finished

BuildPolygon(); // The second polygon
...
BuildEndPolygon(); // the second polygon is finished

...

BuildEndBrush(); // this brush is finished

BuildBeginBrush(); // a second brush
...
BuildEndBrush(); // the second brush is finished

...

BuildEndEntity(); // The first entity is finished
BuildBeginEntity(); // a second entity
...
BuildEndEntity(); // the second entity is finished

...
BuildEndMap(); // the map is finished

HLIB contains a HLMapBuilder class which is a basic builder. It doesnt do anything but donc break anything. It is the base class for all your builder. A real life builder is given in example with the PlibMapBuilder class. It is up to you to customize these methods to produce something
usefull. HLIB is just a parser with some 3D geometry CSG calculations.

Due to the file format, HLIB has to do a lot of 3D calculation when reading the map file. To help with these calculations HLIB uses PLIB. PLIB is a 3D library availlable at: http://sourceforge.net/projects/plib

PLIB is made of many components:

- SG: which deals with geometry and is used extensively throughout HLIB
- SSG: which deals with rendering
- UL: which is a utility library, (only used in HLIB for some defines)
- ....

HLIB uses SG internally and externally: the sgVec3 type is defined by SG and is used to pass vertex data from the director (HLMap) to the builder (HLMapBuilder derived classes).

HLIB uses SSG in one class only: PlibMapBuilder. You can safely remove this class if you dont want SSG at all.