Hello @pattatk-maxon,

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 Account

⚠ Please pick another username, it is obviously not okay to have "maxon" in your username. You can do this from Avatar in Menu Bar > Edit Settings > Change Username. Please do this within the next fourteen days (until 02/06/2025), otherwise we will rename it.

Please also note that we usually do not provide support to unverified accounts as yours (you never verified your mail). I also assume this comes from the same team as this support request did? You could also reach us via our contact form (when confidential information must be exchanged) but we should stop bothering end user support.

About your First Question

Your request is unfortunately very ambiguous, as you lack the reproducibility aspect lined out in Support Procedures: How to Ask Questions. , i.e., no executable code and data foundation with which we could reproduce your claims. I have seen your _remap_assetsfunction, but it ties into the rest of your file (it at least also calls _pathmap_recognized_types) and we cannot start poking around in your code/file to get it running in the first place.

The function GetAllAssetsNew is the Python frontend for the message MSG_GETALLASSETS which among others is broadcasted into a document by the Asset Inspector to gather all assets in a scene (via C4DAtom::MultiMessage). This means that each scene element that wants to support its path, font, etc, parameters being managed, must actively implement that message. It also means anything that is not a scene element (C4DAtom) cannot support it. Or to put it differently, if it does not show up in the Asset Inspector, it is not supported.

Your questions are all too ambiguous, I cannot really answer any of them.

What does 'aren't being properly remapped' mean concretely? Which are the 'certain Redshift cache' files? What are 'globalized' path names? Are you talking about absolute paths? Which attachments are not captured by the function and what do you consider to be an 'attachment'? Do you mean assets? And when you do, which assets are not being captured by the function?

The recommended approach for comprehensive path mapping in Cinema 4D + Redshift on DeadlineCloud?

I am not really sure what is 'comprehensive path mapping' for you, but I assume you want to map/transform the paths referenced in a scene file. MSG_GETALLASSETS (GetAllAssetsNew in Python) is the tool for that. But there is no guarantee that a scene will expose everything with that message, only the things which cannot be recomputed are guaranteed to be exposed.

In general, you could also just abstractly iterate over a scene graph to for example find all scene elements that have a parameter of DTYPE_FILENAME:

