I added a simple class for dumping to WAV that I had done a few months ago, just to discard it was not SDL’s fault (it wasn’t, although PulseAudio gave me a couple of false alarms with its I’m going to sound distorted without you expecting it moments).

I am pretty sure that the bug is super ridiculously simple to fix (not that easy to find), and I have been staying here against the will of my sleepy, heavy eyelids, just in case the “A-HA!! moment” decided to materialise, but it hasn’t happened. So I guess it’s time to call it a day… and come back to this tomorrow :-(

Today I decided to do something different. And I thought: Okay, I’ll try and sort out this compiling for windows issue, so that I can focus on the rest of more important things without having to worry about it any more.

And guess what…? I think I managed to do it :-)

Roughly, these are the steps I followed, just in case someone else wants to compile for windows with opengl and sdl support, using [ubuntu] linux:

• install mingw (I did it with Synaptic Package Manager so that I didn’t have to go through the ./configure and ./make hell)
• get the dev libraries from sdl for windows/mingw –this file– or check their downloads page
• uncompress the file and locate the bin, include and lib folders within, and…
  • copy bin/SDL.dll to the folder where your win32 .exe will go — so that the exe can pick and load the dll when executing
  • copy the include and lib folders to a folder in your project’s src folder — or anywhere you’ve got access to! For example: project/src/libs/sdl/
• now in your main.cpp, include SDL’s header files like this:
  #include <SDL/SDL.h>
#include <SDL/SDL_opengl.h>
• And the makefile could be something like this too:
  WINDOWS_SDL = ./libs/sdl/windows

windows:
        i586-mingw32msvc-g++ -I$(WINDOWS_SDL)/include -L$(WINDOWS_SDL) \
main.cpp $(WINDOWS_SDL)/libSDL.dll.a -o ../test.exe\
 -lmingw32 -lSDLmain -lSDL -mwindows -lopengl32 -Wl,-R.

(ugly hard line returns added by me so that you can see all parameters in one go).

This assumes you are invoking make from the src folder. The output will go to the parent folder. But well, the most important things that need to be highlighted are the bunch of switches you need to include in order to get the program to link:

-I$(WINDOWS_SDL)/include — this tells the compiler where to look for additional header files. This way it can find <SDL/SDL.h> and you do not need to modify the file or add #define’s when building for linux.

-L$(WINDOWS_SDL) — pretty much the same but tells the compiler to look for static libraries in the WINDOWS_SDL folder too

$(WINDOWS_SDL)/libSDL.dll.a — links the library into our binary!

-lmingw32 -lSDLmain -lSDL -mwindows -lopengl32 -Wl,-R. — these are magic – remove any of them and the linker will complain about missing symbols ;)

I still have to test this in a real windows machine; so far I have just tried with Wine. The output is a little jerky and a bit slower than the native (64 bit) counterpart, but I guess this will do much better than compiling in Virtual Box and testing with Wine :D

I’ll try to upload a test .exe when I test it on a real windows box myself, so that you can test it and see if it works in your computer (if you want, of course!). It’s ages since I compiled anything for win, and I truly wonder whether it will work with Vista/7… my last demo for Windows was done in 2005 and XP was in full glory back then :P

We released this demo approximately 6 years ago. Then I was using windows and I didn’t worry about other platforms actually. Nowadays I’m using linux and get horrified with the mere thought of having to use windows again, but my demos didn’t work too well with wine. Since I still hadn’t lost the code, what about doing a portable version which works in my computer? So that’s what I have done with Scene Of The Girls.

Things that I have learnt

I expect most of you to feel skeptical about the idea of taking sources 6 years old and trying to make them work in a completely different system. But it has been an interesting experience and I have learnt a lot meanwhile.

BASS is way better than fmod

This is kind of ironic. At the beginning, I used BASS. Then when I began coding for Mac I had to use fmod, because it was the only available multiplatform library. I wasn’t too happy with the sound quality (specially for modules) but that was all that we had. I then found out that BASS was available for MacOS, so I switched back to BASS. But then I wanted to code for linux and BASS wasn’t available, so I switched again to fmod. I tried with fmod3.75 and then I noticed that I couldn’t capture the demo with it, so I moved to the newer fmodex, which did allow me to capture the demo, with audio.

