Your browser does not seem to support JavaScript. As a result, your viewing experience will be diminished, and you have been placed in read-only mode.

Please download a browser that supports JavaScript, or enable it if it's disabled (i.e. NoScript).

JohnTerenece

@JohnTerenece

Reputation

Posts

Profile views

Followers

Following

Joined Last Online

Best posts made by JohnTerenece

RE: DESC_PARENT_COLLAPSE Display

Thanks for the response.

DESC_GUIOPEN works having the twirl down open by default. What I'm looking for is the ability to modify whether or not it is actively open based on controls by the user. For example if "Angle Threshold" is greater than 90 degrees than have it twirled down, otherwise have it closed.

John Terenece

posted in Plugin Development with Cinema 4D •

Latest posts made by JohnTerenece

Effector Updates

Hello,

I am working on a plugin that uses an In/Exclude list that the user will fill with Effectors and then I will use the new position provided from the Effectors to do other things.

My issue comes in when I initially drop an Effector into the In/Exclude while in R25. The initial values that I get from the Effectors are different than the ones I get from the next time it runs on a refresh.

This isn't an issue in other versions of Cinema because the code runs again immediately with the expected Effector values, meanwhile in R25 it doesn't run a second time until something causes a Cinema refresh which would cause a visual problem in my full plugin because the Effector values are not correct.

Video of the issue in R25

Running same circumstance in R23

I've only run into this issue in R25 with this particular In/Exclude for Effectors, in R25 with an In/Exclude for BaseObjects I haven't had this refresh issue. In R20 through R24 I haven't had this issue with any In/Exclude.

Below is the complete code trimmed down with the problem with the points shown via prints.

#define ID_EFFECTORTEST 1055750

#include "c4d.h"
#include "c4d_gui.h"
#include "c4d_baseeffectordata.h"
#include "customgui_inexclude.h"

class EffectorTestClass : public ObjectData
{
	INSTANCEOF(EffectorTestClass, ObjectData)

public:
	virtual Bool Init(GeListNode* node);
	virtual Bool Message(GeListNode* node, Int32 type, void* data);
	virtual SplineObject* GetContour(BaseObject* op, BaseDocument* doc, Float lod, BaseThread* bt);
	virtual void CheckDirty(BaseObject *op, BaseDocument *doc);
	static NodeData* Alloc() { return NewObjClear(EffectorTestClass); }
	virtual Bool GetDDescription(GeListNode *node, Description *description, DESCFLAGS_DESC &flags);
	virtual void RunEffectors(BaseObject *op, BaseDocument *doc, PolygonObject *poly);

	maxon::BaseArray<BaseObject*> compareDirtyObj;
	maxon::BaseArray<UInt32> dirtyNumber;

	maxon::Result<void> resultVoid;
	maxon::Result<Int32> resultInt;
	maxon::Result<Vector> resultVector;
	maxon::Result<BaseObject*> resultBaseObject;

	UInt32 opDirtyCount = 0;
};


enum Controls
{
	idMainTab = 100000,
	idEffectorList,

};

Bool EffectorTestClass::Message(GeListNode* node, Int32 type, void* data)
{
	return SUPER::Message(node, type, data);
}

Bool EffectorTestClass::GetDDescription(GeListNode *node, Description *description, DESCFLAGS_DESC &flags)
{
	BaseContainer *datainstance;
	const DescID *singleid;
	if (!description->LoadDescription(node->GetType()))
	{
	}

	datainstance = ((BaseList2D*)node)->GetDataInstance();
	if (!datainstance)
		return FALSE;
	singleid = description->GetSingleDescID();
	DescID cid;

	DescID DescMainTabGroup = DescLevel(idMainTab, DTYPE_GROUP, 0);
	if (!singleid || DescMainTabGroup.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_GROUP);
		bc.SetString(DESC_NAME, "Effector Test"_s);

		bc.SetInt32(DESC_COLUMNS, 1);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_SCALEH, TRUE);

		if (!description->SetParameter(DescMainTabGroup, bc, DescLevel(ID_EFFECTORTEST)))
			return TRUE;
	}

	cid = DescLevel(idEffectorList, CUSTOMDATATYPE_INEXCLUDE_LIST, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(CUSTOMGUI_INEXCLUDE_LIST);

		bc.SetString(DESC_NAME, "Effectors"_s);
		BaseContainer acceptedObjects;
		acceptedObjects.InsData(Obaseeffector, String());
		acceptedObjects.InsData(Oweighteffector, String());

		bc.SetInt32(IN_EXCLUDE_FLAG_INIT_STATE, 3);
		bc.SetInt32(IN_EXCLUDE_FLAG_NUM_FLAGS, 2);
		bc.SetInt32(IN_EXCLUDE_FLAG_IMAGE_01_ON, 300000131);
		bc.SetInt32(IN_EXCLUDE_FLAG_IMAGE_01_OFF, 300000130);
		bc.SetContainer(DESC_ACCEPT, acceptedObjects);
		bc.SetBool(IN_EXCLUDE_FLAG_SEND_SELCHANGE_MSG, true);

		bc.SetInt32(IN_EXCLUDE_FLAG_BIG_MODE_SIZE, 150);
		if (!description->SetParameter(cid, bc, DescMainTabGroup))
			return TRUE;
	}

	flags |= DESCFLAGS_DESC::LOADED | DESCFLAGS_DESC::RECURSIONLOCK;

	return SUPER::GetDDescription(node, description, flags);
}

