C++ MFnMatrixAttribute::setConnectable方法代码示例

MStatus BCIViz::initialize()
{ 
	MFnNumericAttribute numFn;
	MFnMatrixAttribute matAttr;
	MStatus			 stat;
	
	ainput = matAttr.create( "input", "in", MFnMatrixAttribute::kDouble );
	matAttr.setStorable(false);
	matAttr.setWritable(true);
	matAttr.setConnectable(true);
	addAttribute(ainput);
	
	atargets = matAttr.create( "target", "tgt", MFnMatrixAttribute::kDouble );
	matAttr.setStorable(false);
	matAttr.setWritable(true);
	matAttr.setArray(true);
	matAttr.setConnectable(true);
	addAttribute(atargets);
	
	outValue = numFn.create( "outValue", "ov", MFnNumericData::kDouble );
	numFn.setStorable(false);
	numFn.setWritable(false);
	numFn.setReadable(true);
	numFn.setArray(true);
	numFn.setUsesArrayDataBuilder( true );
	addAttribute(outValue);
	
	attributeAffects(ainput, outValue);
	attributeAffects(atargets, outValue);
	return MS::kSuccess;
}

MStatus offset::initialize()
{
	// local attribute initialization

	MFnMatrixAttribute  mAttr;
	offsetMatrix=mAttr.create( "locateMatrix", "lm");
	    mAttr.setStorable(false);
		mAttr.setConnectable(true);

	//  deformation attributes
	addAttribute( offsetMatrix);

	attributeAffects( offset::offsetMatrix, offset::outputGeom );

	return MStatus::kSuccess;
}

//.........这里部分代码省略.........
	}
	
	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 );

