smartlikearoboc's GSoC blog

I’m throwing a pretty crazy end-of-GSoC party over here, so I thought I’d post some PICTARZ (TM) of the GUI as it’s on the branch right now, because I’ve been promising them for quite a while. That’s pretty much it folks.

Also, while I’m at it I might as well share a video which is a must watch in order to be considered a worthy human being:

UPDATE: Apparently, it looks like my artistic retardedness made me paint half of the GUI pink instead of yellow. The usual folks at IRC pointed that out – as always. ;D

I commited a fix… It was just a one-line change thanks to my awesome idea of using color palettes instead of repeating color values. </egotrip> It’s actually *yellow* now – I checked against the trunk version. Go me.

So… yes, right. Doc is up. And by doc I mean documentation. And by up I mean that a first draft of the Theme Format documentation has been uploaded and can be seen here. It even has PICTARZ, so feel free to take a peek and tell me what do you think I could improve (apart from the obvious missing sentences and the hundreds of typos). And don’t tell me I can improve PICTARZ because they are the most awesome shit you’ll ever see in a XML format documentation. EVAR.

Also, in case you don’t know, I have been working my ass off this last week. Yesterday I dropped all traces of the legacy GUI code from my SVN branch (if that’s not a project milestone, then I don’t know what is it).

This afternoon I’ve written a whole theme from scratch (a reproduction of the old “classic” theme) in less than 1h. I guess that proves that the new STX format is powerful or something.

…And that’s it. I’m basically done. There are just a few graphical glitches here and there (the new GUI doesn’t look exactly like the old one) which I’ll be fixing over the weekend.

I wanna be Jackie Onassis. I wanna wear a pair of dark sunglasses. I wanna be Jackie O, oh, oh, oh please don’t die.

UPDATE: I have given another pass to the STX format documentation, and also uploaded the documentation for the XML Parser.

This afternoon I’ve hit a pretty important milestone on my project:

Wait a second, didn’t I show a screenshot that looked just like that 2 weeks ago? Well, it turns out that in this case, the actual rendering is 100% defined from an external XML file.

So that’s basically what I wanted to show. The parser for theme looks is finished (and it’s able to do more powerful stuff than rounded squares, by the way), so the parser for theme layouts is coming up next.

Also, don’t watch The Ruins. It’s not scary but plain disgusting. And try not to live in Spain, either: It’s 4 in the morning and we are at 38 degrees Celsius. I obviously cannot sleep.

Good news everyone: I just wanted to let you know that I’m free again – free from my exams, that is. Actually, this post is just a replacement for my previous one; it turns out that the overall tone of my last post wasn’t really appropriate, something which I quite understand. Sometimes I tend to forget that this is a development blog and not my personal one and I go quite a bit off-topic. Also, while I’m at it, I’d like to apologize to the development team for “messing up” like that – specially to my mentor.

Anyways, I really don’t have anything else regarding progress to report, so I’ll just cut it here with the promise of a proper progress update tomorrow night, as soon as I get some more work done.

Tanoku, out.

Welcome once more to my weekly progress update. You must be wondering what is it that afflicts me so much as to make me randomly murder people. It turns out that my roommates decided it would be awesome if we moved to another flat for the next year. And it turns out that they went straight ahead and looked for our new place without even asking me first. This would surely piss off the average man, but I myself hate switching places with such a deep passion that I’m starting to feel homicidal instincts towards my roommates or the humanity in general. So that’s basically it. If I trash my 24′ LCD or my computer rig while moving you’ll probably see me on the newspapers.

Let’s talk now about more interesting stuff: from the coding front I’ve got bad news and good news. The good news is that this week I’ve made massive progress. Actually, I wouldn’t call it massive, but I have finished several things which I expected to take much, much longer.

The overall integration of the new Graphical User Interface system in the current code base, for example, was one of my biggest concerns. Fortunately I did have many chances to spam my mentor with questions, and with a deeper understanding of ScummVM’s code comes a much more mature design for the new GUI, which can already be seen in my SVN branch and in my mind. Actually, I don’t think you could read my mind, but whatever.

