closestPointOnCurve/closestPointOnCurveNode.cpp

closestPointOnCurve/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::kSuccess;
}