[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 1.12 Crystal Space Contributors

This is a list of people who have contributed to Crystal Space in one way or another. Some of these people are no longer active with Crystal Space and may not be reachable. This list is sorted alphabetically by first name.

- Adam Bradley (artdodge@cs.bu.edu)

  Adam worked a lot on the Crystal Space event system. He designed it completely from scracth and then did all the needed implementation work.

- Alessandro Russo (alessandro.russo@ntt.it)

  Alessandro contributed a patch for the X11 driver which allows simultaneous keypresses and disables autorepeat. This makes movement much smoother.

- Alex Pfaffe (ddg@oz.net)

  Alex integrated Crystal Space with the VCOLLIDE library for collision detection. Later he removed VCOLLIDE and used RAPID instead. He then rewrote RAPID to work better with Crystal Space. He also contributed the (long defunct) DDG landscape engine.

- Anders Reggestad (anders@pvv.ntnu.no)

  Anders fixed `csGetTicks()` to be multi-thread safe and also made sure it does not overflow.

- Anders Stenberg

  Anders added the ODE based dynamics plugin. He also wrote the original (and now obsolete) effect-system which was the first integration of more advanced OpenGL features into Crystal Space. Anders was also one of the initiators and main contributors to the new advanced rendering system. He also worked on the (now defunct) PicoGUI plugin.

- Andon M. Coleman

  Andon patched 3ds2lev so it works correctly for non-texture mapped 3DS objects.

- Andreas Busch (nobita@t-online.de)

  Andreas made a few fixes to Crystal Space, and applied numerous corrections for typographical errors in the Crystal Space manual.

- Andreas Hoefler

  Andreas re-wrote and cleaned up the WAV loader.

- Andrew Apted (ajapted@netspace.net.au)

  Andrew added a (now defunct) GGI driver to Crystal Space. GGI information available at:

  http://www.ggi-project.org/

- Andrew Craig (acraig@paqrat.com)

  Andrew worked a bit on the sprcal3d mesh object, and also applied numerous other smaller fixes.

- Andrew Kenneth Milton (akm@zeus.theinternet.com.au)

  Andrew provided an early (now defunct) makefile for FreeBSD and supplied some other FreeBSD patches.

- Andrew Mann (amann@tccgi.com)

  Andrew made several fixes and optimizations. He also created partedit, the particle editor. Andrew also contributed the new 3D sound system.

- Andrew Topp (talmakion@yahoo.com.au)

  Andrew worked on shader expressions, the PicoGUI plugin, and made a few other changes.

- Andrew Zabolotny (bit@eltech.ru)

  Andrew was a major contributor to the project. He was one of those developers who did far more work than can possibly be detailed in this small blurb, and his contribution to Crystal Space is far more extensive than this tiny entry implies. Here is an excerpt of his contributions:

  - Helped a lot with general project maintenance and bug fixing.
  - Ported Crystal Space to OS/2.
  - Changed Crystal Space to read/write ZIP files instead of the CSAR archive format.
  - Enhanced Crystal Space to read PNG files.
  - Did a major rewrite of the platform-dependent portions of the project.
  - Wrote the 2D sprite support.
  - Wrote CSWS, the original Crystal Space Windowing System, and MazeD, an unfinished (and now defunct) Crystal Space map editor.
  - Made many useful improvments to `DrawPolygon()` and `DrawPolygonQuick()` in the software renderer.
  - Contributed to the halo code.
  - Introduced the first MMX support.
  - Re-wrote the DJGPP port (non-Allegro) to use 16-bit and also support more video modes.
  - Ported almost all assembly to NASM and wrote a few new routines.
  - Improved speed of fog and alpha transparency considerably.
  - Is responsible for the current makefile build system.
  - Is the created of VFS, the Virtual File System.
  - Created SCF as a replacement for COM and converted the project to use it.
  - Re-wrote csfgen, the font generator.
  - Contributed to the engine, the map loader, the event system and various other parts of Crystal Space.
  - Created a nice memory debugger (now defunct).
- Ang See Chai (lynx@tm.net.my)

  Ang See contributed a set of textures.

- Anis Ahmad (anis@cyberus.ca)

  Anis updated the very early makefiles for Watcom C++ for both Crystal Space and (the defunct) CSAR. He also made an early Crystal Space editor for Windows 95.

- Antonio Gascon (434961@cepsz.unizar.es)

  Antonio provided some notes which allowed a few matrix inversions to be optimized away.

- Anuj Goyal (agoyal@coverty.com)

  Anuj reported a few leak/memory corruption issues in CS.

- Aren Blondahl (rean@pathcom.ca)

  Aren applied some patches to map2cs.

- Ayal Pinkus (apinkus@xs4all.nl)

  Ayal contributed a nice missile sprite which was used to replace the old, ugly missile used by Walktest. He helped create the base classes for the curve system. He then implemented the first Bezier curves with 3x3 control points.

- Benjamin Sprague (sprague@core.com)

  Benjamin submitted some patches for one of the terrain plugins.

- Bill Bohan (zorn@technologist.com)

  Bill contributed the first free textures for Crystal Space.

- Bjorn Hansen (holomorph@users.sourceforge.net)

  Bjorn applied some event-related fixes.

- Bob bob@imperium.ru

  Bob provided a (long defunct) project file for Windows/Watcom C++.

- Bob Ham (node@users.sourceforge.net)

  Bob submitted a (long defunct) makefile patch for GNU/Hurd. He proof-read much of this manual. He also started working on a map editor for Crystal Space, called Ticle, but abandoned the project.

- Bart van Langen (bart.van.langen@dyme.nl)

  Bart provided a few patches, a working Watcom/DOS makefile and Visual C++ project files.

- Boyan Hristov (boyan_hristov@newmail.ru)

  Boyan contributed a lightning plugin. Boyan also added several features to AWS.

- Brad Davis (jbdavis@uswest.net)

  Brad provided the original CVS hosting for Crystal Space.

- Brandon Ehle (azverkan@yahoo.com)

  Brandon contributed the original csPython and csLua modules for scripting. (The Python module has undergone complete re-write by Rene Jager since that time, and the Lua module has been dropped for lack of maintenance.) Using csPython he wrote an Unreal map-to-Crystal Space convertor. Brandon also worked on the never completed (and long defunct) PlayStation2 port. He made some improvements to ``csQuaternion'`. He added the (now non-existant) ``newdoc'` directory with LaTeX documentation (which was dropped in favor of Texinfo). Later Brandon worked on a cal3d convertor for Crystal Space and a motion manager plugin (both of which have been completely subsumed by more recent and functional modules by other contributors).

- Brendan Burns (bburns@genet.cs.umass.edu)

  Brendan worked on a memory canvas which can render directly to a memory buffer instead of a window.

- Brett Hall (swizin@rain.org)

  Brett fixed a bug in the X11 canvas which caused it to crash at exit when the window was closed by the window manager.

- Brian Haskin (haskin@ptway.com)

  Brian provided some FreeBSD patches.

- Bruce Williams (brucewil@pacbell.net)

  Bruce helped optimize the (presently defunct) Direct3D driver. He also contributed a set of conversion utilities to load 3DS, ``.mdl'`, etc. files.

- Burton Radonsxi (loth@pacificcoast.net)

  Burton added an Allegro canvas.

- caedes (caedes@sindominio.net)

  caedes submitted the ``Jack'` sound renderer. caedes also worked on the ``sprcal3d'` loader and he updated the scripting plugins for various classes in CS. caedes also worked on the physics loader plugin and the ODE physics plugin. caedes also added a new sequence to the engine sequence manager.

- Charles Al' Quarra (charsquarra@hotmail.com)

  Charles contributed the OPCODE and (the now obsolete) cloth plugins.

- Charles Vidal (vidalc@club-internet.fr)

  Charles contributed a (long defunct) TCL/TK script for launching Crystal Space.

- Chen Puning (chenpuning@hotmail.com)

  Chen fixed a bug in the engine's `GetScreenBoundingBox()`.

- Chris Bruner (cbruner@ionline.net)

  Chris submitted several fixes for the Borland compile.

- Chris Forno (jcore@users.sourceforge.net)

  Chris helped with documentation.

- Chris Matuszewski (ganamide@yahoo.com)

  Chris fixed some issues with intersecting triangles, fixed a few bugs in AWS, and a few other issues.

- Christian Bayle (bayle@aist.enst.fr)

  Christian Bayle contributed scripts to make a Debian package for Crystal Space.

- Christian Van Brussel

  Christian fixed an issue in the cal3d plugin.

- Christopher Nelson (paradox@BBHC.ORG)

  Christopher is the author and creator of the Alternate Windows System AWS for Crystal Space. He also added the (now defunct) cslexan (lexical analyzer) plugin. Before he started work on the AWS, he contributed to CSWS. Christopher also created the terrbig terrain plugin, and contributed a platform independent memory mapper.

- Conor Stokes (cstokes@wantree.com.au)

  Conor performed some optimization of the 16-bit scanline routines in the software renderer following optimizations by Olivier Langlois. He was also the main inspiration source for the current visibility algorithm work done at that time.

- Dan Bogdanov

  Dan was the DJGPP port maintainer for a time.

- Dan Härdfeldt (swedishcoder@sf.net)

  Dan worked on the CEGUI plugin.

- Dan Ogles (dogles@peachtree.com)

  Dan provided a patch for ``printf()'` to make it work with the Windows port. Dan made the Direct3D port for Windows. He greatly enhanced the Windows port and also added 16-bit support for Windows. He also spearheaded the (now defunct) movement to make the 3D and 2D drivers COM-compliant, and supplied a skeleton COM framework for non-Windows platforms. He also contributed the early halo code to Crystal Space.

- Daniel Duhprey (duhprey@yahoo.com)

  Daniel contributed the ``csOBB'` class (Oriented Bounding Box). He also made the terrbig plugin and helped develop the ODE dynamics plugin. He did a good deal of work on the new rendering system; especially the shadow system. He also worked on the new terrain engine (for new renderer).

- Daniel Fannar Gudbjartsson (dfg@decode.is)

  Daniel did some work on the physics engine and collision detection.

- Daniel Fryer (dfryer@uvic.ca)

  Daniel found and fixed a couple bugs: one memory leak, and one incorrect calculation of vertex count.

- Desmond Fletcher (desmond.fletcher@usm.edu)

  Desmond helped a bit on ``map2cs'` and updated its documentation. He also pointed out several bugs and errors in Crystal Space.

- Darius Snapkauskas (snapkus@iname.com)

  Darius was busy with 3D sprites. He contributed some unfinished stubs for his work. Unfortunately he seemed to have stopped supporting it. His unfinished code was retired and replaced completely with an implementation by Jorrit.

- David N. Arnold (derek_arnold@fuse.net)

  David enhanced the DOS port made by Murat. He added C++ classes and VESA support. David also wrote the original Pentium assembler version of ``scan.cpp'` in the software renderer.

- David M. Asbell (dasbell@users.sourceforge.net)

  David added support for SpriteSockets, a mechanism for attaching sprites to specific places on other sprites.

- David Durant (ddurant@novametrix.com)

  David added code for sprite selection to WalkTest and also applied some fixes for sprites. He cleaned up some code in WalkTest, and added a double-linked list class.

- David Huen (smh1008@cus.cam.ac.uk)

  David did a some work to improve the original BeOS port.

- Denis Dmitriev (mrsigma@home.com)

  Denis contributed a routine to split a convex object into slices parallel to the view plane (useful for volumetric fog). He added a progress bar to the console (during lighting) and added a new way to do bilinear filtering for the software renderer. He also dramatically improved the quality of the precalculated lightmaps in the software renderer. Denis improved the movement system in WalkTest by implementing gravity and better collision detection (using the collision detection system from Alex Pfaffe). He added the (defunct) metademo application which was later reworked to become the ``metaballs'` mesh object. He also fixed a number of bugs.

- Doug Rabson (dfr@nlsystems.com)

  Doug helped fixed a possible memory leak with SHM extension in the X11 driver.

- Dmitry Derevyanko (dmitryd@robotics.eecs.berkeley.edu)

  Dmitry helped by running Purify and solving numerous bugs that way. He also contributed (now defunct) makefiles for IRIX/SGI.

- Eric Sunshine (sunshine@sunshineco.com)

  Eric is one of the developers who does far more work than can possibly be detailed in this small blurb, and his contribution to Crystal Space is far more extensive than this tiny entry implies. His contributions include:

  - Ported Crystal Space to MacOS/X, MacOS/X Server (Rhapsody), OpenStep, and NextStep.
  - Is the designer, instigator, and (often) implementor of many of the sweeping architectural changes to the project which have taken it from a monolithic and inflexible Quake-wannabe to a well-designed, and well-thought-out, modular, and extensible package aimed at a much wider audience. A small list of such sweeping changes includes: Replacement of the monolithic SCF registration database (``scf.cfg'`) with a self-describing plugin facility; eradication of the monolithic "system driver" class and related convolutioin which prevented Crystal Space from acting as a component capable of being plugged into a larger, existing application framework; creation of the domain-based configuration facility which allows higher-priority components to override settings of lower-priority components, and which maintains user-specific settings separately from factory-supplied (read-only) settings (the user-specific settings can roam with the user if supported by the platform); the ``object registry'`, which is a general-purpose container accessible to all components, and into which components can place any resources they wish to share with other components; instigation of the event system overhaul to take it from a monolithic, unalterable facility to a completely extensible one in which any plugin module or custom application can define and create new event types dynamically (without having to modify the Crystal Space event definitions); and much more.
  - Fixed hordes upon hordes of bugs and problems throughout the project.
  - Provided significant updates and clean up to the build systems, source code, organization, and architecture.
  - Added an automated synthesis process for the Windows/MSVC project files. This process gleans necessary information from the GNU makefiles throughout the project in order to entirely eliminate manual maintenance of these files.
  - Added automated generation of CVS ``snapshots'`. These are packages (archive files) containing the complete CVS tree. Also, log files and diff files are generated.
  - Took on the task of acting as master editor of the Crystal Space documentation. As part of this job, he has written much of the content which ties together various portions of the manual, fleshed out much of the bare skeleton and written many otherwise absent sections. He is also responsible for the documentation's current look and feel and has created an entire supporting infrastructure to make documentation available easily and automatically on all supported platforms. He set up the automated API reference generation, node repairing for the Texinfo documentation source, and conversion of Texinfo to various other formats. He has also pored through the documentation and updated many out of date references.
  - Re-wrote and re-engineered the (now defunct) BeOS port of Crystal Space almost entirely from scratch, in the process making it about 98% functional as compared to being only about 15% functional before the re-write.
  - Re-engineered Crystal Space's network driver architecture and completely rewrote the network drivers from scratch. The new architecture is far more robust, generalized, and usable than the old.
  - Coerced Crystal Space to use GNU Autoconf for configuration (or, looked at another way, he coerced Autoconf to work with Crystal Space), and wrote all of the underlying configuration support code (no small job).
- Eric Wigforss (ewigforss@novametrix.com)

  Eric applied a few Windows-specific patches to the networking code.

- Erik Namtvedt

  Erik contributed the (now defunct) ensocket network plugin.

- FragDance Galore (fragdance@hotmail.com)

  FragDance contributed a WAL/SGI loader, and added initial support for alpha maps to the texture loaders. He also contributed to the halo code.

- Frank O'Connor (frank@oconnors.org)

  Frank maintained the Windows port of Crystal Space for a while. One of the first tasks he undertook was a reorganization of the MSVC project files. He also helped with project maintenance in general.

- Frank Richter (res@crystalspace3d.org)

  Frank has done too much to mention. He has worked a great deal on many parts of the project, making from minor to large-scale changes, ranging from the build system, to the plugin system, to the renderer, to the engine. He has done a lot of work on the new renderer architecture, and has been a driving force in improving localization and internationalization support.

- Fritz Elfert (fritz.elfert@millenux.com)

  Fritz fixed some bugs in sprcal3d, map2cs, null renderer, VFS, ``csStringArray'`, etc.

- Gary Clark (GaryC@jeld-wen.com)

  Gary designed the basic framework of the ``Graphics3D'` class (which later became ``csGraphics3D'`, and which later spawned the ``iGraphics3D'` interface). Gary also made an extension to optionally allow the use of accurate RGB light sourcing in the software renderer. (It is optional because it slows the texture cache.) He also supplied a patch to fix the problem with the X11 driver where it would not start drawing until an expose event was generated. He contributed the ``lin_joy.cpp'` file, which provided an example of how to use the joystick from within GNU/Linux. (This was never integrated into the project, however Norman Krämer much later provided a GNU/Linux joystick plugin which is part of the project.)

- Gary Haussmann (g.haussmann@worldnet.att.net)

  Gary wrote the original OpenGL renderer, as well as the early importers for 3DS and ``.md2'` models.

- George Yohng (cspace@mmts.nsys.by)

  George added an SDL canvas plugin and reported some bugs.

- Gert Steenssens (gsteenss@eps.agfa.be)

  Gert wrote the GNU/Linux drivers for the sound system and also converted the SVGALIB driver to COM (way back when COM was used in the project. He also helped develop the GNU/Linux-Glide and OpenGL ports.

- Greg Ewing (greg@cosc.canterbury.ac.nz)

  Greg contributed a patch which greatly increased the computation speed of the initial palette table in the software renderer.

- Hariharan Bhasker (hbhasker@yahoo.com)

  Hariharan wrote the ``pathtut tutorial'` for Crystal Space, which shows how to use the `csPath` class to smoothly move an object along some path.

- Helge Foerster (Helge.Foerster@t-online.de)

  Helge suggested the algorithm for texel filtering used by the software renderer.

- Hristo Hristov (hhristov@delin.org)

  Hristo worked on the genmesh animation plugin. He also did various shader updates and worked on the stencil2 shadow plugin.

- iceeey

  iceeey worked on the CEGUI plugin and a few other smaller changes.

- Ivan Avramovic (iavramov@ibm.net)

  Ivan cleaned up the matrix/vector code and rewrote the ``csCamera'` class. He also helped a lot with cleaning up the perspective projection and clipping, in which he made some considerable improvements. He also helped fix a lot of bugs with portals and clipping. Ivan also enhanced the image loader classes to make it possible to dynamically add new image formats even with a pre-compiled Crystal Space library. He re-wrote the map loader routines and added the ``csObject'` library. He also separated the very early scripting support from the engine.

- Jaison Lee (jaison@apk.net)

  Jaison contributed a new version of ``police.fnt'` which eliminates an error experienced by the Borland compiler.

- James Baicoianu (james@baicoianu.com)

  James implemented ``iPolygonMesh'` in the ball mesh plugin.

- James Thompson (jamesthom@users.sourceforge.net)

  James applied a few fixes to the Python plugin.

- Javier Santos (jsantos@infonegocio.com)

  Javier contributed an XML/Schema for the Crystal Space map file format.

- Jeff Lundin (jlundin@fz.ml.org)

  Jeff helped with the DJGPP port.

- Jerry A. Segler Jr

  Jerry added theme support to CSWS.

- Jesko Schwarzer (jesko@bigfoot.de)

  Jesko suggested a way to improve speed of volumetric fog.

- Jesse McClusky (Jesse.McClusky@PSS.Boeing.com)

  Jesse made the most recent (yet long defunct) Amiga port.

- Jochen Moench (jochen.moench@de.thalesgroup.com)

  Jochen submitted a patch for `SetAction()` in the spr3d plugin.

- John Harger (john_h@selectpath.com)

  John worked on the new renderer particle system. He fixed various other issues (mostly related to the new renderer), and improved the error reporting of the plugin loader on Windows. John also worked on the PS1 shader plugin and made numerous changes to the particle plugin.

- John Lilley (jlilley@empathy.com)

  John managee the defunct Crystal Space Texture Archive.

- Jon Heiner (jonh@MIT.EDU)

  Jon provided a few patches and a (now defunct) makefile for the SGI/IRIX port.

- Jonathan Hudson (jhudso1@gl.umbc.edu)

  Jonathan fixed a bug in the BMP reader which made the image load up-side-down.

- Jonathan Hudson (nathanoj@realmail.2ndmail.com)

  Jonathan implemented visibility testing for particle systems.

- Jonathan Tarbox (jtarbox@sbcglobal.net)

  Jonathan made some small enhancement to the (now defunct) BeOS port of Crystal Space. He also performed the bulk of the conversion of the event system from the inflexible, monolithic design to the newer extensible, dynamic design, and made events serializable.

- Jorge Acereda (al004046@anubis.uji.es)

  Jorge made several contributions: FreeBSD/NetBSD port, fixed the ``.md2'` importer to recognize actions, fixed some bugs in mdl2spr, fixed some bugs in 3ds2lev, fixed some bugs in the engine, resolved some memory leak fixes, `dlopen()` fixes, fixed a few bugs in Blocks, and some other smaller changes.

- Jorrit Tyberghein (jorrit.tyberghein@gmail.com)

  Jorrit is the main author of Crystal Space. He wrote the initial engine with the main current functionality. He is still the main driving force of the project. Contact him for any general and strategic questions as well as specific implementation issues. Jorrit's home address is Schoonstraat 11, 3020 Veltem Beisem, BELGIUM.

- Justin Miller (j5t@gmx.net)

  Justin contributed a number of patches, some documentation, significant work on early physics, including a demonstration application.

- Jyrki O Saarinen (jxsaarin@cc.helsinki.fi)

  Jyrki created the original Amiga port of Crystal Space (now defunct).

- Karlis Freivalds (karlisf@cclu.lv)

  Karlis found and fixed a few bugs in the Watcom port.

- Keith Fulton (keith@paqrat.com)

  Keith added the ability for rain drops to do collision detection with the surrounding geometry. He also worked on various other components, such as the sequence manager. He has also fixed various bugs, and has contributed significantly to the sprcal3d mesh object plugin.

- Krishnan Shrikumar (krish@urbyte.com)

  Krishnan wrote the ``sectorexport'` Blender export script.

- Leandro Ezequiel Lovisolo (lovisolo@datafull.com)

  Leandro contributed the ``crystal.fgd'` definition file for Worldcraft. He also made a few updates to the map2cs tutorial.

- Leslie Saputra (gwfremin@bellsouth.net)

  Leslie contributed some code to implement freelook functionality to Walktest, like that in Quake.

- Loic Dachary (loic@gnu.org)

  Loic added a patch for better error reporting when a plugin fails to load, and also supplied a small patch for ``cs-config'`.

- Luca Cappa (groton@gmx.net)

  Luca applied some various small fixes (engine lights, AWS, etc.).

- Luca Pancallo (lpancallo@ptc.com)

  Luca extended the ASE importer, and added a Crystal Space sprite exporter. He also sent a patch for mdl2spr and made various fixes to 3ds2lev. Luca contributed the 3DSMAX exporter script.

- Marc Haisenko

  Marc fixed a bug with AWS radio buttons.

- Mark Welch

  Mark submitted a few patches for the MSVC project files before they were synthesized automatically.

- Markus F.X.J. Oberhumer (k3040e4@wildsau.idv-edu.uni-linz.ac.at)

  Markus provided a small patch for the X11 driver.

- Markus Korth (mkorth@military.de)

  Markus fixed a bug in the (now defunct) ``unixconf.sh'` script.

- Marten Svanfeldt (developer@svanfeldt.com)

  Marten now as a Crystal Space Project Administrator has done far more work and helped the project in so many ways, they are too numerous to completely detail here.

  - Marten added support for vertex-programs to the old OpenGL renderer.
  - Marten was one of the initiators of the new advanced OpenGL renderer and wrote large part of the interface. He has written parts of the renderer itself and the shader system.
  - Marten also worked on the new SCF system in Crystal Space and he is the main author of the new lightmap system.
  - Marten has performed Crystal Space wide changes and additions that have enhanced the codebase considerably.
  - Marten is a leading Crystal Space developer with the Microsoft MSVC toolset and has been at the forefront of adding support for the latest versions and maintaining compatibility with the Crystal Space codebase.
  - Recently Marten has been working on a new particles system for Crystal Space.
- Martin Geisse (mgeisse@gmx.net)

  Martin converted many of the Crystal Space text and LaTeX documents to Texinfo format. He contributed a random dungeon generation plug-in module, as well as a sample program which demonstrates its use. Martin added the model data classes and rewrote the old model importer in a more modular way. He also cleaned up some of the utility classes, parts of the (defunct) system driver and parts of the engine, added the configuration manager which was designed by Eric Sunshine, changed many applications to use the ``engine'` as a plug-in (rather than linking it statically), and added the simplept application. He added ``fast interfaces'` to SCF. Martin also completely rewrote the ``Software'` and ``DirectSound'` sound renderers, and modified the map file loader and the image loader to work as plug-ins.

- Matt Reda (mreda@mac.com)

  Matt contributed an OpenGL driver, a CoreGraphics driver, and a CoreAudio driver for the MacOS/X port of Crystal Space. The addition of these drivers made Crystal Space a viable option for game development on Macintosh. (Previously, only software rendering was supported via a Cocoa-based window.) Matt also worked a bit on the isometric engine and added a split-view option to WalkTest.

- Mattias Engdegard (f91-men@nada.kth.se)

  Mattias provided a patch for cleaner handling of the X11 visual and window creation.

- Mathew Sutcliffe (oktal@users.sourceforge.net)

  Mathew added functions to parse input (keyboard, mouse, joystick) to and from text. He contributed the Perl bindings, and has made other smaller contributions.

- Matthew Tang

  Matthew added a map file exporter script for Blender.

- Matze Braun (matze@braunis.de)

  Matze made various changes, fixes and enhancements to the project (too many to list). Some of the more important include: creation of the cs-config script, annotation facility for online documentation, several bug fixes, enhancements and fixes to map2cs, null canvas for the null renderer, work on the Cygwin port, viewmesh enhancements, VFS support for ``csFileDialog'`. Matze also created the Crystal Space JAM build system.

- Maurice Vosmeijer (Maurice.Vosmeijer@ehv.sc.philips.com)

  Maurice helped to maintain the (now defunct) Amiga port at one time.

- Mendrak (mendrak@worldnet.att.net)

  Mendrak submitted a patch to add `MountRoot()` to VFS and also extended standard font server for alpha maps.

- Micah Dowty (micah@navi.picogui.org)

  Micah fixed timer resolution in GNU/Linux. He also contributed the movie-recorder plugin, helped with the PicoGUI plugin, and designed and installed the nice Crystal Space logo which appears in Walktest.

- Michael D. Adams (mdmkolbe@gmail.com)

  Michael worked together with Marten Svanfeldt on the new SCF system. Besides that he did lots of fixes throughout Crystal Space.

- Michael Dale Long (mlong@custom.net)

  Michael helped fix the Glide driver and contributed a number of other small fixes. He is also the author of the (long defunct) Crystal Clear project which was included in Crystal Space. Crystal Clear served as a game layer on top of Crystal Space. Michael also wrote the default version of DrawPolygonMesh(). He helped a bit with the Windows port and with the console plugin. He wrote the early CVS guideline in the manual.

- Michael Day (mikeday@corplink.com.au)

  Michael made a small attempt to coerce Crystal Space to use Autoconf, but abandoned the effort.

- Michael Ewert (mewert99@yahoo.com)

  Michael contributed the (long defunct) csPhyzik library to Crystal Space, along with a test application.

- Michael O'Shea

  Michael found a bug in `iLoader::LoadMeshObject()`.

- Michael Voase (mvoase@midcoast.com.au)

  Michael cleaned up the texture manager in the software renderer and added some minor features. He also fixed several bugs, most importantly, buggy implementations of `HitBeamObject()` in several mesh objects; and fixed bounding box problems. He moved ``metaballs'` to a mesh object plugin, and added a blobby texture for them. He wrote the motion manager and contributed a shuttle model for ``csdemo'`.

- Mike Bond (mbond@cox.rr.com)

  Mike added fullscreen support to the X11 canvas.

- Mike Gist (xordan@gmail.com)

  Mike Gist submitted various fixes to Crystal Space. Most of them related to 64-bit code.

- Mike Handverger

  Mike worked on the ODE physics plugin.

- Murat Demircioglu (demircio@boun.edu.tr)

  Murat was the first contributor for Crystal Space. He provided the first patches and changes to port Crystal Space to DOS.

- Nathaniel Saint Martin (noote@bigfoot.com)

  Nathaniel was an eager Crystal Space fan. He even had his own web page (now defunct) dedicated to Crystal Space.

  He enhanced Arnold's DOS port so that it worked with the Watcom C++ compiler. He also suggested and implemented a restructuring of the platform-dependent code with every port having its own directory. He is also the original author of the ``simpcon'` input/output console. Nathaniel was also the first to actually present Jorrit with an almost working Windows 95 version with source. Nathaniel is responsible for much of the early sound support code in Crystal Space (mostly now rewritten). He made the basic sound system, wrote the Windows drivers and wrote support for 3D sound. Nathaniel created a Windows/DOS configuration utility which allowed easier editing of ``cryst.cfg'` (an old-time configuration file). In addition he also enhanced the (now non-existant) CSAR utility. He also helped develop the Windows/Direct3D and Windows/OpenGL versions and is co-author of the (now defunct) Glide port. He made some enhancements to the 3D sprites including two convertors from Quake ``.mdl'` and Quake 2 ``.md2'` to Crystal Space (now combined into the single ``mdl2spr'` utility.

- Neil Mosafi (nmosafi@gmail.com)

  Neil contributed a custom cursor plugin which allows use of arbitary images (via ``iImage'`) as mouse cursors. Neil also worked on the VOS networking plugin.

- Nicholas Blumire (empathy@empathy.hostingcheck.com)

  Nicholas submitted a few bug fixes.

- Nicholas Francis (nicholasfrancis@iname.com)

  Nicholas made a few contributions to MazeD, Andrew Zabolotny's long defuct and unfinished map editor.

- Noah Falk

  Noah fixed numerous problems and made some large-scale changes to AWS.

- Noah "angelbob" L. Gibbs (angelbob@users.sourceforge.net)

  Noah helped out on Michael Ewert's csPhyzik library.

- Norman Krämer (norman@users.sourceforge.net)

  Norman contributed several fixes and new features and helped with code cleanup. In particular he worked on the sound code, the engine, CSWS and the graphics drivers. He also worked on the image loaders. For example he split the former monolithic image loader into several modules, added write-support to many of them, fixed the BMP loader to be endian correct and added RLE8 encoding to the BMP loader. Norman also added the ``csQuaternion'` class and updated the (now defunct) Glide drivers. Norman contributed a FreeType font server plug-in. He added a grid-view to CSWS. He also added a sound renderer using the ``artsd'` sound server that comes with the ``aRts'` system (www.arts-project.org). Norman added an export script for Blender. He added texture coordinate animation to 2D sprites. He worked on the video file streamer. Norman also added the (unused and removed) ``csCrystalBall'` culler and the fancy console plugin. In addition he also did a good deal of work on the OpenGL renderer (mostly support for extensions). Norman worked on AWS and created a convertor from QT to AWS. Norman also added several sound related modules, such as ``ogg'`.

- Olivier Langlois (olanglois@sympatico.ca)

  Oliver made a few fixes to the event system in and ported an early Crystal Space to Borland C++. He also found and fixed some memory leaks. He contributed the ``MemoryHeap'` class for the texture cache in the software renderer. Olivier ported the GCC assembler functions to Visual C++ and implemented a few additional Visual C++ assembly functions. He implemented the BMP loader. He also optimized and helped optimize several key-functions in the engine pipe-line. For example, he managed to nearly double the speed of the assembler scanline routines. Lightmap generation and math functions were also improved.

- Oriol Esteve

  Oriol fixed an OpenGL lightmap alignment bug.

- Patrick McFarland (diablod3@gmail.com)

  Patrick is co-author of the Autoconf `CS_PATH_CRYSTAL()` macro which foreign projects can employ to determine if Crystal Space is installed.

- Paul Garceau (pgarceau@teleport.com)

  Paul contributed a (now defunct) makefile for Windows NT using GCC and helped to maintain that port.

- Peter Amstutz (tetron@student.umass.edu)

  Peter provided a patch to speed up loading of 3D sprites considerably. Peter worked together with Brendan Burns on the memory canvas. He also added two canvas-related broadcast events, and made a few other small correction. Peter created the VOS networking plugin.

- Peter Donald (donaldp@lion.cs.latrobe.edu.au)

  Peter fixed some issues and bugs with the early sound drivers.

- Petr Kocmid (pkocmid@atlas.cz)

  Petr helped fix the Glide driver on Windows, and added XML output to ``map2cs'`.

- Phil Harvey (filrv@syroxdev.co.uk)

  Phil suggested a statistics counter to illuminate the number of polygons considered and drawn each frame. He helped Nathaniel to get the Windows 32-bit port working. Phil patched `find_rgb_slow()` in the software renderer to make it slightly faster (but he forgot to rename it to `find_rgb_slow_somewhat_faster()`. :-)

- Philip Walls (malverian@lockless.dyndns.org)

  Philip added software cursor drawing to the SVGALIB canvas.

- Philip Wyett (philipwyett@blueyonder.co.uk)

  Philip acted as general maintainer of the Window port for quite a while (and performed general maintenance), wrote build instructions for MSVC, Mingw, and Cygwin, and created installable packages of support libraries for Crystal Space on Windows, from time to time.

- Philipp Aumayr (phueppl@gmx.at)

  Philipp helped work on the new OpenGL renderer and also participated in its design discussions.

- Philipp Spoth (Spoeth@t-online.de)

  Philipp helped with optimizing the texture cache in the software renderer. He also helped optimize a few other routines.

- Piotr Obrzut (piotr_obrzut@o2.pl)

  Piotr worked on the ODE physics plugin and also on the ``bullet'` physics plugin.

- Ralf Eisele (eiselera@pcpool1.informatik.uni-ulm.de)

  Ralf updated the (now defunct) Amiga port to Crystal Space version 0.09.

- Randall Foreman (eidpers@comcast.net)

  Randall supplied a number of patches and build-time problem reports aimed at making the 0.97 version of the project buildable with the Borland compiler.

- Reed Hedges (reed@zerohour.net)

  Reed worked on the VOS networking plugin together with Peter Amstutz, and addressed a few other minor issues at various points in the project.

- Rene Dudfield (illumen@yahoo.com)

  Rene made an attempt to add some rudimentary networking support (long ago discarded) to Blocks game, and contributed to the 3D sprite code. He also provided a set of export scripts for Blender.

- Rene Jager (renej.frog@yucom.be)

  Rene performed the bulk of the work on Crystal Space's language-agnostic Swig interface file (``cspace.i'`). This file is used by all present external language bindings, and should be usable by future ones, as well. He is also responsible for the Java bindings, and the present incarnation of the Python scripting module. Rene also applied some fixes the OPCODE plugin.

- Richard D. Shank (rdscrystalspace@rhinogames.com)

  Richard added the 3DS model importer. He also converted the old statically-linked terrain engine to a plug-in.

- Richard Uren (richard@starport.net)

  Richard made several changes and fixes to the isometric engine and also contributed a loader for it.

- Robert Bate (rbate@mac.com)

  Robert maintained the (now defunct) pre-Carbon Macintosh port.

- Robert Blum (r.blum@advertainment.com)

  Robert patched Dan Ogles' `printf()` patch to avoid buffer overrun, and also found a bug in the GIF loading code. He also ran a memory debugger on Crystal Space and found and fixed many bugs thus reported.

- Rodolphe Ortalo (ortalo@laas.fr)

  Rodolphe patched the Glide driver to work on GNU Linux. He also provided output from Purify which helped track down some problems.

- Roland Reckel (luxx@yahoo.com)

  Roland contributed a simple terrain engine.

- Ryan Surkamp (deathatsight@yahoo.com)

  Ryan made a bezier-based landscape engine.

- Samuel Humphreys (samuelh@ntlworld.com)

  Samuel submitted some patches for sprites, and patched the X11 drivers to allow window resizing to work. Samuel added the original (now defunct) procedural texture system to the project, which made it possible to render on textures procedurally and use those textures to map polygons, as usual. He also helped to clean up the engine code, and added the (defunct) perfstat plugin.

- Scott Bowden

  Scott added an Unreal-to-Crystal Space converter.

- Scott Wood (scott@geekland.cx)

  Scott sent patches to allow Crystal Space to compile on Alpha machines.

- Sebastian Duell (wastel7@gmx.de)

  Sebastian contributed a Blender export script.

- Serguei ``Snaar'` Narojnyi (snaar@idirect.ca)

  Serguei added the first integrated networking code to Crystal Space (long defunct). His code was COM-compatible so it could be easily extended for platform-dependent extensions.

- Seth Galbraith (sgalbrai@linknet.kitsap.lib.wa.us)

  Seth contributed a nice missile sprite for Walktest, and he fixed the texture bug in ``mdl2spr'`. Seth was also a source of suggestions and bug reports. Seth updated the (now defunct) DOS/DJGPP documentation and tutorial. He also wrote the (long defunct) Squawk (Squawk) demo which illustrated a sky box and multiple cameras. Seth changed the ``csCamera'` and ``csView'` classes to make the FOV non-static, and so that it is possible to recenter each view separately. He added sprite vertex tweening and new lighting attenuation settings. He also worked on vertex/texel merging in sprites, and on sprites in general, and he added several other features to the project.

- Simon Boily (personcountzero@hotmail.com)

  Simon made several changes to the (presently defunct) Direct3D renderer. He added multitexture support and render state caching.

- Simon Posnjak (simon.posnjak@siol.net)

  Simon applied some documentation fixes.

- Siu-Hang (shor@cse.cuhk.edu.hk)

  Sui-Hang attempted to add functionality to (the long defunct) MazeD for sector, portals, lights, textures, etc. He also improved the calculation time of the palette at startup in the software renderer.

- Slavik Levtchenko (Smirnov@bbs.math.spbu.ru)

  Slavik created one incarnation of the (now defunct) Watcom port with 16-bit display support.

- Stephan Goetter (sg17@irz301.inf.tu-dresden.de)

  Stephan made a very early (but never completed) attempt to add shared-library creation support on GNU Linux to the makefile system.

- Steve Israelson (pfhorte@rogers.wave.ca)

  Steve made the pre-Carbon Macintosh port of Crystal Space. He also made some optimizations to the assembly code `draw_scanline()` routines in the software renderer. Steve made the first preliminary physics system and also implemented an simple uniform form of dynamic lighting useful for fluorescent lights and such. Steve greatly enhanced the routines to parse the map format.

- Steven Geens (old_belge@hotmail.com)

  Steven made a MilkShape-to-Crystal Space sprite convertor which also supports skeletal animation. Steven also fixed a very bad bug in the collision detection system. He worked on sprcal3d mesh object, as well.

- Sylvain Rochette (srochette@telweb.com)

  Sylvain provided a few fixes for the Windows port.

- Thomas Giesel (skoe@freenet.de)

  Thomas supplied a small patch for BeOS to allow full-screen mode with the OpenGL driver.

- Thomas H. Hendrick (thomas@users.sourceforge.net)

  Thomas started work on the now defunct OpenGL_ext renderer.

- Thomas Hieber (thieber@gmx.net)

  Thomas was the primary maintainer of the Windows port of Crystal Space for some time and has also contributed in various other ways. He wrote `DrawPolygonFX()` for the software renderer. He added the (long defunct) ``csGame'` library and the Crystal Shooter application. He also significantly enhanced and maintained the Windows port and, especially, the Direct3D port (presently defunct). Thomas also wrote ``map2cs'`, a converter which translates Quake maps to Crystal Space format. He provided a shuttle sprite and a space station sprite for ``csdemo'`. Thomas introduced the concept of map nodes and key/value pairs for engine objects.

- Thomas Krug (thomas.krug@assix.de)

  Thomas submitted some patches for the OpenGL driver.

- Thomas Ogbuji, Chimezie (thomasog@uiuc.edu)

  Thomas wrote a Crystal Space map-to-VRML convertor in Java. He also wrote a Java Crystal Space map file editor.

- Thomas Riemer (triemer@apt4g.a3nyc.com)

  Thomas contributed a (long defunct and highly incomplete) ``network manager'`, as well as NSTP, a plug-in for the long ago defunct NetSpace project.

- Thomas Skoldenborg (thomas@dum.chalmers.se)

  Thomas fixed a problem with OpenGL renderer to prevent the 3Dfx/Mesa combination from crashing.

- Tobias Brueckner (tobias.brueckner@gmx.net)

  Tobias fixed several bugs in the OpenGL renderer, the engine, and one of the terrain plugins.

- Toni Asco Gonzalez (e3445510@est.fib.upc.es)

  Toni implemented a faster version of `DrawPolygonMesh()` for OpenGL. He also fixed some bugs in ``3ds2lev'`. Toni made some modifications to ``map2cs'`, and to ``walktest'` to support generic mesh placement.

- Tor Andersson (d97ta@efd.lth.se)

  Tor contributed some textures. He also donated code for reading several file formats and a virtual machine. This code was never integrated with Crystal Space, but his contributions were appreciated. Tor supplied a ``dj_joy.c'` file which provided an example on how to use the joystick from within DOS with DJGPP. He also added JPEG support to Crystal Space and support for the mouse in DJGPP.

- Travis McIntosh (Travis.McIntosh@student.oc.edu)

  Travis did some very fundamental work on the curve and lighting code in order to implement both dynamic and pseudo-dynamic lights for them, and also to allow shadows.

- Tristan McLure (Tristan_CS@gmx.de)

  Tristan added a DirectX v6.1 canvas for Windows.

- Trochu Xavier (xtrochu@yahoo.com)

  Trochu wrote the original (now defunct) HOWTO illustrating how to build Crystal Space with Visual C++ for Windows 95, and also contributed a few small patches to the Windows 95 version. He added Glide API support (together with Nathaniel)!

- Troy Chard (troy.chard@shaw.ca)

  Troy contributed several improvements to ``3ds2lev'`, as well as numerous enhancements for the ``odedynam'` plugin.

- Vincent Knecht (vince@iefr.ath.cx)

  Vincent worked the RPM script for Crystal Space. Vincent also did various fixes to Crystal Space.

- Void (glitia@texnet.ro)

  Void did some work on Blocks and fixed numerous other issues.

- Vyacheslav L. Chupyatov (sla@istu.udm.ru)

  Vyacheslav suggested some fixes to allow Crystal Space to compile with Watcom C++ v11. He also contributed a few makefiles for Watcom C++, and fixed a few small bugs.

- Wolfgang Lehrach (wolfg_l@pro-net.co.uk)

  Wolfgang wrote a Doom-to-Crystal Space convertor in Java.

- Wouter C. A. Wijngaards (wouter@users.sourceforge.net)

  Wouter contributed a particle system to Crystal Space based upon 2D sprites. He also added a (now defunct) full-fledged radiosity calculator. Wouter is the author of the game Tunnel Fighter, which is based upon Crystal Space. He added many of the nice particle effects plugins, and a test map for them, and the so-called full screen visual effects. Wouter is the author of the ISO engine. He also worked on visibility culling in the terrain engine and on the terrain texture generator. He added a test application for a bump-mapping feature (subsumed by the new renderer technology), and a test application for a procedural sky texture. He added the ``flare'` halo and several minor patches. He also added the original version of the ``make install'` target.

- Wyatt Miler (wmiler@nyx.net)

  Wyatt had performed some editing of Crystal Space's (long defunct) LaTeX documentation files. Wyatt added the background music to Blocks. He has also worked on correcting errors in the texinfo documentation, and hosts his own Crystal Space site for Mac OS X users which provides daily builds and other resources.

- Xavier Hosxe (xhosxe@cyrano.com)

  Xavier contributed a few patches which allowed Crystal Space to compile with the EGCS compiler.

- Xavier Pianet (xavier@planet.dk)

  Xavier created the original port of Crystal Space for BeOS. (The BeOS port was later re-written from scratch by Eric Sunshine; and ultimately removed from the project on account of the demise of Be and general lack of interest in that platform.)

The following people have also contributed to the project either by providing minor patches or by their suggestions and ideas:

Adam Bailey
Alistair Leslie (AlistairL@optushome.com.au)
Artur Biesiadowski (abies@pg.gda.pl)
Branimir Karadzic
Charles Duffy (cduffy@bigfoot.com)
David Fox
Denis Oliver Kropp (dok@master.fischlustig.de)
Donald Ryan Willhoit (willhoit@mail1.andrew.cmu.edu)
Duane McDonnel
E. Allen Soard (esp@espsw.net)
Ed Halley
Frederick A. Niles
Furqan Ullah (furqan@writeme.com)
Garrett (garrett@memesis.org)
Gregory Austwick (g.austwick@virgin.net)
Harald Fielker (fielker@informatik.fh-augsburg.de)
Jan Dvorak (johnydog@go.cz)
Jaroslav Benkovsky (benkovsk@www.pvtnet.cz)
Jason McKnight
Jason Platt
Jonathon Doran (jon.doran@nsc.com)
Malcolm Peacock (malcolm@mpeacock.demon.co.uk)
Matt Keith (keith@www.keithcom.com)
Michael Knorr (damage-list@freenet.de)
Michael Robellard (miker@vetechno.com)
Paul Snively (psnively@earthlink.net)
Paulo Candido
Ryan J. Evans
Sebestyen Zoltan (szoli@valerie.inf.elte.hu)
Simon B. (simonb@telisphere.com)
Terrence Stewart
Thiago Ramon
Thomthee Besset (Besset@sugar-land.dowell.slb.com)
Travis McLane (tmclane@swt.edu)
Walt Armour (walt@armour.cx)
Wormz Studios (wormzstudios@iname.com)

Many thanks also for the people at GrimmWare for being the first to offer web space for Crystal Space.

Many thanks to Alessandro Russo for convincing his system manager to create a mailing list for Crystal Space. Thanks to Marco d'Itri (the system manager) for creating this list. Also thanks to those people for creating an FTP mirror of the original Crystal Space site.

Many thanks to Ted Nguyen for donating a couple copies of Microsoft Visual C++ 6 to the project.

If we have forgotten anyone or missed a contribution, we sincerely apologize. Please feel free to notify us of errors or omissions.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ]

This document was generated using texi2html 1.76.