About

A morph can use the mixing mode "Correctional PSD" (Pose Space Deformation). A CAReferencePSD object allows accessing the related data. The class is defined in the lib_ca.h header file.

Access

The CAReferencePSD object is obtained from the CAMorphNode object, see CAMorphNode Points.

    // This example accesses the PSD data of the given point morph.
 
    // expand data to access it
    const CAMORPH_MODE_FLAGS expandFlags = CAMORPH_MODE_FLAGS::ALL | CAMORPH_MODE_FLAGS::EXPAND;
    morph->SetMode(doc, poseMorphTag, expandFlags, CAMORPH_MODE::ABS);
 
    // check stored data
    if (mnode->GetInfo() & CAMORPH_DATA_FLAGS::POINTS)
    {
      // get PSD data
      CAReferencePSD* const psd = mnode->GetPSDReference();
 
      if (psd)
      {
        // loop through all controllers
        const Int32 controllerCount = psd->GetExternalControllerCount();
 
        for (Int32 controllerIndex = 0; controllerIndex < controllerCount; ++controllerIndex)
        {
          BaseObject* const controller = psd->GetExternalController(controllerIndex);
          if (controller == nullptr)
            return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
 
          ApplicationOutput("Controller: " + controller->GetName());
        }
      }
    }
    // collapse data
    const CAMORPH_MODE_FLAGS collapseFlags = CAMORPH_MODE_FLAGS::ALL | CAMORPH_MODE_FLAGS::COLLAPSE;
    morph->SetMode(doc, poseMorphTag, collapseFlags, CAMORPH_MODE::AUTO);

Interpolation

For auto-weighting an interpolation mode is used:

CAReferencePSD::GetInterpolationMode(): Returns the interpolation mode.
CAReferencePSD::SetInterpolationMode(): Sets the interpolation mode.

The modes are:

CAMORPH_PSDINTERPOLATION_MODE::AXIS : Per joint axis.
CAMORPH_PSDINTERPOLATION_MODE::JOINT : Per joint interpolation (joint axis average).
CAMORPH_PSDINTERPOLATION_MODE::GLOBAL : Use one global value (joint average).
CAMORPH_PSDINTERPOLATION_MODE::DEFAULT : Default mode (Joint).

        // This example switches the interpolation setting
        // of the given CAReferencePSD.
 
        const CAMORPH_PSDINTERPOLATION_MODE interpolation = psd->GetInterpolationMode();
 
        if (interpolation == CAMORPH_PSDINTERPOLATION_MODE::AXIS)
          psd->SetInterpolationMode(CAMORPH_PSDINTERPOLATION_MODE::JOINT);

Driver

The joints referenced in the used weight tag can be forced to work as drivers for the PSD.

CAReferencePSD::IsJointForcedAsDriver(): Checks if the joint with the given index is forced as a driver.
CAReferencePSD::ForceJointAsDriver(): Forces the joint with the given index as a driver.
CAReferencePSD::ClearAllForcedDrivers(): Clears all forced drivers.

        // This example loops through all joints weighted in the
        // referenced Weight tag. All joints are forced as drivers.
 
        GeData data;
        poseMorphTag->GetParameter(ConstDescID(DescLevel(ID_CA_POSE_WEIGHTTAG_UI_ONLY)), data, DESCFLAGS_GET::NONE);
 
        C4DAtom* const wTag = data.GetLinkAtom(doc, Tweights);
        if (wTag)
        {
          CAWeightTag* const weightTag = static_cast<CAWeightTag*>(wTag);
 
          const Int32 jointCount = weightTag->GetJointCount();
 
          for (Int32 jointIndex = 0; jointIndex < jointCount; ++jointIndex)
          {
            psd->ForceJointAsDriver(jointIndex, true);
          }
        }

Pose

The PSD is based on a skeleton reference pose.

CAReferencePSD::RestoreReferencePose(): Restores the reference pose.
CAReferencePSD::UpdateReferencePose(): Uses the current pose as the reference.

      // This example restores the reference pose of the CAReferencePSD.
 
      // get PSD data
      CAReferencePSD* const psd = mnode->GetPSDReference();
 
      if (psd)
      {
        psd->RestoreReferencePose();
      }

Controllers

Non-joint objects can also be used as controllers.

CAReferencePSD::GetExternalControllerCount(): Returns the number of external controllers.
CAReferencePSD::GetExternalController(): Returns the external controller for the given index.
CAReferencePSD::GetExternalControllerMatrix(): Returns the matrix stored for the controller of the given index.
CAReferencePSD::SetExternalControllerMatrix(): Sets the matrix stored for the controller of the given index.
CAReferencePSD::RemoveExternalController(): Removes the external controller at the given index.
CAReferencePSD::ClearAllExternalControllers(): Removes all external controllers.

      // This example sets all selected non joint objects
      // as a controller object of the given point morph.
 
      // get PSD data
      CAReferencePSD* const psd = mnode->GetPSDReference();
 
      if (psd)
      {
        AutoAlloc<AtomArray> objects;
        if (objects)
        {
          // get selected objects
          doc->GetActiveObjects(objects, GETACTIVEOBJECTFLAGS::NONE);
 
          // 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);
 
            // only add non-joint objects
            if (baseObject && !baseObject->IsInstanceOf(Ojoint))
            {
              // add object as controller
              const Matrix mg = baseObject->GetMg();
              psd->SetExternalControllerMatrix(baseObject, mg);
            }
          }
        }
      }

Table of Contents