//------------------------------------------------------------------------------
//
MStatus AdskPrepareRenderGlobals::initialize()
{    
   MStatus stat;  
   MFnStringData stringFn;
   MObject emptyStr = stringFn.create( &stat );
   
   MObject* attrib[3];
   attrib[0] = &aRepName;
   attrib[1] = &aRepLabel;
   attrib[2] = &aRepType;
   const char* longName[] = {"repName", "repLabel", "repType"};
   const char* shortName[] = {"rna", "rla", "rty"};
   
   MFnTypedAttribute stringAttrFn;
   for (int i = 0; i < 3; i++)
   {      
      *attrib[i] = stringAttrFn.create(longName[i], shortName[i], MFnData::kString, emptyStr);     
      stat = MPxNode::addAttribute(*attrib[i]);
      CHECK_MSTATUS_AND_RETURN_IT(stat);
   }
   
   MFnNumericAttribute boolAttrFn;
   aUseRegEx = boolAttrFn.create("useRegExp", "urx", MFnNumericData::kBoolean, 0);  
   stat = MPxNode::addAttribute(aUseRegEx);
   CHECK_MSTATUS_AND_RETURN_IT(stat);

   return  stat;
}
예제 #2
0
MStatus EntityInstanceNode::Initialize()
{
    MAYA_START_EXCEPTION_HANDLING();

    MStatus stat;

    // wtf is this - rachel
    MFnStringData dataFn;
    MObject stringData = dataFn.create( "" );

    // fileName attribute
    MFnTypedAttribute tAttr;
    s_ArtFilePath = tAttr.create("ArtFilePath", "fn", MFnData::kString, &stat);
    tAttr.setDefault( stringData );
    MCheckErr(stat, "Unable to create attr: ArtFilePath");

    tAttr.setReadable(true);
    tAttr.setWritable(false);

    stat = addAttribute(s_ArtFilePath);
    MCheckErr(stat, "Unable to add attr: ArtFilePath");

    MAYA_FINISH_EXCEPTION_HANDLING();

    return MS::kSuccess;
}
예제 #3
0
MStatus AlembicCurvesDeformNode::initialize()
{
  MStatus status;

  MFnUnitAttribute uAttr;
  MFnTypedAttribute tAttr;
  MFnNumericAttribute nAttr;
  MFnGenericAttribute gAttr;
  MFnStringData emptyStringData;
  MObject emptyStringObject = emptyStringData.create("");

  // input time
  mTimeAttr = uAttr.create("inTime", "tm", MFnUnitAttribute::kTime, 0.0);
  status = uAttr.setStorable(true);
  status = uAttr.setKeyable(true);
  status = addAttribute(mTimeAttr);

  // input file name
  mFileNameAttr =
      tAttr.create("fileName", "fn", MFnData::kString, emptyStringObject);
  status = tAttr.setStorable(true);
  status = tAttr.setUsedAsFilename(true);
  status = tAttr.setKeyable(false);
  status = addAttribute(mFileNameAttr);

  // input identifier
  mIdentifierAttr =
      tAttr.create("identifier", "if", MFnData::kString, emptyStringObject);
  status = tAttr.setStorable(true);
  status = tAttr.setKeyable(false);
  status = addAttribute(mIdentifierAttr);

  // output for list of ArbGeomParams
  mGeomParamsList = tAttr.create("ExocortexAlembic_GeomParams", "exo_gp",
      MFnData::kString, emptyStringObject);
  status = tAttr.setStorable(true);
  status = tAttr.setKeyable(false);
  status = tAttr.setHidden(false);
  status = tAttr.setInternal(true);
  status = addAttribute(mGeomParamsList);

  // output for list of UserAttributes
  mUserAttrsList = tAttr.create("ExocortexAlembic_UserAttributes", "exo_ua",
      MFnData::kString, emptyStringObject);
  status = tAttr.setStorable(true);
  status = tAttr.setKeyable(false);
  status = tAttr.setHidden(false);
  status = tAttr.setInternal(true);
  status = addAttribute(mUserAttrsList);

  // create a mapping
  status = attributeAffects(mTimeAttr, outputGeom);
  status = attributeAffects(mFileNameAttr, outputGeom);
  status = attributeAffects(mIdentifierAttr, outputGeom);

  return status;
}
예제 #4
0
MStatus DynamicEnum::initialize()
{
	MFnNumericAttribute nAttr;
	MFnTypedAttribute tAttr;
	MFnStringData sData;
	MStatus status; // Status will be used to hold the MStatus value

	// returned by each api function call. It is important
	// to check the status returned by a call to aid in
	// debugging. Failed API calls can result in subtle
	// errors that can be difficult to track down, you may
	// wish to use the CHECK_MSTATUS macro for any API
	// call where you do not need to provide your own
	// error handling.
	//

	// Attribute Initialization:
	aFilePath = tAttr.create( "filepath", "file", MFnData::kString, &status );
	CHECK_MSTATUS( status );
	CHECK_MSTATUS( tAttr.setKeyable( true ) );
	CHECK_MSTATUS( tAttr.setStorable( true ) );
	CHECK_MSTATUS( tAttr.setDefault( sData.create("") ) );

	aGridName = tAttr.create( "grid", "grd", MFnData::kString, &status );
	CHECK_MSTATUS( status );
	CHECK_MSTATUS( tAttr.setKeyable( true ) );
	CHECK_MSTATUS( tAttr.setStorable( true ) );
	CHECK_MSTATUS( tAttr.setDefault( sData.create("") ) );

	aOutColor = nAttr.createColor( "outColor", "oc", &status );
	CHECK_MSTATUS( status );
	CHECK_MSTATUS( nAttr.setHidden( false ) );
	CHECK_MSTATUS( nAttr.setReadable( true ) );
	CHECK_MSTATUS( nAttr.setWritable( false ) );

	// Next we will add the attributes we have defined to the node
	//
	CHECK_MSTATUS( addAttribute( aFilePath ) );
	CHECK_MSTATUS( addAttribute( aGridName ) );
	CHECK_MSTATUS( addAttribute( aOutColor ) );

	// The attributeAffects() method is used to indicate when the input
	// attribute affects the output attribute. This knowledge allows Maya
	// to optimize dependencies in the graph in more complex nodes where
	// there may be several inputs and outputs, but not all the inputs
	// affect all the outputs.
	//
	CHECK_MSTATUS( attributeAffects( aFilePath, aOutColor ) );
	CHECK_MSTATUS( attributeAffects( aGridName, aOutColor ) );

	return( MS::kSuccess );
}
예제 #5
0
MStatus PRTAttrs::addStrParameter(MFnDependencyNode & node, MObject & attr, const MString & name, MString & value ) {
	MStatus           stat;
	MStatus           stat2;
	MFnStringData		  stringData;
	MFnTypedAttribute sAttr;

	attr = sAttr.create(longName(name), briefName(name), MFnData::kString, stringData.create(value, &stat2), &stat );
	MCHECK(stat2);
	MCHECK(stat);
	MCHECK(addParameter(node, attr, sAttr));

	MPlug plug(node.object(), attr);
	MCHECK(plug.setValue(value));

	return MS::kSuccess;
}
예제 #6
0
// The initialize routine is called after the node has been created.
// It sets up the input and output attributes and adds them to the
// node. Finally the dependencies are arranged so that when the
// inputs change Maya knowns to call compute to recalculate the output
// value.
//
MStatus stringFormat::initialize()
{
	MFnNumericAttribute numAttr;
	MFnTypedAttribute	typedAttr;
	MFnStringData		stringData;
	MStatus				stat;
	MStatus				stat2;

	// Setup the input attributes
	//
	attrFormat = typedAttr.create("format", "f", MFnData::kString, 
								  stringData.create(&stat2), &stat);
	CHECK_MSTATUS( stat2 );
	CHECK_MSTATUS( stat );
 	CHECK_MSTATUS( typedAttr.setStorable( true ) );
 	CHECK_MSTATUS( typedAttr.setKeyable( true ) );

	attrValues = numAttr.create("values", "v", MFnNumericData::kDouble, 
								0, &stat);
	CHECK_MSTATUS( stat );
 	CHECK_MSTATUS( numAttr.setArray( true ) );
	CHECK_MSTATUS( numAttr.setReadable( false ) );
 	CHECK_MSTATUS( numAttr.setIndexMatters( true ) );
 	CHECK_MSTATUS( numAttr.setStorable( true ) );
 	CHECK_MSTATUS( numAttr.setKeyable( true ) );

	attrOutput = typedAttr.create( "output", "o", MFnData::kString,
								   stringData.create(&stat2), &stat);
	CHECK_MSTATUS( stat2 );
	CHECK_MSTATUS( stat );
	CHECK_MSTATUS( typedAttr.setWritable( false ) );
	CHECK_MSTATUS( typedAttr.setStorable( false ) );

	// Add the attributes to the node
	//
	CHECK_MSTATUS( addAttribute( attrFormat ) );
	CHECK_MSTATUS( addAttribute( attrValues ) );
	CHECK_MSTATUS( addAttribute( attrOutput ) );

	// Set the attribute dependencies
	//
	CHECK_MSTATUS( attributeAffects( attrFormat, attrOutput ) );
	CHECK_MSTATUS( attributeAffects( attrValues, attrOutput ) );

	return MS::kSuccess;
} 
예제 #7
0
MStatus AlembicCurvesLocatorNode::initialize()
{
  MStatus status;

  MFnUnitAttribute uAttr;
  MFnTypedAttribute tAttr;
  MFnNumericAttribute nAttr;
  MFnGenericAttribute gAttr;
  MFnStringData emptyStringData;
  MObject emptyStringObject = emptyStringData.create("");

  // input time
  mTimeAttr = uAttr.create("inTime", "tm", MFnUnitAttribute::kTime, 0.0);
  status = uAttr.setStorable(true);
  status = uAttr.setKeyable(true);
  status = addAttribute(mTimeAttr);

  // input file name
  mFileNameAttr =
      tAttr.create("fileName", "fn", MFnData::kString, emptyStringObject);
  status = tAttr.setStorable(true);
  status = tAttr.setUsedAsFilename(true);
  status = tAttr.setKeyable(false);
  status = addAttribute(mFileNameAttr);

  // input identifier
  mIdentifierAttr =
      tAttr.create("identifier", "if", MFnData::kString, emptyStringObject);
  status = tAttr.setStorable(true);
  status = tAttr.setKeyable(false);
  status = addAttribute(mIdentifierAttr);

  // sentinel attr
  mSentinelAttr = nAttr.create("sentinel", "sent", MFnNumericData::kInt, 0);
  nAttr.setHidden(true);
  status = addAttribute(mSentinelAttr);

  // create a mapping
  status = attributeAffects(mTimeAttr, mSentinelAttr);
  status = attributeAffects(mFileNameAttr, mSentinelAttr);
  status = attributeAffects(mIdentifierAttr, mSentinelAttr);

  return status;
}
예제 #8
0
MStatus	MayaToIndigoGlobals::initialize()
{
	MayaRenderGlobalsNode::initialize();

	MFnNumericAttribute nAttr;
	MFnTypedAttribute tAttr;
	MFnGenericAttribute gAttr;
	MFnEnumAttribute eAttr;
	MFnMessageAttribute mAttr;

	MStatus stat = MStatus::kSuccess;

//	------------- automatically created attributes start ----------- // 

	white_point = eAttr.create("white_point", "white_point", 4, &stat);
	stat = eAttr.addField( "User", 0 );
	stat = eAttr.addField( "A", 1 );
	stat = eAttr.addField( "B", 2 );
	stat = eAttr.addField( "C", 3 );
	stat = eAttr.addField( "D50", 4 );
	stat = eAttr.addField( "D55", 5 );
	stat = eAttr.addField( "D65", 6 );
	stat = eAttr.addField( "D75", 7 );
	stat = eAttr.addField( "E", 8 );
	stat = eAttr.addField( "F1", 9 );
	stat = eAttr.addField( "F2", 10 );
	stat = eAttr.addField( "F3", 11 );
	stat = eAttr.addField( "F4", 12 );
	stat = eAttr.addField( "F5", 13 );
	stat = eAttr.addField( "F6", 14 );
	stat = eAttr.addField( "F7", 15 );
	stat = eAttr.addField( "F8", 16 );
	stat = eAttr.addField( "F9", 17 );
	stat = eAttr.addField( "F10", 18 );
	stat = eAttr.addField( "F11", 19 );
	stat = eAttr.addField( "F12", 20 );
	CHECK_MSTATUS(addAttribute( white_point ));

	white_pointX = nAttr.create("white_pointX", "white_pointX",  MFnNumericData::kFloat, 0.0);
	CHECK_MSTATUS(addAttribute( white_pointX ));

	white_pointY = nAttr.create("white_pointY", "white_pointY",  MFnNumericData::kFloat, 0.0);
	CHECK_MSTATUS(addAttribute( white_pointY ));

	bih_tri_threshold = nAttr.create("bih_tri_threshold", "bih_tri_threshold",  MFnNumericData::kInt, 1100000);
	CHECK_MSTATUS(addAttribute( bih_tri_threshold ));

	metropolis = nAttr.create("metropolis", "metropolis",  MFnNumericData::kBoolean, true);
	CHECK_MSTATUS(addAttribute( metropolis ));

	large_mutation_prob = nAttr.create("large_mutation_prob", "large_mutation_prob",  MFnNumericData::kFloat, 0.1);
	CHECK_MSTATUS(addAttribute( large_mutation_prob ));

	max_change = nAttr.create("max_change", "max_change",  MFnNumericData::kFloat, .01);
	CHECK_MSTATUS(addAttribute( max_change ));

	max_num_consec_rejections = nAttr.create("max_num_consec_rejections", "max_num_consec_rejections",  MFnNumericData::kInt, 1000);
	CHECK_MSTATUS(addAttribute( max_num_consec_rejections ));

	logging = nAttr.create("logging", "logging",  MFnNumericData::kBoolean, true);
	CHECK_MSTATUS(addAttribute( logging ));

	path_tracing = eAttr.create("path_tracing", "path_tracing", 0, &stat);
	stat = eAttr.addField( "bidirectional", 0 );
	stat = eAttr.addField( "backwards", 1 );
	CHECK_MSTATUS(addAttribute( path_tracing ));

	tone_mapper = eAttr.create("tone_mapper", "tone_mapper", 1, &stat);
	stat = eAttr.addField( "linear", 0 );
	stat = eAttr.addField( "reinhard", 1 );
	stat = eAttr.addField( "camera", 2 );
	CHECK_MSTATUS(addAttribute( tone_mapper ));

	tone_linearScale = nAttr.create("tone_linearScale", "tone_linearScale",  MFnNumericData::kFloat, 1.0);
	nAttr.setMin(0.0001);
	nAttr.setMax(100);
	CHECK_MSTATUS(addAttribute( tone_linearScale ));

	tone_reinhardPreScale = nAttr.create("tone_reinhardPreScale", "tone_reinhardPreScale",  MFnNumericData::kFloat, 1.0);
	CHECK_MSTATUS(addAttribute( tone_reinhardPreScale ));

	tone_reinhardPostScale = nAttr.create("tone_reinhardPostScale", "tone_reinhardPostScale",  MFnNumericData::kFloat, 1.0);
	CHECK_MSTATUS(addAttribute( tone_reinhardPostScale ));

	tone_reinhardBurn = nAttr.create("tone_reinhardBurn", "tone_reinhardBurn",  MFnNumericData::kFloat, 10.0);
	CHECK_MSTATUS(addAttribute( tone_reinhardBurn ));

	tone_cameraResponse_function_path = tAttr.create("tone_cameraResponse_function_path", "tone_cameraResponse_function_path",  MFnNumericData::kString);
	CHECK_MSTATUS(addAttribute( tone_cameraResponse_function_path ));

	tone_cameraEv_adjust = nAttr.create("tone_cameraEv_adjust", "tone_cameraEv_adjust",  MFnNumericData::kFloat, 0.0);
	CHECK_MSTATUS(addAttribute( tone_cameraEv_adjust ));

	tone_cameraFilm_iso = nAttr.create("tone_cameraFilm_iso", "tone_cameraFilm_iso",  MFnNumericData::kFloat, 200.0);
	CHECK_MSTATUS(addAttribute( tone_cameraFilm_iso ));

	save_untonemapped_exr = nAttr.create("save_untonemapped_exr", "save_untonemapped_exr",  MFnNumericData::kBoolean, false);
	CHECK_MSTATUS(addAttribute( save_untonemapped_exr ));

	save_tonemapped_exr = nAttr.create("save_tonemapped_exr", "save_tonemapped_exr",  MFnNumericData::kBoolean, true);
	CHECK_MSTATUS(addAttribute( save_tonemapped_exr ));

	save_igi = nAttr.create("save_igi", "save_igi",  MFnNumericData::kBoolean, false);
	CHECK_MSTATUS(addAttribute( save_igi ));

	image_save_period = nAttr.create("image_save_period", "image_save_period",  MFnNumericData::kFloat, 60);
	CHECK_MSTATUS(addAttribute( image_save_period ));

	halt_time = nAttr.create("halt_time", "halt_time",  MFnNumericData::kFloat, -1);
	CHECK_MSTATUS(addAttribute( halt_time ));

	halt_samples_per_pixel = nAttr.create("halt_samples_per_pixel", "halt_samples_per_pixel",  MFnNumericData::kInt, -1);
	CHECK_MSTATUS(addAttribute( halt_samples_per_pixel ));

	hybrid = nAttr.create("hybrid", "hybrid",  MFnNumericData::kBoolean, false);
	CHECK_MSTATUS(addAttribute( hybrid ));

	auto_choose_num_threads = nAttr.create("auto_choose_num_threads", "auto_choose_num_threads",  MFnNumericData::kBoolean, true);
	CHECK_MSTATUS(addAttribute( auto_choose_num_threads ));

	num_threads = nAttr.create("num_threads", "num_threads",  MFnNumericData::kBoolean, 1);
	CHECK_MSTATUS(addAttribute( num_threads ));

	super_sample_factor = nAttr.create("super_sample_factor", "super_sample_factor",  MFnNumericData::kInt, 2);
	CHECK_MSTATUS(addAttribute( super_sample_factor ));

	watermark = nAttr.create("watermark", "watermark",  MFnNumericData::kBoolean, false);
	CHECK_MSTATUS(addAttribute( watermark ));

	info_overlay = nAttr.create("info_overlay", "info_overlay",  MFnNumericData::kBoolean, false);
	CHECK_MSTATUS(addAttribute( info_overlay ));

	cache_trees = nAttr.create("cache_trees", "cache_trees",  MFnNumericData::kBoolean, true);
	CHECK_MSTATUS(addAttribute( cache_trees ));

	aperture_diffraction = nAttr.create("aperture_diffraction", "aperture_diffraction",  MFnNumericData::kBoolean, true);
	CHECK_MSTATUS(addAttribute( aperture_diffraction ));

	post_process_diffraction = nAttr.create("post_process_diffraction", "post_process_diffraction",  MFnNumericData::kBoolean, true);
	CHECK_MSTATUS(addAttribute( post_process_diffraction ));

	render_foreground_alpha = nAttr.create("render_foreground_alpha", "render_foreground_alpha",  MFnNumericData::kBoolean, false);
	CHECK_MSTATUS(addAttribute( render_foreground_alpha ));

	splat_filter = eAttr.create("splat_filter", "splat_filter", 0, &stat);
	stat = eAttr.addField( "fastbox", 0 );
	stat = eAttr.addField( "radial", 1 );
	stat = eAttr.addField( "mn_cubic", 2 );
	CHECK_MSTATUS(addAttribute( splat_filter ));

	splat_filter_cubic_b = nAttr.create("splat_filter_cubic_b", "splat_filter_cubic_b",  MFnNumericData::kFloat, 0.6);
	CHECK_MSTATUS(addAttribute( splat_filter_cubic_b ));

	splat_filter_cubic_ring = nAttr.create("splat_filter_cubic_ring", "splat_filter_cubic_ring",  MFnNumericData::kFloat, 0.2);
	CHECK_MSTATUS(addAttribute( splat_filter_cubic_ring ));

	downsize_filter = eAttr.create("downsize_filter", "downsize_filter", 0, &stat);
	stat = eAttr.addField( "mn_cubic", 0 );
	stat = eAttr.addField( "gauss", 1 );
	stat = eAttr.addField( "sharp", 2 );
	CHECK_MSTATUS(addAttribute( downsize_filter ));

	downsize_filter_cubic_radius = nAttr.create("downsize_filter_cubic_radius", "downsize_filter_cubic_radius",  MFnNumericData::kFloat, 2);
	CHECK_MSTATUS(addAttribute( downsize_filter_cubic_radius ));

	vignetting = nAttr.create("vignetting", "vignetting",  MFnNumericData::kBoolean, true);
	CHECK_MSTATUS(addAttribute( vignetting ));

	gpu = nAttr.create("gpu", "gpu",  MFnNumericData::kBoolean, false);
	CHECK_MSTATUS(addAttribute( gpu ));

	selected_gpu_device = eAttr.create("selected_gpu_device", "selected_gpu_device", 0, &stat);
	stat = eAttr.addField( "CUDA", 0 );
	stat = eAttr.addField( "OPEN_CL", 1 );
	CHECK_MSTATUS(addAttribute( selected_gpu_device ));

	glass_acceleration = nAttr.create("glass_acceleration", "glass_acceleration",  MFnNumericData::kBoolean, false);
	CHECK_MSTATUS(addAttribute( glass_acceleration ));

	environmentType = eAttr.create("environmentType", "environmentType", 1, &stat);
	stat = eAttr.addField( "Off", 0 );
	stat = eAttr.addField( "Color/Map", 1 );
	stat = eAttr.addField( "Sun", 2 );
	CHECK_MSTATUS(addAttribute( environmentType ));

	environmentColor = nAttr.createColor("environmentColor", "environmentColor");
	nAttr.setDefault(0.4,0.4,1.0);
	CHECK_MSTATUS(addAttribute( environmentColor ));

	environmentSun = mAttr.create("environmentSun", "environmentSun");
	CHECK_MSTATUS(addAttribute( environmentSun ));

	turbidity = nAttr.create("turbidity", "turbidity",  MFnNumericData::kFloat, 2.0);
	CHECK_MSTATUS(addAttribute( turbidity ));

	extra_atmospheric = nAttr.create("extra_atmospheric", "extra_atmospheric",  MFnNumericData::kBoolean, false);
	CHECK_MSTATUS(addAttribute( extra_atmospheric ));

	sun_layer = nAttr.create("sun_layer", "sun_layer",  MFnNumericData::kInt, 0);
	CHECK_MSTATUS(addAttribute( sun_layer ));

	sky_layer = nAttr.create("sky_layer", "sky_layer",  MFnNumericData::kInt, 0);
	CHECK_MSTATUS(addAttribute( sky_layer ));

	sky_model = eAttr.create("sky_model", "sky_model", 0, &stat);
	stat = eAttr.addField( "original", 0 );
	stat = eAttr.addField( "captured-simulation", 1 );
	CHECK_MSTATUS(addAttribute( sky_model ));

	environmentMapType = eAttr.create("environmentMapType", "environmentMapType", 0, &stat);
	stat = eAttr.addField( "Spherical", 0 );
	stat = eAttr.addField( "Lat-Long", 1 );
	CHECK_MSTATUS(addAttribute( environmentMapType ));

	environmentMapMultiplier = nAttr.create("environmentMapMultiplier", "environmentMapMultiplier",  MFnNumericData::kFloat, 1.0);
	CHECK_MSTATUS(addAttribute( environmentMapMultiplier ));

	MFnStringData	fnStringData;
	MObject	defaultString;

	defaultString = fnStringData.create( "notepad.exe" );
	preferredTextEditor = tAttr.create("preferredTextEditor", "preferredTextEditor",  MFnNumericData::kString, defaultString);
	CHECK_MSTATUS(addAttribute( preferredTextEditor ));

//	------------- automatically created attributes end ----------- // 

	return stat;

}
예제 #9
0
MStatus mtmEnvLight::initialize()
{
    MFnTypedAttribute tAttr; 
    MFnNumericAttribute nAttr; 
    MFnLightDataAttribute lAttr;
	MFnEnumAttribute eAttr;
	MFnMessageAttribute mAttr;
	MStatus stat;

    //aColor = nAttr.createColor( "color", "c" );
    //CHECK_MSTATUS ( nAttr.setKeyable(true) );
    //CHECK_MSTATUS ( nAttr.setStorable(true) );
    //CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.58824f, 0.644f) );

    aLightColor = nAttr.createColor( "lightColor", "lightColor" );
    CHECK_MSTATUS ( nAttr.setKeyable(true) );
    CHECK_MSTATUS ( nAttr.setStorable(true) );
    nAttr.setDefault(0.7f, 0.58824f, 0.344f);

	aShadowColor = nAttr.createColor( "shadowColor", "sc" );
    CHECK_MSTATUS ( nAttr.setKeyable(true) );
    CHECK_MSTATUS ( nAttr.setStorable(true) );
    CHECK_MSTATUS ( nAttr.setDefault(0.0f, 0.0f, 0.0f) );

    aPosition = nAttr.createPoint( "position", "pos" );
    CHECK_MSTATUS ( nAttr.setKeyable(true) );
    CHECK_MSTATUS ( nAttr.setStorable(true) );

    aInputDirection = nAttr.createPoint( "inputDirection", "id" );
    CHECK_MSTATUS ( nAttr.setKeyable(true) );
    CHECK_MSTATUS ( nAttr.setStorable(true) );
    CHECK_MSTATUS ( nAttr.setDefault(-1.0f, 0.0f, 0.0f) );

    aInputAmbient = nAttr.create( "ambientOn", "an", MFnNumericData::kBoolean);
    CHECK_MSTATUS ( nAttr.setKeyable(true) );
    CHECK_MSTATUS ( nAttr.setStorable(true) );
    CHECK_MSTATUS ( nAttr.setHidden(false) );
    CHECK_MSTATUS ( nAttr.setDefault(true) );

    aInputDiffuse = nAttr.create( "emitDiffuse", "dn", MFnNumericData::kBoolean);
    CHECK_MSTATUS ( nAttr.setKeyable(true) );
    CHECK_MSTATUS ( nAttr.setStorable(true) );
    CHECK_MSTATUS ( nAttr.setHidden(false) );
    CHECK_MSTATUS ( nAttr.setDefault(true) );

    aInputSpecular = nAttr.create( "emitSpecular", "sn", MFnNumericData::kBoolean);
    CHECK_MSTATUS ( nAttr.setKeyable(true) );
    CHECK_MSTATUS ( nAttr.setStorable(true) );
    CHECK_MSTATUS ( nAttr.setHidden(false) );
    CHECK_MSTATUS ( nAttr.setDefault(true) );

    aIntensity = nAttr.create( "intensity", "i", MFnNumericData::kFloat);
    CHECK_MSTATUS ( nAttr.setKeyable(true) );
    CHECK_MSTATUS ( nAttr.setStorable(true) );
    CHECK_MSTATUS ( nAttr.setHidden(false) );
    CHECK_MSTATUS ( nAttr.setDefault(1.0f) );

	samplingquality = nAttr.create( "samplingquality", "samplingquality", MFnNumericData::kFloat, 1.0);
	envmap = tAttr.create( "envmap", "envmap", MFnNumericData::kString);
	tAttr.setUsedAsFilename(true);
	areamap = tAttr.create( "areamap", "areamap", MFnNumericData::kString);
	tAttr.setUsedAsFilename(true);
	areafullsphere = nAttr.create( "areafullsphere", "areafullsphere", MFnNumericData::kBoolean, true);
	envintensity = nAttr.createColor( "envintensity", "envintensity" );
	nAttr.setDefault(1.0f, 1.0f, 1.0f);
	raybackground = nAttr.create( "raybackground", "raybackground", MFnNumericData::kBoolean, false);
	castshadow = nAttr.create( "castshadow", "castshadow", MFnNumericData::kBoolean, true);
	envtype = eAttr.create( "envtype", "envtype", 0, &stat);
	stat = eAttr.addField( "Direct Lighting", 0 );
	stat = eAttr.addField( "Ambient Occlusion", 1 );
	stat = eAttr.addField( "Full Irradiance", 2 );
	stat = eAttr.addField( "Raytrace Background", 3 );
	eAttr.setDefault(0);		
	doraysamples = nAttr.create( "doraysamples", "doraysamples", MFnNumericData::kBoolean, false);
	doadaptive = nAttr.create( "doadaptive", "doadaptive", MFnNumericData::kBoolean, false);
	domaxdist = nAttr.create( "domaxdist", "domaxdist", MFnNumericData::kBoolean, false);
	maxdist = nAttr.create( "maxdist", "maxdist", MFnNumericData::kFloat, 10.0);
	coneangle = nAttr.create( "coneangle", "coneangle", MFnNumericData::kFloat, 45.0);
	envtint = nAttr.createColor( "envtint", "envtint" );
	nAttr.setDefault(1.0f, 1.0f, 1.0f);
	shadowI = nAttr.create( "shadowI", "shadowI", MFnNumericData::kFloat, 1.0);
	samples = nAttr.create( "samples", "samples", MFnNumericData::kInt, 32);
	MFnStringData fnStringData;
	MObject defaultObjectMask;
	defaultObjectMask = fnStringData.create( "*" );
	objectmask = tAttr.create( "objectmask", "objectmask", MFnNumericData::kString, defaultObjectMask);
	usePortalGeometry = nAttr.create( "usePortalGeometry", "usePortalGeometry", MFnNumericData::kBoolean, false);
	portalGeometry = mAttr.create( "portalGeometry", "portalGeometry");
	mAttr.setConnectable(true);
	mAttr.accepts(MFnData::kAny);
	
// Outputs

    aLightDirection = nAttr.createPoint( "lightDirection", "ld" );
    CHECK_MSTATUS ( nAttr.setStorable(false) );
    CHECK_MSTATUS ( nAttr.setHidden(true) );
    CHECK_MSTATUS ( nAttr.setReadable(true) );
    CHECK_MSTATUS ( nAttr.setWritable(false) );
    CHECK_MSTATUS ( nAttr.setDefault(-1.0f, 0.0f, 0.0f) );

    aLightIntensity = nAttr.createColor( "lightIntensity", "li" );
    CHECK_MSTATUS ( nAttr.setStorable(false) );
    CHECK_MSTATUS ( nAttr.setHidden(true) );
    CHECK_MSTATUS ( nAttr.setReadable(true) );
    CHECK_MSTATUS ( nAttr.setWritable(false) );
    CHECK_MSTATUS ( nAttr.setDefault(1.0f, 0.5f, 0.2f) );

    aLightAmbient = nAttr.create( "lightAmbient", "la", 
								  MFnNumericData::kBoolean);
    CHECK_MSTATUS ( nAttr.setStorable(false) );
    CHECK_MSTATUS ( nAttr.setHidden(true) );
    CHECK_MSTATUS ( nAttr.setReadable(true) );
    CHECK_MSTATUS ( nAttr.setWritable(false) );
    nAttr.setDefault(true);

    aLightDiffuse = nAttr.create( "lightDiffuse", "ldf",
								  MFnNumericData::kBoolean);
    CHECK_MSTATUS ( nAttr.setStorable(false) );
    CHECK_MSTATUS ( nAttr.setHidden(true) );
    CHECK_MSTATUS ( nAttr.setReadable(true) );
    CHECK_MSTATUS ( nAttr.setWritable(false) );
    CHECK_MSTATUS ( nAttr.setDefault(true) );

    aLightSpecular = nAttr.create( "lightSpecular", "ls", 
								   MFnNumericData::kBoolean);
    CHECK_MSTATUS ( nAttr.setStorable(false) );
    CHECK_MSTATUS ( nAttr.setHidden(true) );
    CHECK_MSTATUS ( nAttr.setReadable(true) );
    CHECK_MSTATUS ( nAttr.setWritable(false) );
    CHECK_MSTATUS ( nAttr.setDefault(true) );

    aLightShadowFraction = nAttr.create("lightShadowFraction","lsf",
										MFnNumericData::kFloat);
    CHECK_MSTATUS ( nAttr.setStorable(false) );
    CHECK_MSTATUS ( nAttr.setHidden(true) );
    CHECK_MSTATUS ( nAttr.setReadable(true) );
    CHECK_MSTATUS ( nAttr.setWritable(false) );
    CHECK_MSTATUS ( nAttr.setDefault(0.0f) );

    aPreShadowIntensity = nAttr.create("preShadowIntensity","psi",
									   MFnNumericData::kFloat);
    CHECK_MSTATUS ( nAttr.setStorable(false) );
    CHECK_MSTATUS ( nAttr.setHidden(true) );
    CHECK_MSTATUS ( nAttr.setReadable(true) );
    CHECK_MSTATUS ( nAttr.setWritable(false) );
    CHECK_MSTATUS ( nAttr.setDefault(0.0f) );

    aLightBlindData = nAttr.createAddr("lightBlindData","lbld");
    CHECK_MSTATUS ( nAttr.setStorable(false) );
    CHECK_MSTATUS ( nAttr.setHidden(true) );
    CHECK_MSTATUS ( nAttr.setReadable(true) );
    CHECK_MSTATUS ( nAttr.setWritable(false) );

    aLightData = lAttr.create( "lightData", "ltd", 
                               aLightDirection, aLightIntensity, 
							   aLightAmbient, 
                               aLightDiffuse, aLightSpecular, 
							   aLightShadowFraction,
                               aPreShadowIntensity, aLightBlindData);
    CHECK_MSTATUS ( nAttr.setReadable(true) );
    CHECK_MSTATUS ( nAttr.setWritable(false) );
    CHECK_MSTATUS ( lAttr.setStorable(false) );
    CHECK_MSTATUS ( lAttr.setHidden(true) );
    lAttr.setDefault(-1.0f, 0.0f, 0.0f, 1.0f, 0.5f, 0.2f, true, true,
					 true, 0.0f, 1.0f, NULL);

    CHECK_MSTATUS ( addAttribute(coneangle) );
    CHECK_MSTATUS ( addAttribute(samples) );
    CHECK_MSTATUS ( addAttribute(objectmask) );
    CHECK_MSTATUS ( addAttribute(shadowI) );
    CHECK_MSTATUS ( addAttribute(envtint) );
    CHECK_MSTATUS ( addAttribute(maxdist) );
    CHECK_MSTATUS ( addAttribute(domaxdist) );
    CHECK_MSTATUS ( addAttribute(doadaptive) );
    CHECK_MSTATUS ( addAttribute(doraysamples) );
    CHECK_MSTATUS ( addAttribute(envtype) );
    CHECK_MSTATUS ( addAttribute(castshadow) );
    CHECK_MSTATUS ( addAttribute(raybackground) );
    CHECK_MSTATUS ( addAttribute(envintensity) );
    CHECK_MSTATUS ( addAttribute(areafullsphere) );
    CHECK_MSTATUS ( addAttribute(areamap) );
    CHECK_MSTATUS ( addAttribute(envmap) );
    CHECK_MSTATUS ( addAttribute(samplingquality) );
    CHECK_MSTATUS ( addAttribute(usePortalGeometry) );
    CHECK_MSTATUS ( addAttribute(portalGeometry) );
	

    //CHECK_MSTATUS ( addAttribute(aColor) );
    CHECK_MSTATUS ( addAttribute(aLightColor) );
    CHECK_MSTATUS ( addAttribute(aShadowColor) );
    CHECK_MSTATUS ( addAttribute(aPosition) );
    CHECK_MSTATUS ( addAttribute(aInputDirection) );
    CHECK_MSTATUS ( addAttribute(aInputAmbient) );
    CHECK_MSTATUS ( addAttribute(aInputDiffuse) );
    CHECK_MSTATUS ( addAttribute(aInputSpecular) );
    CHECK_MSTATUS ( addAttribute(aIntensity) );
	
    CHECK_MSTATUS ( addAttribute(aLightData) );

    CHECK_MSTATUS ( attributeAffects (aLightIntensity, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aLightDirection, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aLightAmbient, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aLightDiffuse, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aLightSpecular, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aLightShadowFraction, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aPreShadowIntensity, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aLightBlindData, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aLightData, aLightData) );

    //CHECK_MSTATUS ( attributeAffects (aColor, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aPosition, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aInputDirection, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aInputAmbient, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aInputDiffuse, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aInputSpecular, aLightData) );
    CHECK_MSTATUS ( attributeAffects (aIntensity, aLightData) );

    return MS::kSuccess;
}
예제 #10
0
MStatus uiDrawManager::initialize()
{
    MStatus status;

    MFnNumericAttribute nAttr;
    MFnEnumAttribute eAttr;
    MFnTypedAttribute typedAttr;

    // Add ui type attribute
    aUIType = eAttr.create("uiType", "ut", uiDrawManager::kText);
    eAttr.addField("text", uiDrawManager::kText);
    eAttr.addField("line", uiDrawManager::kLine);
    eAttr.addField("point", uiDrawManager::kPoint);
    eAttr.addField("rect", uiDrawManager::kRect);    
    eAttr.addField("quad", uiDrawManager::kQuad);
    eAttr.addField("sphere", uiDrawManager::kSphere);
    eAttr.addField("circle", uiDrawManager::kCircle);    
    eAttr.addField("arc", uiDrawManager::kArc);    
    eAttr.addField("line list", uiDrawManager::kLineList);
    eAttr.addField("line strip", uiDrawManager::kLineStrip);
    eAttr.addField("point list", uiDrawManager::kPointList);
    eAttr.addField("icon", uiDrawManager::kIcon);
    eAttr.addField("cone", uiDrawManager::kCone);
    eAttr.addField("box", uiDrawManager::kBox);
    MPxNode::addAttribute(aUIType);

    // Add color attribute
    aPrimitiveColor = nAttr.create("primitiveColor", "pc", MFnNumericData::k3Float);
    nAttr.setDefault(1.0f, 0.0f, 0.0f);
    nAttr.setUsedAsColor(true);
    MPxNode::addAttribute(aPrimitiveColor);

    // Add transparency attribute
    aPrimitiveTransparency = nAttr.create("primitiveTransparency", "pt", MFnNumericData::kFloat, 0.0);
    nAttr.setSoftMin(0.0);
    nAttr.setSoftMax(1.0);    
    MPxNode::addAttribute(aPrimitiveTransparency);

    // add line width and line style attributes
    aLineWidth = nAttr.create("lineWidth", "lw", MFnNumericData::kFloat, 2.0);
    MPxNode::addAttribute(aLineWidth);

    aLineStyle = eAttr.create("lineStyle", "ls", MUIDrawManager::kSolid);
    eAttr.addField("solid", MUIDrawManager::kSolid);
    eAttr.addField("shortdotted", MUIDrawManager::kShortDotted);
    eAttr.addField("shortdashed", MUIDrawManager::kShortDashed);
    eAttr.addField("dashed", MUIDrawManager::kDashed);
    eAttr.addField("dotted", MUIDrawManager::kDotted);
    MPxNode::addAttribute(aLineStyle);

    // Add filled attribute
    aIsFilled = nAttr.create("isFilled", "if", MFnNumericData::kBoolean, 0);    
    MPxNode::addAttribute(aIsFilled);

    // Add shaded attribute
    aShaded = nAttr.create("shaded", "sd", MFnNumericData::kBoolean, 0);    
    MPxNode::addAttribute(aShaded);

    // Add radius attribute
    aRadius = nAttr.create("radius", "ra", MFnNumericData::kDouble, 1.0);
    MPxNode::addAttribute(aRadius);

    // add 2D attributes
    aDraw2D = nAttr.create("draw2D", "d2", MFnNumericData::kBoolean, 0);
    MPxNode::addAttribute(aDraw2D);

    aPosition = nAttr.create("position", "pos", MFnNumericData::k3Double);
    nAttr.setDefault(0.0, 0.0, 0.001);
    MPxNode::addAttribute(aPosition);

    // Add text attributes.
    MFnStringData stringFn;
    MObject defaultText = stringFn.create("uiDrawManager-Text");
    aText = typedAttr.create("text", "t", MFnData::kString, defaultText);
    MPxNode::addAttribute(aText);    

    aTextFontSize = nAttr.create("textFontSize", "tfs", MFnNumericData::kInt, MUIDrawManager::kDefaultFontSize);
    nAttr.setMin(-1);
    nAttr.setMax(99);    
    MPxNode::addAttribute(aTextFontSize);

    unsigned int nFont = MUIDrawManager::getFontList(uiDrawManagerData::fFontList);
    if (nFont == 0)
    {
        perror("No font available!");
    }
    aFontFaceName = eAttr.create("fontFaceName", "ffn", 0);
    for (unsigned int i = 0; i < nFont; i++)
    {
        MString str = uiDrawManagerData::fFontList[i];
        eAttr.addField(str, (short)i);
    }
    MPxNode::addAttribute(aFontFaceName);

    aTextAlignment = eAttr.create("textAlignment", "ta", MUIDrawManager::kLeft);
    eAttr.addField("left", MUIDrawManager::kLeft);
    eAttr.addField("center", MUIDrawManager::kCenter);
    eAttr.addField("right", MUIDrawManager::kRight);
    MPxNode::addAttribute(aTextAlignment);    

    eTextIncline = eAttr.create("textIncline", "tic", MUIDrawManager::kInclineNormal);
    eAttr.addField("normal", MUIDrawManager::kInclineNormal);
    eAttr.addField("italic", MUIDrawManager::kInclineItalic);
    MPxNode::addAttribute(eTextIncline);    

    aTextWeight = eAttr.create("textWeight", "tw", MUIDrawManager::kWeightBold);
    eAttr.addField("light", MUIDrawManager::kWeightLight);
	eAttr.addField("normal", MUIDrawManager::kWeightNormal);
	eAttr.addField("demiBold", MUIDrawManager::kWeightDemiBold);
	eAttr.addField("bold", MUIDrawManager::kWeightBold);
	eAttr.addField("black", MUIDrawManager::kWeightBlack);
    MPxNode::addAttribute(aTextWeight);

    aTextStretch = nAttr.create("textStretch", "ts", MFnNumericData::kInt, MUIDrawManager::kStretchUnstretched);
    nAttr.setMin(50);
    nAttr.setMax(200);
    MPxNode::addAttribute(aTextStretch);

    aTextLine = eAttr.create("textLine", "tl", 0);
    eAttr.addField("none", 0);
    eAttr.addField("overline", MUIDrawManager::kLineOverline);
    eAttr.addField("underline", MUIDrawManager::kLineUnderline);
    eAttr.addField("strikeout", MUIDrawManager::kLineStrikeoutLine);
    MPxNode::addAttribute(aTextLine);    

    aTextBoxSize = nAttr.create("textBoxSize", "tbs", MFnNumericData::k2Int);
    nAttr.setDefault(0, 0);
    MPxNode::addAttribute(aTextBoxSize);

    aTextBoxColor = nAttr.create("textBoxColor", "tbc", MFnNumericData::k3Float);
    nAttr.setDefault(0.0f, 1.0f, 1.0f);
    nAttr.setUsedAsColor(true);
    MPxNode::addAttribute(aTextBoxColor);

    aTextBoxTransparency = nAttr.create("textBoxTransparency", "tbt", MFnNumericData::kFloat, 0.0);
    nAttr.setSoftMin(0.0);
    nAttr.setSoftMax(1.0);    
    MPxNode::addAttribute(aTextBoxTransparency);
    
    // add point attributes
    aPointSize = nAttr.create("pointSize", "ps", MFnNumericData::kFloat, 2.0);
    MPxNode::addAttribute(aPointSize);

    // add line attributes
    aLineStartPoint = nAttr.create("lineStartPoint", "lsp", MFnNumericData::k3Double);
    nAttr.setDefault(0.0, 0.0, 0.0);
    MPxNode::addAttribute(aLineStartPoint);

    aLineEndPoint = nAttr.create("lineEndPoint", "lep", MFnNumericData::k3Double);
    nAttr.setDefault(1.0, 1.0, 1.0);
    MPxNode::addAttribute(aLineEndPoint);

    // add rect attributes
    aRectUp = nAttr.create("rectUp", "ru", MFnNumericData::k3Double);
    nAttr.setDefault(0.0, 1.0, 0.0);
    MPxNode::addAttribute(aRectUp);

    aRectNormal = nAttr.create("rectNormal", "rn", MFnNumericData::k3Double);
    nAttr.setDefault(0.0, 0.0, 1.0);
    MPxNode::addAttribute(aRectNormal);

    aRectScale = nAttr.create("rectScale", "rs", MFnNumericData::k2Double);
    nAttr.setDefault(1.0, 1.0);
    MPxNode::addAttribute(aRectScale);

    // add quad attributes
    double defaultPosition[4][3] = 
    {
        {0.0, 0.0, 0.0},
        {1.0, 0.0, 0.0},
        {1.0, 1.0, 0.0},
        {0.0, 1.0, 0.0}
    };
    for (int i = 0; i < 4;  ++i)
    {
        MString fullName = "quadVertex";
        MString shortName = "qv";
        aQuadVertex[i] = nAttr.create(fullName + i, shortName + i, MFnNumericData::k3Double);
        nAttr.setDefault(defaultPosition[i][0], defaultPosition[i][1], defaultPosition[i][2]);
        MPxNode::addAttribute(aQuadVertex[i]);
    }

    // add circle attributes
    aCircleNormal = nAttr.create("circleNormal", "cn", MFnNumericData::k3Double);
    nAttr.setDefault(0.0, 0.0, 1.0);
    MPxNode::addAttribute(aCircleNormal);

    // add arc attributes
    aArcStart = nAttr.create("arcStartVector", "asv", MFnNumericData::k3Double);
    nAttr.setDefault(1.0, 0.0, 0.0);
    MPxNode::addAttribute(aArcStart);

    aArcEnd = nAttr.create("arcEndVector", "aev", MFnNumericData::k3Double);
    nAttr.setDefault(0.0, 1.0, 0.0);
    MPxNode::addAttribute(aArcEnd);

    aArcNormal = nAttr.create("arcNormal", "an", MFnNumericData::k3Double);
    nAttr.setDefault(0.0, 0.0, 1.0);
    MPxNode::addAttribute(aArcNormal);

	// icon attributes
	aIconName = eAttr.create("icon", "i", 0 );
	unsigned int iconCount = MUIDrawManager::getIconNames(uiDrawManagerData::fIconList);
	for (unsigned int i=0; i<iconCount; i++)
	{
		MString str = uiDrawManagerData::fIconList[i];
        eAttr.addField(str, (short)i);
	}
	MPxNode::addAttribute(aIconName);

	aIconScale = nAttr.create("iconScale", "cs", MFnNumericData::kFloat, 1.0);
    MPxNode::addAttribute(aIconScale);

	// cone attributes
	aConeDirection = nAttr.create("coneDirection", "cd", MFnNumericData::k3Double);
    nAttr.setDefault(0.0, 0.0, 1.0);
    MPxNode::addAttribute(aConeDirection);

	aConeHeight = nAttr.create("coneHeight", "ch", MFnNumericData::kDouble);
    nAttr.setDefault(1.0);
    MPxNode::addAttribute(aConeHeight);

	// box attributes
	aBoxUp = nAttr.create("boxUp", "bu", MFnNumericData::k3Double);
    nAttr.setDefault(0.0, 0.0, 1.0);
    MPxNode::addAttribute(aBoxUp);

	aBoxRight = nAttr.create("boxRight", "br", MFnNumericData::k3Double);
    nAttr.setDefault(0.0, 1.0, 0.0);
    MPxNode::addAttribute(aBoxRight);

	aBoxScale = nAttr.create("boxScale", "bs", MFnNumericData::k3Double);
    nAttr.setDefault(1.0, 1.0, 1.0);
    MPxNode::addAttribute(aBoxScale);

	return MS::kSuccess;
}
MStatus OccLightNode::initialize()
{
	MFnTypedAttribute   tAttr;
	MFnStringData       tDefault;
	MFnNumericAttribute nAttr;
	MFnEnumAttribute    eAttr;
	MFnLightDataAttribute lAttr;
	MStatus status;
	MObject string;

	// Create input attributes
	aRmanShader = tAttr.create( MString("rmanShader"), MString("rms"), MFnData::kString, tDefault.create(getTypeName()), &status );
	MAKE_INPUT(tAttr);

	aRmanShaderType = tAttr.create( MString("rmanShaderType"), MString("rst"), MFnData::kString, tDefault.create(getShaderClasscification()), &status );
	MAKE_INPUT(tAttr);

	aRmanShaderLong = tAttr.create( MString("rmanShaderLong"), MString("rml"), MFnData::kString, aRmanShaderLong, &status );
	MAKE_INPUT(tAttr);

	aRmanShaderLif = tAttr.create(  MString("rmanShaderLif"),  MString("lif"), MFnData::kString, aRmanShaderLif, &status );
	MAKE_INPUT(tAttr);

	aRmanParams = tAttr.create(  MString("rmanParams"),  MString("rpr"), MFnData::kStringArray, aRmanParams, &status );
	MAKE_INPUT(tAttr);

	aRmanDetails = tAttr.create(  MString("rmanDetails"),  MString("rdt"), MFnData::kStringArray, aRmanDetails, &status );
	MAKE_INPUT(tAttr);

	aRmanTypes = tAttr.create(  MString("rmanTypes"),  MString("rty"), MFnData::kStringArray, aRmanTypes, &status );
	MAKE_INPUT(tAttr);

	aRmanDefaults = tAttr.create(  MString("rmanDefaults"),  MString("rdf"), MFnData::kStringArray, aRmanDefaults, &status );
	MAKE_INPUT(tAttr);

	aRmanArraySizes = tAttr.create(  MString("rmanArraySizes"),  MString("ras"), MFnData::kIntArray, aRmanArraySizes, &status );
	MAKE_INPUT(tAttr);

	aRmanLifCmds = tAttr.create(  MString("rmanLifCmds"),  MString("rlc"), MFnData::kStringArray, aRmanLifCmds, &status );
	MAKE_INPUT(tAttr);

	aRmanMethods = tAttr.create(  MString("rmanMethods"),  MString("rmt"), MFnData::kStringArray, aRmanMethods, &status );
	MAKE_INPUT(tAttr);

	aRmanIsOutput = tAttr.create(  MString("rmanIsOutput"),  MString("rio"), MFnData::kIntArray, aRmanIsOutput, &status );
	MAKE_INPUT(tAttr);

	aRmanAccept = tAttr.create(  MString("rmanAccept"),  MString("rma"), MFnData::kStringArray, aRmanAccept, &status );
	MAKE_INPUT(tAttr);


	aOutColor = nAttr.createColor("outColor", "oc");
	MAKE_OUTPUT(nAttr);
	aOutTransparency = nAttr.createColor("outTransparency", "ot");
	MAKE_OUTPUT(nAttr);

	IfMErrorWarn( addAttribute( aRmanShader ) );
	IfMErrorWarn( addAttribute( aRmanShaderType ) );
	IfMErrorWarn( addAttribute( aRmanShaderLong ) );
	IfMErrorWarn( addAttribute( aRmanShaderLif ) );
	IfMErrorWarn( addAttribute( aRmanParams ) );
	IfMErrorWarn( addAttribute( aRmanDetails ) );
	IfMErrorWarn( addAttribute( aRmanTypes ) );
	IfMErrorWarn( addAttribute( aRmanDefaults ) );
	IfMErrorWarn( addAttribute( aRmanArraySizes ) );
	IfMErrorWarn( addAttribute( aRmanLifCmds ) );
	IfMErrorWarn( addAttribute( aRmanMethods) );
	IfMErrorWarn( addAttribute( aRmanIsOutput) );
	IfMErrorWarn( addAttribute( aRmanAccept) );

	IfMErrorWarn( addAttribute( aOutColor ) );
	IfMErrorWarn( addAttribute( aOutTransparency ) );

	initialize_shader_parameters();

	return MS::kSuccess;
}
예제 #12
0
MStatus liqDisplacementNode::initialize()
{
  MFnTypedAttribute   tAttr;
  MFnStringData       tDefault;
  MFnNumericAttribute nAttr;
  MFnMessageAttribute mAttr;
  MFnEnumAttribute    eAttr;
  MStatus status;

  // Create input attributes

  aRmanShader = tAttr.create( MString("rmanShader"), MString("rms"), MFnData::kString, aRmanShader, &status );
  MAKE_INPUT(tAttr);

  aRmanShaderLong = tAttr.create( MString("rmanShaderLong"), MString("rml"), MFnData::kString, aRmanShaderLong, &status );
  MAKE_INPUT(tAttr);

  aRmanShaderLif = tAttr.create(  MString("rmanShaderLif"),  MString("lif"), MFnData::kString, aRmanShaderLif, &status );
  MAKE_INPUT(tAttr);

  aRmanParams = tAttr.create(  MString("rmanParams"),  MString("rpr"), MFnData::kStringArray, aRmanParams, &status );
  MAKE_INPUT(tAttr);

  aRmanDetails = tAttr.create(  MString("rmanDetails"),  MString("rdt"), MFnData::kStringArray, aRmanDetails, &status );
  MAKE_INPUT(tAttr);

  aRmanTypes = tAttr.create(  MString("rmanTypes"),  MString("rty"), MFnData::kStringArray, aRmanTypes, &status );
  MAKE_INPUT(tAttr);

  aRmanDefaults = tAttr.create(  MString("rmanDefaults"),  MString("rdf"), MFnData::kStringArray, aRmanDefaults, &status );
  MAKE_INPUT(tAttr);

  aRmanArraySizes = tAttr.create(  MString("rmanArraySizes"),  MString("ras"), MFnData::kIntArray, aRmanArraySizes, &status );
  MAKE_INPUT(tAttr);

  aRmanLifCmds = tAttr.create(  MString("rmanLifCmds"),  MString("rlc"), MFnData::kStringArray, aRmanLifCmds, &status );
  MAKE_INPUT(tAttr);

  aPreviewPrimitive = eAttr.create( "previewPrimitive", "pvp", 7, &status );
  eAttr.addField( "Sphere",   0 );
  eAttr.addField( "Cube",     1 );
  eAttr.addField( "Cylinder", 2 );
  eAttr.addField( "Torus",    3 );
  eAttr.addField( "Plane",    4 );
  eAttr.addField( "Teapot",   5 );
  eAttr.addField( "Custom",   6 );
  eAttr.addField( "(globals)",7 );
  MAKE_NONKEYABLE_INPUT(eAttr);
  CHECK_MSTATUS(eAttr.setConnectable(false));

  aPreviewCustomPrimitive = tAttr.create(  MString("previewCustomPrimitive"),  MString("pcp"), MFnData::kString, aPreviewCustomPrimitive, &status );
  MAKE_INPUT(tAttr);

  aPreviewCustomBackplane = tAttr.create(  MString("previewCustomBackplane"),  MString("pcb"), MFnData::kString, aPreviewCustomBackplane, &status );
  MAKE_INPUT(tAttr);

  aPreviewObjectSize = nAttr.create("previewObjectSize", "pos", MFnNumericData::kDouble, 1.0, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setConnectable(false));

  aPreviewPixelSamples = nAttr.create("previewPixelSamples", "pxs",  MFnNumericData::kInt, 3, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setConnectable(false));


  aPreviewShadingRate = nAttr.create("previewShadingRate", "psr", MFnNumericData::kDouble, 1.0, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setConnectable(false));

  aPreviewBackplane = nAttr.create("previewBackplane", "pbp", MFnNumericData::kBoolean, true, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setConnectable(false));

  aShaderSpace = tAttr.create( MString("shaderSpace"), MString("ssp"), MFnData::kString, aShaderSpace, &status );
  MAKE_INPUT(tAttr);

  aDisplacementBound = nAttr.create("displacementBound", "db", MFnNumericData::kDouble, 0.0, &status);
  MAKE_INPUT(nAttr);

  MObject defaultSpaceObj = tDefault.create( MString("shader"), &status);
  aDisplacementBoundSpace = tAttr.create( MString("displacementBoundSpace"), MString("dbs"), MFnData::kString, defaultSpaceObj, &status );
  MAKE_INPUT(tAttr);

  aOutputInShadow = nAttr.create("outputInShadow", "ois",  MFnNumericData::kBoolean, 0.0, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);

  // refreshPreview must be true to allow refresh
  aRefreshPreview = nAttr.create("refreshPreview", "rfp",  MFnNumericData::kBoolean, 0.0, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setHidden(true));

  // Create output attributes
  aDisplacement = nAttr.create("displacement", "d", MFnNumericData::kFloat, 0.0, &status);
  MAKE_OUTPUT(nAttr);
  aOutColor = nAttr.createColor("outColor", "oc");
  MAKE_OUTPUT(nAttr);
  aAssignedObjects = mAttr.create("liqAssignedObjects", "ao");
  MAKE_OUTPUT(mAttr);

  CHECK_MSTATUS(addAttribute(aRmanShader));
  CHECK_MSTATUS(addAttribute(aRmanShaderLong));
  CHECK_MSTATUS(addAttribute(aRmanShaderLif));
  CHECK_MSTATUS(addAttribute(aRmanParams));
  CHECK_MSTATUS(addAttribute(aRmanDetails));
  CHECK_MSTATUS(addAttribute(aRmanTypes));
  CHECK_MSTATUS(addAttribute(aRmanDefaults));
  CHECK_MSTATUS(addAttribute(aRmanArraySizes));
  CHECK_MSTATUS(addAttribute(aRmanLifCmds));

  CHECK_MSTATUS(addAttribute(aPreviewPrimitive));
  CHECK_MSTATUS(addAttribute(aPreviewCustomPrimitive));
  CHECK_MSTATUS(addAttribute(aPreviewCustomBackplane));
  CHECK_MSTATUS(addAttribute(aPreviewObjectSize));
  CHECK_MSTATUS(addAttribute(aPreviewPixelSamples));
  CHECK_MSTATUS(addAttribute(aPreviewShadingRate));
  CHECK_MSTATUS(addAttribute(aPreviewBackplane));
  CHECK_MSTATUS(addAttribute(aShaderSpace));
  CHECK_MSTATUS(addAttribute(aDisplacementBound));
  CHECK_MSTATUS(addAttribute(aDisplacementBoundSpace));
  CHECK_MSTATUS(addAttribute(aOutputInShadow));
  CHECK_MSTATUS(addAttribute(aRefreshPreview));

  CHECK_MSTATUS(addAttribute(aAssignedObjects));
  CHECK_MSTATUS(addAttribute(aDisplacement));
  CHECK_MSTATUS(addAttribute(aOutColor));

  CHECK_MSTATUS(attributeAffects(aRmanShaderLong, aDisplacement));
  CHECK_MSTATUS(attributeAffects(aRmanShaderLif, aDisplacement));

  return MS::kSuccess;
}
예제 #13
0
MStatus liqSurfaceNode::initialize()
{
  MFnTypedAttribute   tAttr;
  MFnStringData       tDefault;
  MFnNumericAttribute nAttr;
  MFnEnumAttribute    eAttr;
  MFnMessageAttribute mAttr;
  MFnLightDataAttribute lAttr;
  MStatus status;

  // Create input attributes

  aRmanShader = tAttr.create( MString("rmanShader"), MString("rms"), MFnData::kString, aRmanShader, &status );
  MAKE_INPUT(tAttr);

  aRmanShaderLong = tAttr.create( MString("rmanShaderLong"), MString("rml"), MFnData::kString, aRmanShaderLong, &status );
  MAKE_INPUT(tAttr);

  aRmanShaderLif = tAttr.create(  MString("rmanShaderLif"),  MString("lif"), MFnData::kString, aRmanShaderLif, &status );
  MAKE_INPUT(tAttr);

  aRmanParams = tAttr.create(  MString("rmanParams"),  MString("rpr"), MFnData::kStringArray, aRmanParams, &status );
  MAKE_INPUT(tAttr);

  aRmanDetails = tAttr.create(  MString("rmanDetails"),  MString("rdt"), MFnData::kStringArray, aRmanDetails, &status );
  MAKE_INPUT(tAttr);

  aRmanTypes = tAttr.create(  MString("rmanTypes"),  MString("rty"), MFnData::kStringArray, aRmanTypes, &status );
  MAKE_INPUT(tAttr);

  aRmanDefaults = tAttr.create(  MString("rmanDefaults"),  MString("rdf"), MFnData::kStringArray, aRmanDefaults, &status );
  MAKE_INPUT(tAttr);

  aRmanArraySizes = tAttr.create(  MString("rmanArraySizes"),  MString("ras"), MFnData::kIntArray, aRmanArraySizes, &status );
  MAKE_INPUT(tAttr);

  aRmanLifCmds = tAttr.create(  MString("rmanLifCmds"),  MString("rlc"), MFnData::kStringArray, aRmanLifCmds, &status );
  MAKE_INPUT(tAttr);

  aPreviewPrimitive = eAttr.create( "previewPrimitive", "pvp", 7, &status );
  eAttr.addField( "Sphere",   0 );
  eAttr.addField( "Cube",     1 );
  eAttr.addField( "Cylinder", 2 );
  eAttr.addField( "Torus",    3 );
  eAttr.addField( "Plane",    4 );
  eAttr.addField( "Teapot",   5 );
  eAttr.addField( "Custom",   6 );
  eAttr.addField( "(globals)",7 );
  MAKE_NONKEYABLE_INPUT(eAttr);
  CHECK_MSTATUS(eAttr.setConnectable(false));

  aPreviewCustomPrimitive = tAttr.create(  MString("previewCustomPrimitive"),  MString("pcp"), MFnData::kString, aPreviewCustomPrimitive, &status );
  MAKE_INPUT(tAttr);

  aPreviewCustomBackplane = tAttr.create(  MString("previewCustomBackplane"),  MString("pcb"), MFnData::kString, aPreviewCustomBackplane, &status );
  MAKE_INPUT(tAttr);

  aPreviewCustomLightRig = tAttr.create(  MString("previewCustomLights"),  MString("pcl"), MFnData::kString, aPreviewCustomLightRig, &status );
  MAKE_INPUT(tAttr);

  aPreviewObjectSize = nAttr.create("previewObjectSize", "pos", MFnNumericData::kDouble, 1.0, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setConnectable(false));

  aPreviewPixelSamples = nAttr.create("previewPixelSamples", "pxs",  MFnNumericData::kInt, 3, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setConnectable(false));

  aPreviewShadingRate = nAttr.create("previewShadingRate", "psr", MFnNumericData::kDouble, 1.0, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setConnectable(false));

  aPreviewBackplane = nAttr.create("previewBackplane", "pbp", MFnNumericData::kBoolean, true, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setConnectable(false));

  aPreviewIntensity = nAttr.create("previewIntensity", "pi", MFnNumericData::kDouble, 1.0, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setConnectable(false));

  aGLPreviewTexture = nAttr.createColor("GLPreviewTexture", "gpt");
  nAttr.setDefault( -1.0, -1.0, -1.0 );
  nAttr.setDisconnectBehavior( MFnAttribute::kReset );
  MAKE_INPUT(nAttr);



  aColor = nAttr.createColor("color", "cs");
  nAttr.setDefault( 1.0, 1.0, 1.0 );
  nAttr.setDisconnectBehavior( MFnAttribute::kReset );
  MAKE_INPUT(nAttr);

  aOpacity = nAttr.createColor("opacity", "os");
  nAttr.setDefault( 1.0, 1.0, 1.0 );
  MAKE_INPUT(nAttr);

  aShaderSpace = tAttr.create( MString("shaderSpace"), MString("ssp"), MFnData::kString, aShaderSpace, &status );
  MAKE_INPUT(tAttr);

  aDisplacementBound = nAttr.create("displacementBound", "db", MFnNumericData::kDouble, 0.0, &status);
  MAKE_INPUT(nAttr);

  MObject defaultSpaceObj = tDefault.create( MString("shader"), &status);
  aDisplacementBoundSpace = tAttr.create( MString("displacementBoundSpace"), MString("dbs"), MFnData::kString, defaultSpaceObj, &status );
  MAKE_INPUT(tAttr);

  aOutputInShadow = nAttr.create("outputInShadow", "ois",  MFnNumericData::kBoolean, 0.0, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);

  // resolution attribute for maya's hardware renderer
  aResolution = nAttr.create("resolution", "res",  MFnNumericData::kInt, 8, &status);
  CHECK_MSTATUS(nAttr.setStorable( true ));
  CHECK_MSTATUS(nAttr.setReadable( true ));
  CHECK_MSTATUS(nAttr.setWritable( true ));
  CHECK_MSTATUS(nAttr.setHidden( true ));

  // refreshPreview must be true to allow refresh
  aRefreshPreview = nAttr.create("refreshPreview", "rfp",  MFnNumericData::kBoolean, 0.0, &status);
  MAKE_NONKEYABLE_INPUT(nAttr);
  CHECK_MSTATUS(nAttr.setHidden(true));

  // dynamic shader attr
  aCi = nAttr.createColor("Ci", "ci");
  nAttr.setDefault( 1.0, 1.0, 1.0 );
  MAKE_INPUT(nAttr);

  aOi = nAttr.createColor("Oi", "oi");
  nAttr.setDefault( 1.0, 1.0, 1.0 );
  MAKE_INPUT(nAttr);


  // create attributes for maya renderer

  // lambertian control
  aMayaIgnoreLights = nAttr.create("mayaIgnoreLights", "mil",  MFnNumericData::kBoolean, 0.0, &status);
  MAKE_INPUT(nAttr);
  aMayaKa = nAttr.create("mayaKa", "mka", MFnNumericData::kFloat, 0.2, &status);
  MAKE_INPUT(nAttr);
  aMayaKd = nAttr.create("mayaKd", "mkd", MFnNumericData::kFloat, 0.8, &status);
  MAKE_INPUT(nAttr);

  // Camera Normals
  aNormalCameraX = nAttr.create( "normalCameraX", "nx", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  aNormalCameraY = nAttr.create( "normalCameraY", "ny", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  aNormalCameraZ = nAttr.create( "normalCameraZ", "nz", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  aNormalCamera = nAttr.create( "normalCamera","n", aNormalCameraX, aNormalCameraY, aNormalCameraZ, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f, 1.0f, 1.0f ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );

  // Light Direction
  aLightDirectionX = nAttr.create( "lightDirectionX", "ldx", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  aLightDirectionY = nAttr.create( "lightDirectionY", "ldy", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  aLightDirectionZ = nAttr.create( "lightDirectionZ", "ldz", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  aLightDirection = nAttr.create( "lightDirection", "ld", aLightDirectionX, aLightDirectionY, aLightDirectionZ, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f, 1.0f, 1.0f ) );

  // Light Intensity
  aLightIntensityR = nAttr.create( "lightIntensityR", "lir", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  aLightIntensityG = nAttr.create( "lightIntensityG", "lig", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  aLightIntensityB = nAttr.create( "lightIntensityB", "lib", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  aLightIntensity = nAttr.create( "lightIntensity", "li", aLightIntensityR, aLightIntensityG, aLightIntensityB, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f, 1.0f, 1.0f ) );

  // Light
  aLightAmbient = nAttr.create( "lightAmbient", "la", MFnNumericData::kBoolean, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( true ) );
  aLightDiffuse = nAttr.create( "lightDiffuse", "ldf", MFnNumericData::kBoolean, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( true ) );
  aLightSpecular = nAttr.create( "lightSpecular", "ls", MFnNumericData::kBoolean, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( false ) );
  aLightShadowFraction = nAttr.create( "lightShadowFraction", "lsf", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setReadable( true ) );
  CHECK_MSTATUS( nAttr.setWritable( true ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );
  aPreShadowIntensity = nAttr.create( "preShadowIntensity", "psi", MFnNumericData::kFloat, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 1.0f ) );

  #if MAYA_API_VERSION >= 800
  aLightBlindData = nAttr.createAddr( "lightBlindData", "lbld", 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( (void*) 0 ) );
  #else
  aLightBlindData = nAttr.create( "lightBlindData", "lbld", MFnNumericData::kLong, 0, &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( nAttr.setStorable( false ) );
  CHECK_MSTATUS( nAttr.setHidden( true ) );
  CHECK_MSTATUS( nAttr.setReadable( false ) );
  CHECK_MSTATUS( nAttr.setDefault( 0 ) );
  #endif
  aLightData = lAttr.create( "lightDataArray", "ltd", aLightDirection,
                              aLightIntensity, aLightAmbient, aLightDiffuse, aLightSpecular,
                              aLightShadowFraction, aPreShadowIntensity, aLightBlindData,
                              &status );
  CHECK_MSTATUS( status );
  CHECK_MSTATUS( lAttr.setArray( true ) );
  CHECK_MSTATUS( lAttr.setStorable( false ) );
  CHECK_MSTATUS( lAttr.setHidden( true ) );
  CHECK_MSTATUS( lAttr.setDefault( 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, true, true, false, 1.0f, 1.0f, 0 ) );

  // Create output attributes
  aOutColor = nAttr.createColor("outColor", "oc");
  MAKE_OUTPUT(nAttr);
  aOutTransparency = nAttr.createColor("outTransparency", "ot");
  MAKE_OUTPUT(nAttr);
  aAssignedObjects = mAttr.create("liqAssignedObjects", "ao");
  MAKE_OUTPUT(mAttr);


  CHECK_MSTATUS(addAttribute(aRmanShader));
  CHECK_MSTATUS(addAttribute(aRmanShaderLong));
  CHECK_MSTATUS(addAttribute(aRmanShaderLif));
  CHECK_MSTATUS(addAttribute(aRmanParams));
  CHECK_MSTATUS(addAttribute(aRmanDetails));
  CHECK_MSTATUS(addAttribute(aRmanTypes));
  CHECK_MSTATUS(addAttribute(aRmanDefaults));
  CHECK_MSTATUS(addAttribute(aRmanArraySizes));
  CHECK_MSTATUS(addAttribute(aRmanLifCmds));

  CHECK_MSTATUS(addAttribute(aPreviewPrimitive));
  CHECK_MSTATUS(addAttribute(aPreviewCustomPrimitive));
  CHECK_MSTATUS(addAttribute(aPreviewCustomBackplane));
  CHECK_MSTATUS(addAttribute(aPreviewCustomLightRig));
  CHECK_MSTATUS(addAttribute(aPreviewObjectSize));
  CHECK_MSTATUS(addAttribute(aPreviewPixelSamples));
  CHECK_MSTATUS(addAttribute(aPreviewShadingRate));
  CHECK_MSTATUS(addAttribute(aPreviewBackplane));
  CHECK_MSTATUS(addAttribute(aPreviewIntensity));
  CHECK_MSTATUS(addAttribute(aGLPreviewTexture));
  CHECK_MSTATUS(addAttribute(aCi));
  CHECK_MSTATUS(addAttribute(aOi));

  CHECK_MSTATUS(addAttribute(aColor));
  CHECK_MSTATUS(addAttribute(aOpacity));
  CHECK_MSTATUS(addAttribute(aShaderSpace));
  CHECK_MSTATUS(addAttribute(aDisplacementBound));
  CHECK_MSTATUS(addAttribute(aDisplacementBoundSpace));
  CHECK_MSTATUS(addAttribute(aOutputInShadow));
  CHECK_MSTATUS(addAttribute(aResolution));
  CHECK_MSTATUS(addAttribute(aRefreshPreview));
  CHECK_MSTATUS(addAttribute(aMayaIgnoreLights));
  CHECK_MSTATUS(addAttribute(aMayaKa));
  CHECK_MSTATUS(addAttribute(aMayaKd));
  CHECK_MSTATUS(addAttribute(aNormalCamera));
  CHECK_MSTATUS(addAttribute(aLightData));
  CHECK_MSTATUS(addAttribute(aAssignedObjects));
  CHECK_MSTATUS(addAttribute(aOutColor));
  CHECK_MSTATUS(addAttribute(aOutTransparency));

  CHECK_MSTATUS(attributeAffects( aColor,               aOutColor ));
  CHECK_MSTATUS(attributeAffects( aOpacity,             aOutColor ));
  CHECK_MSTATUS(attributeAffects( aGLPreviewTexture,    aOutColor ));
  CHECK_MSTATUS(attributeAffects( aMayaIgnoreLights,    aOutColor ));
  CHECK_MSTATUS(attributeAffects( aMayaKa,              aOutColor ));
  CHECK_MSTATUS(attributeAffects( aMayaKd,              aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightIntensityR,     aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightIntensityB,     aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightIntensityG,     aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightIntensity,      aOutColor ));
  CHECK_MSTATUS(attributeAffects( aNormalCameraX,       aOutColor ));
  CHECK_MSTATUS(attributeAffects( aNormalCameraY,       aOutColor ));
  CHECK_MSTATUS(attributeAffects( aNormalCameraZ,       aOutColor ));
  CHECK_MSTATUS(attributeAffects( aNormalCamera,        aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightDirectionX,     aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightDirectionY,     aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightDirectionZ,     aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightDirection,      aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightAmbient,        aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightSpecular,       aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightDiffuse,        aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightShadowFraction, aOutColor ));
  CHECK_MSTATUS(attributeAffects( aPreShadowIntensity,  aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightBlindData,      aOutColor ));
  CHECK_MSTATUS(attributeAffects( aLightData,           aOutColor ));

  return MS::kSuccess;
}
예제 #14
0
MStatus VmIslandNode::compute( const MPlug& i_plug, MDataBlock& io_dataBlock )
{
    MStatus status;
    
    fprintf( stderr, "VmIslandNode::compute()...\n" );
    
    //Check plugs
    if( i_plug == oa_update )
    {
        //Make sure all internal structures are up to date with attributes
        fprintf( stderr, "VmIslandNode::compute(oa_update)\n" );
        
        MDataHandle seedHandle = io_dataBlock.inputValue( ia_seed, & status);
        const long seed = seedHandle.asLong();
        CHECK_MSTATUS( status );
        
        MDataHandle roughnessHandle = io_dataBlock.inputValue( ia_roughness, & status);
        const float roughness = roughnessHandle.asFloat();
        CHECK_MSTATUS( status );
        
        MDataHandle planeHeightHandle = io_dataBlock.inputValue( ia_planeHeight, & status);
        const long planeHeight = planeHeightHandle.asLong();
        CHECK_MSTATUS( status );

        MDataHandle smoothHandle = io_dataBlock.inputValue( ia_smooth, & status);
        const long smooth = smoothHandle.asLong();
        CHECK_MSTATUS( status );

        MDataHandle resolutionHandle = io_dataBlock.inputValue( ia_resolution, & status);
        const long resolution = resolutionHandle.asLong();
        CHECK_MSTATUS( status );

        MDataHandle planeSizeHandle = io_dataBlock.inputValue( ia_planeSize, & status);
        const long planeSize = planeSizeHandle.asLong();
        CHECK_MSTATUS( status );


        
        MDataHandle gridSizeHandle = io_dataBlock.inputValue( ia_gridSize, & status);
        const long gridSize = gridSizeHandle.asLong();
        m_gridSize = (int) gridSize;
        CHECK_MSTATUS( status );


        //Grass
        //--------------
        MDataHandle baseWidthHandle = io_dataBlock.inputValue( ia_baseWidth, & status);
        const float baseWidth = baseWidthHandle.asFloat();
        CHECK_MSTATUS( status );

        MDataHandle grassMultiplierHandle = io_dataBlock.inputValue( ia_grassMultiplier, & status);
        const long grassMultiplier = grassMultiplierHandle.asLong();
        CHECK_MSTATUS( status );

        MDataHandle grassSegmentLengthHandle = io_dataBlock.inputValue( ia_grassSegmentLength, & status);
        const float grassSegmentLength = grassSegmentLengthHandle.asFloat();
        CHECK_MSTATUS( status );

        MDataHandle grassNumSegmentsHandle = io_dataBlock.inputValue( ia_grassNumSegments, & status);
        const long grassNumSegments = grassNumSegmentsHandle.asLong();
        CHECK_MSTATUS( status );

        //MDataHandle windDirectionHandle = io_dataBlock.inputValue( ia_windDirection, & status);
        MFloatVector& windDirVec = io_dataBlock.inputValue( ia_windDirection, & status).asFloatVector();
        const Vcore::Vec3 windDirection = Vec3(windDirVec.x, windDirVec.y, windDirVec.z);
        CHECK_MSTATUS( status );

        MDataHandle grassBendAmountHandle = io_dataBlock.inputValue( ia_grassBendAmount, & status);
        const float grassBendAmount = grassBendAmountHandle.asFloat();
        CHECK_MSTATUS( status );

        MDataHandle windSpreadHandle = io_dataBlock.inputValue( ia_windSpread, & status);
        const float windSpread = windSpreadHandle.asFloat();
        CHECK_MSTATUS( status );

        MDataHandle clockHandle = io_dataBlock.inputValue( ia_clock, & status);
        const float clock = clockHandle.asLong();
        CHECK_MSTATUS( status );

        //Colours
        //-----------------
        MFloatVector& grassBaseColour1Vec = io_dataBlock.inputValue( ia_grassBaseColour1, & status).asFloatVector();
        const Vcore::Vec3 grassBaseColour1 = Vec3(grassBaseColour1Vec.x, grassBaseColour1Vec.y, grassBaseColour1Vec.z);
        CHECK_MSTATUS( status );

        MFloatVector& grassTipColour1Vec = io_dataBlock.inputValue( ia_grassTipColour1, & status).asFloatVector();
        const Vcore::Vec3 grassTipColour1 = Vec3(grassTipColour1Vec.x, grassTipColour1Vec.y, grassTipColour1Vec.z);
        CHECK_MSTATUS( status );

        MFloatVector& grassBaseColour2Vec = io_dataBlock.inputValue( ia_grassBaseColour2, & status).asFloatVector();
        const Vcore::Vec3 grassBaseColour2 = Vec3(grassBaseColour2Vec.x, grassBaseColour2Vec.y, grassBaseColour2Vec.z);
        CHECK_MSTATUS( status );

        MFloatVector& grassTipColour2Vec = io_dataBlock.inputValue( ia_grassTipColour2, & status).asFloatVector();
        const Vcore::Vec3 grassTipColour2 = Vec3(grassTipColour2Vec.x, grassTipColour2Vec.y, grassTipColour2Vec.z);
        CHECK_MSTATUS( status );


        //Update paramters of external lib system and rebuild
        m_island.setPlaneParameters( 
            planeSize, 
            planeHeight, 
            seed, 
            roughness, 
            resolution, 
            gridSize, 
            grassMultiplier, 
            baseWidth,
            grassSegmentLength, 
            grassNumSegments, 
            windDirection, 
            grassBendAmount, 
            windSpread, 
            clock, 
            smooth,
            grassBaseColour1,
            grassTipColour1,
            grassBaseColour2,
            grassTipColour2
        );
        
        //Rebuild object and check for success
        const bool updateOK = m_island.build();

        m_cachedVertices = m_island.getComponents( Vcore::Visland::VERTICES );
        m_cachedColours = m_island.getComponents( Vcore::Visland::COLOURS );
        m_cachedNormals = m_island.getComponents( Vcore::Visland::NORMALS );
        m_cachedIndices = m_island.getAllIndices();
        m_geomInstances = m_island.getAllGeometryInstances();
        
        // We must set a value for the plug we have been asked to evaluate,
        // even if we are not going to use it. We set it in the data-block,
        // and to set it we use outputValue().
        //
        // Here we usually set the result to true. The caller who triggered the
        // computation for this attribute might not look at the value that
        // we are setting this plug to. But they do ask for the value of this plug,
        // only to trigger an update of the internal structures. See the draw()
        // and boundingBox() methods to see how this is done.
        
        MDataHandle updateHandle = io_dataBlock.outputValue( i_plug );
        updateHandle.set( updateOK );
        
        //Need to set plug to clean to refresh it
        io_dataBlock.setClean( i_plug );
    }
    
    else if( i_plug == oa_rib ) {
        //Set up rib system to ready renderman values
        
        fprintf( stderr, "VmIslandNode::compute(oa_rib)\n" );
        
        MDataHandle seedHandle = io_dataBlock.inputValue( ia_seed, & status);
        const long seed = seedHandle.asLong();
        CHECK_MSTATUS( status );

        MDataHandle smoothHandle = io_dataBlock.inputValue( ia_smooth, & status);
        const float smooth = smoothHandle.asLong();
        CHECK_MSTATUS( status );
        
        MDataHandle roughnessHandle = io_dataBlock.inputValue( ia_roughness, & status);
        const float roughness = roughnessHandle.asFloat();
        CHECK_MSTATUS( status );

        MDataHandle rmanResolutionHandle = io_dataBlock.inputValue( ia_rmanResolution, & status);
        const long rmanResolution = rmanResolutionHandle.asLong();
        CHECK_MSTATUS( status );
        
        MDataHandle planeHeightHandle = io_dataBlock.inputValue( ia_planeHeight, & status);
        const long planeHeight = planeHeightHandle.asLong();
        CHECK_MSTATUS( status );
        
        MDataHandle planeSizeHandle = io_dataBlock.inputValue( ia_planeSize, & status);
        const long planeSize = planeSizeHandle.asLong();
        CHECK_MSTATUS( status );


        //Grass
        //----------------

        MDataHandle gridSizeHandle = io_dataBlock.inputValue( ia_gridSize, & status);
        const long gridSize = gridSizeHandle.asLong();
        CHECK_MSTATUS( status );

        MDataHandle grassMultiplierHandle = io_dataBlock.inputValue( ia_grassMultiplier, & status);
        const long grassMultiplier = grassMultiplierHandle.asLong();
        CHECK_MSTATUS( status );

        MDataHandle baseWidthHandle = io_dataBlock.inputValue( ia_baseWidth, & status);
        const float baseWidth = baseWidthHandle.asFloat();
        m_gridSize = (int) baseWidth;
        CHECK_MSTATUS( status );

        MDataHandle grassSegmentLengthHandle = io_dataBlock.inputValue( ia_grassSegmentLength, & status);
        const float grassSegmentLength = grassSegmentLengthHandle.asFloat();
        CHECK_MSTATUS( status );

        MDataHandle grassNumSegmentsHandle = io_dataBlock.inputValue( ia_grassNumSegments, & status);
        const long grassNumSegments = grassNumSegmentsHandle.asLong();
        CHECK_MSTATUS( status );

        MFloatVector& windDirVec = io_dataBlock.inputValue( ia_windDirection, & status).asFloatVector();
        const Vcore::Vec3 windDirection = Vec3(windDirVec.x, windDirVec.y, windDirVec.z);
        CHECK_MSTATUS( status );

        MDataHandle grassBendAmountHandle = io_dataBlock.inputValue( ia_grassBendAmount, & status);
        const float grassBendAmount = grassBendAmountHandle.asFloat();
        CHECK_MSTATUS( status );

        MDataHandle windSpreadHandle = io_dataBlock.inputValue( ia_windSpread, & status);
        const float windSpread = windSpreadHandle.asFloat();
        CHECK_MSTATUS( status );

        MDataHandle clockHandle = io_dataBlock.inputValue( ia_clock, & status);
        const float clock = clockHandle.asLong();
        CHECK_MSTATUS( status );

        //Colours
        //-------------------
        MFloatVector& grassBaseColour1Vec = io_dataBlock.inputValue( ia_grassBaseColour1, & status).asFloatVector();
        const Vcore::Vec3 grassBaseColour1 = Vec3(grassBaseColour1Vec.x, grassBaseColour1Vec.y, grassBaseColour1Vec.z);
        CHECK_MSTATUS( status );

        MFloatVector& grassTipColour1Vec = io_dataBlock.inputValue( ia_grassTipColour1, & status).asFloatVector();
        const Vcore::Vec3 grassTipColour1 = Vec3(grassTipColour1Vec.x, grassTipColour1Vec.y, grassTipColour1Vec.z);
        CHECK_MSTATUS( status );

        MFloatVector& grassBaseColour2Vec = io_dataBlock.inputValue( ia_grassBaseColour2, & status).asFloatVector();
        const Vcore::Vec3 grassBaseColour2 = Vec3(grassBaseColour2Vec.x, grassBaseColour2Vec.y, grassBaseColour2Vec.z);
        CHECK_MSTATUS( status );

        MFloatVector& grassTipColour2Vec = io_dataBlock.inputValue( ia_grassTipColour2, & status).asFloatVector();
        const Vcore::Vec3 grassTipColour2 = Vec3(grassTipColour2Vec.x, grassTipColour2Vec.y, grassTipColour2Vec.z);
        CHECK_MSTATUS( status );

        char rib[4096];
        sprintf( rib, "seed=%d;roughness=%f;planeHeight=%d;planeSize=%d;resolution=%d;gridSize=%d;grassMultiplier=%d;baseWidth=%f;grassSegmentLength=%f;grassNumSegments=%d;windDirectionX=%f;windDirectionY=%f;windDirectionZ=%f;grassBendAmount=%f;windSpread=%f;clock=%d;smooth=%d;grassBaseColour1X=%f;grassBaseColour1Y=%f;grassBaseColour1Z=%f;grassTipColour1X=%f;grassTipColour1Y=%f;grassTipColour1Z=%f;grassBaseColour2X=%f;grassBaseColour2Y=%f;grassBaseColour2Z=%f;grassTipColour2X=%f;grassTipColour2Y=%f;grassTipColour2Z=%f;",
            (int) seed, 
            (float) roughness, 
            (int) planeHeight, 
            (int) planeSize, 
            (int) rmanResolution , 
            (int) gridSize, 
            (int) grassMultiplier, 
            (float) baseWidth,
            (float) grassSegmentLength, 
            (int) grassNumSegments, 
            (float) windDirection.x, 
            (float) windDirection.y,
            (float) windDirection.z,
            (float) grassBendAmount, 
            (float) windSpread,
            (int) clock,
            (int) smooth,
            (float) grassBaseColour1.x,
            (float) grassBaseColour1.y,
            (float) grassBaseColour1.z,
            (float) grassTipColour1.x,
            (float) grassTipColour1.y,
            (float) grassTipColour1.z,
            (float) grassBaseColour2.x,
            (float) grassBaseColour2.y,
            (float) grassBaseColour2.z,
            (float) grassTipColour2.x,
            (float) grassTipColour2.y,
            (float) grassTipColour2.z
        );        
        
        // We must set a value for the plug we have been asked to evaluate,
        // even if we are not going to use it. We set it in the data-block,
        // and to set it we use outputValue().
        //
        // Here we are calculating a string value, and that value will 
        // be used by the caller in a "rib-gen" operation - a process in 
        // which a RIB file is generated for Renderman.
        //
        // Notice also that strings in Maya or more complicated than numbers.
        // We need to make a data object for the string data.
        
        MFnStringData stringDataFn;
        MObject stringDataObj = stringDataFn.create( rib, & status );
        CHECK_MSTATUS( status );
        
        MDataHandle ribHandle = io_dataBlock.outputValue( i_plug );
        ribHandle.set( stringDataObj );
        io_dataBlock.setClean( i_plug );
    }
    
    else {
        //Shouldn't be here.
        return MStatus::kSuccess;
    }
}
예제 #15
0
MStatus AlembicNode::initialize()
{
    MStatus status;

    MFnUnitAttribute    uAttr;
    MFnTypedAttribute   tAttr;
    MFnNumericAttribute nAttr;
    MFnGenericAttribute gAttr;
    MFnEnumAttribute    eAttr;

    // add the input attributes: time, file, sequence time
    mTimeAttr = uAttr.create("time", "tm", MFnUnitAttribute::kTime, 0.0);
    status = uAttr.setStorable(true);
    status = addAttribute(mTimeAttr);

    // input file name
    MFnStringData fileFnStringData;
    MObject fileNameDefaultObject = fileFnStringData.create("");
    mAbcFileNameAttr = tAttr.create("abc_File", "fn",
        MFnData::kString, fileNameDefaultObject);
    status = tAttr.setStorable(true);
    status = tAttr.setUsedAsFilename(true);
    status = addAttribute(mAbcFileNameAttr);

    // playback speed
    mSpeedAttr = nAttr.create("speed", "sp",
        MFnNumericData::kDouble, 1.0, &status);
    status = nAttr.setWritable(true);
    status = nAttr.setStorable(true);
    status = nAttr.setKeyable(true);
    status = addAttribute(mSpeedAttr);

    // frame offset
    mOffsetAttr = nAttr.create("offset", "of",
        MFnNumericData::kDouble, 0, &status);
    status = nAttr.setWritable(true);
    status = nAttr.setStorable(true);
    status = nAttr.setKeyable(true);
    status = addAttribute(mOffsetAttr);

    // cycle type
    mCycleTypeAttr = eAttr.create("cycleType", "ct", 0,  &status );
    status = eAttr.addField("Hold", PLAYTYPE_HOLD);
    status = eAttr.addField("Loop", PLAYTYPE_LOOP);
    status = eAttr.addField("Reverse", PLAYTYPE_REVERSE);
    status = eAttr.addField("Bounce", PLAYTYPE_BOUNCE);
    status = eAttr.setWritable(true);
    status = eAttr.setStorable(true);
    status = eAttr.setKeyable(true);
    status = addAttribute(mCycleTypeAttr);

    // Regex Filter
    // This is a hidden variable to preserve a regexIncludefilter string
    // into a .ma file.
    mIncludeFilterAttr = tAttr.create("regexIncludeFilter", "ift",
        MFnData::kString);
    status = tAttr.setStorable(true);
    status = tAttr.setHidden(true);
    status = addAttribute(mIncludeFilterAttr);

    // Regex Filter
    // This is a hidden variable to preserve a regexExcludefilter string
    // into a .ma file.
    mExcludeFilterAttr = tAttr.create("regexExcludeFilter", "eft",
        MFnData::kString);
    status = tAttr.setStorable(true);
    status = tAttr.setHidden(true);
    status = addAttribute(mExcludeFilterAttr);

    // sequence min and max in frames
    mStartFrameAttr = nAttr.create("startFrame", "sf",
        MFnNumericData::kDouble, 0, &status);
    status = nAttr.setWritable(false);
    status = nAttr.setStorable(true);
    status = addAttribute(mStartFrameAttr);

    mEndFrameAttr = nAttr.create("endFrame", "ef",
        MFnNumericData::kDouble, 0, &status);
    status = nAttr.setWritable(false);
    status = nAttr.setStorable(true);
    status = addAttribute(mEndFrameAttr);

    // add the output attributes
    // sampled subD mesh
    MFnMeshData fnMeshData;
    MObject meshDefaultObject = fnMeshData.create(&status);
    mOutSubDArrayAttr = tAttr.create("outSubDMesh", "osubd",
        MFnData::kMesh, meshDefaultObject);
    status = tAttr.setStorable(false);
    status = tAttr.setWritable(false);
    status = tAttr.setKeyable(false);
    status = tAttr.setArray(true);
    status = tAttr.setUsesArrayDataBuilder(true);
    status = addAttribute(mOutSubDArrayAttr);

    // sampled poly mesh
    mOutPolyArrayAttr = tAttr.create("outPolyMesh", "opoly",
        MFnData::kMesh, meshDefaultObject);
    status = tAttr.setStorable(false);
    status = tAttr.setWritable(false);
    status = tAttr.setKeyable(false);
    status = tAttr.setArray(true);
    status = tAttr.setUsesArrayDataBuilder(true);
    status = addAttribute(mOutPolyArrayAttr);

    // sampled nurbs surface
    MFnNurbsSurfaceData fnNSData;
    MObject nsDefaultObject = fnNSData.create(&status);
    mOutNurbsSurfaceArrayAttr = tAttr.create("outNSurface", "ons",
        MFnData::kNurbsSurface, nsDefaultObject);
    status = tAttr.setStorable(false);
    status = tAttr.setWritable(false);
    status = tAttr.setKeyable(false);
    status = tAttr.setArray(true);
    status = tAttr.setUsesArrayDataBuilder(true);
    status = addAttribute(mOutNurbsSurfaceArrayAttr);

    // sampled nurbs curve group
    MFnNurbsCurveData fnNCData;
    MObject ncDefaultObject = fnNCData.create(&status);
    mOutNurbsCurveGrpArrayAttr = tAttr.create("outNCurveGrp", "onc",
        MFnData::kNurbsCurve, ncDefaultObject);
    status = tAttr.setStorable(false);
    status = tAttr.setWritable(false);
    status = tAttr.setKeyable(false);
    status = tAttr.setArray(true);
    status = tAttr.setUsesArrayDataBuilder(true);
    status = addAttribute(mOutNurbsCurveGrpArrayAttr);

    // sampled locator
    mOutLocatorPosScaleArrayAttr = nAttr.create("outLoc", "olo",
        MFnNumericData::kDouble, 0.0, &status);
    status = nAttr.setStorable(false);
    status = nAttr.setWritable(false);
    status = nAttr.setArray(true);
    status = nAttr.setUsesArrayDataBuilder(true);
    status = addAttribute(mOutLocatorPosScaleArrayAttr);

    // sampled transform operations
    mOutTransOpArrayAttr = nAttr.create("transOp", "to",
        MFnNumericData::kDouble, 0.0, &status);
    status = nAttr.setStorable(false);
    status = nAttr.setWritable(false);
    status = nAttr.setArray(true);
    status = nAttr.setUsesArrayDataBuilder(true);
    status = addAttribute(mOutTransOpArrayAttr);

    // sampled camera
    // assume the boolean variables cannot be keyed
    mOutCameraArrayAttr = nAttr.create("outCamera", "ocam",
        MFnNumericData::kDouble, 0.0, &status);
    status = nAttr.setStorable(false);
    status = nAttr.setWritable(false);
    status = nAttr.setArray(true);
    status = nAttr.setUsesArrayDataBuilder(true);
    status = addAttribute(mOutCameraArrayAttr);

    // sampled custom-attributes
    mOutPropArrayAttr = gAttr.create("prop", "pr", &status);
    status = gAttr.addNumericDataAccept(MFnNumericData::kBoolean);
    status = gAttr.addNumericDataAccept(MFnNumericData::kByte);
    status = gAttr.addNumericDataAccept(MFnNumericData::kShort);
    status = gAttr.addNumericDataAccept(MFnNumericData::k2Short);
    status = gAttr.addNumericDataAccept(MFnNumericData::k3Short);
    status = gAttr.addNumericDataAccept(MFnNumericData::kInt);
    status = gAttr.addNumericDataAccept(MFnNumericData::k2Int);
    status = gAttr.addNumericDataAccept(MFnNumericData::k3Int);
    status = gAttr.addNumericDataAccept(MFnNumericData::kFloat);
    status = gAttr.addNumericDataAccept(MFnNumericData::k2Float);
    status = gAttr.addNumericDataAccept(MFnNumericData::k3Float);
    status = gAttr.addNumericDataAccept(MFnNumericData::kDouble);
    status = gAttr.addNumericDataAccept(MFnNumericData::k2Double);
    status = gAttr.addNumericDataAccept(MFnNumericData::k3Double);
    status = gAttr.addNumericDataAccept(MFnNumericData::k4Double);
    status = gAttr.addDataAccept(MFnData::kString);
    status = gAttr.addDataAccept(MFnData::kIntArray);
    status = gAttr.addDataAccept(MFnData::kDoubleArray);
    status = gAttr.addDataAccept(MFnData::kVectorArray);
    status = gAttr.addDataAccept(MFnData::kPointArray);

    status = gAttr.setWritable(false);
    status = gAttr.setKeyable(false);
    status = gAttr.setArray(true);
    status = gAttr.setUsesArrayDataBuilder(true);
    status = addAttribute(mOutPropArrayAttr);

    // set up affection relationships
    status = attributeAffects(mTimeAttr, mOutSubDArrayAttr);
    status = attributeAffects(mTimeAttr, mOutPolyArrayAttr);
    status = attributeAffects(mTimeAttr, mOutNurbsSurfaceArrayAttr);
    status = attributeAffects(mTimeAttr, mOutNurbsCurveGrpArrayAttr);
    status = attributeAffects(mTimeAttr, mOutTransOpArrayAttr);
    status = attributeAffects(mTimeAttr, mOutCameraArrayAttr);
    status = attributeAffects(mTimeAttr, mOutPropArrayAttr);
    status = attributeAffects(mTimeAttr, mOutLocatorPosScaleArrayAttr);

    status = attributeAffects(mSpeedAttr, mOutSubDArrayAttr);
    status = attributeAffects(mSpeedAttr, mOutPolyArrayAttr);
    status = attributeAffects(mSpeedAttr, mOutNurbsSurfaceArrayAttr);
    status = attributeAffects(mSpeedAttr, mOutNurbsCurveGrpArrayAttr);
    status = attributeAffects(mSpeedAttr, mOutTransOpArrayAttr);
    status = attributeAffects(mSpeedAttr, mOutCameraArrayAttr);
    status = attributeAffects(mSpeedAttr, mOutPropArrayAttr);
    status = attributeAffects(mSpeedAttr, mOutLocatorPosScaleArrayAttr);

    status = attributeAffects(mOffsetAttr, mOutSubDArrayAttr);
    status = attributeAffects(mOffsetAttr, mOutPolyArrayAttr);
    status = attributeAffects(mOffsetAttr, mOutNurbsSurfaceArrayAttr);
    status = attributeAffects(mOffsetAttr, mOutNurbsCurveGrpArrayAttr);
    status = attributeAffects(mOffsetAttr, mOutTransOpArrayAttr);
    status = attributeAffects(mOffsetAttr, mOutCameraArrayAttr);
    status = attributeAffects(mOffsetAttr, mOutPropArrayAttr);
    status = attributeAffects(mOffsetAttr, mOutLocatorPosScaleArrayAttr);

    status = attributeAffects(mCycleTypeAttr, mOutSubDArrayAttr);
    status = attributeAffects(mCycleTypeAttr, mOutPolyArrayAttr);
    status = attributeAffects(mCycleTypeAttr, mOutNurbsSurfaceArrayAttr);
    status = attributeAffects(mCycleTypeAttr, mOutNurbsCurveGrpArrayAttr);
    status = attributeAffects(mCycleTypeAttr, mOutTransOpArrayAttr);
    status = attributeAffects(mCycleTypeAttr, mOutCameraArrayAttr);
    status = attributeAffects(mCycleTypeAttr, mOutPropArrayAttr);
    status = attributeAffects(mCycleTypeAttr, mOutLocatorPosScaleArrayAttr);

    MGlobal::executeCommand( UITemplateMELScriptStr );

    return status;
}
예제 #16
0
MStatus NBuddyEMPSaverNode::initialize()

{
    MStatus status;

    MFnTypedAttribute typedAttr; //Typed attributes
    MFnUnitAttribute unitAttr;
    MFnStringData stringData; //String Attributes
    MFnNumericAttribute numFn; //Numerics
    MFnPluginData dataFn;

    //Create the body input array attribute
    _inBodies = typedAttr.create("inBodies","inb" , naiadBodyData::id , MObject::kNullObj , &status);
    NM_CheckMStatus(status, "ERROR creating inBodies attribute.\n");
    typedAttr.setStorable( false );
    typedAttr.setKeyable( false );
    typedAttr.setWritable(true);
    typedAttr.setReadable(false);
    typedAttr.setArray( true );
    status = addAttribute( _inBodies );
    NM_CheckMStatus(status, "ERROR adding inBodies attribute.\n");

    //Attribute for the folder in which to put the emp files
    _empOutputPath = typedAttr.create( "empOutputPath", "ef", MFnData::kString ,stringData.create(MString("/home/jimmi/dev/naiad/emopen/maya/naiadForMaya/test.#.emp")), &status);
    NM_CheckMStatus( status, "Failed to create empOutputPath attribute");
    typedAttr.setStorable( true );
    status = addAttribute( _empOutputPath );
    NM_CheckMStatus( status, "Failed to add empOutputPath plug");

    //Time input
    _time = unitAttr.create( "time", "tm", MFnUnitAttribute::kTime, 0.0, &status );
    NM_CheckMStatus( status, "Failed to create time attribute");
    unitAttr.setStorable(true);
    unitAttr.setWritable(true);
    status = addAttribute( _time );
    NM_CheckMStatus( status, "Failed to add time plug");

    _framePadding = numFn.create( "framePadding", "fp", MFnNumericData::kInt, 4 , &status );
    NM_CheckMStatus( status, "Failed to create framePadding attribute");
    numFn.setStorable(true);
    numFn.setWritable(true);
    status = addAttribute( _framePadding );
    NM_CheckMStatus( status, "Failed to add framePadding plug");
 
    _timeStep = numFn.create( "timeStep", "ts", MFnNumericData::kInt, 0 , &status );
    NM_CheckMStatus( status, "Failed to create timeStep attribute");
    numFn.setStorable(true);
    numFn.setWritable(true);
    status = addAttribute( _timeStep );
    NM_CheckMStatus( status, "Failed to add timeStep plug");

    // an dummy output trigger to force evaluation of the node
    _outTrigger = numFn.create("outTrigger", "ot", MFnNumericData::kBoolean);
    NM_CheckMStatus( status, "Failed to create outTrigger attribute");
    numFn.setStorable(false);
    numFn.setWritable(false);
    status = addAttribute( _outTrigger );
    NM_CheckMStatus( status, "Failed to add outTrigger plug");

    //Attribute Affects
    attributeAffects( _inBodies, _outTrigger );
    attributeAffects( _time, _outTrigger );
    attributeAffects( _framePadding, _outTrigger );
    attributeAffects( _timeStep, _outTrigger );
    attributeAffects( _empOutputPath, _outTrigger );

    return MS::kSuccess;
}
예제 #17
0
// 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;
}