Hi, Maxime, I'm trying to be able to browse through every point, the tangents of those points, and the segments they belong to. It seems like a LineObject wouldn't help me get the tangents or the spline point locations so I think I would need the actual SplineObject.

I want to output a SplineObject, taking in the input splines points, tangents, and segments to be able modify it and return something different.

I hope that clears it up,
Dan

Hello, I was looking over some threads and the SDK examples for EnhancingMainMenu(), so I know how to make menus, but I had a couple of questions.

If I had a series of plugins that I wanted to have a custom menu dropdown would it be possible to have it getting updated by subsequent plugins loading.

So for example, Plugin A makes the menu and is inserted underneath it. Then Plugin B is there and I want that in the same menu, but above Plugin A. If I compiled them separately, A before B, so B being inserted had to be done within Plugin B instead of Plugin A, how would I do that?

This is the simplest case I could think of, but I think there would be more complicated circumstances.

Thanks for any help,
Dan

@m_magalhaes

Thank you! Works perfectly.

Dan

Hello! I have a situation where I'm adding a Random Effector to scene on a button press. That's working correctly, but when I save the scene and reopen it the Field interface and it seems to have reverted to the pre-R20 interface. I'm working in C++ but I managed to recreate the issue in Python for simplicity.

Before I save and load the Falloff tab looks like this.

After I save and load it looks like this.

The code I'm using is here:

import c4d
from c4d import gui
def main():
    randomEffector = c4d.BaseObject(1018643)#Random Effector ID
    doc.InsertObject(randomEffector)
    c4d.EventAdd()

if __name__=='__main__':
    main()

Is there a flag or something I'm missing?

Thanks for any help,
Dan

Hi @ferdinand.

Thanks for all of the help. That all makes sense to me. Hopefully in the future there will be a better work around, but for now I've got a workaround that is clunky but working.

Thanks again,
Dan

Hi @ferdinand!

In regards to your second screenshot that's correct, that's the issue I've been trying to fix.
I recorded a video before I noticed your edit, hopefully it will clear things up more.

https://www.dropbox.com/s/sp9t21r5n6yeng0/Walkthrough.mp4?dl=0

It looks like your spline did update, because I cannot see the spline representation anymore, the only thing that did not seem to have updated is the cloner which clones the spheres onto your spline, it still seems to work on an older cache of your object. Can you confirm that?

Correct. But I don't think it's an older cache.

From what I can tell by putting some prints in the code it seems like the cloner doesn't want an input with zero points. It seems like the cloner tries rebuilding the cache, but in a virtual document, so the Circle is copied over, but since there is no Next object in this virtual document it returns the default four points.

I'm not sure what the fix here is though. The plugin I'm working on behaves in a similar way where sometimes there would be no points returned, but when the cloner does this it's incorrectly returning points.

Thanks for the help,
Dan

Hi @ferdinand, thank you for your continued patience.

It might be helpful if you could line out what you are actually trying to do, because I think your current case is still a simplification, right?

The rest of my code isn't really relevant here, although it does follow the C4D norms more. Instead of using GetNext(), I use a link field and I have a float that would offset the points from the input spline based on the current frame.

I re-read through your posts but I'm still confused, sorry!

With what you wrote here:

The user advances the document frame to 1.
EVMSG_CHANGE is invoked, ObjectData::CheckDirtyis being called.
Your implementation is called, _prevFrame != currentframe evaluates as True.
You mark the node as dirty and set _prevFrame = currentframe;
Your GetContour is being called.
Now the user changes the order of the nodes in the scene.
EVMSG_CHANGE is invoked, ObjectData::CheckDirtyis being called.
Your implementation is called, _prevFrame != currentframe evaluates as False because we are still at the same frame.
Your GetContour is not being called.

That's not the case is it? I didn't remove the check of if the next object had been changed. So this happens:

Your implementation is called, _prevFrame != currentframe evaluates as False because we are still at the same frame.