And there was a big “but”: the latency. There was a considerable amount of time between the “BOOM” in the music and the images reacting. Funnily it wasn’t that the images were happening with delay; it was that the music happened to sound too late for what was being shown in the screen. You saw torus shaking, and a quarter of a second later, there was a bassdrum kick. Something was decidedly wrong. I copied the code to a usb pen stick, and compiled everything on my powerbook with MacOSX, just to dismiss any possible ALSA+Pulseaudio+whatever latency issue. After all, supposedly MacOSX sound drivers have a very good latency. But the problem was still there. I tried on mrdoob’s laptop (a Macbook running Linux) and the latency was still there. Luckily before I began to code my own sound/module playing library I thought of having a look at the BASS site again, just in case they happened to have released a linux version and oh joy! there it was!

I then proceeded to change once again my Music.h/cpp wrapper. I congratulate myself each time I have to change the wrapper, because thanks to having the wrapper I don’t have to change every other call in the code. Then I ran the demo again, in linux, and the latency had gone away! YEAH! Even more, the song sounds WAY BETTER, because BASS interprets properly the resonant filters the song uses. That was a supercool moment!

So unfortunately for the fmod guys, sorry, but there’s something wrong in your library. Although to be honest, the fmod API is nicer and doesn’t make you think of bytes when what you want to know is how many seconds have elapsed, but is the price you have to pay for no delays.

GLC: a .kkapture alternative for linux

Normally one would capture a demo with .kkapture… if he happened to be using windows. Us linux-ers are left out without any alternative… or not! Because I found glc. It can capture opengl windows along with its associated audio and it works very well actually. I used it for capturing the demo and publishing it in youtube, after encoding it to mp4 with this script.

getopt_long is confusing, but very rewarding

To date I had only used a very basic style of argument parsing. I decided I would have something better, and I used getopt_long for it. This allowed me to add a lot of configuration options which before had been hardcoded in the demo and forced me to recompile each time I wanted to test a different parameter. You can see how I used it in the parse_arguments function in main.cpp.

PyGTK is very cool

This also set the path clear for the next thing I wanted: a nice launcher for people who do not want to type in a series of config options to launch the demo. I made the launcher with pygtk, and verified it works on any vanilla ubuntu (as I suspected, pygtk comes by default with the system because several basic applications depend on it).

So I just open that GTK window with some checkboxes and pulldown lists and let the user choose what he wants, and it builds up the config settings for the executable, and calls it. And when developing, one just had to press the up arrow to get the last typed in command and relaunch the demo using those very same parameters, instead of having to select them manually in the launcher dialogue. Simple linux style, I like it!

VBlank is off by default, whatever they say

I had lots of tearing in my app, even in window mode. I checked the SDL docs and they mentioned an GL attribute (SDL_GL_SWAP_CONTROL) that could be activated but was deprecated, and activated by default. I tried it anyway, explicitly setting it to true and surprise! the tearing and flickering went away!

And now…

I guess I’ll continue releasing the remaining sources, once I get them to work here and wipe up extremely confusing stuff. The main goal is to let someone else learn from the code just as I did when looking at the code of other demos and specially sites like NeHe. There aren’t superclever tricks in this demo, it is all fairly basic and if you want to code an opengl demo, it should be a good basis, at least for experimenting and changing things here and there. So come on, play with the code, experiment with it and make something better. And let me know afterwards!

Damn geeks

First, we have a bit of a desperate cry by a certain Solomon Grundy:

Damn geeks. They’ve screwed up everything. They can’t even get something as simple as the Internet right. No wonder 70% of financial application are still coded in COBOL and don’t use the Internet as their primary avenue of communications.

from the comments at Adobe yanks speech exposing critical ‘clickjacking’ vulns. By the way, why do the Register guys have anchors for each individual comment, but do not show them? I had to use the very helpful Web Developer Toolbar once again for revealing anchors in the page (Information — Display anchors, just in case you need it). Damn geeks!

