The Y in Python

After being truly blown away by my now favorite movie of all time, Suzume, I'd decided I definitely need to pour my love into and base a new 3D project on it (which I'm still working on, so stay tuned for that!). Combined with not wanting to create every single asset needed from scratch, somehow feature The Last Of Us II (since I recently finished it as well) and get to know more about game development (a little bit the other way around, but oh well), I dived into the topic of reverse-engineering game files - another story that I'll definitely write about in the future.

Still frame from Suzume ©CoMix Wave Films

Fiddling around with various scripts, some of those written myself, to get to those tasty unpacked, readable game files (as I said, story coming soon!), I've finally found myself with some good old .fbx files inside of Cinema4D; but wait, apparently most of the textures inside the material are missing! We only get the diffuse texture, but no normal, roughness, metallic, ... maps needed for our PBR workflow. Just add them? Oh I would, though not manually for every single material of those 100 or so we just imported. What now? Enter Python!

I've already known that we can interact with Cinema4D using Python, but I've never really done so, only in Houdini for my Bachelor Thesis →. So I've started looking into how to write scripts for Cinema4D, mostly using the examples provided by Maxon on GitHub →, though didn't get very far since I needed Redshift materials for our scene to work properly. Some googling and searching around later, I've found DunHouGo's repository to interact with Redshift nodes (which I've since updated) →, which helped me a TON getting things off the ground.

The idea in.. idea?

Okay, so now I know the basics of how to interact with materials using Python, but what exactly do I want the script to do? Let's see:

• For the selected materials in the scene, ...
  1. get the diffuse texture path
  2. gather all other channels of that texture (normal, roughness, metallic, ...)
  3. add the needed nodes like ramps for roughness, bump map for normal, ...
  4. connect it all to the right channels of the material

So far, so good for that very specific instance of this project. However, it got me thinking: Me and a lot of other 3D artists have already spent a ton of time doing the same repetitive tasks when importing any texture sets from somewhere - setting the right color space, connecting it to the right ports, adding ramps, bump map nodes, etc. - , so surely I could expand that script to be more generic and useful for everyone, right?

• For a given texture folder, ...
  1. gather all matching texture sets
  2. create a material for each texture set
  3. connect the textures to the right channels of each material
  4. add the needed nodes like ramps for roughness, bump map for normal, ...
• Pack both options into a nice UI so we can choose what we want to do!

So not a lot to expand on, right?

Being wrong

What lies behind a few simple ideas can turn out a little more difficult. I want the script to automatically recognize what kind of texture channel we're dealing with, and still find matching sets. If you like, you can ponder on this problem yourself for a bit and try to find a solution before reading on.

I've asked this question in my (Tech) University's general chat and got all kinds of ideas, from reading the texture name character by character to even.. AI? Yeah, I think it's safe to say that's a little overkill for this problem. In the end, I came up with a solution I'm using quite regularly in some programming tasks. Still, I'm curious to hear how you'd solve this problem, so feel free to send me an email → or DM me on Instagram!

Hex hex with Reg Ex

Imagine you have a super powerful search tool, like when you use "Ctrl + F" in a document, but on steroids. Regular expressions are like a special language that helps you describe patterns in text. Think of a pattern as a rule you want to find in a bunch of text. This rule can be simple, like finding every word that starts with "cat", or really complex, like finding email addresses. Regular expressions give you a way to describe these rules using special characters and symbols, so let's look at an example to know what I'm talking about: Finding all the words that start with the letter "c" in a sentence.

Imagine you have the sentence: "Cats, dogs, and cows are cute animals." You can use the regular expression c\w+ to match words that start with "c". Here's how it breaks down:

• c is the literal character "c" you want to match.
• \w represents any word character (letters, digits, or underscores).
• + means "one or more times", so \w+ matches a sequence of word characters.

When you apply the regular expression c\w+ to the sentence, it will find and match "Cats", "cows", and "cute". Remember that regular expressions are often case-sensitive, so the above example would only match lowercase "c". If you want to match both uppercase and lowercase, you can modify the expression to [Cc]\w+.

Alright, hopefully you're still with me. Back to the problem at hand: Let's take a look at the regular expression I've come up with to solve our problem:

channels_dict = {
    "image_extensions":         ["png", "jpeg", "jpg", "dds", "tga", "tif", "tiff", "bmp", "exr"],
    "color_channel":            ["Base_Color", "BaseColor", "basecolor", "color", "COL", "Color", "Albedo", "col", "Base", "diff", "_D-", "_D."],
    "normal_channel":           ["Normal_OpenGL", "normal", "NRM", "Normal", "nml", "nrml", "Norm", "_N.", "_N("],
    "ao_channel":               ["Mixed_AO", "ao", "AO"],
    "metalness_channel":        ["Metallic", "Meta", "_M.", "_metal."],
    "roughness_channel":        ["Roughness", "roughness", "Roug", "_R.", "_rough."],
    "specular_channel":         ["Specular", "specular", "_S."],
    "glossiness_channel":       ["GLOSS", "glossiness"],
    "opacity_channel":          ["opacity", "alpha", "opac", "_O.", "Opacity"],
    "translucency_channel":     ["_L.", "_L_", "Translucency", "Transmission"],
    "displacement_channel":     ["height", "DISP", "Displacement", "depth"],
    "misc_channel":             ["soft-mask", "color-mask", "mix-mask", "tint-mask", "paint-mask", "mask", "_M(", "_MSK", "OVERLAY", "blend"]
}
all_channels = [channel for channels in channels_dict.values() for channel in channels]
texture_regex = r'^(.*?)(' + '|'.join(all_channels) + ')(.*?)(?:' + '|'.join(image_extensions) + ')\b'

Whew, quite a sight to behold, so let's break it down piece by piece:

• channels_dict: This dictionary contains keys representing the different types of image channels (e.g., color, normal, metalness), and the associated values are lists of possible naming schemes for each type.
• all_channels: This list extracts all the channel names from the values of channels_dict and flattens them into a single list.
• texture_regex: This is the regular expression pattern being constructed. Let's look at what it does:
  • r'^(.*?)': This section captures any characters at the beginning of the input. The ^ asserts the start of the string, and (.*?) captures any characters non-greedily into a group: This will be our base name of the texture!
  • (' + '|'.join(all_channels) + '): This part creates a regular expression group using the all_channels list. The | between channel names functions as an "OR" operator, allowing any of the names to match: Our channel name!
  • (.*?): Similar to the previous part, this captures any characters between the channel name and the image extension: Our (not needed) suffix!
  • (?:' + '|'.join(image_extensions) + ')\b: This segment captures any specified image extensions (e.g., "png", "jpg") using a non-capturing group (?: ... ). The \b ensures we end the match at the end of the extension and there's nothing after.

If I could summarize regex in one sentence, it would be: "Defying expectations, this monstrous creation harmonizes chaos into function." - I'm not sure if that makes sense, but it sounds cool, right? Well, the important part is that after a lot of trial and error, I've finally come up with a regular expression that works for all the texture sets I've thrown at it.

Galantis - Runaway

Getting the regular expression to work was, arguably, the most crucial part of this whole ordeal. The rest of the script's functions are pretty standard programming stuff, though it was a little harder to find out how to do this or that - the only real resource we have to look stuff up is the Cinema4D Python SDK →, which, well, to say the least, could see some improvements. A lot of trial and error (and a few posts and questions in C4D's Plugincafé) later, we've got most of it down. Great! Just.. how do we actually use our script? We need a UI!

