C# Geometry.ConstPointer方法代码示例

 /// <summary>
 /// Returns the underlying const ON_Geometry* for a RhinoCommon class. You should only
 /// be interested in using this function if you are writing C++ code.
 /// </summary>
 /// <param name="geometry">A geometry object. This can be null and in such a case <see cref="IntPtr.Zero"/> is returned.</param>
 /// <returns>A pointer to the const geometry.</returns>
 public static IntPtr NativeGeometryConstPointer(Geometry.GeometryBase geometry)
 {
   IntPtr rc = IntPtr.Zero;
   if (geometry != null)
     rc = geometry.ConstPointer();
   return rc;
 }

 public bool UpdateToLeader(Geometry.Leader leader, DocObjects.ObjectAttributes attributes)
 {
   IntPtr pConstAttributes = (attributes == null) ? IntPtr.Zero : attributes.ConstPointer();
   IntPtr pConstLeader = leader.ConstPointer();
   return UnsafeNativeMethods.CRhinoObjectPairArray_UpdateToLeader(m_parent.m_pObjectPairArray, m_index, pConstLeader, pConstAttributes);
 }

 public bool UpdateToBrep(Geometry.Brep brep, DocObjects.ObjectAttributes attributes)
 {
   IntPtr pConstAttributes = (attributes == null) ? IntPtr.Zero : attributes.ConstPointer();
   IntPtr pConstBrep = brep.ConstPointer();
   return UnsafeNativeMethods.CRhinoObjectPairArray_UpdateToBrep(m_parent.m_pObjectPairArray, m_index, pConstBrep, pConstAttributes);
 }

 public bool UpdateToExtrusion(Geometry.Extrusion extrusion, DocObjects.ObjectAttributes attributes)
 {
   IntPtr pConstAttributes = (attributes == null) ? IntPtr.Zero : attributes.ConstPointer();
   IntPtr pConstExtrusion = extrusion.ConstPointer();
   return UnsafeNativeMethods.CRhinoObjectPairArray_UpdateToExtrusion(m_parent.m_pObjectPairArray, m_index, pConstExtrusion, pConstAttributes);
 }

 public bool UpdateToSurface(Geometry.Surface surface, DocObjects.ObjectAttributes attributes)
 {
   IntPtr pConstAttributes = (attributes == null) ? IntPtr.Zero : attributes.ConstPointer();
   IntPtr pConstSurface = surface.ConstPointer();
   return UnsafeNativeMethods.CRhinoObjectPairArray_UpdateToSurface(m_parent.m_pObjectPairArray, m_index, pConstSurface, pConstAttributes);
 }

 public bool UpdateToText(Geometry.TextEntity text, DocObjects.ObjectAttributes attributes)
 {
   IntPtr pConstAttributes = (attributes == null) ? IntPtr.Zero : attributes.ConstPointer();
   IntPtr pConstText = text.ConstPointer();
   return UnsafeNativeMethods.CRhinoObjectPairArray_UpdateToText2(m_parent.m_pObjectPairArray, m_index, pConstText, pConstAttributes);
 }

 /// <summary>Constrains the picked point to lie on a surface.</summary>
 /// <param name="surface">A surface to use as constraint.</param>
 /// <param name="allowPickingPointOffObject">
 /// defines whether the point pick is allowed to happen off object. When false,
 /// a "no no" cursor is shown when the cursor is not on the object. When true,
 /// a normal point picking cursor is used and the marker is visible also when
 /// the cursor is not on the object.
 /// </param>
 /// <returns>true if constraint could be applied.</returns>
 /// <example>
 /// <code source='examples\vbnet\ex_orientonsrf.vb' lang='vbnet'/>
 /// <code source='examples\cs\ex_orientonsrf.cs' lang='cs'/>
 /// <code source='examples\py\ex_orientonsrf.py' lang='py'/>
 /// </example>
 public bool Constrain(Geometry.Surface surface, bool allowPickingPointOffObject)
 {
   IntPtr ptr = NonConstPointer();
   IntPtr pSurface = surface.ConstPointer();
   return UnsafeNativeMethods.CRhinoGetPoint_Constrain8(ptr, pSurface, allowPickingPointOffObject);
 }

 /// <summary>
 /// Adds a mesh to the list.
 /// </summary>
 /// <param name="mesh">A mesh to add.</param>
 /// <param name="asConst">Whether this mesh should be treated as non-modifiable.</param>
 public void Add(Geometry.Mesh mesh, bool asConst)
 {
   if (null != mesh)
   {
     IntPtr pMesh = mesh.ConstPointer();
     if (!asConst)
       pMesh = mesh.NonConstPointer();
     IntPtr ptr = NonConstPointer();
     UnsafeNativeMethods.ON_MeshArray_Append(ptr, pMesh);
   }
 }

 public bool SetBrep(int id, Geometry.Brep value)
 {
   IntPtr pThis = NonConstPointer();
   IntPtr pConstBrep = value.ConstPointer();
   return UnsafeNativeMethods.CRhinoHistory_SetBrep(pThis, id, pConstBrep);
 }

 public bool SetSurface(int id, Geometry.Surface value)
 {
   IntPtr pThis = NonConstPointer();
   IntPtr pConstSurface = value.ConstPointer();
   return UnsafeNativeMethods.CRhinoHistory_SetSurface(pThis, id, pConstSurface);
 }

 /// <summary>
 /// Draw a typical Rhino Curvature Graph.
 /// </summary>
 /// <param name="curve">Base curve for curvature graph.</param>
 /// <param name="color">Color of curvature graph.</param>
 /// <param name="hairScale">100 = true length, &gt; 100 magnified, &lt; 100 shortened.</param>
 /// <param name="hairDensity">&gt;= 0 larger numbers = more hairs (good default is 1).</param>
 /// <param name="sampleDensity">Between 1 and 10. Higher numbers draw smoother outer curves. (good default is 2).</param>
 public void DrawCurvatureGraph(Geometry.Curve curve, System.Drawing.Color color, int hairScale, int hairDensity, int sampleDensity)
 {
   int argb = color.ToArgb();
   IntPtr pCurve = curve.ConstPointer();
   UnsafeNativeMethods.CRhinoDisplayPipeline_DrawCurvatureGraph(m_ptr, pCurve, argb, hairScale, hairDensity, sampleDensity);
 }

 public bool UpdateToHatch(Geometry.Hatch hatch, DocObjects.ObjectAttributes attributes)
 {
   IntPtr pConstAttributes = (attributes == null) ? IntPtr.Zero : attributes.ConstPointer();
   IntPtr pConstHatch = hatch.ConstPointer();
   return UnsafeNativeMethods.CRhinoObjectPairArray_UpdateToHatch(m_parent.m_pObjectPairArray, m_index, pConstHatch, pConstAttributes);
 }

 public bool SetMesh(int id, Geometry.Mesh value)
 {
   IntPtr pThis = NonConstPointer();
   IntPtr pConstMesh = value.ConstPointer();
   return UnsafeNativeMethods.CRhinoHistory_SetMesh(pThis, id, pConstMesh);
 }

 public bool UpdateToAngularDimension(Geometry.AngularDimension dimension, ObjectAttributes attributes)
 {
   IntPtr pConstDimension = dimension.ConstPointer();
   IntPtr pConstAttributes = (attributes == null) ? IntPtr.Zero : attributes.ConstPointer();
   return UnsafeNativeMethods.CRhinoObjectPairArray_UpdateResult7(m_parent.m_pObjectPairArray, m_index, pConstDimension, pConstAttributes);
 }