public override void writeBinary(MOStream outstream) { MOStream instream = new MOStream(MOStream.getCPtr(outstream).Handle, false); MStreamUtils.writeDouble(outstream, fValue, true); return; }
public override void readBinary(MIStream arg0, uint length) { MIStream instream = new MIStream(MIStream.getCPtr(arg0).Handle, false); MStreamUtils.readDouble(arg0, out fValue, true); return; }
public override int write(Structure dataToWrite, MOStream cDst) { MStreamUtils.writeCharBuffer(cDst, "<?xml version='1.0' encoding='UTF-8'?>\n"); // Start with the main structure tag containing the name string rootString = "<" + structureTag + " " + structureNameAttribute + "='" + dataToWrite.name + "'>\n"; MStreamUtils.writeCharBuffer(cDst, rootString); // Write out each structure member in its own tag for (StructureIterator iterator = dataToWrite.begin(); iterator != dataToWrite.end(); iterator = iterator.next()) { string memberString = " <" + memberTag + " " + memberNameAttribute + "='" + iterator.memberName() + "'" + " " + memberTypeAttribute + "='" + Member.typeName(iterator.memberType()) + "'"; if (iterator.memberLength() != 1) { memberString = memberString + " " + memberDimAttribute + "='" + iterator.memberLength() + "'"; } memberString += "/>\n"; MStreamUtils.writeCharBuffer(cDst, memberString); } rootString = "</" + structureTag + ">"; MStreamUtils.writeCharBuffer(cDst, rootString); return(0); }
public override void writeASCII(MOStream outstream) { MOStream instream = new MOStream(MOStream.getCPtr(outstream).Handle, false); MStreamUtils.writeDouble(outstream, fValue); MStreamUtils.writeChar(outstream, ' '); return; }
public override void doCreate() { Associations associationsRead = null; MIStream inStream = MStreamUtils.CreateIFStream(fileName); string errors = ""; associationsRead = fSerialize.read(inStream, ref errors); if (associationsRead == null) { String fmt = MStringResource.getString(MetaDataRegisterMStringResources.kImportMetadataFileReadFailed); String msg; if (errors == null || errors.Length < 1) { errors = "No errors was given by the serializer when reading the metadata file."; } msg = String.Format(fmt, fileName, errors); displayError(msg); throw new System.ApplicationException(msg); } String resultFmt = MStringResource.getString(MetaDataRegisterMStringResources.kImportMetadataResult); for (int i = 0; i < fMeshes.length; ++i) { MFnMesh mesh = new MFnMesh(fMeshes[i]); // Should have filtered out non-meshes already but check anyway if (mesh == null) { continue; } displayInfo(mesh.fullPathName); //We dont have the correct interface on MDGModifier to assign metadata so no undo redo for now Associations associationsMesh = mesh.metadata; associationsMesh.assign(associationsRead); for (int c = 0; c < associationsRead.channelCount; ++c) { Autodesk.Maya.MetaData.Channel channel = associationsRead.channelAt((uint)c); String cName = channel.nameProperty; for (int s = 0; s < channel.dataStreamCount; ++s) { Autodesk.Maya.MetaData.Stream cStream = channel.dataStream((uint)s); if (cStream != null) { String sName = cStream.name; String msg = String.Format(resultFmt, mesh.fullPathName, cName, sName); appendToResult(msg); } } } } MStreamUtils.Close(inStream); inStream = null; }
private static void CurrentDomainOnUnhandledException( object sender, UnhandledExceptionEventArgs e) { // write the error the Output Window var error = MStreamUtils.stdErrorStream(); MStreamUtils.writeCharBuffer(error, e.ExceptionObject + "\n"); // write the error to the status bar MGlobal.displayError(e.ExceptionObject.ToString()); }
public override void getFormatDescription(MOStream info) { string msgPre = MStringResource.getString(MetaDataRegisterMStringResources.kStructureXMLInfoPre); string msgPost = MStringResource.getString(MetaDataRegisterMStringResources.kStructureXMLInfoPost); MStreamUtils.writeChar(info, msgPre[0]); for (uint i = (uint)Member.eDataType.kFirstType; i < (uint)Member.eDataType.kLastType; ++i) { if (i != (uint)Member.eDataType.kFirstType) { MStreamUtils.writeCharBuffer(info, ", "); } } MStreamUtils.writeChar(info, msgPost[0]); }
public override void doCreate() { if (fMeshes.length != 1) { throw new System.ApplicationException("ExportMetadataCmd: do not support less or more then 1 mesh."); } MFnMesh mesh = new MFnMesh(fMeshes[0]); displayInfo(mesh.fullPathName); Associations associationsToWrite = mesh.metadata; if (associationsToWrite == null) { throw new System.ApplicationException("ExportMetadataCmd: no association to write."); } String errors = ""; // Dump either to a file or the return string, depending on which was // requested. // MOStream destination = MStreamUtils.CreateOFStream(fileName); if (fSerialize.write(associationsToWrite, destination, ref errors) == 0) { setResult(fileName); } else { String msg = MStringResource.getString(MetaDataRegisterMStringResources.kExportMetadataFailedFileWrite); displayError(msg); } MStreamUtils.Close(destination); destination = null; if (errors != null && errors.Length > 0) { displayError(errors); return; } return; }
public override void redoIt() { MObject dependNode = new MObject(); MOStream stdoutstream = MStreamUtils.stdOutStream(); for (; !iter.isDone; iter.next()) { // Get the selected dependency node and create // a function set for it // try { iter.getDependNode(dependNode); } catch (System.Exception) { MStreamUtils.writeCharBuffer(MStreamUtils.stdErrorStream(), "Error getting the dependency node"); continue; } MFnDependencyNode fnDN; try { fnDN = new MFnDependencyNode(dependNode); } catch (System.Exception) { MStreamUtils.writeCharBuffer(MStreamUtils.stdErrorStream(), "Error creating MFnDependencyNode"); continue; } MFnTypedAttribute fnAttr = new MFnTypedAttribute(); MObject newAttr = fnAttr.create("blindDoubleData", "BDD", blindDoubleData.tid); try { fnDN.addAttribute(newAttr, MFnDependencyNode.MAttrClass.kLocalDynamicAttr); } catch (System.Exception) { // do nothing // addAttribute only need call once, the redundant calls will return false (throw exception) } // Create a plug to set and retrieve value off the node. // MPlug plug = new MPlug(dependNode, newAttr); // ----------------------------------- Attention ------------------------------------ // --------------------------------- Downcast Begin ----------------------------------- // the following codes are used to get the c# object // MFnPluginData pdFnCreator = new MFnPluginData(); // 1. you cannot gain blindDoubleData by the following code // {code} // blindDoubleData newData = new blindDoubleData() // {code} // As we need to keep the relationship between c# impl and c++ instance pointer // We cannot use the above ctor codes, otherwise, the mandatory information used for down casting is omitted // 2. you cannot use the tempData gained by the following code // {code} // MObject tempData = pdFnCreator.create(blindDoubleData.tid); // {code} // reason: // tempData is useless, we cannot use tempData to do downcast // the create function gains the tempData by the following code // // {code} // newHandle = new MObject(mayaHandle); // {code} // // the mayaHandle is the actual pointer, which we store. But we have no information about the newHandle // the return object is useless. the data we needed is stored in pdFnCreator pdFnCreator.create(blindDoubleData.tid); // 3. get "the data" we needed blindDoubleData newData = pdFnCreator.data() as blindDoubleData; // ---------------------------------- Downcast End ----------------------------------- if (newData == null) { continue; } newData.value = 3.2; plug.setValue(newData); // Now try to retrieve the value of the plug as an MObject. // MObject sData = new MObject(); try { plug.getValue(sData); } catch (System.Exception) { continue; } // Convert the data back to MPxData. // MFnPluginData pdFn = new MFnPluginData(sData); blindDoubleData data = pdFn.data() as blindDoubleData; // Get the value. // if (null == data) { // error MStreamUtils.writeCharBuffer(MStreamUtils.stdErrorStream(), "error: failed to retrieve data."); } MStreamUtils.writeLine(stdoutstream); MStreamUtils.writeCharBuffer(stdoutstream, ">>>>>>>>>>>>>>>>>>>>>>>> blindDoubleData binary >>>>>>>>>>>>>>>>>>>>"); MStreamUtils.writeLine(stdoutstream); data.writeBinary(stdoutstream); MStreamUtils.writeLine(stdoutstream); MStreamUtils.writeCharBuffer(stdoutstream, ">>>>>>>>>>>>>>>>>>>>>>>> blindDoubleData ascii >>>>>>>>>>>>>>>>>>>>"); MStreamUtils.writeLine(stdoutstream); data.writeASCII(stdoutstream); } return; }
public override Structure read(MIStream cSrc, ref string errors) { int errCount = 0; Structure newStructure = null; errors = ""; uint size = MStreamUtils.getLength(cSrc); string myString = ""; // The last argument is true since we don't want to stop reading a stream when a WhiteSpace is encountered. MStreamUtils.readCharBuffer(cSrc, out myString, size, true); XmlReader reader = XmlReader.Create(new System.IO.StringReader(myString)); string elementName = ""; while (reader.Read()) { // Skip anything unrecognized, for maximum flexibility if (reader.NodeType != XmlNodeType.Element) { continue; } elementName = reader.Name; // Root must be a <structure> tag if (elementName == structureTag) { bool isStrucNameFound = reader.MoveToAttribute(structureNameAttribute); if (isStrucNameFound) { string structureName = reader.ReadContentAsString(); newStructure = new Structure(structureName); } else { string msgFmt = MStringResource.getString(MetaDataRegisterMStringResources.kStructureXMLStructureNameNotFound); IXmlLineInfo xmlInfo = (IXmlLineInfo)reader; int lineNumber = xmlInfo.LineNumber; string errorMsg = String.Format(msgFmt, lineNumber.ToString()); errors += errorMsg; errCount++; continue; } } if (newStructure == null) { continue; } // All children must all be <member> tags if (elementName == memberTag) { uint memberDim = 1; string memberName = ""; string memberType = ""; bool isMemberNameFound = reader.MoveToAttribute(memberNameAttribute); if (isMemberNameFound) { memberName = reader.ReadContentAsString(); } else { string msgFmt = MStringResource.getString(MetaDataRegisterMStringResources.kStructureXMLMemberNameNotFound); IXmlLineInfo xmlInfo = (IXmlLineInfo)reader; int lineNumber = xmlInfo.LineNumber; string errorMsg = String.Format(msgFmt, lineNumber.ToString()); errors += errorMsg; continue; } bool isMemberTypeFound = reader.MoveToAttribute(memberTypeAttribute); if (isMemberTypeFound) { memberType = reader.ReadContentAsString(); } else { string msgFmt = MStringResource.getString(MetaDataRegisterMStringResources.kStructureXMLMemberTypeNotFound); IXmlLineInfo xmlInfo = (IXmlLineInfo)reader; int lineNumber = xmlInfo.LineNumber; string errorMsg = String.Format(msgFmt, lineNumber.ToString()); errors += errorMsg; continue; } bool isMemberDimFound = reader.MoveToAttribute(memberDimAttribute); if (isMemberDimFound) { memberDim = (uint)reader.ReadContentAsInt(); } else { memberDim = 1; } newStructure.addMember(Member.typeFromName(memberType), memberDim, memberName); } } // If there were errors any structure created will be incorrect so pass // back nothing rather than bad data. if (errCount > 0) { newStructure = null; } return(newStructure); }