// Check if the child object, In/Exclude objects have been changed
void EffectorTestClass::CheckDirty(BaseObject *op, BaseDocument *doc)
{
	if (doc == nullptr || op == nullptr)
		return;

	Bool setDirty = FALSE;
	BaseContainer docdata = doc->GetData(DOCUMENTSETTINGS::GENERAL);
	if (docdata == BaseContainer())
		return;

	BaseContainer *dataInstance = op->GetDataInstance();

	maxon::BaseArray<BaseObject*> objArray;

	if (op->GetDown() != nullptr)
		resultBaseObject = objArray.Append(op->GetDown());

	GeData tempdata;
	dataInstance->GetParameter(idEffectorList, tempdata);
	InExcludeData* data = static_cast<InExcludeData*>(tempdata.GetCustomDataType(CUSTOMDATATYPE_INEXCLUDE_LIST));
	if (data != nullptr)
	{
		Int32 flags = 0;
		for (Int32 objIndex = 0; objIndex < data->GetObjectCount(); objIndex++)
		{
			BaseObject* object = static_cast<BaseObject*>(data->ObjectFromIndex(doc, objIndex));
			if (object != nullptr)
			{
				if (object->GetDeformMode())
				{

					flags = data->GetFlags(doc, object);
					if ((flags & 1) == 1)
					{
						resultBaseObject = objArray.Append(object);
					}
				}
			}
		}
	}

	if (Int32(objArray.GetCount()) != Int32(compareDirtyObj.GetCount()))
	{
		setDirty = TRUE;
		dirtyNumber.Reset();
	}

	if (Int32(dirtyNumber.GetCount()) != Int32(objArray.GetCount()))
	{
		for (Int32 objIndex = Int32(dirtyNumber.GetCount()); objIndex < Int32(objArray.GetCount()); objIndex++)
			resultInt = dirtyNumber.Append(0);
	}

	compareDirtyObj.Reset();
	resultVoid = compareDirtyObj.CopyFrom(objArray);

	for (Int32 index = 0; index < Int32(objArray.GetCount()); index++)
	{
		if (dirtyNumber[index] != objArray[index]->GetDirty(DIRTYFLAGS::DATA | DIRTYFLAGS::MATRIX | DIRTYFLAGS::CHILDREN | DIRTYFLAGS::CACHE))
			setDirty = TRUE;

		dirtyNumber[index] = objArray[index]->GetDirty(DIRTYFLAGS::DATA | DIRTYFLAGS::MATRIX | DIRTYFLAGS::CHILDREN | DIRTYFLAGS::CACHE);

	}
	if (setDirty == TRUE || opDirtyCount != op->GetDirty(DIRTYFLAGS::MATRIX | DIRTYFLAGS::DATA))
	{
		opDirtyCount = op->GetDirty(DIRTYFLAGS::MATRIX | DIRTYFLAGS::DATA);
		op->SetDirty(DIRTYFLAGS::DATA | DIRTYFLAGS::CACHE);

	}
}

SplineObject* EffectorTestClass::GetContour(BaseObject* op, BaseDocument* doc, Float lod, BaseThread* bt)
{
	PolygonObject *testObj = (PolygonObject*)op->GetDown();
	if (testObj)
	{
		RunEffectors(op, doc, testObj);
	}
	opDirtyCount = op->GetDirty(DIRTYFLAGS::MATRIX | DIRTYFLAGS::DATA);
	SplineObject * returnSpline = SplineObject::Alloc(0, SPLINETYPE::LINEAR);
	return returnSpline;

}

Bool EffectorTestClass::Init(GeListNode* node)
{
	opDirtyCount = 0;
	return true;
}