But then : next != _nextCache would get checked and that would be true, so GetContour would be called, right? From what I understand adding _prevFrame != currentframe would have GetContour called more, not less, since there is another condition that could trigger it.

It also applies here that once you have run through your CheckDirty implementation for a frame all further evaluations for that frame will evaluate as false, because _prevFrame != currentframe is then false.

While the frame check would always return false, I don't understand why that stops the other check(s) from returning true and GetContour being called correctly. You said there are dozens of calls of CheckDirty, but can only one of them return as dirty and the rest are skipped after that?

Thanks,
Dan

Hi @ferdinand !

I didn't understand it to that degree, but that all seems to make sense and seems to be what's happening here, but I feel like something else is happening here in addition to that. It makes sense that Circle wouldn't update without more checks, but my concern is this.

When the _prevFrame != currentframe is implemented this is the result of having an empty spline underneath circle.

An empty spline is being fed to circle, so there should be no points returned. Instead its running the code:

  
    // This code is properly executed when you put either no or not a spline object next to the node.
    if (next == nullptr || next->GetType() != Ospline)
    {
        SplineObject* rs = SplineObject::Alloc(4, SPLINETYPE::LINEAR);
        if (!rs)
        {
            return nullptr;
        }
        Vector* padr = rs->GetPointW();
        padr[0] = Vector(100, 0, 0);
        padr[1] = Vector(0, 100, 0);
        padr[2] = Vector(-100, 0, 0);
        padr[3] = Vector(0, -100, 0);
        rs->Message(MSG_UPDATE);
        return rs;
    }

So its behaving as if there is no spline next, when there is. This only happens when this code is implemented.

 if (_prevFrame != currentframe)
    {
        _prevFrame = currentframe;
       
        op->SetDirty(DIRTYFLAGS::DATA);
    }

This doesn't seem to make sense to me, although I could be missing something simple.

Thanks for all of the help!
Dan

Thanks again, Ferdinand!

You're right about the errors in my code, some of them I just left in accidentally because of my rush to respond, sorry!

I didn't properly explain my problem, but after messing around with the differences between your and my code I came across the specific issue.

I added this to CheckDirty:

    Int32 currentframe = doc->GetTime().GetFrame(doc->GetFps());
     // checking if the frame has changed since the last check.
    if (_prevFrame != currentframe)
    {
        _prevFrame = currentframe;
       
        op->SetDirty(DIRTYFLAGS::DATA);
    }

And now when Empty Spline is underneath Circle, four points are returned when there should be nothing.

I don't quite understand why exactly. An extra update seems to be getting forced because of the frame check, but I'm not sure the way around it if I were doing something frame dependent.

All of the code:

#include "c4d.h"
#include "c4d_symbols.h"
#include "odoublecircle.h"
#include "main.h"

class DoubleCircleData : public ObjectData
{
    INSTANCEOF(DoubleCircleData, ObjectData)
    
public:
    virtual Bool Init(GeListNode* node);
    virtual SplineObject* GetContour(BaseObject* op, BaseDocument* doc, Float lod, BaseThread* bt);
    virtual void CheckDirty(BaseObject* op, BaseDocument* doc);
    
    static NodeData* Alloc() { return NewObjClear(DoubleCircleData); }
    
private:
    BaseObject* _nextCache = nullptr;
    Int32 _prevFrame = -1;
};

Bool DoubleCircleData::Init(GeListNode* node)
{
    BaseObject*         op = (BaseObject*)node;
    BaseContainer* data = op->GetDataInstance();
    if (!data)
        return false;
    
    data->SetFloat(CIRCLEOBJECT_RAD, 200.0);
    data->SetInt32(PRIM_PLANE, 0);
    data->SetBool(PRIM_REVERSE, false);
    data->SetInt32(SPLINEOBJECT_INTERPOLATION, SPLINEOBJECT_INTERPOLATION_ADAPTIVE);
    data->SetInt32(SPLINEOBJECT_SUB, 8);
    data->SetFloat(SPLINEOBJECT_ANGLE, DegToRad(5.0));
    data->SetFloat(SPLINEOBJECT_MAXIMUMLENGTH, 5.0);
    
    return true;
}

