Hi @jenandesign, first of all, welcome in the plugincafe community.

No worry at all, since it's your first post, but I would like to point you about few rules in order to properly ask questions in this forum for future ones (I've set up this one).

• How to Post Questions (Especially the tagging system).
• Q&A New Functionality.

With that's said. Regarding your question. I get it to work (a bit hacky) but it's working.
When C4D render a scene, actually the whole scene is cloned in memory and then it renders this one. (It allow a user to still work on C4D while the other scene is rendering).
So this render scene is read-only, you shouldn't modify at anytime anything in this scene, or you can screw up the render.
Moreover in a shaderData, in order to optimize memory, only relevant information (aka polygon, UV) are copied. So you are losing your UserData.
This means you have to find another way to find your effector.
So the way I find to achieve what you want is to get the document from the object passed to the shader(the rendered document).
Then in this document, I search for an effector called "Plain" (Not the most robust way but it's working).

Then here the final code I put on the python color channel of a sketch and toon

import c4d

def main():
    doc = op.GetDocument()
    effector = doc.SearchObject("Plain")
    if not effector: return c4d.Vector()
    
    eff =  c4d.modules.mograph.C4D_Falloff()
    if not eff: return c4d.Vector()
    eff.InitFalloff(bc=effector.GetData())

    eff.SetMg(effector.GetMg())
    eff.SetMode(effector[c4d.FALLOFF_MODE])

     # World position currently sampled
    value = eff.Sample(wPnt, False)
    return c4d.Vector(value)

And the attached scene where a plain effector drives a mograph effector and the sketch and toon shader.
0_1542626486830_SketchAndToon.c4d

If you have any questions, please let me know!
Cheers,
Maxime!

Hi @merkvilson first of all pip and Niklas localimport module is completely two different things.

• pip is a python module manager (similar to package manager in unix). This means once it's installed to a python binary, it will be able to manage other modules, download them, install them with all their dependencies and update them and so on.
• localimport is a python module that let you manage import in a local way while in Cinema 4D by default is global. For more information please read how the import function works in python.
  Meaning if you add a module named xyz to the sys.path from your plugin A and from plugin B you try to import another module named xyz, it will load the one from plugin A (the first one register).

Now how to install pip?

1. Downloads https://bootstrap.pypa.io/get-pip.py.
2. Downloads the c4dpy version matching your Cinema 4D version. (Already included in R21)
3. Moves c4dpy and get-pip.py in the Cinema 4D folder.
4. Opens a shell to the Cinema 4D folder:
   • Window: Type cmd in the top path and press Enter.
   • Mac: Open a new shell, then with cd navigate to your Cinema 4D folder. (You can drag and drop the path).
5. Runs this command line c4dpy get-pip.py. This will execute the get-pip script which will, download and install the pip module.
6. Now you can start to play with pip c4dpy -m pip install numpy. c4dpy allow to runs any module with the -m argument see c4dpy commandline. in this case I asked to pip to download and install numpy but any other 3rd party compatible with pip can be downloaded and used.

With that's said we do not provide support for 3rd party modules, so if it does not work with Cinema 4D Python environment, we can't help you.

Cheers,
Maxime.

Hi @kisaf,

MCOMMAND_MIRROR is indeed a bit special because when you click on the Apply button from the GUI, it does send a message to some c4d elements, then these elements read MDATA_MIRROR_VALUE, MDATA_MIRROR_SYSTEM and MDATA_MIRROR_PLANE calculates values for MDATA_MIRROR_POINT and MDATA_MIRROR_VECTOR and then call the SendModelingCommand. Unfortunately, there is no way for you to send this message, and the best way to do it is to recalculate the stuff as bellow.

import c4d


def main():
    # Checks if selected object is valid
    if op is None:
        raise ValueError("op is none, please select one object.")

    # Defines some general settings, take care MDATA_MIRROR_VALUE, MDATA_MIRROR_SYSTEM and MDATA_MIRROR_PLANE
    settings = c4d.BaseContainer()
    settings[c4d.MDATA_MIRROR_DUPLICATE] = True
    settings[c4d.MDATA_MIRROR_SELECTIONS] = True
    settings[c4d.MDATA_MIRROR_ONPLANE] = True
    settings[c4d.MDATA_MIRROR_WELD] = True
    settings[c4d.MDATA_MIRROR_TOLERANCE] = 0.01

    # Corresponds to MDATA_MIRROR_VALUE, MDATA_MIRROR_SYSTEM and MDATA_MIRROR_PLANE
    value = 1000.0
    system = 0 # 0 = Object, 1 = World
    plane = 1 # 0 = XY, 1 = ZY, 2 = XZ

    if not 0 <= system < 2:
        raise ValueError("System can only be 0 or 1")

    # Buffer position vector
    pos = c4d.Vector()

    # Calculates Local (Object) coordinates
    if system == 0:
        globalMatrix = op.GetMg()
        if plane == 0:
            pos = globalMatrix.v3
        elif plane == 1:
            pos = globalMatrix.v1
        elif plane == 2:
            pos = globalMatrix.v2

        settings[c4d.MDATA_MIRROR_POINT] = globalMatrix.off + pos * value
        settings[c4d.MDATA_MIRROR_VECTOR] = pos

    # Calculates World coordinates
    elif system == 1:
        if plane == 0:
            pos = c4d.Vector(0.0, 0.0, 1.0)
        elif plane == 1:
            pos = c4d.Vector(1.0, 0.0, 0.0)
        elif plane == 2:
            pos = c4d.Vector(0.0, 1.0, 0.0)

        settings[c4d.MDATA_MIRROR_POINT] = pos * value
        settings[c4d.MDATA_MIRROR_VECTOR] = pos

    # Send the Modeling Operation
    res = c4d.utils.SendModelingCommand(c4d.MCOMMAND_MIRROR,
                                        [op],
                                        c4d.MODELINGCOMMANDMODE_ALL,
                                        settings,
                                        doc)

    c4d.EventAdd()


if __name__ == "__main__":
    main()

Hope it solves your issue, if you have any question, please let me know.
Cheers,
Maxime.

So regarding your script why it crashes, it's simply because you make an infinite loop with this code since you add each time something more to iterate.

for idx in newPos:
    newPos.append(GlobalToLocal(oldObject, idx))

Just to make it cleaner I've called objA and objB.
Then the needed steps are:

1. Get World Position from points of objB.
2. Convert these World Position in the local space of objA.

So as you may be already aware regarding our Matrix Fundamentals where is how to achieve both operations.

• Local Position to World Position corresponds to the obj global matrix where the position is locals to multiplied by the local position.
• World Position to Local Position corresponds to the inverse obj global matrix where the position will be locals multiplied by the world position.

Finally, before providing with the solution I would like to remind you to please always execute your code in the main function. The main reason is that if you transform your script as a button in the Dialog, every code that is in the global scope of your script is executed for each redraw of the Cinema 4D GUI (which is pretty intensive!). Moreover please always check for objects, if they exist or not try to adopt a defensive programming style in order to avoid any issues.

import c4d

def main():
    # Declares object variables
    ObjA = doc.SearchObject("A")
    ObjB = doc.SearchObject("B")

    # Checks if objects are found
    if ObjA is None or ObjB is None:
        raise ValueError("Can't found a and b object")

    # Checks if they are polygon object
    if not isinstance(ObjA, c4d.PolygonObject) or not isinstance(ObjB, c4d.PolygonObject):
        raise TypeError("Objects are not PolygonObject")

    # Checks Point count is the same for both obj
    allPtsObjA = ObjA.GetAllPoints()
    allPtsObjB = ObjB.GetAllPoints()
    if len(allPtsObjA) != len(allPtsObjB):
        raise ValueError("Object does not get the same pount count")

    # Retrieves all points of B in World Position, by multipling each local position of ObjB.GetAllPoints() by ObjB.GetMg()
    allPtsObjBWorld = [pt * ObjB.GetMg() for pt in allPtsObjB]

    # Retrieves All points of B from World to Local Position of ObjA, by multipling each world position of ObjB by the inverse objA.GetMg()
    allPtsObjANewLocal = [pt * ~ObjA.GetMg() for pt in allPtsObjBWorld]
    
    # Sets New points position
    ObjA.SetAllPoints(allPtsObjANewLocal)
    ObjA.Message(c4d.MSG_UPDATE)
    
    # Updates Cinema 4D
    c4d.EventAdd()

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

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

Hi @mikeudin, due to how our Classic Python API is built deepcopy does not work since our python objects only store pointer to our internal C++ object and not directly to other Python objects, so deepcopy fail in this regards since, the deepcopy operation, free and try to recreate these data, which is not possible since they are not PyObject but real C++ object but copy.copy does works, but since it's a shallow copy operation it only works for one level (e.g. a dict of dict of DescID will fail).

For more information about the difference please read Shallow vs Deep Copying of Python Objects.

However here a couple methods to copy a dict.

import copy
dict1 = {'1':dId_one,'2':dId_two}
dict2 =  copy.copy(dict1)

dict1 = {'1':dId_one,'2':dId_two}
dict2 =  dict1.copy()

dict1 = {'1':dId_one,'2':dId_two}
dict2 =  dict(dict1)

Cheers,
Maxime.

Hi @mike, first of all I would like to remind you to read and use the Q&A functionnality.

Regarding your question, here is an example of a basic GeDialog, which make use to SetFloat to define a range.

import c4d

class MonDlg( c4d.gui.GeDialog):
    idSlider = 1000
    idButton = 1001

    # Create the Layout
    def CreateLayout(self):
        self.AddEditSlider(self.idSlider, c4d.BFH_SCALE|c4d.BFV_SCALE, initw=100, inith=20)
        self.AddButton(self.idButton, c4d.BFH_SCALE|c4d.BFV_SCALE, initw=100, inith=20,name = 'Get Value')	
        return True

    # Called after CreateLayout
    def InitValues(self):
        self.SetFloat(self.idSlider, 0.25, min=0.0, max=1.0, step=0.01, min2=0.0, max2=0.0)
        return True

    # Called for each interaction from a widget
    def Command(self, id, msg):
        if id == self.idButton:
            print self.GetFloat(self.idSlider)
        
        return True

def main():
    dlg = MonDlg()
    dlg.Open(c4d.DLG_TYPE_MODAL)

if __name__=='__main__':
    main()

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

Hi @chuanzhen actually the problem interested me and I took some personal time on my weekend to do some tests.

I did 2 test scenes, which was a cube with 163970 points driven by 3 joints
With your original source code 0.53 fps
optimize python: 1.09 fps (x2.05)
C++: 19.36 fps (x36.52)

And the other one was the same cube but driven by 11 joints.
With your original source code 0.37 fps
optimize python: 0.64 fps (x1.73)
C++: 12.08 (x32.65)

So here is the optimized python code. As you can see I try to avoid as much as possible doing operation in the nested loop.

class newskin(plugins.ObjectData):
 
    lasttagdirty = None   #for weight change update
    jointdir = None       #for joint change update
    cachedir = None       #for other bindmesh check
 
    def CheckDirty(self, op, doc):
        #check first run
        if op[c4d.NEWSKINTAG] is None:
            op.SetDirty(c4d.DIRTYFLAGS_DATA)
            return
 
        #check weight change
        if op[c4d.NEWSKINTAG].GetDirty(c4d.DIRTYFLAGS_DATA) != self.lasttagdirty:
            op.SetDirty(c4d.DIRTYFLAGS_DATA)
            return
 
        #check matrix change
        checktime = op[c4d.NEWSKINTAG].GetJointCount()
        cdirty = 0
 
        for i in xrange(checktime):
            cdirty += op[c4d.NEWSKINTAG].GetJoint(i).GetDirty(c4d.DIRTYFLAGS_MATRIX)
 
        if cdirty != self.jointdir or self.cachedir != op[c4d.NEWSKINCHECK].GetDirty(c4d.DIRTYFLAGS_CACHE):
            op.SetDirty(c4d.DIRTYFLAGS_DATA)
            return
 
        return
 
   
    def ModifyObject(self, mod, doc, op, op_mg, mod_mg, lod, flags, thread):
 
        if mod[c4d.NEWSKINTAG] is None or mod[c4d.NEWSKINCHECK] is None:
            return True
 
        tag = mod[c4d.NEWSKINTAG]
        self.lasttagdirty = tag.GetDirty(c4d.DIRTYFLAGS_DATA)  #get current weight tag dirty
        self.cachedir = mod[c4d.NEWSKINCHECK].GetDirty(c4d.DIRTYFLAGS_CACHE)    #get bindmesh check
        plist = [pos * op_mg for pos in op.GetAllPoints()]
        pcount = op.GetPointCount()  
        jcount = tag.GetJointCount()
        self.jointdir = 0
 
        for m in xrange(jcount):
            joint = tag.GetJoint(m)
            self.jointdir += joint.GetDirty(c4d.DIRTYFLAGS_MATRIX)   #all joint current matrix dirtycount
 
        temp = c4d.Vector()
        for n in xrange(pcount):    #n:point index  
            temp %= temp
 
            for m in xrange(jcount):
                joint = tag.GetJoint(m)
                weight = tag.GetWeight(m, n)
 
                if not weight :
                    continue  
 
                cjmg = joint.GetMg()
                jdict = tag.GetJointRestState(m)
                jmg = jdict["m_bMg"]
                jmi = jdict["m_bMi"]
 
                temp += weight * cjmg * jmi * plist[n]  #defrmer global pos
            plist[n] = temp
       
        plist = [~op_mg * pos for pos in plist]
        op.SetAllPoints(plist)
        op.Message(c4d.MSG_UPDATE)
 
        return True

And here the C++ version (compatible R20 only). It uses paralellFor, not sure it's really worth didn't do proper profiling about it but I wanted to try them. Moreover please do not consider my C++ code has fully optimized since you could probably improve it depending on the situation.

#include "c4d_symbols.h"
#include "main.h"
#include "c4d_objectdata.h"
#include "lib_ca.h"

// Local resources
#include "oskinmodifier.h"
#include "maxon/parallelfor.h"
#include "maxon/basearray.h"

/**A unique plugin ID. You must obtain this from http://www.plugincafe.com. Use this ID to create new instances of this object.*/
static const Int32 ID_OBJECTDATA_SKINMODIFIER = 1000002;

class SkinModifier : public ObjectData
{
	INSTANCEOF(SkinModifier, ObjectData)

public:
	static NodeData* Alloc() { return NewObj(SkinModifier) iferr_ignore("SkinModifier plugin not instanced"); }

	virtual void CheckDirty(BaseObject *op, BaseDocument *doc);
	virtual Bool ModifyObject(BaseObject* mod, BaseDocument* doc, BaseObject* op, const Matrix& op_mg, const Matrix& mod_mg, Float lod, Int32 flags, BaseThread* thread);

private:

	BaseList2D* GetBaseLink(BaseObject* op, DescID id, Int excepted);
	Int lasttagdirty; /// get current weight tag dirty
	Int jointdir;
	Int cachedir;
};

void SkinModifier::CheckDirty(BaseObject *op, BaseDocument *doc)
{
	BaseList2D* t = GetBaseLink(op, DescID(NEWSKINTAG), Tweights);
	BaseList2D* l = GetBaseLink(op, DescID(NEWSKINCHECK), Opolygon);
	if (!t || !l)
		return;

	PointObject* linkOp = static_cast<PointObject*>(l);
	CAWeightTag* tag = static_cast<CAWeightTag*>(t);

	// check first run
	if (!tag)
	{
		op->SetDirty(DIRTYFLAGS::DATA);
		return;
	}

	// check weight change
	if (tag->GetDirty(DIRTYFLAGS::DATA) != lasttagdirty)
	{
		op->SetDirty(DIRTYFLAGS::DATA);
		return;
	}

	// check matrix change
	Int cdirty = 0;
	for (Int i = 0; i < tag->GetJointCount(); i++)
	{
		cdirty += tag->GetJoint(i, tag->GetDocument())->GetDirty(DIRTYFLAGS::MATRIX);
		if (cdirty != jointdir || cachedir != linkOp->GetDirty(DIRTYFLAGS::CACHE))
		{
			op->SetDirty(DIRTYFLAGS::DATA);
			return;
		}
	}

	return;
}

BaseList2D* SkinModifier::GetBaseLink(BaseObject* op, DescID id, Int excepted)
{
	GeData data;
	if (!op->GetParameter(id, data, DESCFLAGS_GET::NONE))
		return nullptr;

	return data.GetLink(op->GetDocument(), excepted);
}


Bool SkinModifier::ModifyObject(BaseObject* mod, BaseDocument* doc, BaseObject* op, const Matrix& op_mg, const Matrix& mod_mg, Float lod, Int32 flags, BaseThread* thread)
{
	if (!mod || !op || !doc || !thread)
		return false;

	BaseList2D* t = GetBaseLink(mod, DescID(NEWSKINTAG), Tweights);
	BaseList2D* l = GetBaseLink(mod, DescID(NEWSKINCHECK), Opolygon);
	if (!t || !l)
		return false;

	PointObject* linkOp = static_cast<PointObject*>(l);
	CAWeightTag* tag = static_cast<CAWeightTag*>(t);

	lasttagdirty = tag->GetDirty(DIRTYFLAGS::DATA);
	cachedir = linkOp->GetDirty(DIRTYFLAGS::CACHE);

	PointObject* pObj = ToPoint(op);
	const Vector * pListR = pObj->GetPointR();
	Vector * pListW = pObj->GetPointW();

	const Int pcount = pObj->GetPointCount();
	const Int jcount = tag->GetJointCount();
	jointdir = 0;

	for (Int i = 0; i < jcount; i++)
	{
		BaseObject* joint = tag->GetJoint(i, doc);
		jointdir += joint->GetDirty(DIRTYFLAGS::MATRIX);
	}


	auto worker = [jcount, op_mg, &pListR, &pListW, &doc, &tag](maxon::Int i)
	{
		Vector temp;
		Vector pos = op_mg * pListR[i];

		for (Int m = 0; m < jcount; m++)
		{
			Vector pos = op_mg * pListR[i];
			BaseObject* joint = tag->GetJoint(m, doc);
			Float weight = tag->GetWeight(m, i);

			if (weight == 0.0)
				continue;

			Matrix cjmg = joint->GetMg();
			JointRestState jrest = tag->GetJointRestState(m);
			Matrix jmg = jrest.m_bMg;
			Matrix jmi = jrest.m_bMi;

			temp += weight * cjmg * jmi * pos;
		}
		pListW[i] = ~op_mg * temp;
	};

	maxon::ParallelFor::Dynamic(0, pcount, worker);

	// Notify Cinema about the internal data update.
	op->Message(MSG_UPDATE);

	return true;
}

Bool RegisterSkinModifier()
{
	return RegisterObjectPlugin(ID_OBJECTDATA_SKINMODIFIER, "C++ oskinmodifier"_s, OBJECT_MODIFIER, SkinModifier::Alloc, "oskinmodifier"_s, nullptr, 0);
}

Cheers,
Maxime.

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

Don't worry, since it's your first topic, I've set up your topic correctly. But please for your next topics, use the Q&A functionnaly, make sure to also read How to Post Questions.

With that's said you can find the manual about SetDParameter in the C++ docs which will be trigger each time a user changes a value in the description of your tag. And also the C++ manual about GetDDescription.
Here a quick example of the implementation in python

    extensions = ["exr","hdr","jpg","png"]

    # Called by C4D when loading description
    def GetDDescription(self, node, description, flags):
        data = node.GetDataInstance()
        if data is None:
            return False

        # Load the description
        if not description.LoadDescription(node.GetType()):
            return False

        # If there is no description for c4d.TESTSCALE, we create it. Otherwise we override it and set DESC_CYCLE with our extensions list.
        singleID = description.GetSingleDescID()
        paramID = c4d.DescID(c4d.TESTSCALE)
        if singleID is None or paramID.IsPartOf(singleID)[0]:
            bcParam = description.GetParameterI(c4d.TESTSCALE)

            items = c4d.BaseContainer()
            for i, extension in enumerate(self.extensions):
                items.SetString(i, extension)

            bcParam[c4d.DESC_CYCLE] = items

        return (True, flags | c4d.DESCFLAGS_DESC_LOADED)

    # Called when a parameter is Set
    def SetDParameter(self, node, id, t_data, flags):
        if not node:
            return

        # called when the filename is changed. We add the path to our list and we return c4d.DESCFLAGS_PARAM_SET to inform c4d the paramaters is just sets
        if id[0].id == c4d.STRINGTEST:
            self.extensions.append(t_data)
            return (True, flags | c4d.DESCFLAGS_PARAM_SET)

        return False

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

Hi @Ashton_FCS_PluginDev, we are glad to see you back in the new plugincafe community!
No worries at all since it's your first post here, but please make sure to read and apply the rules defined on the following topics:

• How to Post Questions.
• Q&A Functionality.

Regarding your issue, you read m_spec, but you never check if there is a bitmashader in it or not. And in your case, there is no, so m_spec is set to None, and you are then trying to access value.
So please always check for None.
Then since you directly read the BITMAPSHADER_FILENAME parameter from this shader, please also consider to check the shader type you retrieve, maybe a user used a noise and not a bitmap.

m_spec = userMat[c4d.MATERIAL_REFLECTION_SHADER]
if not m_spec or m_spec.CheckType(c4d.Xbitmap):
    continue

Finally, as you may already be aware, reflection gets multiple layers. You get some information in this thread, how to deal with it.

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

Hi @mike,
No worries at all since, but please make sure to read and apply the rules defined on the following topics:

• Q&A Functionality.

Regarding your question, you can make use of the Shift Priority Tags. You can find more information on the priority in the c4d help.

But C4D also offer the Shift Priority Tag.
Finally, note in some case it can be a limitation of the viewport which not refresh properly while data are correctly set.
And you need to manually refresh the viewport.

Hope it solves your issue, if you have any question please let me know!
Cheers,
Maxime!

Hi sorry for the late reply, just in case I'm still on it...
However, the issue seems to happen only if the root is a GeListNode, if you use a python list instead, then it's working nicely.

Cheers,
Maxime.

See Building R23 SDK with Visual Studio 16.9

Hi @victor, sorry for the late reply, you can use CheckIsRunning, for this purpose.
Here a code sample from a Python Generator.

import c4d

# main == GetVirtualObject
def main():
    if c4d.CheckIsRunning(c4d.CHECKISRUNNING_EDITORRENDERING) or c4d.CheckIsRunning(c4d.CHECKISRUNNING_EXTERNALRENDERING):
        return c4d.BaseObject(c4d.Osphere)
    return c4d.BaseObject(c4d.Ocube)

Another option that will be more consistent is to listen to MSG_MULTI_RENDERNOTIFICATION which is a message sent to all BaseList2D of a scene, before and at the end of the rendering.

Cheers,
Maxime.

Hi @fwilleke80 here are the possibilities:

Create a comment to disable stylecheck locally

// stylecheck.naming=false
....
code
....
// stylecheck.naming=true

Unfortunately, it doesn't work for all kinds of warnings described in ProjectTool - Style Check. And you can't use stylecheck=false.
Here a list of style check you can redefine:

• stylecheck.max-linecount
• stylecheck.naming
• stylecheck.using
• stylecheck.domains
• stylecheck.whitespace
• stylecheck.indentation
• stylecheck.enum-class
• stylecheck.enum-registration
• stylecheck.void-paramlist
• stylecheck.newline-for-substatement
• stylecheck.case-break
• stylecheck.no-whitespace
• stylecheck.supercall
• stylecheck.explicit
• stylecheck.ambiguouscalls

Some others may work I don't have a clear list.

Use Maxon Macro

• MAXON_WARN_MUTE_FUNCTION_LENGTH Mute warning if function is larger than 500 lines (similar to stylecheck.max-linecount=1000)
• MAXON_WARN_MUTE_NAMING: Mute warning if the naming scheme doesn't match (similar to stylecheck.naming=false).
• MAXON_WARN_MUTE_UNUSED: mute warning if a function/variable is not used.
• MAXON_WARN_UNUSED_CLASS: same as previous but for classes.

Use pragma warning

While it's not the best way, you can use pragma to disable error, for more information see MSDN - Pragma Warning.

Hope this helps.
Cheers,
Maxime.

Hi @fwilleke80 unfortunately there is no option to do it, you can either disable the stylecheck or enable it.

One question raised, and you probably have your own reason, but why don't you put these files outside of your source and thread them as an external library?

Cheers,
Maxime.

Thanks a lot some are false positive or even coming from the standard library.

But I will fix the one that are wrong and update the doc

Cheers,
Maxime.

Sorry I was not clear but AddSeparatorH expect initw and AddSeparatorV expect inith in S24 like in C++.

I will fix the Python documentation.
Cheers,
Maxime.

Hi Daniel, this was updated during S24, to match C++ convention.

We will update the documentation for the parameter (should be inith). Thanks for pointing it.

Cheers,
Maxime.

This is 2 separated "optimization", one to prevent running the script when an animation is played.
The first one about the exeCount prevents running the script for each scene evaluation (aka each action, e.g user click on the object manager, select one object than another then another one, its pointless to execute your script each time)

It's a pretty dumb approach, I admit but its one

Cheers,
Maxime.

Hi Franck, sorry for the long delay. So I will answers you with a step by step for implementing your own basic Python Object Generator

First, the resource file will consist of a code field and a button.
In opythonexample.h

#ifndef OPYTHON_EXAMPLE_H__
#define OPYTHON_EXAMPLE_H__

enum
{
	OPYTHON_EXAMPLE_CODE = 1000,
	OPYTHON_EXAMPLE_OPENEDITOR = 1001
};

#endif // OPYTHON_EXAMPLE_H__

In opythonexample.res

CONTAINER Opythonexample
{
	NAME Opythonexample;
	INCLUDE Obase;

	GROUP ID_OBJECTPROPERTIES
	{
		SCALE_V;

		BUTTON OPYTHON_EXAMPLE_OPENEDITOR { }

		STRING OPYTHON_EXAMPLE_CODE
		{
		  CUSTOMGUI MULTISTRING;
		  PYTHON;
		  SCALE_V;
		}
	}    
}

And the opythonexample.str

STRINGTABLE Opythonexample
{
	Opythonexample		"C++ SDK - Python Object";

	OPYTHON_EXAMPLE_CODE			"Code";
	OPYTHON_EXAMPLE_OPENEDITOR 		"Open Python Editor";
}

So let's create a basic ObjectData with just a special handling for the code parameter (done in GetDParameter) in order to be aware if the code changed.

#include "c4d_objectdata.h"
#include "c4d_general.h"
#include "opythonexample.h"

#include "lib_description.h"


#define PLUGIN_ID_PYTHON_OBJECT 1057128

class PythonExampleObject : public ObjectData
{
	INSTANCEOF(PythonExampleObject, ObjectData)

private:
	Bool codeChanged = false; // Store if the code changed and therefore the Python code be re-compiled

public:
	virtual Bool Init(GeListNode* node)
	{
		// We call SetParameter in this case, so SetDParameter is called and codeChanged == true
		String code = "import c4d\nimport maxon\n\ndef GetVirtualObjects(op):\n    return c4d.BaseObject(c4d.Ocube)\n\nprint(f'This will be called for each _scope.Execute(), value of {doc}')";
		node->SetParameter(DescID(OPYTHON_EXAMPLE_CODE), code, DESCFLAGS_SET::NONE);

		return true;
	};

	maxon::Result<void> CreateInitAndExecuteScope(BaseObject* obj)
	{
		iferr_scope;
		if (obj == nullptr)
			return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION, "Passed BaseObject is nullptr"_s);

		BaseContainer* data = ((BaseObject*)obj)->GetDataInstance();
		if (data == nullptr)
			return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION, "Unable to retrieve the BaseContianer"_s);

		String code = data->GetString(OPYTHON_EXAMPLE_CODE);

		_scope = _vm.CreateScope() iferr_return;
		_scope.Init("SDK Python Object"_s, code, maxon::ERRORHANDLING::PRINT) iferr_return;

		// Add Doc reference to the all scope
		MAXON_SCOPE
		{
			maxon::py::CPythonGil lock(_pyLibMaxonAPI);
		  
			BaseDocument* doc = obj->GetDocument();
			if (doc == nullptr)
			{
				_scope.Add("doc"_s, maxon::Data(_pyLibMaxonAPI.CPy_None())) iferr_return;
				return maxon::OK;
			}

			maxon::specialtype::BaseDocument* docSpecial = reinterpret_cast<maxon::specialtype::BaseDocument*>(doc);
			_scope.Add("doc"_s, maxon::Data(docSpecial)) iferr_return;
		}

		_scope.Execute() iferr_return;

		codeChanged = false;

		return maxon::OK;
	}

	virtual BaseObject* GetVirtualObjects(BaseObject* op, HierarchyHelp* hh)
	{
        // Return nothing for the moment
		return nullptr;
	};

	virtual Bool SetDParameter(GeListNode* node, const DescID& id, const GeData& t_data, DESCFLAGS_SET& flags)
	{
		if (node == nullptr)
			return false;

		switch (id[0].id)
		{
			// This parameter will not be stored in the BaseContainer
			case OPYTHON_EXAMPLE_CODE:
			{
				codeChanged = true;
				break;
			}
		}

		return SUPER::SetDParameter(node, id, t_data, flags);
	}

	static NodeData* Alloc()
	{
		return NewObjClear(PythonExampleObject);
	}
};