void EffectorTestClass::RunEffectors(BaseObject *op, BaseDocument *doc, PolygonObject *poly)
{
	BaseContainer *dataInstance = op->GetDataInstance();
	maxon::BaseArray<Vector> originalCenterPoint;

	const CPolygon *polyArray = poly->GetPolygonR();

	if (polyArray == nullptr)
	{
		return;
	}

	Matrix objMx = poly->GetMg();
	BaseObject *obj = (BaseObject*)Get();
	BaseTag * motag = obj->GetTag(ID_MOTAGDATA);
	if (motag == nullptr)
		motag = obj->MakeTag(ID_MOTAGDATA);
	if (motag == nullptr)
	{
		return;
	}
	BaseTag * polyObjMocacheTag = obj->GetTag(ID_MOBAKETAG);

	GetMoDataMessage modataMsg = GetMoDataMessage();
	modataMsg.index = 0;

	if (polyObjMocacheTag)
	{
		polyObjMocacheTag->Message(MSG_GET_MODATA, &modataMsg);
	}
	BaseTag *objTag = obj->GetTag(ID_MOTAGDATA);
	if (objTag)
		objTag->Message(MSG_GET_MODATA, &modataMsg);

	if (!modataMsg.modata)
	{
		if (!motag->Message(MSG_GET_MODATA, &modataMsg) || !modataMsg.modata)
		{
			return;
		}
	}

	Float startingTimeA = GeGetMilliSeconds();
	MoData *md = modataMsg.modata;

	if (md)
	{

		maxon::BaseArray<Vector> centerPointArray;

		maxon::BaseArray< maxon::BaseArray<Vector> > polyPointArray;
		maxon::BaseArray<Vector> originalCenterArray;
		md->GetAutoLock();
		MDArray<Matrix> matrixArray;
		maxon::BaseArray<Matrix> originalMatrixArray;

		Int32 polygonCount = poly->GetPolygonCount();
		Int32 pointCount = poly->GetPointCount();
		const CPolygon* polygons = poly->GetPolygonR();
		const Vector *posArray = poly->GetPointR();

		
		// Get the center points of the various polygons
		for (Int32 polyIndex = 0; polyIndex < polygonCount; polyIndex++)
		{

			Vector centerPointOfPolygon = Vector(0);
			if (polygons[polyIndex].c == polygons[polyIndex].d)
			{
				centerPointOfPolygon += posArray[polygons[polyIndex].a];
				centerPointOfPolygon += posArray[polygons[polyIndex].b];
				centerPointOfPolygon += posArray[polygons[polyIndex].c];

				centerPointOfPolygon = (centerPointOfPolygon / 3.0);

			}
			else
			{
				centerPointOfPolygon += posArray[polygons[polyIndex].a];
				centerPointOfPolygon += posArray[polygons[polyIndex].b];
				centerPointOfPolygon += posArray[polygons[polyIndex].c];
				centerPointOfPolygon += posArray[polygons[polyIndex].d];

				centerPointOfPolygon = (centerPointOfPolygon / 4.0);
			}
			centerPointOfPolygon = Vector(polyIndex * 10, polyIndex * 10, polyIndex * 10);

			resultVector = originalCenterPoint.Append(centerPointOfPolygon);
			resultVector = centerPointArray.Append(centerPointOfPolygon);
		}

		md->SetCount(Int32(centerPointArray.GetCount()));
		matrixArray = md->GetMatrixArray(MODATA_MATRIX);

		MDArray<Vector> setMtxColorArray = md->GetVectorArray(MODATA_COLOR);
		MDArray<Vector> setMtxColorArra2y = md->GetVectorArray(MODATA_COLOR);

		dataInstance = op->GetDataInstance();
		const CustomDataType * effectorsraw = dataInstance->GetCustomDataType(idEffectorList, CUSTOMDATATYPE_INEXCLUDE_LIST);
		InExcludeData * effectors = nullptr;
		if (effectorsraw)
			effectors = (InExcludeData*)effectorsraw;

		resultVoid = originalMatrixArray.Resize(Int32(centerPointArray.GetCount()));
		// Generate the matrices
		for (Int32 centerIndex = 0; centerIndex < Int32(centerPointArray.GetCount()); centerIndex++)
		{
			Vector normal = CalcFaceNormal(posArray, polyArray[centerIndex]);

			Vector upVector = Vector(0, 1, 0);

			normal = normal;
			normal.Normalize();
			if (1.0 - abs(Dot(normal, upVector)) < .003)
			{
				upVector = Vector(0, 0, -1);

			}
			Vector z = normal;
			z.Normalize();
			Vector temp = Cross(upVector, z);

			Vector y = Cross(z, temp);
			y.Normalize();

			Vector x = Cross(y, z);
			x.Normalize();

			matrixArray[centerIndex] = Matrix(centerPointArray[centerIndex], x, y, z);
		}

		// Runs through the effectors
		if (effectors)
		{
			Effector_PassData emsg = Effector_PassData();
			emsg.op = op;
			emsg.md = md;
			emsg.weight = 1.0;
			emsg.thread = nullptr;
			Int32 flags = 0;
			for (Int i = 0; i < effectors->GetObjectCount(); i++)
			{
				BaseObject * e = (BaseObject*)effectors->ObjectFromIndex(doc, i);
				if (!e)
					continue;
				if (!e->GetDeformMode())
					continue;
				flags = effectors->GetFlags(doc, e);
				if (e != nullptr && e->GetDeformMode() == true && (flags & 1) == 1)
				{
					e->Message(MSG_EXECUTE_EFFECTOR, &emsg);
				}
			}
		}

		MDArray<Matrix> itemsMtxArray = md->GetMatrixArray(MODATA_MATRIX);
		Int32 matrixItemCnt = Int32(md->GetCount());
		ApplicationOutput("New run");
		for (Int32 centerIndex = 0; centerIndex < matrixItemCnt; centerIndex++)
			ApplicationOutput("Effector pos " + String::VectorToString(itemsMtxArray[centerIndex].off));

	}
	return;
}




Bool RegisterEffectorTest(Bool hideplugin)
{
	return RegisterObjectPlugin(ID_EFFECTORTEST, "Effector Move"_s, OBJECT_GENERATOR | OBJECT_ISSPLINE | OBJECT_INPUT, EffectorTestClass::Alloc, "OEffectorTest"_s, AutoBitmap("circle.tif"_s), 0);
}

I am confused what the difference between R23 and R25 could be that is responsible for the latest version not to work the same way or is it purely coincidental that my R23 version worked?

Any help would be greatly appreciated.

John Terenece

posted in Plugin Development with Cinema 4D •

RE: Mograph Effector List

Thanks for the response.

I figured it would need to be the SceneHook but always best to double check.

John Terenece

posted in Plugin Development with Cinema 4D •

Mograph Effector List

Hello

I'm working on a plugin that has an In/Exclude List for a user to feed in Effectors in a similar way to Mograph objects, my plugin is meant to act as a pseudo Mograph object. I've been able to mimic almost all of the same kind of functionality that Cinema offers with its Mograph objects.

The only functionality that I'm missing is when a Mograph object is selected and then an Effector is added into the scene, the Effector will be linked to the Mograph object's effector list.

Here is my code for creating my In/Exclude.


