In continuation to the MultipassBitmap problem I had with R16, it now seems I might have related issues with R20.

Following is the full implementation of a dummy plugin to reproduce the issue.

It's a Command plugin, when executed it will create a single layer bitmap, and a multi layer one. Both will be displayed into the Picture Viewer.
Both bitmaps will have a background, on top of that a red diagonal cross, on top of that a green circle at the center, on top of that a blue rectangle in the top left quarter of the bitmap. And finally, on top of that a bitmap (the plugin's icon) being blitted in the top left corner.
The single layer bitmap will have all drawing in a single "layer", while the multi layer bitmap does have each different drawing context in a separate layer.

The single layer bitmap is drawn without any issue, but the multi layer one has issues when blitting.
I get a "Cinema 4D has triggered a breakpoint" when performing the Blit() for the MultipassBitmap ... and resulting bitmap has no blitted bitmap. Still, the same method is used to blit on regular BaseBitmap, and this works as expected and does not report any problem.

I can only assume I am doing something wrong, but I cannot figure out what exactly.

// ========================
// Cinema 4D C++ plugin
//
// PluginName: Test
// Dummy "empty" plugin
// ========================

// Main.cpp

#include "c4d.h"
#include "lib_clipmap.h"

// Dummy IDs - for demonstration purposes only
#define MYCOMMAND_PLUGIN_ID	1000000

// ====================================
// CommandData
// ====================================

class MyCommand : public CommandData
{
	INSTANCEOF(MyCommand, CommandData)

public:
	virtual Bool Execute(BaseDocument* doc);

	// Custom methods

protected:
	void DrawBackground(GeClipMap* clipmap);
	void DrawCross(GeClipMap* clipmap);
	void DrawCircle(GeClipMap* clipmap);
	void DrawRectangle(GeClipMap* clipmap);
	void DrawBitmap(GeClipMap* clipmap);

	Bool WriteSingleLayer();
	Bool WriteMultiLayer();
};

Bool MyCommand::Execute(BaseDocument* doc)
{
	WriteSingleLayer();
	WriteMultiLayer();

	return TRUE;
}


void MyCommand::DrawBackground(GeClipMap* clipmap)
{
	Vector color(128);
	clipmap->SetColor(SAFEINT32(color.x), SAFEINT32(color.y), SAFEINT32(color.z), 255);
	clipmap->FillRect(0, 0, clipmap->GetBw() - 1, clipmap->GetBh() - 1);
}

void MyCommand::DrawCross(GeClipMap* clipmap)
{
	Vector color(255,0,0);
	clipmap->SetColor(SAFEINT32(color.x), SAFEINT32(color.y), SAFEINT32(color.z), 255);
	clipmap->Line(0, 0, clipmap->GetBw() - 1, clipmap->GetBh() - 1);
	clipmap->Line(0, clipmap->GetBh() - 1, clipmap->GetBw() - 1, 0);
}

void MyCommand::DrawCircle(GeClipMap* clipmap)
{
	Vector color(0,255,0);
	clipmap->SetColor(SAFEINT32(color.x), SAFEINT32(color.y), SAFEINT32(color.z), 255);
	clipmap->FillEllipse(100, 100, clipmap->GetBw() - 101, clipmap->GetBh() - 101);
}

void MyCommand::DrawRectangle(GeClipMap* clipmap)
{
	Vector color(0,0,255);
	clipmap->SetColor(SAFEINT32(color.x), SAFEINT32(color.y), SAFEINT32(color.z), 255);
	clipmap->FillRect(0, 0, clipmap->GetBw() / 2, clipmap->GetBh() / 2);
}

void MyCommand::DrawBitmap(GeClipMap* clipmap)
{
	AutoBitmap bitmap("icon.png"_s);
	if (bitmap)
	{
		// use a clipmap for drawing/blitting the bitmap
		AutoAlloc<GeClipMap> bitmapClipmap;
		if (!bitmapClipmap)
			return;
		if (bitmapClipmap->Init(bitmap) != IMAGERESULT::OK)
			return;

		clipmap->Blit(0, 0, *bitmapClipmap, 0, 0, bitmapClipmap->GetBw() - 1, bitmapClipmap->GetBh() - 1, GE_CM_BLIT::COPY);
	}
}


Bool MyCommand::WriteSingleLayer()
{
	AutoAlloc<BaseBitmap> outputBitmap;
	if (!outputBitmap)
		return false;
	const Int32 bitdepth = 32;
	const Int32 bitmapSize = 512;
	IMAGERESULT res = outputBitmap->Init(bitmapSize, bitmapSize, bitdepth);
	if (res != IMAGERESULT::OK)
		return false;

	AutoAlloc<GeClipMap> clipMap;
	if (clipMap)
	{
		res = clipMap->Init(outputBitmap);
		if (res != IMAGERESULT::OK)
			return false;

		clipMap->BeginDraw();

		DrawBackground(clipMap);
		DrawCross(clipMap);
		DrawCircle(clipMap);
		DrawRectangle(clipMap);
		DrawBitmap(clipMap);

		clipMap->EndDraw();
	}

	// open the resulting bitmap into the Picture Viewer
	ShowBitmap(outputBitmap);

	return true;
}

Bool MyCommand::WriteMultiLayer()
{
	const Int32 bitdepth = 32;
	const Int32 bitmapSize = 512;
	const COLORMODE colorMode = COLORMODE::ARGB;
	MultipassBitmap* multiBitmap = MultipassBitmap::Alloc(bitmapSize, bitmapSize, colorMode);
	if (!multiBitmap)
		return false;

	// get the first layer which is automatically created at allocation time
	MultipassBitmap* layer = multiBitmap->GetLayerNum(0);
	if (!layer)
	{
		MultipassBitmap::Free(multiBitmap);
		return false;
	}
	layer->SetParameter(MPBTYPE::NAME, "Background");
	layer->SetParameter(MPBTYPE::SAVE, true);
	layer->SetParameter(MPBTYPE::SHOW, true);
	// draw onto this layer via a ClipMap
	AutoAlloc<GeClipMap> clipMap;
	if (clipMap && (clipMap->Init(layer) == IMAGERESULT::OK))
	{
		clipMap->BeginDraw();

		DrawBackground(clipMap);

		clipMap->EndDraw();
	}

	// reuse the clipMap used for the background layer (reinit for each layer)

	MultipassBitmap* crossLayer = multiBitmap->AddLayer(nullptr, colorMode);
	if (crossLayer)
	{
		crossLayer->SetParameter(MPBTYPE::NAME, "Cross"_s);
		crossLayer->SetParameter(MPBTYPE::SAVE, true);
		crossLayer->SetParameter(MPBTYPE::SHOW, true);
		//crossLayer->SetParameter(MPBTYPE::BLENDMODE, LAYER_NORMAL);

		if (clipMap->Init(crossLayer) == IMAGERESULT::OK)
		{
			clipMap->BeginDraw();

			DrawCross(clipMap);

			clipMap->EndDraw();
		}
	}

	MultipassBitmap* circleLayer = multiBitmap->AddLayer(nullptr, colorMode);
	if (circleLayer)
	{
		circleLayer->SetParameter(MPBTYPE::NAME, "Circle"_s);
		circleLayer->SetParameter(MPBTYPE::SAVE, true);
		circleLayer->SetParameter(MPBTYPE::SHOW, true);
		//circleLayer->SetParameter(MPBTYPE::BLENDMODE, LAYER_NORMAL);

		if (clipMap->Init(circleLayer) == IMAGERESULT::OK)
		{
			clipMap->BeginDraw();

			DrawCircle(clipMap);

			clipMap->EndDraw();
		}
	}

	MultipassBitmap* rectangleLayer = multiBitmap->AddLayer(nullptr, colorMode);
	if (rectangleLayer)
	{
		rectangleLayer->SetParameter(MPBTYPE::NAME, "Rectangle"_s);
		rectangleLayer->SetParameter(MPBTYPE::SAVE, true);
		rectangleLayer->SetParameter(MPBTYPE::SHOW, true);
		//rectangleLayer->SetParameter(MPBTYPE::BLENDMODE, LAYER_NORMAL);

		if (clipMap->Init(rectangleLayer) == IMAGERESULT::OK)
		{
			clipMap->BeginDraw();

			DrawRectangle(clipMap);

			clipMap->EndDraw();
		}
	}

	MultipassBitmap* bitmapLayer = multiBitmap->AddLayer(nullptr, colorMode);
	if (bitmapLayer)
	{
		bitmapLayer->SetParameter(MPBTYPE::NAME, "Bitmap"_s);
		bitmapLayer->SetParameter(MPBTYPE::SAVE, true);
		bitmapLayer->SetParameter(MPBTYPE::SHOW, true);
		//bitmapLayer->SetParameter(MPBTYPE::BLENDMODE, LAYER_NORMAL);

		if (clipMap->Init(bitmapLayer) == IMAGERESULT::OK)
		{
			clipMap->BeginDraw();

			DrawBitmap(clipMap);	// <--- performing the blit function reports a "Cinema 4D has triggered a breakpoint"

			clipMap->EndDraw();
		}
	}

	// open the resulting bitmap into the Picture Viewer
	ShowBitmap(multiBitmap);

	MultipassBitmap::Free(multiBitmap);
	return true;
}





Bool RegisterMyCommand(void)
{
	return RegisterCommandPlugin(MYCOMMAND_PLUGIN_ID, "Test"_s, 0, AutoBitmap("icon.png"_s), "Test"_s, NewObjClear(MyCommand));
}

// ====================================
// Plugin Main 
// ====================================
Bool PluginStart(void)
{
	ApplicationOutput("Test"_s);
	RegisterMyCommand();

	return TRUE;
}
void PluginEnd(void)
{
}
Bool PluginMessage(Int32 id, void * data)
{
	switch (id) {
	case C4DPL_INIT_SYS:
		if (!g_resource.Init())
			return FALSE;
		return TRUE;
	case C4DMSG_PRIORITY:
		return TRUE;
	case C4DPL_BUILDMENU:
		break;
	case C4DPL_ENDACTIVITY:
		return TRUE;
	}
	return FALSE;
}

@gheyret said in What is mean "2&c&" in Python:

Can you give me a simple exaple for this?

It would be easier to explain when you show the implementation you have so far to set up the dialog and handle the selected menu items? At least then we have some context to start from.

@gheyret
I am not sure to understand your question, since it's technically only two statements.
However, if I assume correctly, you are trying to solo an object by using "item 1" and not solo that object by using "item 2"?
This doesn't make sense to me, since you have 2 booleans to control a single state (solo / not solo) while the combinations of the 2 booleans provide 4 possible results.
I would expect you only have "item 1" and use its state (checked / unchecked) to control solo / not solo.

Another solution would be that each "item x" changes the state of the other "item y".

@mp5gosu
I know, that's why I mention it again ... to please update the Code Style code snippet.

"&c&" will add a checkmark in the menu item,
"&d&" will disable the menu item (user is unable to select it)
This is not Python related, it's just a way of defining extra options for menu items, by including it in the menu item text.

@s_bach said in iferr warn_unused_result missed:

You don't need to write different code for different platforms. You just have to write correct code and Xcode simply performs better checks.

I am not implying to writing different code per platform. That's the whole point I am trying to make here.

All I want is to write correct code, and let the compiler help me in the process, by notifying me where I left out required checks. Unfortunately, Visual Studio doesn't really help me here.

But developing on macOS is not an option, it's only used for building the final plugin.

Since I want to keep source code identical between macOS and Windows versions of the plugin, I need to adjust code on macOS to get it compiled, and port back these changes to the source code made with Visual Studio. (Source control is done on the Windows development machine, which doesn't always like a mixture of source code files from Windows and macOS)

I had hoped the preprocessing via the stylechecks could be used to streamline the issues brought up by the compiler. But, apparently, I am misinterpreting its purpose.

... If in doubt, always compile on both platforms and make sure there are no warnings

Well, that's exactly the reason for my query. I am starting to feel sorry for bringing it up.

Bringing this back to the attention, as it might have been lost during the holiday period.

The Code Style Guide (section 9.6) shows

class Test
{
  MAXON_DISALLOW_COPY_AND_ASSIGN(Test)
private:
  Int _value[5];
};
class Test
{
  MAXON_DISALLOW_COPY_AND_ASSIGN(Test)
public:
  Bool CopyFrom(const Test& source);
private:
  Int _value[5];
};

where the CopyFrom should actually not return a Bool but a maxon::Result<void>.

Replying to this topic to bring it back onto the radar, just in case more recent information could be added. As I still, now and then, encounter this problem when porting plugin updates to macOS.

@martinweber
Never actually cared trying Clear() as this is a BaseBitmap method, and not GeClipMap.
But I tried now just to check, and while it doesn't crash Visual Studio reports that it triggered a breakpoint. No crash, but not a good thing either.
And so does calling SetPen() or Line().
Unfortunately, the output is left empty. I have tried using a simple RGB colormode, instead of the original ARGB ... hoping the issue might have something to do with the alpha channel. But same issue no matter the colormode.

Seems I am unable to draw on a MultipassBitmap in R16.

@martinweber said in Drawing on MultipassBitmap's GeClipMap crashes in R16.050:

Just some ideas and guesses:

Thanks Martin.

• I do check if layer is nullptr, but hadn't included this in the provided code snippet, in order to keep it as short as possible.
• Tried to cast the layer to basebitmap before using it to initialize a GeClipMap. Still same problem.
• Using operator GeClipMap *() is something I picked up from ... (cannot remember). I confirm that simply assigning the clipmap to viewData->mClipMap, does work as well. However, passing clipmap as parameter to DrawBackground is not an option in my situation.

Tried all of the above, but still get an exception thrown as a result of access violation writing location 0x00..03FF when performing a clipmap->FillRect.

The SetColor is fine, and so are the GetBw and GetBh, but the actual FillRect throws an exception. But only on a MultipassBitmap. Doing exactly the same on a regular BaseBitmap is fine.