Bool RegisterPythonObject()
{
	return RegisterObjectPlugin(PLUGIN_ID_PYTHON_OBJECT, "C++ SDK - Python Object"_s, OBJECT_GENERATOR | OBJECT_USECACHECOLOR , PythonExampleObject::Alloc, "Opythonexample"_s, nullptr, 0);
}

Then next step is to add Python functionality but first of all there is few information that you should know for the next step which will consist to create a Python Scope.

So A Python Scope (VirtualMachineScopeInterface) and more especially the CPythonScope will help you to manage your Python code.
CPythonScopeRef::Init will compile (create Python op code) of the passed code and create globals and locals dict.
CPythonScopeRef::Execute will actually run the compiled opcode, it's important to execute the scope at least once, since python it's a pretty dynamic language and this wil lcreate Python object for everything (e.g. class, function).
When the CPythonScopeRef is destructed, the Python Garbage collector is called to free any leftover (using GC_Collect, so it may not be immediate but this is another topic). And the Python Exception state is reseted.

Then in order to do it properly, you need to deal with the GIL. The idea of the GIl is rather simple, the Python VM store some information like like the exception state(did an exception occured during the last Python Execution?).
Now let's think about 2 threads executing some code to the Python VM, since exception state is a boolean stored at the VM level, you need some way to syncrhonize that and if script A is failing you still want script B to run.
So the GIL(Global Interpreter Lock) is just a way to say to the Python VM, I'm script A and I'm executing so don't let any action that may change your internal state until I told you I don't care anymore.
This is a a rough summary but you get teh idea, if you want more information see What Is the Python Global Interpreter Lock (GIL)?