Bool EffectorClass::GetDDescription(GeListNode *node, Description *description, DESCFLAGS_DESC &flags)
{
	BaseContainer *datainstance;
	const DescID *singleid;   

	if (!description->LoadDescription(node->GetType()))
	{
	}

	datainstance = ((BaseList2D*)node)->GetDataInstance(); 
	if (!datainstance)
		return FALSE;
	singleid = description->GetSingleDescID();
	DescID cid;


	DescID DescMainTabGroup = DescLevel(10001, DTYPE_GROUP, 0);
	if (!singleid || DescMainTabGroup.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_GROUP);
		bc.SetString(DESC_NAME, "Effector Control"_s);

		bc.SetInt32(DESC_COLUMNS, 1);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_SCALEH, TRUE);

		if (!description->SetParameter(DescMainTabGroup, bc, DescLevel(ID_RKTMESHSPLINE)))
			return TRUE;
	}
	cid = DescLevel(10002, CUSTOMDATATYPE_INEXCLUDE_LIST, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(CUSTOMGUI_INEXCLUDE_LIST);

		bc.SetString(DESC_NAME, "Effectors"_s);
		BaseContainer acceptedObjects;
		acceptedObjects.InsData(Obaseeffector, String());
		acceptedObjects.InsData(Oweighteffector, String());
		acceptedObjects.InsData(1001381, String());


		bc.SetInt32(IN_EXCLUDE_FLAG_INIT_STATE, 3);
		bc.SetInt32(IN_EXCLUDE_FLAG_NUM_FLAGS, 2);
		bc.SetInt32(IN_EXCLUDE_FLAG_IMAGE_01_ON, 300000131);
		bc.SetInt32(IN_EXCLUDE_FLAG_IMAGE_01_OFF, 300000130);

		bc.SetContainer(DESC_ACCEPT, acceptedObjects);
		bc.SetBool(IN_EXCLUDE_FLAG_SEND_SELCHANGE_MSG, true);

		bc.SetInt32(IN_EXCLUDE_FLAG_BIG_MODE_SIZE, 150);
		if (!description->SetParameter(cid, bc, DescMainTabGroup))
			return TRUE;
	}




	flags |= DESCFLAGS_DESC::LOADED | DESCFLAGS_DESC::RECURSIONLOCK;

	return SUPER::GetDDescription(node, description, flags);
}

I've tried looking through the sdk and forum posts for anything in reference to this functionality and couldn't find anything.

Is there a particular flag that is needed to mimic the Mograph in this way or is the only way to do this with a Scene Hook?

Any help would be greatly appreciated.

John Terenece

posted in Plugin Development with Cinema 4D •

RE: MoData Effector Rotation

Thanks for the response Ferdinand.

I messed up the scene file in my post which is why I deleted it. The setup for my scene is this.

Both my plugin and the PolyFX are being fed the Plain effector. I am trying to have my plugin take in polygons from a fed in object and then use the results from the effectors in the plugin to move those polygons to mimic the behavior of the PolyFX.

John Terenece

posted in Plugin Development with Cinema 4D •

RE: MoData Effector Rotation

I am having an issue I believe is related to me running the code to generate the matrix that I am then feeding into the MoData. Shown with the picture below.

Screenshot from deleted posting [added by @ferdinand for clarity]

The setup for my file is simple with two separate Cubes, one of them being used by my plugin the other being used by a PolyFX. Both my plugin and the PolyFX are being given the same Plain Effector.

If my code was working the way it's meant to the splines I'm creating would be matching the polygons of the PolyFX cube.

Here is the entirety of the function that I am using to get the points from the polygons and running the MoData code.


