/// <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, > 100 magnified, < 100 shortened.</param> /// <param name="hairDensity">>= 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); }
/// <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> public void DrawCurvatureGraph(Geometry.Curve curve, System.Drawing.Color color) { int argb = color.ToArgb(); IntPtr pCurve = curve.ConstPointer(); UnsafeNativeMethods.CRhinoDisplayPipeline_DrawCurvatureGraph(m_ptr, pCurve, argb, 100, 1, 2); }
/// <summary>Constrains the picked point to lie on a mesh.</summary> /// <param name="mesh">A mesh 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> public bool Constrain(Geometry.Mesh mesh, bool allowPickingPointOffObject) { IntPtr ptr = NonConstPointer(); IntPtr pMesh = mesh.ConstPointer(); return UnsafeNativeMethods.CRhinoGetPoint_ConstrainToMesh(ptr, pMesh, allowPickingPointOffObject); }
/// <summary>Constrains the picked point to lie on a brep.</summary> /// <param name="brep">A brep to use as constraint.</param> /// <param name="wireDensity"> /// When wire_density<0, isocurve intersection snapping is turned off, when wire_density>=0, the value /// defines the isocurve density used for isocurve intersection snapping. /// </param> /// <param name="faceIndex"> /// When face_index <0, constrain to whole brep. When face_index >=0, constrain to individual face. /// </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> public bool Constrain(Geometry.Brep brep, int wireDensity, int faceIndex, bool allowPickingPointOffObject) { IntPtr ptr = NonConstPointer(); IntPtr pBrep = brep.ConstPointer(); return UnsafeNativeMethods.CRhinoGetPoint_Constrain9(ptr, pBrep, wireDensity, faceIndex, allowPickingPointOffObject); }
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); }
/// <summary> /// Adds a brep to the list. /// </summary> /// <param name="brep">A brep to add.</param> /// <param name="asConst">Whether this brep should be treated as non-modifiable.</param> public void Add(Geometry.Brep brep, bool asConst) { if (null != brep) { IntPtr pBrep = brep.ConstPointer(); if (!asConst) pBrep = brep.NonConstPointer(); IntPtr ptr = NonConstPointer(); UnsafeNativeMethods.ON_BrepArray_Append(ptr, pBrep); } }
/// <summary>Constrains the picked point to lie on a curve.</summary> /// <param name="curve">A curve 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_insertknot.vb' lang='vbnet'/> /// <code source='examples\cs\ex_insertknot.cs' lang='cs'/> /// <code source='examples\py\ex_insertknot.py' lang='py'/> /// </example> public bool Constrain(Geometry.Curve curve, bool allowPickingPointOffObject) { IntPtr ptr = NonConstPointer(); IntPtr pCurve = curve.ConstPointer(); return UnsafeNativeMethods.CRhinoGetPoint_Constrain7(ptr, pCurve, allowPickingPointOffObject); }