Lets do some code, to create an helper method to help us in thecreation of a valid scope each time we need.
We are going to store the created scope in a member called _scope.
This way we are not forced to re-compile for each evaluation the python code only when the code changed, and use already existing data.

#include "maxon/vm.h"
#include "maxon/cpython.h"
#include "maxon/cpython3_raw.h"
#include "maxon/cpython_c4d.h"

MAXON_DEPENDENCY_WEAK("maxon/vm.h");
MAXON_DEPENDENCY_WEAK("maxon/cpython.h");
MAXON_DEPENDENCY_WEAK("maxon/cpython3_raw.h");
MAXON_DEPENDENCY_WEAK("maxon/cpython_c4d.h");


class PythonExampleObject : public ObjectData
{

private:
    const maxon::VirtualMachineRef& _vm = MAXON_CPYTHON3VM();  // reference to the Python 3 VM
    const maxon::py::CPythonLibraryRef _pyLibMaxonAPI = maxon::Cast<maxon::py::CPythonLibraryRef>(_vm.GetLibraryRef()); // reference to the Python 3 Library
    maxon::VirtualMachineScopeRef _scope; // Will store the previous compiled scope.

public:
	maxon::Result<void> CreateInitAndExecuteScope(BaseObject* obj)
	{
		iferr_scope;
		if (obj == nullptr)
			return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION, "Passed BaseObject is nullptr"_s);

