Anti-Aliasing comparison tool, MK2

3 years or so back, I wrote a tool to compare anti-aliasing methods. It was designed to accompany my Beyond3D article on the topic.

The tool is still useful, but it has a few issues:

  • It’s based on raw OpenGL code, which means that it’s hard to extend, and somewhat likely to break on driver updates.
  • For the same reason, it’s slightly more difficult to ship without dependencies.
  • It doesn’t offer any temporal anti-aliasing technology, which is currently where much of the most interesting research is happening.
  • Its user interface is terrible, and it doesn’t guide people in any way in terms of interpreting what they see.

To solve these issues, I implemented a very similar tool in Unity.

You can get it here.

It features a whole lot of information about the various AA types it supports in tool-tips, and also includes the currently-in-development Unity temporal anti aliasing.

aatest_2016_10_08_21_22_34_955 aatest_2016_10_08_21_23_02_960 aatest_2016_10_08_21_22_48_516If anyone is interested in the sources I can release them, it’s pretty basic and mostly boring UI stuff.

Tales of Symphonia black character outlines

Someone asked for this, and I figured it would probably be easy enough to do. And it was, so here it is.

You can toggle the solid outlines in the game config file, like this:

People are also asking about framerate unlocks, and that would be – if at all possible – a lot more work even in the best circumstances. With the game’s silly DRM, it’s even more annoying, and not a task I want to undertake.

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

Tales of Symphonia postprocessing fix

The initial release from yesterday only fixed the main rendering resolution, the really low-res postprocessing (512×256!) still produced some ugly artifacts. I changed that now, in that the postprocessing scales with the rendering resolution selected. This was a bit harder than the other stuff, since I also needed to identify & fix a few vertex shader constants. Still, it took less time than creating this comparison image:

As a neat side effect, this also fixes the slight shift to the top/left that could be observed with the previous version at high resolutions, e.g. on the starting screen.

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

 

Tales of Symphonia GeDoSaTo plugin

Edit: My article about this sordid affair is now up on PC Gamer.

I never expected that, but Tales of Symphonia was released resolution-locked. I’ve released a preliminary GeDoSaTo plugin for the game to fix that.

Note that when I say “preliminary” I mean with a total development and testing time of less than 3 hours. So if you run into issues, keep that in mind. (Of course, if you get crashes, or the game failing to launch, or anything like that, it might just as well be the game or its DRM system rather than GeDoSaTo)

Things to keep in mind:

  • The game name, for purposes of config files, screenshot paths, etc, is “Symphonia”. This is a bit of a hack due to the silly DRM they use.
  • As always with games with locked rendering resolution, you need to set your desired one from the .ini file ( config\Symphonia\GeDoSaTo.ini ). It looks like this by default:
  • There is a bit of an ugly interaction with some low-res processing going on. I might fix that if I can find the motivation.
  • Keep the in-game resolution setting at 720p, that’s the only thing I tested.

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

 

GeDoSaTo 0.21 – multiple PSHashes, better AO targeting, multi-pass postprocessing etc.

Since the last time I wrote about GeDoSaTo, there have been quite a few changes/improvements. The full changelist is on Github (basically everything under the beta 20 and beta 21 headings), but I feel like some things need further explanation.

Multiple PSHashes can now be specified

This means that it’s easier to get perfect coverage of post-processing injection and hudless screenshots in more games, more situations , and with a larger variety of settings, with a single uniform profile.

Introducing AOHash for the generic depth plugin

It works like the PSHash system, but when the hash is encountered AO is applied (with the GenericDepth plugin). This means you can inject AO before the game renders things like volumetric fog, particles or light overlays:

The way both of these features work is illustrated by the new default profile for Dragon’s Dogma:

hashesI also implemented a depth-based fadeout for AO, this helps work around issues with fog which are not resolved by the new hash targeting ability. You can currently configure it directly in the SAO shader. (Which you can of course customize for each game profile like any shader)

Combining AO hash targeting and the fade-out, it’s possible to get artifact-free AO in e.g. Dragon’s Dogma, which was my main test case.

Multi-pass Postprocessing

Rather than pushing every effect into a single shader (which simply doesn’t even work for some combinations) you can now specify an additional postprocessing pass with e.g. addProcessingPass deband.fx in any settings file. Currently, only the deband shader has been separated out, and you can look at its source here. The system is still not as flexible as I’d like it to be (in order to be able to implement more complex effects without changing GeDoSaTo), but it’s a pretty significant step forward.

Other Stuff

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

And yes, I know that this is not the DX11 support that everyone is asking for all the time. Sadly, that’s on a different level of engineering time requirements.

GeDoSaTo 0.19 “Chaos Flare” – Completely revamped injection

I just released a new version of GeDoSaTo, 0.19 “Chaos Flare”. This release completely changes the injection method. The goal is to be:

  • More consistent. There is now only one method of injection for everything.
  • More compatible. The first injected dll is extremely small, adheres to the Windows standards for DllMain and has no dependencies on any libraries.
  • Safer. The inital dll is written in a very defensive fashion, always loads correctly, and always unloads itself from processes.

