Reinventing the Wheel

I will not be taking Codemasters to court....

noreply@blogger.com (Semi Essessi) — Fri, 20 Jan 2012 14:37:00 +0000

... instead, after receiving lots of free legal advice (thanks to all who helped) I am reporting them to the relevant government bodies for malpractice, which will cost me nothing and go nowhere if my claims are unsubstantiated.

Its not ideal to go back on my previous statements, but I feel this is the right thing to do since it will cost me nothing, it won't win me any money and will serve to prevent the malpractice from continuing if it is indeed occurring.

Any comments, questions etc. are welcome as always.

Programmer pixel art

noreply@blogger.com (Semi Essessi) — Thu, 19 Jan 2012 23:50:00 +0000

I find pixel art quite relaxing - this is probably my most ambitious effort yet though - took the last couple of hours, minus a quick break for Quake.

Click for full size image

Originally I wanted to update my Facebook profile picture, but the idea wasn't so suitable for a square image and loses the pixel art effect when resized to fit in such a small space. I think I made the car slightly too tall and a little too angular owing to my liberal use of the MS Paint line tool, but it looks like the 'lude to me. :)

There are a few dodgy pixels now that I've taken a step back from it, above the front wheel I should have levelled off the dark grey I think, and the black pixel on the left most building's border by the trim should probably match the gap in the bricks instead of being black, but meh...

This is what I used for reference, although I changed the small details to match my own car:

C struct layout optimisation revisited - x86 performance

noreply@blogger.com (Semi Essessi) — Wed, 18 Jan 2012 22:36:00 +0000

One topic that comes up time and time again with me is leveraging C/C++ struct layout rules to save memory. Of particular interest is the bitfield method of saving space on booleans and the common argument I hear against it is that it hurts performance. I usually contest that this may be true if using 3-bit integers which aren't the last entry etc. simply because the bitwise operations performed are, on most architectures, as fast as the copies you get from using "normal" bools. The other thing to consider is that you can set multiple with single instructions if you union with a char, short, int etc. which is definitely faster for copies and "safe" initialisation.

I think I can prove this point easily for x86. Note int 3 so I can inspect disassembly in Visual Studio with all the optimisations turned on, and the first move sets al to 1 by setting eax to 1, i.e. both methods are sharing the value of that instruction:


int main( const int, const char* const* const )
{
00401000  push        ecx  
    
    volatile struct
    {
        union
        {
            struct
            {
                int mb1 : 1;
                int mb2 : 1;
            };

            char mc1;
        };
    } x1;

    volatile struct
    {
        bool mb1;
        bool mb2;
    } x2;

    x1.mb1 = true;
00401001  mov         eax,1  
00401006  or          dword ptr [esp],eax  
    x1.mb2 = true;
00401009  or          dword ptr [esp],2  

    x2.mb1 = true;
0040100D  mov         byte ptr [esp],al  
    x2.mb2 = true;
00401010  mov         byte ptr [esp+1],al  

    __asm int 3
00401014  int         3  

    return 0;
00401015  xor         eax,eax  
}
00401017  pop         ecx  
00401018  ret

... apologies to anyone expecting some other content, but I can't just keep banging on about Codemasters all the time. Not to say that I won't revisit the subject when appropriate.

Star Chart FTW

noreply@blogger.com (Semi Essessi) — Tue, 17 Jan 2012 16:44:00 +0000

StarChart is continuing to do well in the Education category for iOS -

Its nice to see so many positive ratings. :)

Some clarification...

noreply@blogger.com (Semi Essessi) — Tue, 17 Jan 2012 13:16:00 +0000

It is annoying to see how much focus there is on the overtime and overpay situations with Codemasters.

I think it is much more important to notice that Codemasters has violated the European Working Time Directive, failed to ensure that employees received minimum wage, failed to comply with H & S, failed to deliver payslips on time, failed to pay contracted staff within a reasonable time scale and generally failed to run the studio sensibly. Many of these things are illegal.

They have very carefully neither confirmed nor denied this in any of their statements, only talking about the unrelated TOIL and overpay issues. If they do publicly say anything about the accusations I have made they will land themselves in trouble - the safest thing for them to do (assuming they are guilty - which although I have evidence of I hope readers are sensible enough not to assume these things) is to keep quiet because anything they say on the matter would incriminate them. If they admit it then they incriminate themselves - if they deny it then they will be lying and they should know exactly what kind of evidence I have that I could use to debunk any such claims, because they have it too.

I am not kicking up the fuss after the fact - this has been ongoing now for a good few months - I am simply being loud and public because enough is enough. You do not start threatening people with bankruptcy proceedings for being more cooperative than you are at paying your own bills.

The repeated comments about TOIL are irrelevant - I was told (although only verbally) that I would not receive TOIL, I know this and I have never disputed this. That does not mean that they did not play a sneaky trick on me and others, nor does it mean that they did not violate the European Working Time Directive nor neglect their responsibilities to pay minimum wage. It also doesn't mean that I am not entitled to some compensation for having my rights as a citizen of the UK and EU violated. I knew I would not be paid for overtime, that is completely irrelevant.

Again, I reiterate that they have not commented on the real issues. I am disappointed that the news sites have not picked up on this and have only helped focus the attention completely on the overtime and overpay issues.

I would like to mention that I have chased Codemasters up regarding my offer to repay in monthly instalments and am still awaiting their reply. They have made no effort to contact me since the original blog posting on Friday, apparently because the senior executives have not yet reached a decision. Although to be honest, I am surprised that they would be involved in deciding such small details like this... perhaps this is my own fault for making waves.

A number of people have suggested that I do not pay the money back, that I have a very good case for keeping it. I do not care. I am not Codemasters, I do not pay the minimum I can legally get away with or try and dodge my debts by waiting it out. They made a mistake and I am trying my best to pay them the money without compromising my own situation.

Overtime

noreply@blogger.com (Semi Essessi) — Mon, 16 Jan 2012 11:41:00 +0000

Just to clarify that I do have ample evidence. This is from CMs own tracking system that I screenshotted at the time to show a friend just how much overtime I had been clocking up. The "SCAR" I refer to in the e-mails I've posted before. Note the morning where I forgot my swipe card and went to get it at lunch. Also, note me leaving just after 00:00 the previous Sunday.

The commentary in the mail chain is amusing in hindsight.

A big thank you to everyone for spreading awareness of Codiesgate

noreply@blogger.com (Semi Essessi) — Sun, 15 Jan 2012 18:06:00 +0000

The story has gotten a lot of attention and I have lost a good chunk of my weekend replying to e-mails and taking phone calls about this. I am happy to do so - keep them coming and if I don't get back to you right away it is probably because I am busy answering someone else.

I'd like to give special thanks to a friend who suggested the tag "Codiesgate". It seems appropriate and snappy - and its used by nothing else so currently searching for it only points to related articles on my blog.

An extra special thanks to the people at Hacker News and my many friends on Facebook who helped spread this around - between them they are responsible for about 40% of the hits the "Codemasters are on the scrounge" article has received.

I also would like to thank the gaming news sites for being good enough to post their stories, especially Eurogamer who jumped on it immediately and were kind enough to wait for my blog post to go live before posting their own story. I expect Codemasters did their best to ensure their silence on Friday afternoon. I've heard from newspapers that they were unreasonably asking for questions by snail mail - an obvious delaying tactic.

Its quite satisfying to see this story is dominating the first page of Google News search results for Codemasters.

It seems to be getting a great deal of attention on Kotaku as well. Their article has barely been up a whole day but has received slightly more attention than the original blog posting already and seems to be driving more traffic to it as well...

I've also been contacted by a number of journalists, solicitors and even union reps about this who are offering their help and support. This was unexpected, but also much appreciated.

Also, the many former Codies who continue to send me evidence and offers to testify in court. Your contributions have been invaluable and I respect the courage you are showing by approaching me at all.

Thanks.