		BaseContainer* data = ((BaseObject*)obj)->GetDataInstance();
		if (data == nullptr)
			return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION, "Unable to retrieve the BaseContianer"_s);

		String code = data->GetString(OPYTHON_EXAMPLE_CODE);

        // Create a Python Scope, this will override existing one.
        // Since its a Maxon Reference deallocation will be handled automatically by the Maxon API)
		_scope = _vm.CreateScope() iferr_return;

        // Initialize the scope with the given code and express how we want to deal with error (in our case print them)
		_scope.Init("SDK Python Object"_s, code, maxon::ERRORHANDLING::PRINT) iferr_return;

		// Add Doc reference to the all scope
		MAXON_SCOPE
		{
			// Since we will use the Python Library to create Python object. The GIL must be held.
			maxon::py::CPythonGil lock(_pyLibMaxonAPI);
		  
			BaseDocument* doc = obj->GetDocument();
			if (doc == nullptr)
			{
				_scope.Add("doc"_s, maxon::Data(_pyLibMaxonAPI.CPy_None())) iferr_return;
				return maxon::OK;
			}

			// Only maxon.Data can be added to a Maxon Scope (This is the tricky part for Python and Python.framework, since in Python you mostly deal with Classic API type)
			// So a maxon::specialtype::BaseDocument is a Maxon Data type that know how to convert a BaseDocument to a Python BaseObject.
			// In this case the create Python object will not own the BaseDocument, a maxon::specialtype::BaseDocumentMove* would own the passed BaseDocument.
			maxon::specialtype::BaseDocument* docSpecial = reinterpret_cast<maxon::specialtype::BaseDocument*>(doc);
			_scope.Add("doc"_s, maxon::Data(docSpecial)) iferr_return;
		}

		// We finally execute our scope, so Python evaluate it and build everything
		_scope.Execute() iferr_return;

		codeChanged = false;

		return maxon::OK;
	}
}

