@bentraje take a look at the official gedialog_ask_number example.

Cheers,
Maxime.

The correct way would be to have a timer or to forward the GetState method from the CommandData to the GeDialog. And in this method call GeDialog.Enable(buttonId, False).

Let me know if it fulfills your needs.
Cheers,
Maxime.

Hi @bentraje The python doc should be improved in this regard.
If you look at the C++ doc you will see that SetMode is not the correct way to go to convert internal data, but SetParameter.
SetMode only defines how the tag should read the internal data stored.

Additionally, you may found the C++ CAMorph Manual interesting.

Cheers,
Maxime.

Hi @pyr first of all, in Cinema 4D there is no object that behaves like that. So it's not officially supported but you can get it to work.

With that's said I would like to ask for more information.

• Do you need input objects?
• Should your object be considered as a spline object or only returning a spline is enough (aka returning a spline into a null)?

Note that few examples in the GitHub repository can help you:

• double_circle, outputs a spline, like a circle spine.
• osffset_y_spline, offsets a spline, based on another input spline.
• rounded_tube, creates an object like the cube object.

Cheers,
Maxime.

Hi @bentraje you can use BITMAPBUTTON_FORCE_SIZE
The python documentation is wrong is not a boolean but an int (It will be fixed in the next documentation update).

So you can define it as:
bcBitmapButton[c4d.BITMAPBUTTON_FORCE_SIZE] = 12

Cheers,
Maxime.

Hi @gsmetzer please read and apply for your next topics:

• Q&A New Functionality
• How to Post Questions

Regarding your issue.
a Marker is a BaseList2D, which is also a GeListNode. So you can call GeListNode.Remove

