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 have a plugin that I compiled for R20 and R24 and I'm noticing a difference between the two of them.

Here is my plugin in R20:

And here is in R24:

In R20 the description is redrawn as the cube is dragged over. In R24 it isn't redrawn despite GetDDescription being called.

Here is my code, which is the same for each version, but they're behaving differently.

Bool ShortTest::GetDDescription(GeListNode *node,  Description *description,  DESCFLAGS_DESC &flags)
{
  
    if (!description->LoadDescription(node->GetType()))
    {
       
    }
    BaseObject* op = static_cast<BaseObject*>(node);
    if (op == nullptr)
    {
        return FALSE;
    }

    const DescID *singleid = description->GetSingleDescID();
    
    
    DescID cid;
    BaseContainer* datainstance = op->GetDataInstance();
    
  
    DescID DescGroup = DescLevel(2000,  DTYPE_GROUP,  0);
    
    Int32 idShowNothing = 1;
    Int32 idShowEverything = 2;
    Int32 idMode = 10001;
    if (!singleid || DescGroup.IsPartOf(*singleid,  NULL))
    {
        BaseContainer bc;
        bc = GetCustomDataTypeDefault(DTYPE_GROUP);
        bc.SetString(DESC_NAME,  "Object"_s);
        
        
        bc.SetInt32(DESC_COLUMNS,  1);
        bc.SetFloat(DESC_DEFAULT,  1);
        bc.SetBool(DESC_SCALEH,  TRUE);
        bc.SetBool(DESC_DEFAULT,  TRUE);
        
        if (!description->SetParameter(DescGroup,  bc,  DescLevel(1057950)))
        {
            return TRUE;
        }
    }
    
    cid = DescLevel(idMode, DTYPE_LONG, 0);
    if (!singleid || cid.IsPartOf(*singleid, NULL))
    {
        
        
        BaseContainer bc;
        bc = GetCustomDataTypeDefault(DTYPE_LONG);
        bc.SetBool(DESC_FORBID_SCALING, TRUE);
        bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
        bc.SetBool(DESC_GUIOPEN, TRUE);
        bc.SetString(DESC_NAME, "Test                                   "_s);
        BaseContainer MeasureDivisionNames;
        //  if (ModifiersNames == emptyBC) return TRUE;
        
        MeasureDivisionNames.SetString(idShowNothing, "Show Nothing"_s);
        MeasureDivisionNames.SetString(idShowEverything, "Show Parameters"_s);
        
        bc.SetInt32(DESC_CUSTOMGUI, ID_QUICKTABSRADIO_GADGET);
        bc.SetContainer(DESC_CYCLE, MeasureDivisionNames);
        if (!description->SetParameter(cid, bc, DescGroup))
            return TRUE;
    }
    
    if(datainstance->GetInt32(idMode) == idShowEverything)
    {
        
        cid = DescLevel(2002,  DTYPE_REAL,  0);
        if (!singleid || cid.IsPartOf(*singleid,  NULL))
        {
            BaseContainer bc;
            bc = GetCustomDataTypeDefault(DTYPE_REAL);
            bc.SetInt32(DESC_UNIT,FORMAT_DEGREE);
            bc.SetBool(DESC_FORBID_SCALING,  TRUE);
            bc.SetBool(DESC_FORBID_INLINE_FOLDING,  FALSE);
            bc.SetString(DESC_NAME,  "Test 1"_s);
            BaseContainer MeasureDivisionNames;
            
            
            if (!description->SetParameter(cid,  bc,  DescGroup))
                return TRUE;
        }
        cid = DescLevel(2003,  DTYPE_VECTOR,  0);
        if (!singleid || cid.IsPartOf(*singleid,  NULL))
        {
            BaseContainer bc;
            bc = GetCustomDataTypeDefault(DTYPE_VECTOR);
            bc.SetBool(DESC_FORBID_SCALING,  TRUE);
            bc.SetBool(DESC_FORBID_INLINE_FOLDING,  FALSE);
            bc.SetString(DESC_NAME,  "Test 2"_s);
            BaseContainer MeasureDivisionNames;
            
            
            if (!description->SetParameter(cid,  bc,  DescGroup))
                return TRUE;
        }
        cid = DescLevel(2004,  DTYPE_BOOL,  0);
        if (!singleid || cid.IsPartOf(*singleid,  NULL))
        {
            BaseContainer bc;
            bc = GetCustomDataTypeDefault(DTYPE_BOOL);
            bc.SetBool(DESC_FORBID_SCALING,  TRUE);
            bc.SetBool(DESC_FORBID_INLINE_FOLDING,  FALSE);
            bc.SetString(DESC_NAME,  "Test 3"_s);
            BaseContainer MeasureDivisionNames;
            
            
            if (!description->SetParameter(cid,  bc,  DescGroup))
                return TRUE;
        }
        
        cid = DescLevel(2005,  DTYPE_BOOL,  0);
        if (!singleid || cid.IsPartOf(*singleid,  NULL))
        {
            BaseContainer bc;
            bc = GetCustomDataTypeDefault(DTYPE_BOOL);
            bc.SetBool(DESC_FORBID_SCALING,  TRUE);
            bc.SetBool(DESC_FORBID_INLINE_FOLDING,  FALSE);
            bc.SetString(DESC_NAME,  "Test 4"_s);
            BaseContainer MeasureDivisionNames;
            
            
            if (!description->SetParameter(cid,  bc,  DescGroup))
                return TRUE;
        }
        cid = DescLevel(2006,  DTYPE_BOOL,  0);
        if (!singleid || cid.IsPartOf(*singleid,  NULL))
        {
            BaseContainer bc;
            bc = GetCustomDataTypeDefault(DTYPE_BOOL);
            bc.SetBool(DESC_FORBID_SCALING,  TRUE);
            bc.SetBool(DESC_FORBID_INLINE_FOLDING,  FALSE);
            bc.SetString(DESC_NAME,  "Test 5"_s);
            BaseContainer MeasureDivisionNames;
            
            
            if (!description->SetParameter(cid,  bc,  DescGroup))
                return TRUE;
        }
        
    
    }
    flags |= DESCFLAGS_DESC::LOADED| DESCFLAGS_DESC::RECURSIONLOCK;
    
    return SUPER::GetDDescription(node,  description,  flags);
}