Then let's implement the most important part, aka Calling the Python GetVirtualObjects from the C++ GetVirtualObjects

	virtual BaseObject* GetVirtualObjects(BaseObject* op, HierarchyHelp* hh)
	{
        // Since we will use the Python Library to create Python object. The GIL must be held.
		maxon::py::CPythonGil lock(_pyLibMaxonAPI);

		iferr_scope_handler
		{
			return nullptr;
		};

        // If the code changed and a GetVirtualObject pass is called, (re)build the scope
		if (codeChanged)
		{
			CreateInitAndExecuteScope(op) iferr_return;
		}

        // A BaseArray of MaxonData that will serve as argument to be passed to the Python function.
		maxon::BaseArray<maxon::Data*> args;

        // Same things that we saw CreateInitAndExecuteScope with the BaseDocument but this time with a BaseObject 
		maxon::specialtype::BaseObject* opSpecial = reinterpret_cast<maxon::specialtype::BaseObject*>(op);
		maxon::Data pyData = maxon::Data(opSpecial);
		args.Append(&pyData) iferr_return;
		
        // HelperStack is not meaningfull to us, but its necesarry to provide it as it will act as a DataHolder during the Python execution.
		maxon::BlockArray<maxon::Data> helperStack;

        // And we call the Python function named "GetVirtualObjects" (it's important that the scope is executed before, so this function object execit in the globals dict of the Python scope)
        // Then the 3rd arguments is important since it define the expected type to be returned.
        // In this case its not anymore a maxon::specialtype::BaseObject but a maxon::specialtype::BaseObjectMove.
        // We use a BaseObjectMove because in the Python call, we return a BaseObject, that is owned by the Python object.
        // But this python object will be destructured after the PrivateInvoke call, so therefor the BaseObject. So we need to move the BaseObject to have still it alive.
		auto* res = _scope.PrivateInvoke("GetVirtualObjects"_s, helperStack, maxon::GetDataType<maxon::specialtype::BaseObjectMove*>(), &args.ToBlock()) iferr_return;

		if (res == nullptr)
			return nullptr;
		
		maxon::specialtype::BaseObjectMove* pyRes = res->Get<maxon::specialtype::BaseObjectMove*>().GetValue();
		if (pyRes == nullptr)
			return nullptr;

        // Retrieve the BaseObject returned by the Python code
		BaseObject* finalObj = reinterpret_cast<BaseObject*>(pyRes);

		return finalObj;
	};

