Last week I have ported two chapters (the first 10 lessons) of the NeHe OpenGL lessons to make use of the Qt toolkit. You will notice that the code in Qt is much cleaner and simpler than the code in the original NeHe lessons. There is no need to create a rendering or device context yourself or anything like that, and input support like input from keyboard or mouse can simply be implemented by reimplementing one function. As an added bonus, your 3D applications will run on pretty much any platform.

First chapter: setting up an OpenGL window, polygons, colors, rotation, 3D shapes

After completing the first chapter, you will end up with a rotating pyramid and cube…

This video shows the end result (lesson 5).
You can download the Qt 4 source code for this chapter here.

Second chapter: texture mapping, texture filters, lighting, keyboard control, blending, moving bitmaps in 3D space, loading and moving through a 3D world

In the second chapter you will learn a lot about textures, among some other things. Sometimes we make use of QGLContext::bindTexture() to load an image, morph it into a texture and bind it to OpenGL all in one go. Other times we will do it manually because we want to specify the texture filter ourselves (but we do have QGLWidget::convertToGLFormat() which makes that easy as well). To handle keypresses we simply reimplement keyPressEvent(). To load in the 3D world from the file we make use of the excellent QFile and QTextStream classes. As an added bonus, we also make use of QGLWidget::renderText() to show the user what has changed when a key is pressed inside the OpenGL window. Lesson 9 also features a bonus fade-in effect for the revived stars. This makes the effect look much cooler.

This video shows the result of adding texture filters, lighting and keyboard control (lesson 7)
This video shows the result of all the above plus blending (lesson 8)
This video shows the result of moving bitmaps in 3D space (lesson 9)
This video shows the result of moving through a very simple 3D world (lesson 10)
You can download the Qt 4 source code for this chapter here.

The third and fourth chapter are almost complete as well, but I will give you the Qt ports of those chapters another time. Perhaps tomorrow.

I started with a CLFS (Cross-compiled Linux From Scratch) installation yesterday. After major issues which I encountered when trying to boot the new kernel, I managed to create a very minimalistic kernel configuration which built a kernel that was able to boot up! I now have a very minimal Linux installation.

It’s not done yet, though. I will now have to install base system software, build a more advanced kernel, and then start building and integrating different software components of my personal choice. After this project I might either start my own Linux distribution (either from scratch, or based on Arch Linux) or just provide a repository for Arch Linux which contains some special software and help with Arch Linux development – because the goals of the Arch Linux distribution are very similar to mine. I also want to provide a repository with custom kernels and software which improve performance for all laptops that are sold by Hasselt University since 2008. I would however like to improve some things upstream as well, for example add a graphical installer and create an auto-system-configure tool which sets up Arch Linux for specific usage, and I’m not entirely sure yet whether these would be welcome changes upstream. If not, I might have to resort to an Arch Linux fork or my own distribution from scratch.

The last few days I’ve been looking at x86 Linux assembler programming. I think it’s important to know how the code which you write in higher-level languages gets translated to low-level instructions and in what way things like libc or the kernel are involved. With some knowledge of assembler you can not only directly optimize some slower operations by implementing them in low-level assembly and by utilizing specific processor features, but in general you will also learn in which ways you can optimize your software by just writing the high-level code a little bit different – by anticipating how your code will translate into low-level assembler instructions.

That was my motivation for trying to do a few things with the Netwide Assembler (NASM). The result is a simple demo which utilizes libc, GLUT and OpenGL to display a rotating pyramid and cube.

compiled ogl.asm application running in Ubuntu 8.04

The resulting code can be viewed here:

I have also written two other smaller examples:
- marketing.asm is a really simple statistics application which calculates the ideal sample size given a few parameters
- alsawav.asm is a simple audio library which utilizes ALSA to play an unbuffered raw WAV/PCM sample

Please note that all these examples require an x86 Linux distribution. These examples will not work on any other operating system.

This blog is back! After nearly a year of silence, I decided to recreate my old techblog.
Thanks to some handy UNIX tools (vim, grep, sed) I was able to reformat my old MySQL dump into a format which is accepted by this newer version of Wordpress.

I have currently hidden all my old posts though, but most of them will come on line again after a small review, because some posts contain broken links and broken images.

edit: mosts posts are back online!

For the future of this blog, I will write all my blogposts in English. That way I can reach more people. I don’t think this is a big issue, since most guys and girls who are interested in technology will know enough English to read my blog. But if you have another opinion on the matter, please do tell me.