Here, the SDK and the examples provided by Maxon on GitHub →, got me pretty far. I've created a simple UI with a few buttons and checkboxes, and we're good to go! I set the dialogue type to "ASYNC" so we can still interact with Cinema4D while the UI is open to select materials, and we're done - or so I thought.

After a lot of positive feedback from the Redshift community on my script, I got a DM from @stuckpixel, telling me when my script is installed, some other scripts of his studio won't work anymore. Huh, must be them then, since it works for everyone else.

def decodeMessage(message): # As taken from https://developers.maxon.net/docs/Cinema4DPythonSDK/html/manuals/misc/python3_migration.html
    pythonapi.PyCapsule_GetPointer.restype = c_int
    pythonapi.PyCapsule_GetPointer.argtypes = [py_object]
    return pythonapi.PyCapsule_GetPointer(message.GetVoid(c4d.BFM_CORE_PAR1), None)

class SubDialog(c4d.gui.SubDialog):
    def Command(self, mid, msg):
        c4d.SpecialEventAdd(PLUGIN_ID, p1=42) # 42 is the information we want to send
        return True

class MainDialog(c4d.gui.SubDialog):
    def CoreMessage(self, id, msg):
        if id == PLUGIN_ID:
            message = decodeMessage(msg)
            if message == 42:
                self.DoSomething()
        return c4d.gui.GeDialog.CoreMessage(self, id, msg) # Don't forget to still handle the other messages!

A lot to consider it seems! But it's all worth it in the end. Trust me.

The final product

Screenshot from the finished plugin, TexToMatO

We did it! But where to go from here?

↝       Support this project and me on Gumroad →! It's free to download, so try it out for yourself and read up on all the features!

↝      Check out the source code on GitHub →!

↝      Send me an e-mail → if you have any questions, feedback, or just want to say hi!

Since I was asked multiple times why I'm sharing it for free if so much work went into it and it's so useful, I'd like to say that I'm a big fan of open-source software and the idea of sharing knowledge. I've learned a lot from other people's open-source projects, and I'd like to give back to the community. If you want to support me, you can still pay for it on Gumroad; but if you can't or don't want to, that's fine too. I believe that access to knowledge and creativity should be free: Let's support each other in becoming better at what we love to do!

I hope you enjoyed this little journey of mine, and maybe even learned something new. Have fun and keep on creating!
Cheers,
Jérôme