"""Prints all DTYPE_FILENAME parameters to be found in the active scene. """ import c4d import mxutils 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. """ # We iterate over all scene elements in the document but ignore caches. element: c4d.BaseList2D for element in mxutils.RecurseGraph(doc, False, True, True): # Now we iterate over its description to find parameters of DTYPE_FILENAME. data: c4d.BaseContainer pid: c4d.DescID for data, pid, _ in element.GetDescription(c4d.DESCFLAGS_GET_NONE): # Get data type of the last component of the DescID and then check if it is a filename. dtype: int = pid[pid.GetDepth() - 1].dtype if dtype == c4d.DTYPE_FILENAME: print(f"Found path parameter with the label '{data[c4d.DESC_NAME]}' and value " f"'{element[pid]}' in node '{element}'.") print ("Done.") if __name__ == '__main__': # Execute main() main()

Here for example run on an empty scene:
e98f75c9-0202-4030-b2bb-d7f9d3d7e11a-image.png

What you will not be able to discover this way, are paths buried in GraphNode instances, e.g., nodes in Material Node graphs. You could also traverse them when you come across such graph, but that is not done automatically by RecurseGraph as it is a pure Cinema API graph traversal. Please note that when you test this locally, despite my warning, you might see your material nodes and their paths being reflected in this output. These are then Cinema API emulation (BaseList2D) nodes for the GraphNode nodes, to be able to display them in the Attribute Manager. There is no guarantee that they will be present in every scene, as they are constructed on demand, so you must traverse these graphs yourself to be sure.

But in general, I would not advise doing this manually, as Cinema 4D scenes are much more complex than you probably realize, and you will then have to deal with all that complexity. It is not out of the question that there is a bug in MSG_GETALLASSETS as we did recently some work there, but it is more likely that you look for things being exposed by that message which simply by design are not (e.g., some cache which can be recomputed easily). What we did not even touch is the whole cloud-overly-long path thing you are doing (your last support request), and how it could interfere with asset handling.

When you need more help, please make sure to provide for us executable examples, and please open separate requests for each of them (there are at least three different issues mentioned here in your bullet points).

Cheers,
Ferdinand

PS: What we did not even touch, is that your _remap_assets is incorrect, as you explicitly want to target Redshift but at the same time do not support node materials. Your code might work partially due to the mentioned emulation layer nodes, but when you let this code then run in a production environment with no GUI, or without interacting with the GUI first, this emulation layer won't exist. You can have a look at this thread to get a sense of what to do. You would have to implement each render engine you want to support.

Hello @phillipg,

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

I am not quite sure where you came across the information that it would be impossible to do this, but you can allocate and add a sound track just as any other special track as documented. Please post your code for future support requests.

Cheers,
Ferdinand

"""Adds a sound track to the selected object, unless it already has one. """ 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 op: return c4d.gui.MessageDialog("Please select an object.") # The description ID for a sound track and check if it already exists on the object. did: c4d.DescID = c4d.DescID(c4d.DescLevel(c4d.CTsound, c4d.CTsound, 0)) if op.FindCTrack(did): return c4d.gui.MessageDialog("The object already has a sound track.") # Create a new sound track and add it to the object. track: c4d.CTrack = c4d.CTrack(op, did) op.InsertTrackSorted(track) c4d.EventAdd() if __name__ == '__main__': main()

Hello @karpique,

Thank you for reaching out to us. Please follow our support procedures in future regarding providing a question that is for repeatable, we otherwise might refuse support.

Your problem is likely tied to cache optimization being enabled, this has been discussed before here for example. To not write essays due to the unbound nature of your question, I answer in the video below.

Cheers,
Ferdinand

It sounds worth a try, but there may be latency issues when it comes to changes, or data changes can be manually processed during the changes

Perhaps for my needs, I can force the database to be use GetSceneRepository, anyway, it's worth a try. Thank you for your guidance 😊

Dear Community,

we got a few follow-up questions, and I thought I make them public too. This is mostly about how to support material drag events, e.g., dragging a texture into the viewport, so that it can be put on an object as a material.

Cheers,
Ferdinand

Explanation

Code """Provides an example for implementing a custom control (GeUserArea) that can receive drag events and generate drag events itself. This is here demonstrated at the common case of a bitmap GUI, into which image file paths and texture assets can be dragged, and which itself generates image file path drag events. The example can simply be run from the script manager. This version also implements dragging the textures as materials on objects in the viewport. This is done by creating a Redshift material with the texture as input and generating a drag event for that material. """ __author__ = "Ferdinand Hoppe" __copyright__ = "Copyright 2025 Maxon Computer GmbH" import os import re import c4d import maxon import mxutils # A regex to check of a string (which is meant to be a path/url) already as a scheme (like file:/// # or http:///). The protocol we are mostly checking for is "asset:///", but we keep this regex generic # to allow for other schemes as well. RE_URL_HAS_SCHEME = re.compile("^[a-zA-Z][a-zA-Z\d+\-.]*:\/\/\/") class BitmapCard(c4d.gui.GeUserArea): """Implements a control that can receive bitmap path drag events and generates drag events itself. """ def __init__(self) -> None: """Constructs a new BitmapCard object. """ self._bitmap: c4d.bitmaps.BaseBitmap | None = None self._path: str | None = None def GetMinSize(self) -> tuple[int, int]: """Called by Cinema 4d to evaluate the minimum size of the user area. """ return 250, 100 def DrawMsg(self, x1, y1, x2, y2, msg_ref): """Called by Cinema 4D to let the user area draw itself. """ self.OffScreenOn() self.SetClippingRegion(x1, y1, x2, y2) # Draw the background and then the bitmap if it exists. self.DrawSetPen(c4d.gui.GetGuiWorldColor(c4d.COLOR_BGGADGET)) self.DrawRectangle(x1, y1, x2, y2) if self._bitmap: w, h = self._bitmap.GetSize() self.DrawBitmap(self._bitmap, 5, 5, 240, 90, 0, 0, w, h, c4d.BMP_NORMALSCALED) def Message(self, msg:c4d.BaseContainer, result: c4d.BaseContainer) -> int: """Called by Cinema 4D to handle messages sent to the user area. Here we implement receiving drag events. """ # A drag event is coming in. if msg.GetId()==c4d.BFM_DRAGRECEIVE: # Get out when the drag event has been discarded. if msg.GetInt32(c4d.BFM_DRAG_LOST) or msg.GetInt32(c4d.BFM_DRAG_ESC): return self.SetDragDestination(c4d.MOUSE_FORBIDDEN) # Get out when this is not a drag type we support (we just support images). Note that we # cannot make up drag types ourselves, so when we want to send/receive complex data, we # must use the DRAGTYPE_ATOMARRAY type and pack our data into a BaseContainer attached # to the nodes we drag/send. data: dict = self.GetDragObject(msg) dragType: int = data.get("type", 0) if dragType not in [c4d.DRAGTYPE_FILENAME_IMAGE, maxon.DRAGTYPE_ASSET]: return self.SetDragDestination(c4d.MOUSE_FORBIDDEN) # Here we could optionally check the drag event hitting some target area. # yPos: float = self.GetDragPosition(msg).get('y', 0.0) # if not 0 < yPos < 50 or not self.CheckDropArea(msg, True, True): # return self.SetDragDestination(c4d.MOUSE_FORBIDDEN) # After this point, we are dealing with a valid drag event. # The drag is still going on, we just set the mouse cursor to indicate that we are # ready to receive the drag event. if msg.GetInt32(c4d.BFM_DRAG_FINISHED) == 0: return self.SetDragDestination(c4d.MOUSE_MOVE) # The drag event is finished, we can now process the data. else: # Unpack a file being dragged directly. path: str | None = None if dragType == c4d.DRAGTYPE_FILENAME_IMAGE: path = data.get("object", None) # Unpack an asset being dragged. elif dragType == maxon.DRAGTYPE_ASSET: array: maxon.DragAndDropDataAssetArray = data.get("object", None) descriptions: tuple[tuple[maxon.AssetDescription, maxon.Url, maxon.String]] = ( array.GetAssetDescriptions()) if not descriptions: return True # Invalid asset but we are not in an error state. # Check that we are dealing with an image asset. asset: maxon.AssetDescription = descriptions[0][0] metadata: maxon.BaseContainer = asset.GetMetaData() subType: maxon.Id = metadata.Get(maxon.ASSETMETADATA.SubType, maxon.Id()) if (subType != maxon.ASSETMETADATA.SubType_ENUM_MediaImage): return True # Invalid asset but we are not in an error state. path = str(maxon.AssetInterface.GetAssetUrl(asset, True)) if not isinstance(path, str): return False # Critical failure. if (dragType == c4d.DRAGTYPE_FILENAME_IMAGE and (not os.path.exists(path) or os.path.splitext(path)[1].lower() not in [".png", ".jpg", ".jpeg", ".tif"])): return True # Invalid file type but we are not in an error state. self._path = path self._bitmap = c4d.bitmaps.BaseBitmap() if self._bitmap.InitWith(path)[0] != c4d.IMAGERESULT_OK: return False # Critical failure. self.Redraw() # Redraw the user area to show the new bitmap. return True # Process other messages, doing this is very important, as we otherwise break the # message chain. return c4d.gui.GeUserArea.Message(self, msg, result) def InputEvent(self, msg: c4d.BaseContainer) -> bool: """Called by Cinema 4D when the user area receives input events. Here we implement creating drag events. """ # We could be here more elegant and only generate drag events when the user is clicking a # specific area of the user area, or meeting some other conditions. I am just blindly # checking for the left mouse button being pressed and the user area being valid. if (msg.GetInt32(c4d.BFM_INPUT_DEVICE) == c4d.BFM_INPUT_MOUSE and msg.GetInt32(c4d.BFM_INPUT_CHANNEL) == c4d.BFM_INPUT_MOUSELEFT and self._path): # When the user is holding the ctrl key, we generate a drag event for a simple bitmap # file. This can be dragged into anything that accepts bitmap file drag events. Dragging # such event onto an object in the viewport will create a new standard material with the # bitmap as texture. if msg.GetInt32(c4d.BFM_INPUT_QUALIFIER, 0) & c4d.QUALIFIER_CTRL: return self.HandleMouseDrag(msg, c4d.DRAGTYPE_FILENAME_IMAGE, self._path, 0) # When the user is not holding the ctrl key, we create a material for the bitmap and # generate a drag event for the material. # Poll for the shift key being pressed. elif c4d.threading.GeIsMainThread(): # We should be more graceful here and check if a material for that texture already # exists, but I am just blindly creating a new one. And we are creating a Redshift # material, we could of course also check for the active renderer and be more # sophisticated here. # Create a new material and get its Redshift node graph. material: c4d.BaseMaterial = mxutils.CheckType(c4d.BaseMaterial(c4d.Mmaterial)) graph: maxon.NodesGraphModelRef = maxon.GraphDescription.GetGraph( material, maxon.NodeSpaceIdentifiers.RedshiftMaterial) # Create a simple graph using that texture, and insert the material into the # active document. maxon.GraphDescription.ApplyDescription(graph, { "$type": "Output", "Surface": { "$type": "Standard Material", "Base/Color": { "$type": "Texture", # Set the texture. When our source is a file we will just have a plain # path, e.g. "C:/path/to/file.png" and we have to prefix with a scheme # (file) to make it a valid URL. When we are dealing with an asset, the # texture path will already be a valid URL in the "asset:///" scheme. "Image/Filename/Path": (maxon.Url(f"{self._path}") if RE_URL_HAS_SCHEME.match(self._path) else maxon.Url(f"file:///{self._path}")) } } }) doc: c4d.documents.BaseDocument = c4d.documents.GetActiveDocument() doc.InsertMaterial(material) # Create a drag event for our custom material for the bitmap. return self.HandleMouseDrag(msg, c4d.DRAGTYPE_ATOMARRAY, [material], 0) return False class BtmapStackDialog(c4d.gui.GeDialog): """Implements a a simple dialog that stacks multiple BitmapCard controls. """ def __init__(self): """Constructs a new ExampleDialog object. """ self._cards: list[BitmapCard] = [BitmapCard() for _ in range(4)] def CreateLayout(self): """Called by Cinema 4D to populate the dialog with controls. """ self.SetTitle("Drag and Drop Example") self.GroupSpace(5, 5) self.GroupBorderSpace(5, 5, 5, 5) for i, card in enumerate(self._cards): self.AddUserArea(1000 + i, c4d.BFH_LEFT | c4d.BFV_TOP) self.AttachUserArea(card, 1000 + i) return True # Define a global variable of the dialog to keep it alive. ASYNC dialogs should not be opened in # production code from a script manager script, enabled by this global variable hack, as this # results in a dangling dialog. Implement a command plugin when you need async dialogs in production. # Opening modal dialogs from the script manager is fine. dlg: BtmapStackDialog = BtmapStackDialog() if __name__ == "__main__": dlg.Open(dlgtype=c4d.DLG_TYPE_ASYNC, defaultw=150, default=250)

Hey @lionlion44,

Well, doing what you want to do is only halfway possible. An object being soloed just means setting the flag EHIDE on all othe objects. And while there is OHIDE which can be used to hide scene elements in managers, e.g., an object in the Object Manager, it is not being used by the 'Set as Root/Path Bar'-function of the Object Manager. So, you cannot hook into that.

What you can do is just write a simple script which operates both flags for you. But to make this air-tight, you will have to implement a plugin (to avoid accidentally saving a scene with hidden elements).

Cheers,
Ferdinand

Result

Code """Demonstrates how to set the visibility of objects in the viewport and the managers. - When CTRL is not pressed while the script is invoked, the visibility state of the selected objects is set, i.e., everything that is not selected will be hidden. - When CTRL is pressed, the visibility state of the selected objects is cleared. - When HIDE_DESCENDANTS_OF_SELECTED_OBJECTS is set to True, the descendants of selected objects will be considered selected as well. WARNING: The visibility state is written PERMANENTLY into the scene graph, i.e., when one hides objects and saves the scene, the visibility state will be saved as well. One can of course just run the script while pressing CTRL to clear the visibility state of such saved and then loaded back scene, but this could possibly brick scenes for other users. To make this air-tight, one would have to implement a plugin which handles un-hiding objects before a scene is being saved (which is not super trivial in Python atm). Use this script at your own risk. """ __author__ = "Ferdinand Hoppe" __copyright__ = "Copyright 2025, Maxon Computer GmbH" import c4d import mxutils doc: c4d.documents.BaseDocument # The currently active document. op: c4d.BaseObject | None # The primary selected object in `doc`. Can be `None`. # Wether to hide objects that are descendants of selected objects. I.e., when you have A-> B -> C, # and A is selected, B and C will be considered selected as well. HIDE_DESCENDANTS_OF_SELECTED_OBJECTS: bool = True def IsSelected(node: c4d.BaseObject) -> bool: """Returns if #node is selected or if any of its predecessors are selected (when selecting descendants implicitly is enabled). """ while node: if node.GetBit(c4d.BIT_ACTIVE): return True if not HIDE_DESCENDANTS_OF_SELECTED_OBJECTS: break node = node.GetUp() return False def SetObjectVisibility(doc: c4d.documents.BaseDocument, clearSate: bool = False) -> None: """Sets the visibility of the object in the managers and the viewport. """ for node in mxutils.IterateTree(doc.GetFirstObject(), True, True, True): isSelected: bool = clearSate or IsSelected(node) node.ChangeNBit(c4d.NBIT_OHIDE, c4d.NBITCONTROL_CLEAR if isSelected else c4d.NBITCONTROL_SET) node.ChangeNBit(c4d.NBIT_EHIDE, c4d.NBITCONTROL_CLEAR if isSelected else c4d.NBITCONTROL_SET) def main() -> None: """Called by Cinema 4D whhen the """ if not op: c4d.gui.MessageDialog("No object selected.") return state: c4d.BaseContainer = c4d.BaseContainer() if not c4d.gui.GetInputState(c4d.BFM_INPUT_MOUSE, 0, state): raise RuntimeError("Failed to get input state") ctrlIsPressed: bool = state[c4d.BFM_INPUT_QUALIFIER] & c4d.QUALIFIER_CTRL # If Ctrl is pressed, clear the visibility state, otherwise set it. SetObjectVisibility(doc, True if ctrlIsPressed else False) c4d.EventAdd() if __name__ == '__main__': main()

