Oh wait, I think I found a way. In case anybody else wants to know, here it is...

In the PrefsDialogObject:

Bool MyPrefsDialog::SetDParameter(GeListNode *node, const DescID &id,const GeData &t_data,DESCFLAGS_SET &flags)
{
	BaseContainer* bc = MyPlugin::GetPreferences();
	if (!bc)
		SUPER::SetDParameter(node, id, t_data, flags);
	
	switch (id[0].id)
	{
		// If PREFS_MYPLUGIN_SOMEVALUE was changed, store value and notify plugin objects in all open documents.
		case PREFS_MYPLUGIN_SOMEVALUE:
			bc->SetInt32(PREFS_MYPLUGIN_SOMEVALUE, t_data.GetInt32());
			flags |= DESCFLAGS_SET::PARAM_SET;
			
			// Iterate open documents
			for (BaseDocument *doc = GetFirstDocument(); doc; doc = doc->GetNext())
			{
				// Send broadcast message to each document, use unique ID
				doc->MultiMessage(MULTIMSG_ROUTE::BROADCAST, MyPlugin::UNIQUE_ID_PREFS, nullptr);
			}
			
			GeUpdateUI();
			return true;
	}
	
	return SUPER::SetDParameter(node, id, t_data, flags);
}

And then, in the plugin object:

Bool MyPluginObject::Message(GeListNode *node, Int32 type, void *data)
{
	if (type == MyPlugin::UNIQUE_ID_PREFS)
	{
		GePrint("Aha! My prefs have changed!"_s);
		return true;
	}
	return SUPER::Message(node, type, data);
}

And in deed, having the option of executing the source protector using a command line argument for Cinema 4D, or using c4dpy would be great for integration in a plugin build pipeline.

Hi,
I'll just chime in here, as I'm involved in that project, too.

So the token hook needs to access certain elements of the scene to get their values, and the problem (thankfully) is easily reproducible.

I wrote a sample plugin that recreates the behaviour by simply returning data from the first object in the scene. Download it from our dropbox: tokenhookbug.zip

Here is the code:

This is the render setting in my example scene (which just contains a Cube):

Here is the render result in the Picture Viewer, notice the correct file name:

Uploading and rendering the file on TeamRender produces this:

The debugger clearly shows that doc->GetFirstObject() returns nullptr.

Cheers,
Frank

It works like a charm!
Thank you again!

I was surprised at how little code was required.

Sharing is caring. In case anyone needs it, here's the code:

#include "ge_prepass.h"
#include "c4d_general.h"
#include "c4d_baselinkarray.h"
#include "c4d_basedocument.h"

///
/// \brief Registers observers and sends messages to them.
///
class Observable
{
public:
	///
	/// \brief Subscribes a new observer.
	///
	/// \param[in] observer Pointer to an AtomGoal
	/// \param[in] doc The document that owns the AtomGoal
	///
	/// \return A maxon error object if anything went wrong, otherwise maxon::OK
	///
	maxon::Result<void> Subscribe(C4DAtomGoal *observer, BaseDocument *doc);
		
	///
	/// \brief Unsubscribes an observer
	///
	/// \param[in] observer Pointer to an AtomGoal that has previously been subscribed
	/// \param[in] doc The document that owns the AtomGoal
	///
	void Unsubscribe(C4DAtomGoal *observer, BaseDocument *doc);
		
	///
	/// \brief Sends a messages to all subscribed observers
	///
	/// \param[in] type Message type
	/// \param[in] doc The document that owns the subscribed observers
	/// \param[in] data Optional message data
	///
	void Message(Int32 type, BaseDocument *doc, void *data = nullptr) const;

private:
	BaseLinkArray _observers;
};

maxon::Result<void> Observable::Subscribe(C4DAtomGoal *observer, BaseDocument *doc)
{
	if (!observer)
		return maxon::NullptrError(MAXON_SOURCE_LOCATION, "Observer must not be nullptr!"_s);

	// Check if this observer is already registered
	const Int32 observerIndex = _observers.Find(observer, doc);
	if (observerIndex != NOTOK)
		return maxon::OK;

	// Register new observer
	if (!_observers.Append(observer))
	{
		return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION, "Failed to add observer to the list!"_s);
	}

	return maxon::OK;
}

