bool ToMayaMatrixVectorDataConverter<F>::doConversion( IECore::ConstObjectPtr from, MObject &to, IECore::ConstCompoundObjectPtr operands ) const
{
MStatus s;
typename F::ConstPtr data = IECore::runTimeCast<const F>( from );
if( !data )
{
return false;
}
MFnDoubleArrayData fnData;
const typename F::ValueType &v = data->readable();
MDoubleArray array;
array.setLength( v.size() * 16 );
for ( unsigned i=0; i < v.size(); i++ )
{
for ( unsigned j=0; j < 4; j++ )
{
for ( unsigned k=0; k < 4; k++ )
{
array[ i*16 + j*4 + k ] = (double)v[i][j][k];
}
}
}
to = fnData.create( array, &s );
return s;
}
MStatus RemapArrayValuesNode::compute(const MPlug& plug, MDataBlock& data)
{
if (plug != aOutput)
return MS::kUnknownParameter;
MStatus status;
MFnDoubleArrayData input(data.inputValue(aInput).data());
float inputMin = float(data.inputValue(aInputMin).asDouble());
float inputMax = float(data.inputValue(aInputMax).asDouble());
float outputMin = float(data.inputValue(aOutputMin).asDouble());
float outputMax = float(data.inputValue(aOutputMax).asDouble());
int size = input.length();
MDoubleArray outputArray(size);
MRampAttribute ramp(thisMObject(), aRamp, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
MFloatArray positions;
MFloatArray values;
MIntArray interps;
MIntArray indices;
ramp.getEntries(indices, positions, values, interps);
int numIndices = indices.length();
float inValue = 0.0;
float outValue = 0.0;
for (int i = 0; i < size; i++)
{
inValue = float(input[i]);
inValue = remapValue(inValue, inputMin, inputMax);
if (numIndices > 0)
{
ramp.getValueAtPosition(inValue, outValue, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
} else {
outValue = inValue;
}
outValue = remapValue(outValue, 0.0, 1.0, outputMin, outputMax);
outputArray.set(double(outValue), i);
}
MDataHandle outputHandle = data.outputValue(aOutput);
MFnDoubleArrayData output;
MObject outputData = output.create(outputArray);
outputHandle.setMObject(outputData);
outputHandle.setClean();
return MS::kSuccess;
}
void
VertexPolyColourCommand::WriteColoursToNode(MDagPath& dagPath, MColorArray& colors, bool isSource)
{
MStatus status;
// Try to find the colour node attached to the mesh
// If it's not found, create it
MObject ourNode;
if (!FindNodeOnMesh(dagPath,ourNode))
{
CreateNodeOnMesh(dagPath, ourNode);
}
// Send the selection to the node
{
// Pass the component list down to the node.
// To do so, we create/retrieve the current plug
// from the uvList attribute on the node and simply
// set the value to our component list.
//
MDoubleArray dcols;
dcols.setLength(colors.length()*4);
int idx = 0;
for (unsigned int i=0; i<colors.length(); i++)
{
dcols[idx] = (double)colors[i].r; idx++;
dcols[idx] = (double)colors[i].g; idx++;
dcols[idx] = (double)colors[i].b; idx++;
dcols[idx] = (double)colors[i].a; idx++;
}
MFnDoubleArrayData wrapper;
wrapper.create(dcols,&status);
MPlug* colourPlug = NULL;
if (isSource)
{
colourPlug = new MPlug(ourNode, PolyColourNode::m_colors);
}
else
{
colourPlug = new MPlug(ourNode, PolyColourNode::m_colorsDest);
}
// Warning, we have to do this as GCC doesn't like to pass by temporary reference
MObject wrapperObjRef = wrapper.object();
status = colourPlug->setValue(wrapperObjRef);
delete colourPlug;
}
}
MStatus ArrayAngleConstructorNode::compute(const MPlug& plug, MDataBlock& data)
{
if (plug != aOutput)
return MS::kUnknownParameter;
MStatus status;
int index;
MArrayDataHandle inputArrayHandle = data.inputArrayValue(aInput);
int inputSize = inputArrayHandle.elementCount();
int outputSize = data.inputValue(aSize).asInt();
MDoubleArray outputArray(outputSize);
MAngle::Unit uiUnit = MAngle::uiUnit();
for (int i = 0; i < inputSize; i++)
{
index = inputArrayHandle.elementIndex();
if (index >= outputSize) break;
if (uiUnit == MAngle::kRadians)
{
outputArray[index] = inputArrayHandle.inputValue().asAngle().asRadians();
} else {
outputArray[index] = inputArrayHandle.inputValue().asAngle().asDegrees();
}
if (!inputArrayHandle.next()) break;
}
MFnDoubleArrayData outputArrayData;
MObject outputData = outputArrayData.create(outputArray, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
MDataHandle outputHandle = data.outputValue(aOutput);
outputHandle.setMObject(outputData);
outputHandle.setClean();
return MS::kSuccess;
}
MStatus wingVizNode::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
if(plug == aoutval)
{
//double dtime = data.inputValue( aframe ).asDouble();
MTime currentTime = data.inputValue(atime, &status).asTime();
float ns = data.inputValue(anoisize).asFloat();
float nf = data.inputValue(anoifreq).asFloat();
int nd = data.inputValue(anoiseed).asInt();
MObject ogrow = data.inputValue(agrowth).asNurbsSurfaceTransformed();
//MArrayDataHandle hArray = data.inputArrayValue(agrowth);
//int n_obs = hArray.elementCount();
//MObjectArray obslist;
//for(int iter=0; iter<n_obs; iter++)
//{
// obslist.append(hArray.inputValue().asNurbsSurfaceTransformed());
// hArray.next();
//}
//if(!ogrow.isNull()) m_base->setGrow(ogrow);
m_base->setNoise(ns, nf, nd);
m_base->setTime(currentTime.value());
m_base->setNurbs(ogrow);
//m_base->setWind(m_wind);
/*int frame = (int)currentTime.value();
i_show_v = 0;
if(data.inputValue(amaxframe, &status).asInt() == 1)
{
i_show_v = 1;
char file_name[512];
sprintf( file_name, "%s/%s.%d.xvn", m_cachename.asChar(), MFnDependencyNode(thisMObject()).name().asChar(), frame );
int start = data.inputValue(aminframe, &status).asInt();
if(start == frame)
{
m_frame_pre = start;
//m_base->init();
m_base->save(file_name);
}
else if(m_frame_pre+1 == frame)
{
m_frame_pre++;
//m_base->update();
m_base->save(file_name);
}
}*/
}
if(plug== outMesh)
{
MObject ogrow = data.inputValue(agrowth).asNurbsSurfaceTransformed();
m_base->setNurbs(ogrow);
float w0 = data.inputValue(ashaft0).asFloat();
float w1 = data.inputValue(ashaft1).asFloat();
float fw0 = data.inputValue(awidth0).asFloat();
float fw1 = data.inputValue(awidth1).asFloat();
float e0 = data.inputValue(aedge0).asFloat();
float e1 = data.inputValue(aedge1).asFloat();
float t0 = data.inputValue(atwist0).asFloat();
float t1 = data.inputValue(atwist1).asFloat();
int r = data.inputValue(areverse).asInt();
int s = data.inputValue(astep).asInt();
m_base->setReverse(r);
m_base->setFeatherWidth(fw0, fw1);
m_base->setFeatherEdge(e0, e1);
m_base->setShaftWidth(w0, w1);
m_base->setFeatherTwist(t0, t1);
m_base->setStep(s);
MObject outMeshData = m_base->createFeather();
//zDisplayFloat3(m_base->getSeed(), m_base->getSeed1(), m_base->getFract());
MDataHandle meshh = data.outputValue(outMesh, &status);
meshh.set(outMeshData);
data.setClean(plug);
}
if(plug== aouttexcoordoffsetpp)
{
MDoubleArray coeff_array;
m_base->getTexcoordOffset(coeff_array);
MFnDoubleArrayData coeffFn;
MObject coeffOutputData = coeffFn.create( coeff_array, &status );
MDataHandle coeffh = data.outputValue( plug, &status);
coeffh.set(coeffOutputData);
data.setClean(plug);
}
return MS::kUnknownParameter;
}
//-----------------------------------------------------------------------
MStatus visualizeMeshNode::initialize()
//-----------------------------------------------------------------------
{
MStatus stat;
MFnNumericAttribute numericAttr;
MFnTypedAttribute typedAttr;
//!!!####################################################
//COLOR
//!!!####################################################
vtxColorObj = numericAttr.createColor("aColor","col");
numericAttr.setKeyable(true);
numericAttr.setStorable(true);
numericAttr.setDefault(1.0,0.0,0.1);
//!!!####################################################
//COLOR2
//!!!####################################################
vtxColorObj2 = numericAttr.createColor("aColor2","col2");
numericAttr.setKeyable(true);
numericAttr.setStorable(true);
numericAttr.setDefault(1.0,0.785,0.0);
//!!!####################################################
//DRAWING ENABLED
//!!!####################################################
drawingEnabled = numericAttr.create( "drawingEnabled", "en",
MFnNumericData::kBoolean, 1, &stat );
numericAttr.setKeyable(true);
numericAttr.setStorable(true);
if (!stat) {
stat.perror("create drawingEnabled attribute");
return stat;
}
/* // Dieses Feature ist eigentlich ziemlich unnötig
//!!!####################################################
//SHOW ORIGINAL MESH
//!!!####################################################
showOriginalObj = numericAttr.create( "showOriginal", "so",
MFnNumericData::kBoolean, 1, &stat );
numericAttr.setKeyable(true);
numericAttr.setStorable(true);
if (!stat) {
stat.perror("create showOriginal attribute");
return stat;
}
*/
//!!!####################################################
//POINTSIZE
//!!!####################################################
pointSize = numericAttr.create( "pointSize", "ps",
MFnNumericData::kFloat, 10.0, &stat );
numericAttr.setKeyable(true);
numericAttr.setStorable(true);
if (!stat) {
stat.perror("create pointSize attribute");
return stat;
}
//!!!####################################################
//INPUT MESH
//!!!####################################################
inputMesh = typedAttr.create( "inputMesh", "is",
MFnMeshData::kMesh, &stat);
if (!stat) {
stat.perror("create inputMesh attribute");
return stat;
}
//!!!####################################################
//VTXLOCATIONS (DUMMY OUT)
//!!!####################################################
vtxLocations = numericAttr.create( "vtxLocations", "cv",
MFnNumericData::kBoolean,1, &stat);
if (!stat) {
stat.perror("create vtxLocations attribute");
return stat;
}
//!!!####################################################
//VTXWEIGHTS
//!!!####################################################
vtxWeights = typedAttr.create( "vtxWeights", "vw",
MFnData::kDoubleArray, &stat);
if (!stat) {
stat.perror("create vtxLocations attribute");
return stat;
}
MFnDoubleArrayData defaultWeights;
typedAttr.setDefault(defaultWeights.create());
/*
//!!!####################################################
//IN MATRIX (TRANSFORMATIONMATRIX FÜR DAS VTSSET)
//!!!####################################################
//matrix
matrixAttr = typedAttr.create( "inMatrix","imat", MFnData::kMatrix);
MFnMatrixData matrixData;
typedAttr.setDefault(matrixData.create());
*/
#ifdef DEBUG
//!!!####################################################
//DEBUG PARAMETER: FÜR POLYOFFSET
//!!!####################################################
//matrix
pOffset1Obj = numericAttr.create( "offsetValue1", "ov1",
MFnNumericData::kFloat, 0.45, &stat );
numericAttr.setKeyable(true);
numericAttr.setStorable(true);
pOffset2Obj = numericAttr.create( "offsetValue2", "ov2",
MFnNumericData::kFloat, 0.55, &stat );
numericAttr.setKeyable(true);
numericAttr.setStorable(true);
#endif
//Attribute hinzufügen
//------------------------
stat = addAttribute (drawingEnabled);
if (!stat) { stat.perror("addAttribute");
return stat;}
stat = addAttribute (pointSize);
if (!stat) { stat.perror("addAttribute");
return stat;}
stat = addAttribute (inputMesh);
if (!stat) { stat.perror("addAttribute");
return stat;}
stat = addAttribute (vtxLocations);
if (!stat) { stat.perror("addAttribute");
return stat;}
stat = addAttribute (vtxColorObj);
if (!stat) { stat.perror("addAttribute");
return stat;}
stat = addAttribute (vtxColorObj2);
if (!stat) { stat.perror("addAttribute");
return stat;}
stat = addAttribute (vtxWeights);
if (!stat) { stat.perror("addAttribute");
return stat;}
/*
stat = addAttribute (matrixAttr);
if (!stat) { stat.perror("addAttribute");
return stat;}
*/
#ifdef DEBUG
stat = addAttribute( pOffset1Obj );
if (!stat) { stat.perror("addAttribute");
return stat;}
stat = addAttribute( pOffset2Obj );
if (!stat) { stat.perror("addAttribute");
return stat;}
#endif
//Affections setzen
//------------------------
stat = attributeAffects(vtxWeights, vtxLocations );
if (!stat) { stat.perror("attributeAffects");
return stat;}
stat = attributeAffects(inputMesh, vtxLocations );
if (!stat) { stat.perror("attributeAffects");
return stat;}
// Die Parameter müssen die computeMethod aufrufen
#ifdef DEBUG
stat = attributeAffects(pOffset1Obj, vtxLocations );
if (!stat) { stat.perror("attributeAffects");
return stat;}
stat = attributeAffects(pOffset2Obj, vtxLocations );
if (!stat) { stat.perror("attributeAffects");
return stat;}
#endif
return MS::kSuccess;
}
MStatus ModifyArrayNode::compute(const MPlug& plug, MDataBlock& data)
{
if (plug != aOutput)
return MS::kUnknownParameter;
MStatus status;
MFnDoubleArrayData inputArray(data.inputValue(aInput).data());
short op = data.inputValue(aOperation).asShort();
bool reverse = data.inputValue(aReverse).asBool();
int inputSize = int(inputArray.length());
int outputSize = 0;
switch (op)
{
case kREFLECT_LEFT:
case kREFLECT_RIGHT:
outputSize = max(0, inputSize * 2 - 1);
break;
default:
outputSize = inputSize;
break;
}
std::vector<double> values = std::vector<double>(outputSize);
MDoubleArray outputArray(outputSize);
int index = 0;
switch (op)
{
case kNO_OP:
for (int i = 0; i < outputSize; i++)
values[i] = inputArray[i];
break;
case kSORT:
for (int i = 0; i < outputSize; i++)
values[i] = inputArray[i];
std::sort(values.begin(), values.end());
break;
case kABS:
for (int i = 0; i < outputSize; i++)
values[i] = abs(inputArray[i]);
break;
case kREFLECT_LEFT:
for (int i = inputSize - 1; i > 0; i--)
{
values[index] = inputArray[i];
index++;
}
for (int i = 0; i < inputSize; i++)
{
values[index] = inputArray[i];
index++;
}
break;
case kREFLECT_RIGHT:
for (int i = 0; i < inputSize - 1; i++)
{
values[index] = inputArray[i];
index++;
}
for (int i = inputSize - 1; i >= 0; i--)
{
values[index] = inputArray[i];
index++;
}
break;
}
for (int i = 0; i < outputSize; i++)
{
index = reverse ? outputSize - i - 1 : i;
outputArray[i] = values[index];
}
MDataHandle outputHandle = data.outputValue(this->aOutput);
MFnDoubleArrayData output;
MObject outputData = output.create(outputArray);
outputHandle.setMObject(outputData);
outputHandle.setClean();
return MS::kSuccess;
}
MStatus ProxyViz::initialize()
{
MFnNumericAttribute numFn;
MStatus stat;
alodgatehigh = numFn.create( "lodGateMax", "ldmx", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
numFn.setMax(2.f);
addAttribute(alodgatehigh);
alodgatelow = numFn.create( "lodGateMin", "ldmin", MFnNumericData::kFloat, 0.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.f);
numFn.setMax(0.999f);
addAttribute(alodgatelow);
abboxminx = numFn.create( "bBoxMinX", "bbmnx", MFnNumericData::kFloat, -1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxminx);
abboxminy = numFn.create( "bBoxMinY", "bbmny", MFnNumericData::kFloat, -1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxminy);
abboxminz = numFn.create( "bBoxMinZ", "bbmnz", MFnNumericData::kFloat, -1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxminz);
abboxmaxx = numFn.create( "bBoxMaxX", "bbmxx", MFnNumericData::kFloat, 1.f );
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxmaxx);
abboxmaxy = numFn.create( "bBoxMaxY", "bbmxy", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxmaxy);
abboxmaxz = numFn.create( "bBoxMaxZ", "bbmxz", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
addAttribute(abboxmaxz);
aradiusMult = numFn.create( "radiusMultiplier", "rml", MFnNumericData::kFloat);
numFn.setStorable(true);
numFn.setKeyable(true);
numFn.setDefault(1.f);
numFn.setMin(.05f);
addAttribute(aradiusMult);
axmultiplier = numFn.create( "visualMultiplierX", "vmx", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
addAttribute(axmultiplier);
aymultiplier = numFn.create( "visualMultiplierY", "vmy", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
addAttribute(aymultiplier);
azmultiplier = numFn.create( "visualMultiplierZ", "vmz", MFnNumericData::kFloat, 1.f);
numFn.setKeyable(true);
numFn.setStorable(true);
numFn.setMin(0.001f);
addAttribute(azmultiplier);
agroupcount = numFn.create( "numberInstances", "nis", MFnNumericData::kInt, 1);
numFn.setKeyable(false);
numFn.setStorable(true);
numFn.setMin(1);
addAttribute(agroupcount);
ainstanceId = numFn.create( "instanceId", "iis", MFnNumericData::kInt, 0);
numFn.setKeyable(false);
numFn.setStorable(true);
numFn.setMin(0);
addAttribute(ainstanceId);
MFnTypedAttribute typedAttrFn;
MVectorArray defaultVectArray;
MFnVectorArrayData vectArrayDataFn;
vectArrayDataFn.create( defaultVectArray );
outPositionPP = typedAttrFn.create( "outPosition",
"opos",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
if(!stat) MGlobal::displayWarning("failed create pospp");
typedAttrFn.setStorable(false);
if(addAttribute( outPositionPP ) != MS::kSuccess) MGlobal::displayWarning("failed add pospp");
outScalePP = typedAttrFn.create( "outScale",
"oscl",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
if(!stat) MGlobal::displayWarning("failed create sclpp");
typedAttrFn.setStorable(false);
if(addAttribute(outScalePP) != MS::kSuccess) MGlobal::displayWarning("failed add sclpp");
outRotationPP = typedAttrFn.create( "outRotation",
"orot",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
if(!stat) MGlobal::displayWarning("failed create rotpp");
typedAttrFn.setStorable(false);
if(addAttribute(outRotationPP) != MS::kSuccess) MGlobal::displayWarning("failed add rotpp");
MDoubleArray defaultDArray;
MFnDoubleArrayData dArrayDataFn;
dArrayDataFn.create( defaultDArray );
outReplacePP = typedAttrFn.create( "outReplace", "orpl",
MFnData::kDoubleArray, dArrayDataFn.object(),
&stat );
if(stat != MS::kSuccess) {
MGlobal::displayWarning("failed create outReplace");
}
typedAttrFn.setStorable(false);
stat = addAttribute(outReplacePP);
if(stat != MS::kSuccess) {
MGlobal::displayWarning("failed add outReplace");
}
outValue = numFn.create( "outValue", "ov", MFnNumericData::kFloat );
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(outValue);
outValue1 = numFn.create( "outValue1", "ov1", MFnNumericData::kFloat );
numFn.setStorable(false);
numFn.setWritable(false);
addAttribute(outValue1);
MFnTypedAttribute stringAttr;
acachename = stringAttr.create( "cachePath", "cp", MFnData::kString );
stringAttr.setStorable(true);
addAttribute( acachename );
astandinNames = stringAttr.create( "standinNames", "sdn", MFnData::kString );
stringAttr.setStorable(true);
stringAttr.setArray(true);
addAttribute(astandinNames);
MFnMatrixAttribute matAttr;
acameraspace = matAttr.create( "cameraSpace", "cspc", MFnMatrixAttribute::kDouble );
matAttr.setStorable(false);
matAttr.setWritable(true);
matAttr.setConnectable(true);
addAttribute(acameraspace);
ahapeture = numFn.create( "horizontalFilmAperture", "hfa", MFnNumericData::kDouble, 1.0 );
numFn.setStorable(false);
numFn.setConnectable(true);
addAttribute( ahapeture );
avapeture = numFn.create( "verticalFilmAperture", "vfa", MFnNumericData::kDouble, 1.0 );
numFn.setStorable(false);
numFn.setConnectable(true);
addAttribute( avapeture );
afocallength = numFn.create( "focalLength", "fl", MFnNumericData::kDouble );
numFn.setStorable(false);
numFn.setConnectable(true);
addAttribute( afocallength );
aconvertPercentage = numFn.create( "convertPercentage", "cvp", MFnNumericData::kDouble );
numFn.setStorable(false);
numFn.setConnectable(true);
numFn.setDefault(1.0);
numFn.setMax(1.0);
numFn.setMin(0.01);
addAttribute(aconvertPercentage);
agroundMesh = typedAttrFn.create("groundMesh", "grdm", MFnMeshData::kMesh);
typedAttrFn.setStorable(false);
typedAttrFn.setWritable(true);
typedAttrFn.setConnectable(true);
typedAttrFn.setArray(true);
typedAttrFn.setDisconnectBehavior(MFnAttribute::kDelete);
addAttribute( agroundMesh );
attributeAffects(agroundMesh, outValue);
agroundSpace = matAttr.create("groundSpace", "grdsp", MFnMatrixAttribute::kDouble);
matAttr.setStorable(false);
matAttr.setWritable(true);
matAttr.setConnectable(true);
matAttr.setArray(true);
matAttr.setDisconnectBehavior(MFnAttribute::kDelete);
addAttribute( agroundSpace );
attributeAffects(agroundSpace, outValue);
MPointArray defaultPntArray;
MFnPointArrayData pntArrayDataFn;
pntArrayDataFn.create( defaultPntArray );
aplantTransformCache = typedAttrFn.create( "transformCachePlant",
"tmcpl",
MFnData::kPointArray,
pntArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantTransformCache);
MIntArray defaultIntArray;
MFnIntArrayData intArrayDataFn;
intArrayDataFn.create( defaultIntArray );
aplantIdCache = typedAttrFn.create( "idCachePlant",
"idcpl",
MFnData::kIntArray,
intArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantIdCache);
aplantTriangleIdCache = typedAttrFn.create( "triCachePlant",
"trcpl",
MFnData::kIntArray,
intArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantTriangleIdCache);
aplantTriangleCoordCache = typedAttrFn.create( "coordCachePlant",
"crcpl",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantTriangleCoordCache);
aplantOffsetCache = typedAttrFn.create( "offsetCachePlant",
"otcpl",
MFnData::kVectorArray,
vectArrayDataFn.object(),
&stat );
typedAttrFn.setStorable(true);
addAttribute(aplantOffsetCache);
ainexamp = typedAttrFn.create("inExample", "ixmp", MFnData::kPlugin);
typedAttrFn.setStorable(false);
typedAttrFn.setConnectable(true);
typedAttrFn.setArray(true);
addAttribute(ainexamp);
adisplayVox = numFn.create( "showVoxelThreshold", "svt", MFnNumericData::kFloat );
numFn.setDefault(1.0);
numFn.setMin(.7);
numFn.setMax(1.0);
numFn.setStorable(true);
numFn.setKeyable(true);
addAttribute(adisplayVox);
acheckDepth = numFn.create( "checkDepth", "cdp", MFnNumericData::kBoolean );
numFn.setDefault(0);
numFn.setStorable(false);
addAttribute(acheckDepth);
ainoverscan = numFn.create( "cameraOverscan", "cos", MFnNumericData::kDouble );
numFn.setDefault(1.33);
numFn.setStorable(false);
addAttribute(ainoverscan);
aactivated = numFn.create( "activated", "act", MFnNumericData::kBoolean );
numFn.setDefault(0);
numFn.setStorable(false);
addAttribute(aactivated);
attributeAffects(ainexamp, outValue1);
attributeAffects(aradiusMult, outValue1);
attributeAffects(abboxminx, outValue);
attributeAffects(abboxmaxx, outValue);
attributeAffects(abboxminy, outValue);
attributeAffects(abboxmaxy, outValue);
attributeAffects(abboxminz, outValue);
attributeAffects(abboxmaxz, outValue);
attributeAffects(outPositionPP, outValue);
return MS::kSuccess;
}
MStatus puttyNode::deform( MDataBlock& block, MItGeometry& iter, const MMatrix& worldMatrix, unsigned int multiIndex)
{
// MGlobal::displayInfo("deform");
MStatus status = MS::kSuccess;
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// get inputs
//
// get the node ready flag
MDataHandle dh = block.inputValue(aScriptSourced,&status);
SYS_ERROR_CHECK(status, "Error getting aScriptSourced data handle\n");
bool scriptSourced = dh.asBool();
if (!scriptSourced)
return MS::kSuccess;
dh = block.inputValue(aNodeReady,&status);
SYS_ERROR_CHECK(status, "Error getting node ready data handle\n");
bool nodeReady = dh.asBool();
// if it's not ready, don't do anything
if (!nodeReady)
return MS::kSuccess;
dh = block.inputValue(aDefSpace,&status);
SYS_ERROR_CHECK(status, "Error getting defSpace data handle\n");
short defSpace = dh.asShort();
dh = block.inputValue(aDefWeights,&status);
SYS_ERROR_CHECK(status, "Error getting defWeights data handle\n");
short defWeights = dh.asShort();
dh = block.inputValue(aDefEnvelope,&status);
SYS_ERROR_CHECK(status, "Error getting defEnvelope data handle\n");
short defEnvelope = dh.asShort();
// get the command
dh = block.inputValue(aCmdBaseName,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName handle\n");
MString script = dh.asString();
/* if (script == "")
{
status = MS::kFailure;
USER_ERROR_CHECK(status, "no script provided!\n");
}
*/
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// build mel cmd string
//
// check if it's a valid cmd
// get the envelope
//
double env = 1;
if (defEnvelope == MSD_ENVELOPE_AUTO)
{
dh = block.inputValue(envelope,&status);
SYS_ERROR_CHECK(status, "Error getting envelope data handle\n");
env = double(dh.asFloat());
// early stop 'cause there is nothing more to do
if (env == 0.0)
return MS::kSuccess;
}
// get the points, transform them into the right space if needed
//
int count = iter.count();
MVectorArray points(count);
for ( ; !iter.isDone(); iter.next())
points[iter.index()] = iter.position();
if ( defSpace == MSD_SPACE_WORLD )
{
for (int i = 0;i<count;i++)
points[i] = MPoint(points[i]) * worldMatrix;
}
// get the weights
//
MDoubleArray weights;
if ( defWeights == MSD_WEIGHTS_AUTO)
{
weights.setLength(count);
for (int i = 0;i<count;i++)
weights[i] = weightValue(block,multiIndex,i);
}
// get the object name and type
// get the input geometry, traverse through the data handles
MArrayDataHandle adh = block.outputArrayValue( input, &status );
SYS_ERROR_CHECK(status,"error getting input array data handle.\n");
status = adh.jumpToElement( multiIndex );
SYS_ERROR_CHECK(status, "input jumpToElement failed.\n");
// compound data
MDataHandle cdh = adh.inputValue( &status );
SYS_ERROR_CHECK(status, "error getting input inputValue\n");
// input geometry child
dh = cdh.child( inputGeom );
MObject dInputGeometry = dh.data();
// get the type
MString geometryType = dInputGeometry.apiTypeStr();
// get the name
// MFnDagNode dagFn( dInputGeometry, &status);
// SYS_ERROR_CHECK(status, "error converting geometry obj to dag node\n");
// MString geometryName = dagFn.fullPathName(&status);
// SYS_ERROR_CHECK(status, "error getting full path name \n");
// MString geometryType = "";
// MString geometryName = "";
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// set the current values on the temp plugs for the script to be picked up
//
// the position
MObject thisNode = thisMObject();
MPlug currPlug(thisNode,aCurrPosition);
MFnVectorArrayData vecD;
MObject currObj = vecD.create(points,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currPosPlug value\n");
// the weights
currPlug =MPlug(thisNode,aCurrWeight);
MFnDoubleArrayData dblD;
currObj = dblD.create(weights,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currWeightsPlug value\n");
// world matrix
currPlug =MPlug(thisNode,aCurrWorldMatrix);
MFnMatrixData matD;
currObj = matD.create(worldMatrix,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currWorldMatrixPlug value\n");
// the multi index
currPlug =MPlug(thisNode,aCurrMultiIndex);
currPlug.setValue(int(multiIndex));
SYS_ERROR_CHECK(status, "error setting currMultiIndexPlug value\n");
// geometry name/type
// currPlug =MPlug(thisNode,aCurrGeometryName);
// currPlug.setValue(geometryName);
// SYS_ERROR_CHECK(status, "error setting aCurrGeometryName value\n");
currPlug =MPlug(thisNode,aCurrGeometryType);
currPlug.setValue(geometryType);
SYS_ERROR_CHECK(status, "error setting aCurrGeometryType value\n");
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// execute the mel script
//
MString melCmd = script+"(\"" +name()+"\","+count+")";
MCommandResult melResult;
status = MGlobal::executeCommand(melCmd,melResult);
// if the command did not work, then try to resource the script
// (might have been that we were in a fresh scene and nothing was ready yet
if (status != MS::kSuccess)
{
dh = block.inputValue(aScript,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName handle\n");
MString scriptFile = dh.asString();
// try to source the script
MString cmd = "source \"" + scriptFile+"\"";
MCommandResult melResult;
status = MGlobal::executeCommand(cmd,melResult);
// if successfull, retry the command
if (!status.error())
{
status = MGlobal::executeCommand(melCmd,melResult);
}
}
USER_ERROR_CHECK(status, "Error executing mel command, please check the function you provided is valid, error free and has the appropriate parameters!");
// check the result type
if ((melResult.resultType()) != (MCommandResult::kDoubleArray))
{
USER_ERROR_CHECK(MS::kFailure, "result of mel command has wrong type, should be doubleArray (which will be interpreted as vectorArray)!");
}
// get the result as a double array
MDoubleArray newP;
status = melResult.getResult(newP);
USER_ERROR_CHECK(status, "Error getting result of mel command!");
int newCount = newP.length()/3;
// size check
if (newCount != count)
{
USER_ERROR_CHECK(MS::kFailure, "the size of the result does not match the size of the input!");
}
// convert the double array into a vector array
MPointArray newPoints(newCount);
for(int i=0;i<newCount;i++)
newPoints[i]=MPoint(newP[i*3],newP[i*3+1],newP[i*3+2]);
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// interprete and apply the result
//
// do the envelope and weights
if ((defEnvelope == MSD_ENVELOPE_AUTO)||((defWeights == MSD_WEIGHTS_AUTO)))
{
MDoubleArray envPP(count, env);
if (defWeights == MSD_WEIGHTS_AUTO)
{
for (int i = 0;i<count;i++)
envPP[i] *= weights[i];
}
// linear interpolation between old and new points
for (int i = 0;i<count;i++)
newPoints[i] = (points[i] * (1-envPP[i])) + (newPoints[i] * envPP[i]);
}
// retransform the result if it was in world space
if ( defSpace == MSD_SPACE_WORLD )
{
MMatrix worldMatrixInv = worldMatrix.inverse();
for (int i = 0;i<count;i++)
newPoints[i] *= worldMatrixInv;
}
// set the points
iter.reset();
for ( ; !iter.isDone(); iter.next())
iter.setPosition(newPoints[iter.index()]);
return status;
}
MStatus TCC::initialize()
{
MFnNumericAttribute numAttr;
MFnTypedAttribute attrFn;
MFnIntArrayData defaultIArrayDataFn;
MFnDoubleArrayData defaultDArrayDataFn;
MStatus stat;
aRes = numAttr.create( "SubdivisionResolution", "res", MFnNumericData::kInt, 3 );
aRefRes = numAttr.create( "SubdivisionRefinementResolution", "refres", MFnNumericData::kInt, 0 );
aLineThickness = numAttr.create( "UVLineThickness", "th", MFnNumericData::kFloat, 0 );
aInputMesh = attrFn.create("inputMesh", "inMesh", MFnMeshData::kMesh);
defaultIArrayDataFn.create( );
anFVc = attrFn.create("nFVcached", "nFVc", MFnData::kIntArray, defaultIArrayDataFn.object());
attrFn.setConnectable(false);
attrFn.setStorable(true);
defaultIArrayDataFn.create( );
aFc = attrFn.create("Fcached", "Fc", MFnData::kIntArray, defaultIArrayDataFn.object());
attrFn.setConnectable(false);
attrFn.setStorable(true);
defaultIArrayDataFn.create( );
aPole = attrFn.create("pole", "pole", MFnData::kIntArray, defaultIArrayDataFn.object());
attrFn.setConnectable(false);
attrFn.setStorable(true);
defaultIArrayDataFn.create( );
aCorner = attrFn.create("corner", "corner", MFnData::kIntArray, defaultIArrayDataFn.object());
attrFn.setConnectable(false);
attrFn.setStorable(true);
defaultIArrayDataFn.create( );
aT = attrFn.create("T", "T", MFnData::kIntArray, defaultIArrayDataFn.object());
attrFn.setConnectable(false);
attrFn.setStorable(true);
defaultIArrayDataFn.create( );
aEqc = attrFn.create("eqc", "eqc", MFnData::kIntArray, defaultIArrayDataFn.object());
attrFn.setConnectable(false);
attrFn.setStorable(true);
defaultDArrayDataFn.create( );
aItv = attrFn.create("itv", "itv", MFnData::kDoubleArray, defaultDArrayDataFn.object());
attrFn.setConnectable(false);
attrFn.setStorable(true);
defaultIArrayDataFn.create( );
aErr = attrFn.create("err", "err", MFnData::kIntArray, defaultIArrayDataFn.object());
attrFn.setConnectable(false);
attrFn.setStorable(true);
aOutputMesh = attrFn.create( "outputMesh", "out", MFnData::kMesh);
attrFn.setStorable(false);
attrFn.setWritable(false);
stat = addAttribute(aRes); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aRefRes); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aLineThickness); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aInputMesh); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(anFVc); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aFc); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aPole); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aCorner); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aT); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aEqc); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aItv); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aErr); McheckErr(stat, "ERROR adding attribute\n");
stat = addAttribute(aOutputMesh); McheckErr(stat, "ERROR adding attribute\n");
stat = attributeAffects(aRes, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(aRefRes, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(aLineThickness, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(aInputMesh, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(anFVc, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(aFc, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(aPole, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(aCorner, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(aT, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(aEqc, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(aItv, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
stat = attributeAffects(aErr, aOutputMesh); McheckErr(stat, "ERROR in attributeAffects\n");
return MS::kSuccess;
}
