The Release

Just as it says in the title, the plugin has just been released! I’ve somehow managed to find the time to work on it between schoolwork and studying, and it feels great to have a project fully open to the public. The project itself is available to download on my github, and should be extremely simple to set up and use. It’s changed a lot from my initial version, most notably because it is now much better integrated into the Godot editor, but more on that below.

Refactoring

When I last made a post about this project, it was as a completely independent rendering engine.

While that was a cool concept, and I learned a ton about shaders while implementing it, I kept running across problems. First, and most importantly, the results weren’t great visually. The way normal calculations were done resulted in banding across what should have been flat surfaces, and extremely rough shadows. While this is could be a style in itself, the whole point of this project was to make something generally useful, which most definitely was not happening.

The second big issue was ease of editing. As an independent rendering engine, nothing I was working on could be previewed. The editor I was working on would theoretically help, but that still didn’t make any difference for overall scene setup. In theory, Godot is flexible enought that I could probably integrate a viewer into the editor, but that still loses a lot of the functionality the default engine provides.

Finally, there was the simple issue of lighting options. If I were to continue in my own custom renderer, I would have to implement every lighting option already available in Godot. Even worse, I would probably have to optimize them, and make sure every aspect is performant.

In the face of these problems, I simply had little incentive to keep working on the project as it was. I had already done the hardest intellectual work in setting up the basic renderer, so there wasn’t much left to learn either. Instead, I found a better solution, that solved essentially every problem I had.

Actual Integration

The irony is that I only really fulfilled the name of my project after completely abandoning its initial draft. Essentially, my solution was to simply piggyback off Godot’s built in renderer, using it for all the complex lighting and depth calculations. This did require one tradeoff: now, instead of simple pixel textures, each object needs a mesh to define its 3D profile. In the end, I don’t think this is too much of a problem. Every solution I could think of to the smoothness problem involved some sort of mesh, and this approach has a ton of additional benefits. Further, I might eventually try generate meshes from pixel data (this was actually the most viable solution I could think of for smoothing in the first place).

The solution I finally landed on is as follows: First, all renered IsoObjects need an associated texture and mesh. These, and all isometric cameras, are visually snapped to an appropriate grid in 3d space, ensuring pixel alignment during the render.

At runtime, the IsoWorld everything is placed into splits into two views. The first contains copies of all the object meshes and cameras, and exists soley to find which object is closest to the camera at a given pixel. From there, the at object’s pixel at the correct screenspace location is multiplied with lighting values from the second view, resulting in the final output pixel.

All in all, this solves almost every problem in my original implementation. Faces are smooth because their lighting is being calculated from acual smooth faces. Because everything has a mesh, positions and shapes are visible in the editor by default. Even better, the default 3D lights are automatically integrated into the system, so directional lighting, spotlights, and even world environments work without any additional setup.

The sheer versatility of the new version is the only reason I’ve felt comfortable releasing it at this point. While there are still some things I need to add in, the core functionality is definitely there already.

Roadmap

The roadmap for the project is pretty loose now. I’ve solved most of the core problems I’ve come across, so the next thing will be actually adding functionality.

Animation is the first big one. It’s technically already possible, using the AnimationPlayer to switch textures and meshes, but that seems pretty clunky. It probably won’t be too difficult to add in some IsoObjectAnimated thing with set frames, but we’ll see if I can get anything further than that.

Another thing I need to experiment with is transparency. It seems pretty essential to have, but as-is, there isn’t an obvious way to implement it. What I suspect will happen is some sort of layering of object ids per pixel, which I could then use for transparency layering.

I also haven’t tested collisions, but this should work automatically by simply using rendering meshes as collision meshes.

Finally, while my custom level editor has fallen by the wayside in favor of the default editor, I would like to come back to it at some point. Isometric scenes lend themselves so well to tile-built levels that it seems like a waste not to have something built in to take advantage of it.

That’s all for now, but I’ll probably post again soon (maybe after my midterms) with a full tutorial on how to use the plugin. Whether I get around to it or not, the example scenes and comments should be more comprehensive than anything I can write here.