ps. I am having technical difficulties trying to get the blog working with IE 9 and some iPhones - I have a lack of hardware/software to rectify this at the moment but will make every effort to fix this. In the meantime I suggest you use Chrome, Firefox or previous versions of IE if possible. Not that you will necessarily be able to read this with IE 9 to know this. :(

Some more tidbits from ex-Codies...

noreply@blogger.com (Semi Essessi) — Sat, 14 Jan 2012 19:57:00 +0000

Some interesting evidence of the expectations to work unreasonable hours:

Some confirmation about the payslips, and that some of the rumours I heard about finance procedures might be more than just rumours:

The fearful comment at the end helps solidify my belief that I am doing the right thing. That people can be made to fear for their employability (or anything) for simply exercising their rights in exposing illegal or immoral practices is a big problem, not just in this one case, but for society as a whole, and it needs to be dealt with.

On a lighter note, one of my ex-colleagues was rather poetic in his contribution:

Okay,

For fun, I've been working on that rhyme. It's meant to be a parody of "Twas the Night Before Christmas" - http://www.carols.org.uk/twas_the_night_before_christmas.htm and for more spoofs - http://urbanlegends.about.com/od/historical/a/twas_the_night.htm

It's only meant to entertain, not be taken too seriously, but something I thought was fun to do whilst waiting for legal advice :) Any suggestions are obviously welcome!!

Twas the week before Christmas and all through the (Westbury) house
Not a keyboard was stirring, not even a mouse
The desks had all been removed with care
With the knowledge that the employees would not be there.

The workers were nestled and snug in their beds
While visions of counsel benefits danced in their heads
I, in my suit, as my wife took a nap
I couldn't wait to be done with this interview crap

When in my inbox arose such a clatter,
I sprang from my chair to see what was the matter
Codemasters is coming after me for money
But I'm sure they understand that I don't have any

They made me redundant and disposed of my role
They quickly ruined any chances of the studio goal
But now are demanding that I pay them because they made a mistake
Instead of asking nicely, they threatened and bullied

"Now lawyers, Now accountants, Now human resources,
On Executives, Department Heads, and other sleezes
To the ex-employees we go,
to get their money because our investors have grown cold"

I worked countless overtime hours to meet their demand
And all I got was a P45 and a dismissal in hand
My personal life was ruined by the stress of the Bodycount
My diet was in shambles because of pizza and cheap take-out

They said I had one week to pay them back
Then, just before the deadline, they extended that
In the same letter, saying that legal action would ensue
Should we not pay, even though there was no time to

I waited in fear as the holidays flew by
Until one day I found legal advice that I could rely
I sent them a letter saying they did not follow Protocol
They sent me a letter it was not worth their time at all.

"A week before Christmas we came after you
to pay us back, and you didn't, did you?
So here are my lawyers, and expensive ones they are
probably worth more then the amount that I am chasing you for"

"So merry Christmas and a Happy New Year,
Bah humbug to you and all of your cheer!"

Sadly it also came with a similar undertone of fear in a follow-up e-mail:

However, at least one of my former colleagues plucked up the courage to suggest that I could show his name.

... and another threatening letter, scanned.

Thanks to all my former colleagues who have helped expose Codemasters so far.

Codemasters have not yet threatened me with legal action

noreply@blogger.com (Semi Essessi) — Sat, 14 Jan 2012 15:36:00 +0000

I would like to make clear that the news sites have made a number of mistakes. The letter I show threatening legal action is not directed it me. I understand it might be difficult to understand why, or even believe that, somebody is willing to stick their neck out like this for the sake of others, but this is what I am doing. I think my intentions are best described the way I described them to Codemasters themselves the day before I made the blog post.

They asked that I not go ahead with this "threat" and confirming that they were taking my suggestion of offering a reasonable payment plan into consideration - so I replied again clarifying my position.

I reiterate that I am willing to pay - but I am not willing to have my quality of life impacted because they made a huge pile of naive mistakes and I made one that I consider pretty justifiable.

I do not include the reply from Codemasters as it seems to be protected by some small print at the bottom...

Codemasters are on the scrounge

noreply@blogger.com (Semi Essessi) — Fri, 13 Jan 2012 13:30:00 +0000

This was a joke at the time... we should have seen it coming.

I'm beginning to see Codemasters in a very different and negative light after their most recent attempts to extract money from former employees, following an error where they ambiguously overpaid salaries… are they running out of money, or are they just afraid that their incompetence is finally going to be uncovered by their investors? The scam of the Guildford studio has been unraveled, as any web of lies eventually does, and to make matters worse they've screwed up their damage control badly enough to make the situation worse. So, let me put this into context by telling the story about my exit from Codemasters Guildford studio last year…

When I received my final pay from Codemasters I was a pretty happy man, I had received a pretty substantial extra sum - it wasn't quite the amount of money I was owed for unpaid overtime, but it was something. Everyone had received a bit extra and after lots of pub discussion the overriding opinion was that they had seen sense and decided to pay us all bit extra to keep us quiet about just how illegally the studio had been running.

You see, a few weeks previously during the consultation period I made it as clear as possible that I was unhappy about the amount of overtime that was worked without reimbursement. Along with this a previous request for pay rise and promotion to match the work I actually did seemed to have fallen on deaf ears. To put this into context I did at least 400 hours of overtime during 8 months, almost exclusively filling a position that exceeded my job description significantly. Bear in mind that this was a 3 year project, I came in late and I most certainly was not the worst offender when it came to racking up the overtime...

These 400 hours are based on the clock-in times from my swipe card and are a massive underestimate of the true number, this included things like 'day I forgot my pass', 'that time someone else swiped me in and it recorded my breaks instead of my hours' and the like. I had three weeks during my time there during which I worked less than 40 hours according to these massive underestimates, and working one or both weekend days was the norm rather than the exception. When I signed up one thing that sold me was the promise of TOIL (time off in lieu) for overtime - the truth was that this was removed within days of my starting, and every minute of overtime I worked was unpaid.

I had been grumbling about these things before the redundancy was announced and pretty much everyone had raised the issue of overtime several times over, but never taken the issue right the way to the top in a serious way. It didn't seem too bad until we were slammed with redundancy and they managed to restrict the number of hours we did from that point onwards without much difficulty - locking the office before and after certain hours. With only a month of employment left I felt compelled to take the issue as seriously as possible and raised it at the first opportunity to the HR representative. The reply I got was disappointing - I no longer have the original e-mail, but something along the lines of 'senior exec have reviewed your position and have decided you are not entitled to anything'. I pursued it further with a letter after the end of the consultation period after I was advised (by HR) that I should appeal the redundancy if I was unhappy about this:

WITHOUT PREJUDICE

I apologise for my delay in getting in contact regarding this, but I felt it necessary to seek legal counsel before taking matters further.

I have been made aware that, despite your advice to the contrary, appealing the redundancy decision is not correct considering that my dispute is with the decision to not compensate me (or anyone else for that matter) for the additional hours worked during my time at Codemasters. As you know I have already raised this issue and I feel very strongly that some payment should be made for the many hundreds of additional hours of work that I carried out beyond my contracted hours. As such please be aware that I will not be appealing the redundancy decision.

I would also like to make you aware that I refuse to sign and return the letter I was sent to confirm the studio closure, since I refuse on principle to pay even the cost of postage for the sake of such a meaningless thing. I am aware that I am still bound by the contractual obligations mentioned regardless of whether I acknowledge this in writing, and would like to remind you that Codemasters has a legal obligation to provide my P45 and payslip, and that failure to do so may require reference to an employment tribunal.

I would like to remind you that Codemasters has never provided me with a pay statement on or before my pay day - the only company I have ever worked for to be so lax, and whilst this is a small and questionable breach of law I would also like to remind you that this is not the only way in which Codemasters failed to uphold its legal responsibilities as an employer.

I can no longer recall if I opted out of the European Working Time Directive as part of my contract - but I believe I did. Regardless, the only right which can be waived in this manner is to work no more than a 48 hour week - the same directive also states that there should be 11 hours rest in any given 24 hour period and 24 hours rest during any given week - there were several weeks during which I did not have an unbroken 24 hours of rest, and many days without 11 hours of unbroken rest as you should still be able to see from my clocking in/out times on SCAR. There was no effort to enforce the directive on the part of Codemasters, which is dubious given how effectively access to the office was restricted during the consultancy period. I would therefore also like to remind you that failing to uphold this directive is illegal.

I am considering my options at this time, including making a claim in an employment tribunal. However, before I embark on the final process I am writing to you to invite you to put forward a realistic proposal by way of compensation.

The reply I got was also disappointing, and left me feeling like I should take it to an employment tribunal once I sorted out the details of my life such as finding work, finding a new home etc. Not just for my sake, but to teach Codemasters a lesson about having some respect for the law - laws that if I was aware of earlier I could have used to prevent the situation reaching the point that it did - even more hopefully to give the industry as a whole a hint that the accepted practices of 'crunch time' are actually illegal and unacceptable...

Hi Semi

We have undertaken a thorough review of your grievance regarding the non payment for the extra hours that you claimed you have worked. We appreciate it that there was a focus across the whole studio to work extra hours, to get the game completed to the final deadline, however it was made clear and communicated upfront to everyone, that those who did work, no TOIL or overtime pay would be made for those extra hours. Therefore, you knowingly, worked the hours in the knowledge that you would not be compensated for them, in TOIL or payment. Furthermore, from our investigations you never challenged this or raised any queries at the time of working the extra hours.

We appreciate that this has been frustrating for you, and therefore can conclude that we maintain our position and we will not be putting a compensation proposal to you, and that our decision is final.

With regards to your query on pay statements, we can advise that payslips were forwarded to the Guildford office prior to payday, and it was the responsibility of your line manager to distribute accordingly. From further enquires you have never escalated this to your manager, or HR. Should you require copies of any pay statements, that you do not hold, then please let me know, and I will happily provide these for you.

We wish you all the best the future

Many thanks

It was a bit unexpected that they could be so utterly naive, but I left it for a while whilst considering whether to pursue the tribunal or not. Although, later on, I did ask the questions of some management types who will remain nameless.

I received my pay, got an extra amount and chalked it up as a good will gesture to help ensure my silence assuming that the e-mail I had received was in-fact a face saving gesture at best, or that someone with some common sense had realised how stupid it was to ignore these things. What happened the following month though was a complete shock and surprise - I received a voicemail and e-mail explaining that there had been a mistake and I had accidentally been paid an extra months salary! Whats more (and this is on 15th Dec.) I had until 20th Dec to return the money.

I had already spent the money - I had accrued a considerable amount of debt during the year, some of which for the sake of travelling/moving to Guildford for the sake of Codemasters. It made sense to use it to wipe a big chunk of that out. I was also in the situation of needing to find a new place to live (expensive) as well as having transitioned between jobs... /and/ it was Christmas. To make it worse, Codemasters had been so incompetent that I could not trust what they were saying, for instance, our consultation period was longer than necessary because they failed to submit paperwork correctly and there was no HR representative on-site throughout consultation (as if there was anything more important they could be doing than ensuring that laying-off 60+ people who slaved to ship your game wouldn't turn into this disaster), they had been poorly advising me and seemed to be oblivious of the law and its implications. I needed legal advice and they were asking me to repay the money faster than I could feasibly get any - in fact they were asking me to repay by bank transfer as well - meaning I would have to make a payment immediately to have any chance of meeting their ridiculous deadline.

I explained this to them. A few days later when the deadline had passed they called me again and extended the deadline to 3rd of January - at which point I had to explain that although I had been seeking legal advice it was extremely unlikely that I could get some before then owing to the time of year. I made it clear that I would do my best to pay them back as long as I was satisfied that I did indeed owe them the money, despite the fact that I believe they owe me more than twice the sum they are asking from me as reimbursement for overtime.

However, not everyone else seems to have been so lucky, and as I began to extract information from Codemasters payroll team - which was slow and painful owing to the incompetence (a payslip is NOT a break down of how a payslip is calculated ffs.) - I began to hear stories from my former co-workers and some of the commentary was almost unbelievable. I include excerpts from e-mails and allow them to speak from themselves.

* * * *

In reply to someone stating they received a letter threatening to file for bankruptcy against them... (I can not include this one, sorry).

* * * *

There was some discussion of going public, however, the usual arguments for not doing so were banded around. I did have some e-mail screenshots of this - unsurprisingly those who did not want to go public with this were so afraid for their future employability that blocking out their names and identifying details wasn't enough to make them feel safe. This is truly sad as it is difficult to convey exactly how much fear has been put into people to prevent them from exercising their legal rights without this. Even worse, using mainstream news sites is made difficult because of the knowledge that Codemasters will make every effort possible to silence them - as they have done in the past when news worthy cock-ups occurred. Other e-mails and letters I was not given permission to use include the indication that values to not tally up - the amounts asked for change, the dates are not consistent.

When I see these e-mails and letters though, I can't help but feel that Codemasters are being wholly unreasonable about this - they are coming in heavy handed at a bunch of people - 70 or so - who all received extra money and didn't query it because they all had plenty of good reason to expect it to be a genuine payment.

After laying us off, after horribly mistreating us, after cocking up the redundancy procedure and best of all, just before Christmas, they are coming at us aggressively because they made yet another mistake. The best of it is that they owe us money, many of us have outstanding expense claims or were not reimbursed for overtime. Codemasters are famous for not paying their bills on time... many contractors had to threaten to charge interest after their invoices were not paid within 30 days before payment would appear - I hear rumour it is their policy to not pay invoices until at least 30 days have passed and the invoice has been chased - and yet they expect us to pay them faster than they would pay us.

Some employees did so much overtime that their hourly rate was less than minimum wage - and the company made no effort (despite its legal obligations) to prevent this from happening. Sadly these people did not keep records of their hours themselves, or otherwise did not want to pursue the issue. Most of us worked at least one week where we did both weekend days, and having 11 hours unbroken between shifts was a joke. I typically had less than 11 hours of my own time each day - and before I moved to Guildford I'd lose 4 hours of that time to travelling anyway - and I know I wasn't the worst one.

Further I have a general feeling of anger that the redundancy is ultimately down to the people at the senior level (some of whom may have been involved in running other studios into the ground) having left a studio to burn through £20 million of expenses with out any checks and balances in place to safeguard the investment, and yet we were blamed for this. That the same incompetence continues to impact our lives through out this shambolic situation is frankly unacceptable.

So here I am. I have gone public. You know my name, who I am and what I do. I have nothing to fear from Codemasters or anyone else in the industry - I am in the right - I have been reasonable and approachable and done nothing wrong. I write this article now not because I am bitter about redundancy - I've been there before - not because I want to weasel out of paying the money - because I am willing to pay it back provided they make it reasonable for me to do so. I do it because it is the right thing to do - because I am sick and tired of big business being incompetent and getting away with it because of fear and naïveté. I don't like bullies, I never have, I never will...

Hello World!

noreply@blogger.com (Semi Essessi) — Sat, 07 Jan 2012 11:43:00 +0000

This is quite pointless, but I found it amusing to come up with:


#include <stdio.h>

class Evil
{

    class Hack
    {
    public:

        const Hack& operator *() const
        {
            return *this;
        }
    };

public:

    const Evil& operator -() const
    {
        printf( "Hello World!\n" );

        return *this;
    }

    Hack operator *() const
    {
        return Hack();
    }

};

int main( const int, const char* const* const )
{

        *  * ***** *    *     ***       * * *  ***  ***  *    ***
        *  * *     *    *    *   *      * * * *   * *  * *    *  *
        **** ***   *    *    *   *      * * * *   * ***  *    *  *
        *  * *     *    *    *   *      ***** *   * *  * *    *  *
        *  * ***** **** ****  ***       * * *  ***  *  * **** ***

    -Evil();

    return 0;
}

Evil things you can do with C++

noreply@blogger.com (Semi Essessi) — Fri, 06 Jan 2012 07:09:00 +0000

So, here is a really horrible trick to make it look like you have a fancy different operator in C++. The example implements a copy with '=' and a potentially shallow copy (if safe) with '<--'.. You can combine any of the unary and binary operators in this way, so you could create something like '+*' from dereference and addition, or '*+' from unary plus and multiply... there are endless possibilities because you can chain the unary operators together too, e.g..'<------' could do something else altogether Precedence and complicated expressions might get dangerous though... so in this example a <-- b + c will go wrong. Maybe there is a valid use for this kind of evil - I'm not sure, but it is interesting at least.

#include <stdio.h>

template< class T >
class DataWrapper
{

    class SugarPreDec
    {

    public:

        __forceinline SugarPreDec( DataWrapper* pxDataWrapper )
        : mxData( *pxDataWrapper )
        {
        }

        DataWrapper& mxData;

    };

public:

    __forceinline DataWrapper( const T& xData )
    : mpxData( new T( xData ) )
    , mbOwnData( true )
    {
    }

    __forceinline DataWrapper( T* const pxData )
    : mpxData( pxData )
    , mbOwnData( false )
    {
    }

    __forceinline DataWrapper( const DataWrapper& xData )
    : mpxData( new T( *( xData.mpxData ) ) )
    , mbOwnData( true )
    {
    }

    __forceinline ~DataWrapper()
    {
        ResetData();
    }

    __forceinline DataWrapper& operator =( const DataWrapper& xData )
    {
        CopyData( xData.mpxData );
        
        return *this;
    }

    __forceinline DataWrapper& operator =( T* const pxData )
    {
        ReferenceData( pxData );

        return *this;
    }

    __forceinline SugarPreDec operator --()
    {
        return SugarPreDec( this );
    }

    __forceinline DataWrapper& operator <( const SugarPreDec& xSugar )
    {
        if( xSugar.mxData.mbOwnData )
        {
            CopyData( xSugar.mxData.mpxData );
        }
        else
        {
            ReferenceData( xSugar.mxData.mpxData );
        }

        return *this;
    }

    __forceinline bool operator <( const DataWrapper& xData ) const
    {
        return mpxData < xData.mpxData;
    }

    __forceinline void DebugPrint() const
    {
        printf( "Address: 0x%X\n", reinterpret_cast< unsigned int >( mpxData ) );
    }

private:

    __forceinline void ResetData()
    {
        if( mbOwnData )
        {
            delete mpxData;
        }
    }

    __forceinline void CopyData( const T* const pxData )
    {
        ResetData();
        mpxData = new T( *pxData );
        mbOwnData = true;
    }

    __forceinline void ReferenceData( T* const pxData )
    {
        ResetData();
        mpxData = pxData;
        mbOwnData = false;
    }

    T* mpxData;
    bool mbOwnData;

};

int main( const int, const char* const* const )
{
    struct SomeData
    {
        int maiData[ 64 ];
    } axDatas[ 2 ];

    DataWrapper< SomeData > xWrapper1 = axDatas[ 0 ];
    DataWrapper< SomeData > xWrapper2 = xWrapper1;

    xWrapper1.DebugPrint();
    xWrapper2.DebugPrint();

    xWrapper1 = xWrapper2;
    xWrapper2 <-- xWrapper1;

    xWrapper1.DebugPrint();
    xWrapper2.DebugPrint();

    xWrapper1 = &( axDatas[ 1 ] );
    xWrapper2 <-- xWrapper1;

    xWrapper1.DebugPrint();
    xWrapper2.DebugPrint();

    __asm int 3

    return 0;
}

The code produced is a bit odd... not quite sure what the compiler is thinking, but considering the dynamic allocations being done and cleaned up its actually not too bad.

00401002  in          al,dx  
00401003  and         esp,0FFFFFFF8h  
00401006  sub         esp,208h  
0040100C  push        ebx  
0040100D  push        ebp  
    struct SomeData
    {
        int maiData[ 64 ];
    } axDatas[ 2 ];

    DataWrapper< SomeData > xWrapper1 = axDatas[ 0 ];
0040100E  mov         ebp,dword ptr [__imp_operator new (40209Ch)]  
00401014  push        esi  
00401015  push        edi  
00401016  push        100h  
0040101B  call        ebp  
0040101D  add         esp,4  
00401020  test        eax,eax  
00401022  je          main+39h (401039h)  
00401024  mov         ecx,40h  
00401029  lea         esi,[esp+18h]  
0040102D  mov         edi,eax  
0040102F  mov         ebx,eax  
00401031  rep movs    dword ptr es:[edi],dword ptr [esi]  
00401033  mov         dword ptr [esp+10h],ebx  
00401037  jmp         main+45h (401045h)  
00401039  mov         dword ptr [esp+10h],0  
00401041  mov         ebx,dword ptr [esp+10h]  
    DataWrapper< SomeData > xWrapper2 = xWrapper1;
00401045  push        100h  
0040104A  call        ebp  
0040104C  add         esp,4  
0040104F  test        eax,eax  
00401051  je          main+62h (401062h)  
00401053  mov         ecx,40h  
00401058  mov         esi,ebx  
0040105A  mov         edi,eax  
0040105C  rep movs    dword ptr es:[edi],dword ptr [esi]  
0040105E  mov         ebp,eax  
00401060  jmp         main+64h (401064h)  
00401062  xor         ebp,ebp  

    xWrapper1.DebugPrint();
00401064  push        ebx  
00401065  mov         ebx,dword ptr [__imp__printf (4020A8h)]  
0040106B  push        offset string "Address: 0x%X\n" (4020F4h)  
00401070  call        ebx  
    xWrapper2.DebugPrint();
00401072  push        ebp  
00401073  push        offset string "Address: 0x%X\n" (4020F4h)  
00401078  call        ebx  

    xWrapper1 = xWrapper2;
0040107A  mov         eax,dword ptr [esp+20h]  
0040107E  mov         edi,dword ptr [__imp_operator delete (4020A0h)]  
00401084  push        eax  
00401085  call        edi  
00401087  push        100h  
0040108C  call        dword ptr [__imp_operator new (40209Ch)]  
00401092  add         esp,18h  
00401095  test        eax,eax  
00401097  je          main+0B2h (4010B2h)  
00401099  mov         ecx,40h  
0040109E  mov         esi,ebp  
004010A0  mov         edi,eax  
004010A2  rep movs    dword ptr es:[edi],dword ptr [esi]  
004010A4  mov         edi,dword ptr [__imp_operator delete (4020A0h)]  
004010AA  mov         esi,eax  
004010AC  mov         dword ptr [esp+10h],esi  
004010B0  jmp         main+0BEh (4010BEh)  
004010B2  mov         dword ptr [esp+10h],0  
004010BA  mov         esi,dword ptr [esp+10h]  
    xWrapper2 <-- xWrapper1;
004010BE  push        ebp  
004010BF  call        edi  
004010C1  push        100h  
004010C6  call        dword ptr [__imp_operator new (40209Ch)]  
004010CC  add         esp,8  
004010CF  test        eax,eax  
004010D1  je          main+0EAh (4010EAh)  
004010D3  mov         ecx,40h  
004010D8  mov         edi,eax  
004010DA  rep movs    dword ptr es:[edi],dword ptr [esi]  
004010DC  mov         esi,dword ptr [esp+10h]  
004010E0  mov         edi,dword ptr [__imp_operator delete (4020A0h)]  
004010E6  mov         ebp,eax  
004010E8  jmp         main+0ECh (4010ECh)  
004010EA  xor         ebp,ebp  

    xWrapper1.DebugPrint();
004010EC  push        esi  
004010ED  push        offset string "Address: 0x%X\n" (4020F4h)  
004010F2  call        ebx  
    xWrapper2.DebugPrint();
004010F4  push        ebp  
004010F5  push        offset string "Address: 0x%X\n" (4020F4h)  
004010FA  call        ebx  

    xWrapper1 = &( axDatas[ 1 ] );
004010FC  push        esi  
004010FD  call        edi  
    xWrapper2 <-- xWrapper1;
004010FF  push        ebp  
00401100  call        edi  

    xWrapper1.DebugPrint();
00401102  lea         ecx,[esp+130h]  
00401109  push        ecx  
0040110A  push        offset string "Address: 0x%X\n" (4020F4h)  
0040110F  call        ebx  
    xWrapper2.DebugPrint();
00401111  lea         edx,[esp+138h]  
00401118  push        edx  
00401119  push        offset string "Address: 0x%X\n" (4020F4h)  
0040111E  call        ebx  
00401120  add         esp,28h  

    __asm int 3
00401123  int         3  

    return 0;
}
00401124  pop         edi  
00401125  xor         eax,eax  
00401127  pop         esi  
00401128  pop         ebp  
00401129  pop         ebx  
0040112A  mov         esp,ebp  
0040112C  pop         ebp  
0040112D  ret

Objective-C, not actually that bad

noreply@blogger.com (Semi Essessi) — Thu, 05 Jan 2012 22:37:00 +0000

I have just had a revelation about Objective-C. I haven't really enjoyed using the language so far to be honest, the language design fails to respect many things I consider golden rules of language design, the messaging mechanism limits the power of classes and the syntax is simply horrible. However, I've been looking at it the wrong way, as a competitor to C++, and as an extension of C. It really doesn't have the spirit of C about it in the same way that C++ does and the 'standard library' takes this a step further. Objective-C is a Rapid Application Development language, when coupled with Xcode.

Now as I think about it compared to Visual Basic, C#, Java and the like I realise its not so bad - it lets me more easily throw together the highest level stuff and inherit the power of the messaging system whilst giving me the power of C, C++ and assembler for the bits that count.

I'm still not sold. However, I no longer think of the language as a crap version of C with classes or a poor extension, but rather as a language in its own right which has excellent interoperability with C and C++.

Star Chart for Nokia is now on the featured page!

noreply@blogger.com (Semi Essessi) — Tue, 03 Jan 2012 17:18:00 +0000

Awesome. :)

