From 0cacc35d20137ca13051cb64afe1001083b1e149 Mon Sep 17 00:00:00 2001 From: Tyler Fox Date: Fri, 31 Jan 2025 11:32:02 -0800 Subject: [PATCH] Consistent indentation using tabs --- src/drawOverride.h | 2 +- src/riderConstraint.cpp | 96 +-- src/riderConstraint.h | 10 +- src/twistMultiTangentNode.cpp | 1098 ++++++++++++++++----------------- src/twistMultiTangentNode.h | 77 +-- src/twistSplineData.cpp | 6 +- src/twistSplineData.h | 36 +- src/twistSplineNode.cpp | 26 +- src/twistSplineNode.h | 4 +- src/twistSplineUtils.h | 8 +- src/twistTangentNode.cpp | 16 +- src/twistTangentNode.h | 10 +- 12 files changed, 695 insertions(+), 694 deletions(-) diff --git a/src/drawOverride.h b/src/drawOverride.h index 023e836..cc3e221 100644 --- a/src/drawOverride.h +++ b/src/drawOverride.h @@ -135,7 +135,7 @@ class TwistSplineGeometryOverride : public MPxGeometryOverride { Restoration, requiresGeometryUpdate() is the only method get called. (No updateDG() call) Thus the data must be stored in the node. */ - TwistSplineNode* mTwistSplineNode; // The node we are rendering + TwistSplineNode* mTwistSplineNode; // The node we are rendering }; #endif diff --git a/src/riderConstraint.cpp b/src/riderConstraint.cpp index e82ec64..ed40dfa 100644 --- a/src/riderConstraint.cpp +++ b/src/riderConstraint.cpp @@ -47,61 +47,61 @@ SOFTWARE. #include "twistSplineData.h" -#define ROTATE_ORDER_XYZ 0 -#define ROTATE_ORDER_YZX 1 -#define ROTATE_ORDER_ZXY 2 -#define ROTATE_ORDER_XZY 3 -#define ROTATE_ORDER_YXZ 4 -#define ROTATE_ORDER_ZYX 5 +#define ROTATE_ORDER_XYZ 0 +#define ROTATE_ORDER_YZX 1 +#define ROTATE_ORDER_ZXY 2 +#define ROTATE_ORDER_XZY 3 +#define ROTATE_ORDER_YXZ 4 +#define ROTATE_ORDER_ZYX 5 #define CHECKSTAT(m) if (!status) {status.perror(m); return status;}; -MTypeId riderConstraint::id(0x001226FC); +MTypeId riderConstraint::id(0x001226FC); -MObject riderConstraint::aRotateOrder; -MObject riderConstraint::aGlobalOffset; -MObject riderConstraint::aGlobalSpread; -MObject riderConstraint::aScaleCompensation; -MObject riderConstraint::aUseCycle; -MObject riderConstraint::aNormalize; -MObject riderConstraint::aNormValue; +MObject riderConstraint::aRotateOrder; +MObject riderConstraint::aGlobalOffset; +MObject riderConstraint::aGlobalSpread; +MObject riderConstraint::aScaleCompensation; +MObject riderConstraint::aUseCycle; +MObject riderConstraint::aNormalize; +MObject riderConstraint::aNormValue; -MObject riderConstraint::aUseGlobalMin; -MObject riderConstraint::aMinGlobalParam; -MObject riderConstraint::aUseGlobalMax; -MObject riderConstraint::aMaxGlobalParam; +MObject riderConstraint::aUseGlobalMin; +MObject riderConstraint::aMinGlobalParam; +MObject riderConstraint::aUseGlobalMax; +MObject riderConstraint::aMaxGlobalParam; // inputs -MObject riderConstraint::aInputSplines; - MObject riderConstraint::aSpline; - MObject riderConstraint::aSplineLength; - MObject riderConstraint::aEndParam; - MObject riderConstraint::aWeight; +MObject riderConstraint::aInputSplines; + MObject riderConstraint::aSpline; + MObject riderConstraint::aSplineLength; + MObject riderConstraint::aEndParam; + MObject riderConstraint::aWeight; -MObject riderConstraint::aParams; - MObject riderConstraint::aParam; - MObject riderConstraint::aUseMin; - MObject riderConstraint::aMinParam; - MObject riderConstraint::aUseMax; - MObject riderConstraint::aMaxParam; - MObject riderConstraint::aParentInverseMatrix; +MObject riderConstraint::aParams; + MObject riderConstraint::aParam; + MObject riderConstraint::aUseMin; + MObject riderConstraint::aMinParam; + MObject riderConstraint::aUseMax; + MObject riderConstraint::aMaxParam; + MObject riderConstraint::aParentInverseMatrix; // output -MObject riderConstraint::aOutputs; - MObject riderConstraint::aTranslate; - MObject riderConstraint::aTranslateX; - MObject riderConstraint::aTranslateY; - MObject riderConstraint::aTranslateZ; - MObject riderConstraint::aRotate; - MObject riderConstraint::aRotateX; - MObject riderConstraint::aRotateY; - MObject riderConstraint::aRotateZ; - MObject riderConstraint::aScale; - MObject riderConstraint::aScaleX; - MObject riderConstraint::aScaleY; - MObject riderConstraint::aScaleZ; +MObject riderConstraint::aOutputs; + MObject riderConstraint::aTranslate; + MObject riderConstraint::aTranslateX; + MObject riderConstraint::aTranslateY; + MObject riderConstraint::aTranslateZ; + MObject riderConstraint::aRotate; + MObject riderConstraint::aRotateX; + MObject riderConstraint::aRotateY; + MObject riderConstraint::aRotateZ; + MObject riderConstraint::aScale; + MObject riderConstraint::aScaleX; + MObject riderConstraint::aScaleY; + MObject riderConstraint::aScaleZ; MStatus riderConstraint::initialize() { MStatus status; @@ -564,10 +564,10 @@ MStatus riderConstraint::compute(const MPlug& plug, MDataBlock& data) { p *= gSpread; p += gOffset; - if (useGlobalMin) { p = std::fmax(minGlobalParam, p); } - if (pUseMins[pIdx]) { p = std::fmax(pMins[pIdx], p); } - if (useGlobalMax) { p = std::fmin(maxGlobalParam, p); } - if (pUseMaxs[pIdx]) { p = std::fmin(pMaxs[pIdx], p); } + if (useGlobalMin) { p = std::fmax(minGlobalParam, p); } + if (pUseMins[pIdx]) { p = std::fmax(pMins[pIdx], p); } + if (useGlobalMax) { p = std::fmin(maxGlobalParam, p); } + if (pUseMaxs[pIdx]) { p = std::fmin(pMaxs[pIdx], p); } if (doNorm > 0.0) { p = (doNorm) * (p * mp / normVal) + (1.0 - doNorm) * (p); @@ -589,7 +589,7 @@ MStatus riderConstraint::compute(const MPlug& plug, MDataBlock& data) { mat[0][0] = tan[0]; mat[1][0] = norm[0]; mat[2][0] = binorm[0]; mat[3][0] = 0.0; mat[0][1] = tan[1]; mat[1][1] = norm[1]; mat[2][1] = binorm[1]; mat[3][1] = 0.0; mat[0][2] = tan[2]; mat[1][2] = norm[2]; mat[2][2] = binorm[2]; mat[3][2] = 0.0; - mat[0][3] = 0.0; mat[1][3] = 0.0; mat[2][3] = 0.0; mat[3][3] = 1.0; + mat[0][3] = 0.0; mat[1][3] = 0.0; mat[2][3] = 0.0; mat[3][3] = 1.0; MQuaternion q; q = MMatrix(mat); tquats.push_back(std::move(q)); diff --git a/src/riderConstraint.h b/src/riderConstraint.h index 9041dac..1717c46 100644 --- a/src/riderConstraint.h +++ b/src/riderConstraint.h @@ -60,12 +60,12 @@ class riderConstraint : public MPxNode { static MObject aParams; static MObject aParam; - static MObject aUseMin; - static MObject aMinParam; - static MObject aUseMax; - static MObject aMaxParam; + static MObject aUseMin; + static MObject aMinParam; + static MObject aUseMax; + static MObject aMaxParam; - static MObject aParentInverseMatrix; + static MObject aParentInverseMatrix; // output static MObject aOutputs; diff --git a/src/twistMultiTangentNode.cpp b/src/twistMultiTangentNode.cpp index e607518..b60b74e 100644 --- a/src/twistMultiTangentNode.cpp +++ b/src/twistMultiTangentNode.cpp @@ -45,11 +45,11 @@ SOFTWARE. #include "twistMultiTangentNode.h" -#define CHECKSTAT(m) \ - if (!status) { \ - status.perror(m); \ - return status; \ - }; +#define CHECKSTAT(m) \ + if (!status) { \ + status.perror(m); \ + return status; \ + }; MTypeId TwistMultiTangentNode::id(0x00122715); @@ -98,584 +98,584 @@ void *TwistMultiTangentNode::creator() { return new TwistMultiTangentNode(); } MStatus TwistMultiTangentNode::initialize() { - MFnNumericAttribute num_attr; - MFnCompoundAttribute cmp_attr; - MFnMatrixAttribute mat_attr; - MFnUnitAttribute unit_attr; - MStatus status; - - aInTanMat = mat_attr.create("inTanMat", "itm"); - mat_attr.setKeyable(false); - mat_attr.setStorable(false); - mat_attr.setHidden(true); - - aOutTanMat = mat_attr.create("outTanMat", "otm"); - mat_attr.setKeyable(false); - mat_attr.setStorable(false); - mat_attr.setHidden(true); - - aInTanWeight = - num_attr.create("inTanWeight", "itw", MFnNumericData::kDouble, 1.0, &status); - num_attr.setKeyable(true); - num_attr.setStorable(false); - num_attr.setSoftMin(0.0); - num_attr.setSoftMax(2.0); - - aOutTanWeight = - num_attr.create("outTanWeight", "otw", MFnNumericData::kDouble, 1.0, &status); - num_attr.setKeyable(true); - num_attr.setStorable(false); - num_attr.setSoftMin(0.0); - num_attr.setSoftMax(2.0); - - aInSmooth = num_attr.create("inSmooth", "ism", MFnNumericData::kDouble, 1.0, &status); - num_attr.setKeyable(true); - num_attr.setStorable(false); - num_attr.setSoftMin(0.0); - num_attr.setSoftMax(1.0); - - aOutSmooth = num_attr.create("outSmooth", "osm", MFnNumericData::kDouble, 1.0, &status); - num_attr.setKeyable(true); - num_attr.setStorable(false); - num_attr.setSoftMin(0.0); - num_attr.setSoftMax(1.0); - - aInTanAuto = num_attr.create("inAuto", "iat", MFnNumericData::kDouble, 1.0, &status); - num_attr.setKeyable(true); - num_attr.setStorable(false); - num_attr.setSoftMin(0.0); - num_attr.setSoftMax(1.0); - - aOutTanAuto = num_attr.create("outAuto", "oat", MFnNumericData::kDouble, 1.0, &status); - num_attr.setKeyable(true); - num_attr.setStorable(false); - num_attr.setSoftMin(0.0); - num_attr.setSoftMax(1.0); - - aVertMat = mat_attr.create("vertMat", "vm"); - mat_attr.setKeyable(false); - mat_attr.setStorable(false); - mat_attr.setHidden(true); - - aInParentInv = mat_attr.create("inParentInverseMatrix", "ipim"); - mat_attr.setKeyable(false); - mat_attr.setStorable(false); - mat_attr.setHidden(true); - - aOutParentInv = mat_attr.create("outParentInverseMatrix", "opim"); - mat_attr.setKeyable(false); - mat_attr.setStorable(false); - mat_attr.setHidden(true); - - aTwistParentInv = mat_attr.create("twistParentInverseMatrix", "tpim"); - mat_attr.setKeyable(false); - mat_attr.setStorable(false); - mat_attr.setHidden(true); - - aVertData = cmp_attr.create("vertData", "vd", &status); - cmp_attr.setArray(true); - cmp_attr.setDisconnectBehavior(cmp_attr.kDelete); - cmp_attr.addChild(aVertMat); - cmp_attr.addChild(aInParentInv); - cmp_attr.addChild(aOutParentInv); - cmp_attr.addChild(aTwistParentInv); - cmp_attr.addChild(aInTanWeight); - cmp_attr.addChild(aOutTanWeight); - cmp_attr.addChild(aInSmooth); - cmp_attr.addChild(aOutSmooth); - cmp_attr.addChild(aInTanAuto); - cmp_attr.addChild(aOutTanAuto); - cmp_attr.addChild(aInTanMat); - cmp_attr.addChild(aOutTanMat); - - addAttribute(aVertData); - - aStartTension = - num_attr.create("startTension", "st", MFnNumericData::kDouble, 2.0, &status); - num_attr.setKeyable(true); - num_attr.setStorable(true); - addAttribute(aStartTension); - - aEndTension = - num_attr.create("endTension", "et", MFnNumericData::kDouble, 2.0, &status); - num_attr.setKeyable(true); - num_attr.setStorable(true); - addAttribute(aEndTension); - - aMaxVertices = num_attr.create("maxVertices", "mv", MFnNumericData::kInt, 999, &status); - num_attr.setKeyable(true); - num_attr.setStorable(true); - num_attr.setMin(2); - addAttribute(aMaxVertices); - - aClosed = num_attr.create("closed", "cl", MFnNumericData::kBoolean, false, &status); - num_attr.setKeyable(true); - num_attr.setStorable(true); - addAttribute(aClosed); - - aInTanX = - unit_attr.create("inVertTanX", "ivx", MFnUnitAttribute::kDistance, 0.0, &status); - unit_attr.setKeyable(false); - unit_attr.setStorable(false); - unit_attr.setWritable(false); - aInTanY = - unit_attr.create("inVertTanY", "ivy", MFnUnitAttribute::kDistance, 0.0, &status); - unit_attr.setKeyable(false); - unit_attr.setStorable(false); - unit_attr.setWritable(false); - aInTanZ = - unit_attr.create("inVertTanZ", "ivz", MFnUnitAttribute::kDistance, 0.0, &status); - unit_attr.setKeyable(false); - unit_attr.setStorable(false); - unit_attr.setWritable(false); - - aInTan = num_attr.create("inVertTan", "ivt", aInTanX, aInTanY, aInTanZ, &status); - num_attr.setKeyable(false); - num_attr.setStorable(false); - num_attr.setWritable(false); - - aOutTanX = - unit_attr.create("outVertTanX", "ovx", MFnUnitAttribute::kDistance, 0.0, &status); - unit_attr.setKeyable(false); - unit_attr.setStorable(false); - unit_attr.setWritable(false); - aOutTanY = - unit_attr.create("outVertTanY", "ovy", MFnUnitAttribute::kDistance, 0.0, &status); - unit_attr.setKeyable(false); - unit_attr.setStorable(false); - unit_attr.setWritable(false); - aOutTanZ = - unit_attr.create("outVertTanZ", "ovz", MFnUnitAttribute::kDistance, 0.0, &status); - unit_attr.setKeyable(false); - unit_attr.setStorable(false); - unit_attr.setWritable(false); - - aOutTan = num_attr.create("outVertTan", "ovt", aOutTanX, aOutTanY, aOutTanZ, &status); - num_attr.setKeyable(false); - num_attr.setStorable(false); - num_attr.setWritable(false); - - aOutTwistUpX = - unit_attr.create("twistUpX", "tux", MFnUnitAttribute::kDistance, 0.0, &status); - unit_attr.setKeyable(false); - unit_attr.setStorable(false); - unit_attr.setWritable(false); - aOutTwistUpY = - unit_attr.create("twistUpY", "tuy", MFnUnitAttribute::kDistance, 0.0, &status); - unit_attr.setKeyable(false); - unit_attr.setStorable(false); - unit_attr.setWritable(false); - aOutTwistUpZ = - unit_attr.create("twistUpZ", "tuz", MFnUnitAttribute::kDistance, 0.0, &status); - unit_attr.setKeyable(false); - unit_attr.setStorable(false); - unit_attr.setWritable(false); - - aOutTwistUp = num_attr.create( - "twistUp", "tu", aOutTwistUpX, aOutTwistUpY, aOutTwistUpZ, &status - ); - num_attr.setKeyable(false); - num_attr.setStorable(false); - num_attr.setWritable(false); - - aOutTwistMat = mat_attr.create("twistMat", "tm"); - mat_attr.setKeyable(false); - mat_attr.setWritable(false); - mat_attr.setStorable(false); - mat_attr.setHidden(true); - - aInTanLen = num_attr.create("inTanLen", "itl", MFnNumericData::kDouble, 0.0, &status); - num_attr.setKeyable(false); - num_attr.setWritable(false); - num_attr.setStorable(false); - aOutTanLen = num_attr.create("outTanLen", "otl", MFnNumericData::kDouble, 0.0, &status); - num_attr.setKeyable(false); - num_attr.setWritable(false); - num_attr.setStorable(false); - - aTangents = cmp_attr.create("vertTans", "vt", &status); - cmp_attr.addChild(aInTan); - cmp_attr.addChild(aOutTan); - cmp_attr.addChild(aInTanLen); - cmp_attr.addChild(aOutTanLen); - cmp_attr.addChild(aOutTwistUp); - cmp_attr.addChild(aOutTwistMat); - - cmp_attr.setArray(true); - cmp_attr.setUsesArrayDataBuilder(true); - cmp_attr.setKeyable(false); - cmp_attr.setWritable(false); - cmp_attr.setStorable(false); - addAttribute(aTangents); - - std::vector ins, outs; - ins.push_back(&aStartTension); - ins.push_back(&aEndTension); - ins.push_back(&aMaxVertices); - ins.push_back(&aClosed); - ins.push_back(&aVertMat); - ins.push_back(&aInParentInv); - ins.push_back(&aOutParentInv); - ins.push_back(&aTwistParentInv); - ins.push_back(&aInTanWeight); - ins.push_back(&aOutTanWeight); - ins.push_back(&aInTanMat); - ins.push_back(&aOutTanMat); - ins.push_back(&aInSmooth); - ins.push_back(&aOutSmooth); - ins.push_back(&aInTanAuto); - ins.push_back(&aOutTanAuto); - ins.push_back(&aVertData); - - outs.push_back(&aInTanX); - outs.push_back(&aInTanY); - outs.push_back(&aInTanZ); - outs.push_back(&aInTan); - outs.push_back(&aOutTanX); - outs.push_back(&aOutTanY); - outs.push_back(&aOutTanZ); - outs.push_back(&aOutTan); - outs.push_back(&aInTanLen); - outs.push_back(&aOutTanLen); - outs.push_back(&aOutTwistUpX); - outs.push_back(&aOutTwistUpY); - outs.push_back(&aOutTwistUpZ); - outs.push_back(&aOutTwistUp); - outs.push_back(&aOutTwistMat); - outs.push_back(&aTangents); - - for (auto i : ins) { - for (auto o : outs) { - attributeAffects(*i, *o); - } - } - - return MS::kSuccess; + MFnNumericAttribute num_attr; + MFnCompoundAttribute cmp_attr; + MFnMatrixAttribute mat_attr; + MFnUnitAttribute unit_attr; + MStatus status; + + aInTanMat = mat_attr.create("inTanMat", "itm"); + mat_attr.setKeyable(false); + mat_attr.setStorable(false); + mat_attr.setHidden(true); + + aOutTanMat = mat_attr.create("outTanMat", "otm"); + mat_attr.setKeyable(false); + mat_attr.setStorable(false); + mat_attr.setHidden(true); + + aInTanWeight = + num_attr.create("inTanWeight", "itw", MFnNumericData::kDouble, 1.0, &status); + num_attr.setKeyable(true); + num_attr.setStorable(false); + num_attr.setSoftMin(0.0); + num_attr.setSoftMax(2.0); + + aOutTanWeight = + num_attr.create("outTanWeight", "otw", MFnNumericData::kDouble, 1.0, &status); + num_attr.setKeyable(true); + num_attr.setStorable(false); + num_attr.setSoftMin(0.0); + num_attr.setSoftMax(2.0); + + aInSmooth = num_attr.create("inSmooth", "ism", MFnNumericData::kDouble, 1.0, &status); + num_attr.setKeyable(true); + num_attr.setStorable(false); + num_attr.setSoftMin(0.0); + num_attr.setSoftMax(1.0); + + aOutSmooth = num_attr.create("outSmooth", "osm", MFnNumericData::kDouble, 1.0, &status); + num_attr.setKeyable(true); + num_attr.setStorable(false); + num_attr.setSoftMin(0.0); + num_attr.setSoftMax(1.0); + + aInTanAuto = num_attr.create("inAuto", "iat", MFnNumericData::kDouble, 1.0, &status); + num_attr.setKeyable(true); + num_attr.setStorable(false); + num_attr.setSoftMin(0.0); + num_attr.setSoftMax(1.0); + + aOutTanAuto = num_attr.create("outAuto", "oat", MFnNumericData::kDouble, 1.0, &status); + num_attr.setKeyable(true); + num_attr.setStorable(false); + num_attr.setSoftMin(0.0); + num_attr.setSoftMax(1.0); + + aVertMat = mat_attr.create("vertMat", "vm"); + mat_attr.setKeyable(false); + mat_attr.setStorable(false); + mat_attr.setHidden(true); + + aInParentInv = mat_attr.create("inParentInverseMatrix", "ipim"); + mat_attr.setKeyable(false); + mat_attr.setStorable(false); + mat_attr.setHidden(true); + + aOutParentInv = mat_attr.create("outParentInverseMatrix", "opim"); + mat_attr.setKeyable(false); + mat_attr.setStorable(false); + mat_attr.setHidden(true); + + aTwistParentInv = mat_attr.create("twistParentInverseMatrix", "tpim"); + mat_attr.setKeyable(false); + mat_attr.setStorable(false); + mat_attr.setHidden(true); + + aVertData = cmp_attr.create("vertData", "vd", &status); + cmp_attr.setArray(true); + cmp_attr.setDisconnectBehavior(cmp_attr.kDelete); + cmp_attr.addChild(aVertMat); + cmp_attr.addChild(aInParentInv); + cmp_attr.addChild(aOutParentInv); + cmp_attr.addChild(aTwistParentInv); + cmp_attr.addChild(aInTanWeight); + cmp_attr.addChild(aOutTanWeight); + cmp_attr.addChild(aInSmooth); + cmp_attr.addChild(aOutSmooth); + cmp_attr.addChild(aInTanAuto); + cmp_attr.addChild(aOutTanAuto); + cmp_attr.addChild(aInTanMat); + cmp_attr.addChild(aOutTanMat); + + addAttribute(aVertData); + + aStartTension = + num_attr.create("startTension", "st", MFnNumericData::kDouble, 2.0, &status); + num_attr.setKeyable(true); + num_attr.setStorable(true); + addAttribute(aStartTension); + + aEndTension = + num_attr.create("endTension", "et", MFnNumericData::kDouble, 2.0, &status); + num_attr.setKeyable(true); + num_attr.setStorable(true); + addAttribute(aEndTension); + + aMaxVertices = num_attr.create("maxVertices", "mv", MFnNumericData::kInt, 999, &status); + num_attr.setKeyable(true); + num_attr.setStorable(true); + num_attr.setMin(2); + addAttribute(aMaxVertices); + + aClosed = num_attr.create("closed", "cl", MFnNumericData::kBoolean, false, &status); + num_attr.setKeyable(true); + num_attr.setStorable(true); + addAttribute(aClosed); + + aInTanX = + unit_attr.create("inVertTanX", "ivx", MFnUnitAttribute::kDistance, 0.0, &status); + unit_attr.setKeyable(false); + unit_attr.setStorable(false); + unit_attr.setWritable(false); + aInTanY = + unit_attr.create("inVertTanY", "ivy", MFnUnitAttribute::kDistance, 0.0, &status); + unit_attr.setKeyable(false); + unit_attr.setStorable(false); + unit_attr.setWritable(false); + aInTanZ = + unit_attr.create("inVertTanZ", "ivz", MFnUnitAttribute::kDistance, 0.0, &status); + unit_attr.setKeyable(false); + unit_attr.setStorable(false); + unit_attr.setWritable(false); + + aInTan = num_attr.create("inVertTan", "ivt", aInTanX, aInTanY, aInTanZ, &status); + num_attr.setKeyable(false); + num_attr.setStorable(false); + num_attr.setWritable(false); + + aOutTanX = + unit_attr.create("outVertTanX", "ovx", MFnUnitAttribute::kDistance, 0.0, &status); + unit_attr.setKeyable(false); + unit_attr.setStorable(false); + unit_attr.setWritable(false); + aOutTanY = + unit_attr.create("outVertTanY", "ovy", MFnUnitAttribute::kDistance, 0.0, &status); + unit_attr.setKeyable(false); + unit_attr.setStorable(false); + unit_attr.setWritable(false); + aOutTanZ = + unit_attr.create("outVertTanZ", "ovz", MFnUnitAttribute::kDistance, 0.0, &status); + unit_attr.setKeyable(false); + unit_attr.setStorable(false); + unit_attr.setWritable(false); + + aOutTan = num_attr.create("outVertTan", "ovt", aOutTanX, aOutTanY, aOutTanZ, &status); + num_attr.setKeyable(false); + num_attr.setStorable(false); + num_attr.setWritable(false); + + aOutTwistUpX = + unit_attr.create("twistUpX", "tux", MFnUnitAttribute::kDistance, 0.0, &status); + unit_attr.setKeyable(false); + unit_attr.setStorable(false); + unit_attr.setWritable(false); + aOutTwistUpY = + unit_attr.create("twistUpY", "tuy", MFnUnitAttribute::kDistance, 0.0, &status); + unit_attr.setKeyable(false); + unit_attr.setStorable(false); + unit_attr.setWritable(false); + aOutTwistUpZ = + unit_attr.create("twistUpZ", "tuz", MFnUnitAttribute::kDistance, 0.0, &status); + unit_attr.setKeyable(false); + unit_attr.setStorable(false); + unit_attr.setWritable(false); + + aOutTwistUp = num_attr.create( + "twistUp", "tu", aOutTwistUpX, aOutTwistUpY, aOutTwistUpZ, &status + ); + num_attr.setKeyable(false); + num_attr.setStorable(false); + num_attr.setWritable(false); + + aOutTwistMat = mat_attr.create("twistMat", "tm"); + mat_attr.setKeyable(false); + mat_attr.setWritable(false); + mat_attr.setStorable(false); + mat_attr.setHidden(true); + + aInTanLen = num_attr.create("inTanLen", "itl", MFnNumericData::kDouble, 0.0, &status); + num_attr.setKeyable(false); + num_attr.setWritable(false); + num_attr.setStorable(false); + aOutTanLen = num_attr.create("outTanLen", "otl", MFnNumericData::kDouble, 0.0, &status); + num_attr.setKeyable(false); + num_attr.setWritable(false); + num_attr.setStorable(false); + + aTangents = cmp_attr.create("vertTans", "vt", &status); + cmp_attr.addChild(aInTan); + cmp_attr.addChild(aOutTan); + cmp_attr.addChild(aInTanLen); + cmp_attr.addChild(aOutTanLen); + cmp_attr.addChild(aOutTwistUp); + cmp_attr.addChild(aOutTwistMat); + + cmp_attr.setArray(true); + cmp_attr.setUsesArrayDataBuilder(true); + cmp_attr.setKeyable(false); + cmp_attr.setWritable(false); + cmp_attr.setStorable(false); + addAttribute(aTangents); + + std::vector ins, outs; + ins.push_back(&aStartTension); + ins.push_back(&aEndTension); + ins.push_back(&aMaxVertices); + ins.push_back(&aClosed); + ins.push_back(&aVertMat); + ins.push_back(&aInParentInv); + ins.push_back(&aOutParentInv); + ins.push_back(&aTwistParentInv); + ins.push_back(&aInTanWeight); + ins.push_back(&aOutTanWeight); + ins.push_back(&aInTanMat); + ins.push_back(&aOutTanMat); + ins.push_back(&aInSmooth); + ins.push_back(&aOutSmooth); + ins.push_back(&aInTanAuto); + ins.push_back(&aOutTanAuto); + ins.push_back(&aVertData); + + outs.push_back(&aInTanX); + outs.push_back(&aInTanY); + outs.push_back(&aInTanZ); + outs.push_back(&aInTan); + outs.push_back(&aOutTanX); + outs.push_back(&aOutTanY); + outs.push_back(&aOutTanZ); + outs.push_back(&aOutTan); + outs.push_back(&aInTanLen); + outs.push_back(&aOutTanLen); + outs.push_back(&aOutTwistUpX); + outs.push_back(&aOutTwistUpY); + outs.push_back(&aOutTwistUpZ); + outs.push_back(&aOutTwistUp); + outs.push_back(&aOutTwistMat); + outs.push_back(&aTangents); + + for (auto i : ins) { + for (auto o : outs) { + attributeAffects(*i, *o); + } + } + + return MS::kSuccess; } struct DirTanData { - double weight; - double smooth; - double autoVal; - MMatrix piMat; - MMatrix userMat; - MVector leg; - double legLen; - MVector normLeg; - MVector smoothTan; - MVector linearTan; - MVector doneTan; + double weight; + double smooth; + double autoVal; + MMatrix piMat; + MMatrix userMat; + MVector leg; + double legLen; + MVector normLeg; + MVector smoothTan; + MVector linearTan; + MVector doneTan; }; struct TanData { - MMatrix tfmMat; - MMatrix smoothMat; - MVector tfm; - MVector norm; - MMatrix piTwist; - DirTanData inTan; - DirTanData outTan; + MMatrix tfmMat; + MMatrix smoothMat; + MVector tfm; + MVector norm; + MMatrix piTwist; + DirTanData inTan; + DirTanData outTan; }; MMatrix buildMat(const MVector &tfm, const MVector &inrm, const MVector &tan) { - //"""Build a matrix from a position, tangent and normal Go through Graham-Schmidt to - //orthonormalize it """ - MVector bin = (tan ^ inrm).normal(); - MVector nrm = (bin ^ tan).normal(); - - MMatrix ret; - ret[0][0] = tan[0]; - ret[0][1] = tan[1]; - ret[0][2] = tan[2]; - - ret[1][0] = nrm[0]; - ret[1][1] = nrm[1]; - ret[1][2] = nrm[2]; - - ret[2][0] = bin[0]; - ret[2][1] = bin[1]; - ret[2][2] = bin[2]; - - ret[3][0] = tfm[0]; - ret[3][1] = tfm[1]; - ret[3][2] = tfm[2]; - return ret; + //"""Build a matrix from a position, tangent and normal Go through Graham-Schmidt to + //orthonormalize it """ + MVector bin = (tan ^ inrm).normal(); + MVector nrm = (bin ^ tan).normal(); + + MMatrix ret; + ret[0][0] = tan[0]; + ret[0][1] = tan[1]; + ret[0][2] = tan[2]; + + ret[1][0] = nrm[0]; + ret[1][1] = nrm[1]; + ret[1][2] = nrm[2]; + + ret[2][0] = bin[0]; + ret[2][1] = bin[1]; + ret[2][2] = bin[2]; + + ret[3][0] = tfm[0]; + ret[3][1] = tfm[1]; + ret[3][2] = tfm[2]; + return ret; } MVector buildVertMatTangent(double nextLegLen, double preLegLen, MVector &nextLegNrm, MVector &preLegNrm) { - //"""Given all this pre-calculated data, figure out the normalized tangent to the curve at the - //given vertex""" - if (preLegLen == 0.0) { - if (nextLegLen == 0.0) { - return MVector(0, 1, 0); - } - return nextLegNrm; - } - - if (nextLegLen == 0.0) { - return -preLegNrm; - } - - double dot = preLegNrm * nextLegNrm; - - // Pre and post legs both point TOWARD the curTFM - if (dot > 0.999999999) { - // pre/next legs are pointing the same direction - // so we've got a 180 turnaround - MVector y; - if (std::abs(preLegNrm * y) > 0.999999999) { - y = MVector(1, 0, 0); - } - else { - y = MVector(0, 1, 0); - } - return (preLegNrm ^ y).normal(); - } - else if (dot < -0.999999999) { - // pre/next legs are pointing opposite directions - // so we're in a straight line - return -preLegNrm; - } - MVector bin = (preLegNrm ^ nextLegNrm).normal(); - return ((bin ^ preLegNrm) + (bin ^ nextLegNrm)).normal(); + //"""Given all this pre-calculated data, figure out the normalized tangent to the curve at the + //given vertex""" + if (preLegLen == 0.0) { + if (nextLegLen == 0.0) { + return MVector(0, 1, 0); + } + return nextLegNrm; + } + + if (nextLegLen == 0.0) { + return -preLegNrm; + } + + double dot = preLegNrm * nextLegNrm; + + // Pre and post legs both point TOWARD the curTFM + if (dot > 0.999999999) { + // pre/next legs are pointing the same direction + // so we've got a 180 turnaround + MVector y; + if (std::abs(preLegNrm * y) > 0.999999999) { + y = MVector(1, 0, 0); + } + else { + y = MVector(0, 1, 0); + } + return (preLegNrm ^ y).normal(); + } + else if (dot < -0.999999999) { + // pre/next legs are pointing opposite directions + // so we're in a straight line + return -preLegNrm; + } + MVector bin = (preLegNrm ^ nextLegNrm).normal(); + return ((bin ^ preLegNrm) + (bin ^ nextLegNrm)).normal(); } void buildSmoothMats(std::vector &dat, double startTension, double endTension, bool closed) { - for (size_t i = 1; i + 1 < dat.size(); ++i) { - auto &cur = dat[i]; - MVector tan = buildVertMatTangent( - cur.outTan.legLen, cur.inTan.legLen, cur.outTan.normLeg, cur.inTan.normLeg - ); - cur.smoothMat = buildMat(cur.tfm, cur.norm, tan); - - double preLegLen = cur.inTan.legLen * cur.inTan.weight / 3; - double nextLegLen = cur.outTan.legLen * cur.outTan.weight / 3; - cur.inTan.smoothTan = -tan * preLegLen; - cur.outTan.smoothTan = tan * nextLegLen; - } - - if (closed){ - auto &start = dat[0]; - auto &end = dat[dat.size() - 1]; - - MVector tan = buildVertMatTangent( - start.outTan.legLen, end.inTan.legLen, start.outTan.normLeg, end.inTan.normLeg - ); - start.smoothMat = buildMat(start.tfm, start.norm, tan); - end.smoothMat = start.smoothMat; - double preLegLen = end.inTan.legLen * end.inTan.weight / 3; - double nextLegLen = start.outTan.legLen * start.outTan.weight / 3; - - end.inTan.smoothTan = -tan * preLegLen; - start.outTan.smoothTan = tan * nextLegLen; - } - else{ - dat[0].outTan.smoothTan = (dat[1].tfm + dat[1].inTan.smoothTan * startTension - dat[0].tfm) * - (dat[0].outTan.weight / 2); - dat[0].smoothMat = buildMat(dat[0].tfm, dat[0].norm, dat[0].outTan.smoothTan.normal()); - - size_t s = dat.size(); - dat[s - 1].inTan.smoothTan = - (dat[s - 2].tfm + dat[s - 2].outTan.smoothTan * startTension - dat[s - 1].tfm) * - (dat[s - 1].inTan.weight / 2); - - dat[s - 1].smoothMat = buildMat(dat[s - 1].tfm, dat[s - 1].norm, -dat[s - 1].inTan.smoothTan.normal()); - } + for (size_t i = 1; i + 1 < dat.size(); ++i) { + auto &cur = dat[i]; + MVector tan = buildVertMatTangent( + cur.outTan.legLen, cur.inTan.legLen, cur.outTan.normLeg, cur.inTan.normLeg + ); + cur.smoothMat = buildMat(cur.tfm, cur.norm, tan); + + double preLegLen = cur.inTan.legLen * cur.inTan.weight / 3; + double nextLegLen = cur.outTan.legLen * cur.outTan.weight / 3; + cur.inTan.smoothTan = -tan * preLegLen; + cur.outTan.smoothTan = tan * nextLegLen; + } + + if (closed){ + auto &start = dat[0]; + auto &end = dat[dat.size() - 1]; + + MVector tan = buildVertMatTangent( + start.outTan.legLen, end.inTan.legLen, start.outTan.normLeg, end.inTan.normLeg + ); + start.smoothMat = buildMat(start.tfm, start.norm, tan); + end.smoothMat = start.smoothMat; + double preLegLen = end.inTan.legLen * end.inTan.weight / 3; + double nextLegLen = start.outTan.legLen * start.outTan.weight / 3; + + end.inTan.smoothTan = -tan * preLegLen; + start.outTan.smoothTan = tan * nextLegLen; + } + else{ + dat[0].outTan.smoothTan = (dat[1].tfm + dat[1].inTan.smoothTan * startTension - dat[0].tfm) * + (dat[0].outTan.weight / 2); + dat[0].smoothMat = buildMat(dat[0].tfm, dat[0].norm, dat[0].outTan.smoothTan.normal()); + + size_t s = dat.size(); + dat[s - 1].inTan.smoothTan = + (dat[s - 2].tfm + dat[s - 2].outTan.smoothTan * startTension - dat[s - 1].tfm) * + (dat[s - 1].inTan.weight / 2); + + dat[s - 1].smoothMat = buildMat(dat[s - 1].tfm, dat[s - 1].norm, -dat[s - 1].inTan.smoothTan.normal()); + } } void buildLinearTangents(std::vector &dat) { - for (size_t i = 1; i + 1 < dat.size(); ++i) { - auto &prev = dat[i - 1]; - auto &cur = dat[i]; - auto &next = dat[i + 1]; + for (size_t i = 1; i + 1 < dat.size(); ++i) { + auto &prev = dat[i - 1]; + auto &cur = dat[i]; + auto &next = dat[i + 1]; - double preLegLen = cur.inTan.legLen * cur.inTan.weight / 3; - double nextLegLen = cur.outTan.legLen * cur.outTan.weight / 3; + double preLegLen = cur.inTan.legLen * cur.inTan.weight / 3; + double nextLegLen = cur.outTan.legLen * cur.outTan.weight / 3; - MVector inDir = (prev.tfm + (prev.outTan.smoothTan * prev.outTan.smooth) - cur.tfm).normal(); - MVector outDir = (next.tfm + (next.inTan.smoothTan * next.inTan.smooth) - cur.tfm).normal(); + MVector inDir = (prev.tfm + (prev.outTan.smoothTan * prev.outTan.smooth) - cur.tfm).normal(); + MVector outDir = (next.tfm + (next.inTan.smoothTan * next.inTan.smooth) - cur.tfm).normal(); - cur.inTan.linearTan = inDir * preLegLen; - cur.outTan.linearTan = outDir * nextLegLen; - } + cur.inTan.linearTan = inDir * preLegLen; + cur.outTan.linearTan = outDir * nextLegLen; + } - size_t s = dat.size(); + size_t s = dat.size(); - dat[0].outTan.linearTan = (dat[1].tfm + (dat[1].inTan.smoothTan * dat[1].inTan.smooth) - dat[0].tfm) / (3 - dat[1].inTan.smooth); - dat[s - 1].inTan.linearTan = (dat[s - 2].tfm + (dat[s - 2].outTan.smoothTan * dat[s - 2].outTan.smooth) - dat[s - 1].tfm) / (3 - dat[s-2].outTan.smooth); + dat[0].outTan.linearTan = (dat[1].tfm + (dat[1].inTan.smoothTan * dat[1].inTan.smooth) - dat[0].tfm) / (3 - dat[1].inTan.smooth); + dat[s - 1].inTan.linearTan = (dat[s - 2].tfm + (dat[s - 2].outTan.smoothTan * dat[s - 2].outTan.smooth) - dat[s - 1].tfm) / (3 - dat[s-2].outTan.smooth); } void buildDoneTangents(std::vector &dat) { - for (auto &cur : dat) { - MMatrix ti = cur.tfmMat.inverse(); - - double inSmo = cur.inTan.smooth; - double inAutoMul = cur.inTan.autoVal; - MMatrix inUserMat = ti * cur.inTan.userMat; - MVector inUserTan = MVector(inUserMat(3, 0), inUserMat(3, 1), inUserMat(3, 2)); - MVector inAutoTan = cur.inTan.smoothTan * inSmo + cur.inTan.linearTan * (1 - inSmo); - cur.inTan.doneTan = inAutoTan * inAutoMul + inUserTan * (1 - inAutoMul); - - double outSmo = cur.outTan.smooth; - double outAutoMul = cur.outTan.autoVal; - MMatrix outUserMat = ti * cur.outTan.userMat; - MVector outUserTan = MVector(outUserMat(3, 0), outUserMat(3, 1), outUserMat(3, 2)); - MVector outAutoTan = cur.outTan.smoothTan * outSmo + cur.outTan.linearTan * (1 - outSmo); - cur.outTan.doneTan = outAutoTan * outAutoMul + outUserTan * (1 - outAutoMul); - } + for (auto &cur : dat) { + MMatrix ti = cur.tfmMat.inverse(); + + double inSmo = cur.inTan.smooth; + double inAutoMul = cur.inTan.autoVal; + MMatrix inUserMat = ti * cur.inTan.userMat; + MVector inUserTan = MVector(inUserMat(3, 0), inUserMat(3, 1), inUserMat(3, 2)); + MVector inAutoTan = cur.inTan.smoothTan * inSmo + cur.inTan.linearTan * (1 - inSmo); + cur.inTan.doneTan = inAutoTan * inAutoMul + inUserTan * (1 - inAutoMul); + + double outSmo = cur.outTan.smooth; + double outAutoMul = cur.outTan.autoVal; + MMatrix outUserMat = ti * cur.outTan.userMat; + MVector outUserTan = MVector(outUserMat(3, 0), outUserMat(3, 1), outUserMat(3, 2)); + MVector outAutoTan = cur.outTan.smoothTan * outSmo + cur.outTan.linearTan * (1 - outSmo); + cur.outTan.doneTan = outAutoTan * outAutoMul + outUserTan * (1 - outAutoMul); + } } MStatus TwistMultiTangentNode::compute(const MPlug &plug, MDataBlock &data) { - if (plug != aInTanX && plug != aInTanY && plug != aInTanZ && plug != aInTan && - plug != aOutTanX && plug != aOutTanY && plug != aOutTanZ && plug != aOutTan && - plug != aInTanLen && plug != aOutTanLen && plug != aOutTwistUpX && plug != aOutTwistUpY && - plug != aOutTwistUpZ && plug != aOutTwistUp && plug != aOutTwistMat && plug != aTangents) { - return MS::kUnknownParameter; - } - - // Read everything - MArrayDataHandle vertInputs = data.inputArrayValue(aVertData); - unsigned icount = vertInputs.elementCount(); - - double startTension = data.inputValue(aStartTension).asDouble(); - double endTension = data.inputValue(aEndTension).asDouble(); - int rawMaxVertices = data.inputValue(aMaxVertices).asInt(); - unsigned maxVertices = rawMaxVertices < 0 ? 0 : static_cast(rawMaxVertices); - bool closed = data.inputValue(aClosed).asBool(); - - icount = (icount < maxVertices) ? icount : static_cast (maxVertices); - if (icount < 2) { - data.setClean(aInTan); - data.setClean(aInTanLen); - data.setClean(aInTanX); - data.setClean(aInTanY); - data.setClean(aInTanZ); - data.setClean(aOutTan); - data.setClean(aOutTanLen); - data.setClean(aOutTanX); - data.setClean(aOutTanY); - data.setClean(aOutTanZ); - data.setClean(aOutTwistMat); - data.setClean(aOutTwistUp); - data.setClean(aOutTwistUpX); - data.setClean(aOutTwistUpY); - data.setClean(aOutTwistUpZ); - data.setClean(aTangents); - - return MS::kSuccess; - } - - // Don't care which plug I'm being asked for. Just compute all of 'em - std::vector tanData; - - for (unsigned i = 0; i < icount; ++i) { - TanData dat; - - vertInputs.jumpToArrayElement(i); - MDataHandle inHandle = vertInputs.inputValue(); - - dat.inTan.weight = inHandle.child(aInTanWeight).asDouble(); - dat.outTan.weight = inHandle.child(aOutTanWeight).asDouble(); - - dat.inTan.smooth = inHandle.child(aInSmooth).asDouble(); - dat.outTan.smooth = inHandle.child(aOutSmooth).asDouble(); - - dat.inTan.autoVal = inHandle.child(aInTanAuto).asDouble(); - dat.outTan.autoVal = inHandle.child(aOutTanAuto).asDouble(); - - MMatrix vmat = inHandle.child(aVertMat).asMatrix(); - dat.tfmMat = vmat; - dat.tfm = MVector(vmat(3, 0), vmat(3, 1), vmat(3, 2)); - dat.norm = MVector(vmat(1, 0), vmat(1, 1), vmat(1, 2)); - - dat.inTan.piMat = inHandle.child(aInParentInv).asMatrix(); - dat.outTan.piMat = inHandle.child(aOutParentInv).asMatrix(); - dat.piTwist = inHandle.child(aTwistParentInv).asMatrix(); - - dat.inTan.userMat = inHandle.child(aInTanMat).asMatrix(); - dat.outTan.userMat = inHandle.child(aOutTanMat).asMatrix(); - tanData.push_back(std::move(dat)); - } - - if (closed){ - auto &start = tanData[0]; - auto &end = tanData[tanData.size() - 1]; - start.inTan = end.inTan; - end.outTan = start.outTan; - } - - for (size_t i = 1; i < tanData.size(); ++i) { - auto &prev = tanData[i - 1]; - auto &cur = tanData[i]; - - cur.inTan.leg = prev.tfm - cur.tfm; - cur.inTan.legLen = cur.inTan.leg.length(); - cur.inTan.normLeg = cur.inTan.leg / cur.inTan.legLen; - - prev.outTan.leg = -cur.inTan.leg; - prev.outTan.legLen = cur.inTan.legLen; - prev.outTan.normLeg = -cur.inTan.normLeg; - } - - tanData[0].inTan.legLen = 0.0; - tanData[tanData.size() - 1].outTan.legLen = 0.0; - - buildSmoothMats(tanData, startTension, endTension, closed); - buildLinearTangents(tanData); - buildDoneTangents(tanData); - - auto outputs = data.outputArrayValue(aTangents); - auto builder = outputs.builder(); - for (size_t i = 0; i < tanData.size(); ++i) { - auto outHandle = builder.addElement(static_cast(i)); - auto &cur = tanData[i]; - - auto inTanHandle = outHandle.child(aInTan); - auto inPt = MPoint(cur.inTan.doneTan + cur.tfm) * cur.inTan.piMat; - inTanHandle.set3Double(inPt[0], inPt[1], inPt[2]); - - auto inTanLenHandle = outHandle.child(aInTanLen); - inTanLenHandle.setDouble(cur.inTan.doneTan.length()); - - auto outTanHandle = outHandle.child(aOutTan); - auto outPt = MPoint(cur.outTan.doneTan + cur.tfm) * cur.outTan.piMat; - outTanHandle.set3Double(outPt[0], outPt[1], outPt[2]); - - auto outTanLenHandle = outHandle.child(aOutTanLen); - outTanLenHandle.setDouble(cur.outTan.doneTan.length()); - - auto outMatHandle = outHandle.child(aOutTwistMat); - - MTransformationMatrix oriMat = cur.smoothMat * cur.piTwist; - outMatHandle.setMMatrix(oriMat.rotation().asMatrix()); - - auto outTwistHandle = outHandle.child(aOutTwistUp); - outTwistHandle.set3Double(cur.tfmMat(1, 0), cur.tfmMat(1, 1), cur.tfmMat(1, 2)); - } - - data.setClean(aInTan); - data.setClean(aInTanLen); - data.setClean(aInTanX); - data.setClean(aInTanY); - data.setClean(aInTanZ); - data.setClean(aOutTan); - data.setClean(aOutTanLen); - data.setClean(aOutTanX); - data.setClean(aOutTanY); - data.setClean(aOutTanZ); - data.setClean(aOutTwistMat); - data.setClean(aOutTwistUp); - data.setClean(aOutTwistUpX); - data.setClean(aOutTwistUpY); - data.setClean(aOutTwistUpZ); - data.setClean(aTangents); - - return MS::kSuccess; + if (plug != aInTanX && plug != aInTanY && plug != aInTanZ && plug != aInTan && + plug != aOutTanX && plug != aOutTanY && plug != aOutTanZ && plug != aOutTan && + plug != aInTanLen && plug != aOutTanLen && plug != aOutTwistUpX && plug != aOutTwistUpY && + plug != aOutTwistUpZ && plug != aOutTwistUp && plug != aOutTwistMat && plug != aTangents) { + return MS::kUnknownParameter; + } + + // Read everything + MArrayDataHandle vertInputs = data.inputArrayValue(aVertData); + unsigned icount = vertInputs.elementCount(); + + double startTension = data.inputValue(aStartTension).asDouble(); + double endTension = data.inputValue(aEndTension).asDouble(); + int rawMaxVertices = data.inputValue(aMaxVertices).asInt(); + unsigned maxVertices = rawMaxVertices < 0 ? 0 : static_cast(rawMaxVertices); + bool closed = data.inputValue(aClosed).asBool(); + + icount = (icount < maxVertices) ? icount : static_cast (maxVertices); + if (icount < 2) { + data.setClean(aInTan); + data.setClean(aInTanLen); + data.setClean(aInTanX); + data.setClean(aInTanY); + data.setClean(aInTanZ); + data.setClean(aOutTan); + data.setClean(aOutTanLen); + data.setClean(aOutTanX); + data.setClean(aOutTanY); + data.setClean(aOutTanZ); + data.setClean(aOutTwistMat); + data.setClean(aOutTwistUp); + data.setClean(aOutTwistUpX); + data.setClean(aOutTwistUpY); + data.setClean(aOutTwistUpZ); + data.setClean(aTangents); + + return MS::kSuccess; + } + + // Don't care which plug I'm being asked for. Just compute all of 'em + std::vector tanData; + + for (unsigned i = 0; i < icount; ++i) { + TanData dat; + + vertInputs.jumpToArrayElement(i); + MDataHandle inHandle = vertInputs.inputValue(); + + dat.inTan.weight = inHandle.child(aInTanWeight).asDouble(); + dat.outTan.weight = inHandle.child(aOutTanWeight).asDouble(); + + dat.inTan.smooth = inHandle.child(aInSmooth).asDouble(); + dat.outTan.smooth = inHandle.child(aOutSmooth).asDouble(); + + dat.inTan.autoVal = inHandle.child(aInTanAuto).asDouble(); + dat.outTan.autoVal = inHandle.child(aOutTanAuto).asDouble(); + + MMatrix vmat = inHandle.child(aVertMat).asMatrix(); + dat.tfmMat = vmat; + dat.tfm = MVector(vmat(3, 0), vmat(3, 1), vmat(3, 2)); + dat.norm = MVector(vmat(1, 0), vmat(1, 1), vmat(1, 2)); + + dat.inTan.piMat = inHandle.child(aInParentInv).asMatrix(); + dat.outTan.piMat = inHandle.child(aOutParentInv).asMatrix(); + dat.piTwist = inHandle.child(aTwistParentInv).asMatrix(); + + dat.inTan.userMat = inHandle.child(aInTanMat).asMatrix(); + dat.outTan.userMat = inHandle.child(aOutTanMat).asMatrix(); + tanData.push_back(std::move(dat)); + } + + if (closed){ + auto &start = tanData[0]; + auto &end = tanData[tanData.size() - 1]; + start.inTan = end.inTan; + end.outTan = start.outTan; + } + + for (size_t i = 1; i < tanData.size(); ++i) { + auto &prev = tanData[i - 1]; + auto &cur = tanData[i]; + + cur.inTan.leg = prev.tfm - cur.tfm; + cur.inTan.legLen = cur.inTan.leg.length(); + cur.inTan.normLeg = cur.inTan.leg / cur.inTan.legLen; + + prev.outTan.leg = -cur.inTan.leg; + prev.outTan.legLen = cur.inTan.legLen; + prev.outTan.normLeg = -cur.inTan.normLeg; + } + + tanData[0].inTan.legLen = 0.0; + tanData[tanData.size() - 1].outTan.legLen = 0.0; + + buildSmoothMats(tanData, startTension, endTension, closed); + buildLinearTangents(tanData); + buildDoneTangents(tanData); + + auto outputs = data.outputArrayValue(aTangents); + auto builder = outputs.builder(); + for (size_t i = 0; i < tanData.size(); ++i) { + auto outHandle = builder.addElement(static_cast(i)); + auto &cur = tanData[i]; + + auto inTanHandle = outHandle.child(aInTan); + auto inPt = MPoint(cur.inTan.doneTan + cur.tfm) * cur.inTan.piMat; + inTanHandle.set3Double(inPt[0], inPt[1], inPt[2]); + + auto inTanLenHandle = outHandle.child(aInTanLen); + inTanLenHandle.setDouble(cur.inTan.doneTan.length()); + + auto outTanHandle = outHandle.child(aOutTan); + auto outPt = MPoint(cur.outTan.doneTan + cur.tfm) * cur.outTan.piMat; + outTanHandle.set3Double(outPt[0], outPt[1], outPt[2]); + + auto outTanLenHandle = outHandle.child(aOutTanLen); + outTanLenHandle.setDouble(cur.outTan.doneTan.length()); + + auto outMatHandle = outHandle.child(aOutTwistMat); + + MTransformationMatrix oriMat = cur.smoothMat * cur.piTwist; + outMatHandle.setMMatrix(oriMat.rotation().asMatrix()); + + auto outTwistHandle = outHandle.child(aOutTwistUp); + outTwistHandle.set3Double(cur.tfmMat(1, 0), cur.tfmMat(1, 1), cur.tfmMat(1, 2)); + } + + data.setClean(aInTan); + data.setClean(aInTanLen); + data.setClean(aInTanX); + data.setClean(aInTanY); + data.setClean(aInTanZ); + data.setClean(aOutTan); + data.setClean(aOutTanLen); + data.setClean(aOutTanX); + data.setClean(aOutTanY); + data.setClean(aOutTanZ); + data.setClean(aOutTwistMat); + data.setClean(aOutTwistUp); + data.setClean(aOutTwistUpX); + data.setClean(aOutTwistUpY); + data.setClean(aOutTwistUpZ); + data.setClean(aTangents); + + return MS::kSuccess; } diff --git a/src/twistMultiTangentNode.h b/src/twistMultiTangentNode.h index 0fd3451..7df5462 100644 --- a/src/twistMultiTangentNode.h +++ b/src/twistMultiTangentNode.h @@ -32,52 +32,53 @@ SOFTWARE. class TwistMultiTangentNode : public MPxNode { public: TwistMultiTangentNode(); - virtual ~TwistMultiTangentNode(); + virtual ~TwistMultiTangentNode(); - virtual MStatus compute( const MPlug& plug, MDataBlock& data ); - static void* creator(); - static MStatus initialize(); + virtual MStatus compute( const MPlug& plug, MDataBlock& data ); + static void* creator(); + static MStatus initialize(); public: // inputs - static MObject aVertMat; - static MObject aInTanMat; - static MObject aOutTanMat; - static MObject aInTanWeight; - static MObject aOutTanWeight; - static MObject aInTanAuto; - static MObject aOutTanAuto; - static MObject aInSmooth; - static MObject aOutSmooth; - static MObject aInParentInv; - static MObject aOutParentInv; - static MObject aTwistParentInv; - static MObject aVertData; + static MObject aVertMat; + static MObject aInTanMat; + static MObject aOutTanMat; + static MObject aInTanWeight; + static MObject aOutTanWeight; + static MObject aInTanAuto; + static MObject aOutTanAuto; + static MObject aInSmooth; + static MObject aOutSmooth; + static MObject aInParentInv; + static MObject aOutParentInv; + static MObject aTwistParentInv; + static MObject aVertData; - static MObject aStartTension; - static MObject aEndTension; - static MObject aMaxVertices; - static MObject aClosed; + static MObject aStartTension; + static MObject aEndTension; + static MObject aMaxVertices; + static MObject aClosed; // outputs - static MObject aInTanX; - static MObject aInTanY; - static MObject aInTanZ; - static MObject aInTan; - static MObject aOutTanX; - static MObject aOutTanY; - static MObject aOutTanZ; - static MObject aOutTan; - static MObject aInTanLen; - static MObject aOutTanLen; - static MObject aOutTwistUpX; - static MObject aOutTwistUpY; - static MObject aOutTwistUpZ; - static MObject aOutTwistUp; - static MObject aOutTwistMat; - static MObject aTangents; + static MObject aInTanX; + static MObject aInTanY; + static MObject aInTanZ; + static MObject aInTan; + static MObject aOutTanX; + static MObject aOutTanY; + static MObject aOutTanZ; + static MObject aOutTan; + static MObject aInTanLen; + static MObject aOutTanLen; + static MObject aOutTwistUpX; + static MObject aOutTwistUpY; + static MObject aOutTwistUpZ; + static MObject aOutTwistUp; + static MObject aOutTwistMat; + static MObject aTangents; + + static MTypeId id; - static MTypeId id; }; diff --git a/src/twistSplineData.cpp b/src/twistSplineData.cpp index 48d0901..c725ac5 100644 --- a/src/twistSplineData.cpp +++ b/src/twistSplineData.cpp @@ -29,7 +29,7 @@ const MTypeId TwistSplineData::id(0x001226FB); const MString TwistSplineData::typeName("TwistSplineData"); void* TwistSplineData::creator(){ - return new TwistSplineData; + return new TwistSplineData; } TwistSplineData::TwistSplineData() @@ -61,11 +61,11 @@ std::shared_ptr TwistSplineData::getSharedSpline(){ } MTypeId TwistSplineData::typeId() const { - return TwistSplineData::id; + return TwistSplineData::id; } MString TwistSplineData::name() const { - return TwistSplineData::typeName; + return TwistSplineData::typeName; } MStatus TwistSplineData::readASCII(const MArgList& args, unsigned& lastParsedElement) { diff --git a/src/twistSplineData.h b/src/twistSplineData.h index ea27a20..c9dcccb 100644 --- a/src/twistSplineData.h +++ b/src/twistSplineData.h @@ -41,28 +41,28 @@ typedef TwistSpline getSharedSpline() const; - std::shared_ptr getSharedSpline(); + // Data access + const std::shared_ptr getSharedSpline() const; + std::shared_ptr getSharedSpline(); - // static methods and data. - MTypeId typeId() const; - MString name() const; - static const MString typeName; - static const MTypeId id; - static void* creator(); + // static methods and data. + MTypeId typeId() const; + MString name() const; + static const MString typeName; + static const MTypeId id; + static void* creator(); private: - std::shared_ptr _twistSpline; + std::shared_ptr _twistSpline; }; diff --git a/src/twistSplineNode.cpp b/src/twistSplineNode.cpp index 3c402f2..9920054 100644 --- a/src/twistSplineNode.cpp +++ b/src/twistSplineNode.cpp @@ -55,14 +55,14 @@ SOFTWARE. #include "twistSplineNode.h" #define MCHECKERROR(STAT) \ - if (MS::kSuccess != STAT) { \ - return MS::kFailure; \ - } + if (MS::kSuccess != STAT) { \ + return MS::kFailure; \ + } -MTypeId TwistSplineNode::id(0x001226F7); -MString TwistSplineNode::drawDbClassification("drawdb/geometry/twistSpline"); -MString TwistSplineNode::drawRegistrantId("TwistSplineNodePlugin"); +MTypeId TwistSplineNode::id(0x001226F7); +MString TwistSplineNode::drawDbClassification("drawdb/geometry/twistSpline"); +MString TwistSplineNode::drawRegistrantId("TwistSplineNodePlugin"); MObject TwistSplineNode::aOutputSpline; MObject TwistSplineNode::aSplineLength; @@ -172,7 +172,7 @@ MStatus TwistSplineNode::initialize() { addAttribute(aVertexData); - std::vector ins, outs, lenup; + std::vector ins, outs, lenup; ins.push_back(&aScaleCompensation); ins.push_back(&aInTangent); ins.push_back(&aControlVertex); @@ -278,7 +278,7 @@ void TwistSplineNode::getDebugDraw(bool &oDraw, double &oScale) const { } -MStatus TwistSplineNode::compute(const MPlug& plug, MDataBlock& data) { +MStatus TwistSplineNode::compute(const MPlug& plug, MDataBlock& data) { if (plug == aOutputSpline) { MStatus status; @@ -309,8 +309,8 @@ MStatus TwistSplineNode::compute(const MPlug& plug, MDataBlock& data) { MArrayDataHandle inputs = data.inputArrayValue(aVertexData); unsigned ecount = inputs.elementCount(); - // Trim the number of vertices to the maximum provided by the user - if (maxVertices < ecount) { ecount = maxVertices; } + // Trim the number of vertices to the maximum provided by the user + if (maxVertices < ecount) { ecount = maxVertices; } // I'm OK with just looping over the physical indices here // because if it's unconnected, then I don't really care @@ -395,9 +395,9 @@ MStatus TwistSplineNode::compute(const MPlug& plug, MDataBlock& data) { //if (points.length() != 0) outSpline->setVerts(points, scales, quats, lockPositions, lockVals, userTwist, twistLock, orientLock); - // Testing closest point - //outSpline->buildKDTree(); - //auto cp = outSpline->getClosestPoint(MPoint()); + // Testing closest point + //outSpline->buildKDTree(); + //auto cp = outSpline->getClosestPoint(MPoint()); storageH.setMPxData(outSplineData); data.setClean(aOutputSpline); diff --git a/src/twistSplineNode.h b/src/twistSplineNode.h index 272788e..a22d296 100644 --- a/src/twistSplineNode.h +++ b/src/twistSplineNode.h @@ -53,7 +53,7 @@ class TwistSplineNode : public MPxLocatorNode { public: TwistSplineNode(); - virtual ~TwistSplineNode(); + virtual ~TwistSplineNode(); virtual MStatus compute(const MPlug& plug, MDataBlock& data); MStatus setDependentsDirty(const MPlug& plug, MPlugArray& plugArray) override; @@ -66,7 +66,7 @@ class TwistSplineNode : public MPxLocatorNode MObjectArray& monitoredAttributes) const override; void postConstructor() override; static void* creator(); - static MStatus initialize(); + static MStatus initialize(); virtual bool isBounded() const { return true; } virtual MBoundingBox boundingBox() const; std::shared_ptr getSplineData() const; diff --git a/src/twistSplineUtils.h b/src/twistSplineUtils.h index 2630375..fa55f63 100644 --- a/src/twistSplineUtils.h +++ b/src/twistSplineUtils.h @@ -64,10 +64,10 @@ inline Vector reject(const Vector &onto, const Vector &n) { template inline Quat qmult(const Quat &q, const Quat &r){ - return Quat(r[0]*q[0]-r[1]*q[1]-r[2]*q[2]-r[3]*q[3], - r[0]*q[1]+r[1]*q[0]-r[2]*q[3]+r[3]*q[2], - r[0]*q[2]+r[1]*q[3]+r[2]*q[0]-r[3]*q[1], - r[0]*q[3]-r[1]*q[2]+r[2]*q[1]+r[3]*q[0]); + return Quat(r[0]*q[0]-r[1]*q[1]-r[2]*q[2]-r[3]*q[3], + r[0]*q[1]+r[1]*q[0]-r[2]*q[3]+r[3]*q[2], + r[0]*q[2]+r[1]*q[3]+r[2]*q[0]-r[3]*q[1], + r[0]*q[3]-r[1]*q[2]+r[2]*q[1]+r[3]*q[0]); } template diff --git a/src/twistTangentNode.cpp b/src/twistTangentNode.cpp index 22a3986..0b7392e 100644 --- a/src/twistTangentNode.cpp +++ b/src/twistTangentNode.cpp @@ -42,7 +42,7 @@ SOFTWARE. #define CHECKSTAT(m) if (!status) {status.perror(m); return status;}; -MTypeId TwistTangentNode::id(0x001226FA); +MTypeId TwistTangentNode::id(0x001226FA); MObject TwistTangentNode::aOutLinearTarget; MObject TwistTangentNode::aOutLinearTargetX; @@ -326,7 +326,7 @@ MStatus TwistTangentNode::compute(const MPlug& plug, MDataBlock& data) { MVector nextTfm = nextTMat.getTranslation(MSpace::kWorld); double weight = weightH.asDouble(); - MVector curNrm = curTMat.asMatrix()[1]; + MVector curNrm = curTMat.asMatrix()[1]; MVector preLeg = preTfm - curTfm; MVector nextLeg = nextTfm - curTfm; @@ -346,7 +346,7 @@ MStatus TwistTangentNode::compute(const MPlug& plug, MDataBlock& data) { // If we're in a straight line, default to using the local // y-axis as the up-direction //nrm = MVector(0.0, 1.0, 0.0); - nrm = curNrm; + nrm = curNrm; bin = (nrm ^ tan).normal(); nrm = (tan ^ bin).normal(); smo = nextLeg / 3.0; @@ -358,7 +358,7 @@ MStatus TwistTangentNode::compute(const MPlug& plug, MDataBlock& data) { smo = tan * (nextLegLen / 3.0); //nrm = MVector(0.0, 1.0, 0.0); - nrm = curNrm; + nrm = curNrm; bin = (nrm ^ tan).normal(); nrm = (tan ^ bin).normal(); @@ -376,7 +376,7 @@ MStatus TwistTangentNode::compute(const MPlug& plug, MDataBlock& data) { smo = smo * (nextLegLen / 3.0); //nrm = MVector(0.0, 1.0, 0.0); - nrm = curNrm; + nrm = curNrm; bin = (nrm ^ tan).normal(); nrm = (tan ^ bin).normal(); @@ -393,9 +393,9 @@ MStatus TwistTangentNode::compute(const MPlug& plug, MDataBlock& data) { // x-> tan, y-> nrm, z->bin double mm[4][4] = { - {tan[0], tan[1], tan[2], 0.0}, - {nrm[0], nrm[1], nrm[2], 0.0}, - {bin[0], bin[1], bin[2], 0.0}, + {tan[0], tan[1], tan[2], 0.0}, + {nrm[0], nrm[1], nrm[2], 0.0}, + {bin[0], bin[1], bin[2], 0.0}, {curTfm[0], curTfm[1], curTfm[2], 1.0} }; MMatrix outMat(mm); diff --git a/src/twistTangentNode.h b/src/twistTangentNode.h index 5d555aa..377ea4b 100644 --- a/src/twistTangentNode.h +++ b/src/twistTangentNode.h @@ -33,11 +33,11 @@ SOFTWARE. class TwistTangentNode : public MPxNode { public: TwistTangentNode(); - virtual ~TwistTangentNode(); + virtual ~TwistTangentNode(); - virtual MStatus compute( const MPlug& plug, MDataBlock& data ); - static void* creator(); - static MStatus initialize(); + virtual MStatus compute(const MPlug& plug, MDataBlock& data); + static void* creator(); + static MStatus initialize(); void postConstructor() override; public: @@ -80,7 +80,7 @@ class TwistTangentNode : public MPxNode { static MObject aBackpoint; static MObject aEndpoint; - static MTypeId id; + static MTypeId id; };