It did, thanks, I will have a look.

@ThomasB

Absolutely, but you have to either grant me access or make the whole folder public.

Dear community,

GeDialog::GetFilename is broken in 2026.3.0 in both the C++ and Python API, returning the empty filename/string, even when a gadget holds a valid string. Plugins using dialogs which use Filename parameters are therefore currently malfunctioning when used in 2026.3.0. The issue does not exist in 2026.2.0 or earlier versions.

We will deploy the hotfix for this issue in the coming weeks.

Cheers,
Ferdinand

Hello @ThomasB,

could you share your plugin via something like dropbox or google drive with us? You upload above seems to have failed.

Your code looks fine, you do everything correctly at first glance. You only try to modify the scene in the context of MSG_DESCRIPTION_COMMAND (which should only be invoked from the main thread) and shield yourself against rogue actors by also checking c4d.threading.GeIsMainThread() (slightly better would be GeIsMainThreadAndNoDrawThread but that is just semantics). Your node does also not do anything wildly expensive in its Init/__init__.

But I am sure you are not just imagining your performance issues. Generally speaking, your code should only run when the user clicks the button with the ID PY_ADD_AUDIO in the description of your tag. So, this should not be able to accidently run when you render or while scene playback (which I assume is what you mean with 'running (an) animation').

PY_TRACK seems to be a parameter of type DTYPE_BASELINK where you just link the newly created track. I cannot really see anything going wrong with this, as this is very harmless. I also checked if there is any 'special sauce' in creating sound tracks, as they are one of the special tracks, but as far as I can see, we are doing this internally exactly like you do it. So, this also does not seem to be a case of an incorrectly allocated node, which then constantly causes internal errors.

Cheers,
Ferdinand

Hey @ECHekman,

well, when a node displays an embedded description (what you exemplify at the case of a BaseLink), it uses a DescriptionCustomGui too. Other parameter types aside from a BaseLink which can do this are for example field lists.

I am quite frankly a bit surprised that this even bubbles up in the form you report it, that you get a DescID which is selected inside a DescriptionCustomGui that is shown by the node in the DescriptionCustomGui you opened yourself. Attribute Manger selection states (and by extension DescriptionCustomGui) are not a public API feature, as we usually keep our GUIs sealed, i.e., inaccessible to third parties. DescriptionCustomGui is here a bit in a grey area, but I am afraid there is no way to do what you want to do. To do what you want to do, you would need access to internal systems.

And other than in some other cases, where we do not always had the time to expose something (and are open to the idea of changing something), this is for GUIs not the case; they are intentionally sealed as we do not want third parties to change basic UX concepts.

My general advice would also be to not to try to overcome this boundary (that a plugin reacts to which parameter in a node is being highlighted by the user), as you break UX conventions of Cinema 4D with that.

Cheers,
Ferdinand

You can do this, but it is very hacky:

1. Get the description of the node(s) you are currently displaying in the your DescriptionCustomGui.
2. Check if desc is a member via CheckDescID (I think GetParameter would also work and return an empty container when the ID does not exist).
3. When the ID does not exist, start browsing the container for parameters that are of a DTYPE that implies an underlying node, such as DTYPE_BASELINK.
4. When you find such parameter, get the node node, and check there.
5. Rinse and repeat recursively.

Issues:

1. You cannot distinguish the case where an object A has two BaseLink parameters which both hold an object of type T, but not the same instances.
2. You will run into issues with DescID translations which some nodes might do. This is a really big point, which is probably already overlooked in your current code.
3. Nested node relations can get REALLY complicated. BaseLink is trivial, but stuff like field lists, volume lists, or some special shader stuff can get really complicated. You would probably only have to worry about base links and field lists in your case, as other renderers are irrelevant for you, but field list alone are already complex enough that I would strongly advise against 'just implementing it'.

Dear development community,

On June the 10th, 2026, Maxon Computer released Cinema 4D 2026.3. For an overview of the new features please refer to the end user release notes.

Alongside this release, existing APIs have been updated. For a detailed overview, please see the Cinema 4D C++ SDK change notes.

Cinema 4D

C++ API

• Added ARM64 support for Windows.
• Added support for Xcode 26 as a build platform on macOS.

Python API

• No changes

Happy rendering and coding,
the Maxon SDK Team

