MStatus VoxelShape::compute( const MPlug& plug, MDataBlock& data ) {
MStatus stat;
// Check which output attribute we have been asked to compute. If this
// node doesn't know how to compute it, we must return
// MS::kUnknownParameter.
//
if( plug == outData )
{
// Get a handle to the input attribute that we will need for the
// computation. If the value is being supplied via a connection
// in the dependency graph, then this call will cause all upstream
// connections to be evaluated so that the correct value is supplied.
//
MDataHandle inputDataHandle = data.inputValue( voxelData, &stat );
MObject inputDataObj = inputDataHandle.data();
MFnPluginData fnDataCreator;
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")
}
MStatus ObjectParameterHandler::doSetValue( IECore::ConstParameterPtr parameter, MPlug &plug ) const
{
IECore::ConstObjectParameterPtr p = IECore::runTimeCast<const IECore::ObjectParameter>( parameter );
if( !p )
{
return MS::kFailure;
}
// Keep trying all the available handlers until we find one that works.
/// \todo Investigate whether we can do a parameter->getValue() here and just get the handler which represents it
for (IECore::ObjectParameter::TypeIdSet::const_iterator it = p->validTypes().begin(); it != p->validTypes().end(); ++it)
{
ConstParameterHandlerPtr h = ParameterHandler::create( *it );
if (h)
{
if ( h->doSetValue( parameter, plug) )
{
return MS::kSuccess;
}
}
}
MStatus s;
MFnPluginData fnData;
MObject plugData = fnData.create( ObjectData::id );
assert( plugData != MObject::kNullObj );
s = fnData.setObject( plugData );
assert(s);
ObjectData* data = dynamic_cast<ObjectData *>( fnData.data(&s) );
assert(s);
assert(data);
data->setObject( p->getValue()->copy() );
return plug.setValue( plugData );
}
/*! Compute function, gets the input surface, determines what type it is and calls the appropriate conversion function
Encapsulates an cowpointer to the body into the naiadBodyData type and outputs it */
MStatus NBuddySurfaceToBodyNode::compute( const MPlug& plug, MDataBlock& data )
{
MStatus status;
if (plug == _outBody)
{
//Get the body name
MDataHandle bodyNameHndl = data.inputValue( _bodyName, &status );
MString bodyName = bodyNameHndl.asString();
//Create the MFnPluginData for the naiadBody
MFnPluginData dataFn;
dataFn.create( MTypeId( naiadBodyData::id ), &status);
NM_CheckMStatus( status, "Failed to create naiadBodyData in MFnPluginData");
//Get subdivision info from plugs so better approximations of meshes can be done
int divisions = data.inputValue( _subDivide, &status ).asBool();
//Getting genericAttribute handle containing the surface and pick the correct conversion function
MObject meshObj;
MDataHandle inSurfaceHdl = data.inputValue( _inSurface, &status );
if (inSurfaceHdl.type() == MFnData::kNurbsSurface)
{
MFnNurbsSurface nurbsFn(inSurfaceHdl.asNurbsSurface());
// Create the data holder for the tesselated mesh
MFnMeshData dataCreator;
MObject newOutputData = dataCreator.create(&status);
//Setup the tesselation parameters
MTesselationParams tParams;
tParams.setOutputType( MTesselationParams::kTriangles );
tParams.setFormatType( MTesselationParams::kGeneralFormat );
tParams.setUIsoparmType( MTesselationParams::kSpanEquiSpaced );
tParams.setVIsoparmType( MTesselationParams::kSpanEquiSpaced );
tParams.setUNumber( divisions+1 );
tParams.setVNumber( divisions+1 );
// Tesselate and get the returned mesh
meshObj = nurbsFn.tesselate( tParams, newOutputData, &status );
NM_CheckMStatus( status, "NBuddySurfaceToBodyNode::compute Failed to tesselate nurbs surface to poly");
}
else if (inSurfaceHdl.type() == MFnData::kMesh)
{
meshObj = inSurfaceHdl.asMesh();
if ( divisions > 0 )
{
MFnMeshData dataCreator;
MObject newOutputData = dataCreator.create(&status);
MFnMesh meshFn(meshObj);
MIntArray faceIds;
for ( unsigned int i(0); i < meshFn.numPolygons(); ++i )
faceIds.append(i);
meshFn.subdivideFaces( faceIds , divisions );
}
}
else if (inSurfaceHdl.type() == MFnData::kSubdSurface)
{
// Create the subd function set so we can tesselate
MFnSubd subDfn(inSurfaceHdl.asSubdSurface());
// Create the data holder for the tesselated mesh
MFnMeshData dataCreator;
MObject newOutputData = dataCreator.create(&status);
// Tesselate the subD surface
meshObj = subDfn.tesselate(true, 1 , divisions , newOutputData, &status );
NM_CheckMStatus( status, "NBuddySurfaceToBodyNode::compute Failed to tesselate SubD surface to poly");
}
else
return status ;
//Get the handle for the input transform
MDataHandle inTransformHdl = data.inputValue( _inTransform, &status );
NM_CheckMStatus( status, "Failed to get inTransform handle");
MDataHandle useTransformHdl = data.inputValue( _useTransform, &status);
NM_CheckMStatus( status, "Failed to get worldSpaceHdl ");
bool useTransform = useTransformHdl.asBool();
//Get a new naiadBodyData
naiadBodyData * newBodyData = (naiadBodyData*)dataFn.data( &status );
NM_CheckMStatus( status, "Failed to get naiadBodyData handle from MFnPluginData");
try {
newBodyData->nBody = mayaMeshToNaiadBody( meshObj, std::string(bodyName.asChar()), useTransform, inTransformHdl.asMatrix() );
}
catch(std::exception& ex) {
NM_ExceptionPlugDisplayError("NBuddySurfaceToBodyNode::compute ", plug, ex );
}
//Give the data to the output handle and set it clean
MDataHandle bodyDataHnd = data.outputValue( _outBody, &status );
NM_CheckMStatus( status, "Failed to get outputData handle for outBody");
bodyDataHnd.set( newBodyData );
data.setClean( plug );
}
return status;
}
MStatus NuiMayaDeviceGrabber::compute( const MPlug& plug, MDataBlock& datablock )
//
// Description:
// This method computes the value of the given output plug based
// on the values of the input attributes.
//
// Arguments:
// plug - the plug to compute
// data - object that provides access to the attributes for this node
//
{
assert(m_pCache);
if(!m_pCache)
return MS::kFailure;
MStatus returnStatus;
/* Get time */
MDataHandle timeData = datablock.inputValue( aTime, &returnStatus );
MCHECKERROR(returnStatus, "Error getting time data handle\n")
MTime time = timeData.asTime();
//!< 30 frames per second
int frame = (int)time.as( MTime::kNTSCFrame ) - 1;//Noted: The first frame in MAYA is 1;
if(m_pDevice)
{
std::shared_ptr<NuiCompositeFrame> pFrame = m_pDevice->popFrame();
if(pFrame)
{
pFrame->m_depthFrame.SetMinDepth(getShortValue(aMinDepth));
pFrame->m_depthFrame.SetMaxDepth(getShortValue(aMaxDepth));
if(m_pSLAM /*&& m_pSLAM->m_tracker.isThreadOn()*/)
{
std::shared_ptr<NuiVisualFrame> pVisualFrame = std::make_shared<NuiVisualFrame>();
pVisualFrame->acquireFromCompositeFrame(pFrame.get());
m_pSLAM->m_tracker.pushbackFrame(pVisualFrame);
pVisualFrame.reset();
}
m_pCache->pushbackFrame(pFrame);
pFrame.reset();
}
}
std::shared_ptr<NuiCompositeFrame> pCurrentFrame = m_pCache->getLatestFrame();
if ( plug == aOutputMappable )
{
std::shared_ptr<NuiCLMappableData> clData(nullptr);
MDataHandle outHandle = datablock.outputValue( aOutputMappable );
NuiMayaMappableData* clmData = static_cast<NuiMayaMappableData*>(outHandle.asPluginData());
if(!clmData)
{
// Create some user defined geometry data and access the
// geometry so we can set it
//
MFnPluginData fnDataCreator;
MTypeId tmpid( NuiMayaMappableData::id );
fnDataCreator.create( tmpid, &returnStatus );
MCHECKERROR( returnStatus, "compute : error creating mappableData")
clmData = (NuiMayaMappableData*)fnDataCreator.data( &returnStatus );
MCHECKERROR( returnStatus, "compute : error gettin at proxy mappableData object")
clData = std::shared_ptr<NuiCLMappableData>(new NuiCLMappableData());
clmData->setData(clData);
returnStatus = outHandle.set( clmData );
MCHECKERROR( returnStatus, "compute : error gettin at proxy mappableData object")
}