maxon::BaseArray< maxon::BaseArray<Vector> > EffectPolygonClass::RunEffectors(BaseObject *op, BaseDocument *doc)
{
		

		maxon::BaseArray<Vector> originalCenterPoint;
		maxon::BaseArray< maxon::BaseArray<Vector> > finalConnections;
		PolygonObject *poly = (PolygonObject*)doc->SearchObject("Cube"_s);

		if (poly == nullptr)
			return finalConnections;

		Matrix polygonMatrix = poly->GetMg();

		const CPolygon *polyArray = poly->GetPolygonR();

		if (polyArray == nullptr)
			return finalConnections;

		Matrix objMx = poly->GetMg();
		BaseObject *obj = (BaseObject*)Get();
		BaseTag * motag = obj->GetTag(ID_MOTAGDATA);
		if (motag == nullptr)
			motag = obj->MakeTag(ID_MOTAGDATA);
		if (motag == nullptr)
			return finalConnections;
		BaseTag * polyObjMocacheTag = obj->GetTag(ID_MOBAKETAG);

		GetMoDataMessage modataMsg = GetMoDataMessage();
		modataMsg.index = 0;

		if (polyObjMocacheTag)
		{
			polyObjMocacheTag->Message(MSG_GET_MODATA, &modataMsg);
		}
		BaseTag *objTag = obj->GetTag(ID_MOTAGDATA);
		if (objTag)
			objTag->Message(MSG_GET_MODATA, &modataMsg);

		if (!modataMsg.modata)
		{
			if (!motag->Message(MSG_GET_MODATA, &modataMsg) || !modataMsg.modata)
				return finalConnections;
		}


		MoData *md = modataMsg.modata;
		if (md)
		{

			maxon::BaseArray<Vector> centerPointArray;

			maxon::BaseArray< maxon::BaseArray<Vector> > polyPointArray;
			maxon::BaseArray<Vector> singlePointArray;
			maxon::BaseArray<Vector> originalCenterArray;
			md->GetAutoLock();
			MDArray<Matrix> matrixArray;

			Int32 polygonCount = poly->GetPolygonCount();
			Int32 pointCount = poly->GetPointCount();
			const CPolygon* polygons = poly->GetPolygonR();
			const Vector *posArray = poly->GetPointR();

			Matrix opMatrix = op->GetMg();
			Matrix polyMatrix = poly->GetMg();
			for (Int32 polyIndex = 0; polyIndex < polygonCount; polyIndex++)
			{

				Vector centerPointOfPolygon = Vector(0);
				if (polygons[polyIndex].c == polygons[polyIndex].d)
				{
					resultVector = singlePointArray.Append(posArray[polygons[polyIndex].a]);
					resultVector = singlePointArray.Append(posArray[polygons[polyIndex].b]);
					resultVector = singlePointArray.Append(posArray[polygons[polyIndex].c]);

					centerPointOfPolygon += posArray[polygons[polyIndex].a];
					centerPointOfPolygon += posArray[polygons[polyIndex].b];
					centerPointOfPolygon += posArray[polygons[polyIndex].c];
					centerPointOfPolygon = (centerPointOfPolygon / 3.0);
				}
				else
				{
					resultVector = singlePointArray.Append(posArray[polygons[polyIndex].a]);
					resultVector = singlePointArray.Append(posArray[polygons[polyIndex].b]);
					resultVector = singlePointArray.Append(posArray[polygons[polyIndex].c]);
					resultVector = singlePointArray.Append(posArray[polygons[polyIndex].d]);

					centerPointOfPolygon += posArray[polygons[polyIndex].a];
					centerPointOfPolygon += posArray[polygons[polyIndex].c];
					centerPointOfPolygon = (centerPointOfPolygon / 2.0);
				}
				resultVector2D = polyPointArray.Append(singlePointArray);
				singlePointArray.Reset();
				resultVector = originalCenterPoint.Append(centerPointOfPolygon);
				resultVector = centerPointArray.Append(centerPointOfPolygon);
			}
			md->SetCount(centerPointArray.GetCount());
			matrixArray = md->GetMatrixArray(MODATA_MATRIX);

			pointCount = poly->GetPointCount();
			polygonCount = poly->GetPolygonCount();



			BaseContainer *dataInstance = op->GetDataInstance();
			const CustomDataType * effectorsraw = dataInstance->GetCustomDataType(ID_MG_MOTIONGENERATOR_EFFECTORLIST, CUSTOMDATATYPE_INEXCLUDE_LIST);
			InExcludeData * effectors = nullptr;
			if (effectorsraw)
				effectors = (InExcludeData*)effectorsraw;



			for (Int32 centerIndex = 0; centerIndex < centerPointArray.GetCount(); centerIndex++)
			{
				Vector normal = CalcFaceNormal(posArray, polyArray[centerIndex]);

				Vector pointPos = polyMatrix * ~opMatrix * centerPointArray[centerIndex];
				normal = polyMatrix * ~opMatrix * normal;
				normal.Normalize();
				Vector upVector = polyMatrix * ~opMatrix * Vector(0, 1, 0);
				if (1.0 - abs(Dot(normal, upVector)) < 1E-5)
				{
					upVector = Vector(1E-5, 1, 0);
				}
				Vector z = normal;
				z.Normalize();
				Vector temp = Cross(upVector, z);

				Vector y = Cross(z, temp);
				y.Normalize();
				Vector x = Cross(y, z);
				x.Normalize();

				matrixArray[centerIndex] = Matrix(pointPos, x, y, z);



			}

			if (effectors)
			{
				Effector_PassData emsg = Effector_PassData();
				emsg.op = op;
				emsg.md = md;
				emsg.weight = 1.0;
				emsg.thread = nullptr;
				for (Int i = 0; i < effectors->GetObjectCount(); i++)
				{
					BaseObject * e = (BaseObject*)effectors->ObjectFromIndex(doc, i);
					if (!e)
						continue;
					if (!e->GetDeformMode())
						continue;
					e->Message(MSG_EXECUTE_EFFECTOR, &emsg);
				}
				GetMoDataMessage modataMatrixMsg;


			}
			MDArray<Matrix> itemsMtxArray = md->GetMatrixArray(MODATA_MATRIX);
			Int32 matrixItemCnt = md->GetCount();

			maxon::BaseArray<Vector> singleLevelReturn;

			for (Int32 centerIndex = 0; centerIndex < matrixItemCnt; centerIndex++)
			{
				Matrix effectorMat = itemsMtxArray[centerIndex];

				Vector savedPos = effectorMat.off;
				Float distance = Distance(originalCenterPoint[centerIndex], savedPos);

				Vector normalAngle = savedPos - originalCenterPoint[centerIndex];
				normalAngle.Normalize();
				for (Int32 pointIndex = 0; pointIndex < polyPointArray[centerIndex].GetCount(); pointIndex++)
				{
					resultVector = singleLevelReturn.Append((normalAngle * distance + polyPointArray[centerIndex][pointIndex]));

				}
				resultVector2D = finalConnections.Append(singleLevelReturn);
				singleLevelReturn.Reset();
			}
			return finalConnections;
		}
	
	}






// Code used to create a placeholder Effector list
	cid = DescLevel(ID_EFFECTORLIST, CUSTOMDATATYPE_INEXCLUDE_LIST, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(CUSTOMGUI_INEXCLUDE_LIST);

		bc.SetString(DESC_NAME, "Effectors"_s);
		
		bc.SetBool(IN_EXCLUDE_FLAG_SEND_SELCHANGE_MSG, true);





		bc.SetInt32(IN_EXCLUDE_FLAG_BIG_MODE_SIZE, 150);
		if (!description->SetParameter(cid, bc, DescMainTabGroup))
			return TRUE;
	}

}

I went through the Python code and tried to follow it as closely as I could to generate the array of Matrixs that I use. This code matches the behavior of the PolyFX when using a Sphere but differs in the case of the Cube example.

