public override bool compute(MPlug plug, MDataBlock dataBlock) { if (plug.equalEqual(animCube.outputMesh)) { /* Get time */ MDataHandle timeData = dataBlock.inputValue(animCube.time); MTime time = timeData.asTime; /* Get output object */ MDataHandle outputHandle = dataBlock.outputValue(outputMesh); MFnMeshData dataCreator = new MFnMeshData(); MObject newOutputData = dataCreator.create(); createMesh(time, ref newOutputData); outputHandle.set(newOutputData); dataBlock.setClean(plug); } else return false; return true; }
public override bool compute(MPlug plug, MDataBlock dataBlock) { if (plug.equalEqual(animCube.outputMesh)) { /* Get time */ MDataHandle timeData = dataBlock.inputValue(animCube.time); MTime time = timeData.asTime; /* Get output object */ MDataHandle outputHandle = dataBlock.outputValue(outputMesh); MFnMeshData dataCreator = new MFnMeshData(); MObject newOutputData = dataCreator.create(); createMesh(time, ref newOutputData); outputHandle.set(newOutputData); dataBlock.setClean(plug); } else { return(false); } return(true); }
public override bool getInternalValueInContext(MPlug plug, MDataHandle dataHandle, MDGContext ctx) { if (plug.equalEqual(aTransparency)) { dataHandle.set(fTransparency); return(true); } return(base.getInternalValueInContext(plug, dataHandle, ctx)); }
public override bool getInternalValueInContext(MPlug plug, MDataHandle dataHandle, MDGContext ctx) { if (plug.equalEqual(aTransparency)) { dataHandle.set(fTransparency); return true; } return base.getInternalValueInContext(plug, dataHandle, ctx); }
public override bool setInternalValueInContext(MPlug plug, MDataHandle dataHandle, MDGContext ctx) { if (plug.equalEqual(aTransparency)) { fTransparency = dataHandle.asDouble; setImageDirty(); return true; } return base.setInternalValueInContext(plug, dataHandle, ctx); }
public override bool setInternalValueInContext(MPlug plug, MDataHandle dataHandle, MDGContext ctx) { if (plug.equalEqual(aTransparency)) { fTransparency = dataHandle.asDouble; setImageDirty(); return(true); } return(base.setInternalValueInContext(plug, dataHandle, ctx)); }
public override void validateAndSetValue(MPlug plug, MDataHandle handle, MDGContext context) { // Make sure that there is something interesting to process. // if (plug.isNull) { throw new ArgumentNullException("plug"); } if (plug.equalEqual(aRockInX)) { MDataBlock block = _forceCache(context); MDataHandle blockHandle = block.outputValue(plug); // Update our new rock in x value double rockInX = handle.asDouble; blockHandle.set(rockInX); rockXValue = rockInX; // Update the custom transformation matrix to the // right rock value. rockingTransformCheckMatrix ltm = getRockingTransformMatrix(); if (ltm != null) { ltm.setRockInX(rockXValue); } else { MGlobal.displayError("Failed to get rock transform matrix"); } blockHandle.setClean(); // Mark the matrix as dirty so that DG information // will update. dirtyMatrix(); return; } base.validateAndSetValue(plug, handle, context); }
public override bool compute( MPlug plug, MDataBlock block) { if ( plug.equalEqual(constraintGeometry) ) { // block.inputValue(constraintParentInverseMatrix); // MArrayDataHandle targetArray = block.inputArrayValue( compoundTarget ); uint targetArrayCount = targetArray.elementCount(); double weight,selectedWeight = 0; if ( weightType == GeometrySurfaceConstraintCommand.ConstraintType.kSmallestWeight ) selectedWeight = float.MaxValue; MObject selectedMesh = null; uint i; for ( i = 0; i < targetArrayCount; i++ ) { MDataHandle targetElement = targetArray.inputValue(); weight = targetElement.child(targetWeight).asDouble; if ( !equivalent(weight,0.0)) { if ( weightType == GeometrySurfaceConstraintCommand.ConstraintType.kLargestWeight ) { if ( weight > selectedWeight ) { MObject mesh = targetElement.child(targetGeometry).asMesh; if ( !mesh.isNull ) { selectedMesh = mesh; selectedWeight = weight; } } } else { if ( weight < selectedWeight ) { MObject mesh = targetElement.child(targetGeometry).asMesh; if ( !mesh.isNull ) { selectedMesh = mesh; selectedWeight = weight; } } } } targetArray.next(); } // if( selectedMesh == null ) { block.setClean(plug); } else { // The transform node via the geometry attribute will take care of // updating the location of the constrained geometry. MDataHandle outputConstraintGeometryHandle = block.outputValue(constraintGeometry); outputConstraintGeometryHandle.setMObject(selectedMesh); } } else { return false; } return true; }
// // Calls applyRotationLocks && applyRotationLimits // This method verifies that the passed value can be set on the // rotate plugs. In the base class, limits as well as locking are // checked by this method. // // The compute, validateAndSetValue, and rotateTo functions // all use this method. // protected override void checkAndSetRotation(MDataBlock block, MPlug plug, MEulerRotation newRotation, MSpace.Space space) { MDGContext context = block.context; updateMatrixAttrs(context); MEulerRotation outRotation = newRotation; if (context.isNormal) { // For easy reading. // MPxTransformationMatrix xformMat = baseTransformationMatrix; // Get the current translation in transform space for // clamping and locking. // MEulerRotation savedRotation = xformMat.eulerRotation(MSpace.Space.kTransform); // Translate to transform space, since the limit test needs the // values in transform space. The locking test needs the values // in the same space as the savedR value - which is transform // space as well. // baseTransformationMatrix.rotateTo(newRotation, space); outRotation = xformMat.eulerRotation(MSpace.Space.kTransform); // Now that everything is in the same space, apply limits // and change the value to adhere to plug locking. // outRotation = applyRotationLimits(outRotation, block); outRotation = applyRotationLocks(outRotation, savedRotation); // The value that remain is in transform space. // xformMat.rotateTo(outRotation, MSpace.Space.kTransform); // Get the value that was just set. It needs to be in transform // space since it is used to set the datablock values at the // end of this method. Getting the vaolue right before setting // ensures that the transformation matrix and data block will // be synchronized. // outRotation = xformMat.eulerRotation(MSpace.Space.kTransform); } else { // Get the rotation for clamping and locking. This will get the // rotate value in transform space. // double[] s3 = block.inputValue(rotate).Double3; MEulerRotation savedRotation = new MEulerRotation(s3[0], s3[1], s3[2]); // Create a local transformation matrix for non-normal context // calculations. // MPxTransformationMatrix local = createTransformationMatrix(); if (null == local) { throw new InvalidOperationException("rockingTransformCheck::checkAndSetRotation internal error"); } // Fill the newly created transformation matrix. // computeLocalTransformation(local, block); // Translate the values to transform space. This will allow the // limit and locking tests to work properly. // local.rotateTo(newRotation, space); outRotation = local.eulerRotation(MSpace.Space.kTransform); // Apply limits // outRotation = applyRotationLimits(outRotation, block); outRotation = applyRotationLocks(outRotation, savedRotation); local.rotateTo(outRotation, MSpace.Space.kTransform); // Get the rotate value in transform space for placement in the // data block. // outRotation = local.eulerRotation(MSpace.Space.kTransform); local.Dispose(); } MDataHandle handle = block.outputValue(plug); if (plug.equalEqual(rotate)) { handle.set(outRotation.x, outRotation.y, outRotation.z); } else if (plug.equalEqual(rotateX)) { handle.set(outRotation.x); } else if (plug.equalEqual(rotateY)) { handle.set(outRotation.y); } else { handle.set(outRotation.z); } return; }
public override void validateAndSetValue(MPlug plug, MDataHandle handle, MDGContext context) { // Make sure that there is something interesting to process. // if (plug.isNull) throw new ArgumentNullException("plug"); if (plug.equalEqual(aRockInX)) { MDataBlock block = _forceCache(context); MDataHandle blockHandle = block.outputValue(plug); // Update our new rock in x value double rockInX = handle.asDouble; blockHandle.set(rockInX); rockXValue = rockInX; // Update the custom transformation matrix to the // right rock value. rockingTransformCheckMatrix ltm = getRockingTransformMatrix(); if (ltm != null) { ltm.setRockInX(rockXValue); } else { MGlobal.displayError("Failed to get rock transform matrix"); } blockHandle.setClean(); // Mark the matrix as dirty so that DG information // will update. dirtyMatrix(); return; } base.validateAndSetValue(plug, handle, context); }
public override bool compute(MPlug plug, MDataBlock dataBlock) { if (plug.equalEqual(gOutputFloat_2Float_3Float)) { // attribute affecting generic attribute case. Based on the // input attribute, we modify the output generic attribute MDataHandle inputDataInt = dataBlock.inputValue(gInputInt); int inputInt = inputDataInt.asInt; // Get the output handle MDataHandle outputData = dataBlock.outputValue(plug); bool isGenericNumeric = false; bool isGenericNull = false; // Is the output handle generic data if (outputData.isGeneric(ref isGenericNumeric, ref isGenericNull)) { // Based on the inputHandle, update the generic // output handle if (inputInt == 1) { outputData.setGenericBool(false, true); } else if (inputInt == 2) { outputData.setGenericBool(true, true); } else if (inputInt == 3) { outputData.setGenericChar(127, true); } else if (inputInt == 4) { outputData.setGenericDouble(3.145, true); } else if (inputInt == 5) { outputData.setGenericFloat((float)9.98, true); } else if (inputInt == 6) { outputData.setGenericShort(3245, true); } else if (inputInt == 7) { outputData.setGenericInt(32768, true); } else if (inputInt == 8) { MFnNumericData numericData = new MFnNumericData(); MObject obj = numericData.create(MFnNumericData.Type.k2Float); numericData.setData((float)1.5, (float)6.7); outputData.set(obj); } else if (inputInt == 9) { MFnNumericData numericData = new MFnNumericData(); MObject obj = numericData.create(MFnNumericData.Type.k3Float); numericData.setData((float)2.5, (float)8.7, (float)2.3345); outputData.set(obj); } else if (inputInt == 10) { outputData.setGenericInt(909, true); } // Mark the data clean outputData.setClean(); dataBlock.setClean(gOutputFloat_2Float_3Float); } } else { return(false); } return(true); }
public override bool compute(MPlug plug, MDataBlock dataBlock) { if ( plug.equalEqual(gOutputFloat_2Float_3Float) ) { // attribute affecting generic attribute case. Based on the // input attribute, we modify the output generic attribute MDataHandle inputDataInt = dataBlock.inputValue( gInputInt ); int inputInt = inputDataInt.asInt; // Get the output handle MDataHandle outputData = dataBlock.outputValue( plug ); bool isGenericNumeric = false; bool isGenericNull = false; // Is the output handle generic data if ( outputData.isGeneric( ref isGenericNumeric, ref isGenericNull ) ) { // Based on the inputHandle, update the generic // output handle if ( inputInt == 1 ) outputData.setGenericBool( false, true ); else if ( inputInt == 2 ) outputData.setGenericBool( true, true ); else if ( inputInt == 3 ) outputData.setGenericChar( 127, true ); else if ( inputInt == 4 ) outputData.setGenericDouble( 3.145, true ); else if ( inputInt == 5 ) outputData.setGenericFloat( (float)9.98, true ); else if ( inputInt == 6 ) outputData.setGenericShort( 3245, true ); else if ( inputInt == 7 ) outputData.setGenericInt( 32768, true ); else if ( inputInt == 8 ) { MFnNumericData numericData = new MFnNumericData(); MObject obj = numericData.create( MFnNumericData.Type.k2Float); numericData.setData( (float)1.5, (float)6.7 ); outputData.set( obj ); } else if ( inputInt == 9 ) { MFnNumericData numericData = new MFnNumericData(); MObject obj = numericData.create( MFnNumericData.Type.k3Float); numericData.setData( (float)2.5, (float)8.7, (float)2.3345 ); outputData.set( obj ); } else if ( inputInt == 10 ) { outputData.setGenericInt( 909, true ); } // Mark the data clean outputData.setClean(); dataBlock.setClean( gOutputFloat_2Float_3Float ); } } else { return false; } return true; }
public override bool compute(MPlug plug, MDataBlock block) { if (plug.equalEqual(constraintGeometry)) { // block.inputValue(constraintParentInverseMatrix); // MArrayDataHandle targetArray = block.inputArrayValue(compoundTarget); uint targetArrayCount = targetArray.elementCount(); double weight, selectedWeight = 0; if (weightType == GeometrySurfaceConstraintCommand.ConstraintType.kSmallestWeight) { selectedWeight = float.MaxValue; } MObject selectedMesh = null; uint i; for (i = 0; i < targetArrayCount; i++) { MDataHandle targetElement = targetArray.inputValue(); weight = targetElement.child(targetWeight).asDouble; if (!equivalent(weight, 0.0)) { if (weightType == GeometrySurfaceConstraintCommand.ConstraintType.kLargestWeight) { if (weight > selectedWeight) { MObject mesh = targetElement.child(targetGeometry).asMesh; if (!mesh.isNull) { selectedMesh = mesh; selectedWeight = weight; } } } else { if (weight < selectedWeight) { MObject mesh = targetElement.child(targetGeometry).asMesh; if (!mesh.isNull) { selectedMesh = mesh; selectedWeight = weight; } } } } targetArray.next(); } // if (selectedMesh == null) { block.setClean(plug); } else { // The transform node via the geometry attribute will take care of // updating the location of the constrained geometry. MDataHandle outputConstraintGeometryHandle = block.outputValue(constraintGeometry); outputConstraintGeometryHandle.setMObject(selectedMesh); } } else { return(false); } return(true); }