// Evaluate the dirty state of our node by checking if its next neighbor has changed.
void DoubleCircleData::CheckDirty(BaseObject* op, BaseDocument* doc)
{
    // Get the next node to object manager representation of our node and test with
    // the dirty state of our node by comparing it to our cached next node. If they
    // do not match, we ...
    BaseObject* next = op->GetNext();
    Int32 currentframe = doc->GetTime().GetFrame(doc->GetFps());
    // checking if the frame has changed since the last check.
    if (_prevFrame != currentframe)
    {
        _prevFrame = currentframe;
       
        op->SetDirty(DIRTYFLAGS::DATA);
    }
    if (next != _nextCache)
    {
        // ... update our cached next node and ...
        _nextCache = next;
        // ... we mark ourselves as dirty (that does not sound right ^^).
        op->SetDirty(DIRTYFLAGS::DATA);
    }
}

SplineObject* DoubleCircleData::GetContour(BaseObject* op, BaseDocument* doc, Float lod, BaseThread* bt)
{
    BaseContainer* bc = op->GetDataInstance();
    if (!bc)
        return nullptr;
    BaseObject* next = op->GetNext();
    
    // This code is properly executed when you put either no or not a spline object next to the node.
    if (next == nullptr || next->GetType() != Ospline)
    {
        SplineObject* rs = SplineObject::Alloc(4, SPLINETYPE::LINEAR);
        if (!rs)
        {
            return nullptr;
        }
        Vector* padr = rs->GetPointW();
        padr[0] = Vector(100, 0, 0);
        padr[1] = Vector(0, 100, 0);
        padr[2] = Vector(-100, 0, 0);
        padr[3] = Vector(0, -100, 0);
        rs->Message(MSG_UPDATE);
        return rs;
    }
    //else
    
    // In both cases, i.e., the spline with points and without points, your code will branch at runtime
    // into this condition. For a spline with no points the output will be then of course the same as
    // as your implicit 3rd case (which is unreachable). So if you want to react to empty splines, you
    // have to test fort that.
    SplineObject* inputspline = static_cast<SplineObject*>(next);
    Int32 pointcount = inputspline->GetPointCount();
    const Vector* points = inputspline->GetPointR();
    
    SplineObject* rs = SplineObject::Alloc(pointcount, SPLINETYPE::LINEAR);
    if (!rs)
    {
        return nullptr;
    }
    Vector* padr = rs->GetPointW();
    for (Int32 x = 0; x < pointcount; x++)
    {
        padr[x] = points[x];
    }
    rs->Message(MSG_UPDATE);
    return rs;
    
 
    
}

// be sure to use a unique ID obtained from www.plugincafe.com
#define ID_CIRCLEOBJECT 1001154
Bool RegisterCircle()
{
	return RegisterObjectPlugin(ID_CIRCLEOBJECT, GeLoadString(IDS_CIRCLE), OBJECT_GENERATOR | OBJECT_ISSPLINE, DoubleCircleData::Alloc, "Odoublecircle"_s, AutoBitmap("circle.tif"_s), 0);
}

Thanks for all of the help!

Dan

@ferdinand

Thanks, Ferdinand! That all makes sense. I was hoping that I was missing something because I had a larger problem that I thought this might have fixed. I'm not sure if I should make a new thread so I'll post my follow up question here.

I simplified my plugin down to just a modification to Double Circle.