I'm not entirely sure if the issue I'm having is a result of me not creating the Matrix properly or not utilizing the results from the MoData correctly but the issue is preventing me from moving on to trying to utilize rotation on Effectors.

John Terenece

posted in Plugin Development with Cinema 4D •

RE: MoData Effector Rotation

@ferdinand

Thanks for the response Ferdinand.

I'm sorry about the post, I'll make sure to follow the proper guidelines next time.

Your code worked great, problem successfully resolved.

John Terenece

posted in Plugin Development with Cinema 4D •

MoData Effector Rotation

Hello

I'm working on a plugin that takes in points from polygon objects and then uses effectors fed in by the user to change the positions of the points that I then draw.

With the code below I am able to change the positions of the points but the final result is different than the equivalent setup with a Matrix object as seen here. Both my code and the matrix are working from points set as the center point of the polygons of a Sphere with only a default Plain Effector in the Effector List.

My results are shown with the white dots compared to the cubes from the Matrix object.


PolygonObject *poly = (PolygonObject*)doc->SearchObject("Sphere"_s);
			if (!poly )
				return;

	maxon::BaseArray<Vector> drawPoints;
		if (poly == nullptr)
			return;

		polygonMatrix = poly->GetMg();

		const CPolygon *polyArray = poly->GetPolygonR();

		if (polyArray == nullptr)
			return;

		Matrix objMx = poly->GetMg();

		BaseObject *obj = (BaseObject*)Get();
		BaseTag * motag = obj->GetTag(ID_MOTAGDATA);
		if (motag == nullptr)
			motag = obj->MakeTag(ID_MOTAGDATA);
		if (motag == nullptr)
			return;
		BaseTag * polyObjMocacheTag = obj->GetTag(ID_MOBAKETAG);

		GetMoDataMessage modataMsg = GetMoDataMessage();
		modataMsg.index = 0;

		if (polyObjMocacheTag)
		{
			polyObjMocacheTag->Message(MSG_GET_MODATA, &modataMsg);
		}
		BaseTag *objTag = obj->GetTag(ID_MOTAGDATA);
		if (objTag)
			objTag->Message(MSG_GET_MODATA, &modataMsg);

		if (!modataMsg.modata)
		{
			if (!motag->Message(MSG_GET_MODATA, &modataMsg) || !modataMsg.modata)
				return;
		}

		MoData *md = modataMsg.modata;
		if (md)
		{
			md->GetAutoLock();
			MDArray<Matrix> matrixArray;
			drawPoints.Reset();

			polygonCount = poly->GetPolygonCount();
			pointCount = poly->GetPointCount();
			const CPolygon* polygons = poly->GetPolygonR();
			const Vector *posArray = poly->GetPointR();

			// Used as a standin for finding a center point for the polygon
			for (Int32 polyIndex = 0; polyIndex < polygonCount; polyIndex++)
			{
				Vector centerPointOfPolygon = Vector(0);
				if (polygons[polyIndex].c == polygons[polyIndex].d)
				{
					centerPointOfPolygon += posArray[polygons[polyIndex].a];
					centerPointOfPolygon += posArray[polygons[polyIndex].b];
					centerPointOfPolygon += posArray[polygons[polyIndex].c];
					centerPointOfPolygon = (centerPointOfPolygon / 3.0);
				}
				else
				{
					centerPointOfPolygon += posArray[polygons[polyIndex].a];
					centerPointOfPolygon += posArray[polygons[polyIndex].b];
					centerPointOfPolygon += posArray[polygons[polyIndex].c];
					centerPointOfPolygon += posArray[polygons[polyIndex].d];
					centerPointOfPolygon = (centerPointOfPolygon / 4.0);
				}
				drawPoints.Append(centerPointOfPolygon);
			}
			md->SetCount(drawPoints.GetCount());
			matrixArray = md->GetMatrixArray(MODATA_MATRIX);

			pointCount = poly->GetPointCount();
			polygonCount = poly->GetPolygonCount();

			// Grabs the modata from the Matrix object for comparision purposes
			BaseObject *matrix = doc->SearchObject("Matrix"_s);
			if (!matrix)
				return;
			BaseTag *tmpMatrixTag = matrix->GetTag(ID_MOTAGDATA);
			if (!tmpMatrixTag)
				return;

			GetMoDataMessage modataMatrixMsg;
			if (!tmpMatrixTag->Message(MSG_GET_MODATA, &modataMatrixMsg))
				return;
			MDArray<Matrix> matrixMDArray = modataMatrixMsg.modata->GetMatrixArray(MODATA_MATRIX);


			BaseContainer *dataInstance = op->GetDataInstance();
			const CustomDataType * effectorsraw = dataInstance->GetCustomDataType(idEffectorList, CUSTOMDATATYPE_INEXCLUDE_LIST);
			InExcludeData * effectors = nullptr;
			if (effectorsraw)
				effectors = (InExcludeData*)effectorsraw;

			for (Int drawIndex = 0; drawIndex < drawPoints.GetCount(); drawIndex++)
			{
				Vector holdNormal = CalcFaceNormal(posArray, polyArray[drawIndex]);
				Vector pointNormal = ~opMatrix * polygonMatrix * VectorToHPB(holdNormal);

				MoData *matrixData = modataMatrixMsg.modata; UInt32 newDirty = 0;

				maxon::Int32* flags = static_cast<maxon::Int32*>(matrixData->GetArray(MODATA_FLAGS));

				Matrix setMat = HPBToMatrix(pointNormal, ROTATIONORDER::DEFAULT);
				setMat.off = drawPoints[drawIndex];
				matrixArray[drawIndex] = setMat;

			}

			if (effectors)
			{
				Effector_PassData emsg = Effector_PassData();
				emsg.op = op;
				emsg.md = md;
				emsg.weight = 1.0;
				emsg.thread = nullptr;
				for (Int i = 0; i < effectors->GetObjectCount(); i++)
				{
					BaseObject * e = (BaseObject*)effectors->ObjectFromIndex(doc, i);
					if (!e)
						return;
					if (!e->GetDeformMode())
						return;
					e->Message(MSG_EXECUTE_EFFECTOR, &emsg);
				}
				GetMoDataMessage modataMatrixMsg;

				Int32 matrixItemCnt = md->GetCount();

				MDArray<Matrix> itemsMtxArray = md->GetMatrixArray(MODATA_MATRIX);

				for (Int32 drawIndex = 0; drawIndex  < matrixItemCnt; drawIndex ++)
				{
					drawPoints[drawIndex ] = itemsMtxArray[drawIndex ].off;
				}
			}
		}