And finally in order to properly react to the "Open Python Editor" button.
We will need to call CodeEditor_Open when the user press the button.

class PythonExampleObject : public ObjectData
{
public:
	
	virtual Bool Message(GeListNode* node, Int32 type, void* data)
	{
		switch (type)
		{
			case MSG_DESCRIPTION_COMMAND:
			{
				DescriptionCommand* dc = (DescriptionCommand*)data;

				switch (dc->_descId[0].id)
				{

					// The editor button was pressed
					case OPYTHON_EXAMPLE_OPENEDITOR:
					{
						CodeEditor_Open(static_cast<BaseObject*>(node), PythonObjectExpressionCallBack);
						break;
					}
				}
				return true;
				break;
			}

			default: 
				break;
		}

		return SUPER::Message(node, type, data);
	}
}

Then we need to implement the callback (PythonObjectExpressionCallBack) that needs to be passed to CodeEditor_Open.
Unfortually due to a bug in the python.framework, when you compile a string it's not possible to retrieve easily (in less than 200 lines) the columns of where the error occured, so for this part I used the old python library.

static GeData PythonObjectExpressionCallBack(BaseList2D* node, const BaseContainer& msg)
{
	GeData res;
	BaseObject* obj = (BaseObject*)node;
	if (obj == nullptr)
		return res;

	BaseContainer* data = ((BaseObject*)obj)->GetDataInstance();
	if (data == nullptr)
		return res;

	switch (msg.GetId())
	{
		// Return the string to set inside the Script Expression editor.
		case CODEEDITOR_GETSTRING:
		{
			BaseContainer r;
			r.SetString(CODEEDITOR_SETSTRING, data->GetString(OPYTHON_EXAMPLE_CODE));
			r.SetInt32(CODEEDITOR_SETMODE, (Int32)SCRIPTMODE::PYTHON);
			res = r;
			break;
		}

		// Update the code string from the Script Expression editor.
		case CODEEDITOR_SETSTRING:
		{
			// We call SetParameter so SetDParameter is called and therefor codechanged==true
			node->SetParameter(DescLevel(OPYTHON_EXAMPLE_CODE), msg.GetString(CODEEDITOR_SETSTRING), DESCFLAGS_SET::NONE);
			EventAdd();
			res = true;
			break;
		}

		// Compile the code string to Python OPcode (Only check for Syntax error)
		// This is called before CODEEDITOR_EXECUTE
		case CODEEDITOR_COMPILE:
		{
			GePythonGIL pygil;
			PythonLibrary pylib;

			BaseContainer bc;
			String err_string;
			Int32 err_line = 0, err_row = 0;

			if (pylib.CheckSyntax(data->GetString(OPYTHON_EXAMPLE_CODE), &err_row, &err_line, &err_string))
			{
				bc.SetInt32(CODEEDITOR_GETERROR_RES, true);
				bc.SetInt32(CODEEDITOR_GETERROR_LINE, -1);
				bc.SetInt32(CODEEDITOR_GETERROR_POS, -1);
			}
			else
			{
				bc.SetInt32(CODEEDITOR_GETERROR_RES, false);
				bc.SetString(CODEEDITOR_GETERROR_STRING, "SyntaxError: " + err_string);
				bc.SetInt32(CODEEDITOR_GETERROR_LINE, err_line);
				bc.SetInt32(CODEEDITOR_GETERROR_POS, err_row);
			}

			res = bc;
			break;
		}

		// Execute the code string (usually triggering an update of the active document).
        // CODEEDITOR_COMPILE is always called before
		case CODEEDITOR_EXECUTE:
		{
			BaseContainer r;

			EventAdd();

			r.SetInt32(CODEEDITOR_GETERROR_RES, true);
			r.SetString(CODEEDITOR_GETERROR_STRING, String());
			r.SetInt32(CODEEDITOR_GETERROR_LINE, -1);
			r.SetInt32(CODEEDITOR_GETERROR_POS, -1);

			res = r;
			break;
		}

        // This is used to syncronize UI, it should return the DescID of the code parameter
		case CODEEDITOR_GETID:
		{
			return GeData(CUSTOMDATATYPE_DESCID, DescID(DescLevel(OPYTHON_EXAMPLE_CODE)));
			break;
		}

	}
	return res;
}

