BaseList2D Manual


The class BaseList2D is based on C4DAtom and GeListNode. It is a base class for many entities of the classic Cinema 4D API and adds additional functionality.

BaseList2D objects are an instance of Tbaselist2d.


BaseList2D elements can be created with the usual tools:

For most BaseList2D based classes dedicated "Alloc" and "Free" functions exist.
// This example creates an object buffer multipass.
MultipassObject* const multipass = static_cast<MultipassObject*>(BaseList2D::Alloc(Zmultipass));
if (multipass == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
BaseContainer& data = multipass->GetDataInstanceRef();
Definition: c4d_basecontainer.h:47
void SetInt32(Int32 id, Int32 l)
Definition: c4d_basecontainer.h:505
const BaseContainer & GetDataInstanceRef() const
Definition: c4d_baselist.h:2344
static BaseList2D * Alloc(Int32 type)
Definition: c4d_basedocument.h:113
Definition: memoryallocationbase.h:67
Object buffer multipass channel.
Definition: c4d_videopostdata.h:140
#define Zmultipass
Definition: ge_prepass.h:1267
Definition: zmultipass.h:6
Definition: zmultipass.h:8

Read-Only Properties

The following properties can be accessed:

// This example prints the name and type name of the active object.
BaseObject* const object = doc->GetActiveObject();
if (object == nullptr)
return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION);
ApplicationOutput("The object: \"" + object->GetName() + "\" is a \"" + object->GetTypeName() + "\"");
Definition: c4d_baseobject.h:225
#define ApplicationOutput(formatString,...)
Definition: debugdiagnostics.h:210
const char * doc
Definition: pyerrors.h:226
Definition: object.h:105



BaseList2D based objects store an internal BaseContainer. This BaseContainer can store various information, like for example (but not restricted to) the values of parameters of an object or tag.

See BaseContainer Manual.

// This example implements NodeData::Init() in a plugin class.
// It sets the default values of the plugin's parameters.
virtual Bool Init(GeListNode* node)
if (node == nullptr || !SUPER::Init(node))
return false;
// get the "real" object
BaseObject* const obj = static_cast<BaseObject*>(node);
// get data container
BaseContainer& data = obj->GetDataInstanceRef();
// set default parameter values
void SetBool(Int32 id, Bool b)
Definition: c4d_basecontainer.h:498
Represents a C4DAtom that resides in a 4D list.
Definition: c4d_baselist.h:1813
PyObject * obj
Definition: complexobject.h:60
maxon::Bool Bool
Definition: ge_sys_math.h:55
struct _node node
Definition: node.h:10
Typically one should use C4DAtom::SetParameter() and C4DAtom::GetParameter() to access parameters, instead of accessing the BaseContainer directly. See C4DAtom Parameters.


Various properties are not stored in parameters but are set using bits. See BIT.

// This example disables the first video post.
RenderData* const rd = doc->GetActiveRenderData();
if (rd == nullptr)
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
BaseVideoPost* const vp = rd->GetFirstVideoPost();
if (vp != nullptr)
void SetBit(Int32 mask)
Definition: c4d_baselist.h:2245
Definition: c4d_videopost.h:24
Definition: c4d_basedocument.h:144
BaseVideoPost * GetFirstVideoPost()
Videopost is disabled.
Definition: ge_prepass.h:912

See also GeListNode NBits.


A BaseList2D based element can have a name. Often this name is used in Cinema 4D's UI, like names of objects in the Object Manager:

// This example changes the name of the selected object.
BaseObject* const object = doc->GetActiveObject();
if (object == nullptr)
return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION);
object->SetName("This is the selected object"_s);
While BaseDocument is as well derived from BaseList2D, the "name" of a document is a Filename set with BaseDocument::SetDocumentName(). See BaseDocument Document Name and Path.


BaseList2D contain function to deal with NimbusRef.

The returned result should be assign to a NimbusBaseRef.


By default a BaseList2D based element can host a list of shaders. If a new shader is created and used by the element, it must be inserted into the element's shader list.

