CCurve Manual


A CCurve represents an animation curve that stores and interpolates animation keys. A CCurve is stored in a CTrack object.

CCurve objects are an instance of CSbase.

// This code loops through all tracks and all keys of the given object.
CTrack* track = activeObject->GetFirstCTrack();
while (track != nullptr)
CCurve* const curve = track->GetCurve();
if (curve == nullptr)
const Int32 keyCount = curve->GetKeyCount();
for (Int32 i = 0; i < keyCount; ++i)
CKey* const key = curve->GetKey(i);
if (key)
// do something with the key
ApplicationOutput("Found a key!");
track = track->GetNext();
Py_ssize_t i
Definition: abstract.h:645
PyObject * key
Definition: abstract.h:289
CTrack * GetFirstCTrack()
Definition: c4d_canimation.h:366
const CKey * GetKey(Int32 index) const
Definition: c4d_canimation.h:388
Int32 GetKeyCount(void) const
Definition: c4d_canimation.h:381
Represents a key in the CCurve of a track which represent the animation of a parameter.
Definition: c4d_canimation.h:58
Definition: c4d_canimation.h:671
CTrack * GetNext() const
Definition: c4d_canimation.h:716
CCurve * GetCurve(CCURVE type=CCURVE::CURVE, Bool bCreate=true)
Definition: c4d_canimation.h:835
maxon::Int32 Int32
Definition: ge_sys_math.h:60
#define ApplicationOutput(formatString,...)
Definition: debugdiagnostics.h:210


CCurve objects cannot be created on their own. They are created with a CTrack that contains the CCurve object.


Access Keys

The CCurve objects stores the animation keys and provides access to these:

// This example searches for a key left from the given time.
const BaseTime time = doc->GetTime();
CKey* const leftKey = curve->FindKey(time, nullptr, FINDANIM::LEFT);
if (leftKey)
// move this key to the current time
leftKey->SetTime(curve, time);
Definition: c4d_basetime.h:25
const CKey * FindKey(const BaseTime &time, Int32 *idx=nullptr, FINDANIM match=FINDANIM::EXACT) const
Definition: c4d_canimation.h:404
void SetTime(CCurve *seq, const BaseTime &t)
Definition: c4d_canimation.h:96
Search left.
const char * doc
Definition: pyerrors.h:226

Add Keys

A CCurve object can create and receive keys:

// This example creates keys along the timeline.
const Int32 fps = doc->GetFps();
const Int32 min = doc->GetMinTime().GetFrame(fps);
const Int32 max = doc->GetMaxTime().GetFrame(fps);
const Int32 range = max - min;
const Int32 step = range / 10;
const BaseTime stepTime = BaseTime(step, fps);
BaseTime keyTime = doc->GetMinTime();
for (Int32 i = 0; i <= 10; ++i)
if (curve->AddKey(keyTime, nullptr) == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
keyTime = keyTime + stepTime;
CKey * AddKey(const BaseTime &time, Int32 *nidx=nullptr, Bool bUndo=false, Bool SynchronizeKeys=false)
Definition: c4d_canimation.h:423
Definition: memoryallocationbase.h:67
const char Py_ssize_t const char Py_ssize_t Py_ssize_t max
Definition: modsupport.h:59
const char Py_ssize_t const char Py_ssize_t min
Definition: modsupport.h:58
PyObject PyObject * step
Definition: sliceobject.h:34

See also CKey Allocation/Deallocation.

Handle Keys

A CCurve object can be used to manipulate its keys:

// This example creates a new key and sets the default values.
CKey* const newKey = curve->AddKey(time, &index);
if (newKey == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
track->FillKey(doc, obj, newKey);
void SetKeyDefault(BaseDocument *doc, Int32 kidx)
Bool FillKey(BaseDocument *doc, BaseList2D *bl, CKey *key)
Definition: c4d_canimation.h:821
PyObject * obj
Definition: complexobject.h:60
Py_ssize_t * index
Definition: abstract.h:374

Unmuted Keys

A key can be muted so it is ignored.

// This example searches for the first unmuted key.
const CKey* const key = curve->FindNextUnmuted(0);
if (key)
const Float time = key->GetTime().Get();
ApplicationOutput("Found unmuted key at " + String::FloatToString(time));
const CKey * FindNextUnmuted(Int32 idx, Int32 *ret_idx=nullptr) const
Definition: c4d_canimation.h:599
static String FloatToString(Float32 v, Int32 vvk=-1, Int32 nnk=-3)
Definition: c4d_string.h:529
maxon::Float Float
Definition: ge_sys_math.h:66

See also CKey Bits.


The interpolation between the keys defines the dynamics of an animation. This interpolation is refined with the tangents.

  • CCurve::CalcHermite(): Calculates the Hermite spline between two sets of key values.
  • CCurve::CalcSoftTangents(): Calculates the soft tangents (i.e. auto interpolation) around the key of the given index.
  • CCurve::GetTangents(): Computes the tangents of a key, taking into account all options like zero slope, link slope etc.
  • CCurve::GetValue(): Returns the value calculated at the given time, taking into account things like time curves.
// This example samples the curve.
BaseTime time(0.0);
const BaseTime step(0.1);
for (Int32 i = 0; i < 10; ++i)
const Float value = curve->GetValue(time);
time = time + step;
PyObject * value
Definition: abstract.h:715
Float GetValue(const BaseTime &time) const
Definition: c4d_canimation.h:538


A CCurve is confined by a first and a last key:

// This example sets the loop time dimensions based on the start
// and end time of the given curve.
const BaseTime start = curve->GetStartTime();
const BaseTime end = curve->GetEndTime();
BaseTime GetStartTime(void) const
Definition: c4d_canimation.h:580
BaseTime GetEndTime(void) const
Definition: c4d_canimation.h:586
PyObject PyObject Py_ssize_t start
Definition: complexobject.h:62
PyObject PyObject Py_ssize_t Py_ssize_t end
Definition: complexobject.h:63

Further Reading