- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Examples

# closestPointOnCurveNode.cpp

    //-
    // ==========================================================================
    // Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
    //
    // Use of this software is subject to the terms of the Autodesk
    // license agreement provided at the time of installation or download,
    // or which otherwise accompanies this software in either electronic
    // or hard copy form.
    // ==========================================================================
    //+

    // DISCLAIMER: THIS PLUGIN IS PROVIDED AS IS.  IT IS NOT SUPPORTED BY

    //            AUTODESK, SO PLEASE USE AND MODIFY AT YOUR OWN RISK.

    //

    // PLUGIN NAME: closestPointOnCurve v1.0

    // FILE: closestPointOnCurveNode.cpp

    // DESCRIPTION: -Defines "closestPointOnCurve" node.

    //              -Please see readme.txt for full details.

    // AUTHOR: QT

    // REFERENCES: -This plugin's concept is based off of the "closestPointOnSurface" node.

    //             -The MEL script AEclosestPointOnSurfaceTemplate.mel was referred to for

    //              the AE template MEL script that accompanies the closestPointOnCurve node.

    // LAST UPDATED: Oct. 13th, 2001.

    // COMPILED AND TESTED ON: Maya 4.0 on Windows

    // HEADER FILES:

    #include "closestPointOnCurveNode.h"

    #include "closestTangentUAndDistance.h"

    // DEFINE CLASS'S STATIC DATA MEMBERS:

    MTypeId closestPointOnCurveNode::id(0x00105482);

    MObject closestPointOnCurveNode::aInCurve;

    MObject closestPointOnCurveNode::aInPosition;

    MObject closestPointOnCurveNode::aInPositionX;

    MObject closestPointOnCurveNode::aInPositionY;

    MObject closestPointOnCurveNode::aInPositionZ;

    MObject closestPointOnCurveNode::aPosition;

    MObject closestPointOnCurveNode::aPositionX;

    MObject closestPointOnCurveNode::aPositionY;

    MObject closestPointOnCurveNode::aPositionZ;

    MObject closestPointOnCurveNode::aNormal;

    MObject closestPointOnCurveNode::aNormalX;

    MObject closestPointOnCurveNode::aNormalY;

    MObject closestPointOnCurveNode::aNormalZ;

    MObject closestPointOnCurveNode::aTangent;

    MObject closestPointOnCurveNode::aTangentX;

    MObject closestPointOnCurveNode::aTangentY;

    MObject closestPointOnCurveNode::aTangentZ;

    MObject closestPointOnCurveNode::aParamU;

    MObject closestPointOnCurveNode::aDistance;

    // CONSTRUCTOR DEFINITION:

    closestPointOnCurveNode::closestPointOnCurveNode()

    {

    }

    // DESTRUCTOR DEFINITION:

    closestPointOnCurveNode::~closestPointOnCurveNode()

    {

    }

    // FOR CREATING AN INSTANCE OF THIS NODE:

    void *closestPointOnCurveNode::creator()

    {

       return new closestPointOnCurveNode();

    }

    // INITIALIZES THE NODE BY CREATING ITS ATTRIBUTES:

    MStatus closestPointOnCurveNode::initialize()

    {

       // CREATE AND ADD ".inCurve" ATTRIBUTE:

       MFnTypedAttribute inCurveAttrFn;

       aInCurve = inCurveAttrFn.create("inCurve", "ic", MFnData::kNurbsCurve);

       inCurveAttrFn.setStorable(true);

       inCurveAttrFn.setKeyable(false);

       inCurveAttrFn.setReadable(true);

       inCurveAttrFn.setWritable(true);

       inCurveAttrFn.setCached(false);

       addAttribute(aInCurve);

       // CREATE AND ADD ".inPositionX" ATTRIBUTE:

       MFnNumericAttribute inPositionXAttrFn;

       aInPositionX = inPositionXAttrFn.create("inPositionX", "ipx", MFnNumericData::kDouble, 0.0);

       inPositionXAttrFn.setStorable(true);

       inPositionXAttrFn.setKeyable(true);

       inPositionXAttrFn.setReadable(true);

       inPositionXAttrFn.setWritable(true);

       addAttribute(aInPositionX);

       // CREATE AND ADD ".inPositionY" ATTRIBUTE:

       MFnNumericAttribute inPositionYAttrFn;

       aInPositionY = inPositionYAttrFn.create("inPositionY", "ipy", MFnNumericData::kDouble, 0.0);

       inPositionYAttrFn.setStorable(true);

       inPositionYAttrFn.setKeyable(true);

       inPositionYAttrFn.setReadable(true);

       inPositionYAttrFn.setWritable(true);

       addAttribute(aInPositionY);

       // CREATE AND ADD ".inPositionZ" ATTRIBUTE:

       MFnNumericAttribute inPositionZAttrFn;

       aInPositionZ = inPositionZAttrFn.create("inPositionZ", "ipz", MFnNumericData::kDouble, 0.0);

       inPositionZAttrFn.setStorable(true);

       inPositionZAttrFn.setKeyable(true);

       inPositionZAttrFn.setReadable(true);

       inPositionZAttrFn.setWritable(true);

       addAttribute(aInPositionZ);

       // CREATE AND ADD ".inPosition" ATTRIBUTE:

       MFnNumericAttribute inPositionAttrFn;

       aInPosition = inPositionAttrFn.create("inPosition", "ip", aInPositionX, aInPositionY, aInPositionZ);

       inPositionAttrFn.setStorable(true);

       inPositionAttrFn.setKeyable(true);

       inPositionAttrFn.setReadable(true);

       inPositionAttrFn.setWritable(true);

       addAttribute(aInPosition);

       // CREATE AND ADD ".positionX" ATTRIBUTE:

       MFnNumericAttribute pointXAttrFn;

       aPositionX = pointXAttrFn.create("positionX", "px", MFnNumericData::kDouble, 0.0);

       pointXAttrFn.setStorable(false);

       pointXAttrFn.setKeyable(false);

       pointXAttrFn.setReadable(true);

       pointXAttrFn.setWritable(false);

       addAttribute(aPositionX);

       // CREATE AND ADD ".positionY" ATTRIBUTE:

       MFnNumericAttribute pointYAttrFn;

       aPositionY = pointYAttrFn.create("positionY", "py", MFnNumericData::kDouble, 0.0);

       pointYAttrFn.setStorable(false);

       pointYAttrFn.setKeyable(false);

       pointYAttrFn.setReadable(true);

       pointYAttrFn.setWritable(false);

       addAttribute(aPositionY);

       // CREATE AND ADD ".positionZ" ATTRIBUTE:

       MFnNumericAttribute pointZAttrFn;

       aPositionZ = pointZAttrFn.create("positionZ", "pz", MFnNumericData::kDouble, 0.0);

       pointZAttrFn.setStorable(false);

       pointZAttrFn.setKeyable(false);

       pointZAttrFn.setReadable(true);

       pointZAttrFn.setWritable(false);

       addAttribute(aPositionZ);

       // CREATE AND ADD ".position" ATTRIBUTE:

       MFnNumericAttribute pointAttrFn;

       aPosition = pointAttrFn.create("position", "p", aPositionX, aPositionY, aPositionZ);

       pointAttrFn.setStorable(false);

       pointAttrFn.setKeyable(false);

       pointAttrFn.setReadable(true);

       pointAttrFn.setWritable(false);

       addAttribute(aPosition);

       // CREATE AND ADD ".normalX" ATTRIBUTE:

       MFnNumericAttribute normalXAttrFn;

       aNormalX = normalXAttrFn.create("normalX", "nx", MFnNumericData::kDouble, 0.0);

       normalXAttrFn.setStorable(false);

       normalXAttrFn.setKeyable(false);

       normalXAttrFn.setReadable(true);

       normalXAttrFn.setWritable(false);

       addAttribute(aNormalX);

       // CREATE AND ADD ".normalY" ATTRIBUTE:

       MFnNumericAttribute normalYAttrFn;

       aNormalY = normalYAttrFn.create("normalY", "ny", MFnNumericData::kDouble, 0.0);

       normalYAttrFn.setStorable(false);

       normalYAttrFn.setKeyable(false);

       normalYAttrFn.setReadable(true);

       normalYAttrFn.setWritable(false);

       addAttribute(aNormalY);

       // CREATE AND ADD ".normalZ" ATTRIBUTE:

       MFnNumericAttribute normalZAttrFn;

       aNormalZ = normalZAttrFn.create("normalZ", "nz", MFnNumericData::kDouble, 0.0);

       normalZAttrFn.setStorable(false);

       normalZAttrFn.setKeyable(false);

       normalZAttrFn.setReadable(true);

       normalZAttrFn.setWritable(false);

       addAttribute(aNormalZ);

       // CREATE AND ADD ".normal" ATTRIBUTE:

       MFnNumericAttribute normalAttrFn;

       aNormal = normalAttrFn.create("normal", "n", aNormalX, aNormalY, aNormalZ);

       normalAttrFn.setStorable(false);

       normalAttrFn.setKeyable(false);

       normalAttrFn.setReadable(true);

       normalAttrFn.setWritable(false);

       addAttribute(aNormal);

       // CREATE AND ADD ".tangentX" ATTRIBUTE:

       MFnNumericAttribute tangentXAttrFn;

       aTangentX = tangentXAttrFn.create("tangentX", "tx", MFnNumericData::kDouble, 0.0);

       tangentXAttrFn.setStorable(false);

       tangentXAttrFn.setKeyable(false);

       tangentXAttrFn.setReadable(true);

       tangentXAttrFn.setWritable(false);

       addAttribute(aTangentX);

       // CREATE AND ADD ".tangentY" ATTRIBUTE:

       MFnNumericAttribute tangentYAttrFn;

       aTangentY = tangentYAttrFn.create("tangentY", "ty", MFnNumericData::kDouble, 0.0);

       tangentYAttrFn.setStorable(false);

       tangentYAttrFn.setKeyable(false);

       tangentYAttrFn.setReadable(true);

       tangentYAttrFn.setWritable(false);

       addAttribute(aTangentY);

       // CREATE AND ADD ".tangentZ" ATTRIBUTE:

       MFnNumericAttribute tangentZAttrFn;

       aTangentZ = tangentZAttrFn.create("tangentZ", "tz", MFnNumericData::kDouble, 0.0);

       tangentZAttrFn.setStorable(false);

       tangentZAttrFn.setKeyable(false);

       tangentZAttrFn.setReadable(true);

       tangentZAttrFn.setWritable(false);

       addAttribute(aTangentZ);

       // CREATE AND ADD ".tangent" ATTRIBUTE:

       MFnNumericAttribute tangentAttrFn;

       aTangent = tangentAttrFn.create("tangent", "t", aTangentX, aTangentY, aTangentZ);

       tangentAttrFn.setStorable(false);

       tangentAttrFn.setKeyable(false);

       tangentAttrFn.setReadable(true);

       tangentAttrFn.setWritable(false);

       addAttribute(aTangent);

       // CREATE AND ADD ".parameU" ATTRIBUTE:

       MFnNumericAttribute paramUAttrFn;

       aParamU = paramUAttrFn.create("paramU", "u", MFnNumericData::kDouble, 0.0);

       paramUAttrFn.setStorable(false);

       paramUAttrFn.setKeyable(false);

       paramUAttrFn.setReadable(true);

       paramUAttrFn.setWritable(false);

       addAttribute(aParamU);

       // CREATE AND ADD ".distance" ATTRIBUTE:

       MFnNumericAttribute distanceAttrFn;

       aDistance = distanceAttrFn.create("distance", "d", MFnNumericData::kDouble, 0.0);

       distanceAttrFn.setStorable(false);

       distanceAttrFn.setKeyable(false);

       distanceAttrFn.setReadable(true);

       distanceAttrFn.setWritable(false);

       addAttribute(aDistance);

       // DEPENDENCY RELATIONS FOR ".inCurve":

       attributeAffects(aInCurve, aPosition);

       attributeAffects(aInCurve, aPositionX);

       attributeAffects(aInCurve, aPositionY);

       attributeAffects(aInCurve, aPositionZ);

       attributeAffects(aInCurve, aNormal);

       attributeAffects(aInCurve, aNormalX);

       attributeAffects(aInCurve, aNormalY);

       attributeAffects(aInCurve, aNormalZ);

       attributeAffects(aInCurve, aTangent);

       attributeAffects(aInCurve, aTangentX);

       attributeAffects(aInCurve, aTangentY);

       attributeAffects(aInCurve, aTangentZ);

       attributeAffects(aInCurve, aParamU);

       attributeAffects(aInCurve, aDistance);

       // DEPENDENCY RELATIONS FOR ".inPosition":

       attributeAffects(aInPosition, aPosition);

       attributeAffects(aInPosition, aPositionX);

       attributeAffects(aInPosition, aPositionY);

       attributeAffects(aInPosition, aPositionZ);

       attributeAffects(aInPosition, aNormal);

       attributeAffects(aInPosition, aNormalX);

       attributeAffects(aInPosition, aNormalY);

       attributeAffects(aInPosition, aNormalZ);

       attributeAffects(aInPosition, aTangent);

       attributeAffects(aInPosition, aTangentX);

       attributeAffects(aInPosition, aTangentY);

       attributeAffects(aInPosition, aTangentZ);

       attributeAffects(aInPosition, aParamU);

       attributeAffects(aInPosition, aDistance);

       // DEPENDENCY RELATIONS FOR ".inPositionX":

       attributeAffects(aInPositionX, aPosition);

       attributeAffects(aInPositionX, aPositionX);

       attributeAffects(aInPositionX, aPositionY);

       attributeAffects(aInPositionX, aPositionZ);

       attributeAffects(aInPositionX, aNormal);

       attributeAffects(aInPositionX, aNormalX);

       attributeAffects(aInPositionX, aNormalY);

       attributeAffects(aInPositionX, aNormalZ);

       attributeAffects(aInPositionX, aTangent);

       attributeAffects(aInPositionX, aTangentX);

       attributeAffects(aInPositionX, aTangentY);

       attributeAffects(aInPositionX, aTangentZ);

       attributeAffects(aInPositionX, aParamU);

       attributeAffects(aInPositionX, aDistance);

       // DEPENDENCY RELATIONS FOR ".inPositionY":

       attributeAffects(aInPositionY, aPosition);

       attributeAffects(aInPositionY, aPositionX);

       attributeAffects(aInPositionY, aPositionY);

       attributeAffects(aInPositionY, aPositionZ);

       attributeAffects(aInPositionY, aNormal);

       attributeAffects(aInPositionY, aNormalX);

       attributeAffects(aInPositionY, aNormalY);

       attributeAffects(aInPositionY, aNormalZ);

       attributeAffects(aInPositionY, aTangent);

       attributeAffects(aInPositionY, aTangentX);

       attributeAffects(aInPositionY, aTangentY);

       attributeAffects(aInPositionY, aTangentZ);

       attributeAffects(aInPositionY, aParamU);

       attributeAffects(aInPositionY, aDistance);

       // DEPENDENCY RELATIONS FOR ".inPositionZ":

       attributeAffects(aInPositionZ, aPosition);

       attributeAffects(aInPositionZ, aPositionX);

       attributeAffects(aInPositionZ, aPositionY);

       attributeAffects(aInPositionZ, aPositionZ);

       attributeAffects(aInPositionZ, aNormal);

       attributeAffects(aInPositionZ, aNormalX);

       attributeAffects(aInPositionZ, aNormalY);

       attributeAffects(aInPositionZ, aNormalZ);

       attributeAffects(aInPositionZ, aTangent);

       attributeAffects(aInPositionZ, aTangentX);

       attributeAffects(aInPositionZ, aTangentY);

       attributeAffects(aInPositionZ, aTangentZ);

       attributeAffects(aInPositionZ, aParamU);

       attributeAffects(aInPositionZ, aDistance);

       return MS::kSuccess;

    }

    // COMPUTE METHOD'S DEFINITION:

    MStatus closestPointOnCurveNode::compute(const MPlug &plug, MDataBlock &data)

    {

       // DO THE COMPUTE ONLY FOR THE *OUTPUT* PLUGS THAT ARE DIRTIED:

       if ((plug == aPosition)  || (plug == aPositionX)  || (plug == aPositionY)  || (plug == aPositionZ)

        || (plug == aNormal) || (plug == aNormalX) || (plug == aNormalY) || (plug == aNormalZ)

        || (plug == aTangent) || (plug == aTangentX) || (plug == aTangentY) || (plug == aTangentZ)

        || (plug == aParamU) || (plug == aDistance))

       {

          // READ IN ".inCurve" DATA:

          MDataHandle inCurveDataHandle = data.inputValue(aInCurve);

          MObject inCurve = inCurveDataHandle.asNurbsCurve();

          // READ IN ".inPositionX" DATA:

          MDataHandle inPositionXDataHandle = data.inputValue(aInPositionX);

          double inPositionX = inPositionXDataHandle.asDouble();

          // READ IN ".inPositionY" DATA:

          MDataHandle inPositionYDataHandle = data.inputValue(aInPositionY);

          double inPositionY = inPositionYDataHandle.asDouble();

          // READ IN ".inPositionZ" DATA:

          MDataHandle inPositionZDataHandle = data.inputValue(aInPositionZ);

          double inPositionZ = inPositionZDataHandle.asDouble();

          // GET THE CLOSEST POSITION, NORMAL, TANGENT, PARAMETER-U AND DISTANCE:

          MPoint inPosition(inPositionX, inPositionY, inPositionZ), position;

          MVector normal, tangent;

          double paramU, distance;

          MDagPath dummyDagPath;

          closestTangentUAndDistance(dummyDagPath, inPosition, position, normal, tangent, paramU, distance, inCurve);

          // WRITE OUT ".position" DATA:

          MDataHandle positionDataHandle = data.outputValue(aPosition);

          positionDataHandle.set(position.x, position.y, position.z);

          data.setClean(plug);

          // WRITE OUT ".normal" DATA:

          MDataHandle normalDataHandle = data.outputValue(aNormal);

          normalDataHandle.set(normal.x, normal.y, normal.z);

          data.setClean(plug);

          // WRITE OUT ".tangent" DATA:

          MDataHandle tangentDataHandle = data.outputValue(aTangent);

          tangentDataHandle.set(tangent.x, tangent.y, tangent.z);

          data.setClean(plug);

          // WRITE OUT ".paramU" DATA:

          MDataHandle paramUDataHandle = data.outputValue(aParamU);

          paramUDataHandle.set(paramU);

          data.setClean(plug);

          // WRITE OUT ".distance" DATA:

          MDataHandle distanceDataHandle = data.outputValue(aDistance);

          distanceDataHandle.set(distance);

          data.setClean(plug);

       }

       else

       {

          return MS::kUnknownParameter;

       }

       return MS::kSuccess;

    }