QuakeForge v0.5.2

QuakeForge v0.5.2

QuakeForge is a 3D graphics game engine based on id Software's legendary Quake and QuakeWorld game engine. See more info for the huge list of new features.

The number of changes is FAR too high to mention (the change log is almost 10% the size of a full source tree now!), but here are some highlights:

General enhancements:

NQ (quake1, single player, NetQuake, WinQuake) is back!

Video (driver and renderer), audio, gamecode (progs), console, model loading and general utility code shared in common libs between the NQ and QW code bases.

Plugin system for sound and CD audio drivers.

Ogg Vorbis compression for sound effect samples (streaming Ogg support is planned).

Menu system re-written in QuakeC/Ruamoko

Curses-based console for servers on Unix-like systems.

New, more flexible, key binding system.

Rendering enhancements:

Experimental 32-bit-per-pixel software renderer.

Dynamic lights don't shine through walls.

Colored alias model lighting for OpenGL targets.

Vertex Array use for sprites, particles and text. There are no fallbacks yet, so QuakeForge won't work yet with old or broken OpenGL drivers.

Selectable particle styles: Set r_particles_style to zero for Id-style particle effects. The default is 1, giving larger, textured particles and a lower overall particle count.

The Alias model format has been extended with the capacity for 16-bit vertices. This gives new models the ability to have a lot more precision.

Improved software-based gamma correction that more closely resembles hardware gamma correction.

Countless speed improvements.

Progs engine enhancements:

Fully modular. Mod/Server-independant, allowing for stand-alone QuakeC interpreters and client-side code.

The engine is no longer dependent on progdefs.h. As a side effect, this makes QuakeForge have trouble with QuakeC compilers that strip symbol names -- but those files can be repaired using the new qfdefs tool.

New basic types, and instructions for using them, for version 0.fff.002 progs (Quake's Version 6 is still supported).

Better dynamic string handling. Dynamic strings are garbage-collected.

Object-oriented runtime system, in the style of Objective-C.

Runtime fixups of built-in functions whose builtin number is zero. If a built-in function is available to the engine, with the same name given in the source code (e.g. "void (void) coredump = #0;"), the engine will set the value to the actual number used by the engine.

Debugging support (needs compiler support, which qfcc provides), including line-number information. Can display the line of text in the source on which an error occurred, if the new Cvar pr_source_path is set correctly.

Instruction-level code dumps are now formatted in an easier-to-read "assembly-code" format.

QuakeForge Code Compiler, qfcc -- a replacement for qcc:

Uses libQFutil for general utility functions such as hash tables, file access (incomplete), and pak files.

Uses libQFgamecode for progs information, such as opcode tables, enums, types, etc.)

Uses a lex/yacc (actually, Flex and Bison) scanner/parser architecture, like a "real" compiler does.

Drastically reduces the number of global defs needed for a given progs, by reusing temporary globals when possible.

All functions use the same block of defs for their local variables (compatible with all known servers), which further reduces the number of global defs needed.

Nested/chained function calls work properly.

Simple expressions, such as "a = b + c;", compile to a single instruction instead of two, and do not use a temporary variable.

Local variables can be initialized to known values, as in "local float foo = 0.1;".

Uses the C preprocessor, so header files are now possible and useful.

The compiler checks for uninitialized and unused variables in functions, to help in finding errors.

The compiler can generate and use object files, for separate compilation (you don't have to compile all of your source all the time, only the parts that have changed). Normally, object files have a .qfo extension.

The compiler can link libraries, which are implemented as .qfo files inside pak archives.

The compiler implements stricter type checking, to assist in finding and fixing code errors.

The C language's for, do ... while, and switch control structures have been adopted to provide a richer set of structures for programmers to use.

Additional functionality is given for progs that are to be used with QuakeForge's more advanced progs engine:

IMPORTANT: The order of operations is slightly different in "native" mode. The evaluation of !foo & bar is no longer !(foo & bar), but rather (!foo) & bar. The new order of operations rules are more correct, but is different from how qcc evaluated. If you give the --traditional switch to qfcc's command-line, the old behavior is used.

The compiler now allows you to create your own functions that can accept a variable number of arguments, using the special "..." notation. The special constants @argc and @argv help with this. @argc contains the number of arguments, and @argv contains a list of those arguments. The handling of this is an improvement on C's vararg function handling in our opinion, made possible by how the Quake system works.

New basic types: integer, pointer, enum, and id.

You can create new complex types, like arrays, structures, and unions, and allocate them at runtime.

String operators. You can add strings together to concatenate them, and you can compare their contents using the <=, <, >, >= operators.

The integer type has the full assortment of C operations available to it.

qfcc and QuakeForge now contain an object-oriented programming system, in the style of Objective-C and Smalltalk. It's *very* powerful, and can be used to create lots of interesting new things with rather little effort. If you don't wish to use the new system, you can safely ignore it with no danger to your code. :)

Special support for using the self special variable inside OO methods as well as the entity of the same name. If you use OO support for entities and want to assign a method as a touch/think/etc. function, self always refers to the object that "owns" the method being executed. The special variable @self was created to refer to the self entity. @this refers to the object.

Enhanced console scripting - GIB (GIB Isn't Bash)

New language, derived from the Quake console "language".

Functions with arguments and return values.

Looping (while, for) and branching (if) commands.

Local and global variables as well as access to Cvars. Supports Python-like slicing of variables.

A basic math interpreter that respects order of operations and provides most arithmetic and logic operators.

Non-preemptive threading and callbacks to GIB functions in response to game events (limited, but functional at the moment).

File reading, writing, and searching.

Integrates with console -- GIB functions can be exported as console commands to be used at the console or in binds.

See the GIB documentation for more information.

Enhanced time cheat ("speed cheat") protection:

Time cheats only work for a split-second before protection kicks in.

Players moving with wrong timings are sped up/slowed down to the correct speed.

The delay before the protection system activates means that lag and normal network latency won't affect it.

People who aren't really trying to cheat won't be kicked :)

Known problems in version 0.5.2:

Doesn't currently work with 3Dfx cards in MS Windows due to our use of vertex arrays. This should be fixed in 0.5.3.

SDL clients don't reliably support fullscreen mode in MS Windows.

MS Windows support in general is sorely under-tested.

Starting an SDL-based client (-sdl, -sgl, or -sdl32) in full-screen mode and then going into windowed mode requires the in_grab Cvar to be toggled from 0 to 1 and back to 0 before the mouse will be released.