Oh! Forget guys my message above!

The calling of Python code from C++ plugin in @kbar 's advice does the trick! :)

If someone from the future who will read this thread will need the code example, I just use the code snippet from here: https://developers.maxon.net/docs/Cinema4DCPPSDK/html/page_maxonapi_python.html

and feed to it this code:

// call it from somewhere
String code = "import c4d\nimport maxon\nimport os    ";
        code+= "\n\nprint(f'This is simple message')";
        code += "\nos.rename('C:/Code/sdk/plugins/myPlugin/myPlugin.xdl64', 'C:/Code/sdk/plugins/myPlugin/old_myPlugin.old')"; 
        
ExecutePythonScript(code, GetActiveDocument());

:smile:

Thank you for your explanation. I suspected that most likely it would not be possible to catch the moment of the beginning of Undo/Redo. Sad...

So if to consider your advice:...
@manuel said in Get ID of Undo-ed parameter...?:

You can either update all your objects based on the new data or check all your structure and check if it needs any updates.

...if I want to call update function in MSG_DOCUMENTINFO_TYPE_UNDO, so how to retrieve the correct object which have been updated here? (it should be my node). As I think I do not need make update in situations when Undo was made for another objects in the scene.

And also I did not understand the second part in the quote. What the structure should I check? Structure of parameters of my node? Or structure of objects? And how to check that they need any updates?

Hi Manuel.
I have a pretty complex structure when not only the slider parameter but also the SplineData parameter of my plugin controls an array of objects (its radiuses, positions, etc).
So I need to use doc->StartUndo() every for-cycle loop for each object in the array. During animation it gets me the error in doc->StartUndo() line, in AddUndo() line, EndUndo() and sometimes causes a crash.
Also I don't need to create the Undo each frame during the animation (when parameter is changed by animation key). I need to create Undo only once - when the user interacts with the parameter(s).

According to your code snippet above. Is the way somehow to achieve this:

1. at the start of Undo/Redo call by user, BEFORE the previous/next version of the node was copied to the scene, somehow to compare the current values of parameters with the values from a copied node-version.
2. store the parameters for which we find the difference
3. at the end of Undo/Redo call by user, AFTER the previous/next version of the node was copied to the scene, send the message to a node with the exact parameter-ID
   ?

the message like this:

DescriptionPostSetValue dc;
DescID distrID = DescID(DescLevel(1140, CUSTOMDATATYPE_SPLINE, op->GetType()));
dc.descid = &distrID;
op->Message(MSG_DESCRIPTION_POSTSETPARAMETER, (void*)&dc);

thank you

C++

Hello.
(very simplified explanation of what my plugin performs )
My ObjectData plugin has some slider parameter ("myParameter") which controls the radius parameter of some sphere.
When the user changes myParameter, MSG_DESCRIPTION_POSTSETPARAMETER catches the message of its ID and calls the function void modifySphereRadius().
(in reality there are lot of "myParameters", "objects" and "modifyObjFunc()"s in my plugin).

At this step everything works fine.

Now I want to make a proper Undo/Redo operation.
I don't want to add AddUndo() operation (doc->AddUndo(UNDOTYPE::CHANGE, mySphere);) inside to my modifySphereRadius() function. It causes the problems during running animation (when myParameter is animated) etc.

So, what I've think, that it would be good to call my modifySphereRadius() function only when myParameter value is restored from the Undo.

Is the way to achieve this?

When the user changes myParameter, the C4D creates the undo-version of my node. And when the user calls Undo action, the old myParameter value of my node is restored.

BUT what I've found that no corresponding messages in the MSG_DESCRIPTION_POSTSETPARAMETER for the myParameter ID was sent.

Is the way to catch the message for the exact parameter ID after it was restored when user called Undo/Redo?

Ok, so it looks like I should to give up of using ParallelFor for InExData. Because it is most expensive part and using ParallelFor for all other parts of code does not speed things up.