Any idea why there is the difference between versions of Cinema?

Thanks, Dan

Thanks, that was exactly what I needed!

Here's the code I wrote. From what I can tell it gets the job done but it seems to get slow fast when the caches get big. Is there a better way to do this?

CompleteDirtyCheck(BaseObject* checkobject, DIRTYFLAGS flags, maxon::BaseArray<Int32>* dirtyvalues)
{
    if (checkobject == nullptr)
    {
        return ;
    }
    
    Int32 dvalue = checkobject->GetDirty(flags);
    dirtyvalues->Append(dvalue);
    BaseObject* cache = checkobject->GetCache();
    if (cache == nullptr)
    {
        return;
    }
    maxon::BaseArray<BaseObject*> caches;
    GetChildren(cache, &caches);
    Int32 childcount = caches.GetCount();
    for (Int32 x = 0; x<childcount; x++)
    {
        BaseObject* subcache = caches[x]->GetCache();
        
        CompleteDirtyCheck(subcache,flags,dirtyvalues);
        
        Int32 dirtyvalue = caches[x]->GetDirty(flags);
        dirtyvalues->Append(dirtyvalue);
        BaseObject* deformcache = caches[x]->GetDeformCache();
        if (deformcache!=nullptr)
        {
            
            Int32 dirtyvalue2 = deformcache->GetDirty(flags);
            dirtyvalues->Append(dirtyvalue2);
        }
    }
    

Hello! I'm having an issue with detecting whether and input object is dirty or not. For reference here is my scene file: Voronoi Fracture.c4d

My understanding is that the Random Effector is making changes to making changes to the Voronoi Fracture's Cache.

I don't understand why checking GetDirty(DIRTYFLAGS::CACHE) isn't returning dirty in this case. Is there something beyond that should be done?

The other test I was doing was browsing through the cache via GetCache(), GetDown and GetNext and checking each individual part of the Cache for it being dirty. This does correctly return whether it is dirty or not, but this really slow to me, especially for something that would be running so often.

What is the best way to reliably get if the Voronoi Fracture is dirty?

Dan

Hi Maxime,

I don't fully understand what you mean. Does my object being a child of the effector matter? If my object is a child of the effector how would I get the result from it?

Dan

Hello!

Is it possible to sample an Effector like it is a Field?

I've done some searching around, but I'm not super familiar with Effectors so I'm not sure if I 100% understand them. I'm looking to do something similar to the MoSpline, where I could feed in a vector and get an output to create something from.

Is there a manual or post to reference? I saw a few, but they don't seem to be exactly on this topic or I missed them.

Thanks,
Dan

Hi @ferdinand !

Thank you for all the help! I think that wraps up my question, not the answer I wanted, but it all makes sense and I know a bit more about what how Fields work.

I'll look into ModifyObjects more as well.

Dan

Hi @ferdinand , thank you for the impressive write up!

I'm not the most familiar with Deformers, so I have a couple of questions on that front. This does seem out of scope of the initial question, but I'm not sure if I should make a different thread or not.

With your cube example: This works because the Bulge deformer is looking at Cache of the Cube and then returning the Deform Cache of it, right? So there is no infinite loop because it isn't modify the Deform Cache.

Is a Deformer capable of doing what I need it to in this case? My understanding is that a Deformer generally moves points around and the like. What I want is to get a float value from the Field to then generator a different cache with that value in GetContour. This wouldn't be just moving points around, but creating completely new ones or utterly changes existing ones.

This seems like it would have the same problem, since my main plugin wouldn't be modified, but recalculating based on changes from the Deformer. So the Cache would rebuild which would trigger infinite rebuilds as a result.

Dan

Hi @ferdinand!

At the moment I'm using the Fields within GetContour. I want to use the field list at FIELDS to just get an output value, based on vectors I'm passing it. I'm using C4D Falloff to get the values. Then with the output value/weights I'm determining the length of my spline. from what I can tell it seems like the crash is occurring because my plugin is now referencing itself and continuously. The plugin changes, so the length of the spline changes from the field so the plugin changes, and so on.

This is my code super trimmed down:

GetContour(BaseObject *      op,
                                      BaseDocument *      doc,
                                      Float      lod,
                                      BaseThread *      bt
                                      )
{
  
    
    GeData data;
    const DescID fieldParameterID(FIELDS);
    
    maxon::BaseArray< maxon::BaseArray<Vector> >  allpositions;
    if (!op->GetParameter(fieldParameterID, data, DESCFLAGS_GET::NONE))
    {
          SplineObject* spline = SplineObject::Alloc(2, SPLINETYPE::LINEAR);
        return spline;
    }
    CustomDataType* const customData = data.GetCustomDataType(CUSTOMDATATYPE_FIELDLIST);
    FieldList* const  fieldList = static_cast<FieldList*>(customData);
    if (!fieldList)
    {
        SplineObject* spline = SplineObject::Alloc(2, SPLINETYPE::LINEAR);
        return spline;
    }
    Int32 fieldListCount = 0;
    if (fieldList)
        fieldListCount = fieldList->GetCount();
    Int32 pointcount =1;
    Float weight = 0;
    if (fieldListCount > 0)
    {
        maxon::BaseArray<maxon::Vector> positions;
        maxon::BaseArray<maxon::Vector> uvws;
        maxon::BaseArray<maxon::Vector> directions;
        
     
        
        resultVoid = positions.Resize(pointcount);
        resultVoid = uvws.Resize(pointcount);
        resultVoid = directions.Resize(pointcount);
        
        
        
        Vector   pos = op->GetMg().off;
        
        
        
        
        
        FieldInput points(positions.GetFirst(), directions.GetFirst(), uvws.GetFirst(), 1, Matrix());
        falloff->PreSample(doc, op, points, FIELDSAMPLE_FLAG::VALUE);
        
        
        
        falloff->Sample(pos, &weight, TRUE, 0.0, nullptr, 0);
        
        
    }
    SplineObject* spline = SplineObject::Alloc(2, SPLINETYPE::LINEAR);
    Vector* points = spline->GetPointW();
    points[0] = Vector(0,100,0);
    points[0] = Vector(0,100,500*weight);
    
    return spline}




//From GeGDescription

  cid = DescLevel(FIELDS, CUSTOMDATATYPE_FIELDLIST, 0);
    if (!singleid || cid.IsPartOf(*singleid, NULL))
    {
        
        BaseContainer bc;
        
        
        bc = GetCustomDataTypeDefault(CUSTOMDATATYPE_FIELDLIST);
        bc.SetBool(DESC_FIELDLIST_NOCOLOR, TRUE);
        bc.SetBool(DESC_FIELDLIST_NODIRECTION, TRUE);
        bc.SetBool(DESC_FIELDLIST_NOROTATION, TRUE);
        BaseContainer acceptedObjects;
        acceptedObjects.InsData(ID_RKTRicochet, String());//matrix
        
        bc.SetString(DESC_NAME, "Field"_s);
        bc.SetBool(DESC_ANIMATE, true);
        if (!description->SetParameter(cid, bc, fieldgroup))
            return TRUE; 
        
    }



//From Check Dirty

   GeData data;
    UInt32 falloffSum = 0;
    Bool superdirty = false;
    const DescID fieldParameterID(FIELDS);
    if (op->GetParameter(fieldParameterID, data, DESCFLAGS_GET::NONE))
    {
        CustomDataType* const customData = data.GetCustomDataType(CUSTOMDATATYPE_FIELDLIST);
        FieldList* const  fieldList = static_cast<FieldList*>(customData);
        //UInt32 falloffSum = 0;
        if (fieldList)
        {
            BaseContainer *dataInstance = op->GetDataInstance();
            falloffSum = falloff->GetDirty(doc, dataInstance);
            
        }
        if (falloffSum != fieldDirty)
        {
            fieldDirty = falloffSum;
            dirty = TRUE;
        }
    }

Dan

Hi @ferdinand! I've been messing around with your code and I think I have it sort of working as I need.

The problem I'm running into at the moment is that it would be possible to drag a Group Field into the plugin, and then as a separate action drag the plugin into that group, thereby still creating the feedback loop. So to prevent that I would need to check on the fields being used before I run my code, instead of when something is being dragged and dropped.

Is there a simpler way to handle this interaction? I'm worried that I might miss some case and it could cause an infintite loop of the plugin referencing itself via the fields.

Dan