Getting Dependence of Object



  • Hello!

    I'm working on a plugin were I want to take an input child object spline and use its points as a basis for an output. I'm able to get when the object is dirty reliably and only update when I have to. But when I have an object like an Oinstance or an Oconnector, I'm not getting a dirty message from them if the object inputting into them has been updated.

    Aside from manually checking the object type and checking INSTANCEOBJECT_LINK and CONNECTOBJECT_LINK respectively I can't figure out a way to get if they have actually updated and therefore I have to update.

    Is there way to get the dependence list for a given object so I can manually check it? Since the linked connect/instance isn't being marked as dirty I don't know another approach to use. Or is there a better way to know when an input into one of those objects has updated?

    Dan



  • hello

    I was trying to do what you want for your project and maybe i found something. (pick a hierarchy and return a spline)

    Seems that you can use GetAndCheckHierarchyClone()
    This function check if something have changed. Return A hierarchy of PolygonObject or SplineObject so you don't have to use makeeditable or get cache or what ever.

    I didn't thought immediately but you can add several flag like so HIERARCHYCLONEFLAGS::ASPOLY | HIERARCHYCLONEFLAGS::ASSPLINE

    This function return the cache if nothing have changed.

    I've created a function to create a BaseArray of all objects but you can pick your own solution.

    
    maxon::BaseArray<BaseObject*> PC11572::HierarchyIterator(BaseObject* obj)
    {
    	maxon::BaseArray<BaseObject*> objArray;
    	while (obj != nullptr)
    	{
    		objArray.Append(obj);
    		// we can append the array from another array.
    		objArray.Append(HierarchyIterator(obj->GetDown()));
    		obj = obj->GetNext();
    	}
    	
    	return objArray;
    }
    
    
    BaseObject* PC11572::GetVirtualObjects(BaseObject *op, HierarchyHelp *hh)
    {
    	
    	if (op == nullptr || hh == nullptr)
    	{
    		return BaseObject::Alloc(Onull);
    	}
    
    	BaseObject* firstChild = op->GetDown();
    
    
    	if (firstChild == nullptr)
    	{
    		return nullptr;
    	}
    
    	BaseObject* res = nullptr;
    	
    	Bool dirty = false;
    	AutoAlloc <AliasTrans> trans;
    	if (!trans) return nullptr;
    	if (!trans->Init(hh->GetDocument())) return nullptr;
    
    	res = op->GetAndCheckHierarchyClone(hh, firstChild, HIERARCHYCLONEFLAGS::ASPOLY | HIERARCHYCLONEFLAGS::ASSPLINE, &dirty, trans, true);
    	trans->Translate(true);
    
    	if (!res)
    	{
    		return BaseObject::Alloc(Onull);;
    	}
    
    	if (dirty)
    	{
    		DiagnosticOutput("This is dirty Create a new spline");
    		// Gets an array of every object 
    		maxon::BaseArray<BaseObject*> myList = HierarchyIterator(res);
    		// Creates a new spline
    		SplineObject* newSpline = SplineObject::Alloc(0, SPLINETYPE::LINEAR);
    		// Gets the revers Matrix (to go from global space to local space
    		const Matrix invOpMg = ~op->GetMg();
    		
    		maxon::Int32 lastPoint = 0;
    
    		for (auto &child : myList)
    		{
    			// The object should already be Opoint or Ospline but extra check doesn't hurt
    			if (child->IsInstanceOf(Opoint) || child->IsInstanceOf(Ospline))
    			{
    				const maxon::Int32 pcnt = ToPoly(child)->GetPointCount();
    				const Vector* childPadr = ToPoly(child)->GetPointR();
    
    				// Don't waste time if there's no point to add
    				if (pcnt == 0)
    					continue;
    
    				// Resizes the spline without changing the Segment number (one segment should be created for each object / each spline segment)
    				newSpline->ResizeObject(lastPoint + pcnt, 1);
    				// Gets write access to the points
    				Vector* padr = newSpline->GetPointW();
    				// Gets the first element in the writable segments array
    				Segment* seg = newSpline->GetSegmentW();
    				// Changes the number of points in that segment
    				seg->cnt = lastPoint + pcnt;
    				// Gets the matrix of the child to go from local to global
    				const Matrix childMg = child->GetMg();
    
    				for (maxon::Int32 i = lastPoint, j = 0 ; i < lastPoint + pcnt; i++, j++)
    				{
    					// Updates the points position from child, by going from local to global to local.
    					padr[i] = invOpMg * (childMg * childPadr[j]);
    				}
    				// Updates last points index so the next object will go behind.
    				lastPoint += pcnt;
    			}
    
    		}
    		return newSpline;
    
    	}
    	else
    	{
    		DiagnosticOutput("There nothing to do");
    		// returning res because GetAndCheckHierarchyClone return cache if not dirty
    		return res;
    	}
    
    	
    	return BaseObject::Alloc(Onull);
    	
    	
    }
    
    

    Cheers
    Manuel



  • hello,

    this topics will be considered as resolved if you have nothing to add.

    Cheers
    Manuel


Log in to reply