My problem seems to be a result of the matrixs that I am filling the MoData with not having the proper rotation information. In my code I use CalcFaceNormal to get the normal of the polygons from the Sphere and then go through the steps to convert the normal to a matrix that is used by the MoData to be used by the Effectors. I run into the same kind of problem when I use a Random Effector.

I tried comparing the information inside the MoData from my object against that of the Matrix and they have different rotations.

Is there a proper way to determine this rotation value so that I can mimic the behavior of the MoGraph objects?

Any help would be greatly appreciated.

John Terenece

posted in Plugin Development with Cinema 4D •

RE: Voronoi Fracture Glitch

Thanks for the response.

I made the two changes and the problem is still present.

John Terenece

posted in Plugin Development with Cinema 4D •

RE: Voronoi Fracture Glitch

Thanks for the response Ferdinand.

I am running R23 SP1 (R23.110) on Windows 10 (OS build 19041.1110). I am also encountering the same problem when running it in R24 (R24.111).

Here is all of my code, trimmed down to the bare minimum that still showed the issue.

#include "c4d.h"
#include "c4d_symbols.h"
#include "lib_description.h"

#define ID_BREAKSPLINE 1058002

class BreakSpline : public ObjectData
{
	INSTANCEOF(BreakSpline, ObjectData)
public:

	virtual Bool Init(GeListNode *node);
	static NodeData *Alloc() { return NewObjClear(BreakSpline); }
	