Hi @shafy sorry for the delay I was away for few times.

Before we start please read the Support Procedure - About AI-Supported Development. Keep in mind we are not there to develop for you neither integrate or guide you with 3rd party module that you will most likely need in order to control knobs.

With that's said what you are asking (at least retrieving a parameter and defining it) is possible for Redshift light intensity. It is as easy as drag and dropping the parameter you are interested by into the Cinema 4D Python Console as explained in Python Script Manager Manual - Drag And Drop. Additionally you can also use the Script Log to record a script or change and therefor re-execute it.

Cheers,
Maxime.

This is fantastic, thank you so much!

This works beautifully.

I see your confusion with the "offset". This is absolutely my fault in formulating the question. Sorry about that. I also wanted the clones to follow a spline with an individual offset, but then thought to remove this part to not overcomplicate the question and accidentally left some traces. However, in your video you gave me valuable insight in how to achieve this as well. I already have a working sketch where I'm daisy chaining your script with a Spline Effector in the right order.

Giving these thoughtful answers is incredibly valuable, you can't believe how motivating this is to go further.

Hey @Fabio-B,

⚠ Please note that we cannot provide support for AI generated code. See Support Procedures: Scope of Support for details.

When you want the clones to move, or in other words to be animated over time, you will need a noise and cannot use hashes or random values, as they are not interpolated, i.e., continous.

