pointOnMeshInfoNode.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: pointOnMeshInfo v1.0
// FILE: pointOnMeshInfoNode.cpp
// DESCRIPTION: -Defines "pointOnMeshInfo" node.
//              -Please see readme.txt for full details.
// AUTHOR: QT
// REFERENCES: -This plugin is based off of the `pointOnSurface` MEL command and "pointOnSurfaceInfo" node.
//             -The pointOnSubdNode.cpp plugin example from the Maya API Devkit was also used for reference.
//             -The MEL script AEpointOnSurfaceInfoTemplate.mel was referred to for the AE template MEL script
//              that accompanies the pointOnMeshInfo node.
// LAST UPDATED: Oct. 11th, 2001.
// COMPILED AND TESTED ON: Maya 4.0 on Windows


// HEADER FILES:
#include "pointOnMeshInfoNode.h"
#include "getPointAndNormal.h"
#include <maya/MIOStream.h>


// DEFINE CLASS'S STATIC DATA MEMBERS:
MTypeId pointOnMeshInfoNode::id(0x00105480);
MObject pointOnMeshInfoNode::aInMesh;
MObject pointOnMeshInfoNode::aFaceIndex;
MObject pointOnMeshInfoNode::aRelative;
MObject pointOnMeshInfoNode::aParameterU;
MObject pointOnMeshInfoNode::aParameterV;
MObject pointOnMeshInfoNode::aPosition;
MObject pointOnMeshInfoNode::aPositionX;
MObject pointOnMeshInfoNode::aPositionY;
MObject pointOnMeshInfoNode::aPositionZ;
MObject pointOnMeshInfoNode::aNormal;
MObject pointOnMeshInfoNode::aNormalX;
MObject pointOnMeshInfoNode::aNormalY;
MObject pointOnMeshInfoNode::aNormalZ;


// CONSTRUCTOR DEFINITION:
pointOnMeshInfoNode::pointOnMeshInfoNode()
{
}


// DESTRUCTOR DEFINITION:
pointOnMeshInfoNode::~pointOnMeshInfoNode()
{
}


// FOR CREATING AN INSTANCE OF THIS NODE:
void *pointOnMeshInfoNode::creator()
{
   return new pointOnMeshInfoNode();
}