This required switching to a 2-stage injection process. Instead of directly injecting the full GeDoSaTo dll, dragging in all its dependencies, and then checking whether it should unload itself, there is now a separate, minimal “shim” dll which has the sole task of injecting the full GeDoSaTo only into whitelisted processes. The entire injection workflow now looks like this:

injectionIn some more detail, the advantages of this are primarily that the “shim” dll, gedoshim.dll, has no dependencies at all except for kernel32.dll, which can be assumed to be present. Furthermore, it doesn’t perform any extensive processing in its DllMain entry point, but rather defers it to a thread it launches. Finally, it always unloads itself, regardless of what happens. All of these properties together should make it almost impossible for it to crash arbitrary processes, even if something does go wrong.

All of this required somewhat major changes, over the course of which I also got rid of some features which shouldn’t really have been used anyways. There are also some drawbacks to this, the extent of which will only be apparent after more people test this latest release:

  • The blacklist feature is gone completely. Every executable you want to run with GeDoSaTo now needs to be whitelisted. It’s safer, reduces complexity, and is really not much work at all.
  • Due to purging the old dual-injection method, the “delayDetouring” option no longer exists. The hope is that games which required it will now simply work anyway, due to the more solid implementation.
  • As you can already see to some extent in the illustration, it’s possible that the new injection mechanism leads to hooks being initialized only after a game has already performed some processing. This has not occurred in my limited testing so far, but it could nevertheless be an issue.

I’ve also used this opportunity to clean up the interface a bit, particularly in Windows 10, and update the readme for the first time in a while.

I’m looking forward to some user feedback on this release. I knew that these changes have been necessary for a while, but I dragged it out due to the high degree of annoyance caused by the shim dll implementation. String processing in C++ isn’t that great in the first place, but without any libraries (including the standard library!) it’s just terrible.

You can get the latest version and test this injection method with the installer provided here. And, as always, you can donate to support GeDoSaTo development (including annoying injection shims!) here.

Note that the main GeDoSaTo dll still requires the latest VC libraries.

Update:
From feedback on Github, it sounds like this update accomplished what it was supposed to. Whew, I’d have hated for all this work to be in vain.

Hexer – A hex editor

Way back in July I was doing some simple binary data file reverse engineering, and got annoyed at the fact that I couldn’t find a free hex editor for Windows which offered all of the following:

  • Seeing all interpretations of data (e.g. various integer types, floats and text) while hovering over some binary data.
  • Searching data of a given type (e.g. uint32) quickly and conveniently in different numerical formats (e.g. decimal or hex).
  • Marking identified pieces of data with their type and some notes.

I thought “it can’t be that hard now, can it?” and set out to create my own. After some deliberation I choose C#/Winforms to implement it, simply because the tool support is second to none and I didn’t want to waste more time on UI stuff than strictly necessary.

After spending a few hours on it way back then, and finally a few more today, it has turned into quite a usable (but far from complete or user-friendly) program. I called it Hexer, which is both appropriate in English and also means “Warlock” (or even “Witcher”, literally) in German.

It has all the features which I was missing:

  • The pane on the left shows various interpretations of selected and hovered-over data.
  • You can easily enter different types of numerical addresses written in any C-style string format (e.g. “161″ searches for the decimal number 161, “0xFF” searches for decimal 255 and 010 searches for decimal 8).
  • As seen in the screenshot, you can mark ranges of data with some data type, and see the in-line interpretation of that data in the file. These markers can be stored and loaded independently of the files they apply to.

I put the source up on GitHub here, and here’s an executable if you want to give it a try. (You’ll need the right version of the .net Runtime of course)

Of the entire implementation I like this part best, which is a simple descriptive listing of all the data types, including their properties (such as name and size) as well as the ability to convert values of that type to and from raw binary and strings. It’s succinct, easy to extend (both with new data types and new meta-information about them), and many of the UI elements are generated directly from that list.

Hexer is far from fully-featured – I put up a short list of TODOs in the Github readme, but there’s a lot more which could (and should) be done.

1.5 Weeks of Windows 10, and Photoviewer executable release

I’ve been using Windows 10 for about 1.5 Weeks now, and I thought it would be time to write about the experience, explain a few workarounds, and post one tiny tool I made to make it more palatable.

So, what has gone wrong in Windows 10?

Booting & drivers

First of all, initially it wouldn’t even boot on my X99 system. It got stuck in an infinite loop on the initial boot screen. By looking through the boot log from my old WIndows 7 installation, I eventually figured out that the fault lies with the “Intel Management Engine” driver – a component I don’t need at all. Disabling it fixed that issue.

However, I still got a black screen on boot. Turns out that Windows 10 thought it was a good idea to show the initial login screen on my projector (turned off projector, I might add) rather than the  monitor.

Talking about boot issues, the idea of removing the option to get to the advanced boot loader with a key press is really fucking annoying. Being really annoying to power users for no good reason seems to be a theme in Windows 10, as I’ve found.