"""Realizes an effector that attracts MoGraph particles spherically around its origin. Add the example to a Matrix object to understand its effect. In Full Control mode we can realize a true attraction force as we have full control over the particle values. Compare this example to Parameter Control mode to understand the difference. """ import c4d import mxutils op: c4d.BaseObject # The Python Effector object containing this code. gen: c4d.BaseObject # The MoGraph Generator executing `op`. doc: c4d.documents.BaseDocument # The document `op` and `gen`are contained in. def main() -> bool: """Called by Cinema 4D to evaluate the effector. """ # Get the particle data for the effector #op. Get out when either the data cannot be retrieved. data: c4d.modules.mograph.MoData = c4d.modules.mograph.GeGetMoData(op) if data is None: return 1.0 # Get the matrices of the particles. This is the array we will modify. matrices: list[c4d.Matrix] = data.GetArray(c4d.MODATA_MATRIX) # For each particle write a new persistent random height value, hashed over the index of the # particle. This will cause the height each time to be the same, as long as the index of the # particle does not change. One could also hash the position of the original particle to get a # height value that is not dependent on the index of the particle (e.g., when the user changes # the order of the particles in the Matrix object). for i in range(data.GetCount()): pos: c4d.Vector = matrices[i].off y: float = c4d.utils.noise.Noise(matrices[i].off, doc.GetTime().Get()) * 25.0 matrices[i].off = c4d.Vector(pos.x, y, pos.z) # Hash a height value over the position of the particle. # y: float = mxutils.g_random.HashVectorToNumber(matrices[i].off) * 25.0 # Write the new data back. data.SetArray(c4d.MODATA_MATRIX, matrices, op[c4d.FIELDS].HasContent()) return True