Incidentally I now work for Escapist Games on Star Chart amongst other things...

Its nice when code compiles out...

noreply@blogger.com (Semi Essessi) — Thu, 29 Dec 2011 16:12:00 +0000

However, as soon as I break alignment by using bitshifts and add a conditional based on the value of one of those bits (an instruction is 6-bits long) - even though the compiler knows everything it needs to work out the return value, it doesn't. I'm curious exactly why it bothers using the stack, for instance.For some reason this disassembly lost the "int main()" but the preceding memory was all zeroes...

If I remove the conditional it does much better:

Still, I'm curious exactly why it has some stack logic there despite not using the stack at all.

Codemasters

noreply@blogger.com (Semi Essessi) — Wed, 02 Nov 2011 16:12:00 +0000

A few lovely stories about Codemasters from recent times that I am posting here for absolutely no reason whatsoever. Just because they are already in the public domain and I can.

http://www.theregister.co.uk/2011/06/10/codemasters/

http://www.guardian.co.uk/technology/2011/jun/10/codemasters-hit-by-hacker-attack

http://www.eurogamer.net/articles/2011-06-10-codemasters-was-hacked-data-stolen

Top tips for making your own game engine

noreply@blogger.com (Semi Essessi) — Fri, 21 Oct 2011 19:50:00 +0000

