Hi pim, thanks for reaching out us.

With regard to your issue I've tried to replicate the behavior and I was able to have the BaseObject::GetRad() returning a 0-valued vector only when performing undo steps.
If this is the sole case then it's likely to be caused by the Subdivision Surface generator actually regenerating its cache after your custom tag has been executed. This is also confirmed with the Subdivision Surface generator not being in the hierarchy: all the tests never produced a single 0-valued vector returned by BaseObject::GetRad().

If, instead, you're able to reproduce in a different scenario, please provide detailed steps in order to dig down more.

Cheers, Riccardo

Hi krftt thanks for reaching out us.

With regard to your question, if the intent is to bake the final appearance of a PBR material on a texture, I confirm that there are no means to achieve this considering that the baked data will also be camera-dependent.

If, on the contrary, your goal is to sample the shader used in any of the reflection layers used in a PBR material you can consider BaseShader::Sample() and, given a ChannelData, retrieve the color at a specific point - see this thread.

To browse through the different channel you can use something like:

    # check for an active material
    mat = doc.GetActiveMaterial()
    if mat is None:
        return
    
    # retrieve the reflection layers count
    layersCount = mat.GetReflectionLayerCount()
    
    # loop through the layers
    for i in xrange(layersCount):
        # get the ReflectionLayer instance and the related data ID
        reflLayer = mat.GetReflectionLayerIndex(i)
        reflLayerData = reflLayer.GetDataID()
        # check for the instance to be the one currently active in the Attribute Manager
        if reflLayer.GetFlags() & (c4d.REFLECTION_FLAG_TAB):
            # retrieve the color
            color = mat[reflLayerData + c4d.REFLECTION_LAYER_COLOR_COLOR]   
            # try to retrieve the shader
            colorShader = mat[reflLayerData + c4d.REFLECTION_LAYER_COLOR_TEXTURE]

            # do something with the data retrieved
            if colorShader is None:
                print "Selected layer is ", reflLayer.GetName(), "and uses color: ", color
            else:
                print "Selected layer is ", reflLayer.GetName(), "and uses shader: ", colorShader.GetName()

Best, Riccardo

Hi Mike, thanks for reaching out us.

With regard to your question, I've had no issue in running something very similar to your code.
Just one note: the ID you're using to store the value in the BaseContainer doesn't have to coincide with the one you're using to register your plugin, is this the case?

On my side I have:

	// cast to BaseTag and check
	BaseTag* customTag = static_cast<BaseTag*>(node);
	if (!customTag)
		return false;
	
	// retrieve the associated BaseContainer and checl
	BaseContainer* customTagBC = customTag->GetDataInstance();
	if (!customTagBC)
		return false;
	
	// switch on message type
	switch (type)
	{
		// Description Command
		case MSG_DESCRIPTION_COMMAND:
		{
			DescriptionCommand* const dc = (DescriptionCommand*)data;
			if (!dc)
				return false;
			// check the descId and act consequently
			if (dc->_descId[0].id == T_PC11485_BUTTON_SET)
			{
				Int32 currentVal = customTagBC->GetInt32(T_PC11485_VALUE);
				customTagBC->SetInt32(T_PC11485_VALUE, currentVal + 1);
			}
			if (dc->_descId[0].id == T_PC11485_BUTTON_GET)
			{
				ApplicationOutput("Value: @", customTagBC->GetInt32(T_PC11485_VALUE));
			}
			break;
		}
	}

for T_PC_11485.h

#ifndef T_PC_11485_H__
#define T_PC_11485_H__

enum
{
	T_PC11485_BUTTON_SET = 1000,
	T_PC11485_BUTTON_GET,
	T_PC11485_VALUE
};

#endif // T_PC_11485_H__

and for T_PC_11485.res

CONTAINER T_PC11485
{
	NAME T_PC11485;
	INCLUDE Tbase;

	GROUP ID_TAGPROPERTIES
	{
		BUTTON T_PC11485_BUTTON_SET	{}
		BUTTON T_PC11485_BUTTON_GET	{}
	}
}

Hope this helps, Riccardo

@Rage if you're looking for a solution where the user is not involved, stick to the first answer where no CallButton() was considered.
On the contrary using it will request the user to interact since there are no means to programmatically interact with the UI or scripting users' actions on the UI.

Best, Riccardo

Hi Mafster, thanks for following up.

The documentation here properly indicates that passing no parameter to Wait() is passing True.
Long story short, this value is required in order to avoid Cinema being stuck on waiting for the thread to end.

Hoping this helps in solving the issue, give best.
Riccardo

Hi Rage, with regard to your follow up you can use the c4d.CallButton() passing, as first argument, the document you intend to change the scale of.

Beware that using this approach, you'll be provided with a modal dialog which requires the user interaction in the end.

Cheers, Riccardo

Hi Daniel, thanks for reaching out us.

With regard to the LModulo function, being it part of the cinema.framework, you can see, by looking at the implementation, that it:

• it's the specialized version for integers with either Int32 or Int64 parameters' data-type;
• handles properly the case of the first argument being negative;
• handles gracefully the case where the second argument is zero.

The code, available in the framework is:

if (!b)
	return 0;
if (a >= 0)
	return a % b;

a -= (a / b) * b;
if (a < 0)
	a += b;

return a;

Cheers, Riccardo

Hi Mafster and thanks for reaching out us.

With regard to your question, we've recently discussed a similar topic here and I do recommend having a look at.

I've used the code below and I actually had Cinema being reactive whilst ffmpeg was running as well as having Cinema being gracefully closed at the end of the session.

import c4d
from c4d.threading import C4DThread

import subprocess, sys


class UserThread(C4DThread):
  def Main(self):
    # call subprocess
    cmd = ["/opt/local/sbin/ffmpeg", "<arg1>", "<arg2>", ..., "<argn>"]
    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    pass

def main():
  thread = UserThread()
  thread.Start()
   # Wait until the main method is done
  thread.Wait(True)


# Execute main()
if __name__=='__main__':
  main()

Am I missing something here?

Cheers, Riccardo

Hi Aaron,

Hi Riccardo, thank you for help! Do you have any other shader plugin in the plugins/ folder?

No, not any other single plugin

when c4dsdkplugins were combined there - also different results.

Also here I found nothing unexpected: either with or without the cinema4dsdk plugins being compiled I had no stall in loading Cinema 4D.

Last with regard to the cracked version, I can't comment.

Best, Riccardo

Hi Frank, thanks for following up.

With regard to

/Volumes/Branches/build_osx/osx-4-release/depot/release/20.0/modules/c4dplugin/source/src/christian/ge_register.cpp(244): WARNING: Unknown baselist allocator - RegID: OBJECT
Optout defined by Installer / Updater.

it has actually nothing to do with BuildNgon()

With regard to

/Volumes/Branches/build_osx/osx-4-release/depot/release/20.0/modules/model/source/dave/modeling/ngonbase.cpp(1450): CRITICAL: Stop: Degenerated Ngon Creation, an Ngon must have at least 5 vertices.

it takes place if the code identifies a potential situation where the number of outer edges ( computed from the list of the inner edges ) is lower than 5 which then could create degenerate ngons (since they should be quads).
This check has been recently introduced to avoid that 4-sides degenerated ngons were created in place of quads.

Best, Riccardo