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

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";

	
}

John Terenece

posted in Plugin Development with Cinema 4D •

RE: Voronoi Fracture Glitch

Thank you Ferdinand.

posted in Plugin Development with Cinema 4D •

RE: Voronoi Fracture Glitch

@ferdinand Thanks for the response Ferdinand.

Sorry I was unclear with what the issue is. I am working in R23, from the tests I did the problem doesn't seem to occur in R20.

I'm not sure what you would call it exactly but the line being drawn through the attribute manager like this is the issue.
Plugin Visual2.png

The same kind of issue appears on the Voronoi Fracture best seen in its effect on the scrollbar.
Voronoi Visual2.png

If I shift the scrollbar in my plugin or the Voronoi the issue disappears, also if I make a change to one of the controls that the line is drawn across that will fix that control while leaving the line effecting rest of the controls.

I am not sure why the issue only seems to occur when I utilize a Voronoi Fracture. Running tests with various other objects, effectors and such did not show this same problem.

From what I can tell it seems to appear when the attribute manager has both a vertical and horizontal scrollbar. If I increase the size of the attribute manager so that the scrollbars aren't needed the issue doesn't seem to happen.

John Terenece

posted in Plugin Development with Cinema 4D •

Voronoi Fracture Glitch

Hello,

I am working on a plugin and running into an unusual visual glitch that seems to only happen when the scene includes a Voronoi Fracture in addition to my plugin. When I select the Voronoi and then switch to my plugin the issue occurs.

The problem manifests like this in the attribute manager for my plugin Plugin Visual.png

Inside the Voronoi Fracture it shows up like this Voronoi Visual.png

I tried using other objects in place of the Voronoi and couldn't replicate the issue.

Below is the code from creating the Object tab in GetDDescription. I simplified my code to look into the issue so all of my controls are identical except for the ids and the names. The names are large so that the horizontal scrollbar will be needed.

    if (!description->LoadDescription(node->GetType()))
    {
    }
    BaseObject* op = static_cast<BaseObject*>(node);
    if (op == nullptr)
    {
        return FALSE;
    }
   

    const DescID *singleid = description->GetSingleDescID();
    
    Bool initbc2 = FALSE;
    BaseContainer bc2;
    DescID cid;
    BaseContainer* datainstance = op->GetDataInstance();
    DescID DescGroup = DescLevel(idGroup,  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_GENSPLINE))
        {
            return TRUE;
        }
    }
    
	DescID DescTestGroup = DescLevel(98765, DTYPE_GROUP, 0);
	if (!singleid || DescGroup.IsPartOf(*singleid, NULL))
	{
		BaseContainer bc;
		bc = GetCustomDataTypeDefault(DTYPE_GROUP);
		bc.SetInt32(DESC_COLUMNS, 2);
		bc.SetInt32(DESC_DEFAULT, 1);
		bc.SetBool(DESC_SCALEH, FALSE);

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

      // Repeated the controls below until the attribute manager is large enough for the vertical scrollbar to appear

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

		bc.SetInt32(DESC_UNIT, DESC_UNIT_METER);
		bc.SetInt32(DESC_STEP, 1);

		bc.SetInt32(DESC_DEFAULT, 0);

		bc.SetString(DESC_NAME, "Offset                                                                      "_s);
		if (!description->SetParameter(cid, bc, 98765))
			return TRUE;
	}


	cid = DescLevel(987649, 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, "Fields   "_s);
		bc.SetBool(DESC_DEFAULT, FALSE);
		if (!description->SetParameter(cid, bc, 98765))
			return TRUE;
	}



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

		bc.SetInt32(DESC_UNIT, DESC_UNIT_METER);
		bc.SetInt32(DESC_STEP, 1);

		bc.SetInt32(DESC_DEFAULT, 0);

		bc.SetString(DESC_NAME, "Offset          "_s);
		if (!description->SetParameter(cid, bc, 98765))
			return TRUE;
	}

The same problem shows up if I create a number of user data on my plugin and switch the selections between my plugin and the Voronoi.

The problem seems to be limited to when the display size for my controls are larger than the attribute manager.

Any help would be greatly appreciated.

John Terenece

posted in Plugin Development with Cinema 4D •

RE: DESC_PARENT_COLLAPSE Display

Thanks for the response. I was assuming that would be the case.

John Terenece

posted in Plugin Development with Cinema 4D •