// COMPUTE ======================================
MStatus gear_uToPercentage::compute(const MPlug& plug, MDataBlock& data)
{
MStatus returnStatus;
// Error check
if (plug != percentage)
return MS::kUnknownParameter;
// Curve
MFnNurbsCurve crv( data.inputValue( curve ).asNurbsCurve() );
// Sliders
bool in_normU = data.inputValue( normalizedU ).asBool();
double in_u = (double)data.inputValue( u ).asFloat();
unsigned in_steps = data.inputValue( steps ).asShort();
// Process
if (in_normU)
in_u = normalizedUToU(in_u, crv.numCVs());
// Get length
MVectorArray u_subpos(in_steps);
MVectorArray t_subpos(in_steps);
MPoint pt;
double step;
for (unsigned i = 0; i < in_steps ; i++){
step = i * in_u / (in_steps - 1.0);
crv.getPointAtParam(step, pt, MSpace::kWorld);
u_subpos[i] = MVector(pt);
step = i/(in_steps - 1.0);
crv.getPointAtParam(step, pt, MSpace::kWorld);
t_subpos[i] = MVector(pt);
}
double u_length = 0;
double t_length = 0;
MVector v;
for (unsigned i = 0; i < in_steps ; i++){
if (i>0){
v = u_subpos[i] - u_subpos[i-1];
u_length += v.length();
v = t_subpos[i] - t_subpos[i-1];
t_length += v.length();
}
}
double out_perc = (u_length / t_length) * 100;
// Output
MDataHandle h = data.outputValue( percentage );
h.setDouble( out_perc );
data.setClean( plug );
return MS::kSuccess;
}
MStatus ReduceArrayNode::compute(const MPlug& plug, MDataBlock& data)
{
if (plug != aOutput)
return MS::kUnknownParameter;
MStatus status;
MDataHandle inputHandle = data.inputValue(aInput, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
MFnDoubleArrayData inputArrayData(inputHandle.data());
MDoubleArray inputArray = inputArrayData.array();
int numInputs = inputArray.length();
short operation = data.inputValue(aOperation).asShort();
double output = numInputs > 0 ? inputArray[0] : 0.0;
if (operation == kLENGTH)
{
output = double(numInputs);
} else {
for (int i = 1; i < numInputs; i++)
{
output = computeOutput(output, inputArray[i], operation, status);
if (!status)
{
reportComputeError(this, operation);
break;
}
}
}
MDataHandle outputHandle = data.outputValue(this->aOutput);
outputHandle.setDouble(output);
outputHandle.setClean();
return MS::kSuccess;
}
// COMPUTE ======================================
MStatus gear_percentageToU::compute(const MPlug& plug, MDataBlock& data)
{
MStatus returnStatus;
// Error check
if (plug != percentage)
return MS::kUnknownParameter;
// Curve
MFnNurbsCurve crv( data.inputValue( curve ).asNurbsCurve() );
// Sliders
bool in_normU = data.inputValue( normalizedU ).asBool();
double in_percentage = (double)data.inputValue( percentage ).asFloat() * .01;
const unsigned in_steps = data.inputValue( steps ).asShort();
// Process
// Get length
MVectorArray u_subpos(in_steps);
MPoint pt;
MDoubleArray u_list(in_steps);
for(unsigned i = 0 ; i < in_steps ; i++ ){
u_list[i] = normalizedUToU(i /(in_steps - 1.0), crv.numCVs());
crv.getPointAtParam(u_list[i], pt, MSpace::kWorld);
u_subpos[i] = MVector(pt);
}
double t_length = 0;
MDoubleArray dist(in_steps);
MVector v;
for (unsigned i = 0; i < in_steps ; i++){
if (i>0){
v = u_subpos[i] - u_subpos[i-1];
t_length += v.length();
dist[i] = t_length;
}
}
MDoubleArray u_perc(in_steps);
for (unsigned i = 0; i < in_steps ; i++){
u_perc[i] = dist[i] / t_length;
}
// Get closest indices
unsigned index = findClosestInArray(in_percentage, u_perc);
unsigned indexA, indexB;
if (in_percentage <= u_perc[index]){
indexA = abs(int(index));
indexB = index;
if ( indexA > indexB){
indexA = indexB;
indexB = indexA+1;
}
}
else {
indexA = index;
indexB = index + 1;
}
// blend value
double blend = set01range(in_percentage, u_perc[indexA], u_perc[indexB]);
double out_u = linearInterpolate(u_list[indexA], u_list[indexB], blend);
if (in_normU)
out_u = uToNormalizedU(out_u, crv.numCVs());
// Ouput
MDataHandle h = data.outputValue( u );
h.setDouble( out_u );
data.setClean( plug );
return MS::kSuccess;
}
