Posts made by ferdinand

Hello @ThomasB,

thank you for reaching out to us. The problem in your script is that Cinema 4D R23 gave you an incorrect symbol when you dragged the roughness shader parameter into your script. You can always look up the correct symbols in our C++ or Python documentation, or right away use the numeric values they do stand for by inspecting the resource files. You can find a fixed version below.

Cheers,
Ferdinand

"""Cinema 4D R23 did link some incorrect symbols for the layer shader when
dragging and dropping parameters into the console.

This problem does not exist anymore as of R25.
"""

import c4d

def main():
    """
    """
    mat = doc.SearchMaterial("Mat")
    layerIndex = mat.GetReflectionLayerIndex(0).GetDataID()

    color_gloss = c4d.BaseList2D(c4d.Xbitmap)
    color_gloss[c4d.BITMAPSHADER_FILENAME] = op[c4d.ID_USERDATA, 1]
    # REFLECTION_LAYER_MAIN_SHADER_ROUGHNESS is the correct symbol. When push
    # comes to shove, you can also always look into header files to find out
    # the raw numeric values the symbols stand for.
    mat[layerIndex + c4d.REFLECTION_LAYER_MAIN_SHADER_ROUGHNESS] = color_gloss
    mat.InsertShader(color_gloss)


if __name__ == '__main__':
    main()

Hello @holgerbiebrach,

please excuse the wait. So, this is possible in Python and quite easy to do. This new behavior is just the old dialog folding which has been reworked a little bit. I have provided a simple example at the end of the posting. There is one problem regarding title bars which is sort of an obstacle for plugin developers which want to distribute their plugins, it is explained in the example below.

I hope this helps and cheers,
Ferdinand

The result:

The code:

"""Example for a command plugin with a foldable dialog as provided with the
Asset Browser or Coordinate Manger in Cinema 4D R25.

The core of this is just the old GeDialog folding mechanic which has been
changed slightly with R25 as it will now also hide the title bar of a folded
dialog, i.e., the dialog will be hidden completely.

The structure shown here mimics relatively closely what the Coordinate Manger
does. There is however one caveat: Even our internal implementations do not
hide the title bar of a dialog when unfolded. Instead, this is done via 
layouts, i.e., by clicking onto the ≡ icon of the dialog and unchecking the
"Show Window Title" option and then saving such layout. If you would want
to provide a plugin which exactly mimics one of the folding managers, you
would have to either ask your users to take these steps or provide a layout.

Which is not ideal, but I currently do not see a sane way to hide the title
bar of a dialog. What you could do, is open the dialog as an async popup which 
would hide the title bar. But that would also remove the ability to dock the 
dialog. You could then invoke `GeDialog.AddGadegt(c4d.DIALOG_PIN, SOME_ID)`to 
manually add a pin back to your dialog, so that you can dock it. But that is 
not how it is done internally by us, as we simply rely on layouts for that.
"""

import c4d


class ExampleDialog (c4d.gui.GeDialog):
    """Example dialog that does nothing.

    The dialog itself has nothing to do with the implementation of the
    folding.
    """
    ID_GADGETS_START = 1000
    ID_GADGET_GROUP = 0
    ID_GADGET_LABEL = 1
    ID_GADGET_TEXT = 2

    GADGET_STRIDE = 10
    GADEGT_COUNT = 5

    def CreateLayout(self) -> bool:
        """Creates a some dummy gadgets.
        """
        self.SetTitle("ExampleDialog")
        flags = c4d.BFH_SCALEFIT

        for i in range(self.GADEGT_COUNT):
            gid = self.ID_GADGETS_START + i * self.GADGET_STRIDE
            name = f"Item {i}"

            self.GroupBegin(gid + self.ID_GADGET_GROUP, flags, cols=2)
            self.GroupBorderSpace(5, 5, 5, 5)
            self.GroupSpace(2, 2)
            self.AddStaticText(gid + self.ID_GADGET_LABEL, flags, name=name)
            self.AddEditText(gid + self.ID_GADGET_TEXT, flags)
            self.GroupEnd()
        return True


class FoldingManagerCommand (c4d.plugins.CommandData):
    """Provides the implementation for a command with a fordable dialog.
    """
    ID_PLUGIN = 1058525
    REF_DIALOG = None

    @property
    def Dialog(self) -> ExampleDialog:
        """Returns a class bound ExampleDialog instance.
        """
        if FoldingManagerCommand.REF_DIALOG is None:
            FoldingManagerCommand.REF_DIALOG = ExampleDialog()

        return FoldingManagerCommand.REF_DIALOG

    def Execute(self, doc: c4d.documents.BaseDocument) -> bool:
        """Folds or unfolds the dialog.

        The core of the folding logic as employed by the Asset Browser
        or the Coordinate manager in R25.
        """
        # Get the class bound dialog reference.
        dlg = self.Dialog
        # Fold the dialog, i.e., hide it if it is open and unfolded. In C++
        # you would also want to test for the dialog being visible with
        # GeDialog::IsVisible, but we cannot do that in Python.
        if dlg.IsOpen() and not dlg.GetFolding():
            dlg.SetFolding(True)
        # Open or unfold the dialog. The trick here is that calling
        # GeDialog::Open will also unfold the dialog.
        else:
            dlg.Open(c4d.DLG_TYPE_ASYNC, FoldingManagerCommand.ID_PLUGIN)

        return True

    def RestoreLayout(self, secret: any) -> bool:
        """Restores the dialog on layout changes.
        """
        return self.Dialog.Restore(FoldingManagerCommand.ID_PLUGIN, secret)

    def GetState(self, doc: c4d.documents.BaseDocument) -> int:
        """Sets the command icon state of the plugin.

        This is not required, but makes it a bit nicer, as it will indicate
        in the command icon when the dialog is folded and when not.
        """
        dlg = self.Dialog
        result = c4d.CMD_ENABLED
        if dlg.IsOpen() and not dlg.GetFolding():
            result |= c4d.CMD_VALUE

        return result


def RegisterFoldingManagerCommand() -> bool:
    """Registers the example.
    """
    return c4d.plugins.RegisterCommandPlugin(
        id=FoldingManagerCommand.ID_PLUGIN,
        str="FoldingManagerCommand",
        info=c4d.PLUGINFLAG_SMALLNODE,
        icon=None,
        help="FoldingManagerCommand",
        dat=FoldingManagerCommand())


if __name__ == '__main__':
    if not RegisterFoldingManagerCommand():
        raise RuntimeError(
            f"Failed to register {FoldingManagerCommand} plugin.")

Hello @chuanzhen,

thank you for reaching out to us. I will answer in bullet points, since there are sort of two questions within you question.

1. The unit type of a parameter is being stored in the Description of the node that parameter is a part of. Each parameter is being described as a BaseContainer in the description of a node. The unit of the parameter is then stored in the field c4d.DESC_UNIT in such container. See example at the end for details.
2. There are no prebuilt functions which would convert the value of a parameter into its display value. You would have to do that yourself with the unit type and the parameter value.

Cheers,
Ferdinand

The example code:

"""Attempts to evaluate the unit type of the first user data parameter of the 
currently selected object.

Must be run in the Script Manger while having an object selected with at least
one user data parameter. When the parameter has one of the unit types float,
percent, degree or meter (there are other unit types), it will print out a
matching message. If not, it will report that there is "another" unit type or
no unit type when the parameter has no unit type set at all.
"""

import c4d

def main() -> None:
    """Attempts to evaluate the unit type of the first user data parameter of
    the currently selected object.
    """
    # op is a predefined module attribute in scripts referencing the currently
    # selected object.
    if not isinstance(op, c4d.BaseObject):
        raise RuntimeError("Please select an object.")

    # The id of the parameter we are interested in, the first user data
    # parameter of a node.
    pid = (c4d.ID_USERDATA, 1)

    # Get the description of the node.
    description = op.GetDescription(c4d.DESCFLAGS_DESC_NONE)
    # Get the first user data element in the description.
    parameterData = description.GetParameter(pid)

    # Bail when the container is empty, i.e., there is no such parameter in
    # the node.
    if len(parameterData) < 1:
        raise RuntimeError(f"Retrieved empty data container for {pid}.")

    # How to iterate over the flags of that parameter container.
    # for cid, value in data:
    #     print (cid, value)

    # Get the unit type flag for the element and bail if there is no value
    # set for that flag.
    unitType = parameterData[c4d.DESC_UNIT]
    if unitType is None:
        print (f"The parameter with the id {pid} has no unit type.")
        return

    # Do some stuff depending on the unit type.
    if unitType == c4d.DESC_UNIT_FLOAT:
        print (f"The unit type for {pid} is float.")
    elif unitType == c4d.DESC_UNIT_PERCENT:
        print (f"The unit type for {pid} is percent.")
    elif unitType == c4d.DESC_UNIT_DEGREE:
        print (f"The unit type for {pid} is degree.")
    elif unitType == c4d.DESC_UNIT_METER:
        print (f"The unit type for {pid} is meter, i.e., length.")
    else:
        print (f"The unit type for {pid} is another unit type.")

if __name__ == '__main__':
    main()

Hello @blastframe,

thank you for reaching out to us. This is the correct behavior of GeDialog. It will always set the focus to its first element, so that users can navigate the dialog with the keyboard. If you look at our asset API examples dialog from the C++ SDK, it has the same behavior:

There are technically two ways to suppress this behavior.

1. Simply dock the dialog with a layout, given it is non-modal dialog, which seems to be the case in your example.
2. There is technically the private message BFM_SETFOCUS with which this behavior might be altered, but that requires some jumping through hoops and is probably also intentionally private, so I cannot really share it without a good reason. I think you will always need dummy element, e.g., a static text with no string, to make this work. So that you can set the focus to that element. By default, Cinema 4D will ignore such static text element as the first element.

I would say setting the focus to a dummy element is bad because it will break the keyboard input mechanics put into place by Cinema 4D. And I also have not tested what the side-effects of such hack would be. Or to be a bit more direct: This is simply not something you are intended to do. You can always set the focus of gadgets with GeDialog.Activate, but this does not allow you to clear the focus or set it to illegal elements.

Cheers,
Ferdinand

Hello @ingvarai,

My old posts are likely gone, I assume.

Your old posts are not gone, but they are not linked to your account anymore, since the accounts of the old forum have not been migrated to the current forum. The old postings have been imported into the Legacy Forum category, in case of C++ questions mostly into SDK Help. So, you cannot search for all postings assigend to an account anymore, since they are attached now to the @Helper account. But when there is a certain topic you do remember, you will usually find it with some searching.

Cheers,
Ferdinand

Hello @holgerbiebrach,

thank you for reaching out to us. Please excuse the delay, I have not had the time to pick up your topic yet. There is at least no direct route solution to this like just a registration symbol for GeDialog (at least I see none). I will have to unpack on Monday if all the required interfaces for doing this are public (the likely answer from a first glance is no, but I will have to dig a bit deeper to know for sure).

Cheers,
Ferdinand

Hello @ingvarai,

thank you for reaching out to us and welcome to the Plugin Café community.

You will find the SDKs for older Cinema 4D versions in the plugin folder shipped with Cinema 4D as exemplified with the screenshot of my R14 folder below.

I hope this does answer your question and cheers,
Ferdinand

Hello @eazy5d,

welcome to Plugin Café and the Cinema 4D development community. Thank you for reaching out to us.

We are having some troubles answering your question, since neither your code is executable (I can see that the import statements and the registration calls for your CommandData are missing for example) nor is your problem description 'And It's a disaster sometimes I get a SystemError: error return without exception set "Which is Fustrating"' fully clear to me. So, you mean an exception is being raised without a callstack or what does 'SystemError: error return without exception set' mean? Without any line-numbers it is hard to unpack that. Which would make executable code important.

So, we would ask you to provide the full content of your '*.pyp' file, so that we can test your plugin ourselves. It would also be good, if you could provide a short description of what actions lead to your problem. I think you did intended to describe that with an image, but the image below 'or worse See gif` seems to be the same as the first one you did post and at least for me does not bear any indication on what is going wrong.

Cheers,
Ferdinand

Hello @mogh,

thank you for reaching out to us. I think you have your axis inverted. At least that will fix your nut example for me. I frankly would rewrite this from scratch (you can reuse the read and write normal tags functions) when you want to do something differently. I remember I had to jump through some hoops hold up by your outer code, when I wrote adjust_point_node. But I think it did work then, didn't it?

Long story short: removing the inversion works for me, but that whole script is very duct tapey, since it assumes that there will always be a parent and that you only want to tranfer its axis. If you are fine with these restrictions, the script is probably fine.

Cheers,
Ferdinand

The result:

The code:

import c4d, array
#from c4d import Vector as V
#https://plugincafe.maxon.net/topic/13004/cad-normal-tag-flipped-after-polyon-merge-join-and-axis-repositioning-how-realign/6

#new Task:
#Corrects points and normals on a point object after placing the polygon axis to the same as the parent 

def adjust_point_node(node, transform):
    """Corrects points and normals on a point object after running the join
    command in the scenario specific to PC13004.

    Args:
        node (c4d.PointObject): The PointObject to transform.
        transform (c4d.Matrix): The transform to apply.

    Raises:
        TypeError: When either `node` or `transform` are not of expected type.
    """
    def read_normal_tag(tag):
        """`Reads a `c4d.NormalTag` to a list of c4d.Vector.

        Args:
            tag (c4d.NormalTag): The tag to read the normals from.

        Returns:
            list[c4d.Vector]: The red in normals. There are polygon_count * 4 
             normals, i.e. each vertex has a normal for each polygon it is
             attached to. The normals are stored in polygon groups.

        Raises:
            RuntimeError: When the memory of the tag cannot be red.
            TypeError: When `tag` is not a `c4d.NormalTag`.
        """
        if not (isinstance(tag, c4d.BaseTag) and tag.CheckType(c4d.Tnormal)):
            msg = f"Expected normal tag, received: {tag}."
            raise TypeError(tag)

        buffer = tag.GetLowlevelDataAddressR()
        if buffer is None:
            msg = "Failed to retrieve memory buffer for VariableTag."
            raise RuntimeError(msg)

        data = array.array('h')
        data.frombytes(buffer)
        # Convert the int16 representation of the normals to c4d.Vector.
        return [c4d.Vector(data[i-3] / 32000.0,
                           data[i-2] / 32000.0,
                           data[i-1] / 32000.0)
                for i in range(3, len(data) + 3, 3)]

    def write_normal_tag(tag, normals, do_normalize=True):
        """`Writes a list of c4d.Vector to a `c4d.NormalTag`.

        Args:
            tag (c4d.NormalTag): The tag to write the normals to.
            normals (list[c4d.Vector]): The normals to write.
            do_normalize (bool, optional): If to normalize the normals.
             Default to `True`.

        Note:
            Does not ensure that `normals` is only composed of c4d.Vector.

        Raises:
            IndexError: When `normals` does not match the size of `tag`.
            RuntimeError: When the memory of the tag cannot be red.
            TypeError: When `tag` is not a `c4d.NormalTag`.
        """
        if not (isinstance(tag, c4d.BaseTag) and tag.CheckType(c4d.Tnormal)):
            msg = f"Expected normal tag, received: {tag}."
            raise TypeError(tag)

        buffer = tag.GetLowlevelDataAddressW()
        if buffer is None:
            msg = "Failed to retrieve memory buffer for VariableTag."
            raise RuntimeError(msg)

        if do_normalize:
            normals = [n.GetNormalized() for n in normals]

        # Convert c4d.Vector normals to integer representation.
        raw_normals = [int(component * 32000.0)
                       for n in normals for component in (n.x, n.y, n.z)]

        # Catch input data of invalid length.
        count = tag.GetDataCount()
        if count * 12 != len(raw_normals):
            msg = (f"Invalid data size. Expected length of {count}. "
                   f"Received: {len(raw_normals)}")
            raise IndexError(msg)

        # Write the data back.
        data = array.array('h')
        data.fromlist(raw_normals)
        data = data.tobytes()
        buffer[:len(data)] = data

    # --- Start of outer function --------------------------------------------
    if (not isinstance(node, c4d.PointObject) or
            not isinstance(transform, c4d.Matrix)):
        msg = f"Illegal argument types: {type(node)}{type(transform)}"
        raise TypeError(msg)

    # I started cleaning up here a bit by running autopep on the script and
    # removing some clutter.

    mat = op.GetMg()
    points = op.GetAllPoints()
    for i,p in enumerate(points):
        points[i] = ~transform * mat * p
        
    node.SetAllPoints(points)
    node.Message(c4d.MSG_UPDATE) 
    node.SetMg(transform)
    
    nodelocalmatrix = node.GetMl()    
    nodematrix = node.GetMg()
    
    # Transform its baked normals.
    tag = node.GetTag(c4d.Tnormal)
    if isinstance(tag, c4d.NormalTag):
        # The only substantial change I made, I removed the inversion operator.
        # normals = [~transform.MulV(n) for n in read_normal_tag(tag)]
        normals = [transform.MulV(n) for n in read_normal_tag(tag)]
        write_normal_tag(tag, normals)
    else:
        msg = f"Could not find normal data to adjust for: {node}."
        print(f"Warning - {msg}")

def main():
    c4d.CallCommand(13957)  # Konsole löschen
    if op is None or not op.CheckType(c4d.Opoint):
        return False

    doc.StartUndo()
    doc.AddUndo(c4d.UNDOTYPE_CHANGE, op)

    targetMat = op.GetUp().GetMg()
    
    adjust_point_node(op, targetMat)
    
    op.Message(c4d.MSG_UPDATE)
    c4d.EventAdd()
    doc.EndUndo()
    
if __name__=='__main__':
    main()

Hello @dglopez,

thank you for clarifying your question. There are unfortunately some things still unclear to me, so let me start with a set of assumptions of mine:

• The other plugin uses a GeDialog and is most likely some CommandData plugin.
• There is a known set of C4DAtom, or more specifically BaseObject, you want to track.
• There is not necessarily a second plugin in your case.

So, there are basically two major ways you can do this. You can either A. push the information into the other plugin from the action of the objects being moved. This option does necessarily need a second plugin which is pushing the information into your other plugin. Or you can B. grab the information from the objects when they have been moved from within the other plugin. This option does not need necessarily a second plugin. Which might sound like semantics is an important distinction, since you cannot move data without restrictions in the message system of Cinema 4D.

When the the other plugin is some GeDialog, option B lends itself best via core messages and EVMSG_CHANGE, see end of posting for an example. However, when the other plugin is some kind of classic API node, e.g., an object itself, you will have to push the information into that node, e.g., with MSG_BASECONTAINER. But depending on how you structure all that, you might need a third plugin in between to handle the transfer. Your question is here unfortunately so broad that I cannot give you anything more concrete.

I hope this helps and cheers,
Ferdinand

The result:

The code:

"""Example for tracking object matrices in a GeDialog.

This can be run as a script manager script and will create a dialog which
tracks the global transform matrices of the objects that have been selected
when the dialog was created.

As discussed in:
    https://plugincafe.maxon.net/topic/13643/
"""

import c4d

class ObjectTrackerDialog (c4d.gui.GeDialog):
    """Example dialog that tracks the transforms of a set of objects.
    """
    ID_GADGETS_START = 1000
    ID_GADGET_GROUP = 0
    ID_GADGET_LABEL = 1
    ID_GADGET_TEXT = 2

    GADGETS_STRIDE = 10

    def __init__(self, objects: list[c4d.BaseObject]) -> None:
        """
        """
        self._objects = objects

    def CoreMessage(self, mid: int, msg: c4d.BaseContainer) -> bool:
        """Receives core messages.

        We react here to EVMSG_CHANGE to update all our object matrices. 
        EVMSG_CHANGE is the message for EventAdd(), i.e., is being fired 
        ALOT. To make this less throttling, we could also use 
        GeDialog.SetTimer and GeDialog.Timer to update the matrices in a
        fixed interval. What is better depends on how time-consuming you
        would consider your updates to be. But the timer approach will also
        consume process time when nothing changed. So, the best approach
        would be to mix the two. I.e., only react to EVMSG_CHANGE when a
        certain time span X has passed since the last time you did react to 
        it.
        """
        if mid == c4d.EVMSG_CHANGE:
            self.UpdateValues()

        return True

    def CreateLayout(self) -> bool:
        """Creates a static text and a text box for each tacked object.
        """
        self.SetTitle("ObjectTrackerDialog")
        for i, item in enumerate(self._objects):
            gid = self.ID_GADGETS_START + i * self.GADGETS_STRIDE
            name = item.GetName()

            self.GroupBegin(gid + self.ID_GADGET_GROUP, 
                c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, cols=2)
            self.AddStaticText(gid + self.ID_GADGET_LABEL, 
                c4d.BFH_LEFT | c4d.BFV_SCALEFIT, name=name)
            self.AddEditText(gid + self.ID_GADGET_TEXT, 
                c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT)
            self.GroupEnd()
        return True

    def InitValues(self) -> bool:
        """Initializes the dialog values.
        """
        return self.UpdateValues()

    def UpdateValues(self) -> bool:
        """Updates the dialog values.
        """
        for i, item in enumerate(self._objects):
            gid = gid = self.ID_GADGETS_START + i * self.GADGETS_STRIDE
            self.SetString(gid + self.ID_GADGET_TEXT, item.GetMg())
        return True

def main():
    """Creates an instance of the ObjectTrackerDialog.
    """
    items = doc.GetActiveObjects(c4d.GETACTIVEOBJECTFLAGS_NONE)
    if not isinstance(items, list) or len(items) < 1:
        raise RuntimeError("Please select at least one object.")
    # Please do not do this in a production environment. This is just a hack
    # to keep an async dialog alive from the script manager. Which will lead
    # to problems when used in production.
    global dialog
    dialog = ObjectTrackerDialog(items)
    dialog.Open(c4d.DLG_TYPE_ASYNC)

if __name__ == '__main__':
    main()

Hello @DGLopez,

thank you for reaching out to us. We will answer your question more thoroughly, but to be able to do so, we will need more information. Your topic is missing:

• The targeted operating systems expressed as tags on your topic.
• The plugin interface(s) used by the already running plugin.
• Provide code or a description of what the already running plugin is doing.
• Describe more precisely what you want to do exactly: Should the dragging be a tool which can be activated by the user, or should it happen all the time or should it only happen to specific objects?

Please read our Forum Guidelines for details on the support process.

Cheers,
Ferdinand

Hello @bonsak,

unfortunately, I still cannot reproduce your problem. Your script runs fine for me and does what its code tells it to do. One source of ambiguity might be your function MakeRSRaw().

def MakeRsRaw(renderdata, parent):
    raw = c4d.documents.RenderData() # Clone active renderdata
    raw.SetName("Redshift Raw") # Set name
    # ...

The comment in code and the fact that you say here in the thread 'i' am copying has non default values, the child will not get these values' implies that there is a misunderstanding. First of all, there is obviously no cloning going on in your code. You simply create a RenderData instance from scratch which then will also come with default values. Secondly, Inherent Parent Behavior does not mean that the node data are being copied over all the time. Which you do seem to expect when you expect a new instance of RenderData to automatically 'snap' to its parent. The option only means that a value is being copied over to the children when it is being edited on the parent. When you want the child to be a carbon copy of its parent form the getgo, you must either clone the parent or overwrite all values of the parent.

I would recommend our user manual for details on the topic, as it does explain it better than I do.

I hope this helps and cheers,
Ferdinand

Hello @delizade,

thank you for reaching out to us. Please remember to tag your topics also with the version(s) of Cinema 4D and OS you are targeting.

About your question: The answer to that is unfortunately not trivial. The take system of Cinema 4D is powerful, but that makes it sometimes hard to find general solutions for working with it programmatically. There is no general solution for "find all classic nodes that are somehow part of the active take". The reason for that is that classic nodes can be manipulated in many ways by takes. In your example it is the layers which are being manipulated and not the objects themselves you are after. So, you will need to find the layer(s) which are part of the active take and then the objects that are part of that layer.

We cannot provide full solutions, but I wrote a little example which goes into the direction you want to go. Please note that this is an example and that we can only answer specific follow up questions. We cannot improve the script so that it will fit your requirements, you will have to do that yourself.

I hope this helps and cheers,
Ferdinand

The result:

The code:

"""Example for iterating over all objects that are attached to a layer.

The script retrieves the layer to be tested for via the take system, looking
for a layer which is part of the overrides of the currently active take.

As discussed in:
    plugincafe.maxon.net/topic/13640
"""

import c4d

def Iterate(document, callback, **kwargs):
    """The iteration function, walking a document object graph depth first.
    
    Args:
        document (c4d.documents.BaseDocument): The document to iterate over.
        callback (callable): A callback to evaluate if a certain node should
         be yielded or not.
        **kwargs: The additional kw arguments for the callback.
    
    Yields:
        c4d.BaseObject: An object node within the document graph that did
         satisfy the callback.
    """
    node = document.GetFirstObject()
    visisted = []
    terminal = node.GetUp() if isinstance(node, c4d.GeListNode) else None

    while node:
        if node not in visisted:
            if callback(node, document, **kwargs):
                yield node
            visisted.append(node)

        if node.GetDown() and node.GetDown() not in visisted:
            node = node.GetDown()
        elif node.GetNext():
            node = node.GetNext()
        else:
            node = node.GetUp()

        if node == terminal:
            break

def MyCallback(node, document, **kwargs):
    """A little callback function which does test if a node should be yielded
    or not.

    We are testing here if the node is attached to the same layer as passed
    down via activeLayer to `Iterate`.
    """
    if not isinstance(node, c4d.BaseList2D):
        return False
    if "activeLayer" not in kwargs:
        return False
    return kwargs["activeLayer"] == node.GetLayerObject(document)

def main():
    """Entry point.
    """
    # Get the active take 
    takeData = doc.GetTakeData()
    baseTake = takeData.GetCurrentTake()

    # Iterate over all overrides to find the first override for a layer 
    # object. Bail the script when we cannot find any overrides for a layer.
    layer = None
    for item in baseTake.GetOverrides():
        if isinstance(item.GetSceneNode(), c4d.documents.LayerObject):
            layer = item.GetSceneNode()
            break
    if layer is None:
        raise RuntimeError("Could not find any layer object overrides.")

    # Iterate over all objects in the scene which are attached to that layer.
    for node in Iterate(doc, MyCallback, activeLayer=layer):
        print (node)


if __name__ == '__main__':
    main()

Hello @mfersaoui,

thank you for reaching out to us. Please remember adding the required tags to your postings as lined out in the Forum Guidelines. Your posting is missing information on the used OS and version of Cinema 4D. You should also formally say with a tag that this is about Python.

About your question: To answer your question formally, yes, it is possible to mirror tags hosted on the classic scene node that represents your ObjectData plugin. In GVO you get passed in that node as node, so you could clone its tags onto nodes you build in the cache. This is however a very unusual thing to do, since caches are caches, i.e., expressions inside a cache will not be evaluated.

It is also not necessary in the case of rigid body simulations since the engine will reach into caches on its own. Your example is not very illustrative for this example, since it does only contain a single cube. So, one could not distinguish if Cinema would treat it as one object or multiple objects, but my little Python generator example at the end of the posting contains twelve cubes and works fine.

So, there are not extra steps for you to do, just return a cache with multiple objects in it and then assign a rigid body tag to the plugin node and it should work. If this does not solve your question, I would have to ask to clarify what you want to do.

Cheers,
Ferdinand

The result:

The code:

"""Example for simple Python generator object that returns a cache containing 
multiple cube objects.

This example is meant to be host a rigid body simulation tag which will drive
the cube inside the cache.

As discussed in:
    plugincafe.maxon.net/topic/13641
"""

import c4d

OBJ_COUNT = 12

def main():
    """Simple generator that returns a cache containing multiple cube objects.
    """
    null = c4d.BaseList2D(c4d.Onull)
    if null is None:
        raise MemoryError("Could not allocate object.")

    for i in range(OBJ_COUNT):
        cube = c4d.BaseList2D(c4d.Ocube)
        if cube is None:
            raise MemoryError("Could not allocate object.")

        cube.SetMl(c4d.Matrix(off=c4d.Vector(i * 250., 0, 0)))
        cube.InsertUnder(null)

    return null

Hello @bonsak,

thank you for reaching out to us. Please remember to follow our Forum Guidelines regarding tagging your postings.

About your question: I cannot reproduce the behavior described by you on either S24 or R25. On which specific version and OS are you? I assume S24.110, but which OS? What might be a source for confusion is how that feature works in the first place. The command Inherit Parent Setting will simply copy over settings from the parent. It will always be grayed out when the parameter of the RenderData which is a child of another RenderData is already of the same value as the parameter of the parent. See end of my posting for details.

If this does not solve your problem, I would have to ask you to provide more precise information as lined out in the Forum Guidelines.

Cheers,
Ferdinand

edit: Hm, I could have sworn that the tags have not been there 5 minutes ago. Probably just getting old But It would be still necessary that you clarify the OS.

How Inherit Parent Setting works:

Hello @yaya ,

thank you for reaching out to us. The bracket syntax, i.e., overloading object.__getitem__, is a Python specific convenience method. The special flexibilty of Python's parameter syntax and how it does translate to DescID and DescLevel has been discussed multiple times here on the forum, e.g., here. For details on DescID, we would recommend reading our C++ manual for that type. See end of my posting for how your specific case would translate.

Cheers,
Ferdinand

// This example assumes that 50004 is a sub-container of integers ...

const DescLevel firstLevel (50004, DTYPE_SUBCONTAINER, 0);
const DescLevel secondLevel (0, DTYPE_LONG, 0);
const DescID someId = DescID(firstLevel, secondLevel);

// Assuming someNode is a pointer to some C4DAtom
GeData data;
if (!someNode->GetParameter(someId, data, DESCFLAGS_GET::NONE))
    // Do something to deal with failing to retrieve the parameter.
    // ...

// The value of the parameter.
const Int32 someParameterValue = data.GetInt32();

Hello @JohnTerenece,

thank you for reaching out to us. Unfortunately, our answer is mostly the same as it was for the previous topic on this plugin of yours.

1. You are using the MoData tags in a way not intended by us. It is not supported by our SDK to implement a custom MoGraph generator and you are therefore not intended to populate and manage your own MoData tags. There is nothing preventing you from doing it anyways, this however will then be out of scope of support as declared in our Forum Guidelines under "Scope of Support".
2. We cannot debug your code for you, especially when the employed techniques are a violation of point one listed here. This is also outlined in "Scope of Support".

You are also misusing the maxon API. Specifically, the error system, as you cannot just step over all errors which are returned. Which is what you do when you store them in some fields attached to your plugin implementation; never to be used or looked at again. Which can introduce all sorts of problems. The cases I saw do look unlikely to go wrong, but this is still a fundamental misuse of our API. See the end of my posting for details.

Finally, about your question. I would look at your CheckDirty(), since this is the likely culprit for your problems. But we cannot debug that for you. When you can show us that something is not being flagged as dirty what was flagged before, we will be glad to provide a context for that. Please also note that example code should be condensed as also outlined in our Forum Guidelines.

I understand that this is not the support you did hope for, but these limitations of scope of support must be enforced by us to a certain degree, as it would otherwise become a boundless task.

Thank you for your understanding,
Ferdinand

maxon::Result Example

What you do:

void EffectorTestClass::CheckDirty(BaseObject *op, BaseDocument *doc)
{
    // ...

    if (op->GetDown() != nullptr)
        // This could fail and you just step over it.
        resultBaseObject = objArray.Append(op->GetDown());

    // ...
    flags = data->GetFlags(doc, object);
    if ((flags & 1) == 1)
    {
        // This could fail and you just step over it.
        resultBaseObject = objArray.Append(object);
    }

    // ...
}

What you should do:

void EffectorTestClass::CheckDirty(BaseObject *op, BaseDocument *doc)
{
    // An error scope handler that brings the classic and maxon API together.
    iferr_scope_handler 
    {
        // you could also write to one of the loggers here, e.g.
        ApplicationOutput("Error in CheckDirty() @", err);
        return false;
    }
    // ...

    if (op->GetDown() != nullptr)
        objArray.Append(op->GetDown()) iferr_return;

    // ...
    flags = data->GetFlags(doc, object);
    if ((flags & 1) == 1)
    {
        objArray.Append(object) iferr_return;
    }

    // ...
}

Hello @camille-chigot,

without any further questions, we will consider this topic as solved by Monday, the 25th and flag it accordingly.

Thank you for your understanding,
Ferdinand

Hello @jwzegelaar,

without any further questions, we will consider this topic as solved by Monday, the 25th and flag it accordingly.

Thank you for your understanding,
Ferdinand

Hello @артём,

without any further questions, we will consider this topic as solved by Monday, the 25th and flag it accordingly.

Thank you for your understanding,
Ferdinand