/// <summary>
/// Returns the underlying const CRhinoObject* for a RhinoCommon class. You should only
/// be interested in using this function if you are writing C++ code.
/// </summary>
/// <param name="rhinoObject">A Rhino object.</param>
/// <returns>A pointer to the Rhino const object.</returns>
public static IntPtr RhinoObjectConstPointer(Rhino.DocObjects.RhinoObject rhinoObject)
{
IntPtr rc = IntPtr.Zero;
if (rhinoObject != null)
rc = rhinoObject.ConstPointer();
return rc;
}
/// <summary>
/// Constructs a new basic material from a <see cref="Rhino.DocObjects.Material">Material</see>.
/// </summary>
/// <param name="material">(optional)The material to create the basic material from.</param>
/// <returns>A new basic material.</returns>
public static RenderMaterial CreateBasicMaterial(Rhino.DocObjects.Material material)
{
IntPtr pConstSourceMaterial = (material == null ? IntPtr.Zero : material.ConstPointer());
IntPtr pNewMaterial = UnsafeNativeMethods.Rdk_Globals_NewBasicMaterial(pConstSourceMaterial);
NativeRenderMaterial newMaterial = RenderContent.FromPointer(pNewMaterial) as NativeRenderMaterial;
if (newMaterial != null)
newMaterial.AutoDelete = true;
return newMaterial;
}
/// <summary>
/// Constructs a light which simulates a <see cref="Rhino.Render.Sun"/>.
/// </summary>
/// <param name="sun">A Sun object from the Rhino.Render namespace.</param>
/// <returns>A light.</returns>
public static Light CreateSunLight(Rhino.Render.Sun sun)
{
Rhino.Runtime.HostUtils.CheckForRdk(true, true);
Rhino.Geometry.Light rc = new Rhino.Geometry.Light();
IntPtr pLight = rc.NonConstPointer();
IntPtr pConstSun = sun.ConstPointer();
UnsafeNativeMethods.Rdk_Sun_Light(pConstSun, pLight);
return rc;
}
/// <summary>
/// Capture View contents to a bitmap using display attributes to define how
/// drawing is performed.
/// </summary>
/// <param name="size">The width and height of the returned bitmap.</param>
/// <param name="attributes">The specific display mode attributes.</param>
/// <returns>A new bitmap.</returns>
public System.Drawing.Bitmap CaptureToBitmap(System.Drawing.Size size, Rhino.Display.DisplayPipelineAttributes attributes)
{
IntPtr pConstView = ConstPointer();
IntPtr pAttributes = attributes.ConstPointer();
IntPtr pRhinoDib = UnsafeNativeMethods.CRhinoDib_New();
System.Drawing.Bitmap rc = null;
if (UnsafeNativeMethods.CRhinoView_CaptureToBitmap(pConstView, pRhinoDib, size.Width, size.Height, pAttributes))
{
IntPtr hBmp = UnsafeNativeMethods.CRhinoDib_Bitmap(pRhinoDib);
if (IntPtr.Zero != hBmp)
rc = System.Drawing.Image.FromHbitmap(hBmp);
}
UnsafeNativeMethods.CRhinoDib_Delete(pRhinoDib);
return 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);
}
/// <summary>
/// Copies all of the ViewportInfo data from an existing RhinoViewport.
/// </summary>
/// <param name="rhinoViewport">A viewport to copy.</param>
public ViewportInfo(Rhino.Display.RhinoViewport rhinoViewport)
{
IntPtr pRhinoViewport = rhinoViewport.ConstPointer();
m_pViewportPointer = UnsafeNativeMethods.ON_Viewport_New2(pRhinoViewport);
}
public static void ForceObjectIntoPreviewCache(Rhino.DocObjects.RhinoObject obj)
{
UnsafeNativeMethods.Rdk_CRMManager_EVF("ForceObjectIntoPreviewCache", obj.ConstPointer());
}
/// <summary>
/// If Style==Wireframe, then the default decomposes the curve object into
/// nurbs curve segments and calls the virtual DrawNurbsCurve for each segment.
/// </summary>
/// <param name="curve">A document curve object.</param>
/// <param name="pipeline">The drawing pipeline.</param>
protected virtual void DrawCurveObject(Rhino.DocObjects.CurveObject curve, DisplayPipeline pipeline )
{
IntPtr pConstThis = ConstPointer();
IntPtr pConstCurve = curve.ConstPointer();
IntPtr pPipeline = pipeline.NonConstPointer();
UnsafeNativeMethods.CRhinoVisualAnalysisMode_DrawCurveObject(pConstThis, pConstCurve, pPipeline);
}
/// <summary>
/// Convert a Rhino.Display.Viewport to an RMA.Rhino.IRhinoViewport.
/// </summary>
/// <param name="source">A RhinoCommon viewport.</param>
/// <returns>
/// Rhino_DotNet IRhinoViewport object on success. This will be an independent copy.
/// </returns>
public static object ToIRhinoViewport(Rhino.Display.RhinoViewport source)
{
object rc = null;
IntPtr pSource = source.ConstPointer();
Type rhType = GetRhinoDotNetType("RMA.Rhino.MRhinoViewport");
if (IntPtr.Zero != pSource && null != rhType)
{
System.Reflection.MethodInfo mi = rhType.GetMethod("WrapNativePointer", new Type[] { typeof(IntPtr), typeof(bool), typeof(bool) });
const bool isConst = true;
const bool doDelete = false;
rc = mi.Invoke(null, new object[] { pSource, isConst, doDelete });
}
return rc;
}
/// <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="meshType">Type of mesh to build.</param>
/// <returns>A bounding box value.</returns>
public virtual Rhino.Geometry.BoundingBox BoundingBox(Rhino.DocObjects.ViewportInfo vp, Rhino.DocObjects.RhinoObject obj, Guid requestingPlugIn, MeshTypes meshType)
{
Geometry.Point3d min = new Geometry.Point3d();
Geometry.Point3d max = new Geometry.Point3d();
if (UnsafeNativeMethods.Rdk_RMPBoundingBoxImpl(m_runtime_serial_number, vp.ConstPointer(), obj.ConstPointer(), requestingPlugIn, (int)meshType, ref min, ref max))
return new Rhino.Geometry.BoundingBox(min, max);
return new Rhino.Geometry.BoundingBox();
}
/// <summary>
/// A wireframe channel will not be added if none of the document properties settings
/// indicate that one is needed. In other words, Rhino will not generate an empty wireframe channel
/// just for the fun of it.
/// </summary>
/// <param name="doc">The document to display</param>
/// <param name="viewport">The view to display</param>
/// <param name="size">The size of the image without clipping (ie - if you have a region, it was the
/// size of the image before you cut the region out.</param>
/// <param name="region">The area of the rendering you want to display. This should match the size
/// of the render window itself (ie - the one set using SetSize)</param>
/// <returns>Returns true if the wireframe channel was successfully added.</returns>
public bool AddWireframeChannel(Rhino.RhinoDoc doc, Rhino.DocObjects.ViewportInfo viewport, System.Drawing.Size size, System.Drawing.Rectangle region)
{
int[] xy = { size.Width, size.Height };
int[] lrtb = { region.Left, region.Right, region.Top, region.Bottom };
return UnsafeNativeMethods.Rdk_RenderWindow_AddWireframeChannel(ConstPointer(), doc.DocumentId, viewport.ConstPointer(), ref xy[0], ref lrtb[0]);
}
public void Add(Rhino.Geometry.Mesh mesh, RenderMaterial material)
{
UnsafeNativeMethods.Rdk_CustomMeshes_AddMesh(NonConstPointer(), mesh.ConstPointer(), material.ConstPointer());
}
/// <summary>
/// Build custom render mesh(es) for the given object.
/// </summary>
/// <param name="vp">the viewport being rendered.</param>
/// <param name="objMeshes">The meshes object to fill with custom meshes - the Object property will already be set.</param>
/// <param name="requestingPlugIn">the UUID of the RDK plug-in requesting the meshes.</param>
/// <param name="meshType"> type of mesh(es) to build.</param>
/// <returns>true if successful.</returns>
public static bool BuildCustomMeshes(Rhino.DocObjects.ViewportInfo vp, ObjectMeshes objMeshes, Guid requestingPlugIn, MeshTypes meshType)
{
return UnsafeNativeMethods.Rdk_CRMManager_BuildCustomMeshes(vp.ConstPointer(), objMeshes.NonConstPointer(), requestingPlugIn, (int)meshType);
}
/// <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">Rhino object of interest.</param>
/// <param name="requestingPlugIn">UUID of the RDK plug-in requesting the meshes.</param>
/// <param name="meshType"> type of mesh(es) to build the bounding box for.</param>
/// <returns>ON_BoundingBox for the meshes.</returns>
public static Rhino.Geometry.BoundingBox BoundingBox(Rhino.DocObjects.ViewportInfo vp, Rhino.DocObjects.RhinoObject obj, Guid requestingPlugIn, MeshTypes meshType)
{
Rhino.Geometry.Point3d min = new Geometry.Point3d();
Rhino.Geometry.Point3d max = new Geometry.Point3d();
Rhino.Geometry.BoundingBox bb = new Geometry.BoundingBox();
if (UnsafeNativeMethods.Rdk_CRMManager_BoundingBox(vp.ConstPointer(), obj.ConstPointer(), requestingPlugIn, (int)meshType, ref min, ref max))
{
bb.Min = min;
bb.Max = max;
}
return bb;
}
/// <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">Rhino object of interest.</param>
/// <param name="requestingPlugIn">UUID of the RDK plug-in requesting the meshes.</param>
/// <param name="meshType"> type of mesh(es) to build the bounding box for.</param>
/// <param name="soleProviderId">the sole provider to call.</param>
/// <returns>ON_BoundingBox for the meshes.</returns>
public static Rhino.Geometry.BoundingBox BoundingBox(Rhino.DocObjects.ViewportInfo vp, Rhino.DocObjects.RhinoObject obj, Guid requestingPlugIn, MeshTypes meshType, Guid soleProviderId)
{
Geometry.Point3d min = new Geometry.Point3d();
Geometry.Point3d max = new Geometry.Point3d();
if (UnsafeNativeMethods.Rdk_CRMManager_BoundingBoxSole(vp.ConstPointer(), obj.ConstPointer(), requestingPlugIn, (int)meshType, soleProviderId, ref min, ref max))
{
Rhino.Geometry.BoundingBox bb = new Geometry.BoundingBox();
return bb;
}
return new Geometry.BoundingBox();
}
/// <summary>
/// Determines if custom render meshes will be built for a particular object.
/// </summary>
/// <param name="vp">the viewport being rendered.</param>
/// <param name="obj">the Rhino object of interest.</param>
/// <param name="requestingPlugIn">type of mesh to build.</param>
/// <param name="meshType">UUID of the plug-in requesting the meshes.</param>
/// <param name="soleProviderId">the UUID of the sole provider to call.</param>
/// <returns>true if BuildCustomMeshes() will build custom render mesh(es) for the given object.</returns>
public static bool WillBuildCustomMeshes(Rhino.DocObjects.ViewportInfo vp, Rhino.DocObjects.RhinoObject obj, Guid requestingPlugIn, MeshTypes meshType, Guid soleProviderId)
{
return UnsafeNativeMethods.Rdk_CRMManager_WillBuildCustomMeshSole(vp.ConstPointer(), obj.ConstPointer(), requestingPlugIn, (int)meshType, soleProviderId);
}
public bool UpdateToPointCloud(Rhino.Geometry.PointCloud cloud, ObjectAttributes attributes)
{
IntPtr pCloud = cloud.ConstPointer();
IntPtr pConstAttributes = (attributes == null) ? IntPtr.Zero : attributes.ConstPointer();
return UnsafeNativeMethods.CRhinoObjectPairArray_UpdateResult2(m_parent.m_pObjectPairArray, m_index, pCloud, pConstAttributes);
}
public void Add(Rhino.Geometry.PlaneSurface plane, RenderMaterial material)
{
UnsafeNativeMethods.Rdk_CustomMeshes_AddPlane(NonConstPointer(), plane.ConstPointer(), material.ConstPointer());
}
/// <summary>
/// Sets the viewport camera projection.
/// </summary>
/// <param name="projection">The "standard" projection type.</param>
/// <param name="updateTargetLocation">
/// if true, the target location is changed so that the vector from the camera location to the target
/// is parallel to the camera direction vector. If false, the target location is not changed.
/// </param>
/// <returns>true on success.</returns>
public bool SetViewProjection(Rhino.DocObjects.ViewportInfo projection, bool updateTargetLocation)
{
IntPtr pThis = NonConstPointer();
IntPtr pConstViewport = projection.ConstPointer();
return UnsafeNativeMethods.CRhinoViewport_SetVP(pThis, pConstViewport, updateTargetLocation);
}
/// <summary>
/// Call this function to render the scene in a view window. The function returns when rendering is complete (or cancelled).
/// </summary>
/// <param name="view">the view that the user selected a rectangle in.</param>
/// <param name="rect">rectangle that the user selected.</param>
/// <param name="inWindow">true to render directly into the view window.</param>
/// <returns>A code that explains how rendering completed.</returns>
/// //TODO - ViewInfo is wrong here
public RenderReturnCode RenderWindow(Rhino.Display.RhinoView view, System.Drawing.Rectangle rect, bool inWindow)
{
m_ReturnCode = RenderReturnCode.InternalError;
if (m_pSdkRender != IntPtr.Zero)
{
m_ReturnCode = (RenderReturnCode)UnsafeNativeMethods.Rdk_SdkRender_RenderWindow(m_pSdkRender, view.ConstPointer(), rect.Top, rect.Left, rect.Bottom, rect.Right, inWindow);
}
return m_ReturnCode;
}
/// <summary>
/// Gets a value indicating if this visual analysis mode can be used on a given Rhino object.
/// </summary>
/// <param name="obj">The object to be tested.</param>
/// <returns>true if this mode can indeed be used on the object; otherwise false.</returns>
public virtual bool ObjectSupportsAnalysisMode(Rhino.DocObjects.RhinoObject obj)
{
IntPtr pConstPointer = ConstPointer();
IntPtr pConstRhinoObject = obj.ConstPointer();
return UnsafeNativeMethods.CRhinoVisualAnalysisMode_ObjectSupportsAnalysisMode(pConstPointer, pConstRhinoObject);
}
bool SetTexture(Rhino.DocObjects.Texture texture, int which, bool front)
{
IntPtr pMaterial = NonConstMaterialPointer(front);
IntPtr pTexture = texture.ConstPointer();
return UnsafeNativeMethods.ON_Material_SetTexture(pMaterial, pTexture, which);
}
/// <summary>
/// Constructs a Rhino_DotNet OnCurve that is a copy of a given curve.
/// </summary>
/// <param name="source">A RhinoCommon source curve.</param>
/// <returns>
/// Rhino_DotNet object on success. This will be an independent copy.
/// </returns>
public static object ToOnCurve(Rhino.Geometry.Curve source)
{
object rc = null;
IntPtr pSource = source.ConstPointer();
Type onType = GetRhinoDotNetType("RMA.OpenNURBS.OnCurve");
if (IntPtr.Zero != pSource && null != onType)
{
System.Reflection.MethodInfo mi = onType.GetMethod("WrapNativePointer", new Type[] { typeof(IntPtr), typeof(bool), typeof(bool) });
IntPtr pNewCurve = UnsafeNativeMethods.ON_Curve_DuplicateCurve(pSource);
rc = mi.Invoke(null, new object[] { pNewCurve, false, true });
}
return rc;
}
/// <summary>
/// Gets the debug dumps. This is a text description of the geometric contents.
/// DebugDump() is intended for debugging and is not suitable for creating high
/// quality text descriptions of an object.
/// </summary>
/// <param name="bezierCurve">curve to evaluate</param>
/// <returns>A debug dump text.</returns>
public static string DebugDumpToString(Rhino.Geometry.BezierCurve bezierCurve)
{
IntPtr pConstThis = bezierCurve.ConstPointer();
using (Rhino.Runtime.StringHolder sh = new StringHolder())
{
IntPtr pString = sh.NonConstPointer();
UnsafeNativeMethods.ON_BezierCurve_Dump(pConstThis, pString);
return sh.ToString();
}
}
public ObjectMeshes(Rhino.DocObjects.RhinoObject obj)
{
m_pRenderMeshes = UnsafeNativeMethods.Rdk_CustomMeshes_New(obj.ConstPointer());
m_bAutoDelete = true;
}
/// <summary>
/// A new render mesh iterator.
/// <para>The caller shall dispose the iterator.
/// Meshes created by the iterator are accessible up till when the iterator is disposed.</para>
/// </summary>
/// <param name="forceTriMesh">true if quad meshes should be triangulated.</param>
/// <param name="vp">The rendering view camera.</param>
/// <returns>A render mesh iterator.</returns>
/// //TODO - ON_Viewport
public RenderMeshIterator NewRenderMeshIterator(Rhino.DocObjects.ViewportInfo vp, bool forceTriMesh)
{
IntPtr pIterator = UnsafeNativeMethods.Rdk_SdkRender_NewRenderMeshIterator(ConstPointer(), vp.ConstPointer(), forceTriMesh);
if (pIterator != IntPtr.Zero)
{
return new RenderMeshIterator(pIterator);
}
return null;
}
/// <summary>
/// Gets the debug dumps. This is a text description of the geometric contents.
/// DebugDump() is intended for debugging and is not suitable for creating high
/// quality text descriptions of an object.
/// </summary>
/// <param name="geometry">Some geometry.</param>
/// <returns>A debug dump text.</returns>
public static string DebugDumpToString(Rhino.Geometry.GeometryBase geometry)
{
IntPtr pConstThis = geometry.ConstPointer();
using (Rhino.Runtime.StringHolder sh = new Rhino.Runtime.StringHolder())
{
IntPtr pString = sh.NonConstPointer();
UnsafeNativeMethods.ON_Object_Dump(pConstThis, pString);
return sh.ToString();
}
}
public static void ObjectChanged(Rhino.DocObjects.RhinoObject obj)
{
UnsafeNativeMethods.Rdk_CRMManager_EVF("ObjectChanged", obj.ConstPointer());
}
/// <summary>
/// Adds an ObjRef to the list.
/// </summary>
/// <param name="objref">An ObjRef to add.</param>
public void Add(Rhino.DocObjects.ObjRef objref)
{
if (null != objref)
{
IntPtr pConstObjRef = objref.ConstPointer();
IntPtr pThis = NonConstPointer();
UnsafeNativeMethods.ON_ClassArrayCRhinoObjRef_Append(pThis, pConstObjRef);
}
}
/// <summary>
/// Constructs a new basic material from a <see cref="Rhino.DocObjects.Material">Material</see>.
/// </summary>
/// <param name="material">The material to create the basic material from.</param>
/// <returns>A new basic material.</returns>
public static RenderMaterial NewBasicMaterial(Rhino.DocObjects.Material material)
{
NativeRenderMaterial newMaterial = RenderContent.FromPointer(UnsafeNativeMethods.Rdk_Globals_NewBasicMaterial(material == null ? IntPtr.Zero : material.ConstPointer())) as NativeRenderMaterial;
newMaterial.AutoDelete = true;
return newMaterial;
}