And thats it

So here is the full code if you are interested.

#include "c4d_objectdata.h"
#include "c4d_general.h"
#include "opythonexample.h"

#include "lib_description.h"
#include "c4d_libs/lib_py.h"

#include "maxon/vm.h"
#include "maxon/cpython.h"
#include "maxon/cpython3_raw.h"
#include "maxon/cpython_c4d.h"

MAXON_DEPENDENCY_WEAK("maxon/vm.h");
MAXON_DEPENDENCY_WEAK("maxon/cpython.h");
MAXON_DEPENDENCY_WEAK("maxon/cpython3_raw.h");
MAXON_DEPENDENCY_WEAK("maxon/cpython_c4d.h");


#define PLUGIN_ID_PYTHON_OBJECT 1057128


static GeData PythonObjectExpressionCallBack(BaseList2D* node, const BaseContainer& msg)
{
	GeData res;
	BaseObject* obj = (BaseObject*)node;
	if (obj == nullptr)
		return res;

	BaseContainer* data = ((BaseObject*)obj)->GetDataInstance();
	if (data == nullptr)
		return res;

	switch (msg.GetId())
	{
		// Return the string to set inside the Script Expression editor.
		case CODEEDITOR_GETSTRING:
		{
			BaseContainer r;
			r.SetString(CODEEDITOR_SETSTRING, data->GetString(OPYTHON_EXAMPLE_CODE));
			r.SetInt32(CODEEDITOR_SETMODE, (Int32)SCRIPTMODE::PYTHON);
			res = r;
			break;
		}

		// Update the code string from the Script Expression editor.
		case CODEEDITOR_SETSTRING:
		{
			// We call SetParameter so SetDParameter is called and therefor codechanged==true
			node->SetParameter(DescLevel(OPYTHON_EXAMPLE_CODE), msg.GetString(CODEEDITOR_SETSTRING), DESCFLAGS_SET::NONE);
			EventAdd();
			res = true;
			break;
		}

		// Compile the code string to Python OPcode (Only check for Syntax error)
		// This is called before CODEEDITOR_EXECUTE
		case CODEEDITOR_COMPILE:
		{
			GePythonGIL pygil;
			PythonLibrary pylib;

			BaseContainer bc;
			String err_string;
			Int32 err_line = 0, err_row = 0;

			if (pylib.CheckSyntax(data->GetString(OPYTHON_EXAMPLE_CODE), &err_row, &err_line, &err_string))
			{
				bc.SetInt32(CODEEDITOR_GETERROR_RES, true);
				bc.SetInt32(CODEEDITOR_GETERROR_LINE, -1);
				bc.SetInt32(CODEEDITOR_GETERROR_POS, -1);
			}
			else
			{
				bc.SetInt32(CODEEDITOR_GETERROR_RES, false);
				bc.SetString(CODEEDITOR_GETERROR_STRING, "SyntaxError: " + err_string);
				bc.SetInt32(CODEEDITOR_GETERROR_LINE, err_line);
				bc.SetInt32(CODEEDITOR_GETERROR_POS, err_row);
			}

			res = bc;
			break;
		}

		// Execute the code string (usually triggering an update of the active document).
		case CODEEDITOR_EXECUTE:
		{
			BaseContainer r;

			EventAdd();

			r.SetInt32(CODEEDITOR_GETERROR_RES, true);
			r.SetString(CODEEDITOR_GETERROR_STRING, String());
			r.SetInt32(CODEEDITOR_GETERROR_LINE, -1);
			r.SetInt32(CODEEDITOR_GETERROR_POS, -1);

			res = r;
			break;
		}

		case CODEEDITOR_GETID:
		{
			return GeData(CUSTOMDATATYPE_DESCID, DescID(DescLevel(OPYTHON_EXAMPLE_CODE)));
			break;
		}

	}
	return res;
}


