Older blog entries for ingvar (starting at number 163)

Stringification of symbols now changed (instead of starting capitalized, we check what package they live in and if they're tagged as being in the "opengl-glue" package we capitalize and prefix with "gl_", previously we always capitalised and prefixed with "gl_" if needed).

Type declarations for backends now in place. Still looking at getting a whole lot of "run code in lisp" glue in (quite a few of the OpenGL functions are suitably variadic and will thus need shadowing so we use internal functions instead of CL functions, since (sin #(3.0 0.1 1.0)) will cause a problem).

Not in possesion of Handy Cool things to paste, but...

New function implemented (named RUN-SHADER). This will (if needed) compute a suitable lambda closure, compile it and cache it in the shader. It will then apply that closure to the arguments passed in.

Signature is (run-shader shader-designator &rest args).

Closer. Not quite there.

LISPGRAPHICS> (defvert test-shader (a b) (declare (ftype (function (fixnum fixnum) fixnum) test-shader)) (return (+ a b)))
TEST-SHADER
LISPGRAPHICS> (emit-code t :opengl (find-shader 'test-shader))
int TestShader (int A,int B)
{
  return (A+B);
}
NIL

"All" that is left is paste over the cracks. Also need to handle the fall-back in type-finding. Probably should write a helper function to extract type data given a symbol and a shader.

Ooooh. We're slowly getting there (I have done some line-breaking and indenting of the expression, so as to make it clearer what's happening):

LISPGRAPHICS> (emit-code t :opengl '(for (setf a 0) (<= a 10) (incf a)
					 (setf (aref b a) a)
					 (if (= a 3)
					     (incf a))))
for (A=0;A<=10;++A)
{
  B[A]=A;
  if (A==3)
    ++A;
}
NIL
LISPGRAPHICS> 

At this pace, I might, possibly, have something releasable before the end of the year, though I'd advise not to hold one's breath while waiting. I shall also ponder how easiest to get compiled lisp code to test, without interacting with OpenGL (that has to be a boon, right, being able to test the values... probably not, come to think of it, it's the varying variables that are of interest, isn't it? ah, well...), should only be some code construction and a well-chosen call to COMPILE.

Once the OpenGL backend is in place, I'm vaguely considering looking at a DirectX backend, but that's so far in the future that...

Still not deat yet.

Gatlopp is on the back-burner. I have a new insane project in progress. THis time, I am looking slightly more three-dimensional than the flatness of Gatlopp,though I don't have anything planned for actually using the latest project. However, I thought it was time to get shaders into lisp, properly (as has been discussed elsewhere, CL support of OpenGL shaders boils down th the ability of creating arrays of C strings, arrays of integers and FFI-callability of a couple of functions).

This morning, I looked at iteration and as much as I would've wanted to include support for the CL LOOP facility, it is a bit too complex to allow for "trivial" compilation to GLSL, so I have decided that one will have to make do with syntethic FOR, WHILE and DO-WHILE statements. It'll just have to do (the FOR statement is similar to the normal DO facility, but tuned towards trivial conversion; WHILE is essentially identical to its elisp counterpart and DO-WHILE is a WHILE testing at the end instead of at the start).

Nothing available for download. Probably won't be for a while.

Also, mad props to Xach, his wife and his newborn son!

"Not dead yet!"

There's been some progress on fixing bugs in Gatlopp. The map problem (hotfix in my previous entry has been incorporated. The shearing underneath the main character when moving on a scrolling map has improved (it's not gone, unfortunately, I can't seem to sync the update of the two window backgrounds and the moved window close enough to make the shearing go away. I fear there's "looking at XSHAPE" in my future).

The "key repeat bug" under MacOS X will, alas, have to stay, until I can figure out a good-enough way of low-pass-filtering the key-down state (I was considering that as a fix, when the problem initially surfaced, but...). I guess one option would be to simply switch to "move mouse around" (possibly by placing the mouse in the right nonant and using the mouse buttons to fire and such-like, that'd even give me some more action buttons). In short, I feel this is a bug in MacOS X, not in Gatlopp. :/

Other bugs? Yes, there's been a few reports. One I haven't been able to reproduce and one should be fixed (the "rays" repoducing on top of their grilles and getting stuck on top of each other), taht was down to some seriously dodgy logic to see if the ray could move off its spawn-grille safely (hint, if you need to have an offset from a centre-point and adjust everything for it, do NOT add in the adjustment when you check if thing's changed, it's already been accounted for...).

Sorry, everyone. I forgot to include the 0th map.

Tarball updated. To save download time, stick this in graphics/test0.map:

0 8 8
########
#++++++#
#+    +#
#+    +#
#+    +#
#+    +#
#++++++#
########

So, it is released (well, strictly speaking, available for download). BSD-type license. Still not brilliant, but I guess I'll survive.

So, I got distracted by making a "mushroom name framework" (currently, alas, only listing English, Swedish and Latin names for assorted mushrooms; also in need for some explanatory exposition, I guess).

However, there's a couple of "Compiler notes" when compiling with SBCL and with Lispworks personal. THose who have the source URL can, at will, grab a fresher tarball. Not quite at a stage where everything is as should be (for one, there's information in the status bar that sould go away).

I'm hoping to be ready for a release comes Friday.

Code-cleanup. Whittling away at the compile warnings, one by one (as long as it's "only notes and style-warnings" I'm not to worried, but...)