void collisionShapeNode::computeCollisionShape(const MPlug& plug, MDataBlock& data)
{
//std::cout << collisionShapeNode::collisionMarginOffset << std::endl;
MObject thisObject(thisMObject());
MPlug plgInShape(thisObject, ia_shape);
if (isCompound(plgInShape))
{
m_collision_shape = createCompositeShape(plgInShape);
} else
{
MObject thisObject(thisMObject());
MPlug plgType(thisObject, ia_type);
int type;
plgType.getValue(type);
switch(type)
{
case 4:
//box
m_collision_shape = solver_t::create_box_shape();
break;
case 5:
//sphere
m_collision_shape = solver_t::create_sphere_shape();
break;
case 6:
//plane
m_collision_shape = solver_t::create_plane_shape();
break;
default:
{
MPlugArray plgaConnectedTo;
plgInShape.connectedTo(plgaConnectedTo, true, true);
int numSelectedShapes = plgaConnectedTo.length();
if(numSelectedShapes > 0)
{
MObject node = plgaConnectedTo[0].node();
m_collision_shape = createCollisionShape(node);
}
}
}
}
//btAssert(m_collision_shape);
data.setClean(plug);
}
// Cache the plug arrays for use in setDependentsDirty
bool AlembicCurvesDeformNode::setInternalValueInContext(const MPlug & plug,
const MDataHandle & dataHandle,
MDGContext &)
{
if (plug == mGeomParamsList) {
MString geomParamsStr = dataHandle.asString();
getPlugArrayFromAttrList(geomParamsStr, thisMObject(), mGeomParamPlugs);
}
else if (plug == mUserAttrsList) {
MString userAttrsStr = dataHandle.asString();
getPlugArrayFromAttrList(userAttrsStr, thisMObject(), mUserAttrPlugs);
}
return false;
}
MBoundingBox AlembicCurvesLocatorNode::boundingBox() const
{
MPlug SentinelPlug(thisMObject(), AlembicCurvesLocatorNode::mSentinelAttr);
int sent = 0;
SentinelPlug.getValue(sent);
return mBoundingBox;
}
// function to mark the output dirty once one of the dynamic attributes changes
MStatus puttyNode::setDependentsDirty( const MPlug &plugBeingDirtied, MPlugArray &affectedPlugs )
{
if ( plugBeingDirtied.isDynamic())
{
MStatus status;
MObject thisNode = thisMObject();
// there is a dynamic attribute that is is dirty, so mark
// the outputGeometry dirty
if ( MStatus::kSuccess == status )
{
// cerr << "\n###" << plugBeingDirtied.name() <<" "<<output.name();
// MPlug pB( thisNode, puttyNode::outputGeom );
// affectedPlugs.append( pB );
MPlug pD( thisNode, puttyNode::aDynDirty );
pD.setValue(true);
// affectedPlugs.append( output );
}
}
return( MS::kSuccess );
}
void SoftBodyNode::computeSoftBodyParam(const MPlug &plug, MDataBlock &data)
{
MObject thisObject(thisMObject());
MObject update;
// update mass
MPlug(thisObject, ca_softBody).getValue(update);
float mass = static_cast<float>( data.inputValue(ia_mass).asDouble() );
this->m_soft_body->set_mass(mass);
// update dynamic friction coefficient
float dynFrictionCoeff = static_cast<float>( data.inputValue(ia_dynamicFrictionCoeff).asDouble() );
this->m_soft_body->set_dynamic_friction_coeff(dynFrictionCoeff);
data.outputValue(ca_softBodyParam).set(true);
// update collision margin
float collisionMargin = data.inputValue(ia_collisionMargin).asFloat();
this->m_soft_body->set_collision_margin(collisionMargin);
data.setClean(plug);
// number of collision clusters
int numClust = data.inputValue(ia_numClusters).asInt();
// this->m_soft_body->set_
}
void rigidBodyNode::clearContactInfo()
{
MObject thisObject(thisMObject());
// contactCount
m_contactCount = 0;
MPlug plugContactCount(thisObject, rigidBodyNode::oa_contactCount);
plugContactCount.setValue(m_contactCount);
// contactName
MStringArray stringArray;
stringArray.clear();
MFnStringArrayData stringArrayData;
MObject strArrObject = stringArrayData.create(stringArray);
MPlug plugContactName(thisObject, rigidBodyNode::oa_contactName);
if ( !plugContactName.isNull() )
plugContactName.setValue(strArrObject);
// contactPosition
MPlug plugContactPosition(thisObject, rigidBodyNode::oa_contactPosition);
bool isArray = plugContactPosition.isArray();
MVectorArray vectorArray;
vectorArray.clear();
MFnVectorArrayData vectorArrayData;
MObject arrObject = vectorArrayData.create(vectorArray);
if ( !plugContactPosition.isNull() )
plugContactPosition.setValue(arrObject);
}
void rigidBodyNode::updateShape(const MPlug& plug, MDataBlock& data, float& collisionMarginOffset)
{
MObject thisObject(thisMObject());
MPlug plgCollisionShape(thisObject, ia_collisionShape);
MObject update;
//force evaluation of the shape
plgCollisionShape.getValue(update);
/* vec3f prevCenter(0, 0, 0);
quatf prevRotation(qidentity<float>());
if(m_rigid_body) {
prevCenter = m_rigid_body->collision_shape()->center();
prevRotation = m_rigid_body->collision_shape()->rotation();
}*/
collision_shape_t::pointer collision_shape;
if(plgCollisionShape.isConnected()) {
MPlugArray connections;
plgCollisionShape.connectedTo(connections, true, true);
if(connections.length() != 0) {
MFnDependencyNode fnNode(connections[0].node());
if(fnNode.typeId() == collisionShapeNode::typeId) {
collisionShapeNode *pCollisionShapeNode = static_cast<collisionShapeNode*>(fnNode.userNode());
pCollisionShapeNode->setCollisionMarginOffset(collisionMarginOffset); //mb
collision_shape = pCollisionShapeNode->collisionShape();
} else {
std::cout << "rigidBodyNode connected to a non-collision shape node!" << std::endl;
}
}
}
data.outputValue(ca_rigidBody).set(true);
data.setClean(plug);
}
void rigidBodyNode::computeRigidBodyParam(const MPlug& plug, MDataBlock& data)
{
// std::cout << "(rigidBodyNode::computeRigidBodyParam) | " << std::endl;
if (!m_rigid_body)
return;
MObject thisObject(thisMObject());
MObject update;
MPlug(thisObject, ca_rigidBody).getValue(update);
double mass = data.inputValue(ia_mass).asDouble();
bool changedMassStatus= false;
float curMass = m_rigid_body->get_mass();
if ((curMass > 0.f) != (mass > 0.f))
{
changedMassStatus = true;
}
if (changedMassStatus)
solver_t::remove_rigid_body(m_rigid_body);
m_rigid_body->set_mass((float)mass);
m_rigid_body->set_inertia((float)mass * m_rigid_body->collision_shape()->local_inertia());
if (changedMassStatus)
solver_t::add_rigid_body(m_rigid_body,name().asChar());
m_rigid_body->set_restitution((float)data.inputValue(ia_restitution).asDouble());
m_rigid_body->set_friction((float)data.inputValue(ia_friction).asDouble());
m_rigid_body->set_linear_damping((float)data.inputValue(ia_linearDamping).asDouble());
m_rigid_body->set_angular_damping((float)data.inputValue(ia_angularDamping).asDouble());
data.outputValue(ca_rigidBodyParam).set(true);
data.setClean(plug);
}
void kgLocator::draw( M3dView & view, const MDagPath & path,
M3dView::DisplayStyle style, M3dView::DisplayStatus status )
{
MStatus stat;
//First get the value of the height attribute
//of the assocuated locator
MObject thisNode = thisMObject();
MFnDagNode dagFn( thisNode );
MPlug heightPlug = dagFn.findPlug( height, &stat );
float heightValue;
heightPlug.getValue( heightValue );
view.beginGL();
glPushAttrib( GL_CURRENT_BIT );
glBegin( GL_LINES );
//Draw a cross
for(unsigned int i=0; i < pts.length(); i+= 2 )
{
glVertex3f(pts[i].x, pts[i].y, pts[i].z );
glVertex3f(pts[i+1].x, pts[i+1].y, pts[i+1].z );
}
//And a vertical spindle
//of the same height as
//the height attribute
glVertex3f( 0.0f, 0.0f, 0.0f );
glVertex3f( 0.0f, heightValue, 0.0f );
glEnd();
glPopAttrib();
view.endGL();
}
MBoundingBox kgLocator::boundingBox() const
{
MBoundingBox bbox;
MPoint pt;
MStatus stat;
MObject thisNode = thisMObject();
MFnDagNode dagFn( thisNode );
MPlug heightPlug = dagFn.findPlug( height, &stat );
float heightValue;
heightPlug.getValue( heightValue );
for(unsigned int i=0; i < pts.length(); ++i )
{
pt.x = pts[i].x; pt.y = pts[i].y; pt.z = pts[i].z;
bbox.expand( pt );
}
//account for the vertical spindle
pt.x=0.0; pt.y = 0.0f; pt.z = 0.0f;
bbox.expand( pt );
pt.x=0.0; pt.y = heightValue; pt.z = 0.0f;
bbox.expand( pt );
return bbox;
}
//
// This method allows the custom transform to apply its own locking
// mechanism to rotation. Standard dependency graph attribute locking
// happens automatically and cannot be modified by custom nodes.
// If the plug should not be changed, then the value from the passed savedR
// argument should be return to be used in the transformation matrix.
//
MEulerRotation rockingTransformCheckNode::applyRotationLocks(const MEulerRotation &toTest,
const MEulerRotation &savedRotation,
MStatus *ReturnStatus )
{
#ifdef ALLOW_DG_TO_HANDLE_LOCKS
// Allow the DG to handle locking.
return toTest;
#else
//
// Implement a simple lock by checking for an existing attribute
// Use the following MEL to add the attribute:
// addAttr -ln "rotateLockPlug"
//
MStatus status;
MObject object = thisMObject();
MFnDependencyNode depNode( object );
MObject rotateLockPlug = depNode.findPlug( "rotateLockPlug", &status );
// If the lock does not exist that we return the updated value that has
// been passed in
if ( rotateLockPlug.isNull() )
return toTest;
// We have a lock. Returned the original saved value of the
// rotation.
return savedRotation;
#endif
}
void NuiMayaDeviceGrabber::addCallbacks()
{
MStatus status;
MObject node = thisMObject();
fCallbackIds.append( MNodeMessage::addAttributeChangedCallback(node, attrChangedCB, (void*)this) );
}
// The compute() method does the actual work of the node using the inputs
// of the node to generate its output.
//
// Compute takes two parameters: plug and data.
// - Plug is the the data value that needs to be recomputed
// - Data provides handles to all of the nodes attributes, only these
// handles should be used when performing computations.
//
MStatus affects::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
MObject thisNode = thisMObject();
MFnDependencyNode fnThisNode( thisNode );
fprintf(stderr,"affects::compute(), plug being computed is \"%s\"\n",
plug.name().asChar());
if ( plug.partialName() == "B" ) {
// Plug "B" is being computed. Assign it the value on plug "A"
// if "A" exists.
//
MPlug pA = fnThisNode.findPlug( "A", &status );
if ( MStatus::kSuccess == status ) {
fprintf(stderr,"\t\t... found dynamic attribute \"A\", copying its value to \"B\"\n");
MDataHandle inputData = data.inputValue( pA, &status );
CHECK_MSTATUS( status );
int value = inputData.asInt();
MDataHandle outputHandle = data.outputValue( plug );
outputHandle.set( value );
data.setClean(plug);
}
} else {
return MS::kUnknownParameter;
}
return( MS::kSuccess );
}
// returns the list of files to archive.
MStringArray AlembicNode::getFilesToArchive(
bool /* shortName */,
bool unresolvedName,
bool /* markCouldBeImageSequence */) const
{
MStringArray files;
MStatus status = MS::kSuccess;
MPlug fileNamePlug(thisMObject(), mAbcFileNameAttr);
MString fileName = fileNamePlug.asString(MDGContext::fsNormal, &status);
if (status == MS::kSuccess && fileName.length() > 0) {
if(unresolvedName)
{
files.append(fileName);
}
else
{
//unresolvedName is false, resolve the path via MFileObject.
MFileObject fileObject;
fileObject.setRawFullName(fileName);
files.append(fileObject.resolvedFullName());
}
}
return files;
}
sgBLocator_fromGeo::sgBLocator_fromGeo()
{
m_pointArr.setLength(6);
m_pointArr[0] = MFloatPoint( 1, 0, 0 );
m_pointArr[1] = MFloatPoint( -1, 0, 0 );
m_pointArr[2] = MFloatPoint( 0, -1, 0 );
m_pointArr[3] = MFloatPoint( 0, 1, 0 );
m_pointArr[4] = MFloatPoint( 0, 0, 1 );
m_pointArr[5] = MFloatPoint( 0, 0, -1 );
m_boundingBox.clear();
m_boundingBox.expand( MVector( 1.0, 1.0, 1.0 ) );
m_boundingBox.expand( MVector( -1.0, -1.0, -1.0 ) );
m_colorActive = MColor( 1.0f, 1.0f, 1.0f );
m_colorLead = MColor( .26f, 1.0f, .64f );
m_colorDefault = MColor( 1.0f, 1.0f, 0.0f );
m_lineWidth = 1;
MFnDependencyNode fnNode( thisMObject() );
MPlug plugOutput = fnNode.findPlug( aOutputValue );
MPlug plugVis =fnNode.findPlug( "v" );
MDGModifier dgModifier;
dgModifier.connect( plugOutput, plugVis );
}
void ProxyViz::processPickInView(const int & plantTyp)
{
useActiveView();
/// not needed?
// _viewport.refresh();
MObject node = thisMObject();
MPlug gateHighPlg(node, alodgatehigh);
float gateHigh = gateHighPlg.asFloat();
MPlug gateLowPlg(node, alodgatelow);
float gateLow = gateLowPlg.asFloat();
// MPlug gcPlg(node, agroupcount);
// int groupCount = gcPlg.asInt();
// MPlug giPlg(node, ainstanceId);
// int groupId = giPlg.asInt();
MPlug perPlg(node, aconvertPercentage);
double percentage = perPlg.asDouble();
pickVisiblePlants(gateLow, gateHigh, percentage, plantTyp);
AHelper::Info<int>("proxyviz picks up n visible plants", numActivePlants() );
}
MStatus pnTriangles::getFloat3(MObject attr, float value[3])
{
MStatus status;
// Get the attr to use
//
MPlug plug(thisMObject(), attr);
MObject object;
status = plug.getValue(object);
if (!status)
{
status.perror("pnTrianglesNode::bind plug.getValue.");
return status;
}
MFnNumericData data(object, &status);
if (!status)
{
status.perror("pnTrianglesNode::bind construct data.");
return status;
}
status = data.getData(value[0], value[1], value[2]);
if (!status)
{
status.perror("pnTrianglesNode::bind get values.");
return status;
}
return MS::kSuccess;
}
// returns the list of files to archive.
MStringArray AlembicNode::getFilesToArchive(
bool /* shortName */,
bool unresolvedName,
bool /* markCouldBeImageSequence */) const
{
MStringArray files;
MStatus status = MS::kSuccess;
MPlug layerFilenamesPlug(thisMObject(), mAbcLayerFileNamesAttr);
MFnStringArrayData fnSAD( layerFilenamesPlug.asMObject() );
MStringArray layerFilenames = fnSAD.array();
for( unsigned int i = 0; i < layerFilenames.length(); i++ )
{
MString fileName = layerFilenames[i];
if (status == MS::kSuccess && fileName.length() > 0) {
if(unresolvedName)
{
files.append(fileName);
}
else
{
//unresolvedName is false, resolve the path via MFileObject.
MFileObject fileObject;
fileObject.setRawFullName(fileName);
files.append(fileObject.resolvedFullName());
}
}
}
return files;
}
void hingeConstraintNode::computeConstraintParam(const MPlug& plug, MDataBlock& data)
{
//std::cout << "hingeConstraintNode::computeRigidBodyParam data.className=" << std::endl;
MObject thisObject(thisMObject());
MObject update;
MPlug(thisObject, ca_constraint).getValue(update);
if(m_constraint) {
float damping = (float) data.inputValue(ia_damping).asDouble();
m_constraint->set_damping(damping);
float lower = (float) data.inputValue(ia_lowerLimit).asDouble();
float upper = (float) data.inputValue(ia_upperLimit).asDouble();
float limit_softness = (float) data.inputValue(ia_limitSoftness).asDouble();
float bias_factor = (float) data.inputValue(ia_biasFactor).asDouble();
float relaxation_factor = (float) data.inputValue(ia_relaxationFactor).asDouble();
m_constraint->set_limit(lower, upper, limit_softness, bias_factor, relaxation_factor);
float* axis = data.inputValue(ia_hingeAxis).asFloat3();
m_constraint->set_axis(vec3f(axis[0], axis[1], axis[2]));
bool enable_motor = data.inputValue(ia_enableAngularMotor).asBool();
float motorTargetVelocity = (float) data.inputValue(ia_motorTargetVelocity).asDouble();
float maxMotorImpulse = (float) data.inputValue(ia_maxMotorImpulse).asDouble();
m_constraint->enable_motor(enable_motor, motorTargetVelocity, maxMotorImpulse);
}
data.outputValue(ca_constraintParam).set(true);
data.setClean(plug);
}
void sixdofConstraintNode::computeConstraintParam(const MPlug& plug, MDataBlock& data)
{
// std::cout << "sixdofConstraintNode::computeRigidBodyParam" << std::endl;
MObject thisObject(thisMObject());
MObject update;
MPlug(thisObject, ca_constraint).getValue(update);
if(m_constraint) {
m_constraint->set_damping((float) data.inputValue(ia_damping).asDouble());
m_constraint->set_breakThreshold((float) data.inputValue(ia_breakThreshold).asDouble());
vec3f lowLin, uppLin, lowAng, uppAng;
float3& mLowLin = data.inputValue(ia_lowerLinLimit).asFloat3();
float3& mUppLin = data.inputValue(ia_upperLinLimit).asFloat3();
float3& mLowAng = data.inputValue(ia_lowerAngLimit).asFloat3();
float3& mUppAng = data.inputValue(ia_upperAngLimit).asFloat3();
for(int j = 0; j < 3; j++)
{
lowLin[j] = mLowLin[j];
uppLin[j] = mUppLin[j];
lowAng[j] = deg2rad(mLowAng[j]);
uppAng[j] = deg2rad(mUppAng[j]);
}
m_constraint->set_LinLimit(lowLin, uppLin);
m_constraint->set_AngLimit(lowAng, uppAng);
}
data.outputValue(ca_constraintParam).set(true);
data.setClean(plug);
}
void curvedArrows::draw( M3dView & view, const MDagPath & /*path*/,
M3dView::DisplayStyle style,
M3dView::DisplayStatus status )
{
// Get the size
//
MObject thisNode = thisMObject();
MPlug tPlug = MPlug( thisNode, aTransparency );
MPlug cPlug = MPlug( thisNode, aTheColor );
float r, g, b, a;
MObject color;
cPlug.getValue( color );
MFnNumericData data( color );
data.getData( r, g, b );
tPlug.getValue( a );
view.beginGL();
if( (style == M3dView::kFlatShaded) ||
(style == M3dView::kGouraudShaded) ) {
// Push the color settings
//
glPushAttrib( GL_COLOR_BUFFER_BIT | GL_CURRENT_BIT | GL_ENABLE_BIT |
GL_PIXEL_MODE_BIT );
if ( a < 1.0f ) {
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
}
glColor4f( r, g, b, a );
glBegin( GL_TRIANGLES );
unsigned int i;
for ( i = 0; i < fsFaceListSize; i ++ ) {
unsigned int *vid = fsFaceList[i];
unsigned int *nid = fsFaceVertexNormalList[i];
for ( unsigned int j = 0; j < 3; j ++ ) {
glNormal3d( fsNormalList[nid[j]-1][0],
fsNormalList[nid[j]-1][1],
fsNormalList[nid[j]-1][2] );
glVertex3d( fsVertexList[vid[j]-1][0],
fsVertexList[vid[j]-1][1],
fsVertexList[vid[j]-1][2] );
}
}
glEnd();
glPopAttrib();
drawEdgeLoop( view, status );
} else {
drawEdgeLoop( view, status );
}
view.endGL();
}
void BasicLocator::postConstructor()
{
//rename the locator shape post construction
MObject oThis = thisMObject();
MFnDependencyNode fnNode(oThis);
fnNode.setName("basicLocator#");
}
collision_shape_t::pointer collisionShapeNode::collisionShape()
{
MObject thisObject(thisMObject());
MObject update;
MPlug(thisObject, oa_collisionShape).getValue(update);
MPlug(thisObject, ca_collisionShapeParam).getValue(update);
return m_collision_shape;
}
bool curvedArrows::drawLast() const
{
MObject thisNode = thisMObject();
MPlug plug( thisNode, aEnableDrawLast );
bool value;
plug.getValue( value );
return value;
}
bool BasicLocator::isTransparent() const
{
MPlug plug(thisMObject(), aIsTransparent);
bool value;
plug.getValue(value);
return value;
}
bool curvedArrows::isTransparent( ) const
{
MObject thisNode = thisMObject();
MPlug plug( thisNode, aEnableTransparencySort );
bool value;
plug.getValue( value );
return value;
}
void nailConstraintNode::update()
{
MObject thisObject(thisMObject());
MObject update;
MPlug(thisObject, ca_constraint).getValue(update);
MPlug(thisObject, ca_constraintParam).getValue(update);
MPlug(thisObject, worldMatrix).elementByLogicalIndex(0).getValue(update);
}
soft_body_t::pointer SoftBodyNode::soft_body()
{
MObject thisObject(thisMObject());
MObject update;
MPlug(thisObject, ca_softBody).getValue(update);
MPlug(thisObject, ca_softBodyParam).getValue(update);
return this->m_soft_body;
}
void ProxyViz::pressToLoad()
{
MObject thisNode = thisMObject();
MPlug plugc( thisNode, acachename );
const MString filename = plugc.asString();
if(filename != "")
loadExternal(replaceEnvVar(filename).c_str());
else
AHelper::Info<int>("ProxyViz error empty external cache filename", 0);
}
MBoundingBox nailConstraintNode::boundingBox() const
{
// std::cout << "nailConstraintNode::boundingBox()" << std::endl;
//load the pdbs
MObject node = thisMObject();
MPoint corner1(-1, -1, -1);
MPoint corner2(1, 1, 1);
return MBoundingBox(corner1, corner2);
}