Cloudflare unfortunately still does interfere with our server cache. You might have to refresh your cache manually to see new data when you read this posting within 24 hours of its release.

Is there still an unanswered question here? If so, please reiterate what you want to achieve.

Okay,

I think I was a bit overly cautious in my answer here. You gave my a very broad question, or to be precise, you gave me a video and a scene file, and did not really ask a precise question. I understand that asking good questions can be hard, especially with a language barrier. But when I have nothing to go by, I of course assume the worst case possible.

The scene you have there is a trivial case, even the best case possible. You have there spline segments which lie in a perfect plane and which have no self intersections. You can treat them just like polygons (in the CG sense, not in the mathematical sense) and simply compute their normal over the first three vertices of each segment. Due to the fundamental property of a polygon - reversing the order of the vertices reverses the normal - you can then easily determine if two segments have opposite or equal winding.

But all this starts to fall apart, as soon as you cannot make these assumptions. And I cannot help you to write the code for this, as this is then more than just a few lines. Hope this helps, and that I my answer was now less 'overly cautious'.

Cheers,
Ferdinand

Result

The code correctly identifies that in this six segment spline are four segments of one winding direction (clockwise in this case) and two of the other winding direction.

winding_direction.c4d

Code

"""Treats spline segments as polygons and compares their plane normals to find 
segments with reversed winding order.
"""

import c4d

op: c4d.SplineObject # The currently active object in the scene.

def main() -> None:
    """Called by Cinema 4D when the script is being executed.
    """
    if not isinstance(op, c4d.SplineObject):
        return c4d.gui.MessageDialog("Please select a spline object.")
    
    # Get all points in the spline and organize them into their segments.
    points: list[c4d.Vector] = op.GetAllPoints()
    segments: list[list[c4d.Vector]] = []

    j: int = 0
    for i in [op.GetSegment(i)["cnt"] for i in range(op.GetSegmentCount())]:
        segments.append(points[j:j+i])
        j += i

    if len(segments) < 2:
        return c4d.gui.MessageDialog("Please select a spline object with at least 2 segments.") 

    # Now build normal data for the spline segments. This assumes:
    #
    #   - A spline where all points lie in a single plane, a '2D' spline in 3D space.
    #   - No self intersections in the spline.
    #   - A piecewise linear spline, i.e., what Cinema 4D calls a 'Linear' spline. When we have a
    #     'Cubic' or 'Bezier' spline, we would have make it linear with 'Current State to Object' 
    #     first.
    #
    # We build the normal for each segment over its three first vertices. The reason why we are doing 
    # this is because of the fundamental identity of a polygon (in a computer graphics sense), 
    # reversing the order of the vertices of a polygon will reverse the normal. So if we have a 
    # spline with two segments with reversed winding order, they will have antiparallel normals (normals 
    # pointing in opposite directions). 
    segmentNormals: list[c4d.Vector] = []
    for segment in segments:
        if len(segment) < 3:
            print("Segment has less than 3 points, skipping normal calculation.")
            continue

        a, b, c = segment[0], segment[1], segment[2]
        edge1: c4d.Vector = b - a
        edge2: c4d.Vector = c - b
        normal: c4d.Vector = edge1.Cross(edge2).GetNormalized()
        segmentNormals.append(normal)

    # Now we just declare one segment as 'ground truth' and check if the other segments have normals 
    # that are parallel or antiparallel to it. When we found a segment with an antiparallel normal, we 
    # know we found a segment with reversed winding order. To check if two normals are parallel or 
    # antiparallel, we just compute their dot product (i.e., spanned angle). When the dot product is 
    # negative, the normals are antiparallel.
    print(f"Establishing the first segment normal {segmentNormals[0]} as ground truth.")
    baseNormal: c4d.Vector = segmentNormals[0]
    for i, normal in enumerate(segmentNormals[1:], start=1):
        isAntiparallel: bool = baseNormal.Dot(normal) < 0
        print(f"Segment {i} normal: {normal} is {'antiparallel' if isAntiparallel else 'parallel'} "
              f"to the base normal {baseNormal}.")
        
if __name__ == '__main__':
    main()

Hm, okay. So, the situation is, you have a Cinema app/plugin, but since you use a non-native GUI, you must bridge the gap to your GUI and Cinema native image data.

Please understand that using external UI kits is out of scope of support. Not only because it is a third party library, and because we refuse support for them, but also because we generally do not like it when plugins use other UI tool kits than the native one.

