Graveyard of Forgotten Projects (Part 3)

This is a direct continuation of the first and second parts. Let this partial quote from there serve as an introduction:

This series (hopefully) of blog posts will gather and shortly describe some previously unreleased and/or forgotten projects I’ve worked on over the past decade and a half, starting from 2000. This is by no means a complete listing, I’m still skipping over the vast majority of unfinished ideas and half-baked projects, but I’m trying to include everything which worked to an extent or has some interesting features.

The primary purpose of this is to serve as an archive for myself, because, as you will notice when I go through the list, I’ve already lost a lot of somewhat interesting stuff and would rather not have that happen again. Perhaps one thing or another might also be useful to someone else, but I obviously won’t troubleshoot code I wrote more than a decade ago and haven’t touched since then! And, just to make that clear, it’s also obviously not indicative of my current skills.

I started this series of posts at the beginning of the year, and resolved to do at least 3 before the end, so that’s why this is happening now. The previous two iterations together went up to the end of 2006, covering a lot of abortive game attempts, a released PSP game and some useful tools.

GPU-based Image Processing and Multigrid Solvers

Around that time I had already implemented my bachelor degree project, and relatively shortly later (well, 2 years, but who’s counting) – and it’s highly related, so I’ll include it here – my master degree project.

These projects together ran roughly from 2004 to 2007, and there was no specific GPU computing API at all until their very end. People were just starting to experiment with doing compute on graphics cards using standard graphics APIs, and so everything I worked on during these projects I did in OpenGL. So, my first step was to create a library which makes it easier to do compute on what is essentially a graphics platform:

Object Model OverviewBased on that, during my bachelor work I implemented a lot of image filters, from simple stuff, over arbitrary convolutions, up to non-linear/anisotropic image filtering like Perona-Malik diffusion.

Perona-MalikTo gather and evaluate a good amount of data on all the GPUs popular at the time, I  created a benchmark which reported various performance metrics and released that on Beyond3D. Other programs created were a testing environment for filter development called “ftest” (my naming sense strikes again) and even a C# GUI for comparing various data and generating charts. I lost the source for the latter, but I still have the former. In fact, ftest has no issue running on my current Windows 10 system – not bad for a binary compiled over 10 years ago (no guarantees on this one of course!):

ftestFor my master thesis in 2007 I implemented a multigrid solver for elliptic PDEs using the same framework. I won’t go into too much detail since this is getting kind of long already and we need to get back to the games! In case you are interested, here’s my master thesis.

Muh aka Project Y aka YouMUH!

This is a long story, spanning all the way from 2008 to 2012. This doesn’t mean that I worked on it for 4 years of course, just that I spent a few days on it from time to time, often with months between them. The basic idea for this game was to be a 2.5D side-scrolling platformer/action game starring Youmu Konpaku (who is in the logo of this blog by the way, and has been since its inception. I guess I always thought I’d talk about this project some day).

In any case, looking back on it now, the “game” seems to have been mostly an excuse for me to play around with whatever rendering, modeling or physics technology I was interested in at the time. That doesn’t mean that I didn’t have some idea for how the whole thing would play when it was completed (something like a mixture of Koumajou Densetsu, Bunny must die, and Noitu Love 2), just that completing it never seemed to be the point.

I started working on modeling for the game in 2008, with just a sword in Wings3D. During 2009 I spent a significant amount of time learning Blender and modeling/animating the main character. In 2009 I started with the actual coding, putting a lot of work into implementing deferred shading with a non-photorealistic art style. I created a cross-hatch shading algorithm which was based on a set of consecutively darker hatched base textures. The result looked like this:

muh_2010Subsequently, I spent far too much time with cloth simulation. At that point, this was still uncommon (nonexistent?) in games, and I basically created everything from scratch, starting with the physics simulation, over collision, to the file format used to specify cloth type/behaviour. It was an addition to the .obj file format and looked like this:

It was quite insane, but it worked out not too terribly in the end. I extended the same physics system to handle bone animations (this part worked well) and tried to also go for hair (this didn’t work well). You can see a video of the state ~2011 here. At that point, I had also switched to a more traditional cel shaded look (a decision which I would revert today).