class PythonExampleObject : public ObjectData
{
	INSTANCEOF(PythonExampleObject, ObjectData)

private:
	const maxon::VirtualMachineRef& _vm = MAXON_CPYTHON3VM();
	const maxon::py::CPythonLibraryRef _pyLibMaxonAPI = maxon::Cast<maxon::py::CPythonLibraryRef>(_vm.GetLibraryRef());
	maxon::VirtualMachineScopeRef _scope;

	Bool codeChanged = false;

public:
	virtual Bool Init(GeListNode* node)
	{
		iferr_scope_handler
		{
			return false;
		};

		// We call SetParameter in this case, so SetDParameter is called and codeChanged == true
		String code = "import c4d\nimport maxon\n\ndef GetVirtualObjects(op):\n    return c4d.BaseObject(c4d.Ocube)\n\nprint(f'This will be called for each _scope.Execute(), value of {doc}')";
		node->SetParameter(DescID(OPYTHON_EXAMPLE_CODE), code, DESCFLAGS_SET::NONE);

		return true;
	};

	maxon::Result<void> CreateInitAndExecuteScope(BaseObject* obj)
	{
		iferr_scope;
		if (obj == nullptr)
			return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION, "Passed BaseObject is nullptr"_s);

		BaseContainer* data = ((BaseObject*)obj)->GetDataInstance();
		if (data == nullptr)
			return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION, "Unable to retrieve the BaseContianer"_s);

		String code = data->GetString(OPYTHON_EXAMPLE_CODE);

		_scope = _vm.CreateScope() iferr_return;
		_scope.Init("SDK Python Object"_s, code, maxon::ERRORHANDLING::PRINT) iferr_return;

		// Add Doc reference to the all scope
		MAXON_SCOPE
		{
			maxon::py::CPythonGil lock(_pyLibMaxonAPI);
		  
			BaseDocument* doc = obj->GetDocument();
			if (doc == nullptr)
			{
				_scope.Add("doc"_s, maxon::Data(_pyLibMaxonAPI.CPy_None())) iferr_return;
				return maxon::OK;
			}

			maxon::specialtype::BaseDocument* docSpecial = reinterpret_cast<maxon::specialtype::BaseDocument*>(doc);
			_scope.Add("doc"_s, maxon::Data(docSpecial)) iferr_return;
		}

		_scope.Execute() iferr_return;

		codeChanged = false;

		return maxon::OK;
	}

	virtual BaseObject* GetVirtualObjects(BaseObject* op, HierarchyHelp* hh)
	{
		maxon::py::CPythonGil lock(_pyLibMaxonAPI);

		iferr_scope_handler
		{
			return nullptr;
		};

		if (codeChanged)
		{
			CreateInitAndExecuteScope(op) iferr_return;
		}

		maxon::BaseArray<maxon::Data*> args;

		maxon::specialtype::BaseObject* opSpecial = reinterpret_cast<maxon::specialtype::BaseObject*>(op);
		maxon::Data pyData = maxon::Data(opSpecial);
		args.Append(&pyData) iferr_return;
		
		maxon::BlockArray<maxon::Data> helperStack;
		auto* res = _scope.PrivateInvoke("GetVirtualObjects"_s, helperStack, maxon::GetDataType<maxon::specialtype::BaseObjectMove*>(), &args.ToBlock()) iferr_return;

		if (res == nullptr)
			return nullptr;
		
		maxon::specialtype::BaseObjectMove* pyRes = res->Get<maxon::specialtype::BaseObjectMove*>().GetValue();
		if (pyRes == nullptr)
			return nullptr;

		BaseObject* finalObj = reinterpret_cast<BaseObject*>(pyRes);

		return finalObj;
	};

	virtual Bool Message(GeListNode* node, Int32 type, void* data)
	{
		switch (type)
		{
			case MSG_DESCRIPTION_COMMAND:
			{
				DescriptionCommand* dc = (DescriptionCommand*)data;

				switch (dc->_descId[0].id)
				{

					// The editor button was pressed
					case OPYTHON_EXAMPLE_OPENEDITOR:
					{
						CodeEditor_Open(static_cast<BaseObject*>(node), PythonObjectExpressionCallBack);
						break;
					}
				}
				return true;
				break;
			}

			default: 
				break;
		}

		return SUPER::Message(node, type, data);
	}

	virtual Bool SetDParameter(GeListNode* node, const DescID& id, const GeData& t_data, DESCFLAGS_SET& flags)
	{
		if (node == nullptr)
			return false;

		switch (id[0].id)
		{
			// This parameter will not be stored in the BaseContainer
			case OPYTHON_EXAMPLE_CODE:
			{
				codeChanged = true;
				break;
			}
		}

		return SUPER::SetDParameter(node, id, t_data, flags);
	}

	static NodeData* Alloc()
	{
		return NewObjClear(PythonExampleObject);
	}
};

Bool RegisterPythonObject()
{
	return RegisterObjectPlugin(PLUGIN_ID_PYTHON_OBJECT, "C++ SDK - Python Object"_s, OBJECT_GENERATOR | OBJECT_USECACHECOLOR , PythonExampleObject::Alloc, "Opythonexample"_s, nullptr, 0);
}

If you have any question, feel free to ask.
Cheers,
Maxime.