SplineObject* DoubleCircleData::GetContour(BaseObject* op, BaseDocument* doc, Float lod, BaseThread* bt)
{
    BaseContainer* bc = op->GetDataInstance();
    if (!bc)
        return nullptr;
    BaseObject* next = op->GetNext();
    if (next==nullptr || next->GetType() != Ospline) // If it's not receiving a valid input return four points
    {
        
        SplineObject* rs = SplineObject::Alloc(4, SPLINETYPE::LINEAR);
        if (!rs)
        {
            return nullptr;
        }
         Vector*     padr = rs->GetPointW();
        padr[0] = Vector(100,0,0);
        padr[1] = Vector(0,100,0);
        padr[2] = Vector(-100,0,0);
        padr[3] = Vector(0,-100,0);
        rs->Message(MSG_UPDATE);
        return rs;
    }
    else if ( next->GetType() == Ospline) // if it's receiving a spline return those points instead
    {
        SplineObject* inputspline = static_cast<SplineObject*>(next);
        Int32 pointcount = inputspline->GetPointCount();
        const Vector * points = inputspline->GetPointR();
        
        SplineObject* rs = SplineObject::Alloc(pointcount, SPLINETYPE::LINEAR);
        if (!rs)
        {
            return nullptr;
        }
        Vector*     padr = rs->GetPointW();
        for (Int32 x = 0; x<pointcount; x++)
        {
            padr[x] = points[x];
        }
        rs->Message(MSG_UPDATE);
        return rs;
    }
    
   
    SplineObject* rs = SplineObject::Alloc(0, SPLINETYPE::LINEAR);
    if (!rs)
    {
        return nullptr;
    }
    rs->Message(MSG_UPDATE);
    return rs;
    
}

The code is pretty simple here, but when I use the Double Circle as an input to a Cloner I get strange results. I have a scene here. Cloner Oddness.c4d

When Spline With Points is after the circle the cloner works correctly, but when I swap the spline to the empty one then instead of getting no output, I get the output as if I didn't have a spline there.

From what I can tell the cloner is rebuilding the cache for the Circle in a different document, where the spline doesn't exist, and that happens to return the four points because of my code.

My question is why is the cloner forcing this rebuild when I return an empty spline to it initially? And is there a way around it. With my plugin there are times when an empty spline is the correct output, but the cloner is forcing unusual rebuilds like in this example.

Dan

Hello, I had a question about something in the C++ SDK underneath GetContour() it says:

GetContour()...


Returns
    The spline contour.
    If the generator does not produce any output (e.g. when the user chose wrong settings) it must at least return an (empty) Onull object, otherwise Cinema 4D will try to rebuild the cache again and again.
    Only return nullptr in the case of a memory error.

It seems like if you had a case where you would have invalid settings you would return an Onull as opposed to a spline. When I go to return an Onull in this circumstance though I have a crash. I did a quick test in the Circle example and this crashes.

SplineObject* DoubleCircleData::GetContour(BaseObject* op, BaseDocument* doc, Float lod, BaseThread* bt)
{
    BaseContainer* bc = op->GetDataInstance();
    if (!bc)
        return nullptr;
    SplineObject* bp = GenerateCircle(bc->GetFloat(CIRCLEOBJECT_RAD));
    if(bc->GetFloat(CIRCLEOBJECT_RAD) >500.0) // Added to test the case
    {
        return static_cast<SplineObject*>(BaseObject::Alloc(Onull));
    }
    if (!bp)
        return nullptr;
    BaseContainer* bb = bp->GetDataInstance();
    
    bb->SetInt32(SPLINEOBJECT_INTERPOLATION, bc->GetInt32(SPLINEOBJECT_INTERPOLATION));
    bb->SetInt32(SPLINEOBJECT_SUB, bc->GetInt32(SPLINEOBJECT_SUB));
    bb->SetFloat(SPLINEOBJECT_ANGLE, bc->GetFloat(SPLINEOBJECT_ANGLE));
    bb->SetFloat(SPLINEOBJECT_MAXIMUMLENGTH, bc->GetFloat(SPLINEOBJECT_MAXIMUMLENGTH));
    
    OrientObject(bp, bc->GetInt32(PRIM_PLANE), bc->GetBool(PRIM_REVERSE));
    
    return bp;
}

Am I misunderstanding something here? I thought the GetContour entry was pretty clear but I seem to be doing it wrong.

Thanks for any info,
Dan