With that being said:

The script I have shown you above would be at least a way to cache command icons. You would have to add a mechanism to avoid having to write all bitmaps to disk every time, and to delete unused ones, because as I explained above, not all commands are static.

For assets I would have to check myself or see some actual code. My base assumption would be that at least bitmap icons of assets can be loaded via BaseBitmap::Init (or InitWith in Python), even when the asset uses an exotic URL such as c4d://[relative:///icon]/5159. Because Python binds to BaseBitmap::Init which expects a cinema::Filename as the first argument, which will be internally converted to a maxon::Url and the Maxon API should then just figure out what you mean with c4d://[relative:///icon]/5159 and load the correct bitmap for you. In asset icons you might also encounter other exotic URL types such as ramdisk urls, zipped urls and more. But in all cases, at least in theory, the unpacking into a BaseBitmap should work from the Python API. For vector icons you will have to wait a bit.

Cheers,
Ferdinand

PS: I am also not sure if serializing to disk is the best way. In C++ it would be for sure not be faster to write everything to disk and then read it back, instead of just converting data in memory. In slow, slow, slow Python, it might actually be faster to write stuff to disk and load it back using the C++ backend, than copying data in Python in memory.

I.e., I mean something like this. But I did it there in the other direction, our GUI wraps alien image data. And not an alien GUI wraps our image data.

Hm,

I still do not really understand what you want to do. I suppose you want to support assets dragged into palettes as I have done below with a texture? Because that is the only way how I can bring the terms "asset", "command", and "icon" into a meaningful context.

Most commands, as for example an explicitly implemented CommandData plugin or the CommandData wrapper created by Cinema 4D for a NodeData plugin such as ObjectData or TagData are static, i.e., their ID will never change.

But Cinema 4D also creates commands dynamically. The Script Manger does this for example (exposde via c4d.GetDynamicScriptID). This might be something you are aware of, and which might have let you to assume that the Asset Browser does the same. Which is unfortunately not the case. The Asset Browser is using a non-public mechanism to create "commands" in palettes which are not really commands. So, you cannot CallCommand them. This little script will walk all commands for you and dump their name, icon, and ID.

import c4d

doc: c4d.documents.BaseDocument  # The currently active document.
op: c4d.BaseObject | None  # The primary selected object in `doc`. Can be `None`.

def main() -> None:
    """Called by Cinema 4D when the script is being executed.
    """
    command: c4d.plugins.BasePlugin
    for command in c4d.plugins.FilterPluginList(c4d.PLUGINTYPE_COMMAND, True):
        name: str = command.GetName()
        if not name:
            continue

        cid: int = command.GetID()
        icon: c4d.BaseBitmap | None = c4d.bitmaps.InitResourceBitmap(cid)
        if icon is None:
            print(f"Found command with name '{name}', id {cid}, and no icon.")
        else:
            print(f"Found command with name '{name}', id {cid}, and an icon {icon}.")


if __name__ == '__main__':
    main()

This will contain:

• Natively implemented commands ("My Light Manger", "Move")
• Command wrappers for NodeData plugins ("My Object", "Cube")
• Command wrappers for scripts ("My Script", "untitled 2")

But it will not contain asset "commands" as the Asset Browser does not create real commands for the assets dragged into palettes but uses a non-public mechanism to trigger the assets when clicking on them. You can of course also export asset icons to some degree, but these are (a) not commands and (b) there are the hurdles in the way as expressed in my previous post.

The command IDs discovered in this manner will also contain dynamically created commands such as the ones created by the Script Manager. So, using such a data source for a running instance of Cinema 4D is fine, but you cannot 'cache' such data as the command ID of the "unitled 2" script wrapper will change every time you restart Cinema 4D.

Cheers,
Ferdinand

Hey @Tpaxep,

please have a look at How to Ask Questions. Your question is very ambigous, and it is impossible to help you like this. I assume the issue for you is that the "holes" in your font spline have another winding direction than the outline?

I.e., the 'hole' in the R is winding counter-clockwise/negatively, while the outline is winding clockwise/positively. This is a non-trivial problem from geometry processing, and our API does not offer any ready made tools for this niche problem. One of the many approaches can be to compute the signed area of the segment (or a bit more advanced: the shoelace formula), but this can fail for self-intersecting splines and will not work for 3D splines. You can also try to compute the winding direction of the spline by looking at the cross product of the tangents, but this will also fail for self-intersecting splines and 3D splines. For 3D splines, you can work with the vector area of the spline, but this will also fail for self-intersecting splines.

