Пример #1
0
        //writing mesh, material is now set to default but will be selected
        //by layer or object, material definitions will be got from material table
        public string writeMeshObject(MRhinoObjectMesh rhinoMesh, string materialName)
        {
            OnMesh mesh = new OnMesh();
            mesh = rhinoMesh.GetMesh();
            System.Globalization.CultureInfo ci = System.Globalization.CultureInfo.CreateSpecificCulture("en");

            //use buffer for strings (much faster than string + string... )
            StringBuilder buffer = new StringBuilder();

            //materials
            //IRhinoMaterial material = rhinoMesh.m_parent_object.ObjectMaterial();
            //string materialName = material.m_material_id.ToString();

            //mesh
            int v_count = mesh.m_V.Count();
            int f_count = mesh.m_F.Count();

            buffer.Append(string.Format(ci, "<mesh vertices=\"{0}\" faces=\"{1}\" has_orco=\"off\" has_uv=\"false\" type=\"0\">", v_count, f_count));
            buffer.Append(string.Format(ci, "<set_material sval=\"{0}\"/>", materialName));

            //list verticles
            foreach (On3fPoint v in mesh.m_V)
            {
                buffer.Append(string.Format(ci, " <p x=\"{0}\" y=\"{1}\" z=\"{2}\"/>", v.x, v.y, v.z));
                v_count++;
            }

            //list faces
            foreach (OnMeshFace f in mesh.m_F)
            {
                buffer.Append(string.Format(ci, " <f a=\"{0}\" b=\"{1}\" c=\"{2}\"/>\n", f.get_vi(0), f.get_vi(1), f.get_vi(2)));
                //quad ?
                if (!f.IsTriangle()) buffer.Append(string.Format(ci, " <f a=\"{0}\" b=\"{1}\" c=\"{2}\"/>\n", f.get_vi(0), f.get_vi(2), f.get_vi(3)));
                f_count++;
            }

            buffer.Append(string.Format(ci, "</mesh>"));
            mesh.Destroy();
            return buffer.ToString();
        }
Пример #2
0
        /// <summary>
        /// Rhino calls WriteFile() to write document geometry to an external file.
        /// </summary>
        public override int WriteFile(string filename, int index, ref MRhinoDoc doc, ref IRhinoFileWriteOptions options)
        {
            int rc = 0; // false

            // Are we saving or exporting?
            bool bExport = options.Mode(IRhinoFileWriteOptions.ModeFlag.SelectedMode);
            // Are we in interactive or scripted mode?
            bool bScript = options.Mode(IRhinoFileWriteOptions.ModeFlag.BatchMode);

            List <IRhinoObject> objects = new List <IRhinoObject>();

            // Get objects to save/export
            MRhinoObjectIterator it = new MRhinoObjectIterator(doc, IRhinoObjectIterator.object_state.undeleted_objects);

            if (bExport)
            {
                it.EnableSelectedFilter();
                it.EnableVisibleFilter();
            }

            // Do the iteration...
            MRhinoObject obj = null;

            for (obj = it.First(); null != obj; obj = it.Next())
            {
                objects.Add(obj);
            }

            ArrayMRhinoObjectMesh meshes          = new ArrayMRhinoObjectMesh(objects.Count);
            OnMeshParameters      mesh_parameters = _mesh_parameters;
            int mesh_ui_style = (bScript) ? 2 : _mesh_ui_style;

            // Get the meshes to save/export
            IRhinoCommand.result res = RhUtil.RhinoMeshObjects(objects.ToArray(), ref mesh_parameters, ref mesh_ui_style, ref meshes);
            if (res == IRhinoCommand.result.success)
            {
                if (mesh_ui_style >= 0 && mesh_ui_style <= 1)
                {
                    _mesh_ui_style = mesh_ui_style;
                }
                _mesh_parameters = mesh_parameters;
            }
            else
            {
                if (bExport)
                {
                    RhUtil.RhinoApp().Print("No meshes to export.\n");
                }
                else
                {
                    RhUtil.RhinoApp().Print("No meshes to save.\n");
                }
                return(rc);
            }

            try
            {
                // Open the file
                System.IO.StreamWriter file = new System.IO.StreamWriter(filename);

                // Write mesh count
                file.WriteLine(string.Format("meshcount={0}\n", meshes.Count()));

                // Write each mesh
                for (int i = 0; i < meshes.Count(); i++)
                {
                    MRhinoObjectMesh obj_mesh = meshes[i];
                    OnMesh           mesh     = obj_mesh.GetMesh();
                    if (null != mesh)
                    {
                        // Write mesh number
                        file.WriteLine(string.Format("mesh={0}\n", i));

                        // Write mesh vertex count
                        file.WriteLine(string.Format("vertexcount={0}\n", mesh.m_V.Count()));

                        // Write mesh face count
                        file.WriteLine(string.Format("facecount={0}\n", mesh.m_F.Count()));

                        // Write mesh vertices
                        for (int vi = 0; vi < mesh.m_V.Count(); vi++)
                        {
                            On3fPoint p = mesh.m_V[vi];
                            file.WriteLine(string.Format("vertex=({0},{1},{2})\n", p.x, p.y, p.z));
                        }

                        // Write mesh faces
                        for (int fi = 0; fi < mesh.m_F.Count(); fi++)
                        {
                            OnMeshFace f = mesh.m_F[fi];
                            file.WriteLine(string.Format("face=({0},{1},{2},{3})\n", f.get_vi(0), f.get_vi(1), f.get_vi(2), f.get_vi(3)));
                        }
                    }
                }

                file.Close();

                rc = 1; // true
            }
            catch (Exception e)
            {
                RhUtil.RhinoApp().Print(string.Format("{0}\n", e.Message));
            }

            return(rc);
        }