MStatus puttyNode::initialize()
{
	MStatus status;
	MFnNumericAttribute		nAttr;
  	MFnEnumAttribute		eAttr;
    MFnTypedAttribute       tAttr;
    MFnMatrixAttribute       mAttr;

    // the script


    aScript = tAttr.create( "script", "scr", MFnData::kString);
    tAttr.setStorable(true);
    tAttr.setKeyable(false);
	SYS_ERROR_CHECK( addAttribute( aScript ), "adding aScript" );  

	aCmdBaseName = tAttr.create( "cmdBaseName", "cbn", MFnData::kString);
    tAttr.setStorable(true);
    tAttr.setKeyable(false);
    tAttr.setHidden(true);    
	SYS_ERROR_CHECK( addAttribute( aCmdBaseName ), "adding aCmdBaseName" );  

    // refresh
    
    aSource = nAttr.create( "source", "src", MFnNumericData::kBoolean, 0 );
    nAttr.setHidden(true);    
    SYS_ERROR_CHECK( addAttribute( aSource ), "adding aSource" ); 
    
	// it is important that script sourced is initialised false and not storable
    // so this way the function gets sourced on maya startup    
    aScriptSourced = nAttr.create( "scriptSourced", "ssrc", MFnNumericData::kBoolean, 0 );
    nAttr.setStorable(false);
    nAttr.setHidden(true);        
    SYS_ERROR_CHECK( addAttribute( aScriptSourced ), "adding aScriptSourced" ); 


    aNodeReady = nAttr.create( "nodeReady", "nr", MFnNumericData::kBoolean, 0 );
    nAttr.setHidden(true);    
    SYS_ERROR_CHECK( addAttribute( aNodeReady ), "adding aNodeReady" ); 

    aDynDirty = nAttr.create( "dynDirty", "dd", MFnNumericData::kBoolean, 0 );
    nAttr.setHidden(true);    
    SYS_ERROR_CHECK( addAttribute( aDynDirty ), "adding aDynDirty" ); 

  
    // space
   	aDefSpace = eAttr.create("deformerSpace", "dsp", MSD_SPACE_OBJECT, &status);
	eAttr.addField("object (default)", MSD_SPACE_OBJECT);
	eAttr.addField("world (automatic conversion)", MSD_SPACE_WORLD);
   	eAttr.setKeyable(false);
	eAttr.setStorable(true);
	SYS_ERROR_CHECK( addAttribute( aDefSpace ), "adding aDefSpace" );

    // envelope
   	aDefEnvelope = eAttr.create("deformerEnvelope", "de", MSD_ENVELOPE_AUTO, &status);
	eAttr.addField("auto", MSD_ENVELOPE_AUTO);
    eAttr.addField("user", MSD_ENVELOPE_USER);    
   	eAttr.setKeyable(false);
	eAttr.setStorable(true);
	SYS_ERROR_CHECK( addAttribute( aDefEnvelope ), "adding aDefEnvelope" );

    // weights
   	aDefWeights = eAttr.create("deformerWeights", "dw", MSD_WEIGHTS_AUTO, &status);
	eAttr.addField("auto", MSD_WEIGHTS_AUTO);
    eAttr.addField("user", MSD_WEIGHTS_USER);    
   	eAttr.setKeyable(false);
	eAttr.setStorable(true);
	SYS_ERROR_CHECK( addAttribute( aDefWeights ), "adding aDefWeights" );

    /////////////////////////////////////////////////////////////////////////////    
    // current values
    aCurrPosition = tAttr.create( "currentPosition", "cpos", MFnData::kVectorArray);
    tAttr.setStorable(false);
    tAttr.setKeyable(false);
    tAttr.setConnectable(false);
    tAttr.setWritable(false);
	SYS_ERROR_CHECK( addAttribute( aCurrPosition ), "adding aCurrPos" );          

    aCurrWeight = tAttr.create( "currentWeight", "cwgh", MFnData::kDoubleArray);
    tAttr.setStorable(false);
    tAttr.setKeyable(false);
    tAttr.setConnectable(false);
    tAttr.setWritable(false);
	SYS_ERROR_CHECK( addAttribute( aCurrWeight ), "adding aCurrWeight" );          
    
    aCurrMultiIndex = nAttr.create("currentMultiIndex","cmi",MFnNumericData::kInt);
    nAttr.setStorable(false);
    nAttr.setKeyable(false);
    nAttr.setConnectable(false);
    nAttr.setWritable(false);
	SYS_ERROR_CHECK( addAttribute( aCurrMultiIndex ), "adding aCurrMultiIndex" );          

    aCurrWorldMatrix = mAttr.create("currentWorldMatrix","cwm"); 
    mAttr.setStorable(false);
    mAttr.setKeyable(false);
    mAttr.setConnectable(false);
    mAttr.setWritable(false);
	SYS_ERROR_CHECK( addAttribute( aCurrWorldMatrix ), "adding aCurrObjectName" );          

/*
//.........这里部分代码省略.........

MStatus proWater::initialize()
{
	// local attribute initialization
    //time parameter
    MFnNumericAttribute nAttr;
    time = nAttr.create("time", "t", MFnNumericData::kDouble);
    nAttr.setDefault(0.0);
    nAttr.setKeyable(true);
    nAttr.setSoftMin(0.0);
    nAttr.setSoftMax(1000);
    nAttr.setMin(0.0);
    nAttr.setMax(1000);
    addAttribute(time);
    attributeAffects(proWater::time, proWater::outputGeom);
    //
    
    //direction parameter
    MFnNumericAttribute dirAttr;
    dir = dirAttr.create("direction", "dirDeg", MFnNumericData::kDouble);
    dirAttr.setDefault(45);
    dirAttr.setKeyable(true);
    dirAttr.setSoftMin(0.0);
    dirAttr.setSoftMax(360);
    dirAttr.setMin(0.0);
    dirAttr.setMax(360);
    addAttribute(dir);
    attributeAffects(proWater::dir, proWater::outputGeom);
    //
    
    //bigAmp1 parameter
    MFnNumericAttribute bigAttr;
    bigFreq = bigAttr.create("largeWaveAmplitude", "bigAmp", MFnNumericData::kDouble);
    bigAttr.setDefault(3);
    bigAttr.setKeyable(true);
    bigAttr.setSoftMin(0.0);
    bigAttr.setSoftMax(100);
    bigAttr.setMin(0.0);
    bigAttr.setMax(100);
    addAttribute(bigFreq);
    attributeAffects(proWater::bigFreq, proWater::outputGeom);
    //
    
    //amplitude1 parameter
    MFnNumericAttribute ampAttr1;
    amplitude1 = ampAttr1.create("firstOctaveAmplitude", "amp1", MFnNumericData::kDouble);
    ampAttr1.setDefault(0.5);
    ampAttr1.setKeyable(true);
    ampAttr1.setSoftMin(0.0);
    ampAttr1.setSoftMax(100);
    ampAttr1.setMin(0.0);
    ampAttr1.setMax(100);
    addAttribute(amplitude1);
    attributeAffects(proWater::amplitude1, proWater::outputGeom);
    //
    
    //frequency1 parameter
    MFnNumericAttribute freqAttr1;
    frequency1 = freqAttr1.create("firstFrequency", "freq1", MFnNumericData::kDouble);
    freqAttr1.setDefault(0.5);
    freqAttr1.setKeyable(true);
    freqAttr1.setSoftMin(0.0);
    freqAttr1.setSoftMax(100);
    freqAttr1.setMin(0.0);
    freqAttr1.setMax(100);
    addAttribute(frequency1);
    attributeAffects(proWater::frequency1, proWater::outputGeom);
    //
    
    //amplitude2 parameter
    MFnNumericAttribute ampAttr2;
    amplitude2 = ampAttr2.create("secondOctaveAmplitude", "amp2", MFnNumericData::kDouble);
    ampAttr2.setDefault(1.3);
    ampAttr2.setKeyable(true);
    ampAttr2.setSoftMin(0.0);
    ampAttr2.setSoftMax(100);
    ampAttr2.setMin(0.0);
    ampAttr2.setMax(100);
    addAttribute(amplitude2);
    attributeAffects(proWater::amplitude2, proWater::outputGeom);
    //
    
    //frequency2 parameter
    MFnNumericAttribute freqAttr2;
    frequency2 = freqAttr2.create("secondFrequency", "freq2", MFnNumericData::kDouble);
    freqAttr2.setDefault(0.7);
    freqAttr2.setKeyable(true);
    freqAttr2.setSoftMin(0.0);
    freqAttr2.setSoftMax(100);
    freqAttr2.setMin(0.0);
    freqAttr2.setMax(100);
    addAttribute(frequency2);
    attributeAffects(proWater::frequency2, proWater::outputGeom);
    //
    
    
    
	MFnMatrixAttribute  mAttr;
	offsetMatrix=mAttr.create( "locateMatrix", "lm");
	    mAttr.setStorable(false);
		mAttr.setConnectable(true);
//.........这里部分代码省略.........

// initialize
// ------------
//! Initialises the Attributes on the node, and set the evaluation dependencies
MStatus NBuddySurfaceToBodyNode::initialize()

{
    MStatus status;

    //Function sets needed
    MFnStringData stringData;
    MFnPluginData dataFn;
    MFnMatrixData matrixFn;
    MFnGenericAttribute genFn;
    MFnTypedAttribute typedAttr;
    MFnNumericAttribute numAttr;
    MFnMatrixAttribute  mAttr;

    //Attribute that specifies if the object should be converted to worldspace or localspace
    _useTransform = numAttr.create( "useTransform", "ut",  MFnNumericData::kBoolean, true, &status );
    NM_CheckMStatus(status, "ERROR creating useWorldSpace attribute.\n");
    status = addAttribute( _useTransform );

    //The input transform for the object
    _inTransform = mAttr.create("inTransform","it", MFnMatrixAttribute::kDouble, &status);
    mAttr.setStorable( true );
    mAttr.setConnectable(true);
    NM_CheckMStatus(status, "ERROR creating inTransform attribute.\n");
    status = addAttribute( _inTransform );
    NM_CheckMStatus(status, "ERROR adding inTransform attribute.\n");

    //Create the inSurface plug
    _inSurface = genFn.create( "inSurface", "surf", &status);
    NM_CheckMStatus( status, "Failed to create inSurface GenericAttribute");
    genFn.addAccept(MFnData::kNurbsSurface);
    genFn.addAccept(MFnData::kMesh);
    genFn.addAccept(MFnData::kSubdSurface);
    genFn.setStorable(false);
    genFn.setCached(false);
    status = addAttribute( _inSurface );
    NM_CheckMStatus(status, "ERROR adding inSurface attribute.\n");

    // Create the attribute for the body output
    _outBody = typedAttr.create("outBody","ob" , naiadBodyData::id , MObject::kNullObj , &status);
    NM_CheckMStatus(status, "ERROR creating outBody attribute.\n");
    typedAttr.setKeyable( false  );
    typedAttr.setWritable( false );
    typedAttr.setReadable( true  );
    typedAttr.setStorable( false );
    status = addAttribute( _outBody );
    NM_CheckMStatus(status, "ERROR adding outBody attribute.\n");

    // Create the attribute for the body name
    _bodyName = typedAttr.create( "bodyName", "bn", MFnData::kString ,stringData.create( MString("mesh-body") ), &status);
    NM_CheckMStatus( status, "Failed to create bodyName attribute");
    typedAttr.setStorable( true );
    typedAttr.setArray( false );
    status = addAttribute( _bodyName );
    NM_CheckMStatus( status, "Failed to add bodyName plug");

    //Tesselation settings
    _subDivide = numAttr.create( "subDivide", "td", MFnNumericData::kInt , 0, &status);
    NM_CheckMStatus( status, "Failed to create subDivide attribute");
    numAttr.setStorable( true );
    numAttr.setArray( false );
    status = addAttribute( _subDivide );
    NM_CheckMStatus( status, "Failed to add bodyName plug");

    // Attribute affects
    attributeAffects( _bodyName, _outBody );
    attributeAffects( _subDivide, _outBody );
    attributeAffects( _inSurface, _outBody );
    attributeAffects( _useTransform, _outBody );
    attributeAffects( _inTransform, _outBody );

    return MS::kSuccess;
}

MStatus curveColliderLocator::initialize()
{ 
	MFnNumericAttribute nAttr;
	MStatus				stat;
	
	colliderRadiusIn = nAttr.create( "radius", "rd", MFnNumericData::kDouble );
	nAttr.setDefault(1.0);
	nAttr.setMin(0);
	nAttr.setKeyable(true);
	nAttr.setArray(true);
	nAttr.setStorable(true);
	nAttr.setWritable(true);
	
	stat = addAttribute(colliderRadiusIn);
	if (!stat) {
		stat.perror("Could not add colliderRadiusIn attribute");
		return stat;
	}
	
	// CREATE AND ADD ".inCurve" ATTRIBUTE:
	
	MFnTypedAttribute inCurveAttrFn;
	colliderCurveIn = inCurveAttrFn.create("colliderCurve", "ic", MFnData::kNurbsCurve);
	inCurveAttrFn.setStorable(true);
	inCurveAttrFn.setKeyable(false);
	inCurveAttrFn.setReadable(true);
	inCurveAttrFn.setWritable(true);
	inCurveAttrFn.setCached(false);

	stat = addAttribute(colliderCurveIn);
	if (!stat) {
		stat.perror("Could not add colliderCurveIn attribute");
		return stat;
	}
	
	MFnMatrixAttribute mAttr;
	colliderXform =mAttr.create("colliderXfm", "cx");
	mAttr.setReadable(false); 
	mAttr.setKeyable(false); 
	mAttr.setConnectable(true);
	stat = addAttribute( colliderXform ); 
	if (!stat) {
		stat.perror("Could not add colliderXform attribute");
		return stat;
	}
	
	colliderColorR = nAttr.create( "colorR", "clr", MFnNumericData::kFloat );
	nAttr.setDefault(0.2f);
	nAttr.setMin(0.0f);
	nAttr.setMax(1.0f);
	nAttr.setKeyable(true);
	nAttr.setStorable(true);
	nAttr.setReadable(true);
	nAttr.setWritable(true);
	stat = addAttribute(colliderColorR);
	if (!stat) {
		stat.perror("Could not add colliderColorR attribute");
		return stat;
	}
	
	colliderColorG = nAttr.create( "colorG", "clg", MFnNumericData::kFloat );
	nAttr.setDefault(0.2f);
	nAttr.setMin(0.0f);
	nAttr.setMax(1.0f);
	nAttr.setKeyable(true);
	nAttr.setStorable(true);
	nAttr.setReadable(true);
	nAttr.setWritable(true);
	stat = addAttribute(colliderColorG);
	if (!stat) {
		stat.perror("Could not add colliderColorG attribute");
		return stat;
	}

	colliderColorB = nAttr.create( "colorB", "clb", MFnNumericData::kFloat );
	nAttr.setDefault(0.8f);
	nAttr.setMin(0.0f);
	nAttr.setMax(1.0f);
	nAttr.setKeyable(true);
	nAttr.setStorable(true);
	nAttr.setReadable(true);
	nAttr.setWritable(true);
	stat = addAttribute(colliderColorB);
	if (!stat) {
		stat.perror("Could not add colliderColorB attribute");
		return stat;
	}
	
	colliderTransparency = nAttr.create( "colorT", "clt", MFnNumericData::kFloat );
	nAttr.setDefault(1.0f);
	nAttr.setMin(0.0f);
	nAttr.setMax(1.0f);
	nAttr.setKeyable(true);
	nAttr.setStorable(true);
	nAttr.setReadable(true);
	nAttr.setWritable(true);
	stat = addAttribute(colliderTransparency);
	if (!stat) {
		stat.perror("Could not add colliderTransparency attribute");
		return stat;
//.........这里部分代码省略.........

// INIT =========================================
MStatus gear_rollSplineKine::initialize()
{
	MFnMatrixAttribute mAttr;
	MFnNumericAttribute nAttr;
	MStatus stat;
	
    // Inputs Matrices
    ctlParent = mAttr.create( "ctlParent", "ctlp", MFnMatrixAttribute::kDouble );
    mAttr.setStorable(true);
    mAttr.setReadable(false);
    mAttr.setIndexMatters(false);
    mAttr.setArray(true);
    addAttribute( ctlParent );
	
    inputs = mAttr.create( "inputs", "in", MFnMatrixAttribute::kDouble );
    mAttr.setStorable(true);
    mAttr.setReadable(false);
    mAttr.setIndexMatters(false);
    mAttr.setArray(true);
    addAttribute( inputs );

    inputsRoll = nAttr.create ( "inputsRoll", "inr", MFnNumericData::kFloat, 0.0 );
    nAttr.setArray(true);
    nAttr.setStorable(true);
    addAttribute ( inputsRoll );
	
	outputParent = mAttr.create( "outputParent", "outp" );
	mAttr.setStorable(true);
	mAttr.setKeyable(true);
	mAttr.setConnectable(true);
	stat = addAttribute( outputParent );
		if (!stat) {stat.perror("addAttribute"); return stat;}

    // Inputs Sliders
	u = nAttr.create("u", "u", MFnNumericData::kFloat, 0.0);
	nAttr.setStorable(true);
	nAttr.setKeyable(true);
	nAttr.setMin(0);
	nAttr.setMax(1);
    stat = addAttribute( u );
		if (!stat) {stat.perror("addAttribute"); return stat;}
		
	resample = nAttr.create("resample", "re", MFnNumericData::kBoolean, false);
	nAttr.setStorable(true);
	nAttr.setKeyable(true);
    stat = addAttribute( resample );
		if (!stat) {stat.perror("addAttribute"); return stat;}

	subdiv = nAttr.create("subdiv", "sd", MFnNumericData::kShort, 10);
	nAttr.setStorable(true);
	nAttr.setKeyable(true);
	nAttr.setMin(3);
    stat = addAttribute( subdiv );
		if (!stat) {stat.perror("addAttribute"); return stat;}

	absolute = nAttr.create("absolute", "abs", MFnNumericData::kBoolean, false);
	nAttr.setStorable(true);
	nAttr.setKeyable(true);
    stat = addAttribute( absolute );
		if (!stat) {stat.perror("addAttribute"); return stat;}

    // Outputs
	output = mAttr.create( "output", "out" );
	mAttr.setStorable(false);
	mAttr.setKeyable(false);
	mAttr.setConnectable(true);
	stat = addAttribute( output );
		if (!stat) {stat.perror("addAttribute"); return stat;}

	// Connections
    stat = attributeAffects ( ctlParent, output );
		if (!stat) {stat.perror("attributeAffects"); return stat;}
    stat = attributeAffects ( inputs, output );
		if (!stat) {stat.perror("attributeAffects"); return stat;}
    stat = attributeAffects ( inputsRoll, output );
		if (!stat) {stat.perror("attributeAffects"); return stat;}
    stat = attributeAffects ( outputParent, output );
		if (!stat) {stat.perror("attributeAffects"); return stat;}
		
    stat = attributeAffects ( u, output );
		if (!stat) {stat.perror("attributeAffects"); return stat;}
    stat = attributeAffects ( resample, output );
		if (!stat) {stat.perror("attributeAffects"); return stat;}
    stat = attributeAffects ( subdiv, output );
		if (!stat) {stat.perror("attributeAffects"); return stat;}
    stat = attributeAffects ( absolute, output );
		if (!stat) {stat.perror("attributeAffects"); return stat;}
		
   return MS::kSuccess;
}