muh_2011During all this time I continually refined the running animation, and looking back at the initial one and the final version I have to say that at least this was a clear track of improvement. The last things I worked on, some time in 2012, was level loading, where again I used a custom format, but at least it was XML-based. This is the final state of the project at this point:

muh_2012Basically, once I got a level loaded (with no materials mind you) I realized that, as a single developer, doing the entire game at a level of graphical sophistication which does the effort I put into just the main character’s skirt and running animation justice would be utterly infeasible. At the same time, doing it any lower level wasn’t going to make me happy, and just doing things again for which I already had a “proof of concept” so to speak would be boring. So, at that point I shelved the project — and a bit later started to work on DSFix, which turned out to be a lot more helpful to far more people.

Nonetheless, I learned a lot doing YouMUH! over the years, including:

  • Modeling and animation in Blender (and that I’m not great at it)
  • Deferred shading
  • Some approaches to non-photorealistic rendering
  • Physics simulation (particularly cloth/hair)
  • Some of the problems that come with trying to integrate neat state-of-the-art code with, well, art

And also, that it’s not a good idea to attempt a medium-fidelity 3D PC game (with bleeding edge features like cloth simulation and NPR) while doing almost everything from scratch and also handling all the code and art on your own. Well, it’s not a good idea if you want to finish something, it’s pretty nice as a hobby and for learning things!


That’s it for this iteration. There’s still one more project I’ve never posted about that I consider significant, and a few smaller ones. But I really wanted to at least reach the 2010s before 2015 is over!

Lightning Returns Plugin for GeDoSaTo (DoF fix, AO)

While playing Lightning Returns, I noticed extremely ugly artifacts/flickering/aliasing whenever DoF was used (particularly in cutscenes) – even at 4k. Turns out the game rendered DoF effects at 720p regardless of the selected rendering resolution.

I fixed that (after spending far too much time on half-baked ideas which turned out more complicated than the real solution) in the latest version of GeDoSaTo. Here’s a comparison (crop from two 3840×2160 screenshots):

Left: default; Right: fixed

Left: default; Right: fixed

I spent some time making sure the DoF effect itself is as close as possible to the intended. I think it worked out pretty well.

While I was at it I also implemented AO support, you can look at a comparison here. It’s disabled by default, so you should enable it in your user .ini if you want to. The performance impact is rather significant.

You can get the latest version including the LR plugin by updating from within GeDoSaTo or with the installer provided here. And, as always, you can donate to support continuing GeDoSaTo development here.

New GeDoSaTo Version, Status Update

It’s somewhat traditional (well, since last year) to have a Final Fantasy-related Christmas update.

This time around, I fixed a variety of bugs/missing features which made GeDoSaTo incompatible with Lightning Returns. After doing that, I also quickly discovered a PSHash for hudless screenshots which seems to work pretty well so far. Due to the way the game handles downsampling resolutions, you need to take some care when trying to get hudless downsampled screenshots, look in the .ini for details.

FF13 LR screenshotOther than the strange insistence on having a fixed set of supported resolutions rather than querying the OS Lightning Returns seems to be a pretty good port so far. At the very least, it doesn’t suffer from the random performance issues of the other two games in the trilogy. The gameplay seems fun as well so far.

DX11 / 64 bit status

People still frequently ask about these, so I thought I’d give a status update. For DX11, the vast majority of the relevant APIs are intercepted at this point, what’s missing is porting/reimplementing the support infrastructure required for downsampling and general operation (e.g. the text console, effect loading and application, rendertarget handling etc.) to the API. This is still a non-trivial amount of work.

64 bit support, on the other hand, would mostly just amount to compiling multiple versions of the .dlls, and setting the correct paths in the tool/loader. The only reason I haven’t done it yet is that it seems quite useless without DX11 support, given that 64 bit games are generally also DX11.

Download

The latest version should also fix some other compatibility issues reported over the past few weeks (some, by far not all of them!), and even a few older ones, including installer issues – see the github tracker for details. I just hope it doesn’t introduce new ones, but if it does then do report them on github.

You can get the latest version by updating from within GeDoSaTo or with the installer provided here. And, as always, you can donate to support continuing GeDoSaTo development here.

Happy Holidays everyone!