C# Rhino.NonConstPointer方法代码示例

    /// <summary>
    /// Constructs a subclass of this object on the stack in your Rhino plug-in's Render() or RenderWindow() implementation.
    /// </summary>
    /// <param name="doc">A Rhino document.</param>
    /// <param name="mode">A command running mode, such as scripted or interactive.</param>
    /// <param name="plugin">A plug-in.</param>
    /// <param name="sizeRendering">The width and height of the rendering.</param>
    /// <param name="caption">The caption to display in the frame window.</param>
    /// <param name="channels">The color channel or channels.</param>
    /// <param name="reuseRenderWindow">true if the rendering window should be reused; otherwise, a new one will be instanciated.</param>
    /// <param name="clearLastRendering">true if the last rendering should be removed.</param>
    protected RenderPipeline(RhinoDoc doc,
                          Rhino.Commands.RunMode mode,
                          Rhino.PlugIns.PlugIn plugin,
                          System.Drawing.Size sizeRendering,
                          string caption,
                          Rhino.Render.RenderWindow.StandardChannels channels,
                          bool reuseRenderWindow,
                          bool clearLastRendering
                          )
    {
      Debug.Assert(Rhino.PlugIns.RenderPlugIn.RenderCommandContextPointer != IntPtr.Zero);

      m_serial_number = m_current_serial_number++;
      m_all_render_pipelines.Add(m_serial_number, this);
      m_size = sizeRendering;
      m_channels = channels;

      m_pSdkRender = UnsafeNativeMethods.Rdk_SdkRender_New(m_serial_number, Rhino.PlugIns.RenderPlugIn.RenderCommandContextPointer, plugin.NonConstPointer(), caption, reuseRenderWindow, clearLastRendering);
      m_plugin = plugin;

      UnsafeNativeMethods.Rdk_RenderWindow_Initialize(m_pSdkRender, (int)channels, m_size.Width, m_size.Height);
    }

    /*
        public static Rhino.Geometry.Curve TryCopyFromOnCurve(object source)
        {
          if (source != null)
          {
            try
            {
              Type base_type = Type.GetType("RMA.OpenNURBS.OnCurve");
              System.Type t = source.GetType();
              if (t.IsAssignableFrom(base_type))
              {
                System.Reflection.PropertyInfo pi = t.GetProperty("InternalPointer");
                IntPtr ptr = (IntPtr)pi.GetValue(source, null);
                Rhino.Geometry.Curve crv = Rhino.Geometry.Curve.CreateCurveHelper(ptr, null);
                crv.NonConstPointer();
                return crv;
              }
            }
            catch (Exception)
            {
            }
          }
          return null;
        }

        /// <summary>
        /// Do not hold on to the returned class outside the scope of your current function.
        /// </summary>
        /// <param name="source">-</param>
        /// <returns>-</returns>
        public static Rhino.Display.DisplayPipeline ConvertFromMRhinoDisplayPipeline(object source)
        {
          if (source != null)
          {
            try
            {
              Type base_type = Type.GetType("RMA.Rhino.MRhinoDisplayPipeline");
              System.Type t = source.GetType();
              if (t.IsAssignableFrom(base_type))
              {
                System.Reflection.PropertyInfo pi = t.GetProperty("InternalPointer");
                IntPtr ptr = (IntPtr)pi.GetValue(source, null);
                return new Rhino.Display.DisplayPipeline(ptr);
              }
            }
            catch (Exception)
            {
            }
          }
          return null;
        }
        */