// INITIALIZES THE NODE BY CREATING ITS ATTRIBUTES:
MStatus pointOnMeshInfoNode::initialize()
{
   // CREATE AND ADD ".inMesh" ATTRIBUTE:
   MFnTypedAttribute inMeshAttrFn;
   aInMesh = inMeshAttrFn.create("inMesh", "im", MFnData::kMesh);
   CHECK_MSTATUS ( inMeshAttrFn.setStorable(true) );
   CHECK_MSTATUS ( inMeshAttrFn.setKeyable(false) );
   CHECK_MSTATUS ( inMeshAttrFn.setReadable(true) );
   CHECK_MSTATUS ( inMeshAttrFn.setWritable(true) );
   CHECK_MSTATUS ( inMeshAttrFn.setCached(false) );
   CHECK_MSTATUS ( addAttribute(aInMesh));

   // CREATE AND ADD ".faceIndex" ATTRIBUTE:
   MFnNumericAttribute faceIndexAttrFn;
   aFaceIndex = faceIndexAttrFn.create("faceIndex", "f", MFnNumericData::kLong, 0);
   CHECK_MSTATUS (faceIndexAttrFn.setStorable(true));
   CHECK_MSTATUS ( faceIndexAttrFn.setKeyable(true) );
   CHECK_MSTATUS ( faceIndexAttrFn.setReadable(true) );
   CHECK_MSTATUS ( faceIndexAttrFn.setWritable(true) );
   CHECK_MSTATUS ( faceIndexAttrFn.setMin(0) );
   CHECK_MSTATUS ( addAttribute(aFaceIndex) );

   // CREATE AND ADD ".relative" ATTRIBUTE:
   MFnNumericAttribute relativeAttrFn;
   aRelative = relativeAttrFn.create("relative", "r", MFnNumericData::kBoolean, 1);
   CHECK_MSTATUS ( relativeAttrFn.setStorable(true) );
   CHECK_MSTATUS ( relativeAttrFn.setKeyable(true));
   CHECK_MSTATUS ( relativeAttrFn.setReadable(true) );
   CHECK_MSTATUS ( relativeAttrFn.setWritable(true) );
   CHECK_MSTATUS ( addAttribute(aRelative) );

   // CREATE AND ADD ".parameterU" ATTRIBUTE:
   MFnNumericAttribute parameterUAttrFn;
   aParameterU = parameterUAttrFn.create("parameterU", "u", MFnNumericData::kDouble, 0.5);
   CHECK_MSTATUS ( parameterUAttrFn.setStorable(true) );
   CHECK_MSTATUS ( parameterUAttrFn.setKeyable(true) );
   CHECK_MSTATUS ( parameterUAttrFn.setReadable(true) ) ;
   CHECK_MSTATUS ( parameterUAttrFn.setWritable(true) ) ;
   CHECK_MSTATUS ( addAttribute(aParameterU) );

   // CREATE AND ADD ".parameterV" ATTRIBUTE:
   MFnNumericAttribute parameterVAttrFn;
   aParameterV = parameterVAttrFn.create("parameterV", "v", MFnNumericData::kDouble, 0.5);
   CHECK_MSTATUS ( parameterVAttrFn.setStorable(true) );
   CHECK_MSTATUS ( parameterVAttrFn.setKeyable(true) );
   CHECK_MSTATUS ( parameterVAttrFn.setReadable(true) );
   CHECK_MSTATUS ( parameterVAttrFn.setWritable(true) );
   CHECK_MSTATUS ( addAttribute(aParameterV) );

   // CREATE AND ADD ".positionX" ATTRIBUTE:
   MFnNumericAttribute pointXAttrFn;
   aPositionX = pointXAttrFn.create("positionX", "px", MFnNumericData::kDouble, 0.0);
   CHECK_MSTATUS ( pointXAttrFn.setStorable(false) );
   CHECK_MSTATUS ( pointXAttrFn.setKeyable(false) );
   CHECK_MSTATUS ( pointXAttrFn.setReadable(true) ) ;
   CHECK_MSTATUS ( pointXAttrFn.setWritable(false) );
   CHECK_MSTATUS ( addAttribute(aPositionX) );

   // CREATE AND ADD ".positionY" ATTRIBUTE:
   MFnNumericAttribute pointYAttrFn;
   aPositionY = pointYAttrFn.create("positionY", "py", MFnNumericData::kDouble, 0.0);
   CHECK_MSTATUS ( pointYAttrFn.setStorable(false) );
   CHECK_MSTATUS ( pointYAttrFn.setKeyable(false) );
   CHECK_MSTATUS ( pointYAttrFn.setReadable(true) );
   CHECK_MSTATUS ( pointYAttrFn.setWritable(false) );
   CHECK_MSTATUS ( addAttribute(aPositionY) );

   // CREATE AND ADD ".positionZ" ATTRIBUTE:
   MFnNumericAttribute pointZAttrFn;
   aPositionZ = pointZAttrFn.create("positionZ", "pz", MFnNumericData::kDouble, 0.0);
   CHECK_MSTATUS ( pointZAttrFn.setStorable(false) );
   CHECK_MSTATUS ( pointZAttrFn.setKeyable(false) );
   CHECK_MSTATUS ( pointZAttrFn.setReadable(true) );
   CHECK_MSTATUS ( pointZAttrFn.setWritable(false) );
   CHECK_MSTATUS ( addAttribute(aPositionZ) );

   // CREATE AND ADD ".position" ATTRIBUTE:
   MFnNumericAttribute pointAttrFn;
   aPosition = pointAttrFn.create("position", "p", aPositionX, aPositionY, aPositionZ);
   CHECK_MSTATUS ( pointAttrFn.setStorable(false) );
   CHECK_MSTATUS ( pointAttrFn.setKeyable(false) );
   CHECK_MSTATUS ( pointAttrFn.setReadable(true) );
   CHECK_MSTATUS ( pointAttrFn.setWritable(false) );
   CHECK_MSTATUS ( addAttribute(aPosition) );

   // CREATE AND ADD ".normalX" ATTRIBUTE:
   MFnNumericAttribute normalXAttrFn;
   aNormalX = normalXAttrFn.create("normalX", "nx", MFnNumericData::kDouble, 0.0);
   CHECK_MSTATUS ( normalXAttrFn.setStorable(false) );
   CHECK_MSTATUS ( normalXAttrFn.setKeyable(false) );
   CHECK_MSTATUS ( normalXAttrFn.setReadable(true) );
   CHECK_MSTATUS ( normalXAttrFn.setWritable(false) );
   CHECK_MSTATUS ( addAttribute(aNormalX) );

   // CREATE AND ADD ".normalY" ATTRIBUTE:
   MFnNumericAttribute normalYAttrFn;
   aNormalY = normalYAttrFn.create("normalY", "ny", MFnNumericData::kDouble, 0.0);
   CHECK_MSTATUS ( normalYAttrFn.setStorable(false) );
   CHECK_MSTATUS ( normalYAttrFn.setKeyable(false) );
   CHECK_MSTATUS ( normalYAttrFn.setReadable(true) );
   CHECK_MSTATUS ( normalYAttrFn.setWritable(false) );
   CHECK_MSTATUS (addAttribute(aNormalY));

   // CREATE AND ADD ".normalZ" ATTRIBUTE:
   MFnNumericAttribute normalZAttrFn;
   aNormalZ = normalZAttrFn.create("normalZ", "nz", MFnNumericData::kDouble, 0.0);
   CHECK_MSTATUS ( normalZAttrFn.setStorable(false));
   CHECK_MSTATUS ( normalZAttrFn.setKeyable(false));
   CHECK_MSTATUS ( normalZAttrFn.setReadable(true));
   CHECK_MSTATUS ( normalZAttrFn.setWritable(false));
   CHECK_MSTATUS ( addAttribute(aNormalZ));

   // CREATE AND ADD ".normal" ATTRIBUTE:
   MFnNumericAttribute normalAttrFn;
   aNormal = normalAttrFn.create("normal", "n", aNormalX, aNormalY, aNormalZ);
   CHECK_MSTATUS ( normalAttrFn.setStorable(false));
   CHECK_MSTATUS ( normalAttrFn.setKeyable(false));
   CHECK_MSTATUS ( normalAttrFn.setReadable(true));
   CHECK_MSTATUS ( normalAttrFn.setWritable(false));
   CHECK_MSTATUS ( addAttribute(aNormal) );

   // DEPENDENCY RELATIONS FOR ".inMesh":
   CHECK_MSTATUS ( attributeAffects(aInMesh, aPosition));
   CHECK_MSTATUS ( attributeAffects(aInMesh, aPositionX));
   CHECK_MSTATUS ( attributeAffects(aInMesh, aPositionY));
   CHECK_MSTATUS ( attributeAffects(aInMesh, aPositionZ));
   CHECK_MSTATUS ( attributeAffects(aInMesh, aNormal));
   CHECK_MSTATUS ( attributeAffects(aInMesh, aNormalX));
   CHECK_MSTATUS ( attributeAffects(aInMesh, aNormalY));
   CHECK_MSTATUS ( attributeAffects(aInMesh, aNormalZ));

   // DEPENDENCY RELATIONS FOR ".faceIndex":
   CHECK_MSTATUS ( attributeAffects(aFaceIndex, aPosition));
   CHECK_MSTATUS ( attributeAffects(aFaceIndex, aPositionX));
   CHECK_MSTATUS ( attributeAffects(aFaceIndex, aPositionY));
   CHECK_MSTATUS ( attributeAffects(aFaceIndex, aPositionZ));
   CHECK_MSTATUS ( attributeAffects(aFaceIndex, aNormal));
   CHECK_MSTATUS ( attributeAffects(aFaceIndex, aNormalX));
   CHECK_MSTATUS (attributeAffects(aFaceIndex, aNormalY));
   CHECK_MSTATUS ( attributeAffects(aFaceIndex, aNormalZ));

   // DEPENDENCY RELATIONS FOR ".relative":
   CHECK_MSTATUS ( attributeAffects(aRelative, aPosition));
   CHECK_MSTATUS ( attributeAffects(aRelative, aPositionX));
   CHECK_MSTATUS ( attributeAffects(aRelative, aPositionY));
   CHECK_MSTATUS (attributeAffects(aRelative, aPositionZ));
   CHECK_MSTATUS ( attributeAffects(aRelative, aNormal));
   CHECK_MSTATUS ( attributeAffects(aRelative, aNormalX));
   CHECK_MSTATUS ( attributeAffects(aRelative, aNormalY));
   CHECK_MSTATUS ( attributeAffects(aRelative, aNormalZ));

   // DEPENDENCY RELATIONS FOR ".parameterU":
   CHECK_MSTATUS (  attributeAffects(aParameterU, aPosition));
   CHECK_MSTATUS ( attributeAffects(aParameterU, aPositionX));
   CHECK_MSTATUS ( attributeAffects(aParameterU, aPositionY));
   CHECK_MSTATUS ( attributeAffects(aParameterU, aPositionZ));
   CHECK_MSTATUS ( attributeAffects(aParameterU, aNormal));
   CHECK_MSTATUS ( attributeAffects(aParameterU, aNormalX));
   CHECK_MSTATUS ( attributeAffects(aParameterU, aNormalY));
   CHECK_MSTATUS ( attributeAffects(aParameterU, aNormalZ));

   // DEPENDENCY RELATIONS FOR ".parameterV":
   CHECK_MSTATUS ( attributeAffects(aParameterV, aPosition));
   CHECK_MSTATUS ( attributeAffects(aParameterV, aPositionX));
   CHECK_MSTATUS ( attributeAffects(aParameterV, aPositionY));
   CHECK_MSTATUS ( attributeAffects(aParameterV, aPositionZ));
   CHECK_MSTATUS ( attributeAffects(aParameterV, aNormal));
   CHECK_MSTATUS ( attributeAffects(aParameterV, aNormalX));
   CHECK_MSTATUS ( attributeAffects(aParameterV, aNormalY));
   CHECK_MSTATUS ( attributeAffects(aParameterV, aNormalZ));

   return MS::kSuccess;
}


