Deformer update and Fields

[Valkaari]

hello,

i'm creating a deformer and i want to add the new falloff / fields option.
everything seem to work fine but the deformer doesn't update when i move / modify a linear field or any field i've added.
(the function modifyObject() isn't called)

If i change frame or force the update with the a key, it does work.

[Valkaari]

using the CheckDirty function seem to be the solution.

void Spherify::CheckDirty(BaseObject* op, BaseDocument* doc)
{
	if (falloff)
	{
		BaseContainer *data = op->GetDataInstance();
		Int32 dirty = falloff->GetDirty(doc, data);
		if (dirty == lastFalloffDirtyCheck) 
                      return;
		op->SetDirty(DIRTYFLAGS::DATA);
		lastFalloffDirtyCheck = dirty;
	}
		
}

the full code for the spherify deformer :

// deformer object example

#include "c4d.h"
#include "c4d_symbols.h"
#include "main.h"
#include "ospherifydeformer.h"
#include "c4d_falloffdata.h"


#define HANDLE_CNT 2

class Spherify : public ObjectData
{
public:
	virtual Bool Init(GeListNode* node);

	virtual Bool Message			(GeListNode* node, Int32 type, void* data);
	virtual void GetDimension		(BaseObject* op, Vector* mp, Vector* rad);
	virtual DRAWRESULT Draw			(BaseObject* op, DRAWPASS type, BaseDraw* bd, BaseDrawHelp* bh);
	virtual void GetHandle			(BaseObject* op, Int32 i, HandleInfo& info);
	virtual Int32 DetectHandle		(BaseObject* op, BaseDraw* bd, Int32 x, Int32 y, QUALIFIER qualifier);
	virtual Bool MoveHandle			(BaseObject* op, BaseObject* undo, const Vector& mouse_pos, Int32 hit_id, QUALIFIER qualifier, BaseDraw* bd);
	virtual Bool ModifyObject		(BaseObject* op, BaseDocument* doc, BaseObject* mod, const Matrix& op_mg, const Matrix& mod_mg, Float lod, Int32 flags, BaseThread* thread);



	
	AutoAlloc<C4D_Falloff>		falloff;
	Int32						lastFalloffDirtyCheck;
	
	virtual Int32				GetHandleCount(BaseObject *op);
	
	virtual void				SetHandle(BaseObject *op, Int32 i, Vector p, const HandleInfo &info);
	virtual Bool				CopyTo(NodeData *dest, GeListNode *snode, GeListNode *dnode, COPYFLAGS flags, AliasTrans *trn);
	virtual Bool				GetDDescription(GeListNode *node, Description *description, DESCFLAGS_DESC &flags);
	virtual Bool            AddToExecution(BaseObject *op, PriorityList *list);
	virtual EXECUTIONRESULT Execute(BaseObject *op, BaseDocument *doc, BaseThread *bt, Int32 priority, EXECUTIONFLAGS flags);
	virtual void				CheckDirty(BaseObject* op, BaseDocument* doc);


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



Int32 Spherify::GetHandleCount(BaseObject *op)
{
	BaseContainer *bc = op->GetDataInstance();
	if (!bc) 
		return 0;
	if (falloff) 
		return falloff->GetHandleCount(bc) + HANDLE_CNT;
	return 0;
}

void Spherify::SetHandle(BaseObject *op, Int32 i, Vector p, const HandleInfo &info)
{
	BaseContainer *bc = op->GetDataInstance();
	if (!bc) 
		return;
	if (falloff) 
		falloff->SetHandle(i, p, bc, info);
}

Bool Spherify::CopyTo(NodeData *dest, GeListNode *snode, GeListNode *dnode, COPYFLAGS flags, AliasTrans *trn)
{
	Spherify *df = (Spherify*)dest;
	if (!df) 
		return false;
	if (falloff && df->falloff)
		if (!falloff->CopyTo(df->falloff)) 
			return false;
	return ObjectData::CopyTo(dest, snode, dnode, flags, trn);
}

Bool Spherify::GetDDescription(GeListNode *node, Description *description, DESCFLAGS_DESC &flags)
{
	BaseObject *op = (BaseObject*)node;
	if (!op) 
		return false;
	BaseContainer *data = op->GetDataInstance();
	if (!data) 
		return false;

	if (!description->LoadDescription(op->GetType())) 
		return false;

	//---------------------------------
	// Add the falloff interface
	if (falloff)
	{
		if (!falloff->SetMode(FIELDS, data)) // The falloff parameters have to have been setup before it can be added to the description, this like makes sure of that
			return false; 
		if (!falloff->AddFalloffToDescription(description, data, DESCFLAGS_DESC::NONE)) 
			return false;
	}

	flags |= DESCFLAGS_DESC::LOADED;

	return true;
}


void Spherify::CheckDirty(BaseObject* op, BaseDocument* doc)
{
	if (falloff)
	{
		BaseContainer *data = op->GetDataInstance();
		Int32 dirty = falloff->GetDirty(doc, data);
		if (dirty == lastFalloffDirtyCheck) 
                        return;
		op->SetDirty(DIRTYFLAGS::DATA);
		lastFalloffDirtyCheck = dirty;
	}
		
}

Bool Spherify::AddToExecution(BaseObject *op, PriorityList *list) {
	list->Add(op, EXECUTIONPRIORITY_INITIAL, EXECUTIONFLAGS::NONE);
	return TRUE;

}
EXECUTIONRESULT Spherify::Execute(BaseObject *op, BaseDocument *doc, BaseThread *bt, Int32 priority, EXECUTIONFLAGS flags)
{
	BaseContainer *data = op->GetDataInstance();
	if (!data)
		return EXECUTIONRESULT::USERBREAK;

	if (falloff)
		if (!falloff->InitFalloff(data, doc, op)) 
			return EXECUTIONRESULT::OUTOFMEMORY;
	return EXECUTIONRESULT::OK;
}



Bool Spherify::Message(GeListNode* node, Int32 type, void* data)
{
	if (type == MSG_MENUPREPARE)
	{
		((BaseObject*)node)->SetDeformMode(true);
	}
	return true;
}

Bool Spherify::ModifyObject(BaseObject* mod, BaseDocument* doc, BaseObject* op, const Matrix& op_mg, const Matrix& mod_mg, Float lod, Int32 flags, BaseThread* thread)
{


	BaseContainer* data = mod->GetDataInstance();

	Vector	 p, *padr = nullptr;
	Matrix	 m, im;
	Int32		 i, pcnt;
	Float		 rad = data->GetFloat(SPHERIFYDEFORMER_RADIUS), strength = data->GetFloat(SPHERIFYDEFORMER_STRENGTH);
	Float		 s;
	Float32* weight = nullptr;

	if (!op->IsInstanceOf(Opoint))
		return true;

	padr = ToPoint(op)->GetPointW();
	pcnt = ToPoint(op)->GetPointCount();
	if (!pcnt)
		return true;


	FieldInput inputs(padr, pcnt, op_mg);
	Bool outputsOK = falloff->PreSample(doc, mod, inputs, FIELDSAMPLE_FLAG::VALUE);
	Float fallOffSampleValue(1.0);


	weight = ToPoint(op)->CalcVertexMap(mod);

	m	 = (~mod_mg) * op_mg;	// op  ->  world  ->  modifier
	im = ~m;



	for (i = 0; i < pcnt; i++)
	{
		if (thread && !(i & 63) && thread->TestBreak())
			break;
		p = m * padr[i];
		s = strength;
		if (weight)
			s *= weight[i];
		if (outputsOK)
			falloff->Sample(p, &fallOffSampleValue, true, 0.0, nullptr, i);
		s *= fallOffSampleValue;
		p = s * (!p * rad) + (1.0 - s) * p;
		padr[i] = im * p;
	}

	DeleteMem(weight);
	op->Message(MSG_UPDATE);

	return true;
}

void Spherify::GetDimension(BaseObject* op, Vector* mp, Vector* rad)
{
	BaseContainer* data = op->GetDataInstance();
	*mp	 = Vector(0.0);
	*rad = Vector(data->GetFloat(SPHERIFYDEFORMER_RADIUS));
}

DRAWRESULT Spherify::Draw(BaseObject* op, DRAWPASS drawpass, BaseDraw* bd, BaseDrawHelp* bh)
{

	if (!op->GetDeformMode()) 
		return DRAWRESULT::SKIP;
	BaseContainer *bc = op->GetDataInstance();
	if (!bc) 
		return DRAWRESULT::FAILURE;
	if (falloff) 
		falloff->Draw(bd, bh, drawpass, bc);
	

	if (drawpass == DRAWPASS::OBJECT)
	{
		BaseContainer* data = op->GetDataInstance();
		Float	 rad = data->GetFloat(SPHERIFYDEFORMER_RADIUS);
		Matrix m = bh->GetMg();

		m.sqmat *= rad;

		bd->SetMatrix_Matrix(nullptr, Matrix());
		bd->SetPen(bd->GetObjectColor(bh, op));
		bd->DrawCircle(m);
		maxon::Swap(m.sqmat.v2, m.sqmat.v3);
		bd->DrawCircle(m);
		maxon::Swap(m.sqmat.v1, m.sqmat.v3);
		bd->DrawCircle(m);
	}
	else if (drawpass == DRAWPASS::HANDLES)
	{
		Int32			 i;
		Int32			 hitid = op->GetHighlightHandle(bd);
		HandleInfo info;

		bd->SetPen(GetViewColor(VIEWCOLOR_ACTIVEPOINT));
		bd->SetMatrix_Matrix(op, bh->GetMg());
		for (i = 0; i < HANDLE_CNT; i++)
		{
			GetHandle(op, i, info);
			if (hitid == i)
				bd->SetPen(GetViewColor(VIEWCOLOR_SELECTION_PREVIEW));
			else
				bd->SetPen(GetViewColor(VIEWCOLOR_ACTIVEPOINT));
			bd->DrawHandle(info.position, DRAWHANDLE::BIG, 0);
		}

		GetHandle(op, 1, info);
		bd->SetPen(GetViewColor(VIEWCOLOR_ACTIVEPOINT));
		bd->DrawLine(info.position, Vector(0.0), 0);
	}
	return DRAWRESULT::OK;
}

void Spherify::GetHandle(BaseObject* op, Int32 i, HandleInfo& info)
{
	BaseContainer* data = op->GetDataInstance();
	if (!data)
		return;
	
	
	if (falloff)  
		falloff->GetHandle(i, data, info);

	switch (i)
	{
		case 0:
			info.position.x	 = data->GetFloat(SPHERIFYDEFORMER_RADIUS);
			info.direction.x = 1.0;
			info.type = HANDLECONSTRAINTTYPE::LINEAR;
			break;

		case 1:
			info.position.x	 = data->GetFloat(SPHERIFYDEFORMER_STRENGTH) * 1000.0;
			info.direction.x = 1.0;
			info.type = HANDLECONSTRAINTTYPE::LINEAR;
			break;

		default: 
			break;
	}
}

Int32 Spherify::DetectHandle(BaseObject* op, BaseDraw* bd, Int32 x, Int32 y, QUALIFIER qualifier)
{
	if (qualifier & QUALIFIER::CTRL)
		return NOTOK;

	HandleInfo info;
	Matrix		 mg = op->GetMg();
	Int32			 i, ret = NOTOK;
	Vector		 p;

	for (i = 0; i < HANDLE_CNT; i++)
	{
		GetHandle(op, i, info);
		if (bd->PointInRange(mg * info.position, x, y))
		{
			ret = i;
			if (!(qualifier & QUALIFIER::SHIFT))
				break;
		}
	}
	return ret;
}

Bool Spherify::MoveHandle(BaseObject* op, BaseObject* undo, const Vector& mouse_pos, Int32 hit_id, QUALIFIER qualifier, BaseDraw* bd)
{
	BaseContainer* dst = op->GetDataInstance();

	HandleInfo info;

	Float val = mouse_pos.x;
	GetHandle(op, hit_id, info);

	if (bd)
	{
		Matrix mg	 = op->GetUpMg() * undo->GetMl();
		Vector pos = bd->ProjectPointOnLine(mg * info.position, mg.sqmat * info.direction, mouse_pos.x, mouse_pos.y);
		val = Dot(~mg * pos, info.direction);
	}

	switch (hit_id)
	{
		case 0:
			dst->SetFloat(SPHERIFYDEFORMER_RADIUS, ClampValue(val, 0.0_f, (Float) MAXRANGE));
			break;

		case 1:
			dst->SetFloat(SPHERIFYDEFORMER_STRENGTH, Clamp01(val * 0.001));
			break;

		default:
			break;
	}
	return true;
}

Bool Spherify::Init(GeListNode* node)
{
	BaseObject*		 op = (BaseObject*)node;
	BaseContainer* data = op->GetDataInstance();

	data->SetFloat(SPHERIFYDEFORMER_RADIUS, 200.0);
	data->SetFloat(SPHERIFYDEFORMER_STRENGTH, 0.5);
	
	if (falloff)
	{
		if (!falloff->InitFalloff(nullptr, nullptr, op))
			return false;
		lastFalloffDirtyCheck = -1;
	}


	return true;
}

// be sure to use a unique ID obtained from www.plugincafe.com
#define ID_SPHERIFYOBJECT 1001158

Bool RegisterSpherify()
{
	return RegisterObjectPlugin(ID_SPHERIFYOBJECT, GeLoadString(IDS_SPHERIZE), OBJECT_MODIFIER | OBJECT_CALL_ADDEXECUTION, Spherify::Alloc, "Ospherifydeformer"_s, AutoBitmap("spherify.tif"_s), 0);
}