void ProxyViz::saveInternal()
{
AHelper::Info<MString>("prxnode save internal", MFnDependencyNode(thisMObject()).name() );
updateNumPlants();
const unsigned n = numPlants();
AHelper::Info<unsigned>("num plants", n );
if(n<1) return;
MPointArray plantTms;
MIntArray plantIds;
MIntArray plantTris;
MVectorArray plantCoords;
MVectorArray plantOffsets;
savePlants(plantTms, plantIds, plantTris, plantCoords, plantOffsets);
MFnPointArrayData tmFn;
MObject otm = tmFn.create(plantTms);
MPlug tmPlug(thisMObject(), aplantTransformCache);
tmPlug.setValue(otm);
MFnIntArrayData idFn;
MObject oid = idFn.create(plantIds);
MPlug idPlug(thisMObject(), aplantIdCache);
idPlug.setValue(oid);
MFnIntArrayData triFn;
MObject otri = idFn.create(plantTris);
MPlug triPlug(thisMObject(), aplantTriangleIdCache);
triPlug.setValue(otri);
MFnVectorArrayData crdFn;
MObject ocrd = crdFn.create(plantCoords);
MPlug crdPlug(thisMObject(), aplantTriangleCoordCache);
crdPlug.setValue(ocrd);
MFnVectorArrayData cotFn;
MObject ocot = cotFn.create(plantOffsets);
MPlug cotPlug(thisMObject(), aplantOffsetCache);
cotPlug.setValue(ocot);
}
//
// Deform computation
//
MStatus jhMeshBlur::deform( MDataBlock& block,MItGeometry& iter,const MMatrix& m,unsigned int multiIndex)
{
MStatus returnStatus;
// Envelope
float envData = block.inputValue(envelope, &returnStatus).asFloat();
CHECK_MSTATUS(returnStatus);
if(envData == 0)
return MS::kFailure;
/*
VARIABLES
*/
//float factor = block.inputValue(aShapeFactor, &returnStatus).asFloat();
float fStrength = block.inputValue(aStrength, &returnStatus).asFloat();
CHECK_MSTATUS(returnStatus);
if (fStrength == 0)
return MS::kFailure;
float fThreshold = block.inputValue(aTreshhold, &returnStatus).asFloat();
CHECK_MSTATUS(returnStatus);
float fW = 0.0f; // weight
float fDistance;
fStrength *= envData;
double dKracht = block.inputValue(aInterpPower, &returnStatus).asDouble();
CHECK_MSTATUS(returnStatus);
double dDotProduct; // Dotproduct of the point
bool bTweakblur = block.inputValue(aTweakBlur, &returnStatus).asBool();
CHECK_MSTATUS(returnStatus);
bool bQuad = block.inputValue(aQuadInterp, &returnStatus).asBool();
CHECK_MSTATUS(returnStatus);
MTime inTime = block.inputValue(aTime).asTime();
int nTijd = (int)inTime.as(MTime::kFilm);
MFloatVectorArray currentNormals; // normals of mesh
MFnPointArrayData fnPoints; // help converting to MPointArrays
MFloatVector dirVector; // direction vector of the point
MFloatVector normal; // normal of the point
MPointArray savedPoints; // save all point before edited
MMatrix matInv = m.inverse(); // inversed matrix
MPoint ptA; // current point (iter mesh)
MPoint ptB; // previous point (iter mesh)
MPoint ptC; // mesh before previous point (iter mesh)
// get node, use node to get inputGeom, use inputGeom to get mesh data, use mesh data to get normal data
MFnDependencyNode nodeFn(this->thisMObject());
MPlug inGeomPlug(nodeFn.findPlug(this->inputGeom,true));
MObject inputObject(inGeomPlug.asMObject());
MFnMesh inMesh(inputObject);
inMesh.getVertexNormals(true, currentNormals);
// get the previous mesh data
MPlug oldMeshPlug = nodeFn.findPlug(MString("oldMesh"));
MPlug oldMeshPositionsAPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 0);
MPlug oldMeshPositionsBPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 1);
MPlug oldMeshPositionsCPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 2); // cache for tweak mode
MPlug oldMeshPositionsDPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 3); // cache for tweak mode
// convert to MPointArrays
MObject objOldMeshA;
MObject objOldMeshB;
MObject objOldMeshC; // cache
MObject objOldMeshD; // cache
oldMeshPositionsAPlug.getValue(objOldMeshA);
oldMeshPositionsBPlug.getValue(objOldMeshB);
oldMeshPositionsCPlug.getValue(objOldMeshC); // cache
oldMeshPositionsDPlug.getValue(objOldMeshD); // cache
fnPoints.setObject(objOldMeshA);
MPointArray oldMeshPositionsA = fnPoints.array();
fnPoints.setObject(objOldMeshB);
MPointArray oldMeshPositionsB = fnPoints.array();
fnPoints.setObject(objOldMeshC);
MPointArray oldMeshPositionsC = fnPoints.array(); // cache
fnPoints.setObject(objOldMeshD);
MPointArray oldMeshPositionsD = fnPoints.array(); // cache
// If mesh position variables are empty,fill them with default values
if(oldMeshPositionsA.length() == 0 || nTijd <= 1){
iter.allPositions(oldMeshPositionsA);
for(int i=0; i < oldMeshPositionsA.length(); i++)
{
// convert to world
oldMeshPositionsA[i] = oldMeshPositionsA[i] * m;
}
oldMeshPositionsB.copy(oldMeshPositionsA);
oldMeshPositionsC.copy(oldMeshPositionsA); // cache
oldMeshPositionsD.copy(oldMeshPositionsA); // cache
}
// get back old date again
if (bTweakblur == true) { // restore cache
oldMeshPositionsA.copy(oldMeshPositionsC);
oldMeshPositionsB.copy(oldMeshPositionsD);
}
iter.allPositions(savedPoints);
for(int i=0; i < savedPoints.length(); i++)
{
// convert points to world points
savedPoints[i] = savedPoints[i] * m;
}
// Actual Iteration through points
for (; !iter.isDone(); iter.next()){
// get current position
ptA = iter.position();
// get old positions
ptB = oldMeshPositionsA[iter.index()] * matInv;
ptC = oldMeshPositionsB[iter.index()] * matInv;
fDistance = ptA.distanceTo(ptB);
fW = weightValue(block,multiIndex,iter.index());
if (fDistance * (fStrength*fW) < fThreshold && fThreshold > 0){
iter.setPosition(ptA);
} else {
// aim/direction vector to calculate strength
dirVector = (ptA - ptB); // (per punt)
dirVector.normalize();
normal = currentNormals[iter.index()];
dDotProduct = normal.x * dirVector.x + normal.y * dirVector.y + normal.z * dirVector.z;
if(bQuad == true){
MVector vecA(((ptB - ptC) + (ptA - ptB)) / 2);
vecA.normalize();
MPoint hiddenPt(ptB + (vecA * fDistance) * dKracht);
ptA = quadInterpBetween(ptB, hiddenPt, ptA, (1 - fStrength * fW) + (linearInterp(dDotProduct, -1, 1) * (fStrength * fW) ) );
} else {
MPoint halfway = (ptA - ptB) * 0.5;
MPoint offset = halfway * dDotProduct * (fStrength*fW);
ptA = ptA - ((halfway * (fStrength*fW)) - offset); // + (offset * strength);
}
// set new value
iter.setPosition(ptA);
}
}
if(bTweakblur == false){
oldMeshPositionsD.copy(oldMeshPositionsB);
oldMeshPositionsC.copy(oldMeshPositionsA);
oldMeshPositionsB.copy(oldMeshPositionsA);
oldMeshPositionsA.copy(savedPoints);
// Save back to plugs
objOldMeshA = fnPoints.create(oldMeshPositionsA);
objOldMeshB = fnPoints.create(oldMeshPositionsB);
objOldMeshC = fnPoints.create(oldMeshPositionsC);
objOldMeshD = fnPoints.create(oldMeshPositionsD);
oldMeshPositionsAPlug.setValue(objOldMeshA);
oldMeshPositionsBPlug.setValue(objOldMeshB);
oldMeshPositionsCPlug.setValue(objOldMeshC);
oldMeshPositionsDPlug.setValue(objOldMeshD);
}
return returnStatus;
}
MStatus liqAttachPrefAttribute::redoIt()
{
MFnTypedAttribute tAttr;
MStatus status;
for ( unsigned i( 0 ); i < objectNames.length(); i++ )
{
MSelectionList nodeList;
nodeList.add( objectNames[i] );
MObject depNodeObj;
nodeList.getDependNode( 0, depNodeObj );
MDagPath dagNode;
nodeList.getDagPath( 0, dagNode );
MFnDependencyNode depNode( depNodeObj );
MObject prefAttr;
MString attrName, varName;
// make sure the renderer description is up to date
liqglo.liquidRenderer.setRenderer();
// build the name of the attribute
varName = ( ( exportN && depNodeObj.hasFn( MFn::kMesh ) )? "N":"P" );
attrName = "rman";
attrName += varName;
attrName += ( ( liqglo.liquidRenderer.requires__PREF )? "__":"" );
attrName += varName + "ref";
// create the attribute
prefAttr = tAttr.create( attrName, attrName, MFnData::kPointArray );
if ( depNodeObj.hasFn( MFn::kNurbsSurface ) )
{
MFnNurbsSurface nodeFn( depNodeObj );
MPointArray nodePArray;
MItSurfaceCV cvs( dagNode, MObject::kNullObj, liqglo.liquidRenderer.requires_SWAPPED_UVS == false, &status );
while( !cvs.isDone() )
{
while( !cvs.isRowDone() )
{
MPoint pt = (worldSpace)? cvs.position( MSpace::kWorld ) : cvs.position( MSpace::kObject );
nodePArray.append( pt );
cvs.next();
}
cvs.nextRow();
}
nodeFn.addAttribute( prefAttr );
MFnPointArrayData pArrayData;
MObject prefDefault = pArrayData.create( nodePArray );
MPlug nodePlug( depNodeObj, prefAttr );
nodePlug.setValue( prefDefault );
}
else if ( depNodeObj.hasFn( MFn::kNurbsCurve ) )
{
// Carsten: added support for PREF on nurbs curves
//
MFnNurbsCurve nodeFn( depNodeObj );
MPointArray nodePArray;
nodeFn.getCVs( nodePArray );
nodeFn.addAttribute( prefAttr );
MFnPointArrayData pArrayData;
MObject prefDefault = pArrayData.create( nodePArray );
MPlug nodePlug( depNodeObj, prefAttr );
nodePlug.setValue( prefDefault );
}
else if ( depNodeObj.hasFn( MFn::kMesh ) )
{
MFnMesh nodeFn( depNodeObj );
// Moritz: modified this line to dim nodePArray -- otherwise
// nodePArray.set() in the wile loop below throws an exception
// which was why __Pref didn't work
MPointArray nodePArray( MFnMesh( depNodeObj ).numVertices() );
unsigned count;
nodeFn.addAttribute( prefAttr );
if ( exportN )
{
// export Nref
unsigned vertex;
unsigned normal;
unsigned face = 0;
unsigned faceVertex = 0;
unsigned int numNormals = nodeFn.numNormals();
unsigned int numPoints = nodeFn.numVertices();
MFloatVectorArray normals;
MVectorArray normalAttArray;
nodeFn.getNormals( normals );
if ( numNormals > numPoints )
{
// if we get more than 1 normal per vertex,
// force the arraysize to the full facevarying size
unsigned faceVaryingCount( 0 );
for ( unsigned pOn( 0 ); pOn < nodeFn.numPolygons(); pOn++ )
faceVaryingCount += nodeFn.polygonVertexCount( pOn );
normalAttArray.setLength( faceVaryingCount );
}
else
normalAttArray.setLength(normals.length());
for ( MItMeshPolygon polyIt ( depNodeObj ); polyIt.isDone() == false; polyIt.next() )
{
count = polyIt.polygonVertexCount();
while ( count > 0 )
{
--count;
normal = polyIt.normalIndex( count );
vertex = polyIt.vertexIndex( count );
if( numNormals == numPoints )
normalAttArray.set(normals[normal], vertex);
else
normalAttArray.set(normals[normal], faceVertex);
++faceVertex;
}
++face;
}
MFnVectorArrayData pArrayData;
MObject prefDefault = pArrayData.create( normalAttArray );
MPlug nodePlug( depNodeObj, prefAttr );
nodePlug.setValue( prefDefault );
}
else
{
// TODO: do we need to account for the altMeshExport algo that's
// used in liquidRibMeshData?
// Moritz: no, it's basically the same as the algo below
for ( MItMeshPolygon polyIt( dagNode, MObject::kNullObj ); !polyIt.isDone(); polyIt.next())
{
count = polyIt.polygonVertexCount();
while ( count > 0 )
{
--count;
unsigned vertexIndex = polyIt.vertexIndex( count );
MPoint nodePoint = (worldSpace)? polyIt.point( count, MSpace::kWorld ) : polyIt.point( count, MSpace::kObject );
// Moritz: this returns MS::kFailure but seems to work?!
nodePArray.set( nodePoint, vertexIndex );
}
}
MFnPointArrayData pArrayData;
MObject prefDefault = pArrayData.create( nodePArray );
MPlug nodePlug( depNodeObj, prefAttr );
nodePlug.setValue( prefDefault );
}
} else cerr << "Neither a Nurbs nor a Mesh !!" << endl;
}
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 cvColor::initialize()
{
MStatus stat;
MFnNumericAttribute numericAttr;
MFnTypedAttribute typedAttr;
drawingEnabled = numericAttr.create( "drawingEnabled", "en",
MFnNumericData::kBoolean, 1, &stat );
if (!stat) {
stat.perror("create drawingEnabled attribute");
return stat;
}
pointSize = numericAttr.create( "pointSize", "ps",
MFnNumericData::kFloat, 4.0, &stat );
if (!stat) {
stat.perror("create pointSize attribute");
return stat;
}
inputSurface = typedAttr.create( "inputSurface", "is",
MFnNurbsSurfaceData::kNurbsSurface, &stat);
if (!stat) {
stat.perror("create inputSurface attribute");
return stat;
}
cvLocations = typedAttr.create( "cvLocations", "cv",
MFnPointArrayData::kPointArray, &stat);
if (!stat) {
stat.perror("create cvLocations attribute");
return stat;
}
MPointArray defaultPoints;
MFnPointArrayData defaultArray;
MObject defaultAttr;
defaultPoints.clear(); // Empty array
defaultAttr = defaultArray.create (defaultPoints);
stat = typedAttr.setDefault(defaultAttr);
if (!stat) {
stat.perror("could not create default output attribute");
return stat;
}
stat = addAttribute (drawingEnabled);
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute (pointSize);
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute (inputSurface);
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = addAttribute (cvLocations);
if (!stat) { stat.perror("addAttribute"); return stat;}
stat = attributeAffects( inputSurface, cvLocations );
if (!stat) { stat.perror("attributeAffects"); return stat;}
stat = attributeAffects( drawingEnabled, cvLocations );
if (!stat) { stat.perror("attributeAffects"); return stat;}
stat = attributeAffects( pointSize, cvLocations );
if (!stat) { stat.perror("attributeAffects"); return stat;}
return MS::kSuccess;
}
MTypeId tmpid( VoxelPreviewDataWrapper::id );
VoxelPreviewDataWrapper * newData = NULL;
MDataHandle outHandle = data.outputValue( outData );
newData = (VoxelPreviewDataWrapper*)outHandle.asPluginData();
if ( newData == NULL ) {
// Create some output data
fnDataCreator.create( tmpid, &stat );
MCHECKERROR( stat, "compute : error creating VoxelPreviewDataWrapper")
newData = (VoxelPreviewDataWrapper*)fnDataCreator.data( &stat );
MCHECKERROR( stat, "compute : error getting proxy VoxelPreviewDataWrapper object")
}
// compute the output values
MFnPointArrayData inputData;
inputData.setObject(inputDataObj);
MPointArray voxels = inputData.array();
newData->reset( new VoxelPreviewData( voxels ) );
bounds = newData->getData()->bounds();
#if 0 // enable to dump voxels to Maya
{
// WARNING: unlike the voxels preview using OpenGL, which is
// handled efficiently by the GPU, this code will actually dump
// potentially thousands of objects into the Maya scene, and that
// will likely make Maya unhappy and crashy - use with caution with
// low voxel densities.
char cmd[ 128];
for( unsigned int i = 0; i < voxels.length(); i += 2 ) {
MStatus SargassoNode::initialize()
{
MFnNumericAttribute nAttr;
MStatus status;
MFnTypedAttribute typedAttr;
MFnMatrixAttribute pimAttr;
aconstraintParentInverseMatrix = pimAttr.create( "constraintParentInvMat", "cpim", MFnMatrixAttribute::kDouble, &status );
pimAttr.setArray(true);
pimAttr.setStorable(false);
pimAttr.setDisconnectBehavior(MFnAttribute::kDelete);
status = addAttribute(aconstraintParentInverseMatrix);
if (!status) { status.perror("addAttribute parent inverse matrix"); return status;}
MFnNumericAttribute numAttr;
constraintTranslateX = numAttr.create( "constraintTranslateX", "ctx", MFnNumericData::kDouble, 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintTranslateX");
return status;
}
constraintTranslateY = numAttr.create( "constraintTranslateY", "cty", MFnNumericData::kDouble, 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintTranslateY");
return status;
}
constraintTranslateZ = numAttr.create( "constraintTranslateZ", "ctz", MFnNumericData::kDouble, 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintTranslateY");
return status;
}
MFnUnitAttribute angleAttr;
constraintRotateX = angleAttr.create( "constraintRotateX", "crx", MFnUnitAttribute::kAngle , 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintRotateX");
return status;
}
constraintRotateY = angleAttr.create( "constraintRotateY", "cry", MFnUnitAttribute::kAngle , 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintRotateY");
return status;
}
constraintRotateZ = angleAttr.create( "constraintRotateZ", "crz", MFnUnitAttribute::kAngle , 0.0, &status );
if(!status) {
MGlobal::displayInfo("failed to create attrib constraintRotateY");
return status;
}
{ // Compound target(geometry,weight): array, delete on disconnect
MFnCompoundAttribute compoundAttr;
compoundOutput = compoundAttr.create( "outValue", "otv",&status );
if (!status) { status.perror("compoundAttr.create"); return status;}
status = compoundAttr.addChild( constraintTranslateX );
if (!status) { status.perror("compoundAttr.addChild tx"); return status;}
status = compoundAttr.addChild( constraintTranslateY );
if (!status) { status.perror("compoundAttr.addChild ty"); return status;}
status = compoundAttr.addChild( constraintTranslateZ );
if (!status) { status.perror("compoundAttr.addChild tz"); return status;}
compoundAttr.addChild( constraintRotateX );
compoundAttr.addChild( constraintRotateY );
compoundAttr.addChild( constraintRotateZ );
compoundAttr.setArray( true );
//status = compoundAttr.setDisconnectBehavior(MFnAttribute::kDelete);
//if (!status) { status.perror("typedAttrKeyable.setDisconnectBehavior:cgeom"); return status;}
}
status = addAttribute( compoundOutput );
if (!status) { status.perror("addAttribute"); return status;}
MPointArray defaultPntArray;
MFnPointArrayData pntArrayDataFn;
pntArrayDataFn.create( defaultPntArray );
atargetRestP = typedAttr.create( "targetRestP", "tgrp", MFnData::kPointArray, pntArrayDataFn.object());
typedAttr.setStorable(true);
addAttribute(atargetRestP);
MIntArray defaultIntArray;
MFnIntArrayData intArrayDataFn;
intArrayDataFn.create( defaultIntArray );
atargetTri = typedAttr.create( "targetTriangle", "tgtri", MFnData::kIntArray, intArrayDataFn.object());
typedAttr.setStorable(true);
addAttribute(atargetTri);
atargetBind = typedAttr.create( "targetBindId", "tgbdi", MFnData::kIntArray, intArrayDataFn.object());
typedAttr.setStorable(true);
addAttribute(atargetBind);
aobjTri = typedAttr.create( "objectTriId", "obti", MFnData::kIntArray, intArrayDataFn.object());
typedAttr.setStorable(true);
addAttribute(aobjTri);
atargetNv = numAttr.create( "targetNumV", "tgnv", MFnNumericData::kInt, 0, &status );
addAttribute(atargetNv);
atargetNt = numAttr.create( "targetNumTri", "tgnt", MFnNumericData::kInt, 0, &status );
addAttribute(atargetNt);
MVectorArray defaultVectArray;
MFnVectorArrayData vectArrayDataFn;
vectArrayDataFn.create( defaultVectArray );
aobjLocal = typedAttr.create( "objectLocalP", "oblp", MFnData::kVectorArray, vectArrayDataFn.object());
typedAttr.setStorable(true);
addAttribute(aobjLocal);
aobjN = numAttr.create( "objectCount", "obct", MFnNumericData::kInt, 0, &status );
addAttribute(aobjN);
atargetMesh = typedAttr.create("targetMesh", "tgms", MFnMeshData::kMesh, &status);
typedAttr.setStorable(false);
addAttribute(atargetMesh);
attributeAffects(atargetMesh, compoundOutput);
// attributeAffects(aconstraintParentInverseMatrix, compoundOutput);
return MS::kSuccess;
}