However, note that you are in a generator and a generator is not supposed to change the scene structure (aka add a new object to it (and a marker is a new object). For more information see Threading Information. The correct way to do it would be to create a CommandData plugin.

Cheers,
Maxime.

Hi @myosis unfortunately, it's not exposed and only defined in the dialog.

You can access the SizeFactor from the WorldContainer with the ID 25085 like so c4d.GetWorldContainer()[25085].

Cheers,
Maxime.

Hi, can you add a screenshot about what you are referring to within Cinema 4D.

Cheers,
Maxime.

Hi sorry for the late reply, unfortunately it's a limitation of the sweep nurbs, since he was rewritten. So you need to create it again and rewire things.

Sorry about it.
Cheers,
Maxime.

@mfersaoui Yes it's safe.

Find an example below, that does what I described previously:

class BakeObject(c4d.plugins.ObjectData):
    """BakeObject Generator"""

    def __init__(self, *args):
        super(BakeObject, self).__init__(*args)
        self.SetOptimizeCache(True)


    def GetVirtualObjects(self, op, hierarchyhelp):
        """
        This method is called automatically when Cinema 4D ask for the cache of an object. This is also the place
        where objects have to be marked as input object by Touching them (destroy their cache in order to disable them in Viewport)
        :param op: The Python Generator
        :type op: c4d.BaseObject.
        :param hh: The hierarchy helper.
        :type hh: c4d.HierarchyHelp (currently a PyObject).
        :return: The Representing object (c4d.LineObject or SplineObject)
        """
        sphere = c4d.BaseObject(c4d.Osphere)
        sphere[c4d.PRIM_SPHERE_SUB] = 48
        sphere.MakeTag(c4d.Tphong)

        return sphere

    def Message(self, node, msgId, data):
        """
        Called by Cinema 4D part to notify the object to a special event
        :param node: The instance of the ObjectData.
        :type node: c4d.BaseObject
        :param msgId: The message ID type.
        :type msgId: int
        :param data: The message data.
        :type data: Any, depends of the message passed.
        :return: Depends of the message type, most of the time True.
        """

        if msgId==c4d.MSG_DESCRIPTION_COMMAND:
            if data['id'][0].id==1006:
                if node.GetCache() is None:
                    return True

                # Make sure no other thread are running
                c4d.StopAllThreads()

                # Retrieves a clone of the current object's cache.
                cacheClone = node.GetCache().GetClone()


                # Insert it into the current doc
                node.GetDocument().InsertObject(cacheClone)

                # Performs a Current State to Object to retrieve a polygonObject.
                resultCSTO = c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_CURRENTSTATETOOBJECT, list=[cacheClone], doc=node.GetDocument())
                if not isinstance(resultCSTO, list) or not resultCSTO:
                    cacheClone.Remove()
                    raise RuntimeError("Failed to perform MCOMMAND_CURRENTSTATETOOBJECT.")
                
                polygonizedCache = None

                if resultCSTO[0].CheckType(c4d.Opolygon):
                    polygonizedCache = resultCSTO[0]

                # If the results is a Null, performs a Join command to retrieve only one object.
                elif resultCSTO[0].CheckType(c4d.Onull):
                    resultJoin = c4d.utils.SendModelingCommand(command=c4d.MCOMMAND_JOIN, list=[resultCSTO[0]], doc=node.GetDocument())
                    if not isinstance(resultJoin, list) or not resultJoin:
                        cacheClone.Remove()
                        for obj in resultCSTO:
                            obj.Remove()
                        raise RuntimeError("Failed to perform MCOMMAND_JOIN.")

                    polygonizedCache = resultJoin[0]

                # Remove the cached clone of our Generator from the document since we get the poligonalized version of it
                cacheClone.Remove()

                if polygonizedCache is None:
                    return True

                # Now that we have a PolygonObject we can perform our baking
                # First we need a glossy material, so lets create it
                glossyMat = c4d.Material()

                # Disables teh color channel
                glossyMat[c4d.MATERIAL_USE_COLOR] = False

                # Removes the default specular layer
                glossyMat.RemoveReflectionLayerIndex(0)

                # Adds a layer
                layer = glossyMat.AddReflectionLayer()

                # Sets the Layer to GGX mode
                glossyMat[layer.GetDataID() + c4d.REFLECTION_LAYER_MAIN_DISTRIBUTION] = c4d.REFLECTION_DISTRIBUTION_GGX

                # Defines the Roughness float value
                glossyMat[layer.GetDataID() + c4d.REFLECTION_LAYER_MAIN_VALUE_ROUGHNESS] = 0.0

                # Defines the Reflection float value
                glossyMat[layer.GetDataID() + c4d.REFLECTION_LAYER_MAIN_VALUE_REFLECTION] = 1.0

                # Inserts glossy mat and the polygonized object into the document
                node.GetDocument().InsertMaterial(glossyMat)
                node.GetDocument().InsertObject(polygonizedCache)

                # Assigns the glossy Mat to the Polygonized Object
                textureTag = polygonizedCache.MakeTag(c4d.Ttexture)
                textureTag[c4d.TEXTURETAG_MATERIAL] = glossyMat
                
                # Now we can start the bake process
                bakeData = c4d.BaseContainer()
                bakeData[c4d.BAKE_TEX_WIDTH] = 512
                bakeData[c4d.BAKE_TEX_HEIGHT] = 512

                bakeData[c4d.BAKE_TEX_USE_PHONG_TAG] = True
                bakeData[c4d.BAKE_TEX_CONTINUE_UV] = True

                bakeData[c4d.BAKE_TEX_COLORPROFILE] = c4d.bitmaps.ColorProfile.GetDefaultLinearRGB()
                bakeData[c4d.BAKE_TEX_FILL_COLOR] = c4d.Vector(0.0)
                bakeData[c4d.BAKE_TEX_PIXELBORDER] = 12
                bakeData[c4d.BAKE_TEX_REFLECTION] = True

                bakeData[c4d.BAKE_TEX_UV_LEFT] = 0.0
                bakeData[c4d.BAKE_TEX_UV_RIGHT] = 1.0
                bakeData[c4d.BAKE_TEX_UV_TOP] = 0.0
                bakeData[c4d.BAKE_TEX_UV_BOTTOM] = 1.0

                # Initialize the Baking
                bakeInfo = c4d.utils.InitBakeTexture(node.GetDocument(), textureTag, polygonizedCache.GetTag(c4d.Tuvw), polygonizedCache.GetTag(c4d.Tuvw), bakeData)
                bakeDoc = bakeInfo[0]
                bakeStatus = bakeInfo[1]
                if bakeStatus != c4d.BAKE_TEX_ERR_NONE or bakeDoc is None:
                    polygonizedCache.Remove()
                    glossyMat.Remove()
                    return True

                # Bake as a 32bit
                bakeBmp = c4d.bitmaps.MultipassBitmap(512, 512, c4d.COLORMODE_RGBf)
                bakeStatus = c4d.utils.BakeTexture(bakeDoc, bakeData, bakeBmp, c4d.threading.GeGetCurrentThread(), self.BakeTextureHook)

                if bakeStatus != c4d.BAKE_TEX_ERR_NONE:
                    polygonizedCache.Remove()
                    glossyMat.Remove()
                    return True

                # Dispay the baking result
                c4d.bitmaps.ShowBitmap(bakeBmp)

                # Cleanup temp stuff
                polygonizedCache.Remove()
                glossyMat.Remove()

                return True
        return True

    def BakeTextureHook(self, info):
        # Texture Baker hook, currently not used
        # print info
        pass

Cheers,
Maxime.