Messages

The take system sends two messages to an object's NodeData::Message() method:

MSG_DESCRIPTION_ALLOWOVERRIDE : Send to find out if a certain parameter can be overridden. Data is DescriptionAllowOverride
MSG_DESCRIPTION_TAKECHANGED : Send to the node if the user changed the take. Data is DescriptionTakeChanged. This is typically handled alongside MSG_DESCRIPTION_CHECKUPDATE.

      // This code simply disables overrides for all parameters of the host object.
 
      case MSG_DESCRIPTION_ALLOWOVERRIDE:
      {
        DescriptionAllowOverride* const dao = (DescriptionAllowOverride*)data;
        if (dao && dao->_descId)
        {
          dao->_allow = false;
 
          return true;
        }
        break;
      }

and

      // This example catches the message MSG_DESCRIPTION_TAKECHANGED
      // to be informed what parameter was changed.
 
      case MSG_DESCRIPTION_TAKECHANGED:
      {
        DescriptionTakeChanged* const dtc = (DescriptionTakeChanged*)data;
 
        if (dtc && dtc->_descId)
        {
          const Int32 parameterID = (*dtc->_descId)[0].id;
          ApplicationOutput(String::IntToString(parameterID));
        }
 
        break;
      }

Note: It is also possible to send MSG_DESCRIPTION_ALLOWOVERRIDE to an object using Message() to check if a certain parameter can be overridden.

Core Message

The Take System sends a core message when the take changed.

EVMSG_TAKECHANGED: Sent as a global notification so dialogs can update when the take changed or MessageData plugins can react.

  // This example shows how a MessageData plugin catches the EVMSG_TAKECHANGED message.
 
  Bool CoreMessage(Int32 id, const BaseContainer& bc)
  {
    if (id == EVMSG_TAKECHANGED)
    {
      ApplicationOutput("Take Changed");
    }
    return true;
  }

Custom Tags

If a custom tag should appear in the Take Manager's context menu, it must use the flag TAG_ADDTOTAKEGROUP:

Bool RegisterLookAtCamera(void)
{
  return RegisterTagPlugin(ID_LOOKATCAMERATAG,
      GeLoadString(IDS_LOOKATCAMERA),
      TAG_EXPRESSION | TAG_VISIBLE | TAG_ADDTOTAKEGROUP,
      LookAtCamera::Alloc,
      "Tlookatcameraexp",
      AutoBitmap("lookatcamera.tif"),
      0);
}

Custom GUIs

It is possible to disable the override functionality for custom GUI elements. This can be useful if the GUI element does not manage data and only displays internal states of a node.

CUSTOMGUI_DISALLOW_TAKESOVERRIDE : This flag must be set if the GUI element should be ignored by the override system.

if (!RegisterCustomGuiPlugin(GeLoadString(IDS_CUSTOMGUISTRING), CUSTOMGUI_DISALLOW_TAKESOVERRIDE, NewObjClear(SDKExampleCustomGUIString)))

CUSTOMGUI_DISALLOW_TAKESOVERRIDE

#define CUSTOMGUI_DISALLOW_TAKESOVERRIDE

Disallows Takes override e.g. the GUI does not hold real data but just react to the node changes (e....

Definition: c4d_customguidata.h:75

cinema::RegisterCustomGuiPlugin

Bool RegisterCustomGuiPlugin(const maxon::String &str, Int32 info, CustomGuiData *dat)

Description GUI

It is possible to create custom dialogs with the Description GUI element. With a parameter it is possible to disable the Take System for that GUI. This is needed e.g. if the GUI element is used to display a custom node.

DESCRIPTION_NO_TAKE_OVERRIDES : This parameter disables overrides for this Description GUI element.

    // This example configurse a new DescriptionCustomGui element.
 
    BaseContainer customguiSettings;
    customguiSettings.SetBool(DESCRIPTION_ALLOWFOLDING, true);
    customguiSettings.SetBool(DESCRIPTION_NO_TAKE_OVERRIDES, true);
 
    const Int32 guiFlags = BFH_SCALEFIT | BFV_SCALEFIT;
 
    void* customGUI = AddCustomGui(GADGET_ID, CUSTOMGUI_DESCRIPTION, ""_s, guiFlags, 400, 200, customguiSettings);
    DescriptionCustomGui* const descriptionGUI = static_cast<DescriptionCustomGui*>(customGUI);

Bits

These bits are used by the Take System to mark objects and tags changed by it:

NBIT::TAKE_LOCK : A node in a BaseOverrideGroup cannot be changed.
NBIT::TAKE_OBJINGROUP : The object is overridden by a BaseOverrideGroup.
NBIT::TAKE_EGROUPOVERIDDEN : The object editor visibility is overridden by a BaseOverrideGroup.
NBIT::TAKE_RGROUPOVERIDDEN : The object render visibility is overridden by a BaseOverrideGroup.

  // This example loops through the tags of the given object and checks if a tag was created by a BaseOverrideGroup.
 
  BaseTag* tag = object->GetFirstTag();
 
  while (tag != nullptr)
  {
    if (tag->GetNBit(NBIT::TAKE_LOCK))
    {
      const String message { "The Tag " + tag->GetName() + "was created by a BaseOverrideGroup" };
      ApplicationOutput(message);
    }
 
    tag = tag->GetNext();
  }

Take Rendering

It is possible to check if the Take System is currently rendering in the background:

IsTakeRenderRunning(): Checks if a Take render is running.

  // This example checks if takes are rendered. If not, the render process will be started.
 
  if (IsTakeRenderRunning() == false)
    CallCommand(431000068);   // render marked takes to PV

Table of Contents