Never lose sight of being able to make a black screen do nothing app in a single simple step - making a new project should be painless. As much as I know GLToy can be improved it is hard to improve on it for this - you run one script with a minimum of one parameter and bam, job done. Every project starts this way, and you want people to use your game engine, right?

Organise the files properly - traversing directory structures is a small waste of time, but the value you get from keeping headers and cpp files next to each other will continue to pay off time after time - best of all its nearly impossible to break the Visual Studio in built "goto declaration" and "open header file" functionality if you stick to this. Sadly Visual Studio encourages stupidity here by providing default filters for header and source files which encourage a poor directory structure.

Don't depend on data - if your game engine crashes without some file present you probably did something wrong. Quake 3 does this, so its clearly forgivable, but still, the value of having a clean seperation and well defined dependencies will make itself apparent over time. If your simple, do nothing, app requires data it doesn't actually use then I'd consider you've quite likely done something wrong, or at least badly.

Plan ahead and don't hack - even big warning comments do not excuse hackery. If you get it right you can implement something once and never touch it again - even if you don't get it quite right try and imagine what you might want to come back and do later, make allowances for extending the code from the beginning. There is nothing worse than having to throw away a whole system because it is a pile of hacks to solve specific cases - except maybe trying to pile more code on top of the hacks and wasting a lot of time lying to yourself that you have a general purpose solution when you done. When you make an engine on your own the advantage of getting it right first time can not be understated - it makes the difference between spending weeks on something and spending hours.