// COMPUTE METHOD'S DEFINITION:
MStatus pointOnMeshInfoNode::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))
   {
      // READ IN ".inMesh" DATA:
      MDataHandle inMeshDataHandle = data.inputValue(aInMesh);
      MObject inMesh = inMeshDataHandle.asMesh();

      // READ IN ".faceIndex" DATA:
      MDataHandle faceIndexDataHandle = data.inputValue(aFaceIndex);
      int faceIndex = faceIndexDataHandle.asLong();

      // READ IN ".relative" DATA:
      MDataHandle relativeDataHandle = data.inputValue(aRelative);
      bool relative = relativeDataHandle.asBool();

      // READ IN ".parameterU" DATA:
      MDataHandle parameterUDataHandle = data.inputValue(aParameterU);
      double parameterU = parameterUDataHandle.asDouble();

      // READ IN ".parameterV" DATA:
      MDataHandle parameterVDataHandle = data.inputValue(aParameterV);
      double parameterV = parameterVDataHandle.asDouble();

      // GET THE POINT AND NORMAL:
      MPoint point;
      MVector normal;
      MDagPath dummyDagPath;
      getPointAndNormal(dummyDagPath, faceIndex, relative, parameterU, parameterV, point, normal, inMesh);

      // WRITE OUT ".position" DATA:
      MDataHandle pointDataHandle = data.outputValue(aPosition);
      pointDataHandle.set(point.x, point.y, point.z);
      data.setClean(plug);

      // WRITE OUT ".normal" DATA:
      MDataHandle normalDataHandle = data.outputValue(aNormal);
      normalDataHandle.set(normal.x, normal.y, normal.z);
      data.setClean(plug);
   }
   else
      return MS::kUnknownParameter;

   return MS::kSuccess;
}