An orange in an apple orchard
Local time is reading 01:40R, so it seems that I’ve survived another Christmas on this rock. Much of the day, has really been spent trying to avoid the holiday altogether, for all practical intents and purposes. At least I got plenty of C code written for my games :-/.
The only real good thing out of the day, was a the ecard a friend sent—my one smile of the day.
As some no, after spending a night of debugging only to learn that I had typed structobj,member instead of structojb.member, after a 6-8 hour coding run, I went in search of a new font. The font I found, was Terminus, and ever since I have _absolutely fucking loved it_ in fact, I can’t even look at my terminal in another font without missing it.
When filing a bug report to the libmng folks, I left a comment in the bug entry about using a font where O != 0; then went in search of my dear terminus, and then found this and just had to install them :-D.
Terminus is my favourite font, but my only compliant has been needing X to actually enjoy it…. now that’s solved!
Take note: I install libraries into C:DevFilesLibrariesWhat; with compiler specific files dumped under sub folders, e.g. C:DevFilesLibrarieszlibmsvczdll.lib and C:DevFilesLibrarieszlibmingwlibzdll.a. Like wise, I leave a README.TXT file in the root, noting anything I will need to remember when it comes to using the library.
# build for Visual C++ 2008 / 9.0
> unzip "pathtojpegsr7.zip"
# I want it in jpegsrc for safe keeping
> mkdir jpeg
> move jpeg-7 jpegsrc
# use the corresponding .vcX files for version
> copy makeasln.vc9 apps.sln
> copy makejsln.vc9 jpeg.sln
> copy makewvcp.vc9 wrjpgcom.vcproj
> copy maketvcp.vc9 jpegtran.vcproj
> copy makervcp.vc9 rdjpgcom.vcproj
> copy makedvcp.vc9 djpeg.vcproj
> copy makecvcp.vc9 cjpeg.vcproj
> copy makejvcp.vc9 jpeg.vcproj
> copy jconfig.vc jconfig.h
# I'm using vcbuild, since I read .vcproj files in vim; you may want the IDE
> vcbuild /nologo jpeg.sln "Release|Win32"
...
> vcbuild /nologo apps.sln "Release|Win32"
# I put compiler specific files in a suitable folder
> mkdir ..msvc
> copy Releasejpeg.lib ..msvc
# jconfig.h is compiler specific, so we dump it in our compiler directory
> copy jconfig.h ..msvc
> del jconfig.h
# build for MinGW/MSys
$ pushd /C/DevFiles/Libraries/jpeg/
$ pushd src
# works for most packages
$ ./configure --prefix=/C/DevFiles/Libraries/jpeg/ --exec-prefix=/C/DevFiles/L
ibraries/jpeg/mingw/
$ make
$ make install
# move jconfig out of independent include and into compiler specific dir
$ mv ../include/jconfig.h
Now copy jerror.h, jinclude.h, jmorecfg.h, jpegint.h, and jpeglib.h into ../include/. Those are the portable headers, that won’t very based on compiler (MinGW/MSVC).
and here’s my notes file:
MinGW -> static link as normal
MinGW -> Use import library libjpeg.dll.a for dynamic linking with libjpeg-7.dll
MinGW -> Last build JPEG-7 on 2009-12-24MSVC -> Can only static link agaisnt jpeg.lib; must use /MD
MSVC -> also add msvc/ to include path, for jconfig.h
MSVC -> Last build JPEG-7 on 2009-12-23In all cases, add include + compiler folders to your include path.
Although my original plan for the day, was to spend it working on Stargella, I’ve not found time for it, and I’ve to much of a headache now to worry about it.
I got in some good SWAT action then set to work on dependency compiling and evaluation, getting the freetype and jpeg libraries built. It was excellent to see that the freetype folks know how to use autotools, something a lot of projects fail at; and that jpeg has an gone through insane hoops to make their package easily built, on virtually anything lol. Tomorrow is moving on to other libs that may be useful. Since the handling of model and map information, will likely be done through XML files, I also need to start evaluating XML parsers again; something I have absolutely no love for. Also, because of that, there’s no point in taking a few moments to write a simple config file parser, when the application requires an XML parser :-S.
Code wise, the main focus for the day was to be working on implementing a simple drop down console, but I haven’t had time to focus on it, due to the time and effort it takes to compile software in a Windows environment. Which is approximately 200% more trouble then a unix environment, or 90% higher if it’s a Linux application written by assholes who knew less about what they’re doing then the puts who wrote the tools 8=).
I’m interested in seeing what SDL_ttf can do for rendering the textual part of the console, but that requires freetype, lol. Freetype however is a very painless thing to setup under Windows, at least using MinGW and MSVC. Whether or not SDL_ttf will be so hunky dory, remains to be seen.
Also spent some time in evaluating the concept of using JavaScript as an embedded scripting language. Mozillas Spidermonkey seems to be the only engine that fits the bill: written in C. It’s also fairly portable and has one hell of a nice (JS)API , with out a doubt it’s gotta be a lovely way of embedding a language into your program. The only problem, the build system issues. I will explore it’s compilation under Windows but expect it to be a wash out. The comments about autotools alone, virtually make Spidermonkey something you can rule out of any sane programmers toolkit. I’ve already learned about Python extension modules, but have never had time to look closely into embedding the interp into an application, but will do that also in time. Another thing to consider, is embedding Lua, a language I’ve never had an excuse to study, lol.
On the embedding a language thing, my thoughts are focused around in game scripting, more so then implementing the game in it. Although with the JSAPI, it wouldn’t be to tricky to do the entire game in JavaScript, as absurd as that might sound to the uninformed. For Stargella, the scripting needs can actually be integrated into the map data, in a fairly simple manor as firing positional events off to the game code. However the underlying code is meant to be (largely) shared across several games, and some (the tactical fps for example) will need much more useful scripting capabilities. Using shared objects written in C would be possible, but then maps would become non-platform independent, and I don’t want that. Quakes solution, was inventing their own C based language, and to a lesser extent the Q3VM, but ahem, I’m not quite going to do that :-P.
Some how, the idea of scripting the game system using JavaScript is still an attractive idea…. but do I really want to live with compiling Spidermonkey in order to do it?
The principal concept of any build tool, is building stuff. In my opinion, make has the perfect idea for it: just tell it what you want, then tell you want done about it.Then exploit that what you want done, can usually be guessed or written once, hehe.
At it’s heart, tmk is still a `make`, and perhaps barrows the most from classic make and from Qts project file sytax. Personally, I feel tmk makes things more simple, I’ll not repeat here what I’m loading into the Wiki on Source Forge however.
In dealing yet again with compiling dependencies under Win32, and yet again having to deal with a yucky mixture of GNU Autotools, CMake, and IDE-x project files…. I’ve come back to thinking about an idea from several months ago, for a project called `yet another build system`; which led me to learning CMake.
The original (yabs) idea, was centred around the concept of XML descriptions of build tools, most namely the Visual C++ and GNU compilers. Which would have been mated with a simple `make` like list of rules, basically on par with the inference rules everyone knows, and loves (or hates).
For tmk however, the horizon has expanded and the XML is dropped lol. tmk is meant to be very much, a more portable make with interesting tuning options. Conceptually, it’s the same, but, eh fixed you could say. If you don’t understand that, just think back to using Makefiles and having to support 20 different build environments! Yeah, that kind of fixing.
The main point, is abstracting away the shoe honing measures. Make is perfect for the environment it was created for, building software on UNIX. However unix has diversified and fragmented sufficiently, that the average programmer is a useless stick in the mud for writing portable sh, supporting other environments like Windows, generally requires a separate set of Makefiles or carting along the (superior) unix environment with you, which is a terrible way of doing things. Fixing that problem is simple, it’s been done.
A novel feature, tmk will aim to complete builds as quickly as possible: by inferring from the rules how to build modules in parallel, which also provides me an excuse to write some code I’ve been meaning to write for EPI ;). This part is also easy.
The interesting part, will be handling dependencies properly. The real royal fuck-baked irk of most ‘later day make’ solutions, such as CMake or VCBuild, are that can’t handle dependencies worth a shit: and it makes building software off the original work station (windows) or operating system group (unix) a bitch and a half.
That’s the personal itch tmk has to fix 😉
One notable feature of .fetchmailrc syntax is the use of optional noise keywords that are supported simply in order to make the specifications read a bit more like English. The ‘with’ keywords and single occurrence of ‘options’ in the example aren’t actually necessary, but they help make the declarations easier to read at a glance.
The traditional term for this sort of thing is syntactic sugar; the maxim that goes with this is a famous quip that “syntactic sugar causes cancer of the semicolon”.[88] Indeed, syntactic sugar needs to be used sparingly lest it obscure more than help.
Having a bit of time free, I’ve elected to work on my games resource sub system. Overall, the whole game is a lot like Id Tech 3 in architecture, because it’s exactly the kind of architecture I want, even if I don’t want to put up with the engine that powered Quake III: Arena so excellently.
For the resource loading, what I want is for a configuration file to define what packages should be loaded, kind of like a PATH for zip files. When something needs to be loaded, it’ll be be found at a path, like foo.zip:/what/file.ext— telling the sub system to locate foo.zip in the game or user data directory, then return a handle to the /what/file.ext stored inside of it. As opposed to the more Id approach, where file naming, e.g. pak0.pk3, pak1.pk3, … controls the loading order, I want my game to use a config file to handle that. Because personally, I think having to remember which machine friendly name a resource resides at, is a pain in the arse for making maps and mods >_>.
Because I’m running things very light on dependencies, mostly because compiling stuff on Windows is a bitch (stupid programmers) and many useful items are not easily available on FreeBSD. So things will probably be built on top of zlib, using contrib/minizip as an example of using zlib with the ZIP format.
It has been a some what hectic day, logged off around 0400R last night and couldn’t sleep, by the time I finally started to doze off, ma started shouting and jarred me awake again :-(.
Fast forward to like 0815 this morning and she does the same damn thing, I’ve had about 3 hours sleep, tops. Getting back to sleep is unbearable, improbable, and time passes slowly. Fast forward again, to about 1045R, and I’m thusly awoke again. In fact, by this point, I’ve had sooo little sleep, that I didn’t even realise that I was having a dream, until I was woken up! Went back to bed and finally got up sometime after 1200R, to be used yet again as a cheap slave…. I’m tired of being nothing more then an asset.
The only positive things so far, is I’ve had time (~1 hour) to play with my file server with only a half dozen interruptions or so. For me, that’s a blessing.
No idea what I’m going to do for the rest of the day, I’m not really in a good mood…. and there’s nothing much that I can get done right now, that is not going to result in headaches later. I fucking hate my life here.
As has been on my todo list for a while, is setting up cron jobs for running dump on my file server, as an “Extra” safe guard to the fact, that my data is mirrored across three different computers already, hehe. (I also do periodic backups to a separate cold storage partition, and priority files to CD-R every year or two.)
My main concern there of course being, how to do it without compromising disk space to much, after all we’re talking about a lot of crap lol. In writing my test script, I’ve also experimented with piping dump into lzma for compression, but at least with Vectra’s scarce resources, is a bit toooo much for the box to handle the data sets involved. Then I started to think, gee, wouldn’t it be cool to just keep a SQLite database that stores logs of changes (cron’d from a script), and then periodically run ZIP on the target, excluding unchanged files since the last backup. Effectively creating a smart form of dump, that functions at a different file system layer (e.g. like tar or cpio).
Then I started to think, well, the best existing solution that I’ve ever bumped into my travels, is a program called Bacula, but I’ve never had to to explore it. With a little poking around, it seems that Bacula is very much the kind of system that I would like to have.
Which poses three questions:
So, sadly it will probably be some time after the new year has come and gone, that I’ll have time to return to this loop; my RTM updated accordingly. On the upside, if three hard disks in separate locations of the building, and with very controlled data replication patterns, some how fails before then…. the entire building will likely have collapsed, so it would be the least of my worries lol.