MStatus sgMeshIntersect::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
if( m_isDirtyMeshMatrix )
{
MDataHandle hInputMeshMatrix = data.inputValue( aInputMeshMatrix );
m_mtxMesh = hInputMeshMatrix.asMatrix();
m_mtxInvMesh = m_mtxMesh.inverse();
}
if( m_isDirtyMesh )
{
MDataHandle hInputMesh = data.inputValue( aInputMesh );
m_fnMesh.setObject( hInputMesh.asMesh() );
}
if( m_isDirtyPointDest )
{
MDataHandle hPointDest = data.inputValue( aPointDest );
m_pointDest = MPoint( hPointDest.asVector() ) * m_mtxInvMesh;
}
if( m_isDirtyPointSrc )
{
MDataHandle hPointSource = data.inputValue( aPointSource );
m_pointSource = MPoint( hPointSource.asVector() ) * m_mtxInvMesh;
}
m_rayDirection = m_pointDest - m_pointSource;
m_fnMesh.intersect( m_pointSource, m_rayDirection, m_pointsIntersect, &status );
if( !status ) return MS::kSuccess;
MDataHandle hParentInverse = data.inputValue( aParentInverseMatrix );
m_mtxParentInverse = hParentInverse.asMatrix();
MDataHandle hOutPoint = data.outputValue( aOutPoint );
hOutPoint.setMVector( m_pointsIntersect[0]*m_mtxMesh*m_mtxParentInverse );
return MS::kSuccess;
}
MStatus retargetLocator::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
MDataHandle hDiscMatrix = data.inputValue( aDiscMatrix );
MDataHandle hDiscAxis = data.inputValue( aDiscAxis );
MDataHandle hDiscAngle = data.inputValue( aDiscAngle );
MDataHandle hDiscDivision = data.inputValue( aDiscDivision );
MDataHandle hDiscOffset = data.inputValue( aDiscOffset );
MDataHandle hDiscSize = data.inputValue( aDiscSize );
MDataHandle hDiscActiveColor = data.inputValue( aDiscActiveColor );
MDataHandle hDiscLeadColor = data.inputValue( aDiscLeadColor );
MDataHandle hDiscDefaultColor = data.inputValue( aDiscDefaultColor );
MDataHandle hDiscFillAlpha = data.inputValue( aDiscFillAlpha );
MDataHandle hDiscLineAlpha = data.inputValue( aDiscLineAlpha );
discAxis = hDiscAxis.asInt();
discDivision = hDiscDivision.asInt();
discAngle = hDiscAngle.asDouble();
discSize = hDiscSize.asVector();
discOffset = hDiscOffset.asVector();
discActiveColor = hDiscActiveColor.asFloat3();
discLeadColor = hDiscLeadColor.asFloat3();
discDefaultColor = hDiscDefaultColor.asFloat3();
discFillAlpha = hDiscFillAlpha.asFloat();
discLineAlpha = hDiscLineAlpha.asFloat();
MArrayDataHandle hArrArrow = data.inputArrayValue( aArrow );
arrowNum = hArrArrow.elementCount();
inheritMatrix.setLength( arrowNum );
aimMatrix.setLength( arrowNum );
inputMeshObj.setLength( arrowNum );
startSize.setLength( arrowNum );
size.setLength( arrowNum );
activeColor.setLength( arrowNum );
leadColor.setLength( arrowNum );
defaultColor.setLength( arrowNum );
fillAlpha.setLength( arrowNum );
lineAlpha.setLength( arrowNum );
offset.setLength( arrowNum );
for( int i =0; i < arrowNum; i++ )
{
MDataHandle hArrow = hArrArrow.inputValue();
MDataHandle hInheritMatrix = hArrow.child( aInheritMatrix );
MDataHandle hAimMatrix = hArrow.child( aAimMatrix );
MDataHandle hInputMesh = hArrow.child( aInputMesh );
MDataHandle hStartSize = hArrow.child( aStartSize );
MDataHandle hSize = hArrow.child( aSize );
MDataHandle hActiveColor = hArrow.child( aActiveColor );
MDataHandle hLeadColor = hArrow.child( aLeadColor );
MDataHandle hDefaultColor = hArrow.child( aDefaultColor );
MDataHandle hFillAlpha = hArrow.child( aFillAlpha );
MDataHandle hLineAlpha = hArrow.child( aLineAlpha );
MDataHandle hOffset = hArrow.child( aOffset );
inheritMatrix[i] = hInheritMatrix.asBool();
aimMatrix[i] = hAimMatrix.asMatrix()*hDiscMatrix.asMatrix().inverse();
inputMeshObj[i] = hInputMesh.asMesh();
startSize[i] = hStartSize.asFloat();
size[i] = hSize.asFloat();
activeColor[i] = hActiveColor.asFloat3();
leadColor[i] = hLeadColor.asFloat3();
defaultColor[i] = hDefaultColor.asFloat3();
fillAlpha[i] = hFillAlpha.asFloat();
lineAlpha[i] = hLineAlpha.asFloat();
offset[i] = hOffset.asVector();
hArrArrow.next();
}
MDataHandle hOutput = data.outputValue( aOutput );
hOutput.set( 1.0 );
data.setClean( plug );
return MS::kSuccess;
}
MStatus dgTransform::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
MDataHandle hTranslate = data.inputValue( aTranslate, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hRotate = data.inputValue( aRotate, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hScale = data.inputValue( aScale, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hShear = data.inputValue( aShear, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hJointOrient = data.inputValue( aJointOrient, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hInputTranslate = data.inputValue( aInputTranslate, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hInputRotate = data.inputValue( aInputRotate, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hInputScale = data.inputValue( aInputScale, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MDataHandle hInputShear = data.inputValue( aInputShear, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MPxTransformationMatrix inputMpxTrMtx;
MEulerRotation inputEulerRot( hInputRotate.asVector() );
inputMpxTrMtx.translateTo( hInputTranslate.asVector() );
inputMpxTrMtx.rotateTo( inputEulerRot );
inputMpxTrMtx.scaleTo( hInputScale.asVector() );
inputMpxTrMtx.shearTo( hInputShear.asVector() );
MMatrix parentMatrix = inputMpxTrMtx.asMatrix();
MPxTransformationMatrix mpxTrMtx;
MEulerRotation eulerRot( hRotate.asVector() );
MEulerRotation joEulerRot( hJointOrient.asVector() );
mpxTrMtx.translateTo( hTranslate.asVector() );
mpxTrMtx.rotateTo( eulerRot );
mpxTrMtx.rotateBy( joEulerRot );
mpxTrMtx.scaleTo( hScale.asVector() );
mpxTrMtx.shearTo( hShear.asVector() );
if( plug == aMatrix )
{
//cout <<"matrix"<<endl;
MDataHandle hMatrix = data.outputValue( aMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
hMatrix.setMMatrix( mpxTrMtx.asMatrix() );
}
if( plug == aInverseMatrix )
{
//cout <<"inverseMatrix"<<endl;
MDataHandle hInverseMatrix = data.outputValue( aInverseMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
hInverseMatrix.setMMatrix( mpxTrMtx.asMatrix().inverse() );
}
if( plug == aWorldMatrix || plug == aWorldInverseMatrix )
{
MMatrix worldMatrix = mpxTrMtx.asMatrix()*parentMatrix;
if( plug == aWorldMatrix )
{
//cout <<"worldMatrix"<<endl;
MDataHandle hWorldMatrix = data.outputValue( aWorldMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
hWorldMatrix.setMMatrix( worldMatrix );
}
if( plug == aWorldInverseMatrix )
{
//cout <<"worldInverseMatrix"<<endl;
MDataHandle hWorldInverseMatrix = data.outputValue( aWorldInverseMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
hWorldInverseMatrix.setMMatrix( worldMatrix.inverse() );
}
}
if( plug == aParentMatrix )
{
//cout <<"parentMatrix"<<endl;
MDataHandle hParentMatrix = data.outputValue( aParentMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
hParentMatrix.setMMatrix( parentMatrix );
}
if( plug == aParentInverseMatrix )
{
//cout <<"parentInverseMatrix"<<endl;
MDataHandle hParentInverseMatrix = data.outputValue( aParentInverseMatrix, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
hParentInverseMatrix.setMMatrix( parentMatrix.inverse() );
}
data.setClean( plug );
return status;
}
MStatus MG_nurbsRivet::compute(const MPlug& plug,MDataBlock& dataBlock)
{
//Get recompute value
MDataHandle recomputeH = dataBlock.inputValue(recompute);
bool recomputeV = recomputeH.asBool();
//input mesh
MDataHandle inputNurbsH = dataBlock.inputValue(inputNurbSurface);
MObject inputNurb = inputNurbsH.asNurbsSurfaceTransformed();
MMatrix offsetMatrixV = dataBlock.inputValue(offsetMatrix).asMatrix();
double U,V;
MFnNurbsSurface nurbsFn ;
nurbsFn.setObject(inputNurb);
MStatus stat;
if (recomputeV == true)
{
//input point
MDataHandle inputPointH = dataBlock.inputValue(inputPoint);
MPoint inputP = inputPointH.asVector();
MPoint closestP = nurbsFn.closestPoint(inputP,NULL,NULL,false,1e+99,MSpace::kObject);
stat = nurbsFn.getParamAtPoint(closestP,U,V,MSpace::kObject);
//Handle to U and V
MDataHandle uValueH =dataBlock.outputValue(uValue);
MDataHandle vValueH =dataBlock.outputValue(vValue);
uValueH.set(float(U));
vValueH.set(float(V));
uValueH.setClean();
vValueH.setClean();
MDataHandle recomputeOutH = dataBlock.outputValue(recompute);
}
MDataHandle uH = dataBlock.inputValue(uValue);
MDataHandle vH = dataBlock.inputValue(vValue);
U = uH.asFloat();
V = vH.asFloat();
MPoint outPoint ;
MVector uVec ;
MVector vVec;
MVector normal;
//Get point
stat = nurbsFn.getPointAtParam(U,V,outPoint,MSpace::kObject);
//Since if getting both the U and V tangent was leading to some little rotation snapping
//of the rivet I only used the U tangent and calculated the next one by dot product
//of the normal and U tangent leading to a 100% stable rivet
nurbsFn.getTangents(U,V,uVec,vVec,MSpace::kObject);
uVec.normalize();
vVec.normalize();
MVector vVecCross;
//Get normal
normal = nurbsFn.normal(U,V,MSpace::kObject);
normal.normalize();
vVecCross =(uVec^normal);
//Build the maya matrix
double myMatrix[4][4]={ { uVec.x, uVec.y , uVec.z, 0},
{ normal[0], normal[1] , normal[2], 0},
{vVecCross.x, vVecCross.y , vVecCross.z, 0},
{ outPoint[0], outPoint[1] , outPoint[2], 1}};
MMatrix rotMatrix (myMatrix);
MMatrix offsetMatrixV2 = offsetMatrixV*rotMatrix;
MTransformationMatrix matrixFn(offsetMatrixV2);
double angles[3];
MTransformationMatrix::RotationOrder rotOrder;
rotOrder =MTransformationMatrix::kXYZ;
matrixFn.getRotation(angles,rotOrder,MSpace::kObject );
//get back radians value
double radX,radY,radZ;
radX=angles[0];
radY=angles[1];
radZ=angles[2];
//convert to degree
double rotX,rotY,rotZ;
rotX = radX*toDeg;
rotY = radY*toDeg;
rotZ = radZ*toDeg;
MDataHandle outputRotateH = dataBlock.outputValue(outputRotate);
outputRotateH.set3Double(rotX,rotY,rotZ);
outputRotateH.setClean();
//let set the output matrix too
MDataHandle outMH= dataBlock.outputValue(outputMatrix);
outMH.set(rotMatrix);
outMH.setClean();
MDataHandle outputH = dataBlock.outputValue(output);
outputH.set(offsetMatrixV2[3][0],offsetMatrixV2[3][1],offsetMatrixV2[3][2]);
outputH.setClean();
return MS::kSuccess;
}
MStatus buildRotation::compute( const MPlug& plug, MDataBlock& data )
{
MStatus returnStatus;
if ((plug == rotate) || (plug.parent() == rotate) || (plug == rotateMatrix)) {
MDataHandle upData = data.inputValue( up, &returnStatus );
McheckErr(returnStatus,"ERROR getting up vector data");
MDataHandle forwardData = data.inputValue( forward, &returnStatus );
McheckErr(returnStatus,"ERROR getting forward vector data");
MVector up = upData.asVector();
MVector forward = forwardData.asVector();
// Make sure that the up and forward vectors are orthogonal
//
if ( fabs( up * forward ) > EPSILON ) {
// Non-zero dot product
//
MVector orthoVec = up ^ forward;
MVector newForward = orthoVec ^ up;
if ( forward * newForward < 0.0 ) {
// Reverse the vector
//
newForward *= -1.0;
}
forward = newForward;
}
// Calculate the rotation required to align the y-axis with the up
// vector
//
MTransformationMatrix firstRot;
MVector rotAxis = MVector::yAxis ^ up;
rotAxis.normalize();
firstRot.setToRotationAxis( rotAxis, MVector::yAxis.angle( up ) );
// Calculate the second rotation required to align the forward vector
//
MTransformationMatrix secondRot;
MVector transformedForward = firstRot.asMatrix() * forward;
transformedForward.normalize();
double angle = transformedForward.angle( MVector::zAxis );
if ( transformedForward.x < 0.0 ) {
// Compensate for the fact that the angle method returns
// the absolute value
//
angle *= -1.0;
}
secondRot.setToRotationAxis( up, angle );
// Get the requested rotation order
//
MDataHandle orderHandle = data.inputValue( rotateOrder );
short order = orderHandle.asShort();
MTransformationMatrix::RotationOrder rotOrder;
switch ( order ) {
case ROTATE_ORDER_XYZ:
rotOrder = MTransformationMatrix::kXYZ; break;
case ROTATE_ORDER_YZX:
rotOrder = MTransformationMatrix::kYZX; break;
case ROTATE_ORDER_ZXY:
rotOrder = MTransformationMatrix::kZXY; break;
case ROTATE_ORDER_XZY:
rotOrder = MTransformationMatrix::kXZY; break;
case ROTATE_ORDER_YXZ:
rotOrder = MTransformationMatrix::kYXZ; break;
case ROTATE_ORDER_ZYX:
rotOrder = MTransformationMatrix::kZYX; break;
default:
rotOrder = MTransformationMatrix::kInvalid; break;
}
MTransformationMatrix result = firstRot.asMatrix() * secondRot.asMatrix();
result.reorderRotation( rotOrder );
double rotation[3];
result.getRotation( rotation, rotOrder, MSpace::kTransform );
MDataHandle outputRot = data.outputValue( rotate );
outputRot.set( rotation[0], rotation[1], rotation[2] );
outputRot.setClean();
MDataHandle outputMatrix = data.outputValue( rotateMatrix );
outputMatrix.set( result.asMatrix() );
outputMatrix.setClean();
} else
return MS::kUnknownParameter;
return MS::kSuccess;
}
