Henrik Poulsen's Blog

Regular Expressions: Learning by doing

2012-01-15T16:31:00.000+01:00

Why
Regular expressions are a behemoth of syntactical nightmares, that is at least the opinion I have always had of regular expressions in the past. The problem with learning it, in my opinion, is the lack of guided examples that are similar to what I want to accomplish. The tutorials tend to just be very generic explanations of the syntax and when you end up trying to use it to fit your purposes it all collapses on your head.
So I want to solve a scenario I need the help of regular expressions for and hopefully it will be helpful for someone else down the line.
This is just a very basic guide to a simple scenario and I will not go in depth into what exactly everything does. The hopes is just that it will bring a little clarity to other lost souls out there.

What
There is a need for remaking the logging logic for a system I am working on, since it was very basic and very outdated (timestamps didn't record milliseconds, no severity of the output in the logs and little to no context to the content of the print). After having that done I was curious about the aspect of developing a small python script which could extract useful information from the massive amounts of logs, to aid the people that actually have to read the logs when problems arise.
Some example situations might be as follows.

Only show entries for

A certain time/date interval.
Specific processes.
A specific process id.

So we need to be able to extract the different elements of a log entry so that the script then can utilize them in any way we might need them.

The log format I want to process is similar to the following:

[2012-01-13 13:00:00.250,    Error <   MyServer:8071  > [ContextInProcess|LocalInfo] Gosh! Something went wrong around here
[2012-01-13 13:00:00:270,     Info <otherserver:2871  > [BullshitDetector] MyServer was just joking.
Go ahead and ignore it.

What we can see here is that the information is padded to help with readability (since these logs are made for humans, so they need to be easy to read) and multi-line entries are allowed as well.

So this post will be focused on parsing out the different elements of the log entries so they can be processed later.

How
Since we have some different elements to the log entries we want to be able to extract these and put names to them so we can easily utilize them later.

So since this is quite a daunting task, for the regex-phobic, we take this one step at a time and start very simple.
First we create a simple python script which just reads in my log sample from above and runs it through re.compile and then we can continue building from there.

import re
def main():
    file = open("Log.txt")
    com = re.compile(r'^(?P<everything>.*)', re.X)
    for line in file:
        match = com.match(line);
        if match:
            print match.groupdict()
    file.close()
    pass

if __name__ == '__main__':
    main()

The python code itself should be quite straight forward.
We open Log.txt, then read it one line at a time and run it through the regular expression we set up, if it matches we just print out the resulting dictionary, then we close the file.
One interesting thing about the python code is re.X, this enables verbose mode for the regex compiler.
This basically means that it will ignore any white spaces we insert into the expression (with some exceptions), and allows us to comment the expression with #, which allows us to make the expression readable in our code.
So this is what it would look like if we tried to structure the above expression a little bit better.

re.compile(r'''
    ^                   # from the start of the line
    (?P<everything>     # we create a group called "everything"
        .*              # the group will match anything
    )                   # end of group     
    ''', re.X)

It will give the exact same result, but now it is so readable that I doubt I will have to explain the elements of this expression.
So now lets tackle the expression itself. After running the script you would get the following output.

{'everything': '[2012-01-13 13:00:00.250,    Error <   MyServer:8071  > [ContextInProcess|LocalInfo] Gosh! Something went wrong around here'}
{'everything': '[2012-01-13 13:00:00:270,     Info <otherserver:2871  > [BullshitDetector] MyServer was just joking.'}
{'everything': 'Go ahead and ignore it.'}

We got three prints, one for every line in the file. And we can see that in every print we have a dictionary with only one key (everything) and it contains the entire row from the log. This should be pretty obvious from the commented version of the expression why it would result in this.

So this is all fine and dandy, but it is not very usable in this manner. We would like to group the different elements in the log entries so we get a nicely formatted dictionary at the end with all the relevant keys that we would need.
We also want to ensure that the entries correctly formatted. So that if there were ever a multi-line log entry printed which looks like this:

[2012-01-13 15:00:00.980,    Error <   MyServer:8071  > [ContextInProcess|LocalInfo] Interesting stuff on the next line.
[something, other < whatever: nice > [ hmm ] ok

It should fail since we would expect the first parameter to be a timestamp and not a string. Then we should know that this line is actually a part of the last log entry we parsed out and it should be appended to it.

Since we have delimiters in the format of the log it is quite simple to extract the different groups we want.
In this next version we have just extracted the different elements of our log entry and given them appropriate names.

com = re.compile(r'''
        ^\[                 # the line starts with a [
        (?P<timestamp>      # timestamp group
            .*
        )
        , # delimiter
        (?P<severity>       # severity group
            .*
        ) 
        < # delimiter
        (?P<process>        # process group
            .*
        )
        : # delimiter 
        (?P<pid>            # process id group
            .*
        )
        >\ \[ # delimiter for "> ["
        (?P<context>        # context group
            .*
        )
        \] # delimiter
        (?P<entry>          # the log entry group
        .*
        )
    ''', re.X)

This gives us:

{'severity': '    Error ', 'process': '   MyServer', 'timestamp': '2012-01-13 13
:00:00.250', 'pid': '8071  ', 'context': 'ContextInProcess|LocalInfo', 'entry':
' Gosh! Something went wrong around here'}
{'severity': '     Info ', 'process': 'otherserver', 'timestamp': '2012-01-13 13
:00:00:270', 'pid': '2871  ', 'context': 'BullshitDetector', 'entry': ' MyServer
 was just joking.'}

Now we have all the groups we need, but no validation for any of the fields. This code is also quite simple. We just specify our groups and then select our delimiters between the groups.
Note that we have to escape special characters and spaces. So at line 18 you see ">\ \[" but it means "> [" and that is the three character delimiter between the process id group and context group that we have in our format. The results of the script have not trimmed the excess white spaces from the elements, but this is outside of the scope of this post since that is very easily handled in python later.

We could of course stop here since now we do have the data that we want in the format that we want.
However the special case mentioned earlier about the multi-line entry would give a false positive with the code we currently have. What we can do to avoid this is to specify the expected contents of the different groups we have. So that if it doesn't match what we expect, then it wont return anything and we will take this as a hint that this line is a continuation of the last match we had.

So here comes a final version of our expression.

com = re.compile(r'''
        ^\[                 # the line starts with a [
        (?P<timestamp>      # timestamp group
            [0-9]{4}    # year
            -
            [0-9]{2}    # month
            -
            [0-9]{2}    # day
            \ # whitespace
            [0-9]{2}    # hour
            :
            [0-9]{2}    # minute
            :
            [0-9]{2}    # second
            .
            [0-9]{3}    # millisecond
        )
        , # delimiter
        (?P<severity>       # severity group
            [A-za-z ]+
        ) 
        < # delimiter
        (?P<process>        # process group
            [A-Za-z ]+
        )
        : # delimiter 
        (?P<pid>            # process id group
            [0-9 ]+
        )
        >\ \[ # delimiter for "> ["
        (?P<context>        # context group
            .*
        )
        \] # delimiter
        (?P<entry>          # the log entry group
            .*
        )
    ''', re.X)

What we have done here is set up some rules for some of the groups (timestamp, severity, process and pid) which makes it harder to get false positives.
If we take a look at the timestamp group we see the following type of statements:

[0-9]{4}

[0-9] means that we want to match any number between and including 0-9.
{4} means that we want there to be exactly 4 of such numbers.
So the above one would indicate a year, since it has four digits.
In this manner we have defined up the entire timestamp in such variations, with the appropriate delimiters in between. This will not impact our original group, since the outer group remains unchanged, we have just changed the pattern with which it detects a valid timestamp group.

In the severity group we have:

[A-Za-z ]+

[A-Za-z ] This is just a variation of the one from the timestamp one. It means that we want all letter ranges between upper-case and lower-case A-Z. Also notice the white space added, this is because we are not trimming white spaces, so if there is a white space in there it would fail if we got there. Note that we do not have to escape the white space here.
+ Means one or more. So if one of the fields were to be blank it would fail. If we wouldn't care if they were empty we could replace them with * which is zero or more.
The context and entry groups we leave as they were since they can be very diverse and we don't want any restrictions there.

Afterthought
With the discovery of the verbose flag for regex it sure became a lot easier to read these kinds of expressions, so that was an encouraging discovery.
There are still some things that could be done with the expression. For example the context group could be entirely optional which would impact the delimiters etc, so that might be material for a second post in the future if I end up going there.
My opinions of regular expressions have slightly improved after doing this, but I still find it rather crude when you want to do some more "complex" things so there is still a long way to go before I become a convert.

Let me know in the comments what you thought. Did it give you anything even though it was very basic?

Portfolio Entry: Mind Sway

2010-12-16T12:28:00.000+01:00

About

Mind Sway is a prototype Facebook game developed by me for xDelia, my employer May 2010 - February 2011.

Purpose
Simply put, the goal of this game is to help the person that plays it become more financially responsible. To facilitate this goal Mind Sway is developed as a platform for testing and improving financial capability in people. The desire is that the game will contain an avatar which is semi-autonomous and can be controlled by the player, but which can end up making horrible decisions due to high impulsiveness, and other factors. The player can then opt to participate in minigames aimed at the factors the avatar is poor at and at the same time improve this factor in themselves as well, by implementing scientifically tested tasks which has the desired results.

Technology

Implemented in Unity3d
Utilizes the Behave library for behavior trees used by all characters in the game.
A* Pathfinding library for all pathing in the game.
MySQL for the storing of all user data.
Facebook API for identifying users and getting any pertinent information (such as finding out which friends the player has whom are playing the game as well)

Media

Cooking for UDK

2010-12-06T18:48:00.000+01:00

I attempted to cook an alpha version of my UDK Game, Zombie Road, this weekend but soon ran into problems with missing scripts and packages. So here is a small check list of things that needs to be done to fix it, beyond adding things to the .ini files.

Compile game in frontend.
Cook game, don't forget adding your maps to the maplist.
Go to your UDKGame\Scripts folder and copy your game's .u file, in my case ZombieRoad.u, to UDKGame\CookedPC
Copy all used packages from UDKGame\Content to UDKGame\CookedPC which would be things like maps, weapons, vehicles etc.
Package game in Frontend.
Done

Up to step 2 is easy to find. Step 3 you can find on the UDK forums if you do the correct searches. Step 4 is trickier.
Hopefully this saves someone else the trouble of finding this out the hard way.

Portfolio Entry: Zombie Road [WIP]

2010-11-23T18:50:00.000+01:00

Foreword
A collaborative project by me and Rasmus Welin done with UDK, Unreal Development Kit. I mainly handle all the code and Rasmus is in charge of of modelling, level editing etc. This post will represent the current state of the game and will be updated with time as new features are added to the game. For posts about the continued development on this game see the Zombie Road category.

Purpose
The purposes for doing this project are several.

Having a proper game in my portfolio
Gaining experience with Unreal Script
Gaining more experience in general game programming, since prior experiences have been with low level implementations.

Concept

Zombie Road is a co-op first person shooter. It is inspired by Killing floor, Left 4 Dead and other first person Zombie shooters, but also things from games like Ultima Online when it comes to character progression. Rather than using the level system it will be based upon improvement of individual skillsets. It will not contain player vs player gameplay and will be purely focused on co-op survival.

Features & Technology
This is a list of features that currently exists in the game and any particular technologies used to implement them.

Scaleform UI
- Menus
- HUD
Persistent user data
- User data is stored on GAE, Google App Engine (character progress etc). GAE is also used for the server listings for the server browser.
- UDK's steam integration is used to fetch the player's account ID. This is what is used to keep track of unique players without the need of our own account logic.
Server Browser
- Implemented my own server browser with the help of GAE and scaleform. The servers are posted to and fetched from a GAE datastore and presented in a scaleform menu.
Wave based gameplay

Waves are easily configured in the UDK editor so you can specify things like:

Wave count
Amount of mobs for each wave (goal condition)
How many mobs are allowed to be spawned at any one time
Types of mobs to spawn
Frequency of mobs. Either by percent or a fixed number (for example 30% for certain mobs and that only 1 of a certain type of mob is allowed to be spawned (boss)

Media

Editing wave information in editor

Feel free to comment below.

Compiling a run-time generated DirectX 11 shader

2010-04-23T19:10:00.000+02:00

I recently got the idea to try to create a procedural shader system for DirectX 11. This basically entails that one simply throws a mesh at the shader generator and it generates a customized shader for this mesh that suits it perfectly.
I knew it is being done in high-end game engines but I had no idea how one actually does it. I spent quite a lot of time on google trying to find this, but it basically looks like some universal secret even though it actually is quite simple. So I played around with it a bit and I managed to get it to work in the end. So the follow code snippet is the procedure I used for getting it to work, probably a whole load of other ones out there.
Just hope this saves other people the same frustrations I had for a while.

void GenerateShader()
{
    ostringstream shader;

    // Basic Vertex Shader
    shader << "float4 BasicVS( float4 Pos : POSITION ) : SV_POSITION" << endl;
    shader << "{" << endl;
    shader << " return Pos;" << endl;
    shader << "}" << endl;

    // Basic Pixel Shader
    shader << "float4 BasicPS( float4 Pos : SV_POSITION ) : SV_Target" << endl;
    shader <<"{" << endl;
    shader <<" return float4( 1.0f, 1.0f, 1.0f, 1.0f );" << endl;
    shader <<"}" << endl;

    // A standard DirectX 10 technique
    shader << "technique10 DefaultTechnique" << endl;
    shader << "{" << endl;
    shader << " pass p0" << endl;
    shader << " {" << endl;
    shader << "  SetGeometryShader(NULL);" << endl;
    shader << "  SetVertexShader(CompileShader(vs_4_0, BasicVS()));" << endl;
    shader << "  SetPixelShader(CompileShader(ps_4_0, BasicPS()));" << endl;
    shader << " }" << endl;
    shader << "}" << endl;

    // This is where the "magic" is at. Grab the char* from your stringstream
    // and feed it into D3DCompile() along with whatever other parameters you usually send it.

    ID3DBlob* errorBlob;
    unsigned int shaderSize = shader.str().size() * sizeof(char);
    HRESULT hr = D3DCompile(shader.str().c_str(), shaderSize, "none", 0, 0, "DefaultTechnique", "fx_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &blob_, &errorBlob);

    if( FAILED(hr) )
    {
        OutputDebugStringA( (char*)errorBlob->GetBufferPointer() );
    }

    SAFE_RELEASE( errorBlob );
}

So now all that is left is 99.9% of the work to actually switch case together a shader that supports all the things your different meshes might need.
Maybe I will post something on that later when I manage to make a dent in that daunting task :p

Portfolio Entry: Relief & Parallax Mapping

2010-02-03T13:28:00.000+01:00

I implemented this during a weekend, mostly because relief mapping has always interested me. Decided to toss in parallax mapping as well when I was "in the neighborhood", and a little normal mapping for good measure as well. This is the basic implementation of both techniques with no optimizations or artifact corrections.

Here is a small code snippet. Nothing special, just don't like to not show code.

void GenerateShader()
float ray_intersect_relief(in float2 orig, in float2 dir)
{
    const float max_num_linear_steps = 20;
    const float max_num_binary_steps = 5;
    float depth = 0.0f;
    float size = 1.0f / max_num_linear_steps;

    // Attempt to find the first intersection against the relief map with a linear search.
    // This is because binary search can easily miss topography.
    for(int i = 0; i < max_num_linear_steps - 1; i++)
    {
        float4 t = gTexRelief.Sample(textureSampler, orig + dir * depth);
        if(depth < t.r)
            depth += size;
    }

    // A binary search to try and find the "edge" of the closest intersection point
    for(int j = 0; j < max_num_binary_steps; j++)
    {
        size *= 0.5f;
        float4 t = gTexRelief.Sample(textureSampler, orig + dir * depth);
        if(depth < t.r)
            depth += 2*size;
        depth -= size;
    }
    return depth;
}

100 days later (give or take a few)

2010-01-09T19:23:00.000+01:00

So... It's been a while.

Life is good, excluding the torment of a dying molar, and not a whole lot has happened in this time of silence. Work has been good, but has not really been related to what I wanted to write about in this blog so I opted to stay quiet for a while.

Lately I started looking at available positions in various game companies and it was somewhat upsetting to notice that you are not really suited for filling any position other than as a junior. So I basically decided that I really needed to do something about my portfolio. It was a while back that I decided this, but there was Christmas and stuff in the way so I haven't really started doing stuff until now. Now it has begun though.

The general idea is that I will simply implement all the various things I have always wanted to try and then post the results in the portfolio section (hopefully with some binaries as well). The types of thing I will be implementing will mostly be 3D graphics related, since this is the area I always seem to find myself drooling over. But there will also be some other stuff like resource management and so on.

I have already implemented the first thing I will be putting on the portfolio (relief mapping) and it will be going up there shortly (probably not today though). Other things to be expected, in the very near future, are things like, just to name a few: Parallax mapping, Screen Space Ambient Occlusion, Deferred rendering.

If one refuses to work for any other industry one can only blame themselves for not doing everything in their power to be worthy of working there.

Lots of changes

2009-09-30T12:23:00.000+02:00

Yeah so I went to the job meeting. 15 minutes into the meeting I got the job! So I am now a full time employee ( for 6 months at least ) at the xDelia project as a game programmer.

I start tomorrow already, so it is going a million miles an hour at the moment. I am headed over to Germany, Tuesday - Thursday, next week for some work related workshop as well. So lots of things happening indeed.

So now there's lots to do. I need to fill out some papers for the educational part of school and report that I am taking a leave of absence. Then of course there is also contract signing and all matter of other stuff I need to fix with the job (have to hunt down a computer for my room, and then of course have someone tell me where my room is). Not to mention having to report to CSN my leave of absence as well so they'll stop sending me money, but for some reason you need to know how much you will earn, which I don't know yet, before you are allowed to report a leave of absence. Seems kind of silly to me.

Now this is the story all about how
My life got flipped, turned upside down

Kinda how it feels. This will pretty much change everything I was doing. No more school for a while of course and iPhone coding will be put on the back-burner again. It is, however, all good. I get what I value most. Experience. With the economy as it is there is no way in Helsinki that any game company would hire someone that has no prior work experience. So this job will be worth a lot for my CV. Hopefully it will be for at least a year. Generally looks better in the resumé than 6 months, I say anyway.

So who's turn is it next now then from Quantum Studios?

Full speed ahead... into nothing?

2009-09-25T17:18:00.000+02:00

Yeah so I'm still full up with all the school assignments. My little web server is slowly getting somewhere, if it will be done within a reasonable amount of time is yet unknown.

I recieved what could seem to be a job offer the other day. I don't really know what terms are involved yet (pay, hours, duration, etc) so trying to not get my hopes up. Going to meet up with the person that contacted me on tuesday and discuss it. Hopefully it will be something worthwhile. I really want an excuse to cut down on college for a while.

I really hope it will lead somewhere, but no point in obsessing about it until tuesday.

Back to C and continue with the web server a while longer.

Web server

2009-09-18T13:23:00.000+02:00

So I started on the web server assignment. I can tell already that this is gonna take plenty of hours to finish. So the plan is to continue working on that today. Hopefully I will learn something from this that I will actually need some day.

Also got rejected from the job I applied to the other day. Kinda silly that companies won't even consider people with no prior job experience, where will the next Carmack come from then? ( did keendra smile now? ) :p

There should be a law on companies having to offer junior positions if their corporation is larger than x people =P As long as there is senior staff there it shouldn't matter all that much if some of the positions gets filled by post-grads.

No news is good news?

2009-09-16T15:35:00.000+02:00

Yeah so I haven't written in a while. Been busy with school so there hasn't been much progress with the "furthering of my career" aspect of my life.

One of the courses I am taking is assignment oriented, so there is no exam, which makes the assignments very time consuming. So I have been working alot at that.

After these few weeks of being back to school I have convinced myself that I really need to try harder to find a job. School is nice and stuff, but I feel ready to make a name for myself and gain proper work experience.

So I updated my portfolio a bit today (just added info about my Bachelor's thesis) and found a job I am going to apply for as well. So the rest of the day will be dedicated to three tasks.

Write a cover letter and apply for the job.
Start looking at the next assignment.
Go to Amiralen (a local shopping center) and do some grocery shopping (Dragons need food apparently).

So yeah, thats about it.

Give me a job!

Networking Done

2009-08-30T19:30:00.000+02:00

The UDP networking is now done for my Freevo remote app, tested it with my Freevo server earlier and it works perfectly. Just have to finish up the Settings tab, which will most likely be done today, so that one can specify what host and port it should connect to and stuff like that. Then it’s just the final icons and intensive bug testing and tweaking left to do. Making this app has been a great help in putting the stuff I have learned in the book into practice.
So school starts again tomorrow. Or well not really. I’m just going to talk to someone about what courses I decided on for my master’s education (since you get to pick 90% of the curriculum yourself). The courses don’t actually start until Tuesday. Will be nice to start meeting other people again, rather than sitting here cooped up in Karlskrona with nobody we know.

Art update

2009-08-29T10:29:00.000+02:00

So I found some artists to help me out with my apps. Andreas Nilsson is making some icons for the Freevo remote app. Rasmus Welin is learning how to make sprite characters for the usage in the JRPG I mentioned previously. So now I just have to get out of procrastination mode and continue work on the apps.

Starting the Masters education on Monday at BTH, so I don't know how much time there will be for programming on these things during the week, but there's always the weekends.

The Battle Plan

2009-08-27T11:34:00.000+02:00

So I have decided what my big iPhone game down the road will be. It will be a jrpg styled game, like all the “Tales of” games.

This decision came after buying a game, which is similar in concept, from the app store. People were raving about how perfect and wonderful this game was etc etc.

It didn’t take long to realize that people have really low standards to when it comes to games on the iPhone. Sure it isn’t a super powerful platform for games in the first place, but the products should still be held at a high standard. It lacked lots of sound effects, dialogs made no sense, made lots of contemporary comments which ruined the atmosphere (gangster rap in a medieval fantasy setting doesn’t make sense now does it?), worthless controls, annoying background music. The list just goes on and on and still almost all of those which have commented on this game gave the score 5/5.

So that was when I decided that a jrpg is what I would, to show people how a proper game should be like on the iPhone. This will probably be years in the making, but I have time.

iPhone ahoy!

2009-08-17T11:45:00.000+02:00

Yeah. So I finally started reading the iPhone book the other day. So far I have learned a whole bunch of cool stuff when it comes to making graphical interfaces and I must say that it was easier and more streamlined than I thought it would be.
So soon maybe I am qualified to make my first in-game menu for a game ;)
Check back soon for more about my progress, if it pleases you!

Update of small importance.

2009-08-07T14:13:00.000+02:00

So I haven’t posted anything in a while. Mainly because nothing much programming related has happened.
I moved in with my girlfriend to our new apartment in Karlskrona, KNA, last weekend and since then we have generally been busy with getting the place in order and exploring KNA.
I did however finish one more assignment in the “Multimedia programming with Python”. Which sounds much more fun than it actually is. The course recommends the usage of Tkinter, which I find to be extremely boring and feels very old and poorly designed. Not to mention some problems it seems to have with Python’s garbage collector.
With the assignment I submitted yesterday I chose to declare a function that would load some images and display them on the screen, but for some unexplainable reason the images just wouldn’t show on the screen although the window would get the correct size to fit every image.
So after an hour of two of debugging and googling I found the problem with the following snippet of code:

image = Image.open("python.jpg")
tkpicture = ImageTk.PhotoImage(image)
label_image = Label(self.parent, image=tkpicture)

This code is completely appropriate and loads an image from file and works in all cases, except when it is used within a function.
Apparently the line Label(self.parent, image=tkpicture) does not trigger python to increment the reference count of tkpicture. So when one returns from the loadImage() function the garbage collector thinks tkpicture is unused and therefore deletes it.
The “solution” to this problem is to do the following:

label_image = Label(self.parent, image=tkpicture)
label_image.image = tkpicture

This seems infinitely inane since assigning tkpicture to image is what the Label constructor is doing already. I highly doubt that there isn’t a better way of doing this. Not to mention that doing this prevents Python from cleaning up tkpicture by itself. So one have to make sure to do this:

label_image.image = o

Otherwise one would be leaking memory due to that extra reference.
Just one final assignment to be done and then I am done with this course, and a happy day it will be.

Going to start reading the iPhone book soon. That I can guarantee will be a much more pleasant experience.

Objective-C Progress

2009-07-24T17:38:00.000+02:00

I picked up a couple of books the other day to help me out with learning Objective-C, objc, and developing for the iPhone. I finished reading the objc one today, and I must say that it was very good. I had tried doing some tutorials on objc before I read this book and it generally left me with more unanswered questions than I had from the start.
Since I am a C++ programmer through and through it is tricky to pick up a new language that looks similar, but works completely different. I was having more issues with objc than with learning Python.
However, as I stated, it feels a lot better now having read the objc book. It’s named "Learn Objective-C on the Mac" and I recommend it to anyone that would wish to learn objc. However one should know that this is intended for people that already know some other programming language, so it isn’t aimed towards beginners.
The next step is to read the iPhone book, named "Beginning iPhone 3 Development: Exploring the iPhone SDK", which should prove to be equally good and even more relevant to my goal of making iPhone games (duh!).
So check back in a couple of days and maybe there is something interesting to be seen.

So... It happened.

2009-07-23T20:23:00.000+02:00

To the glee of some (Keendra) and the despair of others (mostly me) I ended up starting a blog.
Thought it was time to let people, who are interested, what I’m up to. However this blog will be focused on my aspirations of becoming a game programmer and all which that entails.
Currently I am on summer break. Got my Bachelor’s Degree in Computer Science, with a specialization in Game Programming, in June and I’m going straight for my Master’s in Computer Science, which starts in September.
On the agenda currently I am moving to Karlskrona, Sweden in a week with my girlfriend. Other than that I have started reading up on Objective-C/iPhone programming with the hopes of making some cool iPhone games in the near future with some friends, and maybe make some money.
Other than that there isn’t much to report at this time.
Check back later for more =P

Portfolio Entry: Bachelor's Thesis "Potential of GPU Based Hybrid RayTracing For Real-Time Games"

2009-06-01T19:38:00.000+02:00

Abstract

The development of Graphics Hardware Technology is blazing fast, with new and more improved models, that out spec the previous generations with leaps and bounds, before one has the time to digest the potential of the previous generations computing power. With the progression of this technology the computer games industry has always been quick to adapt this new power and all the features that emerge as the graphic card industry learn what the customers need from their products. The current generations of games use extraordinary visual effects to heighten the immersion into the games, all of which is thanks to the constant progress of the graphics hardware, which would have been an impossibility just a couple of years ago.

Ray tracing has been used for years in the movie industry for creation of stunning special effects and whole movies completely made in 3D. This technique for giving realistic imagery has always been for usage exclusively for non-interactive entertainment, since this way of rendering an image is extremely expensive when it comes to computations. To generate one single image with Ray Tracing you might need several hundred millions of calculations, which so far haven’t been proven to work in real-time situations, such as for games.

However, due to the continuous increase of processing power in Graphical Processing Units, GPUs, the limits of what can, and cannot, be done in real-time is constantly shifting further and further into the realm of possibility. So this thesis focuses upon finding out just how close we are to getting ray tracing into the realm of real-time games.

Two tests were performed to find out the potential a current (2009) high-end computer system has when it comes to handling a raster - ray tracing hybrid implementation. The first test is to see how well a modern GPU handles rendering of a very simple scene with phong shading and ray traced shadows without any optimizations. And the second test is with the same scenario, but this time done with a basic optimization; this last test is to illustrate the impact that possible optimizations have on ray tracers. These tests were later compared to Intel’s results with ray tracing Enemy Territory: Quake Wars.

If you wish to read the thesis you can find it here

Portfolio Entry: Transcendence

2009-06-01T19:35:00.000+02:00

This is a two player co-operative horror game that me and my classmates made as our final project in our Bachelors education in Computer Science. We also competed in the Swedish Game Awards -09 with this game.

My role in this project was as the Project Leader and the 3D Engine programmer. Since we have had bad experiences with existing 3D Engines I decided to start creating my own 3D engine for the game about 6 months before we started working on the actual game. As of the end of march 2009 the engine consisted of 12,000 LOC.

Other than this I also worked on modelling the house (which was made in 3D Studio Max) and spent much time completing our in-house Collada parser.

Portfolio Entry: The Dreamer

2008-05-01T19:33:00.000+02:00

A class project made by me an my classmates (9 people) during 3 weeks in May 2008 for a Game Production course.

This was coded entirely in Python and used the game engine Panda3D.

My responsiblity for this project was that of Project Lead and my main implementation responsibility was coding the quest system.

Portfolio Entry: Bread Cat Blaster Apathy

2008-02-01T18:31:00.000+01:00

It features Phong Shading, Normalmapping, Skinned mesh, Level parsing from XML and the main feature is the Quadtree implementation which is shown in the middle of the clip with different colors for the different splits.

We used DirectX 9.0c for this project and the client was coded in C++.

This game and the level editor which accompanied this game (Made by a classmate) recieved a diploma for best project in the course.

Portfolio Entry: Walk on Terrain

2007-11-01T18:30:00.000+01:00

Featuring Walking on terrain, multi-textured terrain, Phong shading and a basic particlesystem.

The project was made with C++ and DirectX 9.0c