My second concern was the parser: I was afraid that the format for Theme Description files was so complicated that I would be unable to parse it without an external parser generator, but I ended up making a good (I hope) design choice and changed theme descriptions to use a clean, XML-like syntax. It turned out to be a breeze to parse, and in fact theme description files are already being parsed in the SVN branch; this last week I implemented the parser for description files from scratch and so far it’s passing the few unit tests I have prepared.

…and this leads me to the next due point in this update and, oh dear, the bad news: What’s coming up next week? Basically, very little coding-wise. My realistic goal would be to finish the parser and write all the documentation on the new Theme Description file format together with a healthy suite of unit tests. That’s because the real life front, on the other hand, will be extremely busy. Next week I have the 2 most important exams of this semester -and by important I mean hard as fuck, so you unluckily you won’t see me much online.

Now the question is: how does this leave my schedule? Right, so you must be thinking “what schedule, you moron have no schedules”, which is not completely true. According to my mental schedule soon-to-be-written-in-paper, thanks to this last week of work I’m all good and on track for the first evaluation.

However, after this following (and last) week and a half of exams, I’ll obviously fall a tad behind. Fortunately, I’m 100% confident I’ll be able to catch up in less than 4 days after my exams are over -right in time for another weekly update. You still haven’t seen me coding seriously, when I don’t even bother on changing my underwear.

Yes, I know what you are thinking now. “What underwear?”

Excuse the one-day delay on my weekly update. I’ve got good news, though. I got beveled squares working, just like I promised last week.

I know what you are thinking. Only one week to implement the drawing of beveled squares? You must be like the fastest-est coder alive.

Right. Amazingly enough, I did even more than those squares. LordHoto suggested that drawing triangles would be a nice -and obvious- addition to the vector renderer.

I had to agree, so now the Vector Renderer has optimized algorithms for drawing triangles. I bet that will come in handy for scrollbars and dropdown menus.

Next thing, the InterfaceManager class. I expanded it quite a bit, and after some design considerations, it turns out that the class replicates a lot of the functionality of the Theme class. This last class, however, will be scrapped on the final GUI, which leads me to a small design problem that will hopefully be solved soon.

Talking about soon; let’s sum up what’s coming next week. To start off, exams. Yes, exams are still coming and there are two more weeks until this burden is over. That was a dramatization, by the way. It’s not that bad.

Also, the usual routine of answering death threats from my numerous enemies and overall staying alive. This always keeps me busy.

And lastly, but not leastly (look, I made up a word), more code. The code week will start off with a development meeting with my mentor this afternoon, where hopefully we’ll point down the design of the Interface Manager so I can keep hacking on it. In case you are wondering, the parser is delayed until the IM class is finished.

Oh, and it’s raining over here. It’s raining a lot. And that’s not the usual thing in summer. I’m running out of clean clothes.

It’s Saturday already and guess what: I haven’t finished the overview of the VectorRenderer class I promised (only a rough draft of it).

As a note to self, I’ll have to stop promising stuff until I stop sucking at meeting deadlines. Oh well, at least I didn’t spend the whole week procrastinating. Apart from exams, which always keep me busy, I spent the week working on yet another class for the new GUI, the InterfaceManager.

The InterfaceManager class isn’t really a replacement class, because its funcionality isn’t present in the current implementation of the graphical user interface. Right now, the ScummVM interface for the main menu is hooked in its startup function as a new LauncherDialog object which is created and ran as a modal inside the same function.

This approach, however, is not valid with the added complexity of the new GUI, and that’s where the InterfaceManager class comes into play. This class is the core of the extendability of the new interface, since it manages key features such as renderer initialization based on the current platform and settings, generation of dynamic drawing lists (when using dynamic drawing) or of precached shapes for the widgets, and the management of drawing updates for the widgets themselves.

Oh, and to complement this new class, I extended the functionality of the Vector Renderer. See? I told you it wouldn’t take long to change the current implementation, plus I’ve also noticed that it’s missing a key drawing feature to imitate the looks of the actual GUI, beleved borders in square shapes. That’ll be coming next week – the feature which I added this week are Drawing Steps, which allow to discretize the drawing of a complex vectorial shape in individual steps. Quite convinient for specifying such steps in an external configuration file.

Together with beveled corners, next week I’ll be busy with a lawsuit for sexual harrassment, some modifications to the current INI file parser (maybe a rehaul?), a programming exam, a numerical computation exam (yes, I also wonder what the fuck does numerical computation mean) and writing more progress updates on this blog.