There are generic solutions to this problem, but they are not trivial and discussing such problems is out of scope of support, unless the user approaches us with a specific question for an already implemented solution.

Cheers,
Ferdinand

That is of course also a valid option, just pick the scripting language you are most comfortable with.

Hey,

I am not quite sure I understand the question. In case this is related to your vector file request, let me preface this that internally my merge request for BaseBitmap::InitWithVectorFile is already pending. There are some technical discussions still going on about details of the MR, but a feature like this will come in one form or another. I have implemented this in C++ and the ported it back to Python, so that both APIs have this feature. The feature is targeting the next non-hotfix release after the next non-hotfix release (i.e., it will roughly arrive in Q3, and as an MRD you will have access to as soon as we start publishing tester builds for this release).

regarding your question, I am not really sure what you are asking for. Let me try to clarify some things about icons in asset databases:

• Icons for assets can change dynamically, the Dots Preset Asset Example I wrote a long time ago is a good example for this. So, caching icons can lead to stale icons.
• Icons do not have to be necessarily expressed in an URL scheme that makes much sense without the Maxon API, e.g., you could encounter URLs such as c4d://[relative:///icon]/5159, which would be an asset that is referencing the Cinema API icon resource 5159, i.e., c4d.Ocube.
• Generally, the raw asset database file scheme, while somewhat human readable, is not meant to be parsed by external tools, and the format can change without much notice. The only way to reliably parse these files is to use the Cinema and Maxon API, which will abstract away from any file format changes.

So, if you want to parse asset database resources for icon data, you will need to have access to the Cinema and Maxon API. And even then, this can be very much non-trivial.

Cheers,
Ferdinand

Hello @Tpaxep,

Your link does not work as your file upload seems to have failed. But there are in general two ways to achieve this.

1. Manually reverse the spline. For a simple non-bezier spline this is trivial, you just reverse both the points and the segments. When you want to also support bezier splines, i.e., tangents, this becomes a bit more work.
2. Just use the modeling command MCOMMAND_SPLINE_REVERSE. Modeling commands can be undesirable in some contexts, see the extrude example in Modeling Commands for details.

Cheers,
Ferdinand

"""Reverses the selected editable spline object.
"""

import c4d

doc: c4d.documents.BaseDocument  # The currently active document.
op: c4d.BaseObject | None  # The primary selected object in `doc`. Can be `None`.

def main() -> None:
    """Called by Cinema 4D when the script is being executed.
    """
    if not isinstance(op, c4d.SplineObject):
        return c4d.gui.MessageDialog("Please select a spline object.")
    
    doc.StartUndo()
    if not c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_SPLINE_REVERSE, list=[op], 
                                         mode=c4d.MODELINGCOMMANDMODE_ALL, doc=doc):
        c4d.gui.MessageDialog("Failed to reverse the spline.")

    doc.EndUndo()

if __name__ == '__main__':
    main()

Hey @atg,

It is not Visual Studio which is doing this, but our CMake meta build system. And it is intentionally done like this, as the build folders should only contain build output. To change this, you would have to modify cmake\sdk_targets.cmake:817ff and/or MaxonTargets_CreateDirectoryLink in the same file. But that is rather impractical, as you would have to patch these files with each version of the SDK you use.

You have two options:

1. Use the builtin install feature of CMake. The SDK does not have a pre-made install configuration, as I personally dislike the feature and it would also be difficult to generically setup for SDK projects due to the freedom we give projects in where to place dependencies such as dynamic libraries. But you can easily add an install configuration to your own project, which will copy the plugin to a folder of your choice when you run cmake --install. You can even set up a post-build event in Visual Studio to automatically run this command after each build.
2. I personally would just go for a Python script which you can run from a my_build_system/plugins folder and which will copy all folders in it to some target folder of yours and also resolves symbolic links (and possibly filters out some files if you want).

Option two would cost me 30 minutes to set up or so, option one would be much more work for at least me (which is why I dislike the install feature), but it would be more integrated into CMake. I would personally just go for option two, as it is more flexible and easier to set up.

Cheers,
Ferdinand

