Tim/Maj Stuff

Hello, I'm Tim Rennie (occasionally known as 'Maj').

This website contains my various misadventures in programming and Quake.

Thanks to SleepwalkR for hosting

Stuff ordered in reverse chronological order of last update.

Enjoy.

tim at fov120.com

Darkle, but with lazy evaluation.

Lazy* Func_apply(Func* func, Lazy* arg);
Func* Lazy_force(Lazy* self);
Lazy* Lazy_make(Expr* expr);
Expr* Parser_parse(const char* text);

It's been interesting going Boomtalk (Smalltalk) to Darkle (Scheme minus call/cc) to Pity (Haskell/Scheme). The code size keeps dropping and the elegance seems to increase, but I'm beginning to feel that what little practicality I started with has been lost. Could it be just my OOP-adled brain rebelling (having never really used a functional language in anger), or am I dancing on the edge of the Turing Tar Pit?

I've started trying to transform Pity into continuation passing style as well, in the hope of doing Cheney-on-the-MTA. Makes my brain hurt though, and doing anything in C becomes rather tricky. Maybe better to leave it for a compiled version.

Boomtalk, but with function application instead of message passing. Objects implemented as functions from names to methods. Scheme anyone? :]

Object* ask(Object* target, Object* arg)

(Yes, I know Object should be Function... can't be arsed renaming)

Abandoned after giving birth to Pity.

Yet another ray-tracer. Well, everyone has to write at least one, right?

Emphasis on interactive rendering of high detail objects, inspired by OpenRT.de.

Currently managing roughly 250k rays a second against a ~320k point cloud (Pentium M 1.3GHz).

• Basic ADF object using trilinear interpolation and an iterative raycast.
• Triangle mesh object with kd-tree spatial subdivision (abandoned, triangles are for the weak).
• Uniform sized point cloud object with kd-tree spatial subdivision, rendered as disks (points > triangles).
• Forth-like extension language (abandoned, concentrating on primitives first).

A lightweight, Smalltalk-like language, currently at an early stage.

Implemented in C++ using boom, a small library that implements simple objects and message sending.

Object* ask(Object* target, Name* message, Object* arg);
Object* make(DispatchTable* dispatchTable, void* data, size_t dataSize);

Abandoned after giving birth to Darkle.

Second attempt at a simple stack language (see mute for the first).

The main difference is that everything is quoted by default, except '!' and functions specially marked as compile time. Mute took the opposite approach.

make-stack ! enter-stack !
exit-stack capture-env make-compile-time-func swap switch-env
exit-stack ! capture-env ! make-compile-time-func ! ]! def !

make-stack ! enter-stack !
capture-env make-stack enter-stack
exit-stack ! capture-env ! make-compile-time-func ! [ def !


[ exit-stack capture-env make-func swap switch-env ]! ] def !

[ capture-env make-stack enter-stack ]! { def !

[ exit-stack capture-env make-func swap switch-env quote ]! } def !

[ make-stack enter-stack ]! ( def !

[ exit-stack ]! ) def !

[ capture-env make-func ] func def !


[ dup * ] sqr def !

2 sqr

A simple stack language, spawned by an attempt to implement a language in a single evening.

$ 2 dup * p

4

$ 2 : [ ( dup * ) ! ] func ! p

4

$ "sqr" : [ ( dup * ) ! ] func @
$ 2 sqr p

4

$ "<" : [ ( : [ ( ) ! ] func @
$ ">" : [ ( ) !! ] func ) ! ] func @
$ 2 < dup dup * * > ! ! p

8

$ "cube" < dup dup * * > ! @
$ 2 cube p

8

$ "{" < < > ! @
$ "}" < > !! @ > ! @
$ "quad" { dup dup dup * * * } !
$ 2 quad p

16

A basic lisp dialect.

Originally intended to be half practical high-level language with the emphasis on flexibility, and half deranged experiment in impracticalities, unit testing, and OOP in C.

Abandoned after growing too unwieldy and failing to tickle my long-term interest.

My 3rd year uni project. It was supposed to be a simple Doom engine, but somehow acquired a small component system, LISPy console language, telnet client, UNIX fs inspired resource system and limited Quake .bsp support along the way. It was written in Java and OpenGL (gl4java).

Mog was killed by a bungled rewrite attempt and my dissatisfaction with Java.

Random files here.

A plugin for GtkRadiant that renders and edits Quake3 shaders. I wrote the renderer and parser, although I no longer maintain them.

Homepage here.

If you're bored, check out the parsing code for a taste of how badly implementation inheritance and C++ templates can damage an impressionable young coder's mind.

Some docs for the Quake3 shader language. Hopelessly out of date, but perhaps more friendly than the official docs.

Here.

The only remnants of several hundred hours in front DoomEd, WorldCraft and Radiant are these screenshots. The map was intended to be for q3, but was beta'd (well, pre-alpha'd) in q2 due to the lack of compile tools for q3 at the time.

Here.