Notice the stupid level of self-reference in stating an update of your TODO list as an item of your TODO list. I find this fact as amusing as Indy 4.

That’s right. Just because I can’t be arsed to update this development blog it doesn’t mean I have stopped development. Quite the opposite: I have good news for all the ladies who get aroused by reading my code (there must be thousands of these) and for the standard geeks who enjoy reading progress updates.

The vector renderer is rendering -which is a nice thing for a renderer to do-, and it’s doing so a few days before the proposed deadline. The first Coding Period begins in about one week, and so does my exams period. Fortunately, with this “small” head-start I will be able to focus on my exams and still meet all the other deadlines; the vector renderer is one of the key pillars of my project (and quite a bit of work), so having it finished before the actual coding begins is a good thing.

So, what’s exactly done in the Vector Renderer? Well, pretty much everything important. The API is designed and in place, and pixels are being drawn on the overlay. Obviously, next week I’ll notice the renderer is missing some key features and a rehaul will be in order, but meanwhile I plan to write a blog post explaining the design and extendability of the class, which hopefully will also serve as a strong base for the API documentation that will go on the ScummVM wiki when the design is finished. I don’t really need to say that the whole class design gives me a raging hardon; you’ll find that out soon enough.

Until then, I’ll leave you with the moment you all have been waiting for: TEH PICTARS!!

…Actually, there’s just one picture comparing the standard Vector Renderer implementation and the AA renderer for fast platforms. See it after the jump, and click it to enlarge it. Or just draw your eyes closer to the screen.

(Editor’s notice: unfortunately, the image that was included here is lost and not available on archive.org)

I’ve always wanted to have a blog just to post crap like this: This morning I got charged 4 euros (yes, that’s right, four) for sending my Tax Documentation to Google. Four pieces of paper. That’s one euro per page.

Jeezus Christ, seriously. Four euros. It would have been fucking cheaper to buy a plane ticket and give the damn stuff in hand to Leslie Hawthorn myself.

Anyways, here’s some actually interesting info: I’ve just noticed you may be reading this blog without even knowing what’s it all about. Yes, apart from the fact that it is a development blog about my Summer of Code for ScummVM (something which you can infer from the, once again, awesome pun in the title), you might be interested in knowing exactly what I’ll be doing during this summer, and I didn’t explain that on my first post because I was plain too lazy.

Let’s get right into it now: My task consists in the development of a new Graphical User Interface (GUI) for the program. And yes, I know that ScummVM already has a GUI. In fact, I won’t be developing a new one from scratch. I will be rewriting and refactoring a lot of code to fix all the shortcommings of the current implementation, and while I’m at it I’ll add some new features.

I know that the task may not seem that fun, because the result for the average end user will probably be the same GUI he had before (and that’s if the Gods of Timelines don’t bless us with any regressions), but the fact is that there’s gonna be a load of cool code going on the background (we are adding a lot of awesome new features and fixing a lot of the old ones) and all this code will certainly have a big impact on many ports and on the project as a whole. You could say I’m happy like some castanyoles if you knew what the fuck are castanyoles.

Oh, and I almost forgot: I won’t be doing this on my own. Apart from the extremely supportive development team, I have my very own mentor: Johannes Schickel (LordHoto) has the daunting task of replying my random rantings and inconsistent mumblings with valuable advice, and so far he’s been doing an awesome job at it: My first SVN commits are in place and we have an API which is starting to take shape. Expect a few posts on this topic soon (TM), almost certainly before the weekly progress update.

Meanwhile, as I am pretty confident that right now you can’t wait to know even more about my project, here’s enough information to fill your sickest needs -at least until I come back spamming some more.

Detailed project description (HTML)

My GSoC Application, as sent to Google (PDF)

ScummVM project site in Google Code – GSoC

The ScummVM Homepage

My branch in ScummVM’s SVN server

Happy reading.

*Update* According to my Student dashboard, Google did receive my documentation properly. This is indeed nice because I would have to sell half of my liver in the Black Market to fax another 4 pieces of paper to them.

So, what’s this all about? Turns out I got chosen to participate in Google’s Summer of Code with ScummVM as my mentoring organization -hence the hilarious pun in this blog’s title- and this is my very own development blog.