CAWeightTag Manual

About

The CAWeightTag class represents a weight tag. A weight tag stores weights that define the influence a joint object has on a deformed mesh. The class is defined in the lib_ca.h header file.

CAWeightTag objects are an instance of Tweights.

Access

A CAWeightTag tag can be accessed like any other tag, see BaseTag and VariableTag Manual.

// This example accesses the selected weight tag
// and prints the names of weighted joints.
// get weight tag
BaseTag* const tag = doc->GetActiveTag();
if (tag == nullptr || !tag->IsInstanceOf(Tweights))
return maxon::IllegalArgumentError(MAXON_SOURCE_LOCATION);
CAWeightTag* const weightTag = static_cast<CAWeightTag*>(tag);
// loop through all joints
const Int32 jointCount = weightTag->GetJointCount();
for (Int32 i = 0; i < jointCount; ++i)
{
const BaseObject* const joint = weightTag->GetJoint(i, doc);
if (joint == nullptr)
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
ApplicationOutput("Joint: " + joint->GetName());
}
Py_ssize_t i
Definition: abstract.h:645
String GetName() const
Definition: c4d_baselist.h:2543
Definition: c4d_baseobject.h:248
Definition: c4d_basetag.h:52
Bool IsInstanceOf(Int32 id) const
Definition: c4d_baselist.h:1561
Definition: lib_ca.h:179
Int32 GetJointCount() const
BaseObject * GetJoint(Int32 index, BaseDocument *doc)
maxon::Int32 Int32
Definition: ge_sys_math.h:56
#define MAXON_SOURCE_LOCATION
Definition: memoryallocationbase.h:67
#define ApplicationOutput(formatString,...)
Definition: debugdiagnostics.h:204
#define Tweights
Weights.
Definition: ge_prepass.h:1451
const char * doc
Definition: pyerrors.h:226

Allocation/Deallocation

CAWeightTag instances are created with the usual tools, see Entity Creation and Destruction Manual (Classic).

// This example creates a new CAWeightTag
// and adds it to the given polygon object.
CAWeightTag* const weightTag = CAWeightTag::Alloc();
if (weightTag == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
polygonObject->InsertTag(weightTag);
static CAWeightTag * Alloc()
Definition: lib_ca.h:192

Properties

Standard parameters on a CAWeightTag can be edited with C4DAtom::GetParameter() and C4DAtom::SetParameter(). The parameter IDs are defined in tcaweight.h.

Joints

A CAWeightTag manages a list of references to various joint objects.

// This example adds all selected joint objects to the given weight tag.
if (objects == nullptr)
return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
// get selected objects
doc->GetActiveObjects(objects, GETACTIVEOBJECTFLAGS::CHILDREN);
// loop through all objects
const Int32 objectCount = objects->GetCount();
for (Int32 i = 0; i < objectCount; ++i)
{
C4DAtom* const atom = objects->GetIndex(i);
BaseObject* const baseObject = static_cast<BaseObject*>(atom);
if (baseObject == nullptr)
return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
// only add joint objects
if (baseObject->IsInstanceOf(Ojoint))
{
weightTag->AddJoint(baseObject);
}
}
Definition: ge_autoptr.h:37
Definition: c4d_baselist.h:1520
Int32 AddJoint(BaseObject *op)
#define atom
Definition: graminit.h:72
@ CHILDREN
Child objects are added to the selection too, provided they are selected. Otherwise only the topmost ...
#define Ojoint
Joint.
Definition: ge_prepass.h:1097

For each joint the reset (or rest) state is stored:

The JointRestState structure has these members:

// This example loops through all joints known by the given weight tag
// and prints the rest state length to the console.
// loop through all joints
const Int32 jointCount = weightTag->GetJointCount();
for (Int32 i = 0; i < jointCount; ++i)
{
const JointRestState state = weightTag->GetJointRestState(i);
const Float length = state.m_Len;
}
JointRestState GetJointRestState(Int32 index) const
static String FloatToString(Float32 v, Int32 vvk=-1, Int32 nnk=-3)
Definition: c4d_string.h:531
maxon::Float Float
Definition: ge_sys_math.h:62
PyWideStringList Py_ssize_t length
Definition: initconfig.h:448
Definition: lib_ca.h:109
Definition: grammar.h:37

Weights

A CAWeightTag stores weights for each point and joint.

Note
The order of weight values does not correspond to the point order.
// This example loads the weights stored for the given joint
// and prints them to the console window.
// check if any weights are stored
const Int32 weightCount = weightTag->GetWeightCount(jointIndex);
if (weightCount == 0)
continue;
const Int32 pointCount = polyObject->GetPointCount();
// allocate memory
weights.Resize(pointCount) iferr_return;
// load weights
Float32* const handle = weights.GetFirst();
weightTag->GetWeightMap(jointIndex, handle, pointCount);
// print weights
for (Int32 weightIndex = 0; weightIndex < pointCount; ++weightIndex)
{
const Float32 weight = weights[weightIndex];
}
Int32 GetWeightCount(Int32 index) const
void GetWeightMap(Int32 index, Float32 *map, Int32 cnt, Bool includeEffectors=false) const
Definition: basearray.h:415
MAXON_ATTRIBUTE_FORCE_INLINE const T * GetFirst() const
Definition: basearray.h:1175
ResultMem Resize(Int newCnt, COLLECTION_RESIZE_FLAGS resizeFlags=COLLECTION_RESIZE_FLAGS::DEFAULT)
Definition: basearray.h:1218
maxon::Float32 Float32
Definition: ge_sys_math.h:64
#define iferr_return
Definition: resultbase.h:1524
// This example loops through all points to receive weights for each point.
// loop through all points
const Int32 pointCount = polyObject->GetPointCount();
for (Int32 pointIndex = 0; pointIndex < pointCount; ++pointIndex)
{
const Float weight = weightTag->GetWeight(jointIndex, pointIndex);
ApplicationOutput("Point " + String::IntToString(pointIndex) + " : " + String::FloatToString(weight));
}
Float GetWeight(Int32 index, Int32 pntindex) const
static String IntToString(Int32 v)
Definition: c4d_string.h:497

Matrix

Functions

CAWeightTag offers these functions:

// This example moves a joint and its rest state
// and updates the rest state data.
// update rest state
state.m_oMg.off = state.m_oMg.off + Vector(0, 100.0, 0);
state.m_oMi = ~state.m_oMg;
weightTag->SetJointRestState(1, state);
// update joint object position
BaseObject* const joint = weightTag->GetJoint(1, doc);
if (joint)
joint->SetMg(state.m_oMg);
// calculate states
void SetMg(const Matrix &m)
Definition: c4d_baseobject.h:516
void CalculateBoneStates(Int32 index)
void SetJointRestState(Int32 index, const JointRestState &state)
maxon::Vec3< maxon::Float64, 1 > Vector
Definition: ge_math.h:141
#define NOTOK
Definition: ge_sys_math.h:263

Further Reading