Research the existing solutions to everything - if every major game engine does something a certain way and you want to do it differently you had better understand their solution inside and out and be able to explain why your approach is better for your engine. The guys at id, Valve, Epic and Crytek probably know what they are doing...

Add features for projects - if there are no projects then make realistic projects to drive features. Its tempting to think you can guess what people will need, but all that leads to is writing dead code and over-engineered solutions, with the possibility that your interfaces are difficult and dangerous to use. Features added from necessity are forced to work well, especially when you have the "get it right first time" mentality.

Don't be afraid to throw away bad code - maintaining bad code can cost a lot of time and effort - the more you do it the more you realise that writing systems from the ground up can be the best and fastest solution. Copy-paste helps mitigate the risk here, but most importantly if you find yourself writing lots of counter-intuitive boiler plate code to use your systems/modules its probably time to rethink the design of the offending code.

Write lots of engine code in your spare time - you will probably never have to design or implement a game engine architecture during your career if you are a professional games programmer. If you do ever have to then make sure its not your first time in because it will probably be the only commercial game engine you will get to do this with. I've seen plenty of commercial engines featuring mistakes I made in past engine attempts, including the "best-of breed" engines underlying AAA titles, and in some cases these can be pervasive, productivity hampering mistakes which will cost you more money the longer you can't see them and leave them unfixed.

Finally seem to have defeated those hackers...

noreply@blogger.com (Semi Essessi) — Thu, 20 Oct 2011 07:31:00 +0000

So, finally it seems like my blog has stopped being abused by hackers enough that my popular posts list has the inverse square root article back on top like it should be and not that Mass posting alert which has no really useful information and seems to have had its search engine ranking artificially inflated at some points in the past...

... I'm hoping its because I was successful in tracking down and removing all of the script hackery they did on my canvas experiments (which are very likely to remain down owing to lack of free hosting for JavaScript HTML stuff like this - and paid for hosting which is so rubbish that amateur Russian hackers will abuse you).

I don't often stop and look at it, but I quite like this list - mostly the articles that I liked the most myself are listed here, which feels rewarding for some reason... :)

Practical use of Template Meta Programming (TMP) - Part 1

noreply@blogger.com (Semi Essessi) — Tue, 18 Oct 2011 19:28:00 +0000

So - I may be working on the next engine having decided that GLToy - while perfectly fine and usable - is not going to scale well across the next generation of hardware. The only parallelism it exploits is through Havok for physics updates.

I've tried my best to get everything as fast and right as possible first time on this engine - although its not been perfect it is getting there quite quickly - I have usable data structures, common maths helper functions, an update loop and a configuration of "modules", "states" and "systems" which all ticks over.. Almost surprisingly I found some genuine use for template meta-programming amidst the work that needed doing - in particular having a list of types is useful for the modules and systems (it could be useful for states too) where every system needs its update loop run every frame, and every module needs to schedule its update in the "module system" if active during that state.

The usual OO approach to this is to make all of these things instantiated objects and use some virtual function calls to provide the system or module specific functionality for the update cycles. This works, but its less than ideal:

We must now instantiate these classes - for systems in particular this is not especially appropriate - we don't have to instance any data, but the virtual calls we want to use will pass a this pointer around anyway - these virtual calls can not be static. The instances also need to exist somewhere with distinct pointers, which forces some allocations to happen (perhaps a one-off cost).
Virtual calls are relatively slow - the virtual call mechanism will pollute the cache on every use, create stack frames if needed (or at least stack allocations which are freed on function exit). The reason for this is down to the implementation and hardware details - enough stuff happens that you are quite likely to get 2 cache misses on each one - more likely 3 or 4::

if we are lucky a pointer to the v-table is already in the cache - otherwise we fetch the class into the cache (one potential miss)
we fetch the vtable into the cache - provided it is sufficiently small this is a single potential miss - it can be (quite easily) many depending on the location and size of the table - two misses is safer, but lets assume we only get one - note this is very likely to miss once even in the ideal case
we now read the function address out of the vtable and fetch the contents at that address into the instruction cache - this is very likely to miss unless you have a small test case or very local code.

Another solution is to amortise the virtual calls across all types using something similar to what I discussed in this previous blog post. This won't completely remove the problem - there is still a virtual function call and stack frames although at least we've reduced them down to one.

It turns out that the best solution I've found is to use a TMP list to store the types - this way we can remove all the virtual calls, gain the potential to inline all the calls, remove the need for any instances or extra memory overhead and removing the overhead of running a loop across the types. It might be possible to do something even more performant, but I haven't found it yet (please suggest it).

Now, these are small loops and the benefits here are slim, especially over the amortised virtual function call mechanism - however it all adds up. A system which does nothing on its update now costs nothing to update - not even a call to some empty function. This is a nice warm-up for trying to deal with entities - I'd like to try to implement a component based entity system and this is going to mean that for my potentially 1000s of entities I can have many components on each one - 1000s of hits on any bit of code tends to be a non-trivial performance cost, especially if you touch memory whilst polluting the cache on every cycle of the loop. It can even slow separate things down on other threads owing to cache pollution...

So, the entry point function of the new engine looks pretty neat - atm it is 8K, with some 6K or so of main loop - all "solid" code with lots of inlining and unrolling - there are a handful of allocator and static constructor calls, thread creation API calls and a single virtual call for the state system update but for the most part it is one big contiguous block of code that the CPU can churn through happily and that allows the compiler lots of freedom with optimisation. As an example of the optimisation potential, all of the function calls and classes involved can recycle each others stack usage - in fact, aside from very few little bits like constructors, allocations, API calls, virtuals, recursive functions and the static data section everything is using this one stack frame.

So, I guess you might be wondering exactly how we can create a list of types? My approach is similar to many others I have found through research, although I've not seen many starting the list with a null as I have (which is optional, but I do it for the sake of other potential TMP work I will do with these things. at any rate the list is constructed by defining templated types which have the types we want to list as typedefs inside of this - this is accomplished using macros for ease of programmer use. Along with the type, which we can consider the "head" of the sub-list, we include a typedef for the "tail" of the list allowing the "list nodes" to be connected: This sounds horrible, but some code should demonstrate much more clearly - this is the system list from my new code.

template< class T >
struct SystemListConstructor
{
    typedef MP_NULL Head;
    typedef MP_NULL Tail;
};

struct SystemListHead {};

template<>
struct SystemListConstructor< SystemListHead >
{
    typedef MP_NULL Head;

    #include <Configuration/Systems/UseSystems.h>

    typedef MP_NULL Tail;
};


template<>
struct SystemListConstructor< SystemListHead >
{
    typedef MP_NULL Head;

    UseSystem( Maths );
    UseSystem( Time );

    // ... etc

    typedef MP_NULL Tail;
};

typedef SystemListConstructor< SystemListHead > SystemList;

MP_NULL is an empty struct like SystemListHead, but one for which I try to use everywhere some kind of null type is required and so that I can have, e.g. MP_NULLCHECK< T > template which contains an enum value which is true or false accordingly.

Now, you might think I should have shown you the macro first, but that would have probably been confusing, but here it is:

