Procedural texturing tool
Vismut is a procedural texturing tool I’ve been developing on and off since around 2017. After many hiatuses, much learning and several rewrites, it now finally supports its first use case: manual channel packing. 🎉
The only other free and open source tool you can do channel packing in as far as I know is Blender. But the complexity of Blender makes it complicated to use, while Vismut makes it really fast and easy!
Channel packing means taking the red, green, blue and alpha channels from one or more images, and creating one or more new images from them. Games often do this to reduce the number of images needed to represent a material, and thereby reduce memory consumption.
Channel packing is of course just the first small step towards a full procedural texturing tool.
Why Am I Making This?
It’s been a long time since I first discovered procedural texturing, and I loved it right from the start. Since then, I’ve looked for an open source procedural texturing tool. I found a few, but none that align with my priorities.
A few years ago I was learning the programming language Rust, and wanted to build something in it, so I decided to build a procedural texturing tool. To my surprise it seemed like Rust would enable me to actually build something like this, which was amazing to me as I’m far from being a master programmer. As time went on I spent an increasing amount of time working on it. Now I’m confident I can turn this into a useful tool, so that’s what I’m doing! :)
Why Use Nodes?
What makes nodes so powerful is that you can go back to any part of the node graph at any time and make changes that then propagate through the node tree to generate a new material.
Let’s say you’ve created a “bathroom tile” material. When you’re done with it, you decide to make the tiles half as big. You have a node that controls the pattern of the tiles, so you just change one or two values in that node to make all the tiles half as big, and that’s it, this takes seconds. In a traditional digitally painted workflow, a simple change like this would involve a significant amount of time and effort.
It also allows for a ton of reuse. Let’s say you have created a “painted wall” material, and you want something similar but with the paint more flaked off. You could use the existing material as a base and create the “flaked off paint” effect that adapts to the underlying surface. And that effect could itself be improved and reused in other materials.
This is made even more powerful by the ability to take an entire node graph and turn it into a single node that can be used in other graphs. The more time you invest into this type of software, the more you get out of it as you build up your personal library of nodes.
What Makes Vismut Special?
The interface for an application is crucial. A bad interface can make a program incredibly frustrating to use, or even cause work to be lost. A good interface enables the user to work as close to the speed of thought as possible. A lot of thought and effort is being put into Vismut’s interface, here are the main goals:
- Easy to learn
- Allow for mastery
- Always give clear feedback
- Always respond to input
- Gets out of the way, so you can focus on the task
Vismut will use physical measurements rather than “percentage of image” values by default where possible. This allows you to zoom out of a material after creation. Physical measurements also give materials a common ground to stand on, making it effortless to combine them.
The backend library Vismut Core is separate from the frontend, so it can be integrated in a game for instance. This means you can take a saved graph—which is no larger than a few kilobytes—and generate textures from it on the user’s computer. This can be used to achieve reduced size of game downloads, greater customization possibilities, and more.
The plan is to iterate on Vismut towards a useful set of features while keeping the tool as stable and useful as possible along the way. Feedback from users will be an important factor, which is the reason I’m releasing it as early as possible. I’m not only making this for myself, but also for you!
The goal of the next release—version 0.5—is to rewrite the backend to use a new architecture that vastly simplifies the code, is more robust, and makes it easier to create a fluid interface.
After that comes “the grid”. Nodes are always locked to the grid, freeing the user from decisions that make no difference. It also allows for smarter automatic node positioning in the future.
Other upcoming features include saving and loading graphs, a ton of nodes, 2D and 3D previews, and support for variables in the graph. All work is done in the project’s GitLab repository, so look there for an up-to-date roadmap and task list.
I’ve just scratched the surface of a lot of the topics in this post, so look forward to more detailed thoughts in the future! If you’re looking for a program to pack channels with, or you’re just interested, download Vismut and try it out!
I love working on this project on my own, but I think working on projects together with others enables more fun, learning and productivity. So if you’re interested in working on Vismut, join the Vismut Zulip and introduce yourself! I would be delighted to get on a voice or video call to show you around the code, do pair programming, discuss implementations etc. Everyone is welcome, not just programmers! 😀