public BoundingBox GetBoundingBox(bool accurate)
{
#if RHINO_SDK
RhinoObject parent_object = ParentRhinoObject();
#endif
if (accurate)
{
BoundingBox bbox = new BoundingBox();
Transform xf = new Transform();
#if RHINO_SDK
// 3 July 2018 S. Baer (RH-46926)
// When the object is non-const there is a good chance the geometry is
// different than what is in the original parent object' geometry. Skip
// using the parent's bbox getter when in this situation
if (null != parent_object && !IsNonConst)
{
IntPtr ptr_parent_rhinoobject = parent_object.ConstPointer();
if (UnsafeNativeMethods.CRhinoObject_GetTightBoundingBox(ptr_parent_rhinoobject, ref bbox, ref xf, false))
{
return(bbox);
}
}
#endif
AnnotationBase ann = this as AnnotationBase;
if (ann != null)
{
return(ann.InternalGetBoundingBox());
}
IntPtr ptr = ConstPointer();
return(UnsafeNativeMethods.ON_Geometry_GetTightBoundingBox(ptr, ref bbox, ref xf, false) ? bbox : BoundingBox.Empty);
}
else
{
BoundingBox rc = new BoundingBox();
#if RHINO_SDK
if (null != parent_object && !IsNonConst)
{
IntPtr ptr_parent_rhinoobject = parent_object.ConstPointer();
if (UnsafeNativeMethods.CRhinoObject_BoundingBox(ptr_parent_rhinoobject, ref rc))
{
return(rc);
}
}
#endif
AnnotationBase ann = this as AnnotationBase;
if (ann != null)
{
return(ann.InternalGetBoundingBox());
}
IntPtr ptr = ConstPointer();
UnsafeNativeMethods.ON_Geometry_BoundingBox(ptr, ref rc);
return(rc);
}
}
/// <summary>
/// Checks geometry to see if it passes the basic GeometryAttributeFilter.
/// </summary>
/// <param name="rhObject">parent object being considered.</param>
/// <param name="geometry">geometry being considered.</param>
/// <param name="componentIndex">if >= 0, geometry is a proper sub-part of object->Geometry() with componentIndex.</param>
/// <returns>
/// true if the geometry passes the filter returned by GeometryAttributeFilter().
/// </returns>
public bool PassesGeometryAttributeFilter(RhinoObject rhObject, GeometryBase geometry, ComponentIndex componentIndex)
{
IntPtr const_ptr_rhino_object = IntPtr.Zero;
if (rhObject != null)
{
const_ptr_rhino_object = rhObject.ConstPointer();
}
IntPtr const_ptr_geometry = IntPtr.Zero;
if (geometry != null)
{
const_ptr_geometry = geometry.ConstPointer();
}
IntPtr ptr = NonConstPointer();
return(UnsafeNativeMethods.CRhinoGetObject_PassesGeometryAttributeFilter(ptr, const_ptr_rhino_object, const_ptr_geometry, componentIndex));
}
public virtual BoundingBox GetBoundingBox(Transform xform)
{
BoundingBox bbox = BoundingBox.Empty;
#if RHINO_SDK
// In cases like breps and curves, the CRhinoBrepObject and CRhinoCurveObject
// can compute a better tight bounding box
RhinoObject parent_object = ParentRhinoObject();
if (parent_object != null)
{
IntPtr ptr_parent = parent_object.ConstPointer();
if (UnsafeNativeMethods.CRhinoObject_GetTightBoundingBox(ptr_parent, ref bbox, ref xform, true))
{
return(bbox);
}
}
#endif
IntPtr ptr = ConstPointer();
return(UnsafeNativeMethods.ON_Geometry_GetTightBoundingBox(ptr, ref bbox, ref xform, true) ? bbox : BoundingBox.Empty);
}
/// <summary>
/// Finds all of the mesh faces on each of two Rhino objects that interfere within a clash distance.
/// This function uses the object's mesh to calculate the interferences.
/// Acceptable object types include: BrepObject, ExtrusionObject, MeshObject, and SubDObject.
/// </summary>
/// <param name="objA">The first Rhino object.</param>
/// <param name="objB">The second Rhino object.</param>
/// <param name="distance">The largest distance at which a clash can occur.</param>
/// <param name="meshType">The type of mesh to be used for the calculation.</param>
/// <param name="meshingParameters">The meshing parameters used to generate meshes for the calculation.</param>
/// <returns>The resulting meshes are sub-meshes of the input meshes if successful, or an empty array on error.</returns>
public static Mesh[] FindDetail(RhinoObject objA, RhinoObject objB, double distance, MeshType meshType, MeshingParameters meshingParameters)
{
if (null == objA)
{
throw new ArgumentNullException(nameof(objA));
}
if (null == objB)
{
throw new ArgumentNullException(nameof(objB));
}
using (var out_meshes = new SimpleArrayMeshPointer())
{
var ptr_obj_a = objA.ConstPointer();
var ptr_obj_b = objB.ConstPointer();
var ptr_mp = meshingParameters.ConstPointer();
var ptr_out_meshes = out_meshes.NonConstPointer();
var count = UnsafeNativeMethods.RHC_CRhClashDetect_FindClashDetail(ptr_obj_a, ptr_obj_b, distance, (int)meshType, ptr_mp, ptr_out_meshes);
GC.KeepAlive(objA);
GC.KeepAlive(objB);
return(count > 0 ? out_meshes.ToNonConstArray() : new Mesh[0]);
}
}
/// <summary>
/// Returns a bounding box for the custom render meshes for the given object.
/// </summary>
/// <param name="vp">The viewport being rendered.</param>
/// <param name="obj">The Rhino object of interest.</param>
/// <param name="requestingPlugIn">UUID of the RDK plug-in requesting the meshes.</param>
/// <param name="preview">Type of mesh to build.</param>
/// <returns>A bounding box value.</returns>
public virtual BoundingBox BoundingBox(ViewportInfo vp, RhinoObject obj, Guid requestingPlugIn, bool preview)
{
var min = new Point3d();
var max = new Point3d();
if (UnsafeNativeMethods.Rdk_RMPBoundingBoxImpl(m_runtime_serial_number, vp.ConstPointer(), obj.ConstPointer(), requestingPlugIn, preview ? 1 : 0, ref min, ref max))
{
return(new BoundingBox(min, max));
}
return(new BoundingBox());
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
public static void ObjectChanged(RhinoObject obj)
{
UnsafeNativeMethods.Rdk_CRMManager_EVF("ObjectChanged", obj.ConstPointer());
}
// Marked as internal, RhinoObject.GetRenderPrimitiveList will create one
// but there is currently no reason for anyone else to make one.
internal RenderPrimitiveList(RhinoObject obj)
{
m_ptr_custom_render_meshes = UnsafeNativeMethods.Rdk_CustomMeshes_New(obj.ConstPointer());
}