#if RHINO_SDK
    /// <summary>
    /// Gets a C++ plug-in pointer for a given RhinoCommon plug-in.
    /// <para>This is a Rhino SDK function.</para>
    /// </summary>
    /// <param name="plugin">A plug-in.</param>
    /// <returns>A pointer.</returns>
    public static IntPtr PlugInPointer(Rhino.PlugIns.PlugIn plugin)
    {
      return null == plugin ? IntPtr.Zero : plugin.NonConstPointer();
    }

 /// <summary>
 /// Sets dynamic grip locations back to starting grip locations. This makes things
 /// like the Copy command work when grips are "copied".
 /// </summary>
 /// <param name="list">A list of object to transform. This is a special list type.</param>
 protected void ResetGrips(Rhino.Collections.TransformObjectList list)
 {
   IntPtr pList = list.NonConstPointer();
   UnsafeNativeMethods.CRhinoTransformCommand_ResetGrips(Id, pList);
 }

 protected void TransformObjects(Rhino.Collections.TransformObjectList list, Rhino.Geometry.Transform xform, bool copy, bool autoHistory)
 {
   IntPtr pList = list.NonConstPointer();
   UnsafeNativeMethods.CRhinoTransformCommand_TransformObjects(Id, pList, ref xform, copy, autoHistory);
 }

 /// <summary>
 /// Selects objects within the command.
 /// </summary>
 /// <param name="prompt">The selection prompt.</param>
 /// <param name="list">A list of objects to transform. This is a special list type.</param>
 /// <returns>The operation result.</returns>
 protected Result SelectObjects(string prompt, Rhino.Collections.TransformObjectList list)
 {
   IntPtr pList = list.NonConstPointer();
   int rc = UnsafeNativeMethods.CRhinoTransformCommand_SelectObjects(Id, prompt, pList);
   return (Result)rc;
 }

 public bool PickGumball(Rhino.Input.Custom.PickContext pickContext, Rhino.Input.Custom.GetPoint getPoint)
 {
   IntPtr pThis = NonConstPointer();
   IntPtr pConstPickContext = pickContext.ConstPointer();
   IntPtr pGetPoint = IntPtr.Zero;
   if( getPoint!=null)
     getPoint.NonConstPointer();
   return UnsafeNativeMethods.CRhinoGumballDisplayConduit_PickGumball(pThis, pConstPickContext, pGetPoint);
 }

    protected void AddGrip(Rhino.DocObjects.Custom.CustomGripObject grip)
    {
      m_grip_list.Add(grip);

      IntPtr pGrip = grip.NonConstPointer();
      IntPtr pThis = NonConstPointer();
      UnsafeNativeMethods.CRhinoObjectGrips_AddGrip(pThis, pGrip);      
    }

 /// <summary>
 /// Expert user tool that copies user data that has a positive 
 /// CopyCount from the source object to a destination object.
 /// Generally speaking you don't need to use Copy().
 /// Simply rely on things like the copy constructors to do the right thing.
 /// </summary>
 /// <param name="source">A source object for the data.</param>
 /// <param name="destination">A destination object for the data.</param>
 public static void Copy(Rhino.Runtime.CommonObject source, Rhino.Runtime.CommonObject destination)
 {
   IntPtr pConstSource = source.ConstPointer();
   IntPtr pDestination = destination.NonConstPointer();
   UnsafeNativeMethods.ON_Object_CopyUserData(pConstSource, pDestination);
 }

 public static RdkPlugIn GetRdkPlugIn(Rhino.PlugIns.PlugIn plugin)
 {
   for (int i = 0; i < m_all_rdk_plugins.Count; i++)
   {
     if (m_all_rdk_plugins[i].m_rhino_plugin_id == plugin.Id)
       return m_all_rdk_plugins[i];
   }
   IntPtr pRhinoPlugIn = plugin.NonConstPointer();
   return GetRdkPlugInHelper(pRhinoPlugIn, plugin.Id, plugin.m_runtime_serial_number);
 }

 /// <summary>Turns on/off the object's editing grips.</summary>
 /// <param name="customGrips">The custom object grips.</param>
 /// <returns>
 /// true if the call succeeded.  If you attempt to add custom grips to an
 /// object that does not support custom grips, then false is returned.
 /// </returns>
 public bool EnableCustomGrips(Rhino.DocObjects.Custom.CustomObjectGrips customGrips)
 {
   IntPtr pConstThis = ConstPointer();
   IntPtr pGrips = customGrips==null?IntPtr.Zero:customGrips.NonConstPointer();
   bool rc = UnsafeNativeMethods.CRhinoObject_EnableCustomGrips(pConstThis, pGrips);
   if (rc && customGrips != null)
   {
     customGrips.OnAttachedToRhinoObject(this);
   }
   return rc;
 }