And actually as I understand it is pretty logical.
I have 2 InExData parameters in my plugin. So when I copying 3000 items into 2 InExData`s, plus adding 3000 objects into the scene, then the number of operations increases up to 9 000.

And the result for the 3000 objects adding to the scene but with no InExData->InsertObject()

Starting Alloc()...133894.367
Starting ParalelFor...133894.477
Starting Insert()...133894.542
Ending Insert()...133894.551

Hi @ferdinand

You've understood everything perfectly correct.
Yes, I want to add a lot of objects in the scene,
Yes, when its number is 250, it is not the problem at all. The talking about case when the number is 3000.

// The function is called from the ObjectDataPlugin Messages. 
doc->StartUndo(); 
     
    // Alloc() all
    // MainThread  
      
    maxon::TimeValue timer = maxon::TimeValue::GetTime();  
    ApplicationOutput("Starting Alloc()...@", timer.GetSeconds());

    for (Int32 i = 0; i <= amount; ++i) //  3000
    {
        BaseObject* const joint = BaseObject::Alloc(Osphere);
        BaseObject* const cyl = BaseObject::Alloc(Ocylinder);
        BaseObject* const connector = BaseObject::Alloc(180000011);
        BaseObject* const upV = BaseObject::Alloc(Onull);
        BaseTag* const DBtag = BaseTag::Alloc(180000102);
        BaseTag* const Constraint1 = BaseTag::Alloc(1019364);
        BaseTag* const Constraint2 = BaseTag::Alloc(1019364);

        joints.push_back(joint);        cylinders.push_back(cyl);         connectors.push_back(connector);      UpVs.push_back(upV);
        DBtags.push_back(DBtag);       constTags1.push_back(Constraint1);   constTags2.push_back(Constraint2);
    }
    
    // ParallelFor. Sort, set params
    timer = maxon::TimeValue::GetTime();
    ApplicationOutput("Starting ParallelFor...@", timer.GetSeconds());

    // Worker lambda  
    auto worker = [amount, modifyOnly, &controller1, &controller2, ...etc ](maxon::Int32 i)
    {   
        {
            joints.at(i)->SetParameter(ID_BASELIST_NAME, spline->GetName() + String::IntToString(i), DESCFLAGS_SET::NONE);
            joints.at(i)->SetParameter(...etc

            Vector firstpos = ...  // calculate some points 

            cylinders.at(i)->SetParameter(ID_BASELIST_NAME, spline->GetName() + String::IntToString(i), DESCFLAGS_SET::NONE);
            cylinders.at(i)->SetParameter(...

            if (.... some calculation)
            {  
                    joints.at(i)->SetMg(BuildLookAt(~controller1->GetMg() * firstpos, ~controller1->GetMg() * secondpos, joints.at(i)->GetMg().sqmat.v3));
              
           }
  
            cylinders.at(i)->SetRelPos(Vector(0, GetDistance(firstpos, secondpos) / 2, 0));
 
       ....etc.... // a lot of calculations and setParams, setpos, setMg. No insertion in the scene here. 
    };
     
    // Assync 
    maxon::ParallelFor::Dynamic(0, amount+1, worker ); // works nice and fast
       
    // Now an easy but most slow part: objs insertion into the scene

    // Main thread.  
    timer = maxon::TimeValue::GetTime();
    ApplicationOutput("Starting Insert()...@", timer.GetSeconds());

    for (int j = 0; j < joints.size(); j++)
    {
        // DB-class
        joints.at(j)->InsertTag(DBtags.at(j));
        CreatedObjsList->InsertObject(DBtags.at(j), 0);  
        AdditionalCreatdObjsList->InsertObject(DBtags.at(j), 0);  
         
        // joints
        joints.at(j)->InsertUnder(controller2);
        SpecBonesField->InsertObject(joints.at(j), 0);   
   
        /*doc->AddUndo(UNDOTYPE::NEWOBJ, joints.at(j));*/

        // Cylinder
        cylinders.at(j)->InsertUnder(joints.at(j));
        CreatedObjsList->InsertObject(joints.at(j), 0);         
        CreatedObjsList->InsertObject(cylinders.at(j), 0);    
        AdditionalCreatdObjsList->InsertObject(joints.at(j), 0);   
        AdditionalCreatdObjsList->InsertObject(cylinders.at(j), 0);   
        /*doc->AddUndo(UNDOTYPE::NEWOBJ, cylinders.at(j));*/

        // Connector-class
        if (simple bool)
        {
            UpVs.at(j)->InsertUnderLast(parentNull);
            CreatedObjsList->InsertObject(UpVs.at(j), 0); 
            AdditionalCreatdObjsList->InsertObject(UpVs.at(j), 0);   

            /*doc->AddUndo(UNDOTYPE::NEWOBJ, UpVs.at(j));*/

            connectors.at(j)->InsertTag(constTags1.at(j));
            connectors.at(j)->InsertTag(constTags2.at(j));
            connectors.at(j)->InsertUnderLast(parentNull);


            CreatedObjsList->InsertObject(connectors.at(j), 0);  
            AdditionalCreatdObjsList->InsertObject(connectors.at(j), 0);     
            /*doc->AddUndo(UNDOTYPE::NEWOBJ, connectors.at(j)); */

            // tracer in-Ex
            tracerInEx->InsertObject(connectors.at(j), 0);
        } 

        //doc->AddUndo(UNDOTYPE::NEWOBJ, DBtags.at(j));
    }
    
    timer = maxon::TimeValue::GetTime();
    ApplicationOutput("Ending Insert()...@", timer.GetSeconds());
    doc->EndUndo(); 

If I exclude from the "slow part" everything about InExData, it works much faster. Even when the number of objects is really big (3000). I was thinking about the AddUndo(), that it causes the problem, but - no. When I exclude it too, it does not affect the speed of the "slow" step at all.
So my thoughts was exactly about the InExData causes the slowing down.

Hello.

Basically my code looks like:

1. (in the Main Thread ) Allocate all the BaseObjects, add it to a vector-list (I will add all of it into the scene later).
2. ParalelFor worker for sorting all objects and setting its parameters
3. Back to MainThread: InsertObject() for all objects into the doc.

But inside the p.3 I also need to perform a lot of myObjectDataPluginInExData->InsertObject(myObjs.at(i)) operations. But the problem: it really slows down the 3rd step.

Therefore, I considered the possibility of transferring all myInExData-modification to the step-2. To perform it in the threaded mode. The idea is do not modify the scene, just a tempInExData variable.

I was thinking about 1) create the instance of the InExdata not binded to any scene object, 2) inside ParalelFor make all

myTempInExData->InsertObject(myObjects.at(i))

and 3) in the Main Thread assign myTempInExData to myInExData of my plugin.

Is it possible in a some way? Is it possible to modify the myTempInExData in the Paralelfor at all?

@ferdinand said in GetMg() returns not the actual coordinates:

If you indeed want a frame/transform/matrix for your ray origin, which would strike me as odd, I would need to see more context.

I am making the plugin which creates the ragdoll from a user's character.
The part we are talking about appears from here

after clicking the "Create Ragdoll" button:

So after this step, the code calculates a lot of stuff to create Connectors, tags, colliders etc for the ragdoll structure. And now we are talking about the algorithm for the calculation of the sizes of cube-colliders.
In basic words it uses the GeRayColliders and calculates the distance from the center of the bone to the character-mesh. And then feeds this distance to a Cube-collider sizes. However It is little bit more complicated than it sounds, but basically I need to receive the ray from the cube-origin by its local X-axis (and Z-axis too) and then use this double-distance in the cube x (and z) size.
So I need to get the geRayCollider ray direction vector. This vector should be almost the same as the cube's local x-axis (and z) + some random.

And my problem is when I trying to find the point of the local cube's x-axis using the code snippet above I am receive the shift by the X-axis of parent and not the cube. The axes of cube and its parent may not match. The x-axis of a cube can be the z-axis of its parent, etc. So the problem is something here: cube->GetMg() * Vector(10, 0, 0)

Hey @ferdinand ,
My problem is: when I do this:

const Vector p = cube->GetMg() * Vector(-10, floatrandom(-2, 2), floatrandom(-2, 2));

I get the point shifted by -10 units by X-axis but by parent's X-axis. But I need it in the cube's X-axis.
Is it expected behavior for Cinema 4D?

Hi @ferdinand
Thank you for your answer. I will learn it now carefully and will try to adapt it to C++ and my task.

I understand that the algebra question is not the case of this forum. I just ran into a problem with the GetMg() command which has returned not the expected world position of the child-cube.

I will add my code below:

Vector64 direction = parent->GetMg().off - child->GetMg().off; 
Vector64 middlePos = parent->GetMg().off - direction / 2;
// here I get the middlePos. Normally it is the world coordinates of the Cube Rel-position (0, 10, 0), 
// I need middlePos for the GeRayCollider as its ray source. Next I need to get the ray direction. 
// I need it 1) be relative to Cube local X-axis, 2) add to it some random to use it in the loop (the second is not the part of the problem)
// so here where I get the problem
Matrix shiftX = MatrixMove(Vector(-10, floatrandom(-2, 2), floatrandom(-2, 2)));
Matrix RayPosX = cube->GetMg() * shiftX; // !!! I don`t understand why this shifts the ray along the parent space (X-axis), but not the Cube's X-axis which might not match?
Vector rayDirectionX = middlePos + cube->GetMg().off - RayPosX.off; 
if (colliderX->Intersect(middlePos, rayDirectionX, 555)) 
// etc.

If I will print the current Cube->GetMg().off and the middlePos - it will be not the same. And in the result the whole code is not working as expected.