void Observable::Unsubscribe(C4DAtomGoal *observer, BaseDocument *doc)
{
	if (observer && doc)
	{
		const Int32 observerIndex = _observers.Find(observer, doc);
		if (observerIndex != NOTOK)
		{
			_observers.Remove(observerIndex);
		}
	}
}

void Observable::Message(Int32 type, BaseDocument *doc, void *data) const
{
	for (Int32 i = 0; i < _observers.GetCount(); ++i)
	{
		C4DAtomGoal *atom = _observers.GetIndex(i, doc);
		if (atom)
		{
			atom->Message(type, data);
		}
	}
}

Hi Adam, happy new year to you, too!

Since it works now, for some reason, I am pretty happy with what I have. However, since it might interest other plugin developers, I'll share more code. Maybe you have some tipps about improvements or potentially dangerous stuff, too.

The idea is that the shader has a LINK field where the user can link an object (which is also part of my plugin). The object can (but doesn't have to) provide a list of "custom outputs" that will be added to the shader's CYCLE. In the screenshot below it's the "Difference Map".

When a rendering is started, the shader will request the according data from the linked object during InitRender(). But that's not part of this thread

The shader's GetDDescription():

Bool TerrainOperatorShader::GetDDescription(GeListNode *node, Description *description, DESCFLAGS_DESC &flags)
{
	iferr_scope_handler
	{
		GePrint(err.GetMessage());
		return false;
	};

	if (!description->LoadDescription(node->GetType()))
		return false;
	flags |= DESCFLAGS_DESC::LOADED;

	BaseDocument* doc = node->GetDocument();
	const BaseContainer& dataRef = static_cast<BaseShader*>(node)->GetDataInstanceRef();
	
	// Hide or show attributes, depending on shader mode
	const Bool slopeMode = dataRef.GetInt32(XTERRAINOPERATORSHADER_DATA) == XTERRAINOPERATORSHADER_DATA_SLOPE;
	TF4D::GUI::ShowDescription(node, description, XTERRAINOPERATORSHADER_SLOPE_DIRECTION_ENABLE, slopeMode);
	TF4D::GUI::ShowDescription(node, description, XTERRAINOPERATORSHADER_SLOPE_DIRECTION, slopeMode);

	// Get linked object
	BaseObject *linkedObject = dataRef.GetObjectLink(XTERRAINOPERATORSHADER_OPERATORLINK, doc);
	if (linkedObject)
	{
		// Get linked object's NodeData
		TF4D::BaseTerrainOperatorData* linkedOperator = linkedObject->GetNodeData<TF4D::BaseTerrainOperatorData>();

		// Get list of custom outputs (these are the elements to add to the CYCLE)
		maxon::BaseArray<TF4D::GUI::CycleElementData> customOutputs;
		if (linkedOperator->GetCustomOperatorOutputs(customOutputs))
		{
			if (!TF4D::GUI::AddCycleElements(node, description, XTERRAINOPERATORSHADER_DATA, customOutputs, true))
				iferr_throw(maxon::UnexpectedError(MAXON_SOURCE_LOCATION, "Could not add LONG CYCLE elements!"_s));
		}
	}

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

The linked object's NodeData's GetCustomOperatorOutputs():

Bool ErosionOperator::GetCustomOperatorOutputs(maxon::BaseArray<TF4D::GUI::CycleElementData>& customOperatorOutputs) const
{
	iferr_scope_handler
	{
		GePrint(err.GetMessage());
		return false;
	};

	customOperatorOutputs.Reset();

	// GetCustomOutputName() simply returns a maxon::String
	customOperatorOutputs.Append(TF4D::GUI::CycleElementData(TF4D_CUSTOMOUTPUT_EROSION_DIFFERENCE, GetCustomOutputName(TF4D_CUSTOMOUTPUT_EROSION_DIFFERENCE))) iferr_return;

	return true;
}

Cheers,
Frank

Ah, damn. Now I've spoiled that I'm working on erosion for Terraform4D

Why don't you avoid all those difficulties and simply implement that dialog using the C4D UI?

If you're storing data in the tag's BaseContainer, you don't need to override Write() and Read(). That's meant for private class member whose data would be lost otherwise.

Also, you can remove the "return true" at the end of the functions. As you already return in the previous line, it will never be called.

I did today, including it in projectdefinition.txt worked smoothly, thank you!
If I ever find out why copying it do the folders does not work, I'll post it here.

Oh my god. the stupidest error....
OK, question 1 solved already, thanks

Ah, great, thank for checking!
Then I don't need to worry about my bmp code

Cheers,
Frank

In general, beakpoints in \modules\c4dplugin\source\src\richard\genesis\ge_container.h often get triggered when you use a Get() function to get a value that wasn't initialized with that very same type. E.g. initializing a container value in YourPlugin::Init() with bc->SetInt32(THE_ID, 123) and later getting the value with bc->GetBool(THE_ID) will probably trigger a breakpoint, too.

Sometimes you gotta play detective a bit, to interpret those breakpoints correctly, but in almost 100% of the cases, they indicate a problem in your code. Over time, you get a feeling for what the reason might be.

Cheers,
Frank

That second screnshot shows a note on the bottom, you can go to the Options dialog and have it always show the disassembly for missing source files. And yes, Maxon does not hand out their debug files to 3rd party developers, and I wouldn't expect that. To debug that breakpoint, simply take a look into the Call Stack and see what the last function call in your code was, it usually gives you an idea what went wrong.

Cheers,
Frank

Hi Ferdinand,

I agree, but the problem is that projecttool also does play an automated inhouse-tool role, as you might still be aware of, and there these additional files are likely not welcome.

I remember very well. I just didn't want to spoil any details here, without anyone from the SDK team mentioning it first
It does make sense in the Maxon context where one solution hosts a multitude of projects. Just for plugin developers, it usually results in having the Project Tool generate a nice project, but then having to build the solution manually, with all included framework projects, build dependencies (even between the framework projects), and references. That's error prone, generates more support noise for you, and annoys the plugin developers

But I will try to find a place for this idea, which then would have to be an option of the tool on a per project basis.

I think there could be a very easy solution (well, at least it sounds easy... things are rarely as easy as they look on the outside, I know): The projetdefinition.txt specifies what type of file should be created:

For projects:

// Type of project - can be [Lib;DLL;App]
Type=DLL

For solutions:

Type=Solution

So, why not just allow something like this:

Type=DLL,Solution

It could simply do two complete runs then, one for each element in the enumerated Type. It would first do a normal run for Type=DLL, and then another one for Type=Solution. That would just require Project Tool to split the Type string by comma, and then iterate over the split parts and do one complete run for each of them.

That way, plugin developers could have a much improved workflow when creating new projects, and maxon developers wouldn't be bothered with unwanted files.

Currently, I still check in all my plugin project files for all Cinema 4D releases I support, into the source management, because regenerating them on the fly with Project Tool (which is, as far as I remember, the original idea behind it) is just way too much work.

Cheers,
Frank

It is a bit unfortunate that the project tool does not generate an .sln file along with the .vcxproj.

While that makes sense for a large project, where several projects are in the same solution, and usually have to be built together, the normal plugin developer usually only has one project file, and the frameworks. They mostly have the solutoin file in the same folder as the project file. Having to effectively create the solution manually is quite error prone, as there are dependencies and references to to be added.

If there was an option to generate both, the .vcxproj and the .sln file, it would make it easier for plugin developers to get going.

Cheers,
Frank

Shouldn't that be possible in PluginMessage() with id == C4DPL_STARTACTIVITY?

https://developers.maxon.net/docs/Cinema4DPythonSDK/html/misc/pluginstructure.html?highlight=pluginmessage#PluginMessage

Cheers,
Frank

As Manuel stated, you'll need to get the object's cache (baseObjectPtr->GetCache()). If you need the exact projected position of your mouse cursor on the polygon geometry, my first idea would be to use class GeRayCollider to shoot rays from your camera through the mouse cursor onto the geometry. Since you get a BaseDraw* in ToolData::MouseInput() you have all the necessary functions to transform mouse coordinates to world space.

Cheers,
Frank

No worries. I forgot about it, too, until I noticed the issue again recently.

I have sent an email to sdk_support(at)maxon(dot)net with some example code and more detailled info.
Let's continue the discussion there

Cheers,
Frank

Any news on this?

Cheers,
Frank

The video looks normal, the camera is targeting the cube. But it's hard to tell, as the quality is very low.
I didn't see the camera jump around. What did you expect to happen?

If I remember correctly, I decided to just not spend any more time on this issue, and rather keep the number of HUD elements low to avoid speed issues. Why the rest just works, I don’t know. Maybe it’s just the right drawpass for it.