About

A BaseOverride defines the settings for a specific BaseList2D object in a certain take.

Note: BaseOverride objects are stored with the changed object. One should not access them directly, only through BaseTake.

  // This example creates ten takes with different overrides of the material color.
 
  // get the active material
  BaseMaterial* const material = doc->GetActiveMaterial();
 
  // check if the active material is the Cinema 4D standard material
  if (material == nullptr || material->GetType() != Mmaterial)
    return maxon::OK;
 
  // create 10 takes with variations
  for (Int32 i = 0; i < 10; ++i)
  {
    const String       takeName = "Variation " + String::IntToString(i);
    BaseTake*    const materialVariation = takeData->AddTake(takeName, nullptr, nullptr);
    if (materialVariation == nullptr)
      return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
 
    const DescID matColID = ConstDescID(DescLevel(MATERIAL_COLOR_COLOR, DTYPE_COLOR, 0));
 
    // new color
    const Vector hsv { Float(i) * 0.1, 1.0, 1.0 };
    const Vector rgb = HSVToRGB(hsv);
    const GeData newValue { rgb };
 
    // create override
    BaseOverride* const overrideNode = materialVariation->FindOrAddOverrideParam(takeData, material, matColID, newValue);
    if (overrideNode == nullptr)
      return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
 
    overrideNode->UpdateSceneNode(takeData, matColID);
  }

Access

Existing BaseOverride objects can be accessed from the BaseTake or the TakeData object:

BaseTake::GetOverrides(): Returns all BaseOverride of the take.
BaseTake::FindOverride(): Returns the BaseOverride if the given node is overridden.
BaseTake::FindOverrideInHierarchy(): Returns the BaseOverride for the given node and given parameter ID by searching in the entire hierarchy.
TakeData::FindOverrideCounterPart(): Returns the BaseOverride and BaseTake that stores the backup value.

  // This example searches for an override of the active object in the current take.
 
  BaseObject* const object = doc->GetActiveObject();
  if (object == nullptr)
    return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION);
 
  BaseTake* const take = takeData->GetCurrentTake();
  if (take == nullptr)
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
 
  BaseOverride* const baseOverride = take->FindOverride(takeData, object);
  if (baseOverride == nullptr)
    return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);

Allocation/Deallocation

Overrides are created using the host BaseTake:

BaseTake::FindOrAddOverrideParam(): Finds or if necessary creates an override for the given object and parameter.
BaseTake::OverrideNode(): Overrides all parameters of the passed node.
BaseTake::AutoTake(): Compares the two given nodes and creates needed overrides.

  // This example adds an override to the current take for the given cube object
  // and changes the "Size" parameter.
 
  // prepare parameter ID and new value
  const DescLevel cubeSizeLevel { PRIM_CUBE_LEN, DTYPE_VECTOR, 0 };
  const DescLevel vectorXLevel { VECTOR_X, DTYPE_REAL, 0 };
  const DescID    ID = CreateDescID(cubeSizeLevel, vectorXLevel);
  const GeData    newValue { 300.0 };
 
  // create override
  BaseOverride* const overrideNode = take->FindOrAddOverrideParam(takeData, cube, ID, newValue);
  if (overrideNode == nullptr)
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
 
  // update the object
  overrideNode->UpdateSceneNode(takeData, ID);

Note: To delete a specific parameter from an override BaseTake::DeleteOverride() must be used.

Navigation

BaseOverride instances are organized in a BaseList2D list:

BaseOverride::GetNext(): Returns the next BaseOverride in the list or nullptr.
BaseOverride::GetPred(): Returns the previous BaseOverride in the list or nullptr.

Note: Functions like BaseOverride::GetUp() etc. are reserved for future use.

Read-Only Properties

The following properties can be accessed:

BaseOverride::GetSceneNode(): Returns a pointer to the original scene node.
BaseOverride::GetOwnerTake(): Returns the host BaseTake.
BaseOverride::IsInGroup(): Checks if the BaseOverride is in a group and returns that BaseOverrideGroup.

Override

A BaseOverride stores the values of different parameters. These parameters can be accessed in different ways:

BaseOverride::IsOverriddenParam(): Checks if the parameter with the given ID is overridden.
BaseOverride::GetAllOverrideDescID(): Returns the IDs of all overridden parameters.
BaseOverride::UpdateSceneNode(): Updates the given parameter on the assigned scene node.

  // This example checks if the given take contains an override for the given sphere object.
  // If so, it is checked if the "Radius" parameter is overridden.
  // In this case, the value is increased and the node updated.
 
  // check if the given object is a "Sphere" object
  if (object->GetType() != Osphere)
    return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION);
 
  BaseOverride* const baseOverride = take->FindOverride(takeData, object);
  if (baseOverride == nullptr)
    return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION);
 
  // the "Radius" parameter of a sphere
  const DescID ID = ConstDescID(DescLevel(PRIM_SPHERE_RAD, DTYPE_REAL, 0));
 
  // check if the "Radius" parameter is overridden
  if (baseOverride->IsOverriddenParam(ID))
  {
    GeData data;
    baseOverride->GetParameter(ID, data, DESCFLAGS_GET::NONE);
    // change parameter
    data = data.GetFloat() + 10.0;
    // update override
    baseOverride->SetParameter(ID, data, DESCFLAGS_SET::NONE);
    // update node
    baseOverride->UpdateSceneNode(takeData, ID);
  }

Table of Contents