Cheers,
Ferdinand

Hey @m_adam,
Thanks for the reply! What you’re saying makes a lot of sense C++ is clearly the better option for this kind of stuff, especially when you need more control and better performance. I haven’t had much chance to dive into C++ yet, but I’m well aware it’s way more powerful than Python when it comes to working with the engine.
It’s a bit of a shame that there’s no way to directly access polygon info from Python, since that’s exactly what I needed. But still, I really appreciate you taking the time to explain it.
Cheers,
James H.

@ferdinand
Thank you for your detailed explanation, it shed some light on the whole matter for me.

Hi @chuanzhen,

Glad to hear the issue went away.

Just to note, the frozen matrices are designed in a way that simulate behavior of an intermediate parent null object, i.e. just as if you had an invisible parent null object with matrix being equal to the frozen one. Sometimes it can get confusing, because the way the global matrix of the object is calculated is effectively:

[Local Matrix] = [Frozen Translation] * [Frozen Rotation] * [Relative Translation] * [Relative Rotation] * [Frozen Scale] * [Relative Scale]

If the relative transform (the main one) and the frozen transform are the same for two objects, given they are children of the same parent and there're no other 3rd parties involved (e.g. plugins, python tags etc), the global transform matrices of these two objects are the same.

Please find more useful insights in our great Matrix Manual.

Cheers,
Ilia

@hoganXYZ hi if it does not appear in the script log then there is no clear rules. Sometimes there is another way sometimes now it depends on how it is implemented. For the one you asked I do not think it is possible. Best bet would be to ask Redshift on their forum.

Cheers,
Maxime.

Hi I was able to reproduce the issue and fix it for the next version.
The bug is that setting RDATA_FRAMERATE require the RenderData to be part of a document in case the "Use Project Frame Rate" is enabled on the render settings. If this is enabled and this is enabled by default the value you enter will be disregarded. "Use Project Frame Rate" is a new setting added in 2025.2.

I will ping you once the fix is available.
Cheers,
Maxime.

Hi Ferdinand,

Thanks a lot for the clear explanation and for taking the time to share the code. The part about accessing BaseVideoPost and using REDSHIFT_RENDERER_EMISSION_ENABLE was spot on. Exactly what I needed. Works perfectly!

Really appreciate it.

Anthony

Hi Ilia,

Thanks a lot for the quick and clear reply!

That makes sense. I had a feeling it might be a limitation of the current API. I’ll definitely follow up with the Redshift team on their forum to confirm whether there’s any workaround or future support planned for accessing those fields.

Appreciate your help and the reference to the related thread!

Cheers,
Anthony

Hi @d_keith,

I would kindly ask you to check our Support Procedures, namely the "How To Ask Questions" paragraph:

Singular Question: The initial posting of a support topic must contain a singular question. Do not ask ten things at once, that makes it extremely hard to answer topics. Break up your questions into multiple topics.

Here you effectively have 4 different questions about Asset Browser, and these are candidates for 4 different threads on the forum. In your further postings please try to follow the aforementioned rules.

Regarding your questions:

Should I be able to mount a directory and have it auto-create a DB?

Mounting database is effectively executing the AssetDataBasesInterface.SetDatabases. It has nothing to do with creating database neither semantically, nor is this mentioned in the docu. If you need to create repository, please use maxon.AssetInterface.CreateRepositoryFromUrl(), it will scan the directory for being already a database and create proper dir structure if it's not.

Any idea why I need to re-try creating the Repo for it to work?

If you face any errors in the script, please always attach at least the error message! In this case I assume you receive the following error, when executing the maxon.AssetRepositoryTypes.AssetDatabase() for the first time after Cinema 4D started. Looks like a bug to me, I've created a bug report for that (ITEM#585831).

The error message:

Traceback (most recent call last): File "console", line 1, in <module> File "C:\Program Files\Maxon Cinema 4D 2025\resource\modules\python\libs\python311\maxon\interface.py", line 5049, in __call__ self._cachedObj.R = _maxon_mapping.GetAssociatedDataType(dt) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Exception: unable to find datatype

As a workaround you can just execute the following line first in your main():

maxon.AssetRepositoryTypes.AssetDatabase() ... about multiple DBs ...

You're giving your databases unique IDs with the line repo_id = maxon.AssetInterface.MakeUuid(str(url), True). If you need them to be the same, just pick one instead, e.g. repo_id = maxon.Id('net.maxon.sdk.cool.things.repo')

... revealing assets doesn't work...

I've created a bug report for that, as it looks like a bug with refreshing in the Asset Browser. As a workaround you can reload databases and reopen the AB before reveling your assets, e.g.:

def RepenAssetBrowser(): CID_ASSET_BROWSER = 1054225 # Close the Asset Browser if it's alredy opened if c4d.IsCommandChecked(CID_ASSET_BROWSER): c4d.CallCommand(CID_ASSET_BROWSER) # Open again c4d.CallCommand(CID_ASSET_BROWSER) def main(): # ... # assets = [] # ... # assets.append(asset) # ... maxon.AssetDataBasesInterface.ReloadAssetRepositories(True) RepenAssetBrowser() maxon.AssetManagerInterface.RevealAsset(assets)

Cheers,
Ilia

Hey,

Node attributes are things that are directly present on a GraphNode. You could also call them fields, because a GraphNode like many things in our API has qualities of a DataDictionay, i.e., you can write values over keys into it, just like for Python's own dict.

Such node attributes (for true nodes) are then rendered out quite similarly to port values in the Attribute Manager but they are fundamentally different from ports, as users cannot drive their value with a connection, i.e., the value of a port of another node. And a port also always requires another GraphNode attached to the true node¹ for which they are a port, while the attribute sits directly on the true node.

An attribute, e.g., the name of a node, will also never show up in the node representation in the graph. In the screen below I for example right clicked on the RS Reference node and invoked Add Input > All; but things like Name, Color, Show Preview etc. are alle not listed.

174097cf-d777-49d2-b0ea-0057c8474a5e-image.png

That is because they are all attributes and not ports. There is unfortunately no absolute rule like 'everything in Basic is attributes and everything else is ports'. While it holds (for now) true that everything in Basic is an attribute, especially Redshift also puts attributes into other tabs. They usually only appear in more complex scenarios when dealing with port bundles and variadic ports, but they exist.

And just for clarity, attributes do not only exist on nodes that are what our API calls 'true nodes'¹, but also on other GraphNode types, e.g., a GraphNode representing a port. It is just that they are usually not rendered out to the GUI there and more of an internal nature (nodes have a lot of internal attributes).

Cheers,
Ferdinand

¹ GraphNode instances that represent what the end user would consider a 'node', e.g., the RS Reference node, and with that excluding GraphNode instances that for example represent an input port.

Ah, super! thank you.

@ferdinand said in SAVEDOCUMENTFLAGS_AUTOSAVE still added to the recent file list?:

But please provide instructions on how to use your code when required in the future.

oh shit, i'm so sorry. you're right. completly missed this one. 😬
...
and of cause thanks for the explaination / clarification.