I started to work last Friday on a BaseBitmap.InitWithVectorImage. It will for sure not make it into the next release of Cinema 4D, as we are too close to that, and I cannot make any promises when or if it will arrive. But I see value in this especially since I realized that you cannot even really use this in C++, as VectorImageInterface requires access to some internal components to be rasterized.

Hello @Dunhou,

Thank you for reaching out to us. I am afraid that this is not possible within our Python API at the moment.

Internally, BaseBitmap is what we call an adapter. It is a hollowed out type from older days, which only continues to exist so that we do not have to rewrite large parts of our code base. A BaseBitmap wraps internally an ImageInterface, where also the sub-type VectorImageInterface exists. Unfortunately, neither of these Maxon API interfaces are exposed to Python, and it is also somewhat unlikely that they will be in the future. The reason why your code bmp.InitWith(preview_url) does not work, is because the backend function ::InitFromFile which implements BaseBitmap::InitWith operates based on bitmap loaders and VectorImageInterface is not a bitmap loader, because it was implemented long after the 'classic' Cinema API.

When I have some time, I will try to monkey patch a BaseBitmap.FromVectorImage method into the Python API. For now, you would have to use an external library such as Pillow.

Cheers,
Ferdinand

Hey @Anlv,

Thank you for reaching out to us and reporting this. I just changed it so that the path is always a raw string. This will be shipped with an upcoming (but not the next) public release.

Cheers,
Ferdinand

I.e., your script will then be as follows where there is an r in front of the string, which should fix the issue on Windows.

plugins.ReloadPythonPlugin(
    path = r"C:\Users\<user>\AppData\Roaming\Maxon\Maxon Cinema 4D 2026_XXXXXXXX\plugins\PluginName\PluginName.pyp",
    reloadDocumentAfterReload=False,
    reloadOnlyActiveDocument=False
)

Hello @rndm_cg,

Welcome to the Maxon developers forum and its community, it is great to have you with us!

Getting Started

Before creating your next postings, we would recommend making yourself accustomed with our forum and support procedures. You did not do anything wrong, we point all new users to these rules.

• Forum Overview: Provides a broad overview of the fundamental structure and rules of this forum, such as the purpose of the different sub-forums or the fact that we will ban users who engage in hate speech or harassment.
• Support Procedures: Provides a more in detail overview of how we provide technical support for APIs here. This topic will tell you how to ask good questions and limits of our technical support.
• Forum Features: Provides an overview of the technical features of this forum, such as Markdown markup or file uploads.

It is strongly recommended to read the first two topics carefully, especially the section Support Procedures: How to Ask Questions.

About your First Question

It is pretty straight forward, you just add top level groups and they will automatically be turned into tabs. I used here the rounded tube example to add an extra tab. Make sure to reflect your group in all files (res, h, and str).

CONTAINER roundedtube
{
	NAME roundedtube;
	INCLUDE Obase;

	GROUP ID_OBJECTPROPERTIES
	{
		REAL PY_TUBEOBJECT_RAD				{ UNIT METER; MIN 0.0; }
		REAL PY_TUBEOBJECT_IRADX			{ UNIT METER; MIN 0.0; }
		REAL PY_TUBEOBJECT_IRADY			{ UNIT METER; MIN 0.0; }
		LONG PY_TUBEOBJECT_SUB				{ MIN 1; MAX 1000; }
		LONG PY_TUBEOBJECT_ROUNDSUB		{ MIN 1; MAX 1000; }
		REAL PY_TUBEOBJECT_ROUNDRAD		{ UNIT METER; MIN 0.0; }
		LONG PY_TUBEOBJECT_SEG				{ MIN 3; MAX 1000; }
	}
	
	INCLUDE Oprimitiveaxis;

  // The new tab group, all top level groups in a container will become tabs.
	GROUP ID_GRP_MY_STUFF
	{
		LONG ID_MY_THING			{ MIN 0; MAX 1; }
	}
}

Groups are elements as any other, and when you want them to be tabs, they need an ID and should have string (see my screen).

Cheers,
Ferdinand

I do not think that DRAW_ALPHA_FROM_IMAGE should not work. I just picked DRAW_ALPHA_NORMAL because it is the "most default one" out of the DRAW_ALPHA flags. I will have a look later. But you can for now probably just use DRAW_ALPHA_NORMAL.