	Bool GetDDescription(GeListNode *node, Description *description, DESCFLAGS_DESC &flags);  
	
};

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

	if (op == nullptr)
		return FALSE;

	const DescID *singleid = description->GetSingleDescID();

	BaseObject *pp;
	Bool first = TRUE;

	DescID cid;
	BaseContainer* datainstance = op->GetDataInstance();
	
	DescID DescGroup = DescLevel(10000, DTYPE_GROUP, 0);
	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, ID_BREAKSPLINE))
		{
			return TRUE;
		}
	}

	DescID subgroupthree = DescLevel(10001, DTYPE_GROUP, 0);
	if (!singleid || subgroupthree.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_GROUP);
		bc.SetInt32(DESC_COLUMNS, 3);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_SCALEH, false);

		if (!description->SetParameter(subgroupthree, bc, DescGroup))
			return TRUE;
	}


	cid = DescLevel(10002, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetString(DESC_NAME, "Orientation  "_s);
		BaseContainer MeasureDivisionNames;
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);

		MeasureDivisionNames.SetString(-1, ""_s);
		MeasureDivisionNames.SetString(0, "X+"_s);
		MeasureDivisionNames.SetString(1, "Y+"_s);
		MeasureDivisionNames.SetString(2, "Z+"_s);

		bc.SetContainer(DESC_CYCLE, MeasureDivisionNames);
		if (!description->SetParameter(cid, bc, subgroupthree))
			return TRUE;
	}

	cid = DescLevel(10003, 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, "Run With Matrix"_s);

		if (!description->SetParameter(cid, bc, subgroupthree))
			return TRUE;
	}

	cid = DescLevel(10004, DTYPE_BUTTON, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_BUTTON);
		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_BUTTON);
		bc.SetString(DESC_NAME, "Create Reference"_s);
		if (!description->SetParameter(cid, bc, subgroupthree))
			return TRUE;
	}

	DescID linkgroup = DescLevel(10005, DTYPE_GROUP, 0);
	if (!singleid || subgroupthree.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_GROUP);
		bc.SetInt32(DESC_COLUMNS, 3);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_SCALEH, false);

		if (!description->SetParameter(linkgroup, bc, DescGroup))
			return TRUE;
	}

	DescID linkgroup2 = DescLevel(10006, DTYPE_GROUP, 0);
	if (!singleid || subgroupthree.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_GROUP);
		bc.SetInt32(DESC_COLUMNS, 3);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_SCALEH, false);

		if (!description->SetParameter(linkgroup2, bc, DescGroup))
			return TRUE;
	}
	

	cid = DescLevel(10007, DTYPE_SEPARATOR, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_SEPARATOR);
		bc.SetBool(DESC_SEPARATORLINE, TRUE);
		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}

	cid = DescLevel(10008, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetInt32(DESC_MIN, 0);
		bc.SetInt32(DESC_MINSLIDER, 0);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_LONGSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 100);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Row 1"_s);

		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}

	cid = DescLevel(10009, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetInt32(DESC_MIN, 0);
		bc.SetInt32(DESC_MINSLIDER, 0);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_LONGSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 100);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Row 2"_s);
		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}
	cid = DescLevel(10010, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetInt32(DESC_MIN, 0);
		bc.SetInt32(DESC_MINSLIDER, 0);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_LONGSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 100);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Row 3"_s);


		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}
	cid = DescLevel(10011, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetInt32(DESC_MIN, 0);
		bc.SetInt32(DESC_MINSLIDER, 0);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_LONGSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 100);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Row 4"_s);
		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}
	cid = DescLevel(10012, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetInt32(DESC_MIN, 0);
		bc.SetInt32(DESC_MINSLIDER, 0);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_LONGSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 100);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Row 5"_s);
		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}
	cid = DescLevel(10013, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetInt32(DESC_MIN, 0);
		bc.SetInt32(DESC_MINSLIDER, 0);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_LONGSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 100);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Row 6"_s);

		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}
	cid = DescLevel(10014, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetInt32(DESC_MIN, 0);
		bc.SetInt32(DESC_MINSLIDER, 0);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_LONGSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 100);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Row 7"_s);


		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}
	cid = DescLevel(10015, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetInt32(DESC_MIN, 0);
		bc.SetInt32(DESC_MINSLIDER, 0);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_LONGSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 100);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Row 8"_s);

		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}
	cid = DescLevel(10016, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetInt32(DESC_MIN, 0);
		bc.SetInt32(DESC_MINSLIDER, 0);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_LONGSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 100);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Row 9"_s);


		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}
	cid = DescLevel(10017, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetInt32(DESC_MIN, 0);
		bc.SetInt32(DESC_MINSLIDER, 0);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_LONGSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 100);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Row 10"_s);

		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}


	cid = DescLevel(10018, DTYPE_REAL, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_REAL);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);

		bc.SetInt32(DESC_MINSLIDER, 0);
		bc.SetInt32(DESC_UNIT, DESC_UNIT_METER);
		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_REALSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 5);
		bc.SetFloat(DESC_DEFAULT, 0);
		bc.SetFloat(DESC_STEP, .01);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Expand"_s);

		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}
	cid = DescLevel(10019, DTYPE_LONG, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_LONG);
		bc.SetBool(DESC_FORBID_SCALING, TRUE);
		bc.SetFloat(DESC_MIN, 0);

		bc.SetInt32(DESC_MINSLIDER, 0);
		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_REALSLIDER);
		bc.SetInt32(DESC_MAXSLIDER, 10);
		bc.SetInt32(DESC_MAX, 500);
		bc.SetFloat(DESC_DEFAULT, 0);
		bc.SetBool(DESC_FORBID_INLINE_FOLDING, FALSE);
		bc.SetString(DESC_NAME, "Smoothing"_s);

		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}



	cid = DescLevel(10020, DTYPE_SEPARATOR, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_SEPARATOR);
		bc.SetBool(DESC_SEPARATORLINE, TRUE);
		if (!description->SetParameter(cid, bc, DescGroup))
			return TRUE;
	}
	DescID SubGroupOne = DescLevel(10024, DTYPE_GROUP, 0);
	if (!singleid || SubGroupOne.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_GROUP);


		bc.SetInt32(DESC_COLUMNS, 2);
		bc.SetBool(DESC_SCALEH, TRUE);

		if (!description->SetParameter(SubGroupOne, bc, DescGroup))
		{
			return TRUE;
		}
	}
	
	DescID DescDataSplineTab = DescLevel(10021, DTYPE_GROUP, 0);
	if (!singleid || DescDataSplineTab.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_GROUP);
		bc.SetString(DESC_NAME, "Spline Controls"_s);
		bc.SetInt32(DESC_COLUMNS, 1);
		bc.SetInt32(DESC_DEFAULT, 0);
		bc.SetBool(DESC_SCALEH, TRUE);

		if (!description->SetParameter(DescDataSplineTab, bc, DescLevel(ID_BREAKSPLINE)))
			return TRUE;
	}


	DescID DescSplineGroup = DescLevel(10022, DTYPE_GROUP, 0);
	if (!singleid || DescSplineGroup.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_GROUP);
		bc.SetInt32(DESC_COLUMNS, 1);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_SCALEH, TRUE);

		if (!description->SetParameter(DescSplineGroup, bc, DescDataSplineTab))
			return TRUE;
	}


	cid = DescLevel(10023, DTYPE_BOOL, 0);
	if (!singleid || cid.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_BOOL);

		bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_BOOL);
		bc.SetString(DESC_NAME, "Reverse"_s);
		bc.SetBool(DESC_DEFAULT, TRUE);
		if (!description->SetParameter(cid, bc, DescSplineGroup))
			return TRUE;
	}

	flags |= DESCFLAGS_DESC::LOADED | DESCFLAGS_DESC::RECURSIONLOCK;

	return SUPER::GetDDescription(node, description, flags);
}

Bool BreakSpline::Init(GeListNode *node)
{
	BaseObject *op = (BaseObject*)node;
	if (!op)
	{
		return FALSE;
	}
	return TRUE;
}

Bool RegisterBreakSpline()
{

	Int32 flags = 0;
	flags = OBJECT_GENERATOR | OBJECT_ISSPLINE | OBJECT_INPUT | OBJECT_UNIQUEENUMERATION;

	return RegisterObjectPlugin(ID_BREAKSPLINE, "Break"_s, flags, BreakSpline::Alloc, "OBreak"_s, nullptr, 0);
}

The res file:

CONTAINER OBreak
{
	NAME OBreak;
	INCLUDE Obase;

	GROUP ID_OBJECTPROPERTIES
	{
		
	}

}

The .h file

#ifndef _OBreak_H_
#define _OBreak_H_

enum
{
	
};

#endif

The .str file

STRINGTABLE OBreak
{
	OBreak "Break";

	
}