// This example creates a shader and adds it to the given material.
if (shader == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
material->SetParameter(DescID { MATERIAL_COLOR_SHADER }, shader, DESCFLAGS_SET::NONE);
Definition: c4d_basechannel.h:36
static BaseShader * Alloc(Int32 type)
Definition: lib_description.h:330
#define Xbrick
Definition: ge_prepass.h:1297
Definition: mmaterial.h:272

See also GeListNode Lists and Trees.


A BaseList2D based element owns a GeMarker object.

See GeMarker Manual for more information.

// This example gets the name and the marker of the given BaseObject.
// The name is used to search for an object with the same name in the document.
// The marker is used to check if the found object is also the original object.
const String objectName = object->GetName();
const GeMarker& marker = object->GetMarker();
// search object with the same name
const BaseObject* const foundObject = doc->SearchObject(objectName);
if (foundObject != nullptr)
// check if it is the same object
const GeMarker& foundObjectMarker = foundObject->GetMarker();
// compare if the markers are equal
if (foundObjectMarker.Compare(marker) == 0)
ApplicationOutput("The found object is the original object"_s);
ApplicationOutput("The found object is not the original object"_s);
const GeMarker & GetMarker() const
Definition: c4d_baselist.h:2410
A unique marker that identifies an object.
Definition: c4d_baselist.h:1302
Int32 Compare(const GeMarker &m) const
Definition: c4d_baselist.h:1339
Definition: c4d_string.h:39

Unique ID

BaseList2D based elements can store an array of unique IDs. These IDs are typically used to identify scenes and elements written by external applications using the Melange library.

// This example adds a new ID to the given object.
// After that all stored IDs are checked.
// adding a new ID
const Int32 ID = 1111111;
Int32 value = 123456;
object->AddUniqueID(ID, (Char*)&value, sizeof(Int32));
Int32 appID = 0;
const Char* memory = nullptr;
Int bytes = 0;
// looping through all IDs
for (Int32 i = 0; i < object->GetUniqueIDCount(); ++i)
// get the unique ID data stored at the given index
if (object->GetUniqueIDIndex(i, appID, memory, bytes))
// check if the memory block has the size of an Int32 number
if (bytes == sizeof(Int32))
const Int32 data = *(Int32*)memory;
Py_ssize_t i
Definition: abstract.h:645
PyObject * value
Definition: abstract.h:715
static String IntToString(Int32 v)
Definition: c4d_string.h:495
void const void * bytes
Definition: bytesobject.h:117
maxon::Char Char
Definition: ge_sys_math.h:56
maxon::Int32 Int32
Definition: ge_sys_math.h:60
maxon::Int Int
Definition: ge_sys_math.h:64

Animation Tracks

BaseList2D based elements store a list of CTrack objects (see also Heads and Branches). A CTrack stores the animation data for a given parameter.

// This example checks if an animation track for the given parameter exists.
// If no track exists it is created.
const DescID paramID = DescLevel { PRIM_SPHERE_RAD, DTYPE_REAL, 0 };
// check if track exists
CTrack* track = sphere->FindCTrack(paramID);
if (track != nullptr)
return maxon::OK;
// create track
track = CTrack::Alloc(sphere, paramID);
if (track == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
// insert track
CTrack * FindCTrack(const DescID &id)
Definition: c4d_canimation.h:671
static CTrack * Alloc(BaseList2D *bl, const DescID &id)
return OK
Definition: apibase.h:2667
Definition: lib_description.h:68
Definition: osphere.h:6
Represents a level within a DescID.
Definition: lib_description.h:289

See Animation Overview.

Keyframe Selection

Parameters can be part of a so called keyframe selection:

// This example checks if there is a keyframe selection on the given object.
// If yes, all available description IDs are checked if they are part of that selection.
if (description == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
// check if any parameters on the object are part of the keyframe selection
if (object->KeyframeSelectionContent())
// read description from the object
if (!object->GetDescription(description, DESCFLAGS_DESC::NONE))
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
void* handle = description->BrowseInit();
const BaseContainer* bc = nullptr;
DescID id, gid;
// loop through the description
while (description->GetNext(handle, &bc, id, gid))
// check if the parameter ID is part of the keyframe selection
if (object->FindKeyframeSelection(id) && bc)
ApplicationOutput("Parameter \"" + bc->GetString(DESC_NAME) + "\" is part of the keyframe selection");
Definition: ge_autoptr.h:37
String GetString(Int32 id, const maxon::String &preset=maxon::String()) const
Definition: c4d_basecontainer.h:387
String Name for standalone use.
Definition: lib_description.h:91

See also C4DAtom Parameter Properties and Animate.


A BaseList2D based element can be part of a layer:

// This example gets the LayerObject from the given object
// and checks if it should be visible or not.
// get layer object
LayerObject* const layer = object->GetLayerObject(doc);
if (layer != nullptr)
// get layer data
const LayerData* const ld = object->GetLayerData(doc);
if (ld != nullptr)
// check if elements should be visible in the Editor
if (ld->view)
LayerObject * GetLayerObject(BaseDocument *doc)
Definition: c4d_basedocument.h:253
Definition: c4d_basedocument.h:319
Bool view
Visible in editor view.
Definition: c4d_basedocument.h:353

See also Layer Manual.

DescID State

For each parameter ID a certain state can be defined. This is typically managed by the Xref or Take system.

The flags are:

// This example toggles the "locked" state of the sphere's "Radius" parameter.
const DESCIDSTATE state = sphere->GetDescIDState(PRIM_SPHERE_RAD, true);
sphere->SetDescIDState(PRIM_SPHERE_RAD, ~DESCIDSTATE::LOCKED & state);
Definition: ge_prepass.h:5506
Description element is locked.
Definition: grammar.h:37


BaseList2D based elements can be edited with these functions:

// This example creates a clone of the given object.
// This clone is scaled and all links pointing to the
// original object are redirected to the clone.
C4DAtom* const atomClone = object->GetClone(COPYFLAGS::NONE, nullptr);
BaseObject* const clone = static_cast<BaseObject*>(atomClone);
if (clone == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
doc->InsertObject(clone, nullptr, nullptr);
// scale the clone's float parameters
// all links should now refer to the clone
object->TransferGoal(clone, false);
// edit the clone
Bool Scale(Float scale)
Definition: c4d_baselist.h:2528
Bool Edit()
Definition: c4d_baselist.h:1377
C4DAtom * GetClone(COPYFLAGS flags, AliasTrans *trn)
Definition: c4d_baselist.h:1462

Further Reading