The new start menu

In short: it sucks. I tried living with it for a few hours, but its refusal to reliably index manually created desktop application shortcuts in its search makes it completely unusable to me. Good thing I bought two StartIsBack licenses back then, and great on the author for having a perfectly up-to-date and fully compatible version out with the Windows 10 release.

Look, it’s a beautiful start menu with actually working indexing for desktop applications and lots of neat functionality!

Program incompatibilities

Let’s start with an amusing one: Skype would crash every time I logged out of Windows 10. The amusing part here is that Skype is now owned by MS, so’ you’d assume that they’d get compatibility right. After a lot of googling, it’s apparently an issue where the sound driver gets unloaded before skype does, and it crashes when trying to play the logout sound. Go figure. The fix is to disable that sound.

There are also various incompatibilities with DirectX pre-9 games and fullscreen mode, resulting in flickering. In most cases I’ve encountered, forcing borderless windowed mode seems to work around those.

What’s nice is that it seems GeDoSaTo is compatible with Windows 10 out of the box, and so is PtBi.

Strange stuff happening to CPU usage

This has been a sporadic issue that seems to have stopped completely now, but for a while I was getting completely nonsensical CPU usage reports in task manager.

Apparently, my CPU was giving its all at 124%.

In complete idle state, my CPU was apparently running at ~30%. At least according to the new “Processes” view in task manager. “Details” was showing 97%-99% idle, and Process Explorer, which I trust more than both of them, agreed.

The “Appification” of general tools & Photoviewer

In the process of converting general windows default utilities to “apps”, it seems that almost invariably functionality is lost — often important functionality. The new “Photos” app apparently can’t even show images at 100% zoom with a simple click, and mouse wheel zoom is completely broken. I find that unacceptable.

Luckily, Windows 10 still ships with the old Photo Viewer. Because it’s MS though, that Photo Viewer is not an executable but rather a dll which needs to be hosted and invoked somewhere, so it’s hard to associate with images in Windows 10. To work around this I’ve created PhotoviewerWow.exe. It merely invokes the existing .dll, and should work on Windows 10 64 bit installations. Just put it somewhere permanent and you can easily associate it directly with image files. (The name is a homage to the insane hoops MS jumps through to run Windows32 on Windows64, since I also had to jump through hoops to run a standard Windows feature on the new Windows)

Another thing about appification that might be even more worrying is that apparently you aren’t even trusted – as an administrator no less – to look at your own apps’ files (hidden away in “Program Files/WindowsApps”). That’s just ridiculous. And worrying.

Improvements?

Well, I guess the new built-in virtual desktop support is neat, and they chose exactly the keyboard shortcuts for it that I would have chosen intuitively (Win+Ctrl+D, Win+Ctrl+Left/Right). So good job on that. And I also like the improvements to the “move window left and right” workflow, where it now shows you a selection of the remaining windows to move to the other half of the screen after you used Win+Left/Right to move one window. It’s also not quite as fugly as Windows 8, and it makes it rather easy to mostly ignore the entire app crap after installing StartIsBack.

Some Audio updates for PtBi

Thanks to a comment on the last post, the audio crash which affected some should now be fixed in version 6.1901.

Also, I investigated the reports of trouble capturing PS3 output, and there was something strange going on. It seems like in some conditions the BMI Pro 4k driver can enter an error state, and nothing will work until the next reboot. Anway, after some debugging I got 1080p5994 capture with full ARGB quality working on PS3:

PtBi updated for RGB pixel formats and Intensity Pro 4k support

I recently got an Intensity Pro 4k to replace my Intensity Pro, which served me well for more than 6 years. It has mixed reviews on the internet, but mostly because of one of two reasons:

  • Noise, which was indeed terrible but is fixed completely by updating the firmware.
  • Software compatibility, which I can’t speak for. I only use one piece of software and I make that one compatible if it isn’t.

BMI Pro 4k to the left, BMI Pro to the right

I have to say that the device has worked pretty flawlessly for me. Nice to finally get full RGB input and 1080p60 capture.

Of course, to actually make use of those features I had to release a new version of PtBi. Since it’s a pretty major upgrade I decided to call it version 6 now. More specifically, the release is 6.1877. In addition to supporting the new pixel formats PtBi should now also produce somewhat more useful messages on errors.

It’s still not quite user-friendly though. You have to select the pixel format and video mode with command line parameters, e.g. PtBi.exe -disable-audio -pf=ARGB -mode=1080p5994. The supported modes are ARGB, BGRA and YUV (which is the default and only option in previous versions). I don’t support 10bit modes since I don’t need it — if anyone really does it shouldn’t be too hard to add.

I also pushed the current source to GitHub, what was there was completely outdated. It’s still terrible though, which is about what you’d expect from a project developed for a few days here and there over 6 years, and built on code even older than that. However, it does it’s job, and it’s the only thing which does that particular job, and I still use it all the time, so perhaps it’s useful to someone.