So yes, that’s quite serious. It seems there’s no way things can be done properly when the internet factor is in the mix. When in doubt, simply blame the Robustness principle: Be liberal in what you accept, and conservative in what you send.

Googleskepticism or just plain common sense?

Following the release of Google’s Chrome, one had the immediate feeling that it was going to be a big news — not only appearing at generalist media but even prompting our families to ask us about that new system Google has released for competing against Bill’s (literally). I wasn’t impressed at all by the G-move neither did feel immediately compelled to download and test it (besides my computer doesn’t run Windows anyway), so I just ignored the complete commotion. But it seems Ted Dziuba got a bit more irritated with all the publicity and media fueled bullshit and/or plain lies and simply ended up exploding:

I understand the argument that as web applications proliferate, the desktop operating system becomes less important, and emphasis is placed on the browser. That’s all well and good, but let’s be realistic here. It’s a fucking web browser. It runs JavaScript a bit faster than other web browsers. That doesn’t add up to a Windows killer.

[...]

People are calling Chrome a cloud operating system because it is a “platform for running web apps”. It renders HTML and interprets Javascript, you know, like every fucking browser made since 1995. It’s also got Google Gears built in. Great. I’ll alert Tim Berners-Lee.

(emphasis added by me)

He also notes the big amount of nonsense that Michael Arrington managed (once again) to produce for the occasion, with allusions to the new and upcoming hot keyword – cloud computing. I would suggest Ted –and any of you–, only one thing: do not read Techcrunch, for your own mental health.

On confusing people

Only two words: Microsoft SDL.

Why did they have to use an acronym which is so well established is something that I can’t understand. Furthermore, Microsoft SDL doesn’t stand up for anything remotely related to media or games. Do not even think they are ditching DirectX for the true SDL. In fact, their SDL is the deceptively boring acronym of Secure Development Lifecycle. Which, coming from Microsoft, absolutely deserves a place on the IT fun saga with a special award in the “Irony” category!

Following the installation of the toolchain, I decided to make a little program to get some information about the PSP’s interface, from the programmers point of view. That is, it would use SDL’s joystick functions to find out how many axis and buttons and which codes did they report to the program. Although it might seem useless it is an easy exercise in checking events and it could even be the base for a future game.

I first tested the program on my computer, using a Logitech USB pad that I have for playing emulators. I intended to use it for real games but I still haven’t found one which doesn’t use the mouse. By the way, the pad works flawlessly in linux, just in case you were looking for a compatible joystick for your linux box.

The pad reported as having six axes, where the axes corresponded to the two analog joysticks and one digital joystick (two axes per joystick: vertical and horizontal), so I was expecting to find a very similar result in the PSP, but with four axes since it only has two joysticks.

Instead, I got an interesting result: two axes only, and the rest were buttons! PSP is reporting the digital joystick as simply four isolated buttons. This, although being surprising, also makes much easier to program simple stuff where you just need to react when a button has been pressed, instead of having to check the value of the axis which is reporting motions, and deduct the appropriate intended direction from there.

I also noticed that the analog joystick can sometimes have a very erratic behaviour, reporting movements while no one is even touching the console. It might be because it’s not a brand new PSP and maybe there’s some dirt or something in the controls … or maybe we were experiencing a earthquake and nobody noticed? :)

For the record, these are the reported SDL button codes, so you can look for an SDL_JOYBUTTONDOWN type of event, and compare event.jbutton.button to the following values to decide what to do:

Left: 7
Right: 9
Up: 8
Down: 6
L: 4
R: 5
Triangle: 0
Square: 3
Circle: 1
Cross: 2
start: 11
select: 10

I didn’t manage to read the other buttons, they seem to be out of the reach of SDL. Maybe it’s got something to do with kernel/user mode, but it doesn’t worry me for the time being.

If you want to try this at home – worry not, it’s safe and harmless! Here’s the source code. You’ll notice I also used the balls and hats functions, but I must confess that while I suspect that balls is referring to trackballs, I have no idea what hats is referring to. If anybody knows, let me know in the comments so that I can stop imagining a little Mexican hat dressing a gamepad :-D

Here’s also a possible sample output, using my logitech pad and pressing buttons and moving sticks randomly: