m_adam

m_adam

settings[c4d.MDATA_BEVEL_RADIUS] = 0.5
Works fine here.

m_adam

Here in R19 it's working nicely. Let me know if you are able to reproduce the issue.

Cheers,
Maxime.

m_adam

Hi @del thanks for reaching us,
As you figured the new bevel tool is c4d.ID_XBEVELTOOL (431000015) (I will update the python documentation) but in order to make it work the recommended way is to use SendModelingCommand like so

import c4d

doc.StartUndo()

# Settings
settings = c4d.BaseContainer()
settings[c4d.MDATA_BEVEL_MASTER_MODE] = c4d.MDATA_BEVEL_MASTER_MODE_SOLID
settings[c4d.MDATA_BEVEL_RADIUS] = 5
settings[c4d.MDATA_BEVEL_SELECTION_PHONG_BREAK] = False

doc.AddUndo(c4d.UNDOTYPE_CHANGE, op)
res = c4d.utils.SendModelingCommand(command = c4d.ID_XBEVELTOOL,
                                list = [op],
                                mode = c4d.MODELINGCOMMANDMODE_EDGESELECTION,
                                bc = settings,
                                doc = doc)

doc.EndUndo()             
c4d.EventAdd()

You can find a list of all symbols in the cpp documentation of xbeveltool.h.
Cheers,
Maxime.

m_adam

I don't think effector is the best way to achieve that at least your effector could retrieve data only for the current generator/object it's currently sampling, so one object per time. So an effector does not have an idea of the whole picture.

The best way would be either to have a GeDialog that will monitor the scene and send the data (but that involve to make a plugin, it's not complicated but its an external file and not directly embedded within a C4D file)
Another solution could be to do a scripting tag, with the correct priority (so it's executed after mograph generation) which will retrieve all data you need. You could add an InExclude UserData to this tag so could drag and drop the cloner in the list and use this as an ID.

Anyway I adapted the example to make it work, with simple cloner (no nested), so the op object of the main method should be a cloner and it will tell you the color for each clone.

"""
Copyright: MAXON Computer GmbH
Author: Maxime Adam

Description:
    - Retrieves the color or each clone using two ways.
    - First one by accessing directly the Mograph Data.
    - Second one by accessing the polygon cache representation of the Mograph Cloner.

Class/method highlighted:
    - c4d.modules.mograph.GeGetMoData()
    - c4d.modules.mograph.MoData
    - MoData.GetArray()
    - BaseObject.GetCache()
    - BaseObject.GetDeformCache()

Compatible:
    - Win / Mac
    - R16, R17, R18, R19, R20
"""
import c4d


def RetrieveColorWithMoData(op):
    if not op.CheckType(1018544):
        raise TypeError("objects is not a cloner.")

    # Retrieves the modata
    md = c4d.modules.mograph.GeGetMoData(op)
    if md is None:
        return []

    # Retrieves the clone offset and the color array
    offset = op[c4d.MG_LINEAR_OFFSET]
    colorList = md.GetArray(c4d.MODATA_COLOR)

    # Appends the color list taking in account the offset (aka skip the first elements)
    return colorList[offset:]


def DeformedPolygonCacheIterator(op):
    """
    A Python Generator to iterate over all PolygonCache of passed BaseObject
    :param op: The BaseObject to retrieves all PolygonObject cache.
    """
    if not isinstance(op, c4d.BaseObject):
        raise TypeError("Expected a BaseObject or derived class got {0}".format(op.__class__.__name__))

    # Try to retrieves the deformed cache of the object
    temp = op.GetDeformCache()
    if temp is not None:
        # If there is a deformed cache we iterate over him, a deformed cache can also contain deformed cache
        # e.g. in case of a nested deformer
        for obj in DeformedPolygonCacheIterator(temp):
            yield obj

    # Try to retrieves the cache of the Object
    temp = op.GetCache()
    if temp is not None:
        # If there is a cache iterate over its, a cache can also contain deformed cache
        # e.g. an instance, have a cache of its linked object but if this object is deformed, then you have a deformed cache as well
        for obj in DeformedPolygonCacheIterator(temp):
            yield obj

    # If op is not a generator / modifier
    if not op.GetBit(c4d.BIT_CONTROLOBJECT):
        # If op is a PolygonObject we return it
        if op.IsInstanceOf(c4d.Opolygon):
            yield op

    # Then finally iterates over the child of the current object to retrieves all objects
    # e.g. in a cloner set to Instance mode, all clones is a new object.
    temp = op.GetDown()
    while temp:
        for obj in DeformedPolygonCacheIterator(temp):
            yield obj
        temp = temp.GetNext()


def RetrieveColorWithCache(op):
    # Iterates the polygon cache of a cloner (does work only, in case of simple instance mode)
    finalList = []
    # Iterates overs each polygon object cache
    for i, obj in enumerate(DeformedPolygonCacheIterator(op)):

        # Adds the object information in the last list
        finalList.append(obj[c4d.ID_BASEOBJECT_COLOR])

    return finalList


def main():
    # Checks if there is a selected object, and this selected object get a child object.
    if not op:
        raise RuntimeError("Failed to retrieves op")

    # Checks if selected object and child objects are cloner objects.
    if not op.CheckType(1018544):
        raise TypeError("objects is not cloner.")

    print RetrieveColorWithMoData(op)
    print RetrieveColorWithCache(op)


if __name__ == "__main__":
    main()

With that's said I think you have everything you need to build your stuff, at least for reading a cloner object.

The project looks cool, so even if it seems complicated don't give up and don't hesitate to ask questions !
Cheers,
Maxime.

m_adam

Then I'm afraid I still don't understand the final result, please be more explicit about what you are trying to achieve, what the expected behavior. In your first post, you said it's not working, but now I do have a scene example so please tell me what you want to achieve within the scene.

Cheers,
Maxime.

m_adam

Hoo sorry, I overlooked the fact that you are directly in a python effector and not in the script manager (in fact I missed to ask you, please next time try to say us, in which context you are executing python).

So I should have mentioned that the selected object should be the topmost cloner (the cloner of the cloner).
So with that's said, with my previous scrip use "gen" instead of op in main and it's fixed see Python Effector.
Here is the example cloner.c4d

Cheers,
Maxime.

m_adam

Hi, the topic is now marked as solved, did you solve your issue?

The only workaround I was able to find is to make use of AddToExecution and define it to GENERATOR+1, here you retrieve and clone the cache of the linked object in a member variable of your instance, then in the next GVO you make use of this cache, but this has the application that you work always on a mesh that has been generated in a previous SceneExecution call, which may be an issue in case of animation.

Cheers,
Maxime.

m_adam

Hi @Parvin, first of all, welcome in the plugincafe community!

Regarding your requestion, a cloner is simply a generator that will copy objects in its cache (like any generator), so in order to access the correct data, you should first access the cache of the first cloner then here you can iterates the cloner and query them for their color like so.

"""
Copyright: MAXON Computer GmbH
Author: Maxime Adam

Description:
    - Retrieves the color or each clone using two ways.
    - First one by accessing directly the Mograph Data.
    - Second one by accessing the polygon cache representation of the Mograph Cloner.

Class/method highlighted:
    - c4d.modules.mograph.GeGetMoData()
    - c4d.modules.mograph.MoData
    - MoData.GetArray()
    - BaseObject.GetCache()
    - BaseObject.GetDeformCache()

Compatible:
    - Win / Mac
    - R16, R17, R18, R19, R20
"""
import c4d


def RetrieveColorWithMoData(op):
    # Retrieving internal cache of the first cloner to access each cloner and query them.
    cacheMainClone = op.GetCache()
    if cacheMainClone is None:
        raise RuntimeError("Failed to retrieves the cached cloner.")

    # Cloner object creates a null, with all their clones. So we dive into this null, and it should be a cloner object
    clonerCache = cacheMainClone.GetDown()
    if not clonerCache.CheckType(1018544):
        raise TypeError("objects are not cloners.")

    # Iterates each cloner and retrieves the data for each one
    finalList = []
    while clonerCache:
        # Retrieves the modata
        md = c4d.modules.mograph.GeGetMoData(clonerCache)
        if md is None:
            continue

        # Retrieves the clone offset and the color array
        offset = clonerCache[c4d.MG_LINEAR_OFFSET]
        colorList = md.GetArray(c4d.MODATA_COLOR)

        # Appends the color list taking in account the offset (aka skip the first elements)
        finalList.append(colorList[offset:])

        # Process the next cloner
        clonerCache = clonerCache.GetNext()

    return finalList


def DeformedPolygonCacheIterator(op):
    """
    A Python Generator to iterate over all PolygonCache of passed BaseObject
    :param op: The BaseObject to retrieves all PolygonObject cache.
    """
    if not isinstance(op, c4d.BaseObject):
        raise TypeError("Expected a BaseObject or derived class got {0}".format(op.__class__.__name__))

    # Try to retrieves the deformed cache of the object
    temp = op.GetDeformCache()
    if temp is not None:
        # If there is a deformed cache we iterate over him, a deformed cache can also contain deformed cache
        # e.g. in case of a nested deformer
        for obj in DeformedPolygonCacheIterator(temp):
            yield obj

    # Try to retrieves the cache of the Object
    temp = op.GetCache()
    if temp is not None:
        # If there is a cache iterate over its, a cache can also contain deformed cache
        # e.g. an instance, have a cache of its linked object but if this object is deformed, then you have a deformed cache as well
        for obj in DeformedPolygonCacheIterator(temp):
            yield obj

    # If op is not a generator / modifier
    if not op.GetBit(c4d.BIT_CONTROLOBJECT):
        # If op is a PolygonObject we return it
        if op.IsInstanceOf(c4d.Opolygon):
            yield op

    # Then finally iterates over the child of the current object to retrieves all objects
    # e.g. in a cloner set to Instance mode, all clones is a new object.
    temp = op.GetDown()
    while temp:
        for obj in DeformedPolygonCacheIterator(temp):
            yield obj
        temp = temp.GetNext()


def RetrieveColorWithCache(op):
    # Iterates the polygon cache of a cloner (does work only, in case of simple instance mode)
    childClonerCnt = op.GetDown()[c4d.MG_LINEAR_COUNT]
    finalList = []
    # Iterates overs each polygon object cache
    for i, obj in enumerate(DeformedPolygonCacheIterator(op)):
        # For each new list we add a new list
        d = float(i) / float(childClonerCnt)
        if float(d) == int(d):
            finalList.append([])

        # Adds the object information in the last list
        finalList[-1].append(obj[c4d.ID_BASEOBJECT_COLOR])

    return finalList


def main():
    # Checks if there is a selected object, and this selected object get a child object.
    if not op or not op.GetDown():
        raise RuntimeError("Failed to retrieves op and its child.")

    # Checks if selected object and child objects are cloner objects.
    if not op.CheckType(1018544) or not op.GetDown().CheckType(1018544):
        raise TypeError("objects are not cloners.")

    print RetrieveColorWithMoData(op)
    print RetrieveColorWithCache(op)


if __name__ == "__main__":
    main()

Don't worry since it's your first topic, in order to setup correctly your next topics (I've done it for this one) please read and apply:

Of course, if you have any question, please let me know.
Cheers,
Maxime.

m_adam

Hi @bentraje,

In order to support undo, you should encapsulate all your calls of BaseDocument.AddUndo with BaseDocument.StartUndo and BaseDocument.EndUndo
Moreover, take care depending on the operation you are doing, BaseDocument.AddUndo has to be called before or after your operation. Take a look at the documentation to know more.

Typically StartUndo, defines the state of the scene to be reverted when pressing undo. And EndUndo the state of the scene to be reverted when pressing re-do after an undo.
AddUndo then record all the changes that you want to store in this undoing.

Which will give us something like:

import c4d

# Main function
def main():
    # Create the BaseContainer to define the tool settings
    settings = c4d.BaseContainer()  
    
    # Explicitly say we will not use point, so the center will be used
    settings[c4d.MDATA_WELD_TOPOINT] = False
    
    doc.StartUndo()
	
    doc.AddUndo(c4d.UNDOTYPE_CHANGE, op)
    # Execute the SendModelingCommand
    res = c4d.utils.SendModelingCommand(command = c4d.ID_MODELING_WELD_TOOL,
                                    list = [op], 
                                    mode = c4d.MODELINGCOMMANDMODE_POLYGONSELECTION, 
                                    bc = settings, 
                                    doc = doc)
                                    
    doc.EndUndo()
	
    # Update the scene
    c4d.EventAdd()

# Execute main()
if __name__=='__main__':
    main()

To find more information about how ID_MODELING_WELD_TOOL works, you can have a look at this topic.

If you have any question, please let me know.
Cheers,
Maxime.

m_adam

Hi @anoano.

I will need more information.
I'm not sure in which context you are, when you say virtual object I think you refer to be inside of a Generator and the GetVirtualObjects method isn't?

Moreover, when you say a link, you refer to a LinkBox parameter, so the linked object can be anywhere and not necessary a Child of the current Generator, isn't?

Last stuff, please make sure to mark your topic as a question. I've done it for this time (don't worry you are new, no issue at all), see Q&A New Functionality.

Cheers,
Maxime.

m_adam

@m_adam

Posts made by m_adam