#define UseSystem( System ) \
typedef SystemListConstructor< System > Tail; }; \
template<> struct SystemListConstructor< System > { typedef System Head;

Note how each instance ends the previous node's templated struct and starts a new one.- including a typedef to "point" at the new struct as the tail of the previous node and including the type we care about as the head of the next node.

Now the final piece required to get any use from this is some kind of traversal mechanism. So that I could allow guaranteed inlining of static functions and various other slightly awkward things I opted for using macros to hide the template metaprogramming - conveniently it is much more readable as well. Here is the macro for iterating over the list of types and calling some predicate function which takes the type as its template parameter:

#define DefineSystemListTraversal( xName, xPredicate ) \
    template< class T >\
    struct Traverser_##xName\
    {\
        static ForceInline void CallPredicate()\
        {\
            xPredicate< T >();\
        }\
\
        static ForceInline void Traverse()\
        {\
            Traverser_##xName< T::Head >::CallPredicate();\
            Traverser_##xName< T::Tail >::Traverse();\
        }\
    };\
\
    template<>\
    struct Traverser_##xName< MP_NULL >\
    {\
        static ForceInline void CallPredicate() {}\
        static ForceInline void Traverse() {}\
    };\
\
    struct xName\
    : protected Traverser_##xName< SystemList >\
    {\
        static ForceInline void Run() { Traverse(); }\
    };

Now, using this thing is actually pretty easy and readable...at least to my mind. Here is some code from the same project which uses this stuff (note the update traverser is not used here, but elsewhere):

template< class System >
ForceInline void TraceSystemName()
{
    Trace( "Using system %s\n", System::GetName() );
}

template< class System >
ForceInline void RegisterSystem()
{
    System::Register();
}

template< class System >
ForceInline void UpdateSystem()
{
    System::Cycle();
}

DefineSystemListTraversal( TraceSystemNames, TraceSystemName );
DefineSystemListTraversal( RegisterSystems, RegisterSystem );
DefineSystemListTraversal( UpdateSystems, UpdateSystem );

static ForceInline void SystemConfiguration()
{
    Trace( "Configuring Systems...\n" );

    TraceSystemNames::Run();

    // register them all
    RegisterSystems::Run();
}

... and the result of all this effort is some beautifully compiled code (not all 8k, just an excerpt) - I won't pretend it is perfect, but I love that this is from my entry point function and its managed to inline and optimise it this heavily before I've gone around and started playing with compiler settings etc. Next time I'll show how its possible to build a map using a binary tree which can be looked up from in constant time at compile time and logarithmic time at run time by extending this same technique...

    Breakpoint();
004211B6  int         3  

    MainLoop::Run();
004211B7  push        offset string "Configuring Systems...\n" (435104h)  
004211BC  push        offset string "MAIN" (4349C4h)  
004211C1  call        TraceChannel (40243Ch)  
004211C6  push        offset string "Maths" (434BF8h)  
004211CB  push        offset string "Using system %s\n" (434E18h)  
004211D0  push        offset string "MAIN" (4349C4h)  
004211D5  call        TraceChannel (40243Ch)  
004211DA  push        offset string "Time" (434CE0h)  
004211DF  push        offset string "Using system %s\n" (434E18h)  
004211E4  push        offset string "MAIN" (4349C4h)  
004211E9  call        TraceChannel (40243Ch)  
004211EE  push        offset string "ThreadSystem" (434CF4h)  
004211F3  push        offset string "Using system %s\n" (434E18h)  
004211F8  push        offset string "MAIN" (4349C4h)  
004211FD  call        TraceChannel (40243Ch)  
00421202  push        offset string "FileSystem" (434D10h)  
00421207  push        offset string "Using system %s\n" (434E18h)  
0042120C  push        offset string "MAIN" (4349C4h)  
00421211  call        TraceChannel (40243Ch)  
00421216  push        offset string "StateSystem" (434D90h)  
0042121B  push        offset string "Using system %s\n" (434E18h)  
00421220  push        offset string "MAIN" (4349C4h)  
00421225  call        TraceChannel (40243Ch)  
0042122A  add         esp,44h  
0042122D  push        offset string "ModuleSystem" (434DACh)  
00421232  push        offset string "Using system %s\n" (434E18h)  
00421237  push        offset string "MAIN" (4349C4h)  
0042123C  call        TraceChannel (40243Ch)  
00421241  add         esp,0Ch  
00421244  xor         eax,eax  
00421246  jmp         EntryPoint+0F0h (421250h)  
00421248  lea         esp,[esp]  
0042124F  nop  
00421250  cmp         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],edi  
00421257  je          00422039  
0042125D  inc         eax  
0042125E  cmp         eax,40h  
00421261  jl          EntryPoint+0F0h (421250h)  
00421263  jmp         00422044  
                {
                    Engine::Initialise();
00421268  push        offset string "Configuring Systems...\n" (435104h)  
0042126D  push        offset string "MAIN" (4349C4h)  
00421272  call        TraceChannel (40243Ch)  
00421277  push        offset string "Maths" (434BF8h)  
0042127C  push        offset string "Using system %s\n" (434E18h)  
00421281  push        offset string "MAIN" (4349C4h)  
00421286  call        TraceChannel (40243Ch)  
0042128B  push        offset string "Time" (434CE0h)  
00421290  push        offset string "Using system %s\n" (434E18h)  
00421295  push        offset string "MAIN" (4349C4h)  
0042129A  call        TraceChannel (40243Ch)  
0042129F  push        offset string "ThreadSystem" (434CF4h)  
004212A4  push        offset string "Using system %s\n" (434E18h)  
004212A9  push        offset string "MAIN" (4349C4h)  
004212AE  call        TraceChannel (40243Ch)  
004212B3  push        offset string "FileSystem" (434D10h)  
004212B8  push        offset string "Using system %s\n" (434E18h)  
004212BD  push        offset string "MAIN" (4349C4h)  
004212C2  call        TraceChannel (40243Ch)  
004212C7  push        offset string "StateSystem" (434D90h)  
004212CC  push        offset string "Using system %s\n" (434E18h)  
004212D1  push        offset string "MAIN" (4349C4h)  
004212D6  call        TraceChannel (40243Ch)  
004212DB  add         esp,44h  
004212DE  push        offset string "ModuleSystem" (434DACh)  
004212E3  push        offset string "Using system %s\n" (434E18h)  
004212E8  push        offset string "MAIN" (4349C4h)  
004212ED  call        TraceChannel (40243Ch)  
004212F2  add         esp,0Ch  
004212F5  xor         eax,eax  
004212F7  lea         esi,[eax+1]  
004212FA  lea         ebx,[ebx]  
00421300  cmp         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],edi  
00421307  je          EntryPoint+1B2h (421312h)  
00421309  add         eax,esi  
0042130B  cmp         eax,40h  
0042130E  jl          EntryPoint+1A0h (421300h)  

    MainLoop::Run();
00421310  jmp         EntryPoint+1BDh (42131Dh)  
                {
                    Engine::Initialise();
00421312  mov         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],offset System<Maths,1>::s_xRegistry (437000h)  
0042131D  xor         eax,eax  
0042131F  nop  
00421320  cmp         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],edi  
00421327  je          EntryPoint+1D2h (421332h)  
00421329  add         eax,esi  
0042132B  cmp         eax,40h  
0042132E  jl          EntryPoint+1C0h (421320h)  

    MainLoop::Run();
00421330  jmp         EntryPoint+1DDh (42133Dh)  
                {
                    Engine::Initialise();
00421332  mov         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],offset System<Time,1>::s_xRegistry (437004h)  
0042133D  xor         eax,eax  
0042133F  nop  
00421340  cmp         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],edi  
00421347  je          EntryPoint+1F2h (421352h)  
00421349  add         eax,esi  
0042134B  cmp         eax,40h  
0042134E  jl          EntryPoint+1E0h (421340h)  

    MainLoop::Run();
00421350  jmp         EntryPoint+1FDh (42135Dh)  
                {
                    Engine::Initialise();
00421352  mov         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],offset System<ThreadSystem,1>::s_xRegistry (437008h)  
0042135D  xor         eax,eax  
0042135F  nop  
00421360  cmp         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],edi  
00421367  je          EntryPoint+212h (421372h)  
00421369  add         eax,esi  
0042136B  cmp         eax,40h  
0042136E  jl          EntryPoint+200h (421360h)  

    MainLoop::Run();
00421370  jmp         EntryPoint+21Dh (42137Dh)  
                {
                    Engine::Initialise();
00421372  mov         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],offset System<FileSystem,0>::s_xRegistry (43700Ch)  
0042137D  xor         eax,eax  
0042137F  nop  
00421380  cmp         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],edi  
00421387  je          EntryPoint+232h (421392h)  
00421389  add         eax,esi  
0042138B  cmp         eax,40h  
0042138E  jl          EntryPoint+220h (421380h)  

    MainLoop::Run();
00421390  jmp         EntryPoint+23Dh (42139Dh)  
                {
                    Engine::Initialise();
00421392  mov         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],offset System<StateSystem,1>::s_xRegistry (437010h)  
0042139D  xor         eax,eax  
0042139F  nop  
004213A0  cmp         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],edi  
004213A7  je          EntryPoint+252h (4213B2h)  
004213A9  add         eax,esi  
004213AB  cmp         eax,40h  
004213AE  jl          EntryPoint+240h (4213A0h)  

    MainLoop::Run();
004213B0  jmp         EntryPoint+25Dh (4213BDh)  
                {
                    Engine::Initialise();
004213B2  mov         dword ptr SystemRegistryBase::s_apxRegistries (4390C0h)[eax*4],offset System<ModuleSystem,1>::s_xRegistry (437014h)  
004213BD  push        offset string "Configuring Modules...\n" (435124h)  
004213C2  push        offset string "MODULE" (4350A8h)  
004213C7  call        TraceChannel (40243Ch)  
004213CC  add         esp,8  
004213CF  test        byte ptr [`MemoryModule::GetName'::`2'::`local static guard' (4385A4h)],1  
004213D6  jne         EntryPoint+29Ah (4213FAh)  
004213D8  or          dword ptr [`MemoryModule::GetName'::`2'::`local static guard' (4385A4h)],esi  
004213DE  push        offset string "MemoryModule" (435008h)  
004213E3  mov         ecx,offset ls_szName (438594h)  
004213E8  call        WideString::WideString (402987h)  
004213ED  push        offset `MemoryModule::GetName'::`2'::`dynamic atexit destructor for 'ls_szName'' (4013A2h)  
004213F2  call        atexit (42F31Fh)  
004213F7  add         esp,4  
004213FA  mov         eax,dword ptr [ls_szName (438594h)]  
004213FF  push        eax  
00421400  push        offset string "Using %S\n" (4350B0h)  
00421405  push        offset string "MODULE" (4350A8h)  
0042140A  call        TraceChannel (40243Ch)  
0042140F  add         esp,0Ch  
00421412  test        byte ptr [`PerformanceModule::GetName'::`2'::`local static guard' (4385B8h)],1  
00421419  jne         EntryPoint+2DDh (42143Dh)  
0042141B  or          dword ptr [`PerformanceModule::GetName'::`2'::`local static guard' (4385B8h)],esi  
00421421  push        offset string "PerformanceModule" (435018h)  
00421426  mov         ecx,offset ls_szName (4385A8h)  
0042142B  call        WideString::WideString (402987h)  
00421430  push        offset `PerformanceModule::GetName'::`2'::`dynamic atexit destructor for 'ls_szName'' (402A54h)  
00421435  call        atexit (42F31Fh)  
0042143A  add         esp,4  
0042143D  mov         ecx,dword ptr [ls_szName (4385A8h)]  
00421443  push        ecx  
00421444  push        offset string "Using %S\n" (4350B0h)  
00421449  push        offset string "MODULE" (4350A8h)  
0042144E  call        TraceChannel (40243Ch)  
00421453  add         esp,0Ch  
00421456  test        byte ptr [`NullRenderModule::GetName'::`2'::`local static guard' (438608h)],1  
0042145D  jne         EntryPoint+321h (421481h)  
0042145F  or          dword ptr [`NullRenderModule::GetName'::`2'::`local static guard' (438608h)],esi  
00421465  push        offset string "NullRenderModule" (435074h)  
0042146A  mov         ecx,offset ls_szName (4385F8h)  
0042146F  call        WideString::WideString (402987h)  
00421474  push        offset `NullRenderModule::GetName'::`2'::`dynamic atexit destructor for 'ls_szName'' (401974h)  
00421479  call        atexit (42F31Fh)  
0042147E  add         esp,4  
00421481  mov         edx,dword ptr [ls_szName (4385F8h)]  
00421487  push        edx  
00421488  push        offset string "Using %S\n" (4350B0h)  
0042148D  push        offset string "MODULE" (4350A8h)  
00421492  call        TraceChannel (40243Ch)  
00421497  add         esp,0Ch  
0042149A  test        byte ptr [`NullAudioModule::GetName'::`2'::`local static guard' (4385CCh)],1  
004214A1  jne         EntryPoint+365h (4214C5h)  
004214A3  or          dword ptr [`NullAudioModule::GetName'::`2'::`local static guard' (4385CCh)],esi  
004214A9  push        offset string "NullAudioModule" (435030h)  
004214AE  mov         ecx,offset ls_szName (4385BCh)  
004214B3  call        WideString::WideString (402987h)  
004214B8  push        offset `NullAudioModule::GetName'::`2'::`dynamic atexit destructor for 'ls_szName'' (4024B4h)  
004214BD  call        atexit (42F31Fh)  
004214C2  add         esp,4  
004214C5  mov         eax,dword ptr [ls_szName (4385BCh)]  
004214CA  push        eax  
004214CB  push        offset string "Using %S\n" (4350B0h)  
004214D0  push        offset string "MODULE" (4350A8h)  
004214D5  call        TraceChannel (40243Ch)  
004214DA  add         esp,0Ch  
004214DD  test        byte ptr [`NullPhysicsModule::GetName'::`2'::`local static guard' (4385F4h)],1  
004214E4  jne         EntryPoint+3A8h (421508h)  
004214E6  or          dword ptr [`NullPhysicsModule::GetName'::`2'::`local static guard' (4385F4h)],esi  
004214EC  push        offset string "NullPhysicsModule" (43505Ch)  
004214F1  mov         ecx,offset ls_szName (4385E4h)  
004214F6  call        WideString::WideString (402987h)  
004214FB  push        offset `NullPhysicsModule::GetName'::`2'::`dynamic atexit destructor for 'ls_szName'' (401EE2h)  
00421500  call        atexit (42F31Fh)  
00421505  add         esp,4  
00421508  mov         ecx,dword ptr [ls_szName (4385E4h)]  
0042150E  push        ecx  
0042150F  push        offset string "Using %S\n" (4350B0h)  
00421514  push        offset string "MODULE" (4350A8h)  
00421519  call        TraceChannel (40243Ch)  
0042151E  add         esp,0Ch  
00421521  test        byte ptr [`NullNetworkModule::GetName'::`2'::`local static guard' (4385E0h)],1  
00421528  jne         EntryPoint+3ECh (42154Ch)  
0042152A  or          dword ptr [`NullNetworkModule::GetName'::`2'::`local static guard' (4385E0h)],esi  
00421530  push        offset string "NullNetworkModule" (435044h)  
00421535  mov         ecx,offset ls_szName (4385D0h)  
0042153A  call        WideString::WideString (402987h)  
0042153F  push        offset `NullNetworkModule::GetName'::`2'::`dynamic atexit destructor for 'ls_szName'' (401F73h)  
00421544  call        atexit (42F31Fh)  
00421549  add         esp,4  
0042154C  mov         edx,dword ptr [ls_szName (4385D0h)]  
00421552  push        edx  
00421553  push        offset string "Using %S\n" (4350B0h)  
00421558  push        offset string "MODULE" (4350A8h)  
0042155D  call        TraceChannel (40243Ch)  
00421562  add         esp,0Ch  
00421565  test        byte ptr [`InputModule::GetName'::`2'::`local static guard' (438630h)],1  
0042156C  jne         00421590  
0042156E  or          dword ptr [`InputModule::GetName'::`2'::`local static guard' (438630h)],esi  
00421574  push        offset string "InputModule" (435098h)  
00421579  mov         ecx,offset ls_szName (438620h)  
0042157E  call        WideString::WideString (402987h)  
00421583  push        offset `InputModule::GetName'::`2'::`dynamic atexit destructor for 'ls_szName'' (402A45h)  
00421588  call        atexit (42F31Fh)  
0042158D  add         esp,4  
00421590  mov         eax,dword ptr [ls_szName (438620h)]  
00421595  push        eax  
00421596  push        offset string "Using %S\n" (4350B0h)  
0042159B  push        offset string "MODULE" (4350A8h)  
004215A0  call        TraceChannel (40243Ch)  
004215A5  add         esp,0Ch  
004215A8  test        byte ptr [`EntityModule::GetName'::`2'::`local static guard' (43861Ch)],1  
004215AF  jne         004215D3  
004215B1  or          dword ptr [`EntityModule::GetName'::`2'::`local static guard' (43861Ch)],esi  
004215B7  push        offset string "EntityModule" (435088h)  
004215BC  mov         ecx,offset ls_szName (43860Ch)  
004215C1  call        WideString::WideString (402987h)  
004215C6  push        offset `EntityModule::GetName'::`2'::`dynamic atexit destructor for 'ls_szName'' (4010AAh)  
004215CB  call        atexit (42F31Fh)  
004215D0  add         esp,4  
004215D3  mov         ecx,dword ptr [ls_szName (43860Ch)]  
004215D9  push        ecx  
004215DA  push        offset string "Using %S\n" (4350B0h)  
004215DF  push        offset string "MODULE" (4350A8h)  
004215E4  call        TraceChannel (40243Ch)  
004215E9  push        4  
004215EB  call        operator new (42F278h)  
004215F0  add         esp,10h  
004215F3  cmp         eax,edi  
004215F5  je          00421601  
004215F7  mov         dword ptr [eax],offset State_Initialising::`vftable' (434EBCh)  
004215FD  mov         ecx,eax  
004215FF  jmp         00421603  
00421601  xor         ecx,ecx  
00421603  mov         dword ptr [ebp-38h],ecx  
00421606  mov         edx,dword ptr [ecx]  
00421608  mov         eax,dword ptr [edx]  
0042160A  call        eax  
0042160C  mov         ecx,dword ptr [HashMapInterface<StateInterface>::s_xMap (43850Ch)]  
00421612  mov         dword ptr [iArgumentCount],eax  
00421615  cmp         ecx,edi  
00421617  je          00421628  
00421619  push        eax  
0042161A  lea         edx,[ebp-38h]  
0042161D  push        edx  
0042161E  call        BinaryTree<StateInterface *,unsigned int>::Node::AddNode (4021F8h)  
00421623  jmp         004217A0  
00421628  mov         ecx,dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool+0Ch (4384F4h)]  
0042162E  mov         eax,dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool+10h (4384F8h)]  
00421633  add         ecx,esi  
00421635  mov         dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool+0Ch (4384F4h)],ecx  
0042163B  cmp         ecx,eax  
0042163D  jne         00421701  
00421643  mov         ebx,eax  
00421645  add         eax,eax  
00421647  push        0Ch  
00421649  mov         dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool+10h (4384F8h)],eax  
0042164E  call        operator new (42F278h)  
00421653  add         esp,4  
00421656  cmp         eax,edi  
00421658  je          00421666  
0042165A  mov         dword ptr [eax],edi  
0042165C  mov         dword ptr [eax+4],edi  
0042165F  mov         dword ptr [eax+8],edi  
00421662  mov         esi,eax  
00421664  jmp         00421668  
00421666  xor         esi,esi  
00421668  mov         ecx,dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool+8 (4384F0h)]  
0042166E  mov         eax,dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool+4 (4384ECh)]  
00421673  inc         ecx  
00421674  lea         edx,[ecx*4]  
0042167B  cmp         eax,edx  
0042167D  jae         004216A1  
0042167F  shr         eax,2  
00421682  cmp         eax,edi  
00421684  jne         0042168B  
00421686  mov         eax,1  
0042168B  cmp         eax,ecx  
0042168D  jge         00421696  
0042168F  nop  
00421690  add         eax,eax  
00421692  cmp         eax,ecx  
00421694  jl          00421690  
00421696  push        eax  
00421697  mov         ecx,offset PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool (4384E8h)  
0042169C  call        HeapMemoryBlock::Resize<Array<Pool<BinaryTree<StateInterface *,unsigned int>::Node>::Allocation,HeapMemoryBlock> *> (401CA8h)  
004216A1  mov         ecx,dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool+8 (4384F0h)]  
004216A7  mov         eax,dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool (4384E8h)]  
004216AC  mov         dword ptr [eax+ecx*4],esi  
004216AF  mov         eax,dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool+8 (4384F0h)]  
004216B4  mov         edx,dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool (4384E8h)]  
004216BA  inc         eax  
004216BB  mov         dword ptr [PoolAllocated<BinaryTree<StateInterface *,unsigned int>::Node>::s_xPool+8 (4384F0h)],eax  
004216C0  mov         esi,dword ptr [edx+eax*4-4]  
004216C4  mov         ecx,dword ptr [esi+4]  
004216C7  mov         eax,ebx  
004216C9  shl         eax,4  
004216CC  add         eax,ebx  
004216CE  cmp         ecx,eax  
004216D0  jae         004216FE  
004216D2  mov         eax,0F0F0F0F1h  
004216D7  mul         eax,ecx  
004216D9  shr         edx,4  
004216DC  cmp         edx,edi  
004216DE  jne         004216E5  
004216E0  mov         edx,1  
004216E5  cmp         edx,ebx  
004216E7  jge         004216F6  
004216E9  lea         esp,[esp]
...       ...         ...

Redundant again...

noreply@blogger.com (Semi Essessi) — Tue, 20 Sep 2011 23:32:00 +0000

It's sad really - Codemasters Guildford is easily the most amazing team I've ever worked with - I've been constantly amazed that so many talented people could throw themselves into something and still produce mediocre results. I was willing to stay there til the bitter end - and managed it, although it came sooner than I expected.

NDAs seem to prevent me from speaking my mind fully so I'll leave it at that...

I seem to have made some impression somehow though - every other gamedev seems to want me for something or the other. Its nice to feel wanted. :)

.NET fail

noreply@blogger.com (Semi Essessi) — Tue, 23 Aug 2011 21:39:00 +0000

60MB of crap required to use it - and the downloader isn't stable enough for my extremely stable 50MBit connection to get it all in time before it explodes.

To make it worse it looks like they burned some money on recreating the error handling dialog somehow. Downloading and installing files is not hard, MS have been doing it for years in many installers I have used without failure - this leads me to believe that whoever did this one was some kind of fool intent on rewriting perfectly good code and burning money instead of getting his job done, quicker, better and with less code.

Then again... I don't know because I can't see the source code... which is probably a good thing because I would lose the next X minutes/hours to debugging and fixing it... I didn't even check the report, lest I see 0xC0000005 and 0x00000000 and this become a rant about naive null pointer usage not being the same thing as defensive code.

The cream of the crop...

noreply@blogger.com (Semi Essessi) — Mon, 08 Aug 2011 06:19:00 +0000

I often bang on about just how awesome game programmers are in general, and the ones I work with in particular, but there is one bunch which consistently put us to shame - rather than try and make a consistent argument for why this is I will just show you some videos from this year's Assembly demo compo...

ASD have been producing demos since way back when I first became interested in the scene, and this latest one, the winner this year, is jawdropping - reminding me of something I once did for AVS a long time ago, only a million times cooler and less buggy:

There were plenty of others, but here are some I liked:

Perhaps the most impressive though are the 4k demos where all the overhead of runtime libraries, and full entry points are too much, where every executable needs to be compressed cleverly with the data being constructed procedurally in most cases for even more economy of size:

The game compo is much less impressive, but the style warms my heart - I found this one in particular both amusing and impressive:

Optimisation practice - Part 2 - The reference implementation

noreply@blogger.com (Semi Essessi) — Sun, 07 Aug 2011 19:49:00 +0000

So... last time I mysteriously hinted at the various possibilities for optimising string reversal in the context of loading a file and writing the reversed string to another file. But, before doing any premature optimisation it is important to have a program against which to test accuracy, and perhaps even to define the problem itself:

// reference implementation of string reversal

// we take the definition of string reversal to be the result in the
// output file generated by this program from any given input file

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

int main( const int iArgumentCount, const char* const* const pszArguments )
{
    // perform some basic argument checking first

    if( iArgumentCount < 3 )
    {
        printf( "Invalid argument count %d, expected: 2\n", iArgumentCount - 1 );
        
        return -1;
    }

    FILE* pxSourceFile = fopen( pszArguments[ 1 ], "rb" );

    if( !pxSourceFile )
    {
        printf( "Failed to open source path \"%s\" for reading\n", pszArguments[ 1 ] );
        
        return -1;
    }

    FILE* pxOutputFile = fopen( pszArguments[ 2 ], "wb" );

    if( !pxOutputFile )
    {
        printf( "Failed to open destination path \"%s\" for writing\n", pszArguments[ 2 ] );
        
        fclose( pxSourceFile );
        return -1;
    }

    // now write the bytes from the source file into the output file
    // one at a time, reading the source file in reverse order
    
    fseek( pxSourceFile, 0, SEEK_END );
    int iLength = ftell( pxSourceFile );

    fseek( pxOutputFile, 0, SEEK_SET );
    
    char cByte;
    for( int i = 0; i < iLength; ++i )
    {
        fseek( pxSourceFile, -i - 1, SEEK_END );
        fread( &cByte, 1, 1, pxSourceFile );
        fwrite( &cByte, 1, 1, pxOutputFile );
    }

    fclose( pxOutputFile );
    fclose( pxSourceFile );

    printf( "Success.\n" );

    return 0;
}

This implementation is naive, but simple, simple enough that I am happy to test it with a simple input file and be satisfied that it almost certainly always works. It would be nice to have tests which are independent of the program, for instance we can check for the operation being its own inverse, a property of string reversal, or check that the last character in the output is always the first in the input etc...

Its obvious from looking at this that we can probably optimise some things, we can expect the file reading/writing to the be the bottleneck, so doing either a single byte at a time is probably less than ideal unless the library is busily hiding the details from us - there is only one way to know for sure though and that is to measure everything...

Optimisation practice - Part 1

noreply@blogger.com (Semi Essessi) — Sat, 23 Jul 2011 00:17:00 +0000

The objective is simple - reverse a string given to a command line program as a file and storing it to a path, also given as a command line parameter.

Sounds easy, right?

Surely there is just one best way, right?

Lets find out... (more to come)

Still not ready...

noreply@blogger.com (Semi Essessi) — Fri, 22 Jul 2011 00:08:00 +0000

That lead role on DOOM 4 is still advertised - its the only job I'd leave Codies for, but painfully aware I am not yet ready for it. I imagine a whole bunch of experienced, existing leads have applied for it and failed. Possibly learning a hard lesson in precisely how little talent it takes to reach such positions in an industry littered with quiche eaters and novices.

Still, I taught myself to code for real with Quake 3, I try my best to learn hard the lessons of Quakes and DOOMs that even modern "AAA" titles can still do with learning, and try to be at least a spiritual successor to Carmack. I'm sure that job will wait for me or otherwise become available when the time is right... its waited 2 years already. I can't help but think they are waiting for the right person and are in no hurry to fill it... that Carmack will lead DOOM 4 because so few exist that could fill those shoes.

I have however wanted that job since forever, since first playing Wolf 3D and dreaming of making games. I can't help but wonder how many applicants there have been and if any of them can crap out a Quake 2 renderer in a month the way I did. If they appreciate the value of convex volumes, BSP trees and cell-portal graphs, having networking at the heart of the architecture and generally not buying all the lies about how many programmers it takes to ship a AAA title.

I long for the good old days having seen myriad programmers with no idea about what I consider to be the most basic things, things like C struct layout rules, PVS, cache utilisation and clean architecture. Modern hardware has opened the door to far too many, but don't get me wrong, most game programmers are still pretty incredible - but the ones I want to be, the idea I had as a child of what it would take - the people I meet mostly don't come close. (mostly)

I'll just have to content myself for now with being some id fanboy, and wannabe real programmer. I have no desire to become a lead where I am now or at any other studio for that matter, and I have a position at the right level and with a company that I feel has enough prestige - even if a Crytek or a Valve came looking for me I would (perhaps foolishly) tell them to stick it. They obviously have some good ideas about how to do things and are very successful, but somehow that makes them much less appealing to me.

Maybe one day soon things will be different - I still seem to be learning at an exponential rate, which I find extremely satisfying, I'm racing towards becoming a real programmer and accelerating along the way with the rate of acceleration increasing, and that rate increasing as well... I'm already convinced I can refactor GLToy into something much better, smaller and faster than it already is, and I believe I will have even better ideas in another 3 months, 6 months, a year... its only a matter of time before I will be ready to fulfil my ambitions.

They do advertise roles within my graspt - but the magic isn't there. My dream is to stand as an equal to the John Carmacks of this world and nothing less - right now though, maybe I am still just more EGO than id.