Namespaces
	RhRdk
	Forward declaration for CRhinoDisplayPipeline::RealtimeDisplayMode.

Classes
struct	__POSITION
	abstract iteration position More...

struct	_charrange

struct	_GLYPHMETRICSFLOAT

class	CArgsRhinoFair

class	CArgsRhinoHatch

class	CArgsRhinoLoft

class	CArgsRhinoMatch
	CArgsRhinoMatch is obsolete. More...

class	CArgsRhinoPrintExportDlg

class	CArgsRhinoSweep1

class	CArgsRhinoSweep2

class	CChannelAttributes

class	CColorVec

class	CDisplayAttributeMaterial

class	CDisplayPipelineAttributes

class	CDisplayPipelineMaterial

class	CLinesDescriptor
	Lines helper class used to describe and draw large chunks of lines. More...

struct	ClippingInfo

struct	CRhCurveAttributes

class	CRhinoAfterTransformObject

class	CRhinoAnnotation

class	CRhinoAnnotationSettings
	CRhinoAnnotationSettings class Note: Dimscale is now part of the DimStyles class and this class property is obsolete. Also, much of the CRhinoAnnotationSettings class has been replaced with CRhinoAnnotationSettingsEx. More...

class	CRhinoAnnotationSettingsEx

class	CRhinoApp
	CRhinoApp: More...

class	CRhinoAppAliasList

class	CRhinoAppAppearanceSettings

class	CRhinoAppChooseOneObjectSettings

class	CRhinoAppContextMenuSettings

class	CRhinoAppCursorToolTipSettings

class	CRhinoAppDontRepeatCommandSettings

class	CRhinoAppFileSettings

class	CRhinoAppFonts

class	CRhinoAppGeneralSettings

class	CRhinoAppGridSettings

class	CRhinoAppModelAidSettings

class	CRhinoAppMouseSettings

class	CRhinoAppSelectionFilterSettings

class	CRhinoAppSettings

class	CRhinoAppShortcutKeys

class	CRhinoAppSmartTrackSettings

class	CRhinoAppSpaceBallSettings

class	CRhinoAppViewSettings

class	CRhinoBendSpaceMorph

class	CRhinoBitmap

class	CRhinoBitmapTable

struct	CRhinoBrepEdgeFilletDistance

class	CRhinoBrepObject

class	CRhinoCacheHandle

class	CRhinoCageObject

class	CRhinoCCXEvent

class	CRhinoCentermark

class	CRhinoClippingPlaneObject

class	CRhinoColorButton

class	CRhinoCommand
	Every command is Rhino is defined by a class derived from CRhinoCommand. More...

class	CRhinoCommandAlias

class	CRhinoCommandContext

class	CRhinoCommandManager

class	CRhinoCommandOption

class	CRhinoCommandOptionName

class	CRhinoCommandOptionValue

class	CRhinoComponentNameConflictUI

class	CRhinoContextMenu

class	CRhinoContextMenuContext

class	CRhinoContextMenuExtension

class	CRhinoContourInput

class	CRhinoCopyGripsHelper

class	CRhinoCoreAppActivity

class	CRhinoCreateDocumentOptions

class	CRhinoCSXEvent

class	CRhinoCurvatureAnalysisSettings

class	CRhinoCurvatureGraphSettings

class	CRhinoCurveObject

class	CRhinoDetailViewIterator

class	CRhinoDetailViewObject

class	CRhinoDialog

class	CRhinoDib

class	CRhinoDigitizerInfo

class	CRhinoDigitizerManager

class	CRhinoDigitizerPlugIn

class	CRhinoDimAngular

class	CRhinoDimension

class	CRhinoDimensionHistoryEnabler

class	CRhinoDimLinear

class	CRhinoDimOrdinate

class	CRhinoDimRadial

class	CRhinoDimStyle
	CRhinoDimStyle class. More...

class	CRhinoDimStyleComboBox
	CRhinoDimStyleComboBox window. More...

class	CRhinoDimStyleContext

class	CRhinoDimStyleTable

class	CRhinoDirectionAnalysisSettings

class	CRhinoDirectoryManager

class	CRhinoDisplayAttrsMgr

class	CRhinoDisplayConduit

class	CRhinoDisplayEngine

class	CRhinoDisplayEngine_GDI

class	CRhinoDisplayEngine_OGL

class	CRhinoDisplayErrorMessage

class	CRhinoDisplayModeChanged

class	CRhinoDisplayModeSettingsChanged

class	CRhinoDisplayPipeline

class	CRhinoDisplayPipeline_GDI

class	CRhinoDisplayPipeline_OGL

class	CRhinoDisplaySettings

class	CRhinoDoc

class	CRhinoDocIterator

class	CRhinoDocProperties

class	CRhinoDocTableReference

class	CRhinoDocumentPropertiesTabs

class	CRhinoDoubleClickContext

class	CRhinoDpi

class	CRhinoDraftAngleAnalysisSettings

class	CRhinoDrawAttributes

class	CRhinoDrawCallback

class	CRhinoDrawCommonAttributes
	Location for new V6 public SDK display. More...

class	CRhinoDrawFancyAttributes

class	CRhinoDrawGripsSettings

class	CRhinoDropTarget

class	CRhinoDump

class	CRhinoEdgeAnalysisSettings

class	CRhinoEdgeContinuitySettings

class	CRhinoEmapAnalysisSettings

class	CRhinoEndAnalysisSettings

class	CRhinoEventWatcher

class	CRhinoEventWatcherEx

class	CRhinoExtend

class	CRhinoExtrusionObject

class	CRhinoFileExportPlugIn

class	CRhinoFileImportPlugIn

class	CRhinoFileMenu

class	CRhinoFileReadOptions

class	CRhinoFileType

class	CRhinoFileUtilities
	File IO helpers. More...

class	CRhinoFileWriteOptions

class	CRhinoFilletEdge

class	CRhinoFitPatch

class	CRhinoFlowSpaceMorph

class	CRhinoGetDimAngular
	Class to interactively get user input for angular dimensions. More...

class	CRhinoGetDimLinear
	Class to interactively get user input for linear dimensions. More...

class	CRhinoGetDimOrdinate
	Class to interactively get user input for radial dimensions. More...

class	CRhinoGetDimRadial
	Class to interactively get user input for radial dimensions. More...

class	CRhinoGripDirections

class	CRhinoGripObject

class	CRhinoGripObjectEx

class	CRhinoGripsEnabler

class	CRhinoGripStatus

class	CRhinoGroup

class	CRhinoGroupGeometry

class	CRhinoGroupObject

class	CRhinoGroupTable

class	CRhinoGumball

class	CRhinoGumballAppearance

class	CRhinoGumballColors

class	CRhinoGumballDisplayConduit

class	CRhinoGumballDragger

class	CRhinoGumballDragSettings

class	CRhinoGumballFrame

class	CRhinoGumballPickResult

class	CRhinoGumballPopUpMenu

class	CRhinoGumballSizes

class	CRhinoHatch

class	CRhinoHatchPattern
	CRhinoHatchPattern class. More...

class	CRhinoHatchPatternTable
	CRhinoHatchPatternTable class - A list of Hatch Pattern definitions. More...

class	CRhinoHiddenCommand

class	CRhinoHistory

class	CRhinoHistoryManager

class	CRhinoHistoryRecord

class	CRhinoHistoryRecordTable

class	CRhinoInferredCurve
	9-17-03 LW added in conjunction with inferred curve osnap testing More...

class	CRhinoInferredCurveArray

class	CRhinoInstanceDefinition

class	CRhinoInstanceDefinitionTable

class	CRhinoInstanceObject

class	CRhinoInstanceObjectIterator
	CRhinoInstanceObjectIterator is used to iterate all instance definition geometry referenced by a CRhinoInstanceObject. Any nested instance definition geometry that is referenced multiple times is returned only once. It safely iterates nested instance definitions in a way that protects against infinite looping when damaged models contain circular nested references. It iterates in a way so that it will not crash if the document is modified or deleted between calls to NextObject(). More...

class	CRhinoInstanceObjectPiece

class	CRhinoIntSnapCandidate

class	CRhinoIsIdle

class	CRhinoKeepKinkySurfaces

class	CRhinoKeyboardShortcut

class	CRhinoLayer

class	CRhinoLayerComboBox
	CRhinoLayerComboBox window. More...

class	CRhinoLayerNode

class	CRhinoLayerState

class	CRhinoLayerTable

class	CRhinoLeader

class	CRhinoLeaseChangedEventArgs

class	CRhinoLicenseLease

class	CRhinoLicenseValidator

class	CRhinoLight

class	CRhinoLightTable

class	CRhinoLinetype

class	CRhinoLinetypeTable

class	CRhinoLoftCurve

class	CRhinoMaelstromSpaceMorph

class	CRhinoMaterial

class	CRhinoMaterialTable

class	CRhinoMeshBooleanOptions
	Contains additional information about mesh booleans. This class can have more methods added. More...

class	CRhinoMeshDensity

class	CRhinoMeshObject

class	CRhinoMeshObjectsUI

class	CRhinoMeshStlUI

class	CRhinoModelessUserInterfaceDocChanged

class	CRhinoModelViewIterator

class	CRhinoMorphControl

class	CRhinoMouseCallback

class	CRhinoNamedColor

class	CRhinoNamedViewCameraIcon

class	CRhinoObject
	Base class for all runtime Rhino objects. More...

class	CRhinoObjectAttributes

class	CRhinoObjectColorComboBox
	CRhinoObjectColorComboBox window. More...

class	CRhinoObjectDrawContext

class	CRhinoObjectDrawIterator

class	CRhinoObjectGrips

class	CRhinoObjectIterator

class	CRhinoObjectMesh

class	CRhinoObjectPair

class	CRhinoObjectPropertiesModelessDockingDialog
	CRhinoObjectPropertiesModelessDockingDialog. More...

class	CRhinoObjectVisualAnalysisMode

class	CRhinoObjRef

class	CRhinoObjRefArray

class	CRhinoOnAfterPostReadViewUpdate

class	CRhinoOnBeforePostReadViewUpdate

class	CRhinoOnChangeObjectSelectState

class	CRhinoOnDocUserStringChanged

class	CRhinoOnMainLoopEvent

class	CRhinoOnPageViewPropertiesChanged

class	CRhinoOnSetActiveDetailObject

class	CRhinoOnTransformObject

class	CRhinoOnViewEnableDrawingChanged

class	CRhinoOnViewModifiedEvent

class	CRhinoOpenDocumentOptions

class	CRhinoOpenGLSettings

class	CRhinoOptionsPageCollection

class	CRhinoOptionsPageCollectionItem

class	CRhinoOptionsPageEventArgs

class	CRhinoPageView

class	CRhinoPageViewIterator

class	CRhinoPageViewObjectIterator

class	CRhinoPhantomObject

class	CRhinoPickContext

struct	CRhinoPickContext_MeshEdgeInfo

class	CRhinoPickFilter

class	CRhinoPlotColorComboBox
	CRhinoPlotColorComboBox window. More...

class	CRhinoPlugIn

class	CRhinoPlugInCommandRecord

class	CRhinoPlugInInfo

class	CRhinoPlugInRecord

class	CRhinoPlugInSettingsChanged

class	CRhinoPointCloudObject

class	CRhinoPointObject

class	CRhinoPolyEdge

class	CRhinoPolyEdgeSegment

class	CRhinoPolylineOnMeshUserData

class	CRhinoPopupMenu

class	CRhinoPrintControlsBase

class	CRhinoPrintInfo

class	CRhinoPropertiesPanelPageCollection

class	CRhinoPropListFileProfileContext

class	CRhinoPropListProfileContext

class	CRhinoPropListProfileContextIterator

class	CRhinoProxyObject

class	CRhinoRecordHistoryCommandOptionHelper

class	CRhinoRenderOverlays

class	CRhinoRenderPlugIn

class	CRhinoReplaceColorDialog

class	CRhinoSaveAndRestoreAppFileReadOptions

class	CRhinoScriptCommand

class	CRhinoScriptContext

class	CRhinoSdkRender

class	CRhinoSdkRenderEx

class	CRhinoSdkRenderEx2

class	CRhinoSdkRenderEx3

class	CRhinoSelCommand

class	CRhinoSelSubObjectCommand

class	CRhinoSettings

class	CRhinoSkinDLL

class	CRhinoSkinDLLEx

class	CRhinoSnapContext

class	CRhinoSnapEvent

class	CRhinoSpaceMorph

class	CRhinoSplopSpaceMorph

class	CRhinoSporphSpaceMorph
	Flow along surface morph. More...

class	CRhinoStereoDisplayConduit

class	CRhinoStretchSpaceMorph

class	CRhinoSubDDisplay

class	CRhinoSubDDisplayAttributes

class	CRhinoSubDObject

class	CRhinoSubDPickSettings

class	CRhinoSurfaceFillet
	New interactive attempt at FilletSrf. More...

class	CRhinoSurfaceObject

class	CRhinoTabbedDockBarDialog

class	CRhinoTaperSpaceMorph
	Taper morph. More...

class	CRhinoTargetDocChanged

class	CRhinoTempAttachCMenu

class	CRhinoTestCommand

class	CRhinoText

class	CRhinoTextDot

class	CRhinoTextDump

class	CRhinoTextOut

class	CRhinoTextOutTextLog

class	CRhinoTextureMapping

class	CRhinoTextureMappingTable

class	CRhinoThicknessAnalysisSettings

class	CRhinoTransformCommand

class	CRhinoTwistSpaceMorph
	Twist morph. More...

class	CRhinoUiFileEvent

class	CRhinoUiFontComboBox
	CRhinoUiFontComboBox. More...

class	CRhinoUiPaintColorSettings
	Colors for the general windows user interface elements. More...

class	CRhinoUndoEventHandler
	Use CRhinoUndoEventHandlerEx instead. More...

class	CRhinoUndoEventHandlerEx

class	CRhinoUnroll

class	CRhinoUtilityPlugIn

class	CRhinoUuidCollection

class	CRhinoView

class	CRhinoViewIterator

class	CRhinoViewport

class	CRhinoViewportIterator

class	CRhinoVisualAnalysisMode

class	CRhinoWaitCursor

class	CRhinoWidget

class	CRhinoWidgetColorSettings

class	CRhinoWidgetGeometry

class	CRhinoWidgetGrip

class	CRhinoWindow

class	CRhinoWindowCreateOptions

class	CRhinoWireframeObject

class	CRhinoWorkerThread

class	CRhinoWorkSession

class	CRhinoZBuffer

class	CRhinoZebraAnalysisSettings

class	CRhMeshBooleanOptionsPrivate

class	CRhWidgetDrawAttr

class	CRhWidgetThickerDottedDrawAttr

struct	CSupportChannels

class	CUD_source_index

class	DisplayAttrsMgrList

class	DisplayAttrsMgrListDesc

class	IDockBarEventWatcher
	Interface class for forwarding dockbar events. More...

class	IRhinoAddPropertiesPages

class	IRhinoMeshExtruder
	Interface to preview and perform mesh extrusions. More...

class	IRhinoOptionsPage

class	IRhinoOptionsPageHost

class	IRhinoPage

class	IRhinoPageHost

class	IRhinoPropertiesPanelPage

class	IRhinoPropertiesPanelPageEventArgs

class	IRhinoPropertiesPanelPageEventWatcher

class	IRhinoPropertiesPanelPageHost

class	IRhinoSdkRenderFrame

class	IRhinoSdkRenderFrameEx

class	IRhinoSdkRenderFrameEx2
	Alpha support added when saving rendered image. More...

class	IRhinoSdkRenderFrameEx3
	Added support for picking. More...

class	IRhinoSnapshotsClient

class	IRhinoSnapshotsClientEx

class	IRhinoWindow

class	IRhWidgetDrawCache

class	IRhWidgetDrawCacheEx

class	ITabbedDockBarEventWatcher
	Extension interface for forwarding tabbed dockbar events. More...

class	MRhinoApp

struct	RealtimeDisplayMode

struct	RegisteredPipeline

class	RhDevelopableSurface

class	RhDisplacement
	Represents surface displacement on an object. More...

class	RhDisplacementArgs
	A class containing all displacement options. More...

class	RhEdgeSofteningArgs

class	RhinoCheckMeshOutput

class	RhinoMeshEdgeSlider
	Class for sliding edges of a mesh. More...

class	RhinoMeshUnwrapper

class	RhinoReduceMeshParameters

class	RhinoSdkBlend

class	RhinoSubDEdgeSlider
	Class for sliding edges of a SubD. More...

class	RhinoVersion

class	RhMeshPipeArgs

class	RhShutLiningArgs
	Shut-lining arguments. More...

class	RhShutLiningCurveArgs
	Shut-lining curve arguments. More...

class	RhSimplifyCurveFlags

struct	tagBROWSEINFO

struct	tagCLIPFORMAT

struct	tagCREATESTRUCT

struct	tagLOGBRUSH

struct	tagMakeRadiusSplineData

struct	tagNCCALCSIZE_PARAMS

struct	tagPAINTSTRUCT

struct	tagPALETTEENTRY

struct	tagPIXELFORMATDESCRIPTOR

struct	tagPOINT

struct	tagPOINTFLOAT

struct	tagRECT

struct	tagSIZE

struct	tagSTGMEDIUM

struct	tagSYSTEMTIME

struct	tagTCITEM

struct	tagTOOLINFOW

struct	tagWINDOWPLACEMENT

struct	tagWINDOWPOS

Macros
#define	_CRT_SECURE_NO_DEPRECATE

#define	_WIN32_IE RHINO_IE_VERSION

#define	_WIN32_WINDOWS _WIN32_WINNT

#define	_WIN32_WINNT RHINO_WINVER

#define	CONST const
	Define some Windows types and structures. More...

#define	CRhinoPickList CRhinoObjRefArray
	obsolete symbol - use CRhinoObjRefArray More...

#define	DECLARE_DYNAMIC_PIPELINE(class_name)

#define	DECLARE_PIPELINE_ATTRIBUTE_CLASS ON_UUID ClassId() const override;

#define	ERROR_ACCESS_DENIED 5L

#define	ERROR_FILE_NOT_FOUND 2L

#define	ERROR_INVALID_DATA 13L

#define	ERROR_INVALID_FUNCTION 1L

#define	ERROR_INVALID_PIXEL_FORMAT -23347

#define	ERROR_MOD_NOT_FOUND -23345

#define	ERROR_MORE_DATA 234L

#define	ERROR_NO_MORE_ITEMS 259L

#define	ERROR_PROC_NOT_FOUND -23346

#define	ERROR_SUCCESS 0L

#define	GetAValue(c) ((c).Alpha())

#define	GetBValue(c) ((c).Blue())

#define	GetGValue(c) ((c).Green())

#define	GetRValue(c) ((c).Red())

#define	HIBYTE(w) ((BYTE)((((DWORD_PTR)(w)) >> 8) & 0xff))

#define	IMPLEMENT_DYNAMIC_PIPELINE(class_name, base_name, description, uuid, bwire, bshade)

#define	LOBYTE(w) ((BYTE)(((DWORD_PTR)(w)) & 0xff))

#define	MAC_DEPRECATED
	OBSOLETE in Rhino 8.x and later ///< #define RHINO_V8SR 0. More...

#define	MB_APPLMODAL 0x00000000L

#define	MB_DEFAULT_DESKTOP_ONLY 0x00020000L

#define	MB_DEFBUTTON1 0x00000000L

#define	MB_DEFBUTTON2 0x00000100L

#define	MB_DEFBUTTON3 0x00000200L

#define	MB_DEFMASK 0x00000F00L

#define	MB_HELP 0x00004000L
	Help Button. More...

#define	MB_ICONASTERISK 0x00000040L

#define	MB_ICONERROR MB_ICONHAND

#define	MB_ICONEXCLAMATION 0x00000030L

#define	MB_ICONHAND 0x00000010L

#define	MB_ICONINFORMATION MB_ICONASTERISK

#define	MB_ICONMASK 0x000000F0L

#define	MB_ICONQUESTION 0x00000020L

#define	MB_ICONSTOP MB_ICONHAND

#define	MB_ICONWARNING MB_ICONEXCLAMATION

#define	MB_MISCMASK 0x0000C000L

#define	MB_MODEMASK 0x00003000L

#define	MB_NOFOCUS 0x00008000L

#define	MB_RIGHT 0x00080000L

#define	MB_RTLREADING 0x00100000L

#define	MB_SERVICE_NOTIFICATION 0x00200000L

#define	MB_SERVICE_NOTIFICATION_NT3X 0x00040000L

#define	MB_SETFOREGROUND 0x00010000L

#define	MB_SYSTEMMODAL 0x00001000L

#define	MB_TASKMODAL 0x00002000L

#define	MB_TOPMOST 0x00040000L

#define	MB_TYPEMASK 0x0000000FL

#define	MB_USERICON 0x00000080L

#define	MF_BYCOMMAND 0x00000000L

#define	MF_BYPOSITION 0x00000000L

#define	MF_CHECKED 0x00000008L

#define	MF_SEPARATOR 0x00000800L

#define	MF_STRING 0x00000000L

#define	MF_UNCHECKED 0x00000000L

#define	NTDDI_VERSION RHINO_NTDDI_VERSION

#define	OPENNURBS_IMPORTS

#define	OPENNURBS_IMPORTS
	release build More...

#define	OPENNURBS_VERSION_DEFINITION

#define	PS_ALTERNATE 8

#define	PS_COSMETIC 0x00000000

#define	PS_DASH 1 /* ------- */

#define	PS_DASHDOT 3 /* _._._._ */

#define	PS_DASHDOTDOT 4 /* _.._.._ */

#define	PS_DOT 2 /* ....... */

#define	PS_ENDCAP_FLAT 0x00000200

#define	PS_ENDCAP_ROUND 0x00000000

#define	PS_ENDCAP_SQUARE 0x00000100

#define	PS_ENDCAP_STYLE 0x00000F00

#define	PS_GEOMETRIC 0x00010000

#define	PS_INSIDEFRAME 6

#define	PS_JOIN_BEVEL 0x00001000

#define	PS_JOIN_MITER 0x00002000

#define	PS_JOIN_ROUND 0x00000000

#define	PS_JOIN_STYLE 0x0000F000

#define	PS_NULL 5

#define	PS_SOLID 0

#define	PS_USERSTYLE 7

#define	REGISTER_PIPELINE_ATTRIBUTE_CLASS(className, classId)

#define	RGB(r, g, b) (ON_Color(r,g,b))

#define	RGBA(r, g, b, a) (ON_Color(r,g,b,a))

#define	RHCMDOPTNAME(s) CRhinoCommandOptionName(s,s)

#define	RHCMDOPTVALUE(s) CRhinoCommandOptionValue(s,s)

#define	RHINO_6_OR_LATER

#define	RHINO_7_OR_LATER

#define	RHINO_8_OR_LATER

#define	RHINO__SDK__VERSION__DEFINITION__

#define	RHINO_CLAMP(V, L, H) ( (V) < (L) ? (L) : ( (V) > (H) ? (H) : (V) ) )

#define	RHINO_CLAMP_UI_SUBD_DISPLAY_DENSITY(D) (D < ON_SubDDisplayParameters::MinimumUserInterfaceDensity ? ON_SubDDisplayParameters::MinimumUserInterfaceDensity : (D > ON_SubDDisplayParameters::MaximumUserInterfaceDensity ? ON_SubDDisplayParameters::MaximumUserInterfaceDensity : D))

#define	RHINO_COMPONENT_INDEX OBSOLETE__USE__ON_COMPONENT_INDEX
	RHINO_COMPONENT_INDEX is OBSOLETE as of 9/30/2004 - user ON_COMPONENT_INDEX. More...

#define	RHINO_CURRENT_FILE_VERSION_NUMBER (OPENNURBS_CURRENT_ARCHIVE_VERSION/10)

#define	RHINO_IE_VERSION 0x0700

#define	RHINO_NOEXCEPT ON_NOEXCEPT
	#define RHINO_9_OR_LATER More...

#define	RHINO_NTDDI_VERSION 0x06010000

#define	RHINO_PLUG_IN_DECLARE

#define	RHINO_PLUG_IN_DECLARE #error include .../SDK/inc/rhinoSdkPlugInDeclare.h in the .cpp file where you are seeing this error.
	A Rhino plug-in is being compiled - import Rhino SDK symbols. More...

#define	RHINO_PLUG_IN_DECLARE_IS_ERROR

#define	RHINO_PLUG_IN_DEPENDENCIES(sIdList) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDependencies(void) {return sIdList;}

#define	RHINO_PLUG_IN_DESCRIPTION(sPlugInDescription) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDescription(void) { return sPlugInDescription; }

#define	RHINO_PLUG_IN_DEVELOPER_ADDRESS(sDeveloperAddress) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperAddress(void) {return sDeveloperAddress;}

#define	RHINO_PLUG_IN_DEVELOPER_COUNTRY(sDeveloperCountry) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperCountry(void) {return sDeveloperCountry;}

#define	RHINO_PLUG_IN_DEVELOPER_EMAIL(sDeveloperEmail) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperEmail(void) {return sDeveloperEmail;}

#define	RHINO_PLUG_IN_DEVELOPER_FAX(sDeveloperFax) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperFax(void) {return sDeveloperFax;}

#define	RHINO_PLUG_IN_DEVELOPER_ORGANIZATION(sDeveloperOrganization) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperOrganization(void) {return sDeveloperOrganization;}

#define	RHINO_PLUG_IN_DEVELOPER_PHONE(sDeveloperPhone) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperPhone(void) {return sDeveloperPhone;}

#define	RHINO_PLUG_IN_DEVELOPER_WEBSITE(sDeveloperWebsite) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperWebsite(void) {return sDeveloperWebsite;}

#define	RHINO_PLUG_IN_ICON_RESOURCE_ID(nIconResourceId) extern "C" RHINO_SDK_EXPORT unsigned int RhinoPlugInIconResourceId(void) { return nIconResourceId; }

#define	RHINO_PLUG_IN_ID(sPlugInId) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInId(void) {return sPlugInId;}

#define	RHINO_PLUG_IN_NAME(sPlugInName) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInName(void) {return sPlugInName;}

#define	RHINO_PLUG_IN_UPDATE_URL(sUpdatePlugInURL) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInUpdateURL(void) {return sUpdatePlugInURL;}

#define	RHINO_PLUG_IN_VERSION(sPlugInVersion) extern "C" RHINO_SDK_EXPORT const char* RhinoPlugInVersion(void) {return sPlugInVersion;}

#define	RHINO_PLUGIN_COMPILE

#define	RHINO_PREPROC_STRINGIZE(s) RHINO_PREPROC_STRINGIZE_HELPER(s)
	#pragma once More...

#define	RHINO_PREPROC_STRINGIZE_HELPER(s) #s

#define	RHINO_REGISTRY_ROOT_STRING "McNeel\\Rhinoceros\\" RMA_VERSION_NUMBER_MAJOR_STRING ".0"

#define	RHINO_REGISTRY_ROOT_WSTRING L"McNeel\\Rhinoceros\\" RMA_VERSION_NUMBER_MAJOR_WSTRING ".0"

#define	RHINO_SDK_CHECKS__LINKER__INSTRUCTIONS__
	These checks are very specific to Windows Rhino. More...

#define	RHINO_SDK_CLASS __attribute__ ((visibility ("default")))

#define	RHINO_SDK_DATA __attribute__ ((visibility ("default")))

#define	RHINO_SDK_EXPORT __attribute__ ((visibility ("default")))

#define	RHINO_SDK_FUNCTION __attribute__ ((visibility ("default")))

#define	RHINO_SDK_H__INCLUDED__
	3rd party Rhino SDK plug-in developer path to openNURBS tools More...

#define	RHINO_SDK_H_IN_PROGRESS_
	the following line must be the first line in this file that is not a comment More...

#define	RHINO_SDK_LINUX_VERSION RHINO_SDK_SERVICE_RELEASE

#define	RHINO_SDK_OSX_VERSION RHINO_SDK_SERVICE_RELEASE

#define	RHINO_SDK_PLUG_IND_DECLARE_INC_

#define	RHINO_SDK_SERVICE_RELEASE RHINO_VERSION_NUMBER

#define	RHINO_SDK_STDAFX_PREAMBLE_H__

#define	RHINO_SDK_TEMPLATE __attribute__ ((visibility ("default")))

#define	RHINO_SDK_WINDOWS_VERSION ON_VERSION_NUMBER_CTOR(6, 0, 2017, 8, 15, 1 )
	SDK is frozen when the definition of RHINO_SDK_WINDOWS_VERSION is a hardcoded number. More...

#define	RHINO_SDK_WINVER_H_INCLUDED_
	Please discuss any changes to this file with Dale Lear. More...

#define	RHINO_VERSION_BRANCH OPENNURBS_VERSION_BRANCH

#define	RHINO_VERSION_DAY_OF_MONTH OPENNURBS_VERSION_DAY_OF_MONTH

#define	RHINO_VERSION_HOUR OPENNURBS_VERSION_HOUR

#define	RHINO_VERSION_MAJOR OPENNURBS_VERSION_MAJOR
	Public SDK path to opennurbs_version.h. More...

#define	RHINO_VERSION_MINOR OPENNURBS_VERSION_MINOR
	"minor" corresponds to the Rhinoceros 6 service release number More...

#define	RHINO_VERSION_MINUTE OPENNURBS_VERSION_MINUTE

#define	RHINO_VERSION_MONTH OPENNURBS_VERSION_MONTH

#define	RHINO_VERSION_NUMBER

#define	RHINO_VERSION_NUMBER_MAJOR_STRING RMA_VERSION_NUMBER_MAJOR_STRING

#define	RHINO_VERSION_NUMBER_MAJOR_WSTRING RMA_VERSION_NUMBER_MAJOR_WSTRING

#define	RHINO_VERSION_NUMBER_SR_STRING RMA_VERSION_NUMBER_SR_STRING

#define	RHINO_VERSION_NUMBER_SR_WSTRING RMA_VERSION_NUMBER_SR_WSTRING

#define	RHINO_VERSION_NUMBER_STRING RMA_VERSION_WITH_PERIODS_STRING

#define	RHINO_VERSION_NUMBER_WITH_COMMAS VERSION_WITH_COMMAS

#define	RHINO_VERSION_NUMBER_WSTRING RMA_VERSION_WITH_PERIODS_WSTRING

#define	RHINO_VERSION_YEAR OPENNURBS_VERSION_YEAR

#define	RHINO_WINDOWS_REGISTRY_SVN_BRANCH L"trunk"

#define	RHINO_WINVER 0x0601

#define	RHINOCEROS_APP_NAME_STRING "Rhinoceros " RMA_VERSION_NUMBER_MAJOR_STRING
	char strings More...

#define	RHINOCEROS_APP_NAME_WSTRING L"Rhinoceros " RMA_VERSION_NUMBER_MAJOR_WSTRING
	wchar_t strings More...

#define	SDKMFCUSAGE true

#define	SDKMFCVER 0

#define	SW_FORCEMINIMIZE 11

#define	SW_HIDE 0

#define	SW_MAX 11

#define	SW_MAXIMIZE 3

#define	SW_MINIMIZE 6

#define	SW_NORMAL 1

#define	SW_RESTORE 9

#define	SW_SHOW 5

#define	SW_SHOWDEFAULT 10

#define	SW_SHOWMAXIMIZED 3

#define	SW_SHOWMINIMIZED 2

#define	SW_SHOWMINNOACTIVE 7

#define	SW_SHOWNA 8

#define	SW_SHOWNOACTIVATE 4

#define	SW_SHOWNORMAL 1

#define	SWP_NOACTIVATE 0x0010

#define	SWP_NOMOVE 0x0002

#define	SWP_NOSIZE 0x0001

#define	SWP_NOZORDER 0x0004

#define	SWP_SHOWWINDOW 0x0040

#define	TL_IMPORTS

#define	TPM_BOTTOMALIGN 0x0020L

#define	TPM_LEFTALIGN 0x0000L

#define	TPM_RETURNCMD 0x0100L

#define	WINVER _WIN32_WINNT

Typedefs
typedef long long	__int64

typedef struct ON_WindowsBITMAPFILEHEADER	BITMAPFILEHEADER

typedef struct ON_WindowsBITMAPINFO	BITMAPINFO

typedef struct ON_WindowsBITMAPINFOHEADER	BITMAPINFOHEADER

typedef signed char	BOOL32

typedef signed char	BOOL32

typedef struct tagBROWSEINFO	BROWSEINFO

typedef LPWSTR	BSTR

typedef unsigned char	BYTE

typedef ON_Font	CFont

typedef char	CHAR

typedef struct _charrange	CHARRANGE

typedef struct tagCLIPFORMAT	CLIPFORMAT

typedef NSPasteBoard	COleDataObject

typedef ON_Color	COLORREF

typedef ON_SimpleArray< CRhinoDisplayConduit * >	ConduitList

typedef struct tagCREATESTRUCT	CREATESTRUCT

typedef void *	CRITICAL_SECTION

typedef bool(*	CUSTOM_MESH_HANDLER_FUNC) (const CRhinoObject &, ON_SimpleArray< ON_Mesh * > &aMeshes)

typedef bool(*	CUSTOM_MESH_HANDLER_FUNC2) (const CRhinoObject &, std::vector< std::shared_ptr< const ON_Mesh >> &aMeshes)

typedef double	DATE

typedef ON_SimpleArray< int >	DisplayBucket
	Object management constructs... More...

typedef NSDragOperation	DROPEFFECT

typedef unsigned int	DWORD

typedef unsigned long long	DWORD64

typedef unsigned long	DWORD_PTR

typedef float	FLOAT

typedef struct _GLYPHMETRICSFLOAT	GLYPHMETRICSFLOAT

typedef ON_UUID	GUID

typedef void *	HACCEL

typedef void *	HANDLE

typedef LPBITMAPINFO	HBITMAP

typedef void *	HBRUSH

typedef id	HCURSOR

typedef void *	HDC

typedef void *	HDWP

typedef void *	HFONT

typedef void *	HGDIOBJ

typedef void *	HGLOBAL

typedef NSOpenGLContext *	HGLRC

typedef void *	HHOOK

typedef LPBITMAPINFO	HICON

typedef void *	HIMAGELIST

typedef void *	HINSTANCE

typedef void *	HKEY

typedef void *	HMENU

typedef void *	HMODULE

typedef void *	HMONITOR

typedef void *	HPALETTE

typedef void *	HPEN

typedef int	HRESULT

typedef void *	HRGN

typedef void *	HTHEME

typedef void *	HTREEITEM

typedef CWnd *	HWND

typedef int	INT

typedef long	INT_PTR

typedef long long	LARGE_INTEGER

typedef unsigned long	LCID

typedef struct tagLOGBRUSH	LOGBRUSH

typedef ON_Font	LOGFONT

typedef ON_Font	LOGFONTW

typedef long	LONG

typedef long	LONG_PTR

typedef long long	LONGLONG

typedef LONG_PTR	LPARAM

typedef struct ON_WindowsBITMAPFILEHEADER *	LPBITMAPFILEHEADER

typedef struct ON_WindowsBITMAPINFO *	LPBITMAPINFO

typedef BOOL32 *	LPBOOL

typedef BYTE *	LPBYTE

typedef void *	LPCDLGTEMPLATE

typedef void *	LPCOMPAREITEMSTRUCT

typedef struct tagCREATESTRUCT *	LPCREATESTRUCT

typedef void *	LPCRITICAL_SECTION

typedef CONST void *	LPCVOID

typedef void *	LPDELETEITEMSTRUCT

typedef void *	LPDEVMODE

typedef void *	LPDISPATCH

typedef void *	LPDRAWITEMSTRUCT

typedef DWORD *	LPDWORD

typedef struct _GLYPHMETRICSFLOAT *	LPGLYPHMETRICSFLOAT

typedef void *	LPHELPINFO

typedef int *	LPINT

typedef long *	LPLONG

typedef void *	LPMEASUREITEMSTRUCT

typedef void *	LPNMUPDOWN

typedef struct tagPAINTSTRUCT *	LPPAINTSTRUCT

typedef struct tagPALETTEENTRY *	LPPALETTEENTRY

typedef struct tagPOINT *	LPPOINT

typedef struct tagPOINTFLOAT *	LPPOINTFLOAT

typedef void *	LPPRINTER_INFO_2

typedef struct tagRECT *	LPRECT

typedef struct tagSIZE *	LPSIZE

typedef char *	LPSTR

typedef void *	LPTOP_LEVEL_EXCEPTION_FILTER

typedef wchar_t *	LPTSTR

typedef struct tagTOOLINFOW *	LPTTTOOLINFOW

typedef void *	LPUNKNOWN

typedef void *	LPVOID

typedef WINDOWPLACEMENT *	LPWINDOWPLACEMENT

typedef struct tagWINDOWPOS *	LPWINDOWPOS

typedef WORD *	LPWORD

typedef wchar_t *	LPWSTR

typedef long	LRESULT

typedef struct tagMakeRadiusSplineData	MakeRadiusSplineData

typedef void *	MENUITEMINFO

typedef void *	MSG

typedef struct tagNCCALCSIZE_PARAMS	NCCALCSIZE_PARAMS

typedef struct tagPOINT *	NPPOINT

typedef struct tagPOINTFLOAT *	NPPOINTFLOAT

typedef struct tagRECT *	NPRECT

typedef ON_SimpleArray< const CRhinoObject * >	ObjectArray

typedef struct tagPAINTSTRUCT	PAINTSTRUCT

typedef struct tagPALETTEENTRY	PALETTEENTRY

typedef struct ON_WindowsBITMAPFILEHEADER *	PBITMAPFILEHEADER

typedef struct ON_WindowsBITMAPINFO *	PBITMAPINFO

typedef struct ON_WindowsBITMAPINFOHEADER *	PBITMAPINFOHEADER

typedef BOOL32 *	PBOOL

typedef BYTE *	PBYTE

typedef DWORD *	PDWORD

typedef unsigned long *	PDWORD_PTR

typedef bool(*	PFDRAWOVERRIDEPROC) (CRhinoDisplayPipeline &)

typedef FLOAT *	PFLOAT

typedef int *	PINT

typedef long *	PINT_PTR

typedef struct tagPIXELFORMATDESCRIPTOR	PIXELFORMATDESCRIPTOR

typedef struct tagLOGBRUSH *	PLOGBRUSH

typedef long *	PLONG_PTR

typedef struct tagPOINT	POINT

typedef struct tagPOINTFLOAT	POINTFLOAT

typedef __POSITION *	POSITION

typedef struct tagPOINT *	PPOINT

typedef struct tagPOINTFLOAT *	PPOINTFLOAT

typedef struct tagRECT *	PRECT

typedef struct tagSIZE *	PSIZE

typedef char *	PSTR

typedef struct tagTOOLINFOW *	PTOOLINFOW

typedef unsigned int *	PUINT

typedef unsigned long *	PUINT_PTR

typedef unsigned long *	PULONG_PTR

typedef void *	PVOID

typedef WINDOWPLACEMENT *	PWINDOWPLACEMENT

typedef struct tagWINDOWPOS *	PWINDOWPOS

typedef WORD *	PWORD

typedef ON_ClassArray< RealtimeDisplayMode >	RealtimeDisplayModeList

typedef struct tagRECT	RECT

typedef ON_ClassArray< RegisteredPipeline >	RegisteredPipelineList

typedef struct ON_WindowsRGBQUAD	RGBQUAD

typedef long long	RhTimestamp

typedef short	SHORT

typedef struct tagSIZE	SIZE

typedef struct tagSTGMEDIUM	STGMEDIUM

typedef struct tagSYSTEMTIME	SYSTEMTIME

typedef wchar_t	TCHAR

typedef struct tagTCITEM	TCITEM

typedef void *	TEXTMETRIC

typedef struct tagTOOLINFOW	TOOLINFOW

typedef unsigned char	UCHAR

typedef unsigned int	UINT

typedef unsigned long	UINT_PTR

typedef UInt32	ULONG

typedef unsigned long	ULONG_PTR

typedef unsigned long long	ULONGLONG

typedef unsigned short	USHORT

typedef ON_UUID	UUID

typedef void	VOID

typedef wchar_t	WCHAR

typedef struct tagWINDOWPLACEMENT	WINDOWPLACEMENT

typedef struct tagWINDOWPOS	WINDOWPOS

typedef void *	WNDPROC

typedef unsigned short	WORD

typedef UINT_PTR	WPARAM

Enumerations
enum	: unsigned int { COMBINE_ADD = 1, COMBINE_MULTIPLY = 2, COMBINE_BLEND = 3, COMBINE_HATCHED = 4, COMBINE_MULTIPLY_WITH_COLOR = 5 }
	Texture combiner constants used in DrawCombinedTextures() method... More...

enum	CRhinoDocStatus { doc_status_first = 0, create_before_construct, create_enter_construct, create_exit_construct, create_begin, create_before_CRhinoDoc_OnNewDocument, create_enter_CRhinoDoc_OnNewDocument, create_before_CDocument_OnNewDocument, create_after_CDocument_OnNewDocument, create_before_event_post_OnNewDocument, create_enter_event_post_OnNewDocument, create_exit_event_post_OnNewDocument, create_after_event_post_OnNewDocument, create_exit_CRhinoDoc_OnNewDocument, create_after_CRhinoDoc_OnNewDocument, create_before_read_template_file, create_enter_read_3dm_template_file, create_before_event_post_OnBeginOpenDocument, create_enter_event_post_OnBeginOpenDocument, create_exit_event_post_OnBeginOpenDocument, create_after_event_post_OnBeginOpenDocument, create_after_read_3dm_template_file, create_before_event_post_OnEndOpenDocument, create_enter_event_post_OnEndOpenDocument, create_exit_event_post_OnEndOpenDocument, create_after_event_post_OnEndOpenDocument, create_read_3dm_template_before_views, create_read_3dm_template_after_views, create_exit_read_3dm_template_file, create_after_read_template_file, create_before_default_views, create_after_default_views, create_end, open_begin, open_before_CRhinoDoc_OnOpenDocument, open_enter_CRhinoDoc_OnOpenDocument, open_before_CDocument_OnOpenDocument, open_before_read_model_file, open_before_read_3dm_model_file, open_enter_read_3dm_model_file, open_before_event_post_OnBeginOpenDocument, open_enter_event_post_OnBeginOpenDocument, open_exit_event_post_OnBeginOpenDocument, open_after_event_post_OnBeginOpenDocument, open_enter_read_model_file, open_exit_read_model_file, open_before_event_post_OnEndOpenDocument, open_enter_event_post_OnEndOpenDocument, open_exit_event_post_OnEndOpenDocument, open_after_event_post_OnEndOpenDocument, open_read_3dm_model_before_views, open_read_3dm_model_after_views, open_exit_read_3dm_model_file, open_after_read_3dm_model_file, open_after_CDocument_OnOpenDocument, open_after_read_model_file, open_exit_CRhinoDoc_OnOpenDocument, open_after_CRhinoDoc_OnOpenDocument, open_before_views, open_after_views, open_end, available, close_begin, close_before_CRhinoDoc_OnCloseDocument, close_enter_CRhinoDoc_OnCloseDocument, close_before_event_post_OnCloseDocument, close_enter_event_post_OnCloseDocument, close_exit_event_post_OnCloseDocument, close_after_event_post_OnCloseDocument, close_before_CDocument_OnCloseDocument, close_after_CDocument_OnCloseDocument, close_exit_CRhinoDoc_OnCloseDocument, close_after_CRhinoDoc_OnCloseDocument, close_end, close_enter_destruct, close_before_destroy, close_enter_destroy, close_exit_destroy, close_after_destroy, close_exit_destruct, doc_status_last = 0x7FFFFFFF }

enum	EConduitNotifiers { CN_PIPELINEADDED = 1, CN_PIPELINEDELETED, CN_PIPELINECLONED, CN_PIPELINEOPENED, CN_PIPELINECLOSED, CN_FRAMESIZECHANGED, CN_PROJECTIONCHANGED, CN_NESTEDPIPELINE_OPENED, CN_NESTEDPIPELINE_CLOSED }
	Conduit notification values... More...

enum	ECullFaceMode : unsigned int { CFM_DRAW_FRONT_AND_BACK = 0, CFM_DRAW_FRONT_FACES = 1, CFM_DRAW_BACK_FACES = 2 }

enum	EDepthMode : unsigned int { DM_NEUTRAL = 0, DM_ALWAYS_IN_FRONT, DM_ALWAYS_IN_BACK }

enum	EFrameBufferFillMode : int { FBFM_DEFAULT_COLOR = 1, FBFM_SOLID_COLOR, FBFM_GRADIENT_2_COLOR, FBFM_GRADIENT_4_COLOR, FBFM_BITMAP, FBFM_RENDERER, FBFM_TRANSPARENT }

enum	ELightingScheme : int { LS_NONE = 0, LS_DEFAULT_LIGHTING = 1, LS_SCENE_LIGHTING = 2, LS_CUSTOM_LIGHTING = 3, LS_AMBIENT_OCCLUSION = 4 }

enum	EnvironmentBackgroundProjection : int { EnvironmentBackgroundProjection::planar = 0, EnvironmentBackgroundProjection::spherical = 1, EnvironmentBackgroundProjection::emap = 2, EnvironmentBackgroundProjection::box = 3, EnvironmentBackgroundProjection::lightprobe = 4, EnvironmentBackgroundProjection::cubemap = 5, EnvironmentBackgroundProjection::vertical_cross_cubemap = 6, EnvironmentBackgroundProjection::horizontal_cross_cubemap = 7, EnvironmentBackgroundProjection::hemispherical = 8, EnvironmentBackgroundProjection::none = -1 }

enum	ERenderOverlayFeatures { ROF_POINTS = 0x00000001, ROF_LIGHTS = 0x00000002, ROF_MESHWIRES = 0x00000004, ROF_ISOS = 0x00000008, ROF_EDGES = 0x00000010, ROF_TEXT = 0x00000020, ROF_CURVES = 0x00000040, ROF_ANNOTATIONS = 0x00000080, ROF_SUBDWIRES = 0x00000100, ROF_SECTION_FILL = 0x00000200, ROF_SECTION_BOUNDARY = 0x00000400 }
	Post rendering features that make up all possible post renderables... More...

enum	ERhinoPointStyle : unsigned int { RPS_SQUARE = 50, RPS_CIRCLE = 51, RPS_TRIANGLE = 2, RPS_HEART = 3, RPS_CHEVRON = 4, RPS_CLOVER = 5, RPS_TAG = 6, RPS_X = 7, RPS_ASTERISK = 8, RPS_PIN = 9, RPS_ARROW_TAIL_OFF_POINT = 10, RPS_ARROW_TIP_OFF_POINT = 11, RPS_VARIABLE_DOT = 50, RPS_ROUND_DOT = 51, RPS_CONTROL_POINT = 100, RPS_ACTIVE_POINT = 101, RPS_ROUND_CONTROL_POINT = 102, RPS_ROUND_ACTIVE_POINT = 103 }
	Points helper types and classes used to describe and draw points... More...

enum	eRhSnapGeom { sng_plane_uv, sng_plane_uvw, sng_box, sng_sphere, sng_cylinder, sng_axes }

enum	EZBiasMode : int { ZBM_AWAY_FROM_CAMERA = -1, ZBM_NEUTRAL = 0, ZBM_TOWARDS_CAMERA = 1 }

enum	GUMBALL_MODE { gb_mode_nothing, gb_mode_menu, gb_mode_translatefree, gb_mode_translatex, gb_mode_translatey, gb_mode_translatez, gb_mode_translatexy, gb_mode_translateyz, gb_mode_translatezx, gb_mode_scalex, gb_mode_scaley, gb_mode_scalez, gb_mode_scalexy, gb_mode_scaleyz, gb_mode_scalezx, gb_mode_rotatex, gb_mode_rotatey, gb_mode_rotatez, gb_mode_extrudex, gb_mode_extrudey, gb_mode_extrudez, gb_mode_cutx, gb_mode_cuty, gb_mode_cutz }
	Transformation modes for gumballs. More...

enum	GUMBALL_POPUP_MENU_ITEM { gb_menu_nothing = 0, gb_menu_relocate = 1, gb_menu_autogumballon = 2, gb_menu_autogumballoff = 4, gb_menu_snappyon = 8, gb_menu_snappyoff = 16, gb_menu_settingscmd = 32, gb_menu_reset = 64, gb_rotate_view_around_autogumball = 128, gb_menu_align_to_object = 256, gb_menu_align_to_cplane = 512, gb_menu_align_to_world = 1024, gb_menu_drag_ratio = 2048, gb_menu_drag_ratio_popup = 4096, gb_menu_autoreset = 8192, gb_menu_enter = 16384, gb_menu_align_to_view = 32768, gb_extrude_merge_faces = 65536, gb_menu_everything = 0xFFFFFFFF }

enum	RhDisplacementSweepResolutionFormula : int { RhDisplacementSweepResolutionFormula::Default = 0, RhDisplacementSweepResolutionFormula::AbsoluteToleranceDependent = 1 }

enum	RHINO_IDEF_STATUS { RHINO_IDEF_NOT_A_LINKED_IDEF = -3, RHINO_IDEF_LINKED_FILE_NOT_READABLE = -2, RHINO_IDEF_LINKED_FILE_NOT_FOUND = -1, RHINO_IDEF_LINKED_FILE_IS_TO_DATE = 0, RHINO_IDEF_LINKED_FILE_IS_NEWER = 1, RHINO_IDEF_LINKED_FILE_IS_OLDER = 2, RHINO_IDEF_LINKED_FILE_IS_DIFFERENT = 3 }

enum	RhinoConicSectionType : int { RhinoConicSectionType::Unknown = 0, RhinoConicSectionType::Circle = 1, RhinoConicSectionType::Ellipse = 2, RhinoConicSectionType::Hyperbola = 3, RhinoConicSectionType::Parabola = 4 }

enum	RhinoDashStyle : unsigned int { RhinoDashStyle::Solid, RhinoDashStyle::Dash }

enum	RhinoFilletSurfaceSplitType : int { RhinoFilletSurfaceSplitType::Nothing = 0, RhinoFilletSurfaceSplitType::Trim = 1, RhinoFilletSurfaceSplitType::Split = 2 }
	RhinoFilletSurfaceSplitType More...

enum	RhinoFilletSurfaceType : int { RhinoFilletSurfaceType::RollingBall = 0, RhinoFilletSurfaceType::Chamfer = 1, RhinoFilletSurfaceType::Rails = 2 }

enum	RhinoKeyboardModifierKey : unsigned char { RhinoKeyboardModifierKey::None = 0, RhinoKeyboardModifierKey::Ctrl = 1, RhinoKeyboardModifierKey::MacCommand = 1, RhinoKeyboardModifierKey::Shift = 2, RhinoKeyboardModifierKey::Alt = 4, RhinoKeyboardModifierKey::MacControl = 8 }

enum	RhinoLineCapStyle : int { RhinoLineCapStyle::None = 0, RhinoLineCapStyle::Round = 1, RhinoLineCapStyle::Flat = 2, RhinoLineCapStyle::Square = 3 }

enum	RhinoLineJoinStyle : int { RhinoLineJoinStyle::None = 0, RhinoLineJoinStyle::Round = 1, RhinoLineJoinStyle::Miter = 2, RhinoLineJoinStyle::Bevel = 3 }

enum	RhinoOptionPageButtons : int { RhinoOptionPageButtons::None = 0x00000000, RhinoOptionPageButtons::DefaultButton = 0x00000001, RhinoOptionPageButtons::ApplyButton = 0x00000002 }
	Standard IRhinoOptionsPageButton More...

enum	RhinoPropertiesPanelPageType : int { RhinoPropertiesPanelPageType::Material = 0, RhinoPropertiesPanelPageType::Light, RhinoPropertiesPanelPageType::Custom, RhinoPropertiesPanelPageType::ObjectProperties, RhinoPropertiesPanelPageType::Dimension, RhinoPropertiesPanelPageType::Leader, RhinoPropertiesPanelPageType::Text, RhinoPropertiesPanelPageType::Hatch, RhinoPropertiesPanelPageType::Dot, RhinoPropertiesPanelPageType::TextureMapping, RhinoPropertiesPanelPageType::Detail, RhinoPropertiesPanelPageType::ClippingPlane, RhinoPropertiesPanelPageType::NamedView, RhinoPropertiesPanelPageType::Decal, RhinoPropertiesPanelPageType::View, RhinoPropertiesPanelPageType::PageCount }
	IRhinoProperties page type More...

enum	RhinoRefitTrimKnotMode : int { RhinoRefitTrimKnotMode::None = 0, RhinoRefitTrimKnotMode::UniformEntireSurface = 1, RhinoRefitTrimKnotMode::UniformPerSpan = 2, RhinoRefitTrimKnotMode::Custom = 3 }
	The mode for adding kinots to the surface for fitting More...

enum	RhinoRefitTrimSectionMode : int { RhinoRefitTrimSectionMode::NoSections = 0, RhinoRefitTrimSectionMode::DivideAtInputKnots = 1, RhinoRefitTrimSectionMode::DivideAtAddedKnots = 2, RhinoRefitTrimSectionMode::DivideAtAllKnots = 3 }
	The mode for dividing the surface into sections More...

enum	RhinoWindowCreateOptions : int { RhinoWindowCreateOptions::None = 0x00000000, RhinoWindowCreateOptions::ChildPage = 0x00000001, RhinoWindowCreateOptions::Visible = 0x00000002, RhinoWindowCreateOptions::Sizable = 0x4, RhinoWindowCreateOptions::Frame = 0x8, RhinoWindowCreateOptions::Minimizable = 0x10, RhinoWindowCreateOptions::Maximizable = 0x20 }

enum	RhinoYesNoResponse : unsigned int { RhinoYesNoResponse::Unset = 0, RhinoYesNoResponse::Yes = 1, RhinoYesNoResponse::YesToAll = 2, RhinoYesNoResponse::No = 3, RhinoYesNoResponse::NoToAll = 4, RhinoYesNoResponse::Cancel = 5, RhinoYesNoResponse::Error = 86 }
	define RhinoYesNoResponse enum More...

enum	RhPipeCapType { RhPipeCapType::None = 0, RhPipeCapType::Flat = 1, RhPipeCapType::Box = 2, RhPipeCapType::Dome = 3 }

enum	TextureReportFilter : unsigned int { TextureReportFilter::MissingOnly, TextureReportFilter::AllTextures }

enum	TextureReportResult : unsigned int { TextureReportResult::Abort, TextureReportResult::Continue, TextureReportResult::Success, TextureReportResult::Failure }

Functions
RHINO_SDK_FUNCTION bool	CapOffSettedMesh (const ON_Mesh pInputMesh, ON_Mesh pOutputMesh, double Offset)

RHINO_SDK_FUNCTION CRhinoDisplayPipeline *	CreateDisplayPipeline (const ON_ClassId *)

RHINO_SDK_FUNCTION bool	FindRegisteredPipeline (const ON_ClassId *, RegisteredPipeline &)

RHINO_SDK_FUNCTION bool	FindRegisteredPipeline (const ON_UUID &, RegisteredPipeline &)

const RHINO_SDK_FUNCTION ON_ClassId *	GetDefaultPageViewPipeline ()

const RHINO_SDK_FUNCTION ON_ClassId *	GetDefaultShadingPipeline ()

const RHINO_SDK_FUNCTION ON_ClassId *	GetDefaultWireframePipeline ()

RHINO_SDK_FUNCTION int	GetRegisteredPipelines (RegisteredPipelineList &)

RHINO_SDK_FUNCTION int	GetRegisteredShadingPipelines (RegisteredPipelineList &)

RHINO_SDK_FUNCTION int	GetRegisteredWireframePipelines (RegisteredPipelineList &)

RHINO_SDK_FUNCTION bool	MakeRhinoContours (const CRhinoContourInput &input, ON_SimpleArray< ON_Polyline * > &output_PlineArray, ON_SimpleArray< ON_Curve * > &output_CurveArray, ON_SimpleArray< ON_3dPoint > &output_PointArray)

RHINO_SDK_FUNCTION bool	MakeRhinoContours (const CRhinoContourInput &input, ON_SimpleArray< ON_Polyline * > &output_PlineArray, ON_SimpleArray< ON_Curve * > &output_CurveArray, ON_SimpleArray< ON_3dPoint > &output_PointArray, double tolerance, CRhinoDoc *doc)

RHINO_SDK_FUNCTION bool	MeshVoronoiAreas (const ON_Mesh &mesh, ON_SimpleArray< double > &result, bool useMeshTopology=true)

	ON_DEPRECATED_MSG ("This function will be removed in Rhino Version 7. \n" "For assistance replacing this function post on discourse.mcneel.com/c/rhino-developer.") RHINO_SDK_FUNCTION bool RhinoBrepGet2dProjection(unsigned int rhino_doc_sn

RHINO_SDK_FUNCTION RhinoOptionPageButtons	operator& (RhinoOptionPageButtons a, RhinoOptionPageButtons b)

RHINO_SDK_FUNCTION RhinoWindowCreateOptions	operator& (RhinoWindowCreateOptions a, RhinoWindowCreateOptions b)

RHINO_SDK_FUNCTION RhinoOptionPageButtons &	operator&= (RhinoOptionPageButtons &a, RhinoOptionPageButtons b)

RHINO_SDK_FUNCTION RhinoWindowCreateOptions &	operator&= (RhinoWindowCreateOptions &a, RhinoWindowCreateOptions b)

RHINO_SDK_FUNCTION RhinoOptionPageButtons	operator\| (RhinoOptionPageButtons a, RhinoOptionPageButtons b)

RHINO_SDK_FUNCTION RhinoWindowCreateOptions	operator\| (RhinoWindowCreateOptions a, RhinoWindowCreateOptions b)

RHINO_SDK_FUNCTION RhinoOptionPageButtons &	operator\|= (RhinoOptionPageButtons &a, RhinoOptionPageButtons b)

RHINO_SDK_FUNCTION RhinoWindowCreateOptions &	operator\|= (RhinoWindowCreateOptions &a, RhinoWindowCreateOptions b)

RHINO_SDK_FUNCTION RhinoOptionPageButtons	operator~ (RhinoOptionPageButtons a)

RHINO_SDK_FUNCTION RhinoWindowCreateOptions	operator~ (RhinoWindowCreateOptions a)

RHINO_SDK_FUNCTION bool	RegisterDisplayPipeline (const ON_ClassId *, const ON_UUID &, const ON_wString &, bool=true, bool=false, bool=false)

const RHINO_SDK_FUNCTION ON_ClassId *	RegisterOpenGLEngine (const ON_ClassId *)

RHINO_SDK_FUNCTION bool	Rh1RailSweepSegmented (ON_SimpleArray< ON_Brep * > &output_surfaces, const ON_Curve pRailCurve, const ON_SimpleArray< const ON_Curve > shapes, ON_3dPoint start_point, ON_3dPoint end_point, int frame_type=0, ON_3dVector roadlike_normal=ON_3dVector::UnsetVector, bool bClosed=false, int blend_type=0, int miter_type=0, double tolerance=0.01, int rebuild_mode=0, int rebuild_points=0, double refit_tolerance=0.0)

RHINO_SDK_FUNCTION bool	RhCheckObjectSnapPoints (eRhSnapGeom sng, const CRhinoSnapContext &sc, CRhinoSnapEvent &se, const ON_Xform &xform)

RHINO_SDK_FUNCTION UUID	RhCreateWidget (CRhinoDoc &doc, CRhinoWidget pWidget, const CRhinoObjectAttributes pAttr=NULL)

RHINO_SDK_FUNCTION void	RhFindWidgetsAssociatedWithObject (const CRhinoObject &obj, ON_SimpleArray< CRhinoWidget * > &aWidgetsOut)

bool	RhFormatNumber (double x, const ON_3dmUnitsAndTolerances &input_units, const ON_3dmUnitsAndTolerances &output_units, ON_wString &string, bool bAppendUnitSystemName, bool bBracketFractions)
	Returns true if formatting worked without fallbacks - no invalid input, overruns, etc. More...

void	RhFormatNumber (double x, ON_wString &string, bool bAppendUnitSystemName, bool bAbbreviate)

RHINO_SDK_FUNCTION void	RhGetGripPoints_Box (ON_3dPointArray &aOut)

RHINO_SDK_FUNCTION void	RhGetGripPoints_Cylinder (ON_3dPointArray &aOut)

RHINO_SDK_FUNCTION void	RhGetGripPoints_Plane_UV (ON_3dPointArray &aOut)

RHINO_SDK_FUNCTION void	RhGetGripPoints_Plane_UVW (ON_3dPointArray &aOut)

RHINO_SDK_FUNCTION void	RhGetGripPoints_Sphere (ON_3dPointArray &aOut)

RHINO_SDK_FUNCTION bool	Rhino1RailSweep (ON_SimpleArray< ON_Brep * > &output_surfaces, const ON_Curve pRail, const ON_SimpleArray< const ON_Curve > shapes, bool bClosed=false, double tolerance=0.01)

RHINO_SDK_FUNCTION bool	Rhino1RailSweep (ON_SimpleArray< ON_Brep * > &output_surfaces, const ON_Curve pRailCurve, const ON_SimpleArray< const ON_Curve > shapes, ON_3dPoint start_point, ON_3dPoint end_point, int frame_type=0, ON_3dVector roadlike_normal=ON_3dVector::UnsetVector, bool bClosed=false, int blend_type=0, int miter_type=0, double tolerance=0.01, int rebuild_mode=0, int rebuild_points=0, double refit_tolerance=0.0)

RHINO_SDK_FUNCTION bool	Rhino1RailSweepSegmented (ON_SimpleArray< ON_Brep * > &output_surfaces, const ON_Curve pRail, const ON_SimpleArray< const ON_Curve > shapes, bool bClosed=false, double tolerance=0.01)

RHINO_SDK_FUNCTION bool	Rhino2RailSweep (ON_SimpleArray< ON_Brep * > &output_surfaces, const ON_Curve pRail[2], const ON_SimpleArray< const ON_Curve > shapes, bool bClosed=false, double tolerance=0.01)

RHINO_SDK_FUNCTION bool	Rhino2RailSweep (ON_SimpleArray< ON_Brep * > &output_surfaces, const ON_Curve pRail[2], const ON_SimpleArray< const ON_Curve > shapes, int rebuild_mode, int rebuild_points, double refit_tolerance, bool bPreserveHeight, bool bClosed=false, double tolerance=0.01)

RHINO_SDK_FUNCTION bool	Rhino2RailSweep (ON_SimpleArray< ON_Brep * > &output_surfaces, const ON_Curve pRail[2], const ON_SimpleArray< const ON_Curve > shapes, ON_3dPoint start_point, ON_3dPoint end_point, bool bClosed=false, double tolerance=0.01, int rebuild_mode=0, int rebuild_points=0, double refit_tolerance=0.0, bool bPreserveHeight=false)

RHINO_SDK_FUNCTION bool	Rhino2RailSweepInParts (ON_SimpleArray< ON_Brep * > &output_surfaces, const ON_Curve pRail[2], const ON_SimpleArray< const ON_Curve > &shapes, bool bClosed=false, double tolerance=0.01)

RHINO_SDK_FUNCTION bool	Rhino2RailSweepOld (ON_SimpleArray< ON_Brep * > &output_surfaces, const ON_Curve pRail[2], const ON_SimpleArray< const ON_Curve > shapes, ON_3dPoint start_point, ON_3dPoint end_point, bool bClosed=false, double tolerance=0.01, int rebuild_mode=0, int rebuild_points=0, double refit_tolerance=0.0, bool bPreserveHeight=false)

RHINO_SDK_FUNCTION ON_Brep *	Rhino3JoinBreps (const ON_SimpleArray< ON_Brep * > &Breps, ON_ClassArray< ON_SimpleArray< int > > &JoinData, double tolerance=0.0)

RHINO_SDK_FUNCTION int	Rhino_dup_cmp_curve (const ON_Curve crva, const ON_Curve crvb)

RHINO_SDK_FUNCTION int	Rhino_dup_cmp_surface (const ON_Surface srfa, const ON_Surface srfb)

RHINO_SDK_FUNCTION double	Rhino_TestMathFunction (int function_index, double x, double y)

RHINO_SDK_FUNCTION void	RhinoAcadNameString (char *name, int max_length=31, bool bAllowSpace=false)

const RHINO_SDK_FUNCTION ON_Plane &	RhinoActiveCPlane ()

RHINO_SDK_FUNCTION ON_Mesh *	RhinoAddShutLinesToMesh (const ON_Mesh &originalMesh, const RhShutLiningArgs &args, ON_Terminator *pCancelHandler=0)

RHINO_SDK_FUNCTION int	RhinoAlignMeshVertices (ON_SimpleArray< ON_Mesh * > &MeshArray, const ON_ClassArray< ON_SimpleArray< bool >> &VertexFlags, double distance)

RHINO_SDK_FUNCTION int	RhinoAlignVertices (ON_SimpleArray< const ON_Geometry * > &meshesSubdsAndPointclouds, ON_SimpleArray< ON_Geometry * > &results, double distance, bool onlyNaked, const ON_SimpleArray< const ON_SimpleArray< bool > * > *vertexFlags, bool averagePoints)

RHINO_SDK_FUNCTION int	RhinoAlignVerticesInPlace (ON_SimpleArray< ON_Geometry * > &meshesSubdsAndPointclouds, double distance, bool onlyNaked, const ON_SimpleArray< const ON_SimpleArray< bool > * > *vertexFlags, bool averagePoints)

RHINO_SDK_FUNCTION class CRhinoApp &	RhinoApp ()
	returns theApp More...

RHINO_SDK_FUNCTION bool	RhinoApplyTopologyLaplacianToScalar (const ON_Mesh &mesh, ON_SimpleArray< double > &scalarValues)

const RHINO_SDK_FUNCTION char *	RhinoAppVersionBuildDescription ()

RHINO_SDK_FUNCTION unsigned int	RhinoAppVersionGetQuartet (unsigned int rhino_app_version_quartet[4])

const RHINO_SDK_FUNCTION char *	RhinoAppVersionQuartetAsString ()

const RHINO_SDK_FUNCTION wchar_t *	RhinoAppVersionQuartetAsWideString ()

RHINO_SDK_FUNCTION ON_Curve *	RhinoArcLineArcBlend (ON_3dPoint P0, ON_3dVector D0, ON_3dPoint P1, ON_3dVector D1, double radius)

RHINO_SDK_FUNCTION BOOL32	RhinoArePointsCoplanar (ON_SimpleArray< ON_3dPoint > &points, ON_3dPoint pPoint=nullptr, ON_3dVector pNormal=nullptr, double tolerance=ON_ZERO_TOLERANCE)

RHINO_SDK_FUNCTION BOOL32	RhinoArePointsCoplanar (ON_SimpleArray< ON_4dPoint > &points, ON_3dPoint pPoint=nullptr, ON_3dVector pNormal=nullptr, double tolerance=ON_ZERO_TOLERANCE)

RHINO_SDK_FUNCTION bool	RhinoAutoAdjustTargetDepth (CRhinoViewport pViewport, const ON_2iPoint pMousePoint=nullptr, const double pFocusSize=nullptr, const double pWeight=nullptr)

RHINO_SDK_FUNCTION BOOL32	RhinoBackupFile (const wchar_t *filename, ON_wString &backup_filename)

RHINO_SDK_FUNCTION bool	RhinoBooleanDifference (const ON_SimpleArray< const ON_Brep * > &InBreps0, const ON_SimpleArray< const ON_Brep * > &InBreps1, double tolerance, bool bResult, ON_SimpleArray< ON_Brep > &OutBreps, ON_SimpleArray< int > &InputIndexForOutput, bool bManifoldOnly=true, bool *bRaisedTol=nullptr)

RHINO_SDK_FUNCTION bool	RhinoBooleanDifference (const ON_SimpleArray< const ON_Brep * > &InBreps0, const ON_SimpleArray< const ON_Brep * > &InBreps1, double tolerance, bool bResult, ON_SimpleArray< ON_Brep > &OutBreps, ON_SimpleArray< ON_3dPoint > &NakedEdgePoints, ON_SimpleArray< ON_3dPoint > &BadIntersectionPoints, ON_SimpleArray< ON_3dPoint > &NonmanifoldEdgePoints, ON_SimpleArray< int > &InputIndexForOutput, bool bManifoldOnly=true, bool *bRaisedTol=nullptr)

RHINO_SDK_FUNCTION bool	RhinoBooleanIntersection (const ON_SimpleArray< const ON_Brep * > &InBreps0, const ON_SimpleArray< const ON_Brep * > &InBreps1, double tolerance, bool bResult, ON_SimpleArray< ON_Brep > &OutBreps, bool bManifoldOnly=true, bool *bRaisedTol=nullptr)

RHINO_SDK_FUNCTION bool	RhinoBooleanIntersection (const ON_SimpleArray< const ON_Brep * > &InBreps0, const ON_SimpleArray< const ON_Brep * > &InBreps1, double tolerance, bool bResult, ON_SimpleArray< ON_Brep > &OutBreps, ON_SimpleArray< ON_3dPoint > &NakedEdgePoints, ON_SimpleArray< ON_3dPoint > &BadIntersectionPoints, ON_SimpleArray< ON_3dPoint > &NonmanifoldEdgePoints, bool bManifoldOnly=true, bool *bRaisedTol=nullptr)

RHINO_SDK_FUNCTION bool	RhinoBooleanSplit (const ON_SimpleArray< const ON_Brep * > &InBreps0, const ON_SimpleArray< const ON_Brep * > &InBreps1, double tolerance, ON_SimpleArray< ON_Brep * > &OutBreps)

RHINO_SDK_FUNCTION bool	RhinoBooleanUnion (const ON_SimpleArray< const ON_Brep * > &InBreps, double tolerance, bool bResult, ON_SimpleArray< ON_Brep > &OutBreps, bool bManifoldOnly=true, bool *bRaisedTol=nullptr)

RHINO_SDK_FUNCTION bool	RhinoBooleanUnion (const ON_SimpleArray< const ON_Brep * > &InBreps, double tolerance, bool bResult, ON_SimpleArray< ON_Brep > &OutBreps, ON_SimpleArray< ON_3dPoint > &NakedEdgePoints, ON_SimpleArray< ON_3dPoint > &BadIntersectionPoints, ON_SimpleArray< ON_3dPoint > &NonmanifoldEdgePoints, bool bManifoldOnly=true, bool *bRaisedTol=nullptr)

RHINO_SDK_FUNCTION ON_Brep *	RhinoBrepBaseballSphere (const ON_3dPoint &center, double radius, double tolerance, ON_Brep *pBrep=nullptr)

RHINO_SDK_FUNCTION ON_Brep *	RhinoBrepCapPlanarHoles (const ON_Brep *pInputBrep, const double &tol)

RHINO_SDK_FUNCTION ON_Brep *	RhinoBrepCapPlanarHoles (const ON_Brep *pInputBrep, const double &tol, const bool &bDisplayErrors)

RHINO_SDK_FUNCTION ON_Brep *	RhinoBrepCapPlanarHolesOld (const ON_Brep *pInputBrep, const double &tol, const bool &bDisplayErrors)

RHINO_SDK_FUNCTION bool	RhinoBrepClosestPoint (const ON_Brep &brep, ON_3dPoint pt, ON_COMPONENT_INDEX ci, double s, double t, ON_3dPoint brep_point=nullptr, double maximum_distance=0.0)

RHINO_SDK_FUNCTION bool	RhinoBrepCombineMarkedVerticesAndEdges (ON_Brep &B, double tol, bool bCompact=true)

RHINO_SDK_FUNCTION bool	RhinoBrepFaceClosestPoint (const ON_BrepFace &face, ON_3dPoint P, double s, double t, double maximum_distance=0.0, const ON_Interval sdomain=nullptr, const ON_Interval tdomain=nullptr)

RHINO_SDK_FUNCTION ON_Brep *	RhinoBrepFaceRemoveInnerLoops (const ON_Brep &brep, ON_COMPONENT_INDEX face_ci, double tolerance)

RHINO_SDK_FUNCTION ON_Brep *	RhinoBrepRemoveAllInnerLoops (const ON_Brep &brep, double tolerance)

RHINO_SDK_FUNCTION ON_Brep *	RhinoBrepRemoveInnerLoops (const ON_Brep &brep, ON_SimpleArray< ON_COMPONENT_INDEX > loops_ci, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoBrepShrinkSurfaceToEdge (ON_Brep &brep, int face_index)

RHINO_SDK_FUNCTION bool	RhinoBrepSplit (const ON_Brep &brep, const ON_Brep &splitter, double tolerance, ON_SimpleArray< ON_Brep * > &pieces, bool *bRaisedTol=nullptr)

RHINO_SDK_FUNCTION int	RhinoBrepSplit (const ON_Brep &brep, const ON_SimpleArray< const ON_Brep * > &cutters, double tolerance, ON_SimpleArray< ON_Brep * > &pieces)

RHINO_SDK_FUNCTION int	RhinoBrepSplit (const ON_Brep &brep, const ON_SimpleArray< const ON_Curve * > &cutters, double tolerance, ON_SimpleArray< ON_Brep * > &pieces)

RHINO_SDK_FUNCTION int	RhinoBrepSplit (const ON_Brep &brep, const ON_SimpleArray< const ON_Geometry * > &cutters, ON_3dVector CPlaneNormal, bool PlanView, double tolerance, ON_SimpleArray< ON_Brep * > &pieces)

RHINO_SDK_FUNCTION int	RhinoBrepTrim (const ON_Brep &B, const ON_Brep &Cutter, double tol, ON_SimpleArray< ON_Brep * > &Trim, ON_ClassArray< ON_SimpleArray< int > > fmap=nullptr, ON_ClassArray< ON_SimpleArray< int > > emap=nullptr)

RHINO_SDK_FUNCTION int	RhinoBrepTrim (const ON_Brep &B, const ON_Plane &Cutter, double tol, ON_SimpleArray< ON_Brep * > &Trim, ON_ClassArray< ON_SimpleArray< int > > fmap=nullptr, ON_ClassArray< ON_SimpleArray< int > > emap=nullptr)

RHINO_SDK_FUNCTION double	RhinoCalcTriangleArea (ON_3dPoint A, ON_3dPoint B, ON_3dPoint C)

RHINO_SDK_FUNCTION double	RhinoCalculateAspectRatio (ON_3dPoint A, ON_3dPoint B, ON_3dPoint C, ON_3dPoint D)

RHINO_SDK_FUNCTION bool	RhinoCaptureObject (CRhinoMorphControl control_object, CRhinoObject captive_object)

RHINO_SDK_FUNCTION ON_Brep *	RhinoChangeSeam (const ON_BrepFace &Face, int di, double t, double tol)

RHINO_SDK_FUNCTION bool	RhinoCheckMesh (const ON_Mesh *pMesh, ON_TextLog &text_log, RhinoCheckMeshOutput &output)

RHINO_SDK_FUNCTION bool	RhinoCheckMesh (const ON_SimpleArray< const CRhinoMeshObject * > &pMeshObjArray, ON_TextLog &text_log, RhinoCheckMeshOutput &output)

RHINO_SDK_FUNCTION bool	RhinoCheckMesh (const ON_SimpleArray< const ON_Mesh * > &pMeshArray, ON_TextLog &text_log, RhinoCheckMeshOutput &output)

RHINO_SDK_FUNCTION ON_Curve *	RhinoCleanUpPolyCurve (const ON_PolyCurve &PC)

RHINO_SDK_FUNCTION bool	RhinoCollapseMeshEdge (ON_Mesh &mesh, int edgeIndex)

RHINO_SDK_FUNCTION int	RhinoCollapseMeshEdges (ON_Mesh &Mesh, bool bGreaterThan, double edgeLength)

RHINO_SDK_FUNCTION bool	RhinoCollapseMeshFace (ON_Mesh &mesh, int faceIndex)

RHINO_SDK_FUNCTION int	RhinoCollapseMeshFacesByArea (ON_Mesh &Mesh, double lessThanArea, double greaterThanArea)

RHINO_SDK_FUNCTION int	RhinoCollapseMeshFacesByAspectRatio (ON_Mesh &Mesh, double aspectRatio)

RHINO_SDK_FUNCTION bool	RhinoCollapseMeshVertex (ON_Mesh &mesh, int topVertexIndex1, int topVertexIndex2)

RHINO_SDK_FUNCTION BOOL32	RhinoColorDialog (HWND hwndParent, ON_Color &color, bool include_button_colors=false, const wchar_t *dialog_title=nullptr)

RHINO_SDK_FUNCTION BOOL32	RhinoColorDialogEx (HWND hwndParent, ON_Color &color, bool include_button_colors=false, const wchar_t dialog_title=nullptr, bool use_alpha=false, HWND hwndMessage=nullptr, const ON_ClassArray< CRhinoNamedColor > pCustomNamedColors=nullptr)

RHINO_SDK_FUNCTION int	RhinoCompareCCXEvent (const CRhinoCCXEvent , const CRhinoCCXEvent )

RHINO_SDK_FUNCTION bool	RhinoCompareGeometry (const CRhinoObject a, const CRhinoObject b)

RHINO_SDK_FUNCTION bool	RhinoCompareGeometry (const ON_Geometry a, const ON_Geometry b)

RHINO_SDK_FUNCTION bool	RhinoComputePrincipalMeshCurvatures (ON_Mesh &mesh, bool useLaplacian=true)

RHINO_SDK_FUNCTION ON_wString	RhinoComputerSerialNumber ()

RHINO_SDK_FUNCTION CRhinoMorphControl *	RhinoControlObject (const CRhinoObject *captive_object)

RHINO_SDK_FUNCTION ON_PolyCurve *	RhinoConvertCurveToArcs (const ON_Curve *pCurve, const double dTol, const double dAngleTol, const double dMinLength, const double dMaxLength)

RHINO_SDK_FUNCTION ON_PolyCurve *	RhinoConvertCurveToLines (const ON_Curve *pCurve, const double dTol, const double dAngleTol, const double dMinLength, const double dMaxLength)

RHINO_SDK_FUNCTION bool	RhinoConvertCurveToPolyline (const ON_Curve &curve, int main_seg_count, int sub_seg_count, double max_ang_radians, double max_chr, double max_aspect, double tolerance, double min_edge_length, double max_edge_length, ON_PolylineCurve &polyline, bool bKeepStartPoint=true, ON_Interval *curve_domain=nullptr)

RHINO_SDK_FUNCTION int	RhinoCopyAnalysisModes (const CRhinoObject source_object, CRhinoObject destination_object)

RHINO_SDK_FUNCTION int	RhinoCopyAnalysisModes (const CRhinoObjectVisualAnalysisMode analysis_mode_list, CRhinoObject destination_object)

RHINO_SDK_FUNCTION ON_Brep *	RhinoCreate1FaceBrepFromPoints (const ON_3dPoint corners[4], int count, double tolerance=0)

RHINO_SDK_FUNCTION CRhinoDib *	RhinoCreateAnaglyph (const CRhinoDib &LeftEye, const CRhinoDib &RightEye, const int nType=0)

RHINO_SDK_FUNCTION ON_PolyCurve *	RhinoCreateArcBlend (const ON_3dPoint &startpt, const ON_3dVector &startdir, const ON_3dPoint &endpt, const ON_3dVector &enddir, const double controlpolygonlengthratio=1.0, ON_PolyCurve *curve_out=nullptr)

RHINO_SDK_FUNCTION ON_Brep *	RhinoCreateEdgeSrf (int curve_count, const ON_Curve **pCrvs)

RHINO_SDK_FUNCTION CRhinoTextDot *	RhinoCreateErrorMarker (ON_3dPoint Location, const wchar_t msg, ON_3dmObjectAttributes attr, unsigned int RhinoDocSN)

RHINO_SDK_FUNCTION bool	RhinoCreateG2ChordalQuinticFilletSrf (const ON_BrepFace &FaceA, const ON_2dPoint &uvA, const ON_BrepFace &FaceB, const ON_2dPoint &uvB, double radius, double tolerance, ON_SimpleArray< ON_Brep * > &resultsA, ON_SimpleArray< ON_Brep * > &resultsB, int rail_degree, bool bTrim, bool bExtend, ON_SimpleArray< ON_Brep * > &Fillets)

RHINO_SDK_FUNCTION bool	RhinoCreateHatches (CArgsRhinoHatch &args, double tolerance, ON_SimpleArray< ON_Hatch * > &results)

RHINO_SDK_FUNCTION bool	RhinoCreateHatches (CArgsRhinoHatch &args, ON_SimpleArray< ON_Hatch * > &results)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoCreateHSpline (const ON_3dPoint Pts, int PntCount, const ON_3dVector StartTan, const ON_3dVector *EndTan)

RHINO_SDK_FUNCTION bool	RhinoCreateNonRationalCubicArcsFilletSrf (const ON_BrepFace &FaceA, const ON_2dPoint &uvA, const ON_BrepFace &FaceB, const ON_2dPoint &uvB, double radius, double tolerance, ON_SimpleArray< ON_Brep * > &resultsA, ON_SimpleArray< ON_Brep * > &resultsB, int rail_degree, bool bTrim, bool bExtend, ON_SimpleArray< ON_Brep * > &Fillets)
	Arc approximation. More...

RHINO_SDK_FUNCTION bool	RhinoCreateNonRationalCubicFilletSrf (const ON_BrepFace &FaceA, const ON_2dPoint &uvA, const ON_BrepFace &FaceB, const ON_2dPoint &uvB, double radius, double tolerance, ON_SimpleArray< ON_Brep * > &resultsA, ON_SimpleArray< ON_Brep * > &resultsB, int rail_degree, double TanSlider, bool bTrim, bool bExtend, ON_SimpleArray< ON_Brep * > &Fillets)

RHINO_SDK_FUNCTION bool	RhinoCreateNonRationalQuarticArcsFilletSrf (const ON_BrepFace &FaceA, const ON_2dPoint &uvA, const ON_BrepFace &FaceB, const ON_2dPoint &uvB, double radius, double tolerance, ON_SimpleArray< ON_Brep * > &resultsA, ON_SimpleArray< ON_Brep * > &resultsB, int rail_degree, bool bTrim, bool bExtend, ON_SimpleArray< ON_Brep * > &Fillets)
	Arc approximation. More...

RHINO_SDK_FUNCTION bool	RhinoCreateNonRationalQuarticFilletSrf (const ON_BrepFace &FaceA, const ON_2dPoint &uvA, const ON_BrepFace &FaceB, const ON_2dPoint &uvB, double radius, double tolerance, ON_SimpleArray< ON_Brep * > &resultsA, ON_SimpleArray< ON_Brep * > &resultsB, int rail_degree, double TanSlider, double InnerSlider, bool bTrim, bool bExtend, ON_SimpleArray< ON_Brep * > &Fillets)

RHINO_SDK_FUNCTION bool	RhinoCreateNonRationalQuinticArcsFilletSrf (const ON_BrepFace &FaceA, const ON_2dPoint &uvA, const ON_BrepFace &FaceB, const ON_2dPoint &uvB, double radius, double tolerance, ON_SimpleArray< ON_Brep * > &resultsA, ON_SimpleArray< ON_Brep * > &resultsB, int rail_degree, bool bTrim, bool bExtend, ON_SimpleArray< ON_Brep * > &Fillets)
	Arc approximation. More...

RHINO_SDK_FUNCTION bool	RhinoCreateNonRationalQuinticFilletSrf (const ON_BrepFace &FaceA, const ON_2dPoint &uvA, const ON_BrepFace &FaceB, const ON_2dPoint &uvB, double radius, double tolerance, ON_SimpleArray< ON_Brep * > &resultsA, ON_SimpleArray< ON_Brep * > &resultsB, int rail_degree, double TanSlider, double InnerSlider, bool bTrim, bool bExtend, ON_SimpleArray< ON_Brep * > &Fillets)

RHINO_SDK_FUNCTION bool	RhinoCreateParabolaFromFocus (const ON_3dPoint &focus, const ON_3dPoint &start, const ON_3dPoint &end, ON_BezierCurve &parabola_out)

RHINO_SDK_FUNCTION bool	RhinoCreateParabolaFromPoints (const ON_3dPoint &P0, const ON_3dPoint &P1, const ON_3dPoint &P2, ON_NurbsCurve &curve_out)

RHINO_SDK_FUNCTION bool	RhinoCreateParabolaFromVertex (const ON_3dPoint &vertex, const ON_3dPoint &start, const ON_3dPoint &end, ON_BezierCurve &parabola_out)

const RHINO_SDK_FUNCTION CRhinoObject *	RhinoCreatePictureFrame (class CRhinoDoc &doc, const ON_Plane &plane, const ON_wString &texturepath, bool makemesh=false, bool usealphaforobjecttransparency=false, double width=0.0, double height=0.0, bool selfillumination=true, bool embedbitmap=false, bool addtodoc=true)

const RHINO_SDK_FUNCTION CRhinoObject *	RhinoCreatePictureFrame (class CRhinoDoc &doc, const ON_Plane &plane, const ON_wString &texturepath, bool makemesh=false, double width=0.0, double height=0.0, bool selfillumination=true, bool embedbitmap=false, bool addtodoc=true)

const RHINO_SDK_FUNCTION CRhinoObject *	RhinoCreatePictureFrame (class CRhinoDoc &doc, const ON_Plane &plane, const ON_wString &texturepath, double width=0.0, double height=0.0, bool selfillumination=true, bool embedbitmap=false, bool addtodoc=true)

RHINO_SDK_FUNCTION int	RhinoCreatePointCloudContours (const ON_PointCloud pPointCloud, ON_3dPoint start_point, ON_3dPoint end_point, double interval, double tolerance, double max_distance, double min_distance, bool bOpenCurves, bool bCreateSpline, bool bCreatePolyline, double fit_tolerance, ON_SimpleArray< ON_Curve > &out_curves)

RHINO_SDK_FUNCTION int	RhinoCreatePointCloudSection (const ON_PointCloud pPointCloud, ON_Plane plane, double tolerance, double max_distance, double min_distance, bool bOpenCurves, bool bCreateSpline, bool bCreatePolyline, double fit_tolerance, ON_SimpleArray< ON_Curve > &out_curves)

RHINO_SDK_FUNCTION bool	RhinoCreateRationalArcsFilletSrf (const ON_BrepFace &FaceA, const ON_2dPoint &uvA, const ON_BrepFace &FaceB, const ON_2dPoint &uvB, double radius, double tolerance, ON_SimpleArray< ON_Brep * > &resultsA, ON_SimpleArray< ON_Brep * > &resultsB, int rail_degree, bool bTrim, bool bExtend, ON_SimpleArray< ON_Brep * > &Fillets)

RHINO_SDK_FUNCTION int	RhinoCreateSolid (const ON_SimpleArray< const ON_Brep * > &InBreps, ON_SimpleArray< ON_Brep * > &OutBreps, double tolerance)

RHINO_SDK_FUNCTION int	RhinoCreateSubPictureMaterialIndex (CRhinoDoc &doc, const CRhinoObject original_picture_object, const ON_Brep shrunk_picture_brep)

RHINO_SDK_FUNCTION ON_NurbsSurface *	RhinoCreateSurfaceFromCorners (const ON_3dPoint &a, const ON_3dPoint &b, ON_3dPoint &c, ON_3dPoint &d, double dtol=0)

RHINO_SDK_FUNCTION bool	RhinoCreateTaperedExtrude (const ON_Curve input_curve, double distance, ON_3dVector direction, ON_3dPoint base, double draft_angle, int cornertype, double tol, double ang_tol, ON_SimpleArray< ON_Brep > &output_breps)

RHINO_SDK_FUNCTION bool	RhinoCreateTextObjectGeometry (const ON_Annotation pAnno, const ON_Viewport vp, const ON_DimStyle dimstyle, double text_scale, bool close_contours, double join_tol, double small_caps_scale, ON::object_type variety, double height, double spacing, ON_SimpleArray< ON_Object > &output)

RHINO_SDK_FUNCTION bool	RhinoCreateTextObjectGeometryByLetter (const ON_Annotation pAnno, const ON_Viewport vp, const ON_DimStyle dimstyle, double text_scale, bool close_contours, double join_tol, double small_caps_scale, ON::object_type variety, double height, double spacing, ON_ClassArray< ON_SimpleArray< ON_Object >> &letter_output)

RHINO_SDK_FUNCTION bool	RhinoCullControlPolygon ()

RHINO_SDK_FUNCTION ON_Mesh *	RhinoCullZeroAreaMeshFaces (const ON_Mesh &MeshIn, int &removed_faces_count, int &fixed_faces_count, ON_Mesh *pMeshOut=0)

RHINO_SDK_FUNCTION bool	RhinoCurve2View (const ON_Curve &C0, const ON_Curve &C1, ON_3dVector D0, ON_3dVector D1, ON_SimpleArray< ON_Curve * > &output_curves, double tol, double angle_tol)

RHINO_SDK_FUNCTION bool	RhinoCurveBoolean (const ON_SimpleArray< const ON_Curve * > &InCurves, const ON_Plane &plane, const ON_SimpleArray< ON_3dPoint > &InPoints, bool bAllRegions, bool bCombineRegions, double tolerance, ON_SimpleArray< ON_Curve * > &PlanarCurves, ON_ClassArray< ON_CurveRegion > &OutRegions)

RHINO_SDK_FUNCTION bool	RhinoCurveBoolean (const ON_SimpleArray< const ON_Curve * > &InCurves, const ON_Plane &plane, const ON_SimpleArray< ON_3dPoint > &InPoints, bool bAllRegions, bool bCombineRegions, double tolerance, ON_SimpleArray< ON_Curve * > &PlanarCurves, ON_ClassArray< ON_CurveRegion > &OutRegions, ON_SimpleArray< int > &PointRegionIds)

RHINO_SDK_FUNCTION int	RhinoCurveBooleanDifference (const ON_Curve crvA, const ON_Curve crvB, double tolerance, ON_SimpleArray< ON_Curve * > &OutCurves)

RHINO_SDK_FUNCTION int	RhinoCurveBooleanDifference (const ON_Curve crvA, const ON_SimpleArray< const ON_Curve > &crvB, double cbtol, ON_SimpleArray< ON_Curve * > &OutCurves)

RHINO_SDK_FUNCTION int	RhinoCurveBooleanIntersection (const ON_Curve crvA, const ON_Curve crvB, double tolerance, ON_SimpleArray< ON_Curve * > &OutCurves)

RHINO_SDK_FUNCTION int	RhinoCurveBooleanUnion (const ON_SimpleArray< const ON_Curve * > &InCurves, double tolerance, ON_SimpleArray< ON_Curve * > &OutCurves)

RHINO_SDK_FUNCTION bool	RhinoCurveBrepIntersect (const ON_Curve &crv, const ON_Brep &brep, double tol, ON_SimpleArray< ON_Curve * > &curves, ON_3dPointArray &points)

RHINO_SDK_FUNCTION int	RhinoCurveCurveIntersect (const ON_Curve &curveA, const ON_Curve &curveB, double tolerance, ON_SimpleArray< CRhinoCCXEvent > &x, const ON_Interval curveA_domain=NULL, const ON_Interval curveB_domain=NULL)

RHINO_SDK_FUNCTION int	RhinoCurveExtremeParameters (const ON_Curve &curve, const ON_3dVector &dir, ON_SimpleArray< double > &out_parameters)

RHINO_SDK_FUNCTION bool	RhinoCurveFaceIntersect (const ON_Curve &crv, const ON_BrepFace &face, double tol, ON_SimpleArray< ON_Curve * > &curves, ON_3dPointArray &points)

RHINO_SDK_FUNCTION bool	RhinoCurveInflectionPoints (const ON_Curve &curve, ON_SimpleArray< ON_3dPoint > &points)

RHINO_SDK_FUNCTION bool	RhinoCurveInflectionPoints (const ON_Curve &curve, ON_SimpleArray< ON_3dPoint > &points, ON_SimpleArray< double > &parameters)

RHINO_SDK_FUNCTION bool	RhinoCurveMaxCurvaturePoints (const ON_Curve &curve, ON_SimpleArray< ON_3dPoint > &points)

RHINO_SDK_FUNCTION bool	RhinoCurveMaxCurvaturePoints (const ON_Curve &curve, ON_SimpleArray< ON_3dPoint > &points, ON_SimpleArray< double > &parameters)

RHINO_SDK_FUNCTION bool	RhinoCurveOnSurfacePoints (const ON_Surface &Srf, const ON_SimpleArray< ON_2dPoint > &Fixed2, const ON_SimpleArray< double > &Dist, const ON_ClassArray< ON_SimpleArray< ON_2dPoint > > &Geo, double tol, bool Periodic, int init_count, int nlevels, ON_SimpleArray< ON_2dPoint > &out, ON_SimpleArray< double > &t, ON_SimpleArray< int > *pIndex)

RHINO_SDK_FUNCTION bool	RhinoCurveOnSurfacePoints (const ON_Surface &Srf, const ON_SimpleArray< ON_2dPoint > &Fixed2, double tol, bool Periodic, int init_count, int nlevels, ON_SimpleArray< ON_2dPoint > &out, ON_SimpleArray< double > &t, ON_SimpleArray< int > *pIndex=nullptr)

RHINO_SDK_FUNCTION bool	RhinoCurveOnSurfaceSolver (const ON_Surface &Srf, ON_SimpleArray< ON_2dPoint > &out, ON_SimpleArray< int > &Index, ON_SimpleArray< double > &t, ON_SimpleArray< double > &tol, bool Periodic, int Num_Levels)

RHINO_SDK_FUNCTION int	RhinoCurveSelfIntersect (const ON_Curve &curve, double tolerance, ON_SimpleArray< CRhinoCCXEvent > &x, const ON_Interval curveA_domain=NULL, const ON_Interval curveB_domain=NULL)

RHINO_SDK_FUNCTION bool	RhinoCurveSplit (const ON_Curve &curve, const ON_Brep &splitter, double tolerance, double angtolrads, ON_SimpleArray< ON_Curve * > &pieces)

RHINO_SDK_FUNCTION int	RhinoCurveSurfaceIntersect (const ON_Curve &curve, const ON_Surface &surface, double distance_tolerance, double angle_tolerance_radians, ON_SimpleArray< CRhinoCSXEvent > &x, const ON_Interval curve_domain=NULL, const ON_Interval surface_u_domain=NULL, const ON_Interval *surface_v_domain=NULL)

RHINO_SDK_FUNCTION void	RhinoCutUpSurface (const ON_Surface &srf, BOOL32 bFlip, const ON_SimpleArray< ON_Curve * > &EdgeCurves, double ftol, double ctol, ON_SimpleArray< ON_Brep * > &Breps, double *max_tol_used=nullptr)

RHINO_SDK_FUNCTION ON_UUID	RhinoDefaultRendererId (void)

RHINO_SDK_FUNCTION wchar_t	RhinoDegreesSymbol ()

RHINO_SDK_FUNCTION unsigned int	RhinoDestroyDisplayMeshes (ON::mesh_type mesh_type, CRhinoObjectIterator &it, bool *bRedrawNeeded)

RHINO_SDK_FUNCTION bool	RhinoDihedralMeanMeshCurvature (const ON_Mesh &MeshIn, ON_SimpleArray< double > &result)

RHINO_SDK_FUNCTION bool	RhinoDihedralMeanMeshCurvatureIncludingNaked (const ON_Mesh &MeshIn, ON_SimpleArray< double > &result)

RHINO_SDK_FUNCTION void	RhinoDisableContinuousMainLoop ()

RHINO_SDK_FUNCTION bool	RhinoDiscreteGaussianMeshCurvature (const ON_Mesh &MeshIn, ON_SimpleArray< double > &result, double *globalAngleDefect=nullptr)

RHINO_SDK_FUNCTION bool	RhinoDiscreteGaussianMeshCurvatureIncludingNaked (const ON_Mesh &MeshIn, ON_SimpleArray< double > &result)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoDisplaceMesh (const ON_Mesh &originalMesh, const RhDisplacement &displacement, const RhDisplacementArgs &args, ON_wString &problemString, ON_Terminator pCancelHandler=0, ON_ProgressReporter pProgressReporter=0)

RHINO_SDK_FUNCTION bool	RhinoDivideCurve (const ON_Curve &curve, double seg_count, double seg_length, bool bReverse, bool bIncludeEnd, ON_SimpleArray< ON_3dPoint > curve_P, ON_SimpleArray< double > curve_t)

RHINO_SDK_FUNCTION int	RhinoDivideCurveEquidistant (const ON_Curve *curve, double distance, ON_SimpleArray< ON_3dPoint > &points)

RHINO_SDK_FUNCTION int	RhinoDivideCurveEquidistant (const ON_Curve curve, double distance, ON_SimpleArray< ON_3dPoint > &points, ON_SimpleArray< double > parameters)

RHINO_SDK_FUNCTION bool	RhinoDoCurveDirectionsMatch (const ON_Curve c0, const ON_Curve c1)

RHINO_SDK_FUNCTION bool	RhinoDollyExtents (class CRhinoObjectIterator &it, const CRhinoViewport &rhino_vp, double border, ON_Viewport &zoomed_vp, const ON_SimpleArray< ON_3dPoint > extra_points=nullptr, ON_BoundingBox camcoord_box=nullptr)

RHINO_SDK_FUNCTION bool	RhinoDollyExtents (class CRhinoView *view, bool active_viewport=true)

RHINO_SDK_FUNCTION bool	RhinoDollyExtents (class CRhinoViewport &viewport, double border)

RHINO_SDK_FUNCTION bool	RhinoDollyExtents (const ON_Viewport &current_vp, ON_BoundingBox camcoord_bbox, ON_Viewport &zoomed_vp)

RHINO_SDK_FUNCTION bool	RhinoDollyExtentsSelected (class CRhinoView *view, bool active_viewport=true)

RHINO_SDK_FUNCTION bool	RhinoDollyExtentsSelected (class CRhinoViewport &viewport, double border)

RHINO_SDK_FUNCTION int	RhinoDuplicateCurveSegments (const ON_Curve curve, ON_SimpleArray< ON_Curve > &OutCurves)

RHINO_SDK_FUNCTION int	RhinoDuplicateLayers (CRhinoDoc &doc, const ON_SimpleArray< int > &in_layers, bool bDuplicateObjects, bool bDuplicateSublayers, ON_SimpleArray< int > &out_layers)

RHINO_SDK_FUNCTION ON_PolylineCurve *	RhinoDupMeshBorder (const ON_MeshComponentRef *pMeshEdgeRef)

RHINO_SDK_FUNCTION void	RhinoDynamicViewChange (CRhinoView *view)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoEdgeSoftenMesh (const ON_Mesh &originalMesh, const RhEdgeSofteningArgs &args, ON_Terminator *pCancelHandler=0)

RHINO_SDK_FUNCTION bool	RhinoEnableContinuousMainLoop ()

RHINO_SDK_FUNCTION bool	RhinoExplodeDimension (const ON_Dimension dimension, const ON_DimStyle dimstyle, ON_SimpleArray< ON_Curve * > &out_curves, ON_SimpleArray< ON_Geometry * > &out_objects)

RHINO_SDK_FUNCTION bool	RhinoExplodeLeader (const ON_Leader leader, const ON_DimStyle dimstyle, ON_SimpleArray< ON_Curve * > &out_curves, ON_SimpleArray< ON_Geometry * > &out_objects)

RHINO_SDK_FUNCTION int	RhinoExplodeMesh (const ON_Mesh mesh_in, ON_SimpleArray< ON_Mesh > &meshlist_out)

RHINO_SDK_FUNCTION bool	RhinoExtendBrepFacesToConnect (const ON_BrepFace pFace0, int edgeIndex0, const ON_BrepFace pFace1, int edgeIndex1, double tol, double angleTol, ON_Brep &outBrep0, ON_Brep &outBrep1)

RHINO_SDK_FUNCTION bool	RhinoExtendBrepFacesToConnect (const ON_BrepFace pFace0, ON_3dPoint f0SelPt, const ON_BrepFace pFace1, ON_3dPoint f1SelPt, double tol, double angleTol, ON_Brep &outBrep0, ON_Brep &outBrep1)

RHINO_SDK_FUNCTION bool	RhinoExtendCrvOnSrf (const ON_BrepFace &face, ON_Curve *&crv, int side=2)

RHINO_SDK_FUNCTION bool	RhinoExtendCurve (ON_Curve &crv, CRhinoExtend::Type type, int side, const ON_SimpleArray< const ON_Geometry > &geom)

RHINO_SDK_FUNCTION bool	RhinoExtendCurve (ON_Curve *&crv, CRhinoExtend::Type type, int side, double length)

RHINO_SDK_FUNCTION bool	RhinoExtendCurve (ON_Curve *&crv, CRhinoExtend::Type type, int side, ON_3dPoint end)

RHINO_SDK_FUNCTION BOOL32	RhinoExtendLineThroughBox (const ON_Line &line_in, const ON_BoundingBox &bbox, ON_Line &line_out)

RHINO_SDK_FUNCTION bool	RhinoExtendSurface (ON_Surface *&srf, ON_Surface::ISO edge_index, double ExtensionLength, bool SmoothToggle)

RHINO_SDK_FUNCTION int	RhinoExtractDuplicateMeshFaces (const ON_Mesh &MeshIn, bool bBoth, ON_Mesh &MeshOut, ON_Mesh &MeshExtractionOut)

RHINO_SDK_FUNCTION int	RhinoExtractDuplicateMeshFaces (const ON_Mesh &MeshIn, ON_Mesh &MeshOut, ON_Mesh &MeshExtractionOut)

RHINO_SDK_FUNCTION bool	RhinoExtractMeshFaces (ON_SimpleArray< int > &FaceIDXArray, ON_Mesh &MeshIn, ON_Mesh &MeshExtracted)

RHINO_SDK_FUNCTION int	RhinoExtractNonManifoldMeshEdges (const ON_Mesh &MeshIn, bool bSelective, int minFaceCtAroundEdge, ON_Mesh &MeshOut, ON_Mesh &MeshExtractionOut)

RHINO_SDK_FUNCTION int	RhinoExtractNonManifoldMeshEdges (const ON_Mesh &MeshIn, bool bSelective, ON_Mesh &MeshOut, ON_Mesh &MeshExtractionOut)

RHINO_SDK_FUNCTION ON_Surface *	RhinoExtrudeCurveStraight (const ON_Curve *pCurve, ON_3dVector direction, double scale=1.0)

RHINO_SDK_FUNCTION ON_Surface *	RhinoExtrudeCurveToPoint (const ON_Curve *pCurve, const ON_3dPoint &apex)

RHINO_SDK_FUNCTION ON_Curve *	RhinoFairCurve (CArgsRhinoFair &args)

RHINO_SDK_FUNCTION ON_Curve *	RhinoFilletCurveCorners (const ON_Curve *curve, double radius, double tol, double ang_tol)

RHINO_SDK_FUNCTION bool	RhinoFilletSurface (const ON_BrepFace pFace0, double u0, double v0, double radius0, const ON_BrepFace pFace1, double u1, double v1, double radius1, RhinoFilletSurfaceType fillet_type, bool bExtend, RhinoFilletSurfaceSplitType split_type, double tolerance, ON_SimpleArray< ON_Brep * > &OutFillets, ON_SimpleArray< ON_Brep * > &OutBreps0, ON_SimpleArray< ON_Brep * > &OutBreps1)

RHINO_SDK_FUNCTION bool	RhinoFilletSurfaceCurve (const ON_Curve pCurve, double t, const ON_BrepFace pFace, double u, double v, double radius, int alignToCurve, int railDegree, int arcDegree, double arcSliders, int nBezierSrfs, double tolerance, ON_SimpleArray< ON_NurbsSurface > &out_fillets, double *fitResults)

RHINO_SDK_FUNCTION bool	RhinoFilletSurfaceNonRational (const ON_BrepFace pFace0, double u0, double v0, const ON_BrepFace pFace1, double u1, double v1, double radius, int railDegree, int arcDegree, double arcSliders, int nBezierSrfs, bool bExtend, RhinoFilletSurfaceSplitType split_type, double tolerance, ON_SimpleArray< ON_Brep > &out_fillets, ON_SimpleArray< ON_Brep * > &out_breps0, ON_SimpleArray< ON_Brep * > &out_breps1, double *fitResults)

RHINO_SDK_FUNCTION bool	RhinoFilletSurfaceToRail (const ON_BrepFace pFace0, const ON_Curve pRailCurve0, const ON_BrepFace pFace1, double u1, double v1, int railDegree, int arcDegree, double arcSliders, int nBezierSrfs, bool bExtend, RhinoFilletSurfaceSplitType split_type, double tolerance, ON_SimpleArray< ON_Brep * > &out_fillets, ON_SimpleArray< ON_Brep * > &out_breps0, ON_SimpleArray< ON_Brep * > &out_breps1, double *fitResults)

RHINO_SDK_FUNCTION bool	RhinoFillMeshHole (const int StartEdgeIdx, ON_Mesh pMesh, ON_Mesh *pMeshHolePatch=nullptr)

RHINO_SDK_FUNCTION bool	RhinoFillMeshHoles (ON_Mesh *pMesh)

RHINO_SDK_FUNCTION bool	RhinoFindLocalInflection (const ON_Curve &curve, ON_3dVector N, ON_Interval subdomain, double seed, double curve_param, double angle_error)

RHINO_SDK_FUNCTION bool	RhinoFitCircleToPoints (const ON_SimpleArray< ON_3dPoint > &point_array, ON_Circle &circle)

RHINO_SDK_FUNCTION bool	RhinoFitCircleToPoints (int point_count, const ON_3dPoint *points, ON_Circle &circle)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoFitCurve (const ON_Curve &curve_in, int degree=3, double dFitTol=ON_UNSET_VALUE, double dAngleTol=ON_UNSET_VALUE, ON_NurbsCurve *curve_out=nullptr)

RHINO_SDK_FUNCTION int	RhinoFitCurveToSurface (const ON_NurbsSurface surface, const ON_Curve curve, ON_3dVector projDir, ON_SimpleArray< double > knots, double tolerance, bool bBezierSections, ON_SimpleArray< ON_NurbsCurve * > &FitCurves, double *FitMeasurement)

RHINO_SDK_FUNCTION int	RhinoFitCurveToSurface2 (const ON_NurbsSurface surface, const ON_Curve curve, ON_3dVector projDir, ON_SimpleArray< double > knots, double tolerance, bool bBezierSections, ON_SimpleArray< ON_NurbsCurve * > &FitCurves, ON_Curve trimCurveOnSurface, ON_Curve splitCurve, double *FitMeasurement)

RHINO_SDK_FUNCTION bool	RhinoFitLineToPoints (const ON_SimpleArray< ON_3dPoint > &point_array, ON_Line &line)

RHINO_SDK_FUNCTION bool	RhinoFitLineToPoints (int point_count, const ON_3dPoint *points, ON_Line &line)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoFitNurbsCurveToPoints (int point_count, const ON_3dPoint pPoints, ON_3dVector pStartTan, ON_3dVector *pEndTan, int degree, bool bPeriodic, double tolerance, bool &bToleranceAchieved)

RHINO_SDK_FUNCTION int	RhinoFitPlaneToPoints (const ON_SimpleArray< ON_3dPoint > &point_array, ON_Plane &plane, ON_BoundingBox &box)

RHINO_SDK_FUNCTION int	RhinoFitPlaneToPoints (int point_count, const ON_3dPoint *points, ON_Plane &plane, ON_BoundingBox &box)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoFitPointsOnSurface (const ON_Surface &srf, const ON_SimpleArray< ON_2dPoint > &points, double tol, bool Periodic)

RHINO_SDK_FUNCTION bool	RhinoFitSphereToPoints (const ON_SimpleArray< ON_3dPoint > &point_array, ON_Sphere &sphere)

RHINO_SDK_FUNCTION bool	RhinoFitSphereToPoints (int point_count, const ON_3dPoint *points, ON_Sphere &sphere)

RHINO_SDK_FUNCTION ON_Surface *	RhinoFitSurface (const ON_Surface &surface_in, int udegree=3, int vdegree=3, double dFitTol=ON_UNSET_VALUE, double *pAchievedTol=nullptr)

RHINO_SDK_FUNCTION int	RhinoFitTrimSurface (const ON_BrepFace face, const ON_BrepEdge edge, ON_SimpleArray< double > &knots, double tolerance, bool bSections, ON_SimpleArray< ON_NurbsSurface * > &FitSurfaces, double *FitMeasurement)

RHINO_SDK_FUNCTION int	RhinoFitTrimSurface2 (const ON_BrepFace face, const ON_BrepEdge edge, ON_SimpleArray< double > &knots, double tolerance, bool bSections, ON_SimpleArray< ON_NurbsSurface * > &FitSurfaces, ON_SimpleArray< ON_NurbsCurve * > &EdgeCurves, double FitMeasurement, ON_Curve trimCurveOnSurface, ON_Curve *splitCurve)

RHINO_SDK_FUNCTION void	RhinoFormatColor (ON_Color color, ON_wString &string)

RHINO_SDK_FUNCTION void	RhinoFormatColor (ON_Color color, ON_wString &string, bool bUseAlpha)

RHINO_SDK_FUNCTION double	RhinoFormatDegreesInDMS (double angle_decimal_degrees, ON_wString &str, bool bWithSpaces=false)

RHINO_SDK_FUNCTION double	RhinoFormatDegreesLatitude (double latitude_decimal_degrees, ON_wString &str, int format=0)

RHINO_SDK_FUNCTION double	RhinoFormatDegreesLongitude (double longitude_decimal_degrees, ON_wString &str, int format=0)

RHINO_SDK_FUNCTION void	RhinoFormatNumber (double x, const ON_3dmUnitsAndTolerances &input_units, const ON_3dmUnitsAndTolerances &output_units, ON_wString &string, bool bAppendUnitSystemName=false)

RHINO_SDK_FUNCTION void	RhinoFormatNumber (double x, const ON_3dmUnitsAndTolerances &units, ON_wString &string, bool bAppendUnitSystemName=false)

RHINO_SDK_FUNCTION void	RhinoFormatNumber (double x, ON_wString &string)

RHINO_SDK_FUNCTION void	RhinoFormatPoint (ON_3dPoint point, ON_wString &string, const wchar_t *number_format=nullptr)

RHINO_SDK_FUNCTION bool	RhinoGet1RailFrames (const ON_Curve &curve, int count, const double *t, ON_SimpleArray< ON_Plane > &frames, ON_3dVector starting_x0)

RHINO_SDK_FUNCTION int	RhinoGetAnalysisMeshes (const ON_SimpleArray< const CRhinoObject * > &objects, ON_ClassArray< CRhinoObjRef > &analysis_meshes, bool bOkToCreate, bool bReturnAllObjects, bool bSkipHiddenObjects)

RHINO_SDK_FUNCTION int	RhinoGetAnalysisMeshes (const ON_SimpleArray< const CRhinoObject * > &objects, ON_ClassArray< CRhinoObjRef > &analysis_meshes, bool bOkToCreate=true, bool bReturnAllObjects=false)

RHINO_SDK_FUNCTION int	RhinoGetBrepFaceIsoCurves (const ON_BrepFace &face, int iso_dir, double iso_constant, ON_SimpleArray< ON_Curve * > &iso_curves)

RHINO_SDK_FUNCTION int	RhinoGetBrepFaceIsoIntervals (const ON_BrepFace &face, int iso_dir, double iso_constant, ON_SimpleArray< ON_Interval > &intervals)

RHINO_SDK_FUNCTION unsigned int	RhinoGetCachedTexture (const ON_wString &Name)

RHINO_SDK_FUNCTION int	RhinoGetCaptiveObjects (const CRhinoMorphControl control_object, ON_SimpleArray< const CRhinoObject > &captives)

RHINO_SDK_FUNCTION bool	RhinoGetClosestPoint (const ON_NurbsCurve &crv, double &t_param, const ON_SimpleArray< const ON_Geometry * > &geom, int &obj_index, ON_COMPONENT_INDEX &comp_index, double &u_param, double &v_param, double MaxDist=0.0)

RHINO_SDK_FUNCTION ON_FileReference	RhinoGetDibAsTextureFileReference (const CRhinoDib &dib, ON__UINT32 crc)

RHINO_SDK_FUNCTION CRhinoDigitizerInfo	RhinoGetDigitizerInfo ()

RHINO_SDK_FUNCTION int	RhinoGetDuplicateMeshFaces (ON_SimpleArray< int > &FaceIDXArray, const ON_Mesh *pMesh)

RHINO_SDK_FUNCTION int	RhinoGetDuplicateMeshFaces (ON_SimpleArray< int > &FaceIDXArray, const ON_Mesh *pMesh, bool bGetAll)

RHINO_SDK_FUNCTION BOOL32	RhinoGetFilletPoints (const ON_Curve &c0, const ON_Curve &c1, double radius, double t0_base, double t1_base, double &t0, double &t1, ON_Plane &FilletPlane)

RHINO_SDK_FUNCTION int	RhinoGetGrevillePoints (const ON_NurbsCurve &in_curve, ON_SimpleArray< ON_3dPoint > &out_points)

RHINO_SDK_FUNCTION int	RhinoGetIsoCurves (const ON_BrepFace &face, int iso_dir, double iso_constant, ON_SimpleArray< ON_Curve * > &curves)

RHINO_SDK_FUNCTION int	RhinoGetIsoIntervals (const ON_BrepFace &face, int iso_dir, double iso_constant, ON_SimpleArray< ON_Interval > &intervals)

RHINO_SDK_FUNCTION DWORD	RhinoGetLastWindowsError ()

RHINO_SDK_FUNCTION BOOL32	RhinoGetLineExtremes (const ON_Curve &curve, ON_Line &line)

RHINO_SDK_FUNCTION bool	RhinoGetMeshOutline (const ON_SimpleArray< const ON_Mesh * > &InMeshes, const CRhinoView view, double tolerance, ON_ClassArray< ON_SimpleArray< ON_PolylineCurve > > &OutRegions)

RHINO_SDK_FUNCTION bool	RhinoGetMeshOutline (const ON_SimpleArray< const ON_Mesh * > &InMeshes, const ON_Viewport &view, const ON_Plane &plane, double tolerance, ON_ClassArray< ON_SimpleArray< ON_PolylineCurve * >> &OutRegions)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoGetMeshParameters (CRhinoDoc &doc, ON_MeshParameters &mp, int &ui_style)

RHINO_SDK_FUNCTION bool	RhinoGetOverlapDistance (const ON_Curve crv_a, const ON_Interval dom_a, const ON_Curve crv_b, const ON_Interval dom_b, double tol, double lim, int cnt, double int_a[3][2], double int_b[3][2], double max_a, double max_b, double max_d, double min_a, double min_b, double *min_d)

RHINO_SDK_FUNCTION bool	RhinoGetPerpendicularCurvePlane (const ON_Curve *crv, double crv_t, ON_Plane &plane)

RHINO_SDK_FUNCTION void	RhinoGetPlugInCommandList (const class CRhinoPlugIn plug_in, ON_SimpleArray< const class CRhinoCommand > &cmd_list)

RHINO_SDK_FUNCTION bool	RhinoGetPointInSolidBrep (const ON_Brep &brep, double tolerance, ON_3dPoint &point)

RHINO_SDK_FUNCTION int	RhinoGetPointOnMesh (const CRhinoMeshObject mesh_object, const wchar_t sPrompt, BOOL32 bAcceptNothing, ON_MESH_POINT &output_point, CRhinoHistory *history=NULL)

RHINO_SDK_FUNCTION int	RhinoGetRenderMeshes (const ON_SimpleArray< const CRhinoObject * > &objects, ON_ClassArray< CRhinoObjRef > &render_meshes, bool bOkToCreate, bool bReturnAllObjects, bool bSkipHiddenObjects)

RHINO_SDK_FUNCTION int	RhinoGetRenderMeshes (const ON_SimpleArray< const CRhinoObject * > &objects, ON_ClassArray< CRhinoObjRef > &render_meshes, bool bOkToCreate, bool bReturnAllObjects, bool bSkipHiddenObjects, bool bUpdateMeshTCs)

RHINO_SDK_FUNCTION int	RhinoGetRenderMeshes (const ON_SimpleArray< const CRhinoObject * > &objects, ON_ClassArray< CRhinoObjRef > &render_meshes, bool bOkToCreate=true, bool bReturnAllObjects=false)

RHINO_SDK_FUNCTION bool	RhinoGetSplitPoints (const ON_Curve &curve, const ON_Brep &cutter, double tolerance, double angtolrads, ON_SimpleArray< double > &tsplit)

RHINO_SDK_FUNCTION bool	RhinoGetSubCurves (const ON_Curve pCurve, const ON_Interval pDomain, bool bSkipSingleSegments, ON_SimpleArray< ON_Curve * > &curve_segments)

RHINO_SDK_FUNCTION bool	RhinoGetTanPerpPoint (const ON_Curve &curve0, const ON_Curve &curve1, bool bPerp0, bool bPerp1, double abs_tol, double &t0, double &t1)

RHINO_SDK_FUNCTION bool	RhinoGetTextOutlines (const ON_Text textobj, const ON_DimStyle dimstyle, bool close_contours, double join_tol, ON_SimpleArray< ON_Curve * > &out_curves)

RHINO_SDK_FUNCTION bool	RhinoGetTextOutlines (const wchar_t str, const ON_Font font, double text_height, bool close_contours, double join_tolerance, ON_ClassArray< ON_ClassArray< ON_SimpleArray< ON_Curve * >>> &out_glyphs)

RHINO_SDK_FUNCTION bool	RhinoGetTextOutlinesWithSmallCaps (const ON_Text pText, const ON_Viewport viewport, const ON_DimStyle dimstyle, double text_scale, bool close_contours, double join_tol, double small_caps_scale, ON_ClassArray< ON_ClassArray< ON_SimpleArray< ON_Curve >>> &out_glyphs)

RHINO_SDK_FUNCTION bool	RhinoGetTextOutlinesWithSmallCaps (const wchar_t str, const ON_Font font, double text_height, bool close_contours, double join_tolerance, double small_caps_scale, ON_ClassArray< ON_ClassArray< ON_SimpleArray< ON_Curve * >>> &out_glyphs)

RHINO_SDK_FUNCTION bool	RhinoGetTightBoundingBox (const ON_SimpleArray< const class CRhinoObject * > &geom, ON_BoundingBox &box, bool Grow=false, ON_Plane *onb=nullptr, bool MakeMeshes=true)

RHINO_SDK_FUNCTION double	RhinoGetTimeInSecondsBetween (const RhTimestamp &start_time, const RhTimestamp &stop_time)

RHINO_SDK_FUNCTION double	RhinoGetTimeInSecondsSince (const RhTimestamp &timestamp)

RHINO_SDK_FUNCTION RhTimestamp	RhinoGetTimestamp ()

RHINO_SDK_FUNCTION ON_Mesh *	RhinoGetTriangulation (const ON_SimpleArray< ON_3dPoint > &InputInnerPoints, const ON_SimpleArray< const ON_PolylineCurve * > &InputInnerBoundaryCurves, const ON_SimpleArray< const ON_PolylineCurve * > &InputInnerBothsideCurves, const ON_PolylineCurve pInputOuterBoundaryCurve=nullptr, const ON_Surface pInputPullBackSurface=nullptr, bool bTrimback=true, int divisions=10)

RHINO_SDK_FUNCTION bool	RhinoGetZeroAreaMeshFaces (ON_SimpleArray< int > &WhollyDegenerateFaces, ON_SimpleArray< int > &PartiallyDegenerateFaces, const ON_Mesh *pMesh)

RHINO_SDK_FUNCTION bool	RhinoHealMesh (const ON_Mesh *pMeshIn, ON_Mesh &MeshOut, const double distance)

RHINO_SDK_FUNCTION class CRhinoHistoryManager *	RhinoHistoryManager ()

RHINO_SDK_FUNCTION class CRhinoHistoryManager *	RhinoHistoryManager (class CRhinoDoc *doc)

RHINO_SDK_FUNCTION ON_Brep *	RhinoInsetBrepFaces (const ON_Brep &brep, const ON_SimpleArray< int > &aFaceIndices, double dDistance, bool bLoose, bool bIgnoreSeams, bool bCreaseCorners, double dTolerance, double dAngleTolerance)

RHINO_SDK_FUNCTION int	RhinoInsetMeshFace (double d, ON_Mesh *pMesh, ON_COMPONENT_INDEX::TYPE ci_type, int ci_index, bool bModify, ON_3dPointArray &basepoints, ON_3dPointArray &corners)

RHINO_SDK_FUNCTION int	RhinoInsetSubDFace (double d, ON_SubD *pSubD, ON_COMPONENT_INDEX::TYPE ci_type, int ci_index, bool bModify, ON_3dPointArray &basepoints, ON_3dPointArray &corners)

RHINO_SDK_FUNCTION RHINO_IDEF_STATUS	RhinoInstanceArchiveFileStatus (const CRhinoInstanceDefinition *idef)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoInterpCurve (int degree, const ON_SimpleArray< ON_3dPoint > &Pt, const ON_3dVector start_tan, const ON_3dVector end_tan, int knot_style, ON_NurbsCurve *nc=nullptr)

RHINO_SDK_FUNCTION ON_Curve *	RhinoInterpolatePointsOnSurface (const ON_Surface &srf, const ON_SimpleArray< ON_2dPoint > PtIn, int is_closed, double tol, int ClosedSrfHandling)

RHINO_SDK_FUNCTION bool	RhinoIntersectBreps (const ON_Brep &B0, const ON_Brep &B1, double tolerance, bool bJoinCurves, ON_SimpleArray< ON_Curve * > &curves, ON_3dPointArray *points)

RHINO_SDK_FUNCTION bool	RhinoIntersectBreps (const ON_Brep &brep0, const ON_Brep &brep1, double tolerance, ON_SimpleArray< ON_Curve * > &curves, ON_3dPointArray *points=nullptr)

RHINO_SDK_FUNCTION bool	RhinoIntersectPlaneBrep (const ON_Plane &plane, const ON_Brep &brep, double tolerance, bool bJoinCurves, ON_SimpleArray< ON_Curve * > &curves, ON_3dPointArray *points)

RHINO_SDK_FUNCTION bool	RhinoIntersectPlaneBrep (const ON_Plane &plane, const ON_Brep &brep, double tolerance, ON_SimpleArray< ON_Curve * > &curves, ON_3dPointArray *points)

RHINO_SDK_FUNCTION bool	RhinoIntersectPlaneWithBoundingBox (ON_3dPoint origin, ON_3dVector normal, const ON_BoundingBox &bounding_box, bool bAccurate, ON_Polyline &polyline)

RHINO_SDK_FUNCTION bool	RhinoIntersectSurfaces (const ON_Surface &srf0, const ON_Surface &srf1, double tolerance, ON_SimpleArray< ON_Curve * > &curves, ON_3dPointArray *points=nullptr)

RHINO_SDK_FUNCTION bool	RhinoIsBrepBox (const ON_Brep &brep, double tolerance)

RHINO_SDK_FUNCTION RhinoConicSectionType	RhinoIsCurveConicSection (const ON_Curve curve, ON_3dPoint focus1, ON_3dPoint focus2, ON_3dPoint center)

RHINO_SDK_FUNCTION bool	RhinoIsMainThread (void)

RHINO_SDK_FUNCTION bool	RhinoIsPointInBrep (const ON_Brep *pBrep, ON_3dPoint pt, double tolerance=ON_SQRT_EPSILON, bool bStrictlyIn=false)

RHINO_SDK_FUNCTION bool	RhinoIsPointOnFace (const ON_BrepFace &face, double tolerance, bool bOkToWrap, double &s, double &t)

RHINO_SDK_FUNCTION bool	RhinoIsRefitTrimValid (const ON_Surface surface, const ON_Curve trimCurve3d, const ON_3dVector trimProjectionDir, double tolerance, bool oneSideOnly, const ON_3dPoint PtActive, ON_NurbsCurve trimCrvU, ON_NurbsSurface surfaceU, bool isTransposed, bool isReversed)

RHINO_SDK_FUNCTION int	RhinoIsValidName (const wchar_t *name)

RHINO_SDK_FUNCTION int	RhinoJoinBrepNakedEdges (ON_Brep &brep, double tolerance=0.0)

RHINO_SDK_FUNCTION bool	RhinoJoinBreps (const ON_SimpleArray< const ON_Brep * > &input_breps, double tolerance, double angle_tolerance, ON_SimpleArray< ON_Brep * > &output_breps)

RHINO_SDK_FUNCTION bool	RhinoJoinBreps (const ON_SimpleArray< const ON_Brep * > &input_breps, double tolerance, double angle_tolerance, ON_SimpleArray< ON_Brep * > &output_breps, ON_ClassArray< ON_SimpleArray< int >> &output_key)

RHINO_SDK_FUNCTION bool	RhinoJoinBreps (ON_Brep &B, const ON_Brep &B1, double tolerance, bool bCompact=true)

RHINO_SDK_FUNCTION ON_Brep *	RhinoJoinBreps (ON_SimpleArray< ON_Brep * > &Breps, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoJoinBreps (ON_SimpleArray< ON_Brep * > &input_breps, ON_SimpleArray< ON_Brep * > &output_breps, double tolerance)

RHINO_SDK_FUNCTION int	RhinoJoinCurves (ON_SimpleArray< const ON_Curve * > &in_curves, ON_SimpleArray< ON_Curve * > &out_curves, double join_tol, bool bPreserveDir, ON_SimpleArray< int > *key)

RHINO_SDK_FUNCTION ON_Brep *	RhinoJoinEdges (const ON_Brep &brep0, int edge_index0, const ON_Brep &brep1, int edge_index1, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoJoinEdges (ON_Brep &brep, int edge_index0, int edge_index1, double tolerance, bool bCompact)

RHINO_SDK_FUNCTION int	RhinoJoinSubDs (const ON_SimpleArray< const ON_SubD * > &input_subds, double join_tolerance, bool bSubDJoinedEdgesAreCreases, bool bPermitNonmanifoldSubD, bool bPreserveSymmetry, ON_SimpleArray< ON_SubD * > &output_subds)

RHINO_SDK_FUNCTION int	RhinoJoinSubDs (const ON_SimpleArray< const ON_SubD * > &input_subds, double join_tolerance, bool bSubDJoinedEdgesAreCreases, bool bPermitNonmanifoldSubD, ON_SimpleArray< ON_SubD * > &output_subds)

RHINO_SDK_FUNCTION RhinoKeyboardModifierKey	RhinoKeyboardModifierKeyFromUnsigned (unsigned int val)

RHINO_SDK_FUNCTION void	RhinoKillSplash ()

RHINO_SDK_FUNCTION bool	RhinoLaplacianMeanMeshCurvature (const ON_Mesh &MeshIn, ON_SimpleArray< double > &result)

RHINO_SDK_FUNCTION int	RhinoLayerManagerSelectedLayers (CRhinoDoc &doc, ON_SimpleArray< int > &layers)

RHINO_SDK_FUNCTION int	RhinoLayerManagerSelectedLayers (ON_SimpleArray< int > &layers)

RHINO_SDK_FUNCTION int	RhinoLayerManagerSelectLayers (CRhinoDoc &doc, const ON_SimpleArray< int > &layers, bool bDeselect)

RHINO_SDK_FUNCTION int	RhinoLayerManagerSelectLayers (ON_SimpleArray< int > layers, bool bDeselect)

RHINO_SDK_FUNCTION BOOL32	RhinoLinetypeDialog (HWND hwndParent, int &linetype_index, bool bDisplayByLayer=false)

const RHINO_SDK_FUNCTION wchar_t *	RhinoLocalizedUnitSystemName (bool bCapitalize, bool bSingular, bool bAbbreviate, const ON_UnitSystem &unit_system)

const RHINO_SDK_FUNCTION wchar_t *	RhinoLocalizedUnitSystemName (bool bCapitalize, bool bSingular, bool bAbbreviate, ON::LengthUnitSystem length_unit_system)

RHINO_SDK_FUNCTION bool	RhinoMakeCompatibleNurbs (ON_SimpleArray< const ON_Curve * > &curves, ON_3dPoint startpt, ON_3dPoint endpt, int simplify_method, int num_elmo_points, double refit_tolerance, double angle_tolerance_radians, ON_SimpleArray< ON_NurbsCurve * > &compatiblecurves)

RHINO_SDK_FUNCTION bool	RhinoMakeCompatibleNurbsSurfaces (const ON_Surface &S0, const ON_Surface &S1, ON_NurbsSurface &C0, ON_NurbsSurface &C1)

RHINO_SDK_FUNCTION int	RhinoMakeConnectedMeshFaceList (const ON_Mesh *pMesh, int StartFaceIDX, double AngleInRadians, bool bGreaterThan, ON_SimpleArray< int > &FaceIDXArray)

RHINO_SDK_FUNCTION bool	RhinoMakeContours (const CRhinoContourInput &input, ON_SimpleArray< ON_Polyline * > &output_PlineArray, ON_SimpleArray< ON_Curve * > &output_CurveArray, ON_SimpleArray< ON_3dPoint > &output_PointArray, double tolerance, bool output, int layer_index, CRhinoDoc *doc)

RHINO_SDK_FUNCTION int	RhinoMakeCubicBeziers (const ON_Curve &Curve, ON_SimpleArray< ON_BezierCurve * > &BezArray, double dist_tol, double kink_tol)

RHINO_SDK_FUNCTION BOOL32	RhinoMakeCurveClosed (ON_Curve *pCrv, double tolerance=0.0)

RHINO_SDK_FUNCTION BOOL32	RhinoMakeCurveEndsMeet (ON_Curve pCrv0, int end0, ON_Curve pCrv1, int end1)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoMakeCurvePeriodic (const ON_Curve &curve, bool bSmooth)

RHINO_SDK_FUNCTION bool	RhinoMakeG1Surface (ON_Surface &srf, double tol=0.0)

RHINO_SDK_FUNCTION int	RhinoMakeMeshPartFaceList (const ON_Mesh *pMesh, int StartFaceIDX, bool bExtractToNonManifoldEdges, ON_SimpleArray< int > &FaceIDXArray)

RHINO_SDK_FUNCTION bool	RhinoMakePiecewiseLinearCurve (const ON_NurbsCurve &crv, double tolerance, ON_NurbsCurve &linear)

RHINO_SDK_FUNCTION bool	RhinoMakePiecewiseLinearSurface (const ON_NurbsSurface &srf, double tolerance, ON_NurbsSurface &linear)

RHINO_SDK_FUNCTION BOOL32	RhinoMakePlanarBreps (ON_SimpleArray< const ON_Curve * > &input_loops, ON_SimpleArray< ON_Brep * > &breps, double tolerance, ON_SimpleArray< int > *used=nullptr)

RHINO_SDK_FUNCTION BOOL32	RhinoMakePlanarBreps (ON_SimpleArray< const ON_Curve * > &input_loops, ON_SimpleArray< ON_Brep * > &breps, ON_SimpleArray< int > *used=nullptr)

RHINO_SDK_FUNCTION bool	RhinoMakePlanarMeshes (ON_SimpleArray< const ON_Curve * > &curves, const ON_MeshParameters &mp, ON_SimpleArray< ON_Mesh * > &meshes, double tol)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoMakeRadiusSpline (ON_Interval domain, ON_SimpleArray< MakeRadiusSplineData > distance_data, bool bClosed=false)

RHINO_SDK_FUNCTION ON_NurbsSurface *	RhinoMakeSurfacePeriodic (const ON_Surface &surface, int dir, bool bSmooth)

RHINO_SDK_FUNCTION bool	RhinoMaskLastWindowsError (DWORD winerr)

RHINO_SDK_FUNCTION bool	RhinoMatchMeshEdge (const ON_Mesh *input, ON_Mesh &output, double distance, bool rachet)

RHINO_SDK_FUNCTION ON_Curve *	RhinoMeanCurve (const ON_Curve pC0, const ON_Curve pC1, double angle_tolerance=ON_UNSET_VALUE)

int	RhinoMemoryErrorHandler (int)
	SDK classes. More...

RHINO_SDK_FUNCTION ON_BrepEdge *	RhinoMergeAdjoiningEdges (ON_BrepEdge &edge, double angtol, int *merge_cnt=nullptr)

RHINO_SDK_FUNCTION bool	RhinoMergeBrepCoplanarFaces (ON_Brep *brep, double tolerance=ON_UNSET_VALUE)

RHINO_SDK_FUNCTION bool	RhinoMergeBreps (const ON_SimpleArray< const ON_Brep * > &InBreps, double tolerance, ON_Brep &MergedBrep)

RHINO_SDK_FUNCTION bool	RhinoMergeCoplanarFaces (ON_Brep *brep, double tolerance=ON_UNSET_VALUE, double angle_tolerance=ON_UNSET_VALUE)

RHINO_SDK_FUNCTION bool	RhinoMergeCoplanarFaces (ON_Geometry *geometry, double tolerance, double angle_tolerance)

RHINO_SDK_FUNCTION bool	RhinoMergeCoplanarFaces (ON_Geometry *geometry, ON_COMPONENT_INDEX face_index, double tolerance, double angle_tolerance)

RHINO_SDK_FUNCTION bool	RhinoMergeCoplanarFaces (ON_Geometry *geometry, ON_COMPONENT_INDEX face_index1, ON_COMPONENT_INDEX face_index2, double tolerance=ON_UNSET_VALUE, double angle_tolerance=ON_UNSET_VALUE)

RHINO_SDK_FUNCTION BOOL32	RhinoMergeCurves (ON_SimpleArray< const ON_Curve * > &input_curves, ON_SimpleArray< ON_Curve * > &output, double join_tol=0.0, BOOL32 bPreserveDir=FALSE, ON_SimpleArray< int > *key=nullptr)

RHINO_SDK_FUNCTION ON_Brep *	RhinoMergeSrf (const ON_Brep in_brep0, const ON_Brep in_brep1, double tolerance, double angtolrads, const ON_2dPoint pick_point0=nullptr, const ON_2dPoint pick_point1=nullptr, double roundness=1.0, bool smooth=true)

RHINO_SDK_FUNCTION bool	RhinoMeshBooleanDifference (const ON_SimpleArray< const ON_Mesh * > &InMeshes0, const ON_SimpleArray< const ON_Mesh * > &InMeshes1, double Intersection_Tolerance, double Overlap_Tolerance, bool something_happened, ON_SimpleArray< ON_Mesh > &OutMeshes, const ON_SimpleArray< const ON_3dmObjectAttributes * > InputAttributeArray, ON_SimpleArray< const ON_3dmObjectAttributes > OuputAttributeArray, CRhinoMeshBooleanOptions options)

RHINO_SDK_FUNCTION bool	RhinoMeshBooleanDifference (const ON_SimpleArray< const ON_Mesh * > &InMeshes0, const ON_SimpleArray< const ON_Mesh * > &InMeshes1, double Intersection_Tolerance, double Overlap_Tolerance, bool something_happened, ON_SimpleArray< ON_Mesh > &OutMeshes, const ON_SimpleArray< const ON_3dmObjectAttributes * > InputAttributeArray=0, ON_SimpleArray< const ON_3dmObjectAttributes > *OuputAttributeArray=0)

RHINO_SDK_FUNCTION bool	RhinoMeshBooleanIntersection (const ON_SimpleArray< const ON_Mesh * > &InMeshes0, const ON_SimpleArray< const ON_Mesh * > &InMeshes1, double Intersection_Tolerance, double Overlap_Tolerance, bool something_happened, ON_SimpleArray< ON_Mesh > &OutMeshes, const ON_SimpleArray< const ON_3dmObjectAttributes * > InputAttributeArray, ON_SimpleArray< const ON_3dmObjectAttributes > OuputAttributeArray, CRhinoMeshBooleanOptions options)

RHINO_SDK_FUNCTION bool	RhinoMeshBooleanIntersection (const ON_SimpleArray< const ON_Mesh * > &InMeshes0, const ON_SimpleArray< const ON_Mesh * > &InMeshes1, double Intersection_Tolerance, double Overlap_Tolerance, bool something_happened, ON_SimpleArray< ON_Mesh > &OutMeshes, const ON_SimpleArray< const ON_3dmObjectAttributes * > InputAttributeArray=0, ON_SimpleArray< const ON_3dmObjectAttributes > *OuputAttributeArray=0)

RHINO_SDK_FUNCTION bool	RhinoMeshBooleanSplit (const ON_SimpleArray< const ON_Mesh * > &MeshesToSplit, const ON_SimpleArray< const ON_Mesh * > &MeshSplitters, double Intersection_Tolerance, double Overlap_Tolerance, bool something_happened, ON_SimpleArray< ON_Mesh > &OutMeshes, bool bMakeBooleanSplits, const ON_SimpleArray< const ON_3dmObjectAttributes * > InputAttributeArray, ON_SimpleArray< const ON_3dmObjectAttributes > OuputAttributeArray, CRhinoMeshBooleanOptions options)

RHINO_SDK_FUNCTION bool	RhinoMeshBooleanSplit (const ON_SimpleArray< const ON_Mesh * > &MeshesToSplit, const ON_SimpleArray< const ON_Mesh * > &MeshSplitters, double Intersection_Tolerance, double Overlap_Tolerance, bool something_happened, ON_SimpleArray< ON_Mesh > &OutMeshes, bool bMakeBooleanSplits=true, const ON_SimpleArray< const ON_3dmObjectAttributes * > InputAttributeArray=0, ON_SimpleArray< const ON_3dmObjectAttributes > *OuputAttributeArray=0)

RHINO_SDK_FUNCTION bool	RhinoMeshBooleanUnion (const ON_SimpleArray< const ON_Mesh * > &InMeshes, double Intersection_Tolerance, double Overlap_Tolerance, bool something_happened, ON_SimpleArray< ON_Mesh > &OutMeshes, const ON_SimpleArray< const ON_3dmObjectAttributes * > InputAttributeArray, ON_SimpleArray< const ON_3dmObjectAttributes > OuputAttributeArray, CRhinoMeshBooleanOptions options)

RHINO_SDK_FUNCTION bool	RhinoMeshBooleanUnion (const ON_SimpleArray< const ON_Mesh * > &InMeshes, double Intersection_Tolerance, double Overlap_Tolerance, bool something_happened, ON_SimpleArray< ON_Mesh > &OutMeshes, const ON_SimpleArray< const ON_3dmObjectAttributes * > InputAttributeArray=0, ON_SimpleArray< const ON_3dmObjectAttributes > *OuputAttributeArray=0)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshBox (ON_3dPoint box_corners[8], const CRhinoMeshDensity &md)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshBox (ON_3dPoint box_corners[8], int X, int Y, int Z)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCone (const ON_Cone &cone, const CRhinoMeshDensity &mesh_density)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCone (const ON_Cone &cone, const CRhinoMeshDensity &mesh_density, bool bQuadCaps)
	Remarks: bQuadCaps is ignored if around is not an even number. More...

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCone (const ON_Cone &cone, int vertical, int around)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCone (const ON_Cone &cone, int vertical, int around, bool bSolid)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCone (const ON_Cone &cone, int vertical, int around, bool bSolid, bool bQuadCaps)
	Remarks: bQuadCaps is ignored if around is not an even number. More...

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCylinder (const ON_Cylinder &cylinder, const CRhinoMeshDensity &mesh_density)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCylinder (const ON_Cylinder &cylinder, const CRhinoMeshDensity &mesh_density, bool bQuadCaps)
	Remarks: bQuadCaps is ignored if around is not an even number. More...

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCylinder (const ON_Cylinder &cylinder, const CRhinoMeshDensity &mesh_density, bool CapTop, bool CapBottom, bool bCircumscribe, bool bQuadCaps)
	Remarks: bQuadCaps is ignored if around is not an even number. More...

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCylinder (const ON_Cylinder &cylinder, int vertical, int around)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCylinder (const ON_Cylinder &cylinder, int vertical, int around, bool bQuadCaps)
	Remarks: bQuadCaps is ignored if around is not an even number. More...

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshCylinder (const ON_Cylinder &cylinder, int vertical, int around, bool CapTop, bool CapBottom, bool bCircumscribe, bool bQuadCaps)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshEllipsoid (const ON_Surface *pSrf, const CRhinoMeshDensity &md)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshEllipsoid (const ON_Surface *pSrf, const CRhinoMeshDensity &md, const bool bQuadCaps)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshEllipsoid (const ON_Surface *pSrf, int vertical, int around)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshEllipsoid (const ON_Surface *pSrf, int vertical, int around, const bool bQuadCaps)

RHINO_SDK_FUNCTION bool	RhinoMeshFace (ON_Mesh &mesh, const ON_SimpleArray< ON_3dPoint > &points)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshIcoSphere (const ON_Sphere &sphere, int subdivisions)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoMeshObjects (const ON_SimpleArray< const CRhinoObject * > &objects, ON_MeshParameters &mp, class CRhinoMeshObjectsUI &ui, ON_ClassArray< CRhinoObjectMesh > &meshes)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoMeshObjects (const ON_SimpleArray< const CRhinoObject * > &objects, ON_MeshParameters &mp, const ON_Xform &xform, class CRhinoMeshObjectsUI &ui, ON_ClassArray< CRhinoObjectMesh > &meshes)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoMeshObjects (const ON_SimpleArray< const CRhinoObject * > &objects, ON_MeshParameters &mp, const ON_Xform &xform, class CRhinoMeshObjectsUI &ui, ON_ClassArray< CRhinoObjectMesh > &meshes, bool bUseWorkerThread)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoMeshObjects (const ON_SimpleArray< const CRhinoObject * > &objects, ON_MeshParameters &mp, const ON_Xform &xform, int &ui_style, ON_ClassArray< CRhinoObjectMesh > &meshes)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoMeshObjects (const ON_SimpleArray< const CRhinoObject * > &objects, ON_MeshParameters &mp, const ON_Xform &xform, int &ui_style, ON_ClassArray< CRhinoObjectMesh > &meshes, bool bUseWorkerThread)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoMeshObjects (const ON_SimpleArray< const CRhinoObject * > &objects, ON_MeshParameters &mp, int &ui_style, ON_ClassArray< CRhinoObjectMesh > &meshes)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshOffset (double d, const ON_Mesh *pMesh)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshOffset (double d, const ON_Mesh *pMesh, bool bSolidify)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshOffset (double d, const ON_Mesh *pMesh, bool bSolidify, const ON_3dVector &direction)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshOffset (double d, const ON_Mesh pMesh, bool bSolidify, const ON_3dVector &direction, ON_SimpleArray< int > pWallFacesOut)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshPipeFromCurve (const ON_Curve &curve, const RhMeshPipeArgs &args, ON_Terminator *pCancelHandler=0)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshPlane (const ON_Plane &plane, ON_Interval x_interval, ON_Interval y_interval, const CRhinoMeshDensity &mesh_density)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshPlane (const ON_Plane &plane, ON_Interval x_interval, ON_Interval y_interval, int X, int Y)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshQuadSphere (const ON_Sphere &sphere, int subdivisions)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshSphere (const ON_Sphere &sphere, const CRhinoMeshDensity &mesh_density)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshSphere (const ON_Sphere &sphere, int vertical, int around)

RHINO_SDK_FUNCTION bool	RhinoMeshSubdivide (const ON_Mesh &inMesh, ON_Mesh &outMesh)
	Subdivides the faces of a mesh. More...

RHINO_SDK_FUNCTION bool	RhinoMeshSubdivideFaces (const ON_Mesh &inMesh, const ON_SimpleArray< ON_COMPONENT_INDEX > face_list, ON_Mesh &outMesh)
	Subdivides specific faces of a mesh. More...

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshTCone (const ON_Brep &TCone, const CRhinoMeshDensity &md)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshTCone (const ON_Brep &TCone, const CRhinoMeshDensity &md, bool bQuadCaps)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshTCone (const ON_Brep &TCone, int vertical, int around)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshTCone (const ON_Brep &TCone, int vertical, int around, bool bQuadCaps)
	Remarks: bQuadCaps is ignored if around is not an even number. More...

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshTorus (const ON_RevSurface *torus, const CRhinoMeshDensity &md)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoMeshTorus (const ON_RevSurface *torus, int vertical, int around)

RHINO_SDK_FUNCTION int	RhinoMessageBox (const char message, const char title, UINT type)

RHINO_SDK_FUNCTION int	RhinoMessageBox (const wchar_t message, const wchar_t title, UINT type)

RHINO_SDK_FUNCTION int	RhinoMessageBox (HWND hParent, const char message, const char title, UINT type)

RHINO_SDK_FUNCTION int	RhinoMessageBox (HWND hParent, const wchar_t message, const wchar_t title, UINT type)

RHINO_SDK_FUNCTION int	RhinoNetworkSurface (const ON_SimpleArray< const ON_Curve * > &curves, const int continuity, ON_NurbsSurface &surface_out, const double dEdgeTol=0.0, const double dInteriorTol=0.0, const double dAngleTol=0.0)

RHINO_SDK_FUNCTION int	RhinoNetworkSurface (const ON_SimpleArray< const ON_Curve * > &ucurves, const int ucontinuity[2], const ON_SimpleArray< const ON_Curve * > &vcurves, const int vcontinuity[2], ON_NurbsSurface &surface_out, const double dEdgeTol=0.0, const double dInteriorTol=0.0, const double dAngleTol=0.0)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoNonRationalArcBezier (int degree, ON_3dPoint ptCenter, ON_3dPoint ptStart, ON_3dPoint ptEnd, double radius, double tanSlider, double midSlider)

RHINO_SDK_FUNCTION bool	RhinoNurbsCurveDirectionsAt (const ON_NurbsCurve &nc, double t, ON_3dVector &u_dir, ON_3dVector &v_dir, ON_3dVector &n_dir)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoNurbsCurveInterpolant (int degree, const ON_SimpleArray< ON_3dPoint > &Pt, ON_3dPoint CV1, ON_3dPoint CVn1, int knot_style=0, ON_NurbsCurve *nurbs_curve=nullptr)

RHINO_SDK_FUNCTION bool	RhinoNurbsSurfaceDirectionsAt (const ON_NurbsSurface &ns, double u, double v, ON_3dVector &u_dir, ON_3dVector &v_dir, ON_3dVector &n_dir)

RHINO_SDK_FUNCTION bool	RhinoObjectClippingPlaneFills (const CRhinoObject &obj, ON_SimpleArray< const CRhinoClippingPlaneObject * > &cp, ON_SimpleArray< ON_Brep * > &aBreps, bool bUnclippedFills=false)

RHINO_SDK_FUNCTION bool	RhinoObjectEnableMeshParameters (const CRhinoObject *obj, bool bEnable=true)

RHINO_SDK_FUNCTION bool	RhinoObjectGetMeshParameters (const CRhinoObject *obj, ON_MeshParameters &mp)

RHINO_SDK_FUNCTION bool	RhinoObjectIsMeshParametersEnabled (const CRhinoObject *obj, bool &bEnabled)

RHINO_SDK_FUNCTION bool	RhinoObjectIsPictureFrame (const CRhinoObject *rhino_object)

RHINO_SDK_FUNCTION bool	RhinoObjectRemoveMeshParameters (const CRhinoObject *obj)

RHINO_SDK_FUNCTION bool	RhinoObjectSetMeshParameters (const CRhinoObject *obj, const ON_MeshParameters &mp, bool bEnable=true)

RHINO_SDK_FUNCTION bool	RhinoOffsetBrep (const ON_Brep &B, double distance, double tolerance, bool bSolid, bool bExtend, bool bShrinkInputSrfs, ON_SimpleArray< ON_Brep * > &Offsets, ON_SimpleArray< ON_Brep * > &Blends, ON_SimpleArray< ON_Brep * > &Walls)

RHINO_SDK_FUNCTION bool	RhinoOffsetBrep (const ON_Brep &B, double distance, double tolerance, bool bSolid, bool bExtend, ON_SimpleArray< ON_Brep * > &Offsets, ON_SimpleArray< ON_Brep * > &Blends, ON_SimpleArray< ON_Brep * > &Walls)

RHINO_SDK_FUNCTION bool	RhinoOffsetCurve (const ON_Curve &curve, const ON_3dVector &normal, const ON_3dPoint &origin, double distance, ON_SimpleArray< ON_Curve * > &offset_curves, double tolerance=0.0, double angle_tolerance=0.0, int corner_style=1)

RHINO_SDK_FUNCTION int	RhinoOffsetCurve (const ON_Curve &curve_in, double distance, ON_3dPoint direction_point, ON_3dVector normal, int corner_style, double tolerance, double angle_tolerance, bool bLoose, int end_style, ON_SimpleArray< ON_Curve * > &curves_out)

RHINO_SDK_FUNCTION int	RhinoOffsetCurve (const ON_Curve &curve_in, double distance, ON_3dPoint direction_point, ON_3dVector normal, int corner_style, double tolerance, double angle_tolerance, ON_SimpleArray< ON_Curve * > &curves_out)

RHINO_SDK_FUNCTION int	RhinoOffsetCurve (const ON_Curve &curve_in, double distance, ON_3dPoint direction_point, ON_3dVector normal, int corner_style, double tolerance, ON_SimpleArray< ON_Curve * > &curves_out)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoOffsetCurveNormal (const ON_Surface pSrf, const ON_NurbsCurve pNC, const ON_NurbsCurve *pHeights)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoOffsetCurveNormal (const ON_Surface pSrf, const ON_NurbsCurve pNC, const ON_SimpleArray< double > &spine_parameters, const ON_NurbsCurve *pHeights)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoOffsetCurveNormal (const ON_Surface pSrf, const ON_NurbsCurve pNC, double height)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoOffsetCurveOnSrf (const ON_Curve p3dCrv, const ON_Brep pBrep, int fid, double distance, double tol, ON_SimpleArray< ON_Curve * > &result_curves)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoOffsetCurveOnSrf (const ON_Curve p3dCrv, const ON_Brep pBrep, int fid, ON_2dPoint through_point, double tol, ON_SimpleArray< ON_Curve * > &result_curves)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoOffsetCurveOnSrf (const ON_Curve p3dCrv, const ON_Brep pBrep, int fid, ON_SimpleArray< double > &params, ON_SimpleArray< double > &dists, double tol, ON_SimpleArray< ON_Curve * > &result_curves)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoOffsetCurveOnSrfOld (const ON_Curve p3dCrv, const ON_Brep pBrep, int fid, ON_SimpleArray< double > &params, ON_SimpleArray< double > &dists, double tol, ON_SimpleArray< ON_Curve * > &result_curves)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoOffsetCurveTangent (const ON_Surface pSrf, const ON_NurbsCurve pNC, double height)

RHINO_SDK_FUNCTION ON_SubD *	RhinoOffsetSubD (const ON_SubD &InSubD, double distance, bool bSolidify)

RHINO_SDK_FUNCTION ON_Brep *	RhinoOffsetSurface (const ON_BrepFace &face, const double dOffsetDistance, const double dTolerance=0.0, const bool bBothSides=false, const bool bSolid=false, double *pAchievedTol=nullptr)

RHINO_SDK_FUNCTION int	RhinoOsnapPickboxRadius (void)

RHINO_SDK_FUNCTION int	RhinoParseAngle (const wchar_t string, double angle_radians_value)

RHINO_SDK_FUNCTION int	RhinoParseAngleDegrees (const wchar_t string, double angle_degrees_value)

RHINO_SDK_FUNCTION int	RhinoParseColor (const wchar_t string, ON_Color color_value)

RHINO_SDK_FUNCTION int	RhinoParseColor (const wchar_t string, ON_Color color_value, bool bUseAlpha)

RHINO_SDK_FUNCTION ON::AngleUnitSystem	RhinoParseDefaultAngleUnitSystem ()

RHINO_SDK_FUNCTION int	RhinoParseNumber (const wchar_t string, double number_value)

RHINO_SDK_FUNCTION int	RhinoParsePoint (const wchar_t string, ON_3dPoint point_value)

RHINO_SDK_FUNCTION bool	RhinoParsePythonFormula (const wchar_t sformula, unsigned int sformula_count, double value)

RHINO_SDK_FUNCTION bool	RhinoParseTextFields (ON_wString pParseResults, const CRhinoObject pRhinoObject, const CRhinoObject pTopParent, const CRhinoInstanceObject pImmediateParent)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoPatchSingleMeshFace (const ON_Mesh *pInputMesh, const ON_SimpleArray< ON_COMPONENT_INDEX > &indexes, bool bJoin)

RHINO_SDK_FUNCTION bool	RhinoPerspectiveMatch (CRhinoView *rhino_view, const ON_SimpleArray< POINT > &points2d, const ON_SimpleArray< ON_3dPoint > &points3d, ON_3dmView &view)

RHINO_SDK_FUNCTION bool	RhinoPipe (const ON_Curve &rail, const ON_SimpleArray< double > &rail_params, const ON_SimpleArray< double > &radii, ON_SimpleArray< ON_Object * > &results, double abstol, double angtol, int blend_type=0, int cap_mode=0, bool fit_rail=false)

RHINO_SDK_FUNCTION bool	RhinoPipe (const ON_Curve &rail, const ON_SimpleArray< double > &rail_params, const ON_SimpleArray< double > &radii0, const ON_SimpleArray< double > &radii1, ON_SimpleArray< ON_Object * > &results, double abstol, double angtol, int blend_type=0, int cap_mode=0, bool fit_rail=false)

RHINO_SDK_FUNCTION int	RhinoPlanarClosedCurveContainmentTest (const ON_Curve &closed_curveA, const ON_Curve &closed_curveB, ON_Plane plane, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoPlanarCurveCollisionTest (const ON_Curve &curveA, const ON_Curve &curveB, ON_Plane plane, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoPlanarSrf (const ON_SimpleArray< const ON_Curve * > &InCurves, ON_SimpleArray< ON_Brep * > &OutBreps, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoPlugInSDKInstalled ()

RHINO_SDK_FUNCTION ON_PointCloud *	RhinoPointCloudRandomSubsample (const ON_PointCloud pPointCloud, const int points_to_keep, ON_PointCloud pSubsample=nullptr, ON_ProgressReporter pProgressReporter=nullptr, ON_Terminator pTerminator=nullptr)

RHINO_SDK_FUNCTION int	RhinoPointInPlanarClosedCurve (ON_3dPoint point, const ON_Curve &closed_curve, ON_Plane plane)

RHINO_SDK_FUNCTION int	RhinoPointInPlanarClosedCurve (ON_3dPoint point, const ON_Curve &closed_curve, ON_Plane plane, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoPrintExportDialog (const CRhinoPrintInfo &initialinfo, const CArgsRhinoPrintExportDlg &args, ON_ClassArray< CRhinoPrintInfo > &settings)

RHINO_SDK_FUNCTION bool	RhinoPrintExportDialog (CRhinoPrintInfo &info, const CArgsRhinoPrintExportDlg &args)

RHINO_SDK_FUNCTION bool	RhinoPrintExportDialog (CRhinoPrintInfo &info, const CArgsRhinoPrintExportDlg &args, bool &bDontShowDialog)

RHINO_SDK_FUNCTION BOOL32	RhinoPrintWidthDialog (HWND hwndParent, double &print_width)

RHINO_SDK_FUNCTION bool	RhinoProjectCurvesToBreps (ON_SimpleArray< const ON_Brep * > &Breps, ON_SimpleArray< const ON_Curve * > &Curves, const ON_3dVector &ProjDir, bool bLoose, ON_SimpleArray< ON_Curve * > &OutCurves, ON_SimpleArray< int > &CurveIndices, ON_SimpleArray< int > &BrepIndices, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoProjectCurvesToBreps (ON_SimpleArray< const ON_Brep * > &Breps, ON_SimpleArray< const ON_Curve * > &Curves, const ON_3dVector &ProjDir, ON_SimpleArray< ON_Curve * > &OutCurves, ON_SimpleArray< int > &CurveIndices, ON_SimpleArray< int > &BrepIndices, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoProjectCurvesToMeshes (ON_SimpleArray< const ON_Mesh * > &Meshes, ON_SimpleArray< const ON_Curve * > &Curves, const ON_3dVector &ProjDir, bool bLoose, ON_SimpleArray< ON_Curve * > &OutCurves, ON_SimpleArray< int > &CurveIndices, ON_SimpleArray< int > &MeshIndices, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoProjectCurvesToMeshes (ON_SimpleArray< const ON_Mesh * > &Meshes, ON_SimpleArray< const ON_Curve * > &Curves, const ON_3dVector &ProjDir, ON_SimpleArray< ON_Curve * > &OutCurves, ON_SimpleArray< int > &CurveIndices, ON_SimpleArray< int > &MeshIndices, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoProjectPointsToBreps (ON_SimpleArray< const ON_Brep * > &Breps, const ON_3dPointArray &Points, const ON_3dVector &ProjDir, ON_3dPointArray &OutPoints, ON_SimpleArray< int > &Indices, double tolerance)

RHINO_SDK_FUNCTION bool	RhinoProjectPointsToMeshes (ON_SimpleArray< const ON_Mesh * > &Meshes, const ON_3dPointArray &Points, const ON_3dVector &ProjDir, ON_3dPointArray &OutPoints, ON_SimpleArray< int > &Indices, double tolerance)

RHINO_SDK_FUNCTION ON_Curve *	RhinoProjectToPlane (const ON_Curve &curve, const ON_Plane &plane, double shortSegmentTolerance)

RHINO_SDK_FUNCTION BOOL32	RhinoProjectToPlane (ON_BoundingBox &curve, ON_Plane &plane)

RHINO_SDK_FUNCTION BOOL32	RhinoProjectToPlane (ON_NurbsCurve &curve, ON_Plane &plane)

RHINO_SDK_FUNCTION int	RhinoPullCurveToFace (const ON_BrepFace &face, const ON_Curve &curve, ON_SimpleArray< ON_Curve * > &OutCurves, double tolerance)

RHINO_SDK_FUNCTION ON_PolylineCurve *	RhinoPullCurveToMesh (const ON_Curve pCrv, const ON_Mesh pMesh, const double tolerance, CRhinoPolylineOnMeshUserData *YDData=0)

RHINO_SDK_FUNCTION int	RhinoPullPointsToFace (const ON_BrepFace &face, const ON_SimpleArray< ON_3dPoint > &InPoints, ON_SimpleArray< ON_3dPoint > &OutPoints, double tolerance)

RHINO_SDK_FUNCTION ON_Brep *	RhinoPushPullExtend (const ON_Brep &brep, int iFaceIdx, const ON_Xform &xform, double dTolerance)

RHINO_SDK_FUNCTION int	RhinoQueryImportScaleGeometry (ON::LengthUnitSystem current, ON::LengthUnitSystem file, bool bInteractive)

RHINO_SDK_FUNCTION bool	RhinoReadFile (const wchar_t *lpsFileName, CRhinoDoc &doc, const CRhinoFileReadOptions &options)

RHINO_SDK_FUNCTION bool	RhinoReadHatchPatternFile (const wchar_t *pFilename, ON_ClassArray< ON_HatchPattern > &hatchPatterns, bool bAllowDuplicates, bool bQuiet)

RHINO_SDK_FUNCTION bool	RhinoReadHatchPatternFile (const wchar_t *pFilename, ON_ObjectArray< ON_HatchPattern > &hatchPatterns, bool bAllowDuplicates, bool bQuiet)

RHINO_SDK_FUNCTION int	RhinoReadLinetypesFromFile (const wchar_t *filename, ON_ObjectArray< ON_Linetype > &linetypes)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoRebuildCurve (const ON_Curve &curve_in, int degree, int pointcount, bool bKeepTangents, ON_NurbsCurve *curve_out=nullptr)

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoRebuildCurve (const ON_Curve &curve_in, int degree=3, int pointcount=10, ON_NurbsCurve *curve_out=nullptr)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoRebuildMeshNormals (const ON_Mesh *MeshIn)

RHINO_SDK_FUNCTION ON_NurbsSurface *	RhinoRebuildSurface (const ON_Surface &surface_in, int udegree=3, int vdegree=3, int upointcount=10, int vpointcount=10, ON_NurbsSurface *surface_out=nullptr)

RHINO_SDK_FUNCTION ON_NurbsSurface *	RhinoRebuildSurfaceOneDirection (const ON_Surface &surface_in, int direction, int point_count, int loft_type, double tolerance, ON_NurbsSurface *surface_out=nullptr)

RHINO_SDK_FUNCTION void	RhinoRedrawLayerManagerWindow ()

RHINO_SDK_FUNCTION void	RhinoRedrawLayerManagerWindow (CRhinoDoc &doc)

RHINO_SDK_FUNCTION bool	RhinoReduceMesh (ON_Mesh &mesh, int iDesiredPolygonCount, bool bAllowDistortion=true, int iAccuracy=10, bool bNormalizeMeshSize=true, ON_ProgressReporter pProgressReporter=0, ON_Terminator pCancelHandler=0, ON_wString pStrProblemOut=0, ON_SimpleArray< int > pFaceTagArray=0, ON_SimpleArray< ON_COMPONENT_INDEX > *pLockedComponents=0)

RHINO_SDK_FUNCTION bool	RhinoReduceMesh (ON_Mesh &mesh, RhinoReduceMeshParameters &parameters)

RHINO_SDK_FUNCTION bool	RhinoRefitCrvCalculateMaxDeviation (const ON_Curve input_curve, const ON_Curve refit_curve, double tolerance, ON_Line *deviation)

RHINO_SDK_FUNCTION bool	RhinoRefitSimplySplitSurface (const ON_Surface surface, const ON_Curve trimCurve3d, const ON_3dVector trimProjectionDir, double tolerance, RhinoRefitTrimKnotMode knotAdditionMode, int numKnots, ON_SimpleArray< double > &Knots, RhinoRefitTrimSectionMode trimParamSections, int numNonTrimSpans, bool meetCurve, bool oneSideOnly, const ON_3dPoint PtActive, bool outputSurface, bool outputCurve, int numSections, double FitMeasurement, ON_SimpleArray< ON_NurbsSurface * > &lowerSurface, ON_SimpleArray< ON_NurbsSurface * > &upperSurface, ON_SimpleArray< ON_NurbsCurve * > &edgeCurves, ON_Curve trimCurveOnSurface, ON_Curve splitCurve)

RHINO_SDK_FUNCTION bool	RhinoRegionSelect (CRhinoViewport &vp, const ON_SimpleArray< ON_3dPoint > &region, const int selectionmode=0, unsigned int geometry_filter=ON::any_object, ON_ClassArray< CRhinoObjRef > *output=nullptr)

void	RhinoRegisterCustomMeshHandler (CUSTOM_MESH_HANDLER_FUNC)

RHINO_SDK_FUNCTION void	RhinoRegisterCustomMeshHandler2 (CUSTOM_MESH_HANDLER_FUNC2)

RHINO_SDK_FUNCTION int	RhinoRemoveAllNakedMicroEdges (ON_Brep &brep, double tolerance, bool bCleanUp)

RHINO_SDK_FUNCTION bool	RhinoRemoveBrepFins (ON_Brep &brep)

RHINO_SDK_FUNCTION bool	RhinoRemoveNakedMicroEdge (ON_Brep &brep, int edge_index, double tolerance, bool bCleanUp)

RHINO_SDK_FUNCTION int	RhinoRemoveNakedMicroEdges (ON_Brep &brep, const ON_SimpleArray< int > &edge_indices, double tolerance, bool bCleanUp)

RHINO_SDK_FUNCTION bool	RhinoRemoveShortSegments (ON_Curve *curve, double tolerance=ON_UNSET_VALUE)

RHINO_SDK_FUNCTION bool	RhinoRenderDrawWiresInDIB (CRhinoDib &alpha_dib, CRhinoDib &dib2, CRhinoDib &final_dib)

RHINO_SDK_FUNCTION bool	RhinoRenderDrawWiresInDIB (CRhinoDoc &doc, ON_3dmView view, const ON_2iSize &size, CRhinoDib &final_dib, bool bGetRenderSettingsFromDoc=true)

RHINO_SDK_FUNCTION bool	RhinoRenderGetWireframeCompositeDIBs (CRhinoDoc &doc, ON_3dmView view, const ON_2iSize &size, CRhinoDib &alpha_dib, CRhinoDib &wires_dib, bool bGetRenderSettingsFromDoc)

RHINO_SDK_FUNCTION bool	RhinoRepairBrep (ON_Brep *pBrep, double repair_tolerance)

RHINO_SDK_FUNCTION bool	RhinoRepairBrep (ON_Brep *pBrep, double repair_tolerance, bool bSpliKinkyEdges)

RHINO_SDK_FUNCTION bool	RhinoRepairCurve (ON_Curve *pCurve, double repair_tolerance, int dim)

RHINO_SDK_FUNCTION bool	RhinoRepairMesh (ON_Mesh *pMesh, double repair_tolerance)

RHINO_SDK_FUNCTION bool	RhinoRepairSurface (ON_Surface *pSurface, double repair_tolerance)

RHINO_SDK_FUNCTION ON_Brep *	RhinoRetrimSurface (const ON_BrepFace &trim_source, const ON_Surface &trim_target, double tol)

RHINO_SDK_FUNCTION ON_Curve *	RhinoRibbonOffsetCurve (const ON_Curve &curve_in, double distance, double blend_radius, ON_3dPoint direction_point, ON_3dVector normal, double tolerance, ON_SimpleArray< ON_2dPoint > &CrossParams)

RHINO_SDK_FUNCTION ON_Curve *	RhinoRibbonOffsetCurve (const ON_Curve &curve_in, double distance, double blend_radius, ON_3dPoint direction_point, ON_3dVector normal, double tolerance, ON_SimpleArray< ON_Curve * > CrossSections, ON_SimpleArray< ON_Surface > *RuledSrfs)

RHINO_SDK_FUNCTION CRhinoCommand::result	RhinoScriptGetMeshParameters (ON_MeshParameters &mp)

RHINO_SDK_FUNCTION bool	RhinoSdkLoft (CArgsRhinoLoft &args, ON_SimpleArray< ON_Brep * > &breps, CRhinoHistory *history=nullptr)

RHINO_SDK_FUNCTION bool	RhinoSdkLoftSurface (CArgsRhinoLoft &args, ON_SimpleArray< ON_NurbsSurface * > &srfs, CRhinoHistory *history=nullptr)

RHINO_SDK_FUNCTION unsigned int	RhinoSdkServiceRelease ()

RHINO_SDK_FUNCTION unsigned int	RhinoSdkVersion ()

RHINO_SDK_FUNCTION int	RhinoSelectDimstyle (bool interactive)

RHINO_SDK_FUNCTION int	RhinoSelectDimstyle (CRhinoDoc &doc, bool interactive)
	Added 11/10/2009 to eliminate ActiveDoc() call. More...

RHINO_SDK_FUNCTION int	RhinoSelectHatchPattern (unsigned int rhino_doc_sn, bool interactive)

RHINO_SDK_FUNCTION BOOL32	RhinoSelectLayerDialog (HWND hwndParent, const wchar_t lpsPrompt, int &layer_index, BOOL32 bDisplayDialog=TRUE, BOOL32 bEnableNewLayerButton=FALSE, BOOL32 bEnableSetLayerCurrentButton=FALSE, BOOL32 pbSetLayerCurrentButtonValue=nullptr)

RHINO_SDK_FUNCTION BOOL32	RhinoSelectMultipleLayersDialog (HWND hwndParent, const wchar_t *lpsPrompt, ON_SimpleArray< int > &layer_indices, BOOL32 bDisplayDialog=TRUE, BOOL32 bEnableNewLayerButton=FALSE)

RHINO_SDK_FUNCTION bool	RhinoSeparateBreps (const ON_Brep &in_brep, ON_SimpleArray< ON_Brep * > &out_breps, ON_ClassArray< ON_SimpleArray< int >> *out_keys)

unsigned int	RhinoSerialNumberOrdinal (unsigned int runtime_serial_number)

unsigned int	RhinoSerialNumberType (unsigned int runtime_serial_number)

RHINO_SDK_FUNCTION HCURSOR	RhinoSetCursor (HCURSOR hCursor)

RHINO_SDK_FUNCTION bool	RhinoSetExternalPackBrepTexturesRoutine (bool(routine)(const ON_SimpleArray< const ON_Mesh > &meshes, ON_SimpleArray< ON_Mesh * > &packed_tex_out))

RHINO_SDK_FUNCTION ON_NurbsCurve *	RhinoSetGrevillePoints (const ON_NurbsCurve &in_curve, int point_count, const ON_3dPoint in_points, ON_NurbsCurve out_curve=nullptr)

RHINO_SDK_FUNCTION bool	RhinoSetNurbsCurveEndCondition (ON_NurbsCurve *curve, int end, int continuity, const ON_3dPoint &point, const ON_3dVector &tangent, const ON_3dVector &curvature)
	RhinoSdkMatchCurve.h. More...

RHINO_SDK_FUNCTION int	RhinoShellBrep (const ON_Brep &brep, const ON_SimpleArray< int > &faces_to_remove, double distance, double tolerance, ON_SimpleArray< ON_Brep * > &shells)

RHINO_SDK_FUNCTION ON_Curve *	RhinoShortPath (const ON_Surface &Srf, ON_2dPoint start, ON_2dPoint end, double tol)

RHINO_SDK_FUNCTION bool	RhinoSimpleRollingBallFillet (const ON_BrepFace &FaceA, bool bFlipA, const ON_BrepFace &FaceB, bool bFlipB, double radius, double tol, ON_SimpleArray< ON_Surface * > &Fillets)

RHINO_SDK_FUNCTION bool	RhinoSimpleRollingBallFillet (const ON_BrepFace &FaceA, const ON_2dPoint &uvA, const ON_BrepFace &FaceB, const ON_2dPoint &uvB, double radius, double tol, ON_SimpleArray< ON_Surface * > &Fillets)

RHINO_SDK_FUNCTION bool	RhinoSimplifyCurve (ON_Curve *&crv, double dist_tol, double angle_tol)

RHINO_SDK_FUNCTION bool	RhinoSimplifyCurve (ON_Curve *&crv, int flags, double dist_tol, double angle_tol)

RHINO_SDK_FUNCTION bool	RhinoSimplifyCurveEnd (ON_Curve *&pC, int side, int flags, double dist_tol, double angle_tol)

RHINO_SDK_FUNCTION ON_Curve *	RhinoSmoothCurve (const ON_Curve *pInput, double dSmoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, int nCoordinateSystem)

RHINO_SDK_FUNCTION ON_Curve *	RhinoSmoothCurve (const ON_Curve pInput, double dSmoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, int nCoordinateSystem, const ON_Plane pPlane)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoSmoothMesh (const ON_Mesh pInput, const ON_SimpleArray< int > &InVertices, double dSmoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, int nCoordinateSystem, const ON_Plane pPlane)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoSmoothMesh (const ON_Mesh pInput, const ON_SimpleArray< int > &InVertices, double dSmoothFactor, int numSteps, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, int nCoordinateSystem, const ON_Plane pPlane)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoSmoothMesh (const ON_Mesh *pInput, double dSmoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, int nCoordinateSystem)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoSmoothMesh (const ON_Mesh pInput, double dSmoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, int nCoordinateSystem, const ON_Plane pPlane)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoSmoothMesh (const ON_Mesh pInput, double dSmoothFactor, int numSteps, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, int nCoordinateSystem, const ON_Plane pPlane)

RHINO_SDK_FUNCTION ON_Surface *	RhinoSmoothSurface (const ON_Surface *pInput, double dSmoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, int nCoordinateSystem)

RHINO_SDK_FUNCTION ON_Surface *	RhinoSmoothSurface (const ON_Surface pInput, double dSmoothFactor, bool bXSmooth, bool bYSmooth, bool bZSmooth, bool bFixBoundaries, int nCoordinateSystem, const ON_Plane pPlane)

RHINO_SDK_FUNCTION bool	RhinoSnapToNurbsCurve (const CRhinoObject *object, const ON_NurbsCurve &nurbs_curve, const CRhinoSnapContext &snap_context, CRhinoSnapEvent &snap_event)

RHINO_SDK_FUNCTION ON_Curve *	RhinoSoftEditCrv (const ON_Curve *curve, double curve_t, const ON_3dVector &delta, double length, bool bFixEnds)

RHINO_SDK_FUNCTION ON_Surface *	RhinoSoftEditSrf (const ON_Surface *surface, const ON_2dPoint &uv, const ON_3dVector &delta, double u_length, double v_length, double tolerance, bool bFixEnds)

RHINO_SDK_FUNCTION bool	RhinoSortPointList (int point_count, const ON_2dPoint points, int order, double mindist)

RHINO_SDK_FUNCTION bool	RhinoSortPointList (int point_count, const ON_3dPoint points, int order, double mindist)

RHINO_SDK_FUNCTION bool	RhinoSortPointList (ON_SimpleArray< ON_3dPoint > &points, double mindist=ON_ZERO_TOLERANCE)

RHINO_SDK_FUNCTION ON_Brep *	RhinoSplitBrepFace (const ON_Brep &brep, int face_index, const ON_SimpleArray< const ON_Curve * > &curves, double tolerance, bool bCopySurface=false)

RHINO_SDK_FUNCTION int	RhinoSplitDisjointMesh (const ON_Mesh pMesh, ON_SimpleArray< ON_Mesh > &MeshArray, bool bJustCount=false)

RHINO_SDK_FUNCTION bool	RhinoSplitFaceAtTangents (ON_Brep &brep, int face_index)

RHINO_SDK_FUNCTION bool	RhinoSplitFacesAtTangents (ON_Brep &brep)

RHINO_SDK_FUNCTION bool	RhinoSplitMeshEdge (ON_Mesh *pMesh, const int edgeidx, const ON_SimpleArray< double > &params)

RHINO_SDK_FUNCTION bool	RhinoSplitMeshEdge (ON_Mesh *pMesh, const int edgeidx, const ON_SimpleArray< ON_3dPoint > &points)

RHINO_SDK_FUNCTION int	RhinoSplitRefitSurface (const ON_Surface surface, const ON_Curve curve, ON_3dVector projDir, bool bMeetCurve, ON_SimpleArray< double > knots, double tolerance, bool bBezierSections, ON_SimpleArray< ON_NurbsSurface * > &FitSurfacesLower, ON_SimpleArray< ON_NurbsSurface * > &FitSurfacesUpper, ON_SimpleArray< ON_NurbsCurve * > &FitCurves, ON_Curve trimCurveOnSurface, ON_Curve splitCurve, double *FitMeasurement)

RHINO_SDK_FUNCTION ON_NurbsSurface *	RhinoSrfControlPtGrid (int point_count[2], int degree[2], const ON_3dPointArray &point_array, ON_NurbsSurface *nurbs_surface=nullptr)

RHINO_SDK_FUNCTION ON_NurbsSurface *	RhinoSrfPtGrid (int point_count[2], int degree[2], BOOL32 is_closed[2], const ON_3dPointArray &point_array, ON_NurbsSurface *nurbs_surface=nullptr)

RHINO_SDK_FUNCTION int	RhinoStraightenBrep (ON_Brep &B, double tol=0.0)

RHINO_SDK_FUNCTION bool	RhinoSubDLoft (const ON_SimpleArray< const ON_NurbsCurve * > &shape_curves, bool bClosedLoft, bool bSubDCorners, bool bSubDCreases, int nDivisions, ON_SubD *result_subd)

RHINO_SDK_FUNCTION bool	RhinoSubDSweep1 (const ON_NurbsCurve rail_curve, const ON_SimpleArray< const ON_NurbsCurve > &shape_curves, bool bSubDCorners, bool bClosedSweep, bool bFrameStyle, ON_3dVector frame_up, ON_SubD *result_subd)

RHINO_SDK_FUNCTION bool	RhinoSubDSweep2 (const ON_SimpleArray< const ON_NurbsCurve * > &rail_curves, const ON_SimpleArray< const ON_NurbsCurve * > &shape_curves, bool bSubDCorners, bool bClosedSweep, ON_SubD *result_subd)

RHINO_SDK_FUNCTION bool	RhinoSurfaceDraftAnglePoint (const ON_BrepFace &face, const ON_2dPoint &test_point, double test_angle, const ON_3dVector &direction, bool bEdge, ON_3dPoint &draft_point, double *draft_angle)

RHINO_SDK_FUNCTION ON_NurbsSurface *	RhinoSurfaceFromPlane (const ON_Plane &plane, ON_Interval u_interval, ON_Interval v_interval, int u_degree, int v_degree, int u_points, int v_points, ON_NurbsSurface *pOutSrf=nullptr)

RHINO_SDK_FUNCTION bool	RhinoSwapMeshEdge (const ON_Mesh pInputMesh, int topei, ON_Mesh *pOutputMesh=nullptr)

RHINO_SDK_FUNCTION BOOL32	RhinoSweep1 (CArgsRhinoSweep1 &args, ON_SimpleArray< ON_Brep * > &brep_array)

RHINO_SDK_FUNCTION BOOL32	RhinoSweep1Ex (CArgsRhinoSweep1 &args, int shape_blending, ON_SimpleArray< ON_Brep * > &brep_array)

RHINO_SDK_FUNCTION BOOL32	RhinoSweep2 (CArgsRhinoSweep2 &args, ON_SimpleArray< ON_Brep * > &brep_array)

RHINO_SDK_FUNCTION bool	RhinoTaperedExtrudeCurveWithRef (const ON_Curve &Crv, const ON_3dVector &ExtrudeDir, double dist, double draft, const ON_3dPoint &ReferencePoint, const ON_3dVector &ReferenceDir, double tolerance, ON_SimpleArray< ON_Brep * > &Extrusions)

RHINO_SDK_FUNCTION bool	RhinoTaperedExtrudeCurveWithRef (const ON_Curve &Crv, const ON_3dVector &ExtrudeDir, double dist, double draft, const ON_3dPoint &ReferencePoint, const ON_3dVector &ReferenceDir, ON_SimpleArray< ON_Surface * > &ExtrusionSrfs)

RHINO_SDK_FUNCTION ON_Surface *	RhinoTaperedExtrudeSmoothCurveWithRef (const ON_Curve &Crv, const ON_3dVector &ExtrudeDir, double dist, double draft, const ON_3dPoint &ReferencePoint, const ON_3dVector &ReferenceDir)

RHINO_SDK_FUNCTION bool	RhinoTransformBrepComponents (ON_Brep brep, int brep_component_count, const ON_COMPONENT_INDEX brep_components, ON_Xform xform, double tolerance, double time_limit, bool bUseMultipleThreads)

RHINO_SDK_FUNCTION int	RhinoTriangulate2dRegion (int point_count, int point_stride, const double point, int edge_count, int edge_stride, const int edge, const int *edge_side, ON_SimpleArray< ON_3dex > &triangles)

RHINO_SDK_FUNCTION int	RhinoTriangulate3dPolygon (int point_count, int point_stride, const double P, int tri_stride, int triangle)

RHINO_SDK_FUNCTION CRhinoObjectGrips *	RhinoTurnOnCaptiveGrips (const CRhinoMorphControl control_object, const CRhinoObject captive_object)

RHINO_SDK_FUNCTION bool	RhinoTweenCurves (const ON_Curve start_crv, const ON_Curve end_crv, int num_of_crvs, double tol, ON_SimpleArray< ON_Curve * > &tween_crvs)

RHINO_SDK_FUNCTION bool	RhinoTweenCurvesWithMatching (const ON_Curve start_crv, const ON_Curve end_crv, int num_of_crvs, double tol, ON_SimpleArray< ON_Curve * > &tween_crvs)

RHINO_SDK_FUNCTION bool	RhinoTweenCurveWithSampling (const ON_Curve start_crv, const ON_Curve end_crv, int num_of_crvs, int sample_num, double tol, ON_SimpleArray< ON_Curve * > &tween_crvs)

RHINO_SDK_FUNCTION bool	RhinoTweenSurfacesSamplePoints (const ON_Surface srf0, const ON_Surface srf1, int num_of_tween_srfs, int num_of_sample_pts, double tol, ON_SimpleArray< ON_Surface * > &out_srfs)

void *	RHINOUI_DIB_CALLOC (size_t num, size_t size)

void	RHINOUI_DIB_FREE (void *memblock)

void *	RHINOUI_DIB_MALLOC (size_t size)

RHINO_SDK_FUNCTION HBITMAP	RhinoUiCopyHBitmap (HBITMAP hBitmapSrc)

RHINO_SDK_FUNCTION bool	RhinoUiDIBBltToDib (BITMAPINFO &bmi_target, LPBYTE dest_bits, long x_dest, long y_dest, long cx, long cy, BITMAPINFO &bmi_source, LPBYTE src_bits, long x_src, long y_src)

RHINO_SDK_FUNCTION int	RhinoUiDIBColorDepth (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION int	RhinoUiDIBColorDepth (const BITMAPINFOHEADER &bmih)

RHINO_SDK_FUNCTION LPBITMAPINFO	RhinoUiDIBCopy (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION LPBITMAPINFO	RhinoUiDIBCopyFromClipboard (HWND hwnd)

RHINO_SDK_FUNCTION bool	RhinoUiDIBCopyToClipboard (HWND hwnd, const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION HANDLE	RhinoUiDIBCopyToHandle (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION LPBITMAPINFO	RhinoUiDIBCreate (long width, long height, int color_depth)

RHINO_SDK_FUNCTION HBITMAP	RhinoUiDIBCreateHBitmap (const BITMAPINFO &bmi, HPALETTE hpal=nullptr)

RHINO_SDK_FUNCTION LPBYTE	RhinoUiDIBFindBits (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION bool	RhinoUiDIBGet256Palette (const BITMAPINFO &bmi, RGBQUAD *rgb)

RHINO_SDK_FUNCTION bool	RhinoUiDIBGetPixel (BITMAPINFO &bmi, const LPBYTE dib_bits, int c_depth, long x, long y, unsigned char r, unsigned char g, unsigned char b, unsigned char a=nullptr)

RHINO_SDK_FUNCTION bool	RhinoUiDIBGetPixel (BITMAPINFO &bmi, long x, long y, unsigned char r, unsigned char g, unsigned char b, unsigned char a=nullptr)

RHINO_SDK_FUNCTION bool	RhinoUiDIBGetPixel (BITMAPINFO &bmi, unsigned char base, long x, unsigned char r, unsigned char g, unsigned char b)

BITMAPINFO *	RhinoUiDIBHBitmapToDIB (HBITMAP hBitmap, HPALETTE hpal=nullptr)

RHINO_SDK_FUNCTION long	RhinoUiDIBHeight (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION long	RhinoUiDIBHeight (const BITMAPINFOHEADER &bmih)

void	RhinoUiDibInstallMemManager (void (my_calloc)(size_t num, size_t size), void (my_malloc)(size_t size), void(my_free)(void memblock))

RHINO_SDK_FUNCTION DWORD	RhinoUiDIBLineSize (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION DWORD	RhinoUiDIBLineSize (const BITMAPINFOHEADER &bmih)

RHINO_SDK_FUNCTION int	RhinoUiDIBNumColors (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION int	RhinoUiDIBNumColors (const BITMAPINFOHEADER &bmih)

RHINO_SDK_FUNCTION long	RhinoUiDIBPaletteSize (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION long	RhinoUiDIBPaletteSize (const BITMAPINFOHEADER &bmih)

RHINO_SDK_FUNCTION DWORD	RhinoUiDIBScanWidth (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION bool	RhinoUiDIBSet256IdentityPalette (BITMAPINFO &bmi, HPALETTE hpal)

RHINO_SDK_FUNCTION bool	RhinoUiDIBSet256PalColors (BITMAPINFO &bmi)

RHINO_SDK_FUNCTION bool	RhinoUiDIBSet256Palette (BITMAPINFO &bmi, RGBQUAD *rgb)

RHINO_SDK_FUNCTION bool	RhinoUiDIBSetPixel (BITMAPINFO &bmi, long x, long y, unsigned char r, unsigned char g, unsigned char b, unsigned char a)

RHINO_SDK_FUNCTION bool	RhinoUiDIBSetPixel (BITMAPINFO &bmi, LPBYTE dib_bits, int c_depth, long x, long y, unsigned char r, unsigned char g, unsigned char b, unsigned char a)

RHINO_SDK_FUNCTION DWORD	RhinoUiDIBSize (const BITMAPINFO bmi)

RHINO_SDK_FUNCTION DWORD	RhinoUiDIBSizeBits (const BITMAPINFO bmi)

RHINO_SDK_FUNCTION long	RhinoUiDIBWidth (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION long	RhinoUiDIBWidth (const BITMAPINFOHEADER &bmih)

RHINO_SDK_FUNCTION long	RhinoUiDIBXPixelsPerMeter (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION long	RhinoUiDIBXPixelsPerMeter (const BITMAPINFOHEADER &bmih)

RHINO_SDK_FUNCTION long	RhinoUiDIBYPixelsPerMeter (const BITMAPINFO &bmi)

RHINO_SDK_FUNCTION long	RhinoUiDIBYPixelsPerMeter (const BITMAPINFOHEADER &bmih)

RHINO_SDK_FUNCTION bool	RhinoUiSetDIBGray256Palette (BITMAPINFO &bmi, HPALETTE hpal, COLORREF base_color=RGB(0, 0, 255))

RHINO_SDK_FUNCTION ON_Mesh *	RhinoUnifyMeshNormals (const ON_Mesh &origmesh, ON_Mesh pNewMesh=0, bool bGetCountOnly=false, int pCount=0)

RHINO_SDK_FUNCTION bool	RhinoUnjoinEdges (const ON_Brep &InBrep, const ON_SimpleArray< int > &eids, ON_SimpleArray< ON_Brep * > &OutBreps)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoUnWeldMesh (const ON_Mesh &OldMesh, double angle_tol, bool ModifyNormals, ON_Mesh *pOutputMesh=0)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoUnWeldMesh (const ON_Mesh &OldMesh, double angle_tol, ON_Mesh *pOutputMesh=0)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoUnweldMeshEdge (const ON_Mesh &mesh, const ON_SimpleArray< int > &edges, bool bModifyNormal)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoUnWeldMeshVertexes (const ON_Mesh &input, ON_SimpleArray< int > indexes, bool ModifyNormals)

RHINO_SDK_FUNCTION bool	RhinoUpdateCachedTextureFromDib (unsigned int hTexture, const CRhinoDib &Dib)

RHINO_SDK_FUNCTION bool	RhinoUpdateCachedTextureFromFile (unsigned int hTexture, const ON_wString &Filename)

RHINO_SDK_FUNCTION CRhinoObject *	RhinoUpdateGripOwner (CRhinoObject old_object, bool bCopyObject, ON_2dexMap group_remap)

RHINO_SDK_FUNCTION void	RhinoUpdateObjectGroups (CRhinoObject *new_object, ON_2dexMap &group_map)

RHINO_SDK_FUNCTION void	RhinoUpdateObjectGroups (CRhinoObjectAttributes &attributes, ON_2dexMap &group_map)

RHINO_SDK_FUNCTION void	RhinoUuidToString (const UUID &uuid, char s[37])

RHINO_SDK_FUNCTION void	RhinoUuidToString (const UUID &uuid, wchar_t s[37])

RHINO_SDK_FUNCTION ON_Surface *	RhinoVariableOffsetSurface (const ON_Surface &InputSrf, const double corner_dists[2][2], const ON_SimpleArray< ON_2dPoint > &uv, const ON_SimpleArray< double > &dists, double tolerance)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoWeldMesh (const ON_Mesh &MeshIn, double angle_tol, ON_Mesh *pMeshOut=0)

RHINO_SDK_FUNCTION ON_Mesh *	RhinoWeldMeshEdges (const ON_Mesh &mesh, const ON_SimpleArray< int > &edges)

RHINO_SDK_FUNCTION bool	RhinoWriteHatchPatternFile (const wchar_t *filename, const ON_ObjectArray< ON_HatchPattern > &patterns)

RHINO_SDK_FUNCTION RhinoYesNoResponse	RhinoYesNoMessageBox (const wchar_t lpsText, const wchar_t lpsCaption=nullptr, int nIncludeButtons=1\|4, UINT nMessageBoxTypeCodes=MB_ICONQUESTION\|MB_DEFBUTTON1)

RHINO_SDK_FUNCTION RhinoYesNoResponse	RhinoYesNoMessageBox (HWND hWndParent, const wchar_t lpsText, const wchar_t lpsCaption=nullptr, int nIncludeButtons=1\|4, UINT nMessageBoxTypeCodes=MB_ICONQUESTION\|MB_DEFBUTTON1)

int	RhMaxIntSnapCandidateCount ()

RHINO_SDK_FUNCTION bool	RhPlanarRegionBoolean (const ON_SimpleArray< const ON_Brep * > &InRegions, const ON_Plane &plane, double tolerance, ON_SimpleArray< ON_Brep * > &OutRegions, ON_SimpleArray< bool > *pbRev=nullptr)

RHINO_SDK_FUNCTION bool	RhPlanarRegionDifference (const ON_Brep B0, const ON_Brep B1, const ON_Plane &plane, double tolerance, ON_SimpleArray< ON_Brep * > &OutRegions)

RHINO_SDK_FUNCTION bool	RhPlanarRegionIntersection (const ON_Brep B0, const ON_Brep B1, const ON_Plane &plane, double tolerance, ON_SimpleArray< ON_Brep * > &OutRegions)

RHINO_SDK_FUNCTION bool	RhPlanarRegionUnion (const ON_Brep B0, const ON_Brep B1, const ON_Plane &plane, double tolerance, ON_SimpleArray< ON_Brep * > &OutRegions)

RHINO_SDK_FUNCTION bool	RhPlanarRegionUnion (const ON_SimpleArray< const ON_Brep * > &InRegions, const ON_Plane &plane, double tolerance, ON_SimpleArray< ON_Brep * > &OutRegions)

RHINO_SDK_FUNCTION void	RhResetAllMessageBoxes ()

RHINO_SDK_FUNCTION bool	UnregisterDisplayPipeline (const ON_ClassId *)

Variables
const ON_SimpleArray< const CRhinoBrepObject * > const ON_Plane ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > double double	angTolerance

const ON_SimpleArray< const CRhinoBrepObject * > &	brepObjects

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Brep &	brepSplitter

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Plane ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > double	distTolerance = ON_UNSET_VALUE

const typedef RECT *	LPCRECT

const typedef char *	LPCSTR

const typedef wchar_t *	LPCTSTR

const typedef wchar_t *	LPCWSTR

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Brep const ON_Plane ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > *	pBackgroundCurves = nullptr

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Brep const ON_Plane ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > *	pBackgroundHiddenCurves = nullptr

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Brep const ON_Plane ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > *	pForegroundCurves = nullptr

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Brep const ON_Plane ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > *	pForegroundHiddenCurves = nullptr

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Plane ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > *	pProjectedHiddenCurves = nullptr

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Plane ON_SimpleArray< CRhinoCurveObject * > &	projectedCurves

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Plane &	projectionPlane

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Brep const ON_Plane ON_SimpleArray< CRhinoCurveObject * > *	pSectionCurves = nullptr

static const ON_UUID	RHINO_CURVATURE_COLOR_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_CURVATURE_GRAPH_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_DIRECTION_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_DRAFT_ANGLE_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_EDGE_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_EDGE_CONTINUITY_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_EMAP_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_END_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_FALSECOLOR_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_SECTION_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_SHADED_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_TEXTURED_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_THICKNESS_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_WIREFRAME_ANALYSIS_MODE_ID

static const ON_UUID	RHINO_ZEBRA_STRIPE_ANALYSIS_MODE_ID

Detailed Description

Macro Definition Documentation

◆ _CRT_SECURE_NO_DEPRECATE

#define _CRT_SECURE_NO_DEPRECATE

This file should be the first header file included in your plug-in's stdafx.h.

◆ _WIN32_IE

#define _WIN32_IE RHINO_IE_VERSION

◆ _WIN32_WINDOWS

#define _WIN32_WINDOWS _WIN32_WINNT

◆ _WIN32_WINNT

#define _WIN32_WINNT RHINO_WINVER

Allow third party plug-ins to require later versions of the Windows Platform SDK.

◆ CONST

#define CONST const

Define some Windows types and structures.

rhinoSdkMacTypes.h TestMacCPPPlugin

Created by Andrew Le Bihan on 31.10.2024.

◆ CRhinoPickList

#define CRhinoPickList CRhinoObjRefArray

obsolete symbol - use CRhinoObjRefArray

◆ DECLARE_DYNAMIC_PIPELINE

#define DECLARE_DYNAMIC_PIPELINE ( class_name )

Value:

private:\
  ON_OBJECT_DECLARE( class_name );\
public: \
  static bool     m_bRegistered##class_name; \
  static ON_UUID  m_Uuid##class_name;\
  static ON_UUID  Uuid(void);\
  virtual bool    IsRegistered(void);

◆ DECLARE_PIPELINE_ATTRIBUTE_CLASS

#define DECLARE_PIPELINE_ATTRIBUTE_CLASS ON_UUID ClassId() const override;

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer.

◆ ERROR_ACCESS_DENIED

#define ERROR_ACCESS_DENIED 5L

◆ ERROR_FILE_NOT_FOUND

#define ERROR_FILE_NOT_FOUND 2L

◆ ERROR_INVALID_DATA

#define ERROR_INVALID_DATA 13L

◆ ERROR_INVALID_FUNCTION

#define ERROR_INVALID_FUNCTION 1L

◆ ERROR_INVALID_PIXEL_FORMAT

#define ERROR_INVALID_PIXEL_FORMAT -23347

◆ ERROR_MOD_NOT_FOUND

#define ERROR_MOD_NOT_FOUND -23345

fake error numbers

◆ ERROR_MORE_DATA

#define ERROR_MORE_DATA 234L

◆ ERROR_NO_MORE_ITEMS

#define ERROR_NO_MORE_ITEMS 259L

◆ ERROR_PROC_NOT_FOUND

#define ERROR_PROC_NOT_FOUND -23346

◆ ERROR_SUCCESS

#define ERROR_SUCCESS 0L

◆ GetAValue

#define GetAValue ( c ) ((c).Alpha())

◆ GetBValue

#define GetBValue ( c ) ((c).Blue())

◆ GetGValue

#define GetGValue ( c ) ((c).Green())

◆ GetRValue

#define GetRValue ( c ) ((c).Red())

◆ HIBYTE

#define HIBYTE ( w ) ((BYTE)((((DWORD_PTR)(w)) >> 8) & 0xff))

◆ IMPLEMENT_DYNAMIC_PIPELINE

#define IMPLEMENT_DYNAMIC_PIPELINE	(	class_name,
		base_name,
		description,
		uuid,
		bwire,
		bshade
	)

Value:

  ON_OBJECT_IMPLEMENT_NO_COPY( class_name, base_name, uuid );\
  ON_UUID   class_name::m_Uuid##class_name = ::ON_UuidFromString( uuid );\
  bool      class_name::m_bRegistered##class_name = ::RegisterDisplayPipeline(&ON_CLASS_RTTI(class_name),\
                                                                              class_name::m_Uuid##class_name,\
                                                                              description,\
                                                                              bwire, bshade); \
  ON_UUID   class_name::Uuid(void) { return class_name::m_Uuid##class_name; }\
  bool      class_name::IsRegistered(void) { return class_name::m_bRegistered##class_name; }

◆ LOBYTE

#define LOBYTE ( w ) ((BYTE)(((DWORD_PTR)(w)) & 0xff))

◆ MAC_DEPRECATED

#define MAC_DEPRECATED

OBSOLETE in Rhino 8.x and later ///< #define RHINO_V8SR 0.

Use MAC_DEPRECATED to decorate functions that should not be used in Rhino for Mac

◆ MB_APPLMODAL

#define MB_APPLMODAL 0x00000000L

◆ MB_DEFAULT_DESKTOP_ONLY

#define MB_DEFAULT_DESKTOP_ONLY 0x00020000L

◆ MB_DEFBUTTON1

#define MB_DEFBUTTON1 0x00000000L

◆ MB_DEFBUTTON2

#define MB_DEFBUTTON2 0x00000100L

◆ MB_DEFBUTTON3

#define MB_DEFBUTTON3 0x00000200L

◆ MB_DEFMASK

#define MB_DEFMASK 0x00000F00L

◆ MB_HELP

#define MB_HELP 0x00004000L

Help Button.

◆ MB_ICONASTERISK

#define MB_ICONASTERISK 0x00000040L

◆ MB_ICONERROR

#define MB_ICONERROR MB_ICONHAND

◆ MB_ICONEXCLAMATION

#define MB_ICONEXCLAMATION 0x00000030L

◆ MB_ICONHAND

#define MB_ICONHAND 0x00000010L

◆ MB_ICONINFORMATION

#define MB_ICONINFORMATION MB_ICONASTERISK

◆ MB_ICONMASK

#define MB_ICONMASK 0x000000F0L

◆ MB_ICONQUESTION

#define MB_ICONQUESTION 0x00000020L

◆ MB_ICONSTOP

#define MB_ICONSTOP MB_ICONHAND

◆ MB_ICONWARNING

#define MB_ICONWARNING MB_ICONEXCLAMATION

◆ MB_MISCMASK

#define MB_MISCMASK 0x0000C000L

◆ MB_MODEMASK

#define MB_MODEMASK 0x00003000L

◆ MB_NOFOCUS

#define MB_NOFOCUS 0x00008000L

◆ MB_RIGHT

#define MB_RIGHT 0x00080000L

◆ MB_RTLREADING

#define MB_RTLREADING 0x00100000L

◆ MB_SERVICE_NOTIFICATION

#define MB_SERVICE_NOTIFICATION 0x00200000L

◆ MB_SERVICE_NOTIFICATION_NT3X

#define MB_SERVICE_NOTIFICATION_NT3X 0x00040000L

◆ MB_SETFOREGROUND

#define MB_SETFOREGROUND 0x00010000L

◆ MB_SYSTEMMODAL

#define MB_SYSTEMMODAL 0x00001000L

◆ MB_TASKMODAL

#define MB_TASKMODAL 0x00002000L

◆ MB_TOPMOST

#define MB_TOPMOST 0x00040000L

◆ MB_TYPEMASK

#define MB_TYPEMASK 0x0000000FL

◆ MB_USERICON

#define MB_USERICON 0x00000080L

◆ MF_BYCOMMAND

#define MF_BYCOMMAND 0x00000000L

◆ MF_BYPOSITION

#define MF_BYPOSITION 0x00000000L

◆ MF_CHECKED

#define MF_CHECKED 0x00000008L

◆ MF_SEPARATOR

#define MF_SEPARATOR 0x00000800L

◆ MF_STRING

#define MF_STRING 0x00000000L

◆ MF_UNCHECKED

#define MF_UNCHECKED 0x00000000L

◆ NTDDI_VERSION

#define NTDDI_VERSION RHINO_NTDDI_VERSION

◆ OPENNURBS_IMPORTS [1/2]

#define OPENNURBS_IMPORTS

NEVER INCLUDE FILES FROM CORE RHINO IN ANY SDK/inc/rhinoSDK*.h file

◆ OPENNURBS_IMPORTS [2/2]

#define OPENNURBS_IMPORTS

release build

The disallowlib lines prevent embedded linking instructions in 3rd party object code from bringing in the wrong C runtime or MFC libraries. The linking instructions are commonly found in statically linked .lib files that were compiled with something besides Visual C++ 8 (Visual Studio 2005) or were compiled with the wrong "Code Generation setting".

For more details, see the McNeel developer CRunTimeTrauma Wiki page. Release Rhino and all 3rd party plug-ins use

Code Generation flag /MD msvcr80.dll (Multithreaded CRT) mfc80u.dll (Unicode MFC)

Debug Rhino and system debug plug-ins use Code Generation flag /MDd msvcr80d.dll (Multithreaded debug CRT) mfc80ud.dll (Unicode debug MFC) No static CRT libs NO STATIC MFC LIBRARES NO MFC 7.1 (Visual Studio 7 / 2003 libraries ) No MFC 4.2 (Visual Studio 4,5,6 libraries ) defining _INC_CRTDBG. if defined(_INC_CRTDBG) error Never include CRTDBG.H in Rhino or Rhino plug-ins. endif define _INC_CRTDBG Force DEBUG_NEW to be the real "new". If you get a compile error here, it's because somewhere DEBUG_NEW is defined to be something besides "new". You need to find out why and change your compile flags, includes, etc., so that DEBUG_NEW is not defined or defined to be "new".

◆ OPENNURBS_VERSION_DEFINITION

#define OPENNURBS_VERSION_DEFINITION

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. The static member functions on RhinoVersion class provide runtime access to Rhinoceros application version information. In most cases, you should use those functions when you need to know version information about the Rhino application this is running.

In some rare case that you actually need the C++ prerpocessor defines for this version information.

If you clearly understand why you are in a special case and you want to include this thoughtfully and diliberately use the C++ defines rather than the RhinoVersion functions, then you must define RHINO__SDK__VERSION__DEFINITION__ before including this file.

If you are confused or frustrated, please ask for help. Todo - move the following defines to a file that is rarely included to eliminate the need to recompile 1000's of files when the build system updates the year, month, day, hour, minute values and other build version information that depend on these defined values.

◆ PS_ALTERNATE

#define PS_ALTERNATE 8

◆ PS_COSMETIC

#define PS_COSMETIC 0x00000000

◆ PS_DASH

#define PS_DASH 1 /* ------- */

◆ PS_DASHDOT

#define PS_DASHDOT 3 /* _._._._ */

◆ PS_DASHDOTDOT

#define PS_DASHDOTDOT 4 /* _.._.._ */

◆ PS_DOT

#define PS_DOT 2 /* ....... */

◆ PS_ENDCAP_FLAT

#define PS_ENDCAP_FLAT 0x00000200

◆ PS_ENDCAP_ROUND

#define PS_ENDCAP_ROUND 0x00000000

◆ PS_ENDCAP_SQUARE

#define PS_ENDCAP_SQUARE 0x00000100

◆ PS_ENDCAP_STYLE

#define PS_ENDCAP_STYLE 0x00000F00

◆ PS_GEOMETRIC

#define PS_GEOMETRIC 0x00010000

◆ PS_INSIDEFRAME

#define PS_INSIDEFRAME 6

◆ PS_JOIN_BEVEL

#define PS_JOIN_BEVEL 0x00001000

◆ PS_JOIN_MITER

#define PS_JOIN_MITER 0x00002000

◆ PS_JOIN_ROUND

#define PS_JOIN_ROUND 0x00000000

◆ PS_JOIN_STYLE

#define PS_JOIN_STYLE 0x0000F000

◆ PS_NULL

#define PS_NULL 5

◆ PS_SOLID

#define PS_SOLID 0

Pen Styles

◆ PS_USERSTYLE

#define PS_USERSTYLE 7

◆ REGISTER_PIPELINE_ATTRIBUTE_CLASS

#define REGISTER_PIPELINE_ATTRIBUTE_CLASS	(	className,
		classId
	)

Value:

static class className##RegistrationHelper\
{   public: className##RegistrationHelper()\
    {       class Factory : public CDisplayPipelineAttributes::Factory\
        {   virtual ON_UUID ClassId() const { return classId; }\
            virtual CDisplayPipelineAttributes* NewObject() const { return new className; } };\
		CDisplayPipelineAttributes::Factory::Register(std::make_unique<Factory>());}\
} g_the##className##RegistrationHelper;\
UUID className::ClassId() const { return classId; }

◆ RGB

#define RGB	(	r,
		g,
		b
	)	(ON_Color(r,g,b))

◆ RGBA

#define RGBA	(	r,
		g,
		b,
		a
	)	(ON_Color(r,g,b,a))

◆ RHCMDOPTNAME

#define RHCMDOPTNAME ( s ) CRhinoCommandOptionName(s,s)

◆ RHCMDOPTVALUE

#define RHCMDOPTVALUE ( s ) CRhinoCommandOptionValue(s,s)

◆ RHINO_6_OR_LATER

#define RHINO_6_OR_LATER

This define may be used in code that needs to know which version of Rhino is being built but wants to avoid including rhinoSdkVersion.h to limit the number of files that are compiled when the build system increments the version numbers.

◆ RHINO_7_OR_LATER

#define RHINO_7_OR_LATER

◆ RHINO_8_OR_LATER

#define RHINO_8_OR_LATER

◆ RHINOSDKVERSIONDEFINITION

#define RHINO__SDK__VERSION__DEFINITION__

This header file defines RHINO_PLUG_IN_DECLARE for plug-ins. Rhino plugins can include this file in exactly one .cpp rather than in stdafx.h if they want to minimize the amount of recompiling that is required when the version numbers are updated.

For plug-ins that use an installed Rhino SDK, this isn't an issue.
For Rhino plug-ins that compile against the core Rhino source code, this is an issue and using rhinoSdkPlugInDeclare.h substantually reduces the amount of recompiling that is required when a developer updates source code.

◆ RHINO_CLAMP

#define RHINO_CLAMP	(	V,
		L,
		H
	)	( (V) < (L) ? (L) : ( (V) > (H) ? (H) : (V) ) )

Description: Returns V, clamped to lie between L & H, Make L <= V <= H Parameters: V [in] value to be clamped L [in] low bound H [in] high bound

◆ RHINO_CLAMP_UI_SUBD_DISPLAY_DENSITY

#define RHINO_CLAMP_UI_SUBD_DISPLAY_DENSITY ( D ) (D < ON_SubDDisplayParameters::MinimumUserInterfaceDensity ? ON_SubDDisplayParameters::MinimumUserInterfaceDensity : (D > ON_SubDDisplayParameters::MaximumUserInterfaceDensity ? ON_SubDDisplayParameters::MaximumUserInterfaceDensity : D))

◆ RHINO_COMPONENT_INDEX

#define RHINO_COMPONENT_INDEX OBSOLETE__USE__ON_COMPONENT_INDEX

RHINO_COMPONENT_INDEX is OBSOLETE as of 9/30/2004 - user ON_COMPONENT_INDEX.

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer.

◆ RHINO_CURRENT_FILE_VERSION_NUMBER

#define RHINO_CURRENT_FILE_VERSION_NUMBER (OPENNURBS_CURRENT_ARCHIVE_VERSION/10)

.3dm file version

Early in the WIP cycle, Rhino writes files that can be read by the current commercial version of Rhino. At some point during the WIP cycle, the WIP product switches to writing files that will only be read by the WIP and the next commercial version.

◆ RHINO_IE_VERSION

#define RHINO_IE_VERSION 0x0700

Visual Studio 2012 and 2013's afxwin.h forces _WIN32_IE to be 0x0700 (We cannot require IE 8.0 while using VS 2012 or 2013.)

◆ RHINO_NOEXCEPT

#define RHINO_NOEXCEPT ON_NOEXCEPT

#define RHINO_9_OR_LATER

Ideally, RHINO_NOEXCEPT would be the C++11 "noexcept" specifier. Less than ideally, Visual Studio 2012 does not support "noexcept" and we use the, almost, equivalent "throw()". The key point being that it is important to indicate at compile time that a function, especially constructor and operator=, does not throw exceptions.

◆ RHINO_NTDDI_VERSION

#define RHINO_NTDDI_VERSION 0x06010000

◆ RHINO_PLUG_IN_DECLARE [1/2]

#define RHINO_PLUG_IN_DECLARE

Value:

extern "C" RHINO_SDK_EXPORT unsigned int RhinoPlugInSdkVersion(void) {return RHINO_SDK_VERSION;} \

extern "C" RHINO_SDK_EXPORT unsigned int RhinoPlugInSdkServiceRelease(void) { return RHINO_SDK_SERVICE_RELEASE;}

◆ RHINO_PLUG_IN_DECLARE [2/2]

#define RHINO_PLUG_IN_DECLARE #error include .../SDK/inc/rhinoSdkPlugInDeclare.h in the .cpp file where you are seeing this error.

A Rhino plug-in is being compiled - import Rhino SDK symbols.

<RHINO SDK_MFC If you get this error, then include .../SDK/inc/rhinoSdkPlugInDeclare.h on the line immediately before the line that has RHINO_PLUG_IN_DECLARE

The definition of RHINO_PLUG_IN_DECLARE depends on values defined in rhinoSdkVersion.h that are frequently changed by the build system.
Using rhinoSdkPlugInDeclare.h to define RHINO_PLUG_IN_DECLARE dramatically reduces the amount of code developers have to build when this version information is updated.

◆ RHINO_PLUG_IN_DECLARE_IS_ERROR

#define RHINO_PLUG_IN_DECLARE_IS_ERROR

◆ RHINO_PLUG_IN_DEPENDENCIES

#define RHINO_PLUG_IN_DEPENDENCIES ( sIdList ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDependencies(void) {return sIdList;}

If your plug-in requires other plug-ins to be loaded before, it can be loaded, then include the macro RHINO_PLUG_IN_DEPENDENCIES(L"id1") where id1 is the id of the plug-in that must be loaded first. If you require multiple plug-ins to be loaded, use commas to delimit the ids RHINO_PLUG_IN_DEPENDENCIES(L"id1,id2"). The id should have the format be in the standard format, i.e. RHINO_PLUG_IN_DEPENDENCIES(L"14D4C6C1-F5FD-4ee4-B2C0-FC7B6CEDF22D") In general, using plug-in dependencies is strongly discouraged. Use properly designed and installed DLLs instead.

◆ RHINO_PLUG_IN_DESCRIPTION

#define RHINO_PLUG_IN_DESCRIPTION ( sPlugInDescription ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDescription(void) { return sPlugInDescription; }

If you want your plug-in to provide a friendly description for use in various user interfaces, both inside and outside of Rhino, then include the RHINO_PLUG_IN_DESCRIPTION macro and specify the resource id of your plug-in's description.

◆ RHINO_PLUG_IN_DEVELOPER_ADDRESS

#define RHINO_PLUG_IN_DEVELOPER_ADDRESS ( sDeveloperAddress ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperAddress(void) {return sDeveloperAddress;}

◆ RHINO_PLUG_IN_DEVELOPER_COUNTRY

#define RHINO_PLUG_IN_DEVELOPER_COUNTRY ( sDeveloperCountry ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperCountry(void) {return sDeveloperCountry;}

◆ RHINO_PLUG_IN_DEVELOPER_EMAIL

#define RHINO_PLUG_IN_DEVELOPER_EMAIL ( sDeveloperEmail ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperEmail(void) {return sDeveloperEmail;}

◆ RHINO_PLUG_IN_DEVELOPER_FAX

#define RHINO_PLUG_IN_DEVELOPER_FAX ( sDeveloperFax ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperFax(void) {return sDeveloperFax;}

◆ RHINO_PLUG_IN_DEVELOPER_ORGANIZATION

#define RHINO_PLUG_IN_DEVELOPER_ORGANIZATION ( sDeveloperOrganization ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperOrganization(void) {return sDeveloperOrganization;}

◆ RHINO_PLUG_IN_DEVELOPER_PHONE

#define RHINO_PLUG_IN_DEVELOPER_PHONE ( sDeveloperPhone ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperPhone(void) {return sDeveloperPhone;}

◆ RHINO_PLUG_IN_DEVELOPER_WEBSITE

#define RHINO_PLUG_IN_DEVELOPER_WEBSITE ( sDeveloperWebsite ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInDeveloperWebsite(void) {return sDeveloperWebsite;}

◆ RHINO_PLUG_IN_ICON_RESOURCE_ID

#define RHINO_PLUG_IN_ICON_RESOURCE_ID ( nIconResourceId ) extern "C" RHINO_SDK_EXPORT unsigned int RhinoPlugInIconResourceId(void) { return nIconResourceId; }

If you want your plug-in to provide an icon for use in various user interfaces, both inside and outside of Rhino, then include the RHINO_PLUG_IN_ICON_RESOURCE_ID macro and specify the resource id of your plug-in's icon. For example: RHINO_PLUG_IN_ICON_RESOURCE_ID(IDI_MY_PLUGIN_ICON)

◆ RHINO_PLUG_IN_ID

#define RHINO_PLUG_IN_ID ( sPlugInId ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInId(void) {return sPlugInId;}

◆ RHINO_PLUG_IN_NAME

#define RHINO_PLUG_IN_NAME ( sPlugInName ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInName(void) {return sPlugInName;}

If you want to use a .rhi automagical installer file, then your plug-in must contain extern "C" const wchar_t* RhinoPlugInName() and a ON_UUID RhinoPlugInId() functions. The argument to the RHINO_PLUG_IN_ID() macro is a uuid in standard Windows string format; e.g., RHINO_PLUG_IN_ID(L"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX")

◆ RHINO_PLUG_IN_UPDATE_URL

#define RHINO_PLUG_IN_UPDATE_URL ( sUpdatePlugInURL ) extern "C" RHINO_SDK_EXPORT const wchar_t* RhinoPlugInUpdateURL(void) {return sUpdatePlugInURL;}

◆ RHINO_PLUG_IN_VERSION

#define RHINO_PLUG_IN_VERSION ( sPlugInVersion ) extern "C" RHINO_SDK_EXPORT const char* RhinoPlugInVersion(void) {return sPlugInVersion;}

Note, this macro returns const char* in order to support the standard predefined DATE and TIME macros.

◆ RHINO_PLUGIN_COMPILE

#define RHINO_PLUGIN_COMPILE

When the core Rhino executable is being compiled, RHINO_SDK_CLASS is defined in Rhino's stdafx.h as __declspec(dllexport).
If RHINO_SDK_CLASS is not defined, then it means a Rhino plug-in is being compiled.

◆ RHINO_PREPROC_STRINGIZE

#define RHINO_PREPROC_STRINGIZE ( s ) RHINO_PREPROC_STRINGIZE_HELPER(s)

#pragma once

Do not put a #pragma once in this header file. It is intentionally included multiple times to insure key defines are not changed. These macros are used with #pragma message to print diagnostic messgages that show the values of #define macros. Usage #define RHINO_VAR = 42 ... #pragma message( "RHINO_VAR = " RHINO_PREPROC_STRINGIZE(RHINO_VAR) ) will print "RHINO_VAR = 42" in the compiler's output log.

◆ RHINO_PREPROC_STRINGIZE_HELPER

#define RHINO_PREPROC_STRINGIZE_HELPER ( s ) #s

◆ RHINO_REGISTRY_ROOT_STRING

#define RHINO_REGISTRY_ROOT_STRING "McNeel\\Rhinoceros\\" RMA_VERSION_NUMBER_MAJOR_STRING ".0"

◆ RHINO_REGISTRY_ROOT_WSTRING

#define RHINO_REGISTRY_ROOT_WSTRING L"McNeel\\Rhinoceros\\" RMA_VERSION_NUMBER_MAJOR_WSTRING ".0"

◆ RHINO_SDK_CHECKSLINKERINSTRUCTIONS__

#define RHINO_SDK_CHECKS__LINKER__INSTRUCTIONS__

These checks are very specific to Windows Rhino.

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. DO NOT USE define TO PROTECT THIS FILE AGAINST MULTIPLE INCLUDES. DO NOT PUT A #pragma once IN THIS FILE. This file checks that compile time defines are correctly set. If something incorrect is defined, it will call #error. #error Exactly one of WIN32 or WIN64 should be defined. If you are getting this error, then you are using the wrong brand of C++ compiler. Rhino application developers muse use use Microsoft Visual Studio 2012. If you are getting this error, then you are using the wrong version of the Microsoft C++ compiler. Rhino 6 application developers muse use use Microsoft Visual Studio 2012 (Microsoft Visual Studio 11.0). Validate Windows version defines MBCS/UNICODE define house keeping for plug-in developers

◆ RHINO_SDK_CLASS

#define RHINO_SDK_CLASS __attribute__ ((visibility ("default")))

◆ RHINO_SDK_DATA

#define RHINO_SDK_DATA __attribute__ ((visibility ("default")))

◆ RHINO_SDK_EXPORT

#define RHINO_SDK_EXPORT __attribute__ ((visibility ("default")))

◆ RHINO_SDK_FUNCTION

#define RHINO_SDK_FUNCTION __attribute__ ((visibility ("default")))

◆ RHINO_SDK_HINCLUDED

#define RHINO_SDK_H__INCLUDED__

3rd party Rhino SDK plug-in developer path to openNURBS tools

3rd party Rhino SDK plug-in developer path to rhino_wip.h

◆ RHINO_SDK_H_IN_PROGRESS_

#define RHINO_SDK_H_IN_PROGRESS_

the following line must be the first line in this file that is not a comment

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. 7 June 2004 DO NOT USE //// pragma once It is important that this file be included multiple times in order for the checking to happen at the right places. Please do not put pragma once in this file. Ask Dale Lear if you have questions.

◆ RHINO_SDK_LINUX_VERSION

#define RHINO_SDK_LINUX_VERSION RHINO_SDK_SERVICE_RELEASE

◆ RHINO_SDK_OSX_VERSION

#define RHINO_SDK_OSX_VERSION RHINO_SDK_SERVICE_RELEASE

Apple OS X SDK version number When the Rhino SDK is frozen, this number will be hard coded. Until then, it will increase each time the build system increments the build version numbers.

◆ RHINO_SDK_PLUG_IND_DECLARE_INC_

#define RHINO_SDK_PLUG_IND_DECLARE_INC_

◆ RHINO_SDK_SERVICE_RELEASE

#define RHINO_SDK_SERVICE_RELEASE RHINO_VERSION_NUMBER

Use RhinoApp().SdkServiceReleaseVersion() to get the value of RHINO_SDK_SERVICE_RELEASE.

RHINO_VERSION_NUMBER is defined in rhinoSdkRhinoVersion.h and is automatically set by the build system. Do not hard code this value. RHINO_SDK_SERVICE_RELEASE must increase so SDK addtions work as expected. Plug-ins that are built with an "updated SDK" will required a host Rhino that is the same or more recent than the "updated SDK".

◆ RHINO_SDK_STDAFX_PREAMBLE_H__

#define RHINO_SDK_STDAFX_PREAMBLE_H__

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer.

◆ RHINO_SDK_TEMPLATE

#define RHINO_SDK_TEMPLATE __attribute__ ((visibility ("default")))

◆ RHINO_SDK_WINDOWS_VERSION

#define RHINO_SDK_WINDOWS_VERSION ON_VERSION_NUMBER_CTOR(6, 0, 2017, 8, 15, 1 )

SDK is frozen when the definition of RHINO_SDK_WINDOWS_VERSION is a hardcoded number.

Windows SDK version number. When the Rhino SDK is frozen, this number will be hard coded. Until then, it will increase each time the build system increments the build version numbers. The Rhino Windows C++ SDK is currently "frozen" at Rhino 6.0 2017 August 14.

NOTE WELL: It is intentional that the values of RHINO_SDK_WINDOWS_VERSION for Rhino 6, 7 and 8 are identical.

The Rhino 7 and 8 SDK is an extended version of the Rhino 6 SDK. Rhino 7 and 8 load Rhino 6.* plug-ins. Thus, the Rhino 6, 7, and 8 have identical values for RHINO_SDK_WINDOWS_VERSION. Use RHINO_SDK_SERVICE_RELEASE to determine which extension of the basic SDK is being used.

There is not a public Apple OSX C++ SDK. Rhino for Mac C++ plug-ins are built and distributed by McNeel and the version numbers for those plug-ins are handled in a different manner.

◆ RHINO_SDK_WINVER_H_INCLUDED_

#define RHINO_SDK_WINVER_H_INCLUDED_

Please discuss any changes to this file with Dale Lear.

◆ RHINO_VERSION_BRANCH

#define RHINO_VERSION_BRANCH OPENNURBS_VERSION_BRANCH

RHINO_VERSION_BRANCH 0: developer build 1: Windows Commercial build 2: Mac Commercial build 3: Windows BETA build 4: Mac Beta build 5: Windows WIP build 6: Mac WIP build

◆ RHINO_VERSION_DAY_OF_MONTH

#define RHINO_VERSION_DAY_OF_MONTH OPENNURBS_VERSION_DAY_OF_MONTH

◆ RHINO_VERSION_HOUR

#define RHINO_VERSION_HOUR OPENNURBS_VERSION_HOUR

◆ RHINO_VERSION_MAJOR

#define RHINO_VERSION_MAJOR OPENNURBS_VERSION_MAJOR

Public SDK path to opennurbs_version.h.

"major" will be 6 for all versions of Rhinoceros 6

◆ RHINO_VERSION_MINOR

#define RHINO_VERSION_MINOR OPENNURBS_VERSION_MINOR

"minor" corresponds to the Rhinoceros 6 service release number

◆ RHINO_VERSION_MINUTE

#define RHINO_VERSION_MINUTE OPENNURBS_VERSION_MINUTE

◆ RHINO_VERSION_MONTH

#define RHINO_VERSION_MONTH OPENNURBS_VERSION_MONTH

◆ RHINO_VERSION_NUMBER

#define RHINO_VERSION_NUMBER

Value:

          ON_VERSION_NUMBER_CTOR( \
          RHINO_VERSION_MAJOR, RHINO_VERSION_MINOR, \
          RHINO_VERSION_YEAR, RHINO_VERSION_MONTH, RHINO_VERSION_DAY_OF_MONTH, \
          RHINO_VERSION_BRANCH )

◆ RHINO_VERSION_NUMBER_MAJOR_STRING

#define RHINO_VERSION_NUMBER_MAJOR_STRING RMA_VERSION_NUMBER_MAJOR_STRING

◆ RHINO_VERSION_NUMBER_MAJOR_WSTRING

#define RHINO_VERSION_NUMBER_MAJOR_WSTRING RMA_VERSION_NUMBER_MAJOR_WSTRING

◆ RHINO_VERSION_NUMBER_SR_STRING

#define RHINO_VERSION_NUMBER_SR_STRING RMA_VERSION_NUMBER_SR_STRING

◆ RHINO_VERSION_NUMBER_SR_WSTRING

#define RHINO_VERSION_NUMBER_SR_WSTRING RMA_VERSION_NUMBER_SR_WSTRING

◆ RHINO_VERSION_NUMBER_STRING

#define RHINO_VERSION_NUMBER_STRING RMA_VERSION_WITH_PERIODS_STRING

◆ RHINO_VERSION_NUMBER_WITH_COMMAS

#define RHINO_VERSION_NUMBER_WITH_COMMAS VERSION_WITH_COMMAS

Four integers separated by commas - useful for getting the version quartet values as unsigned int or int.

◆ RHINO_VERSION_NUMBER_WSTRING

#define RHINO_VERSION_NUMBER_WSTRING RMA_VERSION_WITH_PERIODS_WSTRING

◆ RHINO_VERSION_YEAR

#define RHINO_VERSION_YEAR OPENNURBS_VERSION_YEAR

◆ RHINO_WINDOWS_REGISTRY_SVN_BRANCH

#define RHINO_WINDOWS_REGISTRY_SVN_BRANCH L"trunk"

The value of RHINO_WINDOWS_REGISTRY_SVN_BRANCH is used to build registry paths that require the name of the source code branch. Runtime code validates that it is set correctly. It must be hard coded because it is used in public and internal debug and release builds.

◆ RHINO_WINVER

#define RHINO_WINVER 0x0601

21 March 2012 Dale Lear: Windows 7 is the minimum Windows OS that Rhino 6 will run on. If you get a compile error or warning in this file, it is a serious problem. These values MUST be used by any code that McNeel ships with Rhino. This includes all code that gets linked into Rhino.exe and ALL code that gets linked into any plug-in that McNeel ships with Rhino. Minimum Windows platform = Windows 7 with IE 7.0 See http://msdn.microsoft.com/en-us/library/aa383745(v=vs.85).aspx#setting_winver_or__win32_winnt Note: The first 4 digits of RHINO_NTDDI_VERSION must match the value of RHINO_WINVER.

◆ RHINOCEROS_APP_NAME_STRING

#define RHINOCEROS_APP_NAME_STRING "Rhinoceros " RMA_VERSION_NUMBER_MAJOR_STRING

char strings

Rhinoceros version numbers as strings

Whenever you need a string that has a 6 that will need to be changed to a 7 in the Rhino V7 code, use these macros. You can use string concatenation for strings that are not explicitly defined. Example: L"Rhinoceros " RHINO_VERSION_NUMBER_MAJOR_WSTRING L" " RHINO_VERSION_NUMBER_SR_STRING is the same as L"Rhinoceros 6 SR2"

◆ RHINOCEROS_APP_NAME_WSTRING

#define RHINOCEROS_APP_NAME_WSTRING L"Rhinoceros " RMA_VERSION_NUMBER_MAJOR_WSTRING

wchar_t strings

◆ SDKMFCUSAGE

#define SDKMFCUSAGE true

◆ SDKMFCVER

#define SDKMFCVER 0

This include will define RHINO_SDK_VERSION and RHINO_SDK_SERVICE_RELEASE that are required for RHINO_PLUG_IN_DECLARE.

◆ SW_FORCEMINIMIZE

#define SW_FORCEMINIMIZE 11

◆ SW_HIDE

#define SW_HIDE 0

Windows ShowWindow() parameter values

◆ SW_MAX

#define SW_MAX 11

◆ SW_MAXIMIZE

#define SW_MAXIMIZE 3

◆ SW_MINIMIZE

#define SW_MINIMIZE 6

◆ SW_NORMAL

#define SW_NORMAL 1

◆ SW_RESTORE

#define SW_RESTORE 9

◆ SW_SHOW

#define SW_SHOW 5

◆ SW_SHOWDEFAULT

#define SW_SHOWDEFAULT 10

◆ SW_SHOWMAXIMIZED

#define SW_SHOWMAXIMIZED 3

◆ SW_SHOWMINIMIZED

#define SW_SHOWMINIMIZED 2

◆ SW_SHOWMINNOACTIVE

#define SW_SHOWMINNOACTIVE 7

◆ SW_SHOWNA

#define SW_SHOWNA 8

◆ SW_SHOWNOACTIVATE

#define SW_SHOWNOACTIVATE 4

◆ SW_SHOWNORMAL

#define SW_SHOWNORMAL 1

◆ SWP_NOACTIVATE

#define SWP_NOACTIVATE 0x0010

◆ SWP_NOMOVE

#define SWP_NOMOVE 0x0002

◆ SWP_NOSIZE

#define SWP_NOSIZE 0x0001

◆ SWP_NOZORDER

#define SWP_NOZORDER 0x0004

◆ SWP_SHOWWINDOW

#define SWP_SHOWWINDOW 0x0040

◆ TL_IMPORTS

#define TL_IMPORTS

◆ TPM_BOTTOMALIGN

#define TPM_BOTTOMALIGN 0x0020L

◆ TPM_LEFTALIGN

#define TPM_LEFTALIGN 0x0000L

◆ TPM_RETURNCMD

#define TPM_RETURNCMD 0x0100L

◆ WINVER

#define WINVER _WIN32_WINNT

Typedef Documentation

◆ __int64

typedef long long __int64

◆ BITMAPFILEHEADER

typedef struct ON_WindowsBITMAPFILEHEADER BITMAPFILEHEADER

◆ BITMAPINFO

typedef struct ON_WindowsBITMAPINFO BITMAPINFO

◆ BITMAPINFOHEADER

typedef struct ON_WindowsBITMAPINFOHEADER BITMAPINFOHEADER

◆ BOOL32 [1/2]

typedef signed char BOOL32

Mac Objective-C definition of BOOL typedef signed char BOOL;

◆ BOOL32 [2/2]

typedef signed char BOOL32

◆ BROWSEINFO

typedef struct tagBROWSEINFO BROWSEINFO

◆ BSTR

typedef LPWSTR BSTR

◆ BYTE

typedef unsigned char BYTE

Windows definition of BOOL typedef int BOOL;

◆ CFont

typedef ON_Font CFont

◆ CHAR

typedef char CHAR

◆ CHARRANGE

typedef struct _charrange CHARRANGE

◆ CLIPFORMAT

typedef struct tagCLIPFORMAT CLIPFORMAT

◆ COleDataObject

typedef NSPasteBoard COleDataObject

◆ COLORREF

typedef ON_Color COLORREF

◆ ConduitList

typedef ON_SimpleArray<CRhinoDisplayConduit*> ConduitList

◆ CREATESTRUCT

typedef struct tagCREATESTRUCT CREATESTRUCT

◆ CRITICAL_SECTION

typedef void* CRITICAL_SECTION

◆ CUSTOM_MESH_HANDLER_FUNC

typedef bool(* CUSTOM_MESH_HANDLER_FUNC) (const CRhinoObject &, ON_SimpleArray< ON_Mesh * > &aMeshes)

◆ CUSTOM_MESH_HANDLER_FUNC2

typedef bool(* CUSTOM_MESH_HANDLER_FUNC2) (const CRhinoObject &, std::vector< std::shared_ptr< const ON_Mesh >> &aMeshes)

◆ DATE

typedef double DATE

◆ DisplayBucket

typedef ON_SimpleArray<int> DisplayBucket

Object management constructs...

◆ DROPEFFECT

typedef NSDragOperation DROPEFFECT

◆ DWORD

typedef unsigned int DWORD

◆ DWORD64

typedef unsigned long long DWORD64

◆ DWORD_PTR

typedef unsigned long DWORD_PTR

◆ FLOAT

typedef float FLOAT

◆ GLYPHMETRICSFLOAT

typedef struct _GLYPHMETRICSFLOAT GLYPHMETRICSFLOAT

◆ GUID

typedef ON_UUID GUID

◆ HACCEL

typedef void* HACCEL

◆ HANDLE

typedef void* HANDLE

◆ HBITMAP

typedef LPBITMAPINFO HBITMAP

◆ HBRUSH

typedef void* HBRUSH

◆ HCURSOR

typedef id HCURSOR

The HCURSOR handle type is special on OS X. It contains a valid Objective-C object pointer, so it declared as id so ARC will handle it correctly.

◆ HDC

typedef void* HDC

◆ HDWP

typedef void* HDWP

◆ HFONT

typedef void* HFONT

◆ HGDIOBJ

typedef void* HGDIOBJ

◆ HGLOBAL

typedef void* HGLOBAL

◆ HGLRC

typedef NSOpenGLContext* HGLRC

◆ HHOOK

typedef void* HHOOK

◆ HICON

typedef LPBITMAPINFO HICON

◆ HIMAGELIST

typedef void* HIMAGELIST

◆ HINSTANCE

typedef void* HINSTANCE

◆ HKEY

typedef void* HKEY

◆ HMENU

typedef void* HMENU

◆ HMODULE

typedef void* HMODULE

◆ HMONITOR

typedef void* HMONITOR

◆ HPALETTE

typedef void* HPALETTE

◆ HPEN

typedef void* HPEN

◆ HRESULT

typedef int HRESULT

◆ HRGN

typedef void* HRGN

◆ HTHEME

typedef void* HTHEME

◆ HTREEITEM

typedef void* HTREEITEM

◆ HWND

typedef CWnd* HWND

◆ INT

typedef int INT

◆ INT_PTR

typedef long INT_PTR

◆ LARGE_INTEGER

typedef long long LARGE_INTEGER

◆ LCID

typedef unsigned long LCID

◆ LOGBRUSH

typedef struct tagLOGBRUSH LOGBRUSH

◆ LOGFONT

typedef ON_Font LOGFONT

◆ LOGFONTW

typedef ON_Font LOGFONTW

◆ LONG

typedef long LONG

◆ LONG_PTR

typedef long LONG_PTR

◆ LONGLONG

typedef long long LONGLONG

◆ LPARAM

typedef LONG_PTR LPARAM

◆ LPBITMAPFILEHEADER

typedef struct ON_WindowsBITMAPFILEHEADER * LPBITMAPFILEHEADER

◆ LPBITMAPINFO

typedef struct ON_WindowsBITMAPINFO * LPBITMAPINFO

◆ LPBOOL

typedef BOOL32* LPBOOL

◆ LPBYTE

typedef BYTE* LPBYTE

◆ LPCDLGTEMPLATE

typedef void* LPCDLGTEMPLATE

◆ LPCOMPAREITEMSTRUCT

typedef void* LPCOMPAREITEMSTRUCT

◆ LPCREATESTRUCT

typedef struct tagCREATESTRUCT * LPCREATESTRUCT

◆ LPCRITICAL_SECTION

typedef void * LPCRITICAL_SECTION

◆ LPCVOID

typedef CONST void* LPCVOID

◆ LPDELETEITEMSTRUCT

typedef void* LPDELETEITEMSTRUCT

◆ LPDEVMODE

typedef void* LPDEVMODE

◆ LPDISPATCH

typedef void* LPDISPATCH

◆ LPDRAWITEMSTRUCT

typedef void* LPDRAWITEMSTRUCT

◆ LPDWORD

typedef DWORD* LPDWORD

◆ LPGLYPHMETRICSFLOAT

typedef struct _GLYPHMETRICSFLOAT * LPGLYPHMETRICSFLOAT

◆ LPHELPINFO

typedef void* LPHELPINFO

◆ LPINT

typedef int* LPINT

◆ LPLONG

typedef long* LPLONG

◆ LPMEASUREITEMSTRUCT

typedef void* LPMEASUREITEMSTRUCT

◆ LPNMUPDOWN

typedef void* LPNMUPDOWN

◆ LPPAINTSTRUCT

typedef struct tagPAINTSTRUCT * LPPAINTSTRUCT

◆ LPPALETTEENTRY

typedef struct tagPALETTEENTRY* LPPALETTEENTRY

◆ LPPOINT

typedef struct tagPOINT * LPPOINT

◆ LPPOINTFLOAT

typedef struct tagPOINTFLOAT * LPPOINTFLOAT

◆ LPPRINTER_INFO_2

typedef void* LPPRINTER_INFO_2

◆ LPRECT

typedef struct tagRECT * LPRECT

◆ LPSIZE

typedef struct tagSIZE * LPSIZE

◆ LPSTR

typedef char* LPSTR

◆ LPTOP_LEVEL_EXCEPTION_FILTER

typedef void* LPTOP_LEVEL_EXCEPTION_FILTER

◆ LPTSTR

typedef wchar_t* LPTSTR

◆ LPTTTOOLINFOW

typedef struct tagTOOLINFOW * LPTTTOOLINFOW

◆ LPUNKNOWN

typedef void* LPUNKNOWN

◆ LPVOID

typedef void* LPVOID

◆ LPWINDOWPLACEMENT

typedef WINDOWPLACEMENT * LPWINDOWPLACEMENT

◆ LPWINDOWPOS

typedef struct tagWINDOWPOS * LPWINDOWPOS

◆ LPWORD

typedef WORD* LPWORD

◆ LPWSTR

typedef wchar_t* LPWSTR

◆ LRESULT

typedef long LRESULT

◆ MakeRadiusSplineData

typedef struct tagMakeRadiusSplineData MakeRadiusSplineData

Description: Makes a dimension = 1, degree = 3 spline curve that interpolates input values and doesn't overshoot extreme explicitly set in the input values. The output spline will have double knots at each interpolant and 0 derivative at extremes. The domain will be from dist_data[0].t to dist_data[dist_data.Count()-1].t. This makes a good smooth function for interpolating input values along a curve or for use with the RhinoOffsetCurveNormal() function. Parameters: pSrf [in] - Surface from which normals are calculated. pCrv [in] - 3d curve lying on the surface along which normals are calculated. params [in] - parameters in the domain of pCrv for offset points to interpolate pHeights [in] - offset distance (distance from surface to result curve). pHeights is a NURBS curve of dimension 1 with the same domain as pCrv. It is evaluated at points corresponding to the locations where offsets from the surface are calculated to find the height of the offset at those points. Return: ON_NurbsCurve* pointing to offset curve at distance height from the surface. Remarks: Same as the function above, but the offset point locations are specified. THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CURVE. See Also: RhinoOffsetCurveNormal

◆ MENUITEMINFO

typedef void* MENUITEMINFO

◆ MSG

typedef void* MSG

◆ NCCALCSIZE_PARAMS

typedef struct tagNCCALCSIZE_PARAMS NCCALCSIZE_PARAMS

◆ NPPOINT

typedef struct tagPOINT * NPPOINT

◆ NPPOINTFLOAT

typedef struct tagPOINTFLOAT * NPPOINTFLOAT

◆ NPRECT

typedef struct tagRECT * NPRECT

◆ ObjectArray

typedef ON_SimpleArray<const CRhinoObject*> ObjectArray

◆ PAINTSTRUCT

typedef struct tagPAINTSTRUCT PAINTSTRUCT

◆ PALETTEENTRY

typedef struct tagPALETTEENTRY PALETTEENTRY

◆ PBITMAPFILEHEADER

typedef struct ON_WindowsBITMAPFILEHEADER * PBITMAPFILEHEADER

◆ PBITMAPINFO

typedef struct ON_WindowsBITMAPINFO * PBITMAPINFO

◆ PBITMAPINFOHEADER

typedef struct ON_WindowsBITMAPINFOHEADER * PBITMAPINFOHEADER

◆ PBOOL

typedef BOOL32* PBOOL

◆ PBYTE

typedef BYTE* PBYTE

◆ PDWORD

typedef DWORD* PDWORD

◆ PDWORD_PTR

typedef unsigned long * PDWORD_PTR

◆ PFDRAWOVERRIDEPROC

typedef bool(* PFDRAWOVERRIDEPROC) (CRhinoDisplayPipeline &)

◆ PFLOAT

typedef FLOAT* PFLOAT

◆ PINT

typedef int* PINT

◆ PINT_PTR

typedef long * PINT_PTR

◆ PIXELFORMATDESCRIPTOR

typedef struct tagPIXELFORMATDESCRIPTOR PIXELFORMATDESCRIPTOR

◆ PLOGBRUSH

typedef struct tagLOGBRUSH * PLOGBRUSH

◆ PLONG_PTR

typedef long * PLONG_PTR

◆ POINT

typedef struct tagPOINT POINT

◆ POINTFLOAT

typedef struct tagPOINTFLOAT POINTFLOAT

◆ POSITION

typedef __POSITION* POSITION

◆ PPOINT

typedef struct tagPOINT * PPOINT

◆ PPOINTFLOAT

typedef struct tagPOINTFLOAT * PPOINTFLOAT

◆ PRECT

typedef struct tagRECT * PRECT

◆ PSIZE

typedef struct tagSIZE * PSIZE

◆ PSTR

typedef char* PSTR

◆ PTOOLINFOW

typedef struct tagTOOLINFOW * PTOOLINFOW

◆ PUINT

typedef unsigned int* PUINT

◆ PUINT_PTR

typedef unsigned long * PUINT_PTR

◆ PULONG_PTR

typedef unsigned long * PULONG_PTR

◆ PVOID

typedef void* PVOID

◆ PWINDOWPLACEMENT

typedef WINDOWPLACEMENT* PWINDOWPLACEMENT

◆ PWINDOWPOS

typedef struct tagWINDOWPOS * PWINDOWPOS

◆ PWORD

typedef WORD* PWORD

◆ RealtimeDisplayModeList

typedef ON_ClassArray<RealtimeDisplayMode> RealtimeDisplayModeList

◆ RECT

typedef struct tagRECT RECT

◆ RegisteredPipelineList

typedef ON_ClassArray<RegisteredPipeline> RegisteredPipelineList

◆ RGBQUAD

typedef struct ON_WindowsRGBQUAD RGBQUAD

◆ RhTimestamp

typedef long long RhTimestamp

◆ SHORT

typedef short SHORT

◆ SIZE

typedef struct tagSIZE SIZE

◆ STGMEDIUM

typedef struct tagSTGMEDIUM STGMEDIUM

◆ SYSTEMTIME

typedef struct tagSYSTEMTIME SYSTEMTIME

◆ TCHAR

typedef wchar_t TCHAR

◆ TCITEM

typedef struct tagTCITEM TCITEM

◆ TEXTMETRIC

typedef void* TEXTMETRIC

◆ TOOLINFOW

typedef struct tagTOOLINFOW TOOLINFOW

◆ UCHAR

typedef unsigned char UCHAR

◆ UINT

typedef unsigned int UINT

◆ UINT_PTR

typedef unsigned long UINT_PTR

◆ ULONG

typedef UInt32 ULONG

◆ ULONG_PTR

typedef unsigned long ULONG_PTR

◆ ULONGLONG

typedef unsigned long long ULONGLONG

◆ USHORT

typedef unsigned short USHORT

◆ UUID

typedef ON_UUID UUID

◆ VOID

typedef void VOID

◆ WCHAR

typedef wchar_t WCHAR

◆ WINDOWPLACEMENT

typedef struct tagWINDOWPLACEMENT WINDOWPLACEMENT

◆ WINDOWPOS

typedef struct tagWINDOWPOS WINDOWPOS

◆ WNDPROC

typedef void* WNDPROC

◆ WORD

typedef unsigned short WORD

◆ WPARAM

typedef UINT_PTR WPARAM

Enumeration Type Documentation

◆ anonymous enum

anonymous enum : unsigned int

Texture combiner constants used in DrawCombinedTextures() method...

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer.

Enumerator
COMBINE_ADD
COMBINE_MULTIPLY
COMBINE_BLEND
COMBINE_HATCHED
COMBINE_MULTIPLY_WITH_COLOR

◆ CRhinoDocStatus

enum CRhinoDocStatus

Enumerator
doc_status_first
create_before_construct	CRhinoDoc member initialization occurring. CRhinoDoc::CreateDocument status
create_enter_construct	first line in CRhinoDoc::CRhinoDoc() body
create_exit_construct	last line in CRhinoDoc::CRhinoDoc() body
create_begin	in CRhinoDoc::CreateDocument()
create_before_CRhinoDoc_OnNewDocument	in CRhinoDoc::CreateDocument()
create_enter_CRhinoDoc_OnNewDocument	in CRhinoDoc::OnNewDocument()
create_before_CDocument_OnNewDocument	CRhinoDoc::OnNewDocument() calls CDocument::OnNewDocument()
create_after_CDocument_OnNewDocument
create_before_event_post_OnNewDocument	CRhinoDoc::NewDocument() calls OnNewDocument event watchers.
create_enter_event_post_OnNewDocument
create_exit_event_post_OnNewDocument
create_after_event_post_OnNewDocument
create_exit_CRhinoDoc_OnNewDocument	in CRhinoDoc::OnNewDocument()
create_after_CRhinoDoc_OnNewDocument	in CRhinoDoc::CreateDocument()
create_before_read_template_file	CRhinoDoc::CreateDocument() reads template file.
create_enter_read_3dm_template_file
create_before_event_post_OnBeginOpenDocument
create_enter_event_post_OnBeginOpenDocument
create_exit_event_post_OnBeginOpenDocument
create_after_event_post_OnBeginOpenDocument
create_after_read_3dm_template_file
create_before_event_post_OnEndOpenDocument
create_enter_event_post_OnEndOpenDocument
create_exit_event_post_OnEndOpenDocument
create_after_event_post_OnEndOpenDocument
create_read_3dm_template_before_views	before CRhinoDoc::Read3DM() updates template views
create_read_3dm_template_after_views	after CRhinoDoc::Read3DM() updates template views
create_exit_read_3dm_template_file
create_after_read_template_file
create_before_default_views	CRhinoDoc::CreateDocument() creates default views when no template is used or no views are included in the template.
create_after_default_views
create_end	CRhinoDoc::CreateDocument() is finished.
open_begin	CRhinoDoc::OpenDocument status
open_before_CRhinoDoc_OnOpenDocument	in CRhinoDoc::OpenDocument()
open_enter_CRhinoDoc_OnOpenDocument	in CRhinoDoc::OnOpenDocument()
open_before_CDocument_OnOpenDocument	CRhinoDoc::OnOpenDocument() calls CDocument::OnOpenDocument()
open_before_read_model_file	CRhinoDoc::OpenDocument() is using a plug-in to read a model file.
open_before_read_3dm_model_file	CRhinoDoc::OpenDocument() is using CRhinoDoc::Read3DM() to read a .3dm model file.
open_enter_read_3dm_model_file
open_before_event_post_OnBeginOpenDocument	CRhinoDoc::OnOpenDocument() calls OnOpenDocument event watchers.
open_enter_event_post_OnBeginOpenDocument
open_exit_event_post_OnBeginOpenDocument
open_after_event_post_OnBeginOpenDocument
open_enter_read_model_file	If a plug-in is reading a file to open a document, then these status settings bracket the call to the plug-in reading the file.
open_exit_read_model_file
open_before_event_post_OnEndOpenDocument
open_enter_event_post_OnEndOpenDocument
open_exit_event_post_OnEndOpenDocument
open_after_event_post_OnEndOpenDocument
open_read_3dm_model_before_views	before CRhinoDoc::Read3DM() updates views
open_read_3dm_model_after_views	after CRhinoDoc::Read3DM() updates views
open_exit_read_3dm_model_file
open_after_read_3dm_model_file
open_after_CDocument_OnOpenDocument	in CRhinoDoc::OnOpenDocument() after call to CDocument::OnOpenDocument()
open_after_read_model_file	CRhinoDoc is finished using a plug-in to read the model file.
open_exit_CRhinoDoc_OnOpenDocument	in CRhinoDoc::OnOpenDocument()
open_after_CRhinoDoc_OnOpenDocument	in CRhinoDoc::OpenDocument()
open_before_views	CRhinoDoc::OpenDocument() creates views.
open_after_views
open_end	CRhinoDoc::OpenDocument() is finished.
available	document can be read and modified doc is alive and usable and being used
close_begin	soon ... read_only, ///< document cannot be modified unavailable, ///< document is being modified CRhinoDoc::CloseDocument status
close_before_CRhinoDoc_OnCloseDocument	in CRhinoDoc::CreateDocument()
close_enter_CRhinoDoc_OnCloseDocument	in CRhinoDoc::NewDocument()
close_before_event_post_OnCloseDocument	CRhinoDoc::OnCLoseDocument() calls OnCloseDocument event watchers.
close_enter_event_post_OnCloseDocument
close_exit_event_post_OnCloseDocument
close_after_event_post_OnCloseDocument
close_before_CDocument_OnCloseDocument	CRhinoDoc::OnCloseDocument() calls CDocument::OnCloseDocument()
close_after_CDocument_OnCloseDocument
close_exit_CRhinoDoc_OnCloseDocument	in CRhinoDoc::OnCloseDocument()
close_after_CRhinoDoc_OnCloseDocument	in CRhinoDoc::CloseDocument()
close_end
close_enter_destruct	first line in CRhinoDoc::~CRhinoDoc() body
close_before_destroy
close_enter_destroy	first line of CRhinoDoc::Destroy() body
close_exit_destroy	last line of CRhinoDoc::Destroy() body
close_after_destroy	first line in CRhinoDoc::~CRhinoDoc() body
close_exit_destruct	last line in CRhinoDoc::~CRhinoDoc() body
doc_status_last	force 4 byte size

◆ EConduitNotifiers

enum EConduitNotifiers

Conduit notification values...

Enumerator
CN_PIPELINEADDED
CN_PIPELINEDELETED
CN_PIPELINECLONED
CN_PIPELINEOPENED
CN_PIPELINECLOSED
CN_FRAMESIZECHANGED
CN_PROJECTIONCHANGED
CN_NESTEDPIPELINE_OPENED
CN_NESTEDPIPELINE_CLOSED

◆ ECullFaceMode

enum ECullFaceMode : unsigned int

Enumerator
CFM_DRAW_FRONT_AND_BACK
CFM_DRAW_FRONT_FACES
CFM_DRAW_BACK_FACES

◆ EDepthMode

enum EDepthMode : unsigned int

Enumerator
DM_NEUTRAL
DM_ALWAYS_IN_FRONT
DM_ALWAYS_IN_BACK

◆ EFrameBufferFillMode

enum EFrameBufferFillMode : int

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. Flags and attributes need to be provided to pass back and forth to the conduits based on all of the default stuff the pipeline draws in its channels.

Reason: Conduits may want to override the default behavior (eg. DrawGrid), so we need a way for conduits to tell the pipeline what is being done, as well as let other conduits know what has already been done.

Note: These are all based on what Rhino's pipeline does...there is no way to second guess what other pipelines will or won't do, so all we can do for now is tell conduits as much as we can about Rhino's pipeline attributes...

Enumerator
FBFM_DEFAULT_COLOR
FBFM_SOLID_COLOR
FBFM_GRADIENT_2_COLOR
FBFM_GRADIENT_4_COLOR
FBFM_BITMAP
FBFM_RENDERER
FBFM_TRANSPARENT

◆ ELightingScheme

enum ELightingScheme : int

Enumerator
LS_NONE
LS_DEFAULT_LIGHTING
LS_SCENE_LIGHTING
LS_CUSTOM_LIGHTING
LS_AMBIENT_OCCLUSION

◆ EnvironmentBackgroundProjection

enum EnvironmentBackgroundProjection : int

strong

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer.

Enumerator
planar
spherical
emap
box
lightprobe
cubemap
vertical_cross_cubemap
horizontal_cross_cubemap
hemispherical
none

◆ ERenderOverlayFeatures

enum ERenderOverlayFeatures

Post rendering features that make up all possible post renderables...

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer.

Enumerator
ROF_POINTS
ROF_LIGHTS
ROF_MESHWIRES
ROF_ISOS
ROF_EDGES
ROF_TEXT
ROF_CURVES
ROF_ANNOTATIONS
ROF_SUBDWIRES
ROF_SECTION_FILL
ROF_SECTION_BOUNDARY

◆ ERhinoPointStyle

enum ERhinoPointStyle : unsigned int

Points helper types and classes used to describe and draw points...

Enumerator
RPS_SQUARE	same as VARIABLE_DOT
RPS_CIRCLE	same as ROUND_DOT
RPS_TRIANGLE
RPS_HEART
RPS_CHEVRON
RPS_CLOVER
RPS_TAG
RPS_X
RPS_ASTERISK
RPS_PIN
RPS_ARROW_TAIL_OFF_POINT
RPS_ARROW_TIP_OFF_POINT
RPS_VARIABLE_DOT	"DOT's" are solid filled, single color entities... varying radius
RPS_ROUND_DOT
RPS_CONTROL_POINT	Rhino's standard CV object... "POINT's" are border filled color with white centers, 2 color entities... Note: The radius can vary on all of these...
RPS_ACTIVE_POINT	Rhino's standard active CV object...
RPS_ROUND_CONTROL_POINT
RPS_ROUND_ACTIVE_POINT

◆ eRhSnapGeom

enum eRhSnapGeom

The geometry that can be checked by RhCheckObjectSnapPoints().

Enumerator
sng_plane_uv	Check a plane (uv only).
sng_plane_uvw	Check a plane (uvw).
sng_box	Check a box.
sng_sphere	Check a sphere.
sng_cylinder	Check a cylinder.
sng_axes	Check axes (e.g., x,y,z arrows / frame).

◆ EZBiasMode

enum EZBiasMode : int

Enumerator
ZBM_AWAY_FROM_CAMERA
ZBM_NEUTRAL
ZBM_TOWARDS_CAMERA

◆ GUMBALL_MODE

enum GUMBALL_MODE

Transformation modes for gumballs.

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer.

Enumerator
gb_mode_nothing
gb_mode_menu	gumball menu button was picked
gb_mode_translatefree	unconstrained translation
gb_mode_translatex	translation along a single axis
gb_mode_translatey
gb_mode_translatez
gb_mode_translatexy	translation in a plane
gb_mode_translateyz
gb_mode_translatezx
gb_mode_scalex	NOTE: CRhinoGumballFrame m_scale_mode is used to enable multi-axis scaling. This enum indicates which control is being dragged.
gb_mode_scaley
gb_mode_scalez
gb_mode_scalexy	scaling in a plane
gb_mode_scaleyz
gb_mode_scalezx
gb_mode_rotatex
gb_mode_rotatey
gb_mode_rotatez
gb_mode_extrudex	open extrusion along single axis
gb_mode_extrudey
gb_mode_extrudez
gb_mode_cutx
gb_mode_cuty
gb_mode_cutz

◆ GUMBALL_POPUP_MENU_ITEM

enum GUMBALL_POPUP_MENU_ITEM

These enum values are used to set bitfields that control what appears on the gumball pop-up menu and are used to report what was selected from the menu.

Enumerator
gb_menu_nothing
gb_menu_relocate	Relocate current gumball.
gb_menu_autogumballon	Auto-gumball on/off Rhino app setting.
gb_menu_autogumballoff
gb_menu_snappyon	Snappy/Smooth Rhino app setting.
gb_menu_snappyoff
gb_menu_settingscmd	Run Rhino GumballSettings command.
gb_menu_reset	Reset current gumball transformation.
gb_rotate_view_around_autogumball
gb_menu_align_to_object	Gumball alignment setting.
gb_menu_align_to_cplane
gb_menu_align_to_world
gb_menu_drag_ratio	gumball drag ratio/scale/strength
gb_menu_drag_ratio_popup
gb_menu_autoreset	gumball autoreset after each drag
gb_menu_enter	Show "Enter" on top of the gumball menu.
gb_menu_align_to_view	Gumball alignment setting.
gb_extrude_merge_faces	Gumball merge faces after extrude.
gb_menu_everything

◆ RhDisplacementSweepResolutionFormula

enum RhDisplacementSweepResolutionFormula : int

strong

Enumerator

Default

summary>Default formula.

summary>Formula used in Rhino 5. Dependent on absolute tolerance.

AbsoluteToleranceDependent

◆ RHINO_IDEF_STATUS

enum RHINO_IDEF_STATUS

Description: Returns the status of a linked block. Parameters: idef [in] - The instance definition to query. Return: RHINO_IDEF_STATUS - the status.

Enumerator
RHINO_IDEF_NOT_A_LINKED_IDEF
RHINO_IDEF_LINKED_FILE_NOT_READABLE
RHINO_IDEF_LINKED_FILE_NOT_FOUND
RHINO_IDEF_LINKED_FILE_IS_TO_DATE
RHINO_IDEF_LINKED_FILE_IS_NEWER
RHINO_IDEF_LINKED_FILE_IS_OLDER
RHINO_IDEF_LINKED_FILE_IS_DIFFERENT

◆ RhinoConicSectionType

enum RhinoConicSectionType : int

strong

Enumerator
Unknown
Circle
Ellipse
Hyperbola
Parabola

◆ RhinoDashStyle

enum RhinoDashStyle : unsigned int

strong

Enumerator
Solid
Dash

◆ RhinoFilletSurfaceSplitType

enum RhinoFilletSurfaceSplitType : int

strong

RhinoFilletSurfaceSplitType

Enumerator
Nothing	Nothing
Trim	Trim
Split	Split

◆ RhinoFilletSurfaceType

enum RhinoFilletSurfaceType : int

strong

Enumerator
RollingBall
Chamfer
Rails

◆ RhinoKeyboardModifierKey

enum RhinoKeyboardModifierKey : unsigned char

strong

Enumerator
None
Ctrl
MacCommand	same as Ctrl
Shift
Alt
MacControl

◆ RhinoLineCapStyle

enum RhinoLineCapStyle : int

strong

Enumerator
None
Round
Flat
Square

◆ RhinoLineJoinStyle

enum RhinoLineJoinStyle : int

strong

Enumerator
None
Round
Miter
Bevel

◆ RhinoOptionPageButtons

enum RhinoOptionPageButtons : int

strong

Standard IRhinoOptionsPageButton

class RhinoOptionPageButtons

Description: The standard buttons that can be optionally displayed by IRhinoOptionsPage

Enumerator
None	Don't display any of the standard buttons.
DefaultButton	The "Restore Defaults" button located at the bottom of the host.
ApplyButton	The "Apply" button located at the bottom of the host.

◆ RhinoPropertiesPanelPageType

enum RhinoPropertiesPanelPageType : int

strong

IRhinoProperties page type

class RhinoPropertiesPanelPageType

Description: The type of properties page this is.

Enumerator
Material	Replace the material page with this page; only works for the current render plug - in.
Light	Replace the light page with this page; only works for the current render plug-in.
Custom	User-defined custom object page.
ObjectProperties	For internal use only.
Dimension	If page is provided by Rhino and only dimensions are selected, activate this page.
Leader	If page is provided by Rhino and leaders are selected, activate this page.
Text	If page is provided by Rhino and only text objects are selected, activate this page.
Hatch	If page is provided by Rhino and only hatch objects are selected, activate this page.
Dot	If page is provided by Rhino and only dot objects are selected, activate this page.
TextureMapping	Replace the texture mapping page with this page; only works for the current render plug-in.
Detail	If page is provided by Rhino and only detail objects are selected, activate this page.
ClippingPlane	If page is provided by Rhino and only clipping plane objects are selected, activate this page.
NamedView	If page is provided by Rhino and only named view widget objects are selected, activate this page.
Decal	Decals user interface
View	Page is a view properties page and uses view properties methods. Does not use object properties methods.
PageCount	Reserved, do not use.

◆ RhinoRefitTrimKnotMode

enum RhinoRefitTrimKnotMode : int

strong

The mode for adding kinots to the surface for fitting

Enumerator
None	No knots are added
UniformEntireSurface	The entire surface is fit using uniform spacing with the specified number of knots
UniformPerSpan	Each existing span is uniformly spaced with the specified number of knots
Custom	The provided knot vector will be used

◆ RhinoRefitTrimSectionMode

enum RhinoRefitTrimSectionMode : int

strong

The mode for dividing the surface into sections

Enumerator
NoSections	just output one "upper" and one "lower" surface
DivideAtInputKnots	divide into sections at each of the input surface's existing knots
DivideAtAddedKnots	Yes, divide into sections at each of the "nKnot" added knot values
DivideAtAllKnots	Yes, divide into sections at ALL knot values (i.e. both 1 and 2)

◆ RhinoWindowCreateOptions

enum RhinoWindowCreateOptions : int

strong

Create window options

Enumerator
None	No options set.
ChildPage	The window is a child page being hosted by a core Rhino interface component.
Visible	Window should be made visible when creating component.
Sizable	Window should be resizable (WS_THICKFRAME on Windows) component.
Frame	Window should have a title bar and border (WS_OVERLAPPED on Windows) component.
Minimizable	Window should have a minimize button (WS_MINIMIZEBOX on Windows) component.
Maximizable	Window should have a maximize button (WS_MAXIMIZEBOX on Windows) component.

◆ RhinoYesNoResponse

enum RhinoYesNoResponse : unsigned int

strong

define RhinoYesNoResponse enum

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. Deep, sigh. ... This file is included by Mac Rhino projects in a complicated, contrived, controversial, and complex, manner.
In MacRhino, in some projects, the enum and functions are declared at different points in time. In other projects, everything simply includes RhinoSdk.h and life is, well, simple.

In all Windows code, include RhinoSdk.h and move on. "There is nothing to see here."

Too keep Mac Rhino building.

NO NO NO NO #prag once

RhinoYesNoResponse is a list of possible responses to a question that can be answered yes or no.

Enumerator
Unset	Response is unset.
Yes	User responded yes.
YesToAll	User responded yes and wants to automatically respond yes to all identical queries in the future.
No	User responded no.
NoToAll	User responded no and wants to automatically respond no to all identical queries in the future.
Cancel	User selected cancel in a dialog or other interface.
Error	Response is not available. Possibly because an error occurred in code execution.

◆ RhPipeCapType

enum RhPipeCapType

strong

Enumerator
None	summary>Capping is skipped. The resulting object will be simpler. summary>A flat surface will cap the pipe.
Flat	summary>A simple construction will cap the pipe.
Box	summary>A meridians-and-parallels hemisphere construction will cap the pipe.
Dome

◆ TextureReportFilter

enum TextureReportFilter : unsigned int

strong

Enumerator
MissingOnly
AllTextures

◆ TextureReportResult

enum TextureReportResult : unsigned int

strong

Enumerator
Abort
Continue
Success
Failure

Function Documentation

◆ CapOffSettedMesh()

RHINO_SDK_FUNCTION bool CapOffSettedMesh	(	const ON_Mesh *	pInputMesh,
		ON_Mesh *	pOutputMesh,
		double	Offset
	)

Description: Sort of an expert function meant to be called from the RhinoMeshOffset function above. It assumes, and checks for, the input and output meshes are topologically identical. What is meant by this is that they have the same m_V count and the same m_F count. In fact, the m_F arrays of both meshes must be identical.

This function creates the ribbon of faces along the associated naked edges of the input and output meshes. Once it makes those faces it add them and the input mesh to the output mesh to create a closed mesh. The Offset variable is only used for it's sign to determine the orientation of the ribbon faces.

Parameters: pInputMesh - Input mesh. pOutputMesh - Output mesh. Offset - Input only used for sign.

Returns: Returns a true on success. False on failure. Potentially modifies pOutputMesh even on failure.

◆ CreateDisplayPipeline()

RHINO_SDK_FUNCTION CRhinoDisplayPipeline* CreateDisplayPipeline ( const ON_ClassId * )

◆ FindRegisteredPipeline() [1/2]

RHINO_SDK_FUNCTION bool FindRegisteredPipeline	(	const ON_ClassId *	,
		RegisteredPipeline &
	)

◆ FindRegisteredPipeline() [2/2]

RHINO_SDK_FUNCTION bool FindRegisteredPipeline	(	const ON_UUID &	,
		RegisteredPipeline &
	)

◆ GetDefaultPageViewPipeline()

const RHINO_SDK_FUNCTION ON_ClassId* GetDefaultPageViewPipeline ( )

◆ GetDefaultShadingPipeline()

const RHINO_SDK_FUNCTION ON_ClassId* GetDefaultShadingPipeline ( )

◆ GetDefaultWireframePipeline()

const RHINO_SDK_FUNCTION ON_ClassId* GetDefaultWireframePipeline ( )

RHINO_SDK_FUNCTION bool RegisterDefaultWireframePipeline(const ON_ClassId*);

RHINO_SDK_FUNCTION bool RegisterDefaultShadingPipeline(const ON_ClassId*);

RHINO_SDK_FUNCTION bool RegisterDefaultPageViewPipeline(const ON_ClassId*);

◆ GetRegisteredPipelines()

RHINO_SDK_FUNCTION int GetRegisteredPipelines ( RegisteredPipelineList & )

◆ GetRegisteredShadingPipelines()

RHINO_SDK_FUNCTION int GetRegisteredShadingPipelines ( RegisteredPipelineList & )

◆ GetRegisteredWireframePipelines()

RHINO_SDK_FUNCTION int GetRegisteredWireframePipelines ( RegisteredPipelineList & )

◆ MakeRhinoContours() [1/2]

RHINO_SDK_FUNCTION bool MakeRhinoContours	(	const CRhinoContourInput &	input,
		ON_SimpleArray< ON_Polyline * > &	output_PlineArray,
		ON_SimpleArray< ON_Curve * > &	output_CurveArray,
		ON_SimpleArray< ON_3dPoint > &	output_PointArray
	)

Description: Create contour curves for Breps and contour polylines for meshes that are input.m_interval distance apart and fill the output arrays with the results. If m_bAddOutputToDocument==true the output will be added to the current Rhino document instead of populating the output arrays. Parameters: input - [in] output_PlineArray - [out] ///<output from mesh and point cloud intersection output_CurveArray - [out] ///<output from surface and polysurface intersection output_PointArray = [out] ///<output from curve intersection Returns: true or false depending on success or failure Remarks: It is the calling functions responsibility to clean up the memory used by these arrays.

◆ MakeRhinoContours() [2/2]

RHINO_SDK_FUNCTION bool MakeRhinoContours	(	const CRhinoContourInput &	input,
		ON_SimpleArray< ON_Polyline * > &	output_PlineArray,
		ON_SimpleArray< ON_Curve * > &	output_CurveArray,
		ON_SimpleArray< ON_3dPoint > &	output_PointArray,
		double	tolerance,
		CRhinoDoc *	doc
	)

Description: Create contour curves for Breps and contour polylines for meshes that are input.m_interval distance apart and fill the output arrays with the results. If m_bAddOutputToDocument==true, then doc must NOT be NULL If m_bAddOutputToDocument==false, doc can be NULL and is ignored Parameters: input - [in] output_PlineArray - [out] ///<output from mesh and point cloud intersection output_CurveArray - [out] ///<output from surface and polysurface intersection output_PointArray = [out] ///<output from curve intersection Returns: true or false depending on success or failure Remarks: It is the calling functions responsibility to clean up the memory used by these arrays.

◆ MeshVoronoiAreas()

RHINO_SDK_FUNCTION bool MeshVoronoiAreas	(	const ON_Mesh &	mesh,
		ON_SimpleArray< double > &	result,
		bool	useMeshTopology = `true`
	)

Description: Function that will fill in the result array with the per-vertex Voronoi areas of a triangle mesh. Will fail on a quad mesh.

Parameters: mesh - [in] Input mesh result - [out] result, per vertex or per topology vertex useMeshTopology - optional, boolean toggle to indicate if mesh topology vertices or mesh vertices are used.

Returns: True or false depending on the success of the computation.

◆ ON_DEPRECATED_MSG()

ON_DEPRECATED_MSG ( "This function will be removed in Rhino Version 7. \n" "For assistance replacing this function post on discourse.mcneel.com/c/rhino-developer." )

Description: RhinoBrepGet2dProjection generates a 2D projection of a list of Breps. Parameters: brepObjects - [in] List of Brep objects to be projected. projectionPlane - [in] Plane used to get 2D projection. projectedCurves - [out] Curves that are in the positive part of the plane and are visible will be appended. pProjectedHiddenCurves - [out] If not NULL, curves that are in the positive part of the plane and are hidden will be appended. pDistTolerance - [in] Tolerance used for distance comparisons. Use CRhinoDoc.AbsoluteTolerance() when in doubt. pAngTolerance - [in] Tolerance used for angular comparisons. Use CRhinoDoc.AngleToleranceRadians() when in doubt. Returns: true if success.

Description: Generates a 2D section of a list of Breps. Splits all Breps using the specified Brep splitter, then generates the 2D projection of resulting pieces, and finally returns all output projection curves separated depending in curve position (back or front) and visibility. Parameters: brepObjects - [in] List of Brep objects to be sectioned. brepSplitter - [in] Brep used to split objects. Splitter is a single possibly non-manifold Brep. (See RhinoBrepSplit) projectionPlane - [in] Plane used to get 2D projection. pSectionCurves - [out] Curve objects that lies in brepSplitter pForegroundCurves - [out] Curves that are in the positive part of the splitter and are visible. pBackgroundCurves - [out] Curves that are in the negative part of the splitter and are visible. pForegroundHiddenCurves - [out] Curves that are in the positive part of the splitter and are hidden. pBackgroundHiddenCurves - [out] Curves that are in the negative part of the splitter and are hidden. pDistTolerance - [in] Tolerance used for distance comparisons. Use CRhinoDoc.AbsoluteTolerance() when in doubt. pAngTolerance - [in] Tolerance used for angular comparisons. Use CRhinoDoc.AngleToleranceRadians() when in doubt. Returns: true if success.

◆ operator&() [1/2]

RHINO_SDK_FUNCTION RhinoOptionPageButtons operator&	(	RhinoOptionPageButtons	a,
		RhinoOptionPageButtons	b
	)

◆ operator&() [2/2]

RHINO_SDK_FUNCTION RhinoWindowCreateOptions operator&	(	RhinoWindowCreateOptions	a,
		RhinoWindowCreateOptions	b
	)

◆ operator&=() [1/2]

RHINO_SDK_FUNCTION RhinoOptionPageButtons& operator&=	(	RhinoOptionPageButtons &	a,
		RhinoOptionPageButtons	b
	)

◆ operator&=() [2/2]

RHINO_SDK_FUNCTION RhinoWindowCreateOptions& operator&=	(	RhinoWindowCreateOptions &	a,
		RhinoWindowCreateOptions	b
	)

◆ operator|() [1/2]

RHINO_SDK_FUNCTION RhinoOptionPageButtons operator\|	(	RhinoOptionPageButtons	a,
		RhinoOptionPageButtons	b
	)

◆ operator|() [2/2]

RHINO_SDK_FUNCTION RhinoWindowCreateOptions operator\|	(	RhinoWindowCreateOptions	a,
		RhinoWindowCreateOptions	b
	)

◆ operator|=() [1/2]

RHINO_SDK_FUNCTION RhinoOptionPageButtons& operator\|=	(	RhinoOptionPageButtons &	a,
		RhinoOptionPageButtons	b
	)

◆ operator|=() [2/2]

RHINO_SDK_FUNCTION RhinoWindowCreateOptions& operator\|=	(	RhinoWindowCreateOptions &	a,
		RhinoWindowCreateOptions	b
	)

◆ operator~() [1/2]

RHINO_SDK_FUNCTION RhinoOptionPageButtons operator~ ( RhinoOptionPageButtons a )

◆ operator~() [2/2]

RHINO_SDK_FUNCTION RhinoWindowCreateOptions operator~ ( RhinoWindowCreateOptions a )

◆ RegisterDisplayPipeline()

RHINO_SDK_FUNCTION bool RegisterDisplayPipeline	(	const ON_ClassId *	,
		const ON_UUID &	,
		const ON_wString &	,
		bool	= `true`,
		bool	= `false`,
		bool	= `false`
	)

◆ RegisterOpenGLEngine()

const RHINO_SDK_FUNCTION ON_ClassId* RegisterOpenGLEngine ( const ON_ClassId * )

◆ Rh1RailSweepSegmented()

RHINO_SDK_FUNCTION bool Rh1RailSweepSegmented	(	ON_SimpleArray< ON_Brep * > &	output_surfaces,
		const ON_Curve *	pRailCurve,
		const ON_SimpleArray< const ON_Curve * >	shapes,
		ON_3dPoint	start_point,
		ON_3dPoint	end_point,
		int	frame_type = `0`,
		ON_3dVector	roadlike_normal = `ON_3dVector::UnsetVector`,
		bool	bClosed = `false`,
		int	blend_type = `0`,
		int	miter_type = `0`,
		double	tolerance = `0.01`,
		int	rebuild_mode = `0`,
		int	rebuild_points = `0`,
		double	refit_tolerance = `0.0`
	)

Description: Sweep1 function that fits a surface through profile curves that define the surface cross-sections and one curve that defines a surface edge. The Segmented version breaks the rail at curvature kinks and sweeps each piece separately, then put the results together into a Brep.

Parameters

output_surfaces	Sweep results
pRailCurve	Rail going the right direction
shapes	Shapes will be sorted on rail
start_point	The start point, specify ON_3dPoint::UnsetPoint to ignore.
end_point	The ending point, specify ON_3dPoint::UnsetPoint to ignore.
frame_type	The frame type: 0 = freeform, 1 = roadlike
roadlike_normal	The roadlike normal direction, or ON_3dVector::UnsetVector to ignore.
bClosed	Only matters if rails are closed
blend_type	The blend type: 0 = local, 1 = global.
miter_type	The miter type: 0 = none, 1 = trimmed, 2 = untrimmed miters
tolerance	tolerance for fitting surface and rails
rebuild_mode	0 = no rebuild, 1 = rebuild through points, 2 = refit to tolerance
rebuild_points	if 1 == rebuild_mode, the number of points, otherwise set to 0
refit_tolerance	if 2 == rebuild_mode, the refit tolerance, otherwise set to 0.0

◆ RhCheckObjectSnapPoints()

RHINO_SDK_FUNCTION bool RhCheckObjectSnapPoints	(	eRhSnapGeom	sng,
		const CRhinoSnapContext &	sc,
		CRhinoSnapEvent &	se,
		const ON_Xform &	xform
	)

Description: Checks 'osnap' points for a particular geometry. Checks ON::os_end, ON::os_quadrant, ON::os_midpoint and ON::os_center in that order.

Parameters: sng - [in] The geometry to check (see eRhSnapGeom above). sc - [in] The snap context. se - [in/out] The snap event. xform - [in] The xform that transforms the object into world space.

Returns: True if any snap check was successful, else false.

◆ RhCreateWidget()

RHINO_SDK_FUNCTION UUID RhCreateWidget	(	CRhinoDoc &	doc,
		CRhinoWidget *	pWidget,
		const CRhinoObjectAttributes *	pAttr = `NULL`
	)

Description: Creates a document-resident widget from a new instance of a CRhinoWidget subclass.

Parameters: doc - [in] The document to create the widget in. pWidget - [in] A pointer to a new instance of your widget class. pAttr - [in] A pointer to optional object attributes to use for the new widget.

Returns: The Rhino object UUID of the widget if successful, else ON_nil_uuid.

Remarks: Rhino will create the widget and take ownership of your instance; you must not store a pointer to it.

◆ RhFindWidgetsAssociatedWithObject()

RHINO_SDK_FUNCTION void RhFindWidgetsAssociatedWithObject	(	const CRhinoObject &	obj,
		ON_SimpleArray< CRhinoWidget * > &	aWidgetsOut
	)

◆ RhFormatNumber() [1/2]

bool RhFormatNumber	(	double	x,
		const ON_3dmUnitsAndTolerances &	input_units,
		const ON_3dmUnitsAndTolerances &	output_units,
		ON_wString &	string,
		bool	bAppendUnitSystemName,
		bool	bBracketFractions
	)

Returns true if formatting worked without fallbacks - no invalid input, overruns, etc.

◆ RhFormatNumber() [2/2]

void RhFormatNumber	(	double	x,
		ON_wString &	string,
		bool	bAppendUnitSystemName,
		bool	bAbbreviate
	)

◆ RhGetGripPoints_Box()

RHINO_SDK_FUNCTION void RhGetGripPoints_Box ( ON_3dPointArray & aOut )

◆ RhGetGripPoints_Cylinder()

RHINO_SDK_FUNCTION void RhGetGripPoints_Cylinder ( ON_3dPointArray & aOut )

◆ RhGetGripPoints_Plane_UV()

RHINO_SDK_FUNCTION void RhGetGripPoints_Plane_UV ( ON_3dPointArray & aOut )

◆ RhGetGripPoints_Plane_UVW()

RHINO_SDK_FUNCTION void RhGetGripPoints_Plane_UVW ( ON_3dPointArray & aOut )

◆ RhGetGripPoints_Sphere()

RHINO_SDK_FUNCTION void RhGetGripPoints_Sphere ( ON_3dPointArray & aOut )

◆ Rhino1RailSweep() [1/2]

RHINO_SDK_FUNCTION bool Rhino1RailSweep	(	ON_SimpleArray< ON_Brep * > &	output_surfaces,
		const ON_Curve *	pRail,
		const ON_SimpleArray< const ON_Curve * >	shapes,
		bool	bClosed = `false`,
		double	tolerance = `0.01`
	)

Description: Sweep1 function that fits a surface through profile curves that define the surface cross-sections and one curve that defines a surface edge.

Parameters

output_surfaces	sweep results
pRail	rail going the right direction
shapes	shapes will be sorted on rail
bClosed	only matters if rail is closed
tolerance	tolerance for fitting surface and rails

◆ Rhino1RailSweep() [2/2]

RHINO_SDK_FUNCTION bool Rhino1RailSweep	(	ON_SimpleArray< ON_Brep * > &	output_surfaces,
		const ON_Curve *	pRailCurve,
		const ON_SimpleArray< const ON_Curve * >	shapes,
		ON_3dPoint	start_point,
		ON_3dPoint	end_point,
		int	frame_type = `0`,
		ON_3dVector	roadlike_normal = `ON_3dVector::UnsetVector`,
		bool	bClosed = `false`,
		int	blend_type = `0`,
		int	miter_type = `0`,
		double	tolerance = `0.01`,
		int	rebuild_mode = `0`,
		int	rebuild_points = `0`,
		double	refit_tolerance = `0.0`
	)

Description: Sweep1 function that fits a surface through profile curves that define the surface cross-sections and one curve that defines a surface edge.

Parameters

output_surfaces	Sweep results
pRailCurve	Rail going the right direction
shapes	Shapes will be sorted on rail
start_point	The start point, specify ON_3dPoint::UnsetPoint to ignore.
end_point	The ending point, specify ON_3dPoint::UnsetPoint to ignore.
frame_type	The frame type: 0 = freeform, 1 = roadlike
roadlike_normal	The roadlike normal direction, or ON_3dVector::UnsetVector to ignore.
bClosed	Only matters if rails are closed
blend_type	The blend type: 0 = local, 1 = global.
miter_type	The miter type: 0 = none, 1 = trimmed, 2 = untrimmed miters
tolerance	tolerance for fitting surface and rails
rebuild_mode	0 = no rebuild, 1 = rebuild through points, 2 = refit to tolerance
rebuild_points	if 1 == rebuild_mode, the number of points, otherwise set to 0
refit_tolerance	if 2 == rebuild_mode, the refit tolerance, otherwise set to 0.0

◆ Rhino1RailSweepSegmented()

RHINO_SDK_FUNCTION bool Rhino1RailSweepSegmented	(	ON_SimpleArray< ON_Brep * > &	output_surfaces,
		const ON_Curve *	pRail,
		const ON_SimpleArray< const ON_Curve * >	shapes,
		bool	bClosed = `false`,
		double	tolerance = `0.01`
	)

Description: Sweep1 function that fits a surface through profile curves that define the surface cross-sections and one curve that defines a surface edge. The Segmented version breaks the rail at curvature kinks and sweeps each piece separately, then put the results together into a Brep.

Parameters

output_surfaces	sweep results
pRail	rail going the right direction
shapes	shapes will be sorted on rail
bClosed	only matters if rail is closed
tolerance	tolerance for fitting surface and rails

◆ Rhino2RailSweep() [1/3]

RHINO_SDK_FUNCTION bool Rhino2RailSweep	(	ON_SimpleArray< ON_Brep * > &	output_surfaces,
		const ON_Curve *	pRail[2],
		const ON_SimpleArray< const ON_Curve * >	shapes,
		bool	bClosed = `false`,
		double	tolerance = `0.01`
	)

Description: Sweep2 function that fits a surface through profile curves that define the surface cross-sections and two curves that defines the surface edges.

Parameters

output_surfaces	sweep results
pRail	2 rails going the right direction
shapes	shapes will be sorted on rail
bClosed	only matters if rails are closed
tolerance	tolerance for fitting surface and rails

◆ Rhino2RailSweep() [2/3]

RHINO_SDK_FUNCTION bool Rhino2RailSweep	(	ON_SimpleArray< ON_Brep * > &	output_surfaces,
		const ON_Curve *	pRail[2],
		const ON_SimpleArray< const ON_Curve * >	shapes,
		int	rebuild_mode,
		int	rebuild_points,
		double	refit_tolerance,
		bool	bPreserveHeight,
		bool	bClosed = `false`,
		double	tolerance = `0.01`
	)

Description: Sweep2 function that fits a surface through profile curves that define the surface cross-sections and two curves that defines the surface edges.

Parameters

output_surfaces	sweep results
pRail	2 rails going the right direction
shapes	shapes will be sorted on rail
rebuild_mode	0 = no rebuild, 1 = refit to tolerance, 2 = rebuild to #points
rebuild_points	if 2 == rebuild_mode, the number of points
refit_tolerance	if 2 == rebuild_mode, the refit tolerance
bPreserveHeight	removes the association between the height scaling from the width scaling
bClosed	only matters if rails are closed

◆ Rhino2RailSweep() [3/3]

RHINO_SDK_FUNCTION bool Rhino2RailSweep	(	ON_SimpleArray< ON_Brep * > &	output_surfaces,
		const ON_Curve *	pRail[2],
		const ON_SimpleArray< const ON_Curve * >	shapes,
		ON_3dPoint	start_point,
		ON_3dPoint	end_point,
		bool	bClosed = `false`,
		double	tolerance = `0.01`,
		int	rebuild_mode = `0`,
		int	rebuild_points = `0`,
		double	refit_tolerance = `0.0`,
		bool	bPreserveHeight = `false`
	)

Description: Sweep2 function that fits a surface through profile curves that define the surface cross-sections and two curves that defines the surface edges. Use this version if you want to create shapes like Rhino's Sweep2 commaned.

Parameters

output_surfaces	sweep results
pRail	2 rails going the right direction
shapes	shapes will be sorted on rail
start_point	start point, specify ON_UNSET_POINT to ignore
end_point	end point, specify ON_UNSET_POINT to ignore
bClosed	only matters if rails are closed
tolerance	tolerance for fitting surface and rails
rebuild_mode	0 = no rebuild, 1 = rebuild through points, 2 = refit to tolerance
rebuild_points	if 1 == rebuild_mode, the number of points, otherwise set to 0
refit_tolerance	if 2 == rebuild_mode, the refit tolerance, otherwise set to 0.0
bPreserveHeight	removes the association between the height scaling from the width scaling

◆ Rhino2RailSweepInParts()

RHINO_SDK_FUNCTION bool Rhino2RailSweepInParts	(	ON_SimpleArray< ON_Brep * > &	output_surfaces,
		const ON_Curve *	pRail[2],
		const ON_SimpleArray< const ON_Curve * > &	shapes,
		bool	bClosed = `false`,
		double	tolerance = `0.01`
	)

Description: Sweep2 function that fits a surface through profile curves that define the surface cross-sections and two curves that defines the surface edges. Result are split where parameterization along a rail changes abruptly.

Parameters

output_surfaces	sweep results
pRail	2 rails going the right direction

◆ Rhino2RailSweepOld()

RHINO_SDK_FUNCTION bool Rhino2RailSweepOld	(	ON_SimpleArray< ON_Brep * > &	output_surfaces,
		const ON_Curve *	pRail[2],
		const ON_SimpleArray< const ON_Curve * >	shapes,
		ON_3dPoint	start_point,
		ON_3dPoint	end_point,
		bool	bClosed = `false`,
		double	tolerance = `0.01`,
		int	rebuild_mode = `0`,
		int	rebuild_points = `0`,
		double	refit_tolerance = `0.0`,
		bool	bPreserveHeight = `false`
	)

Description: Sweep2 function that fits a surface through profile curves that define the surface cross-sections and two curves that defines the surface edges. Use this version if you want to create shapes like earlier version of Rhino.

Parameters

output_surfaces	sweep results
pRail	2 rails going the right direction
shapes	shapes will be sorted on rail
start_point	start point, specify ON_UNSET_POINT to ignore
end_point	end point, specify ON_UNSET_POINT to ignore
bClosed	only matters if rails are closed
tolerance	tolerance for fitting surface and rails
rebuild_mode	0 = no rebuild, 1 = rebuild through points, 2 = refit to tolerance
rebuild_points	if 1 == rebuild_mode, the number of points, otherwise set to 0
refit_tolerance	if 2 == rebuild_mode, the refit tolerance, otherwise set to 0.0
bPreserveHeight	removes the association between the height scaling from the width scaling

◆ Rhino3JoinBreps()

RHINO_SDK_FUNCTION ON_Brep* Rhino3JoinBreps	(	const ON_SimpleArray< ON_Brep * > &	Breps,
		ON_ClassArray< ON_SimpleArray< int > > &	JoinData,
		double	tolerance = `0.0`
	)

Description: Low level Brep joining utility designed for use in file reading. Use this when joining a list of Breps for which it is know which pairs are supposed to be joined. Let Ei and Ej be naked edges of Breps[i] and Breps[j], i < j. This routine will attempt to join Ei and Ej if they have an overlap region and j is on the list JoinData[i].

Once this routine has been made more efficient, it will replace TL_JoinBreps() when the JoinData information is known Parameters: Breps - [in] List of Breps to be joined. JoinData - [in] Attempt to join edges from Breps[i] with edges of Breps[JoinData[i][j]] tolerance - [in] overlap tolerance for joining edges Uses document tolerance if <= 0.0 Returns: Joined Brep, or 0 if no edges are joined Process: Append copies of all Breps to JoinedBrep. Attempt to join any appropriate naked edges. Return result. Note: The returned Brep may have several connected components. Caller must separate the components. Returns 0 if no edges are joined. See Also: Rhino3JoinBreps, RhinoJoinBrepNakedEdges(B, tol)

◆ Rhino_dup_cmp_curve()

RHINO_SDK_FUNCTION int Rhino_dup_cmp_curve	(	const ON_Curve *	crva,
		const ON_Curve *	crvb
	)

Description: Compare 2 curves to see if the geometry is the same. Parameters: Pointers to the curves to compare Returns: 1 or -1 if the curves are different 0 if they are the same Notes: This is a fast compare function that can be used for sorting

◆ Rhino_dup_cmp_surface()

RHINO_SDK_FUNCTION int Rhino_dup_cmp_surface	(	const ON_Surface *	srfa,
		const ON_Surface *	srfb
	)

Description: Compare 2 surfaces to see if the geometry is the same. Parameters: Pointers to the surfaces to compare Returns: 1 or -1 if the surfaces are different 0 if they are the same Notes: This is a fast compare function that can be used for sorting

◆ Rhino_TestMathFunction()

RHINO_SDK_FUNCTION double Rhino_TestMathFunction	(	int	function_index,
		double	x,
		double	y
	)

Description: Test math library functions in the TL library. Parameters: function_index - [in] Determines which math library function is called.

     1:    z = x+y
     2:    z = x-y
     3:    z = x*y
     4:    z = x/y
     5:    z = fabs(x)
     6:    z = exp(x)
     7:    z = log(x)
     8:    z = logb(x)
     9:    z = log10(x)
    10:    z = pow(x,y)
    11:    z = sqrt(x)
    12:    z = sin(x)
    13:    z = cos(x)
    14:    z = tan(x)
    15:    z = sinh(x)
    16:    z = cosh(x)
    17:    z = tanh(x)
    18:    z = asin(x)
    19:    z = acos(x)
    20:    z = atan(x)
    21:    z = atan2(y,x)
    22:    z = fmod(x,y)
    23:    z = modf(x,&y)
    24:    z = frexp(x,&y)

double x - [in] double y - [in] Returns: Returns the "z" value listed in the function_index parameter description. Remarks: This function is used to test the results of class floating point functions. It is primarily used to see what happens when Rhino performs illegal math library calls.

◆ RhinoAcadNameString()

RHINO_SDK_FUNCTION void RhinoAcadNameString	(	char *	name,
		int	max_length = `31`,
		bool	bAllowSpace = `false`
	)

Description: Converts a string to a name string valid in AutoCAD Parameters: [in/out] name - a string to convert / the converted string [in] max_len - maximum length of output name [in] bAllowSpaces - optional to allow ' ' in output Remarks: Replaces characters not valid in AutoCAD strings with '_' and truncates to max_length (default == 31 characters)

◆ RhinoActiveCPlane()

const RHINO_SDK_FUNCTION ON_Plane& RhinoActiveCPlane ( )

Description: Return a pointer to the active cplane Returns: pointer to cplane or NULL if there is none.

◆ RhinoAddShutLinesToMesh()

RHINO_SDK_FUNCTION ON_Mesh* RhinoAddShutLinesToMesh	(	const ON_Mesh &	originalMesh,
		const RhShutLiningArgs &	args,
		ON_Terminator *	pCancelHandler = `0`
	)

Description: Use curves to add shutlines to a mesh. Parameters: originalMesh - [in] The mesh to apply shutlining to. args - [in] The arguments used in shutlining. pCancelHandler - [in] Pass an ON_Terminator to provide ability to cancel the operation, use NULL otherwise. Returns: A new mesh with shutlining. NULL if failed. See Also: RhinoMeshPipeFromCurve, RhinoEdgeSoftenMesh, RhinoDisplaceMesh

◆ RhinoAlignMeshVertices()

RHINO_SDK_FUNCTION int RhinoAlignMeshVertices	(	ON_SimpleArray< ON_Mesh * > &	MeshArray,
		const ON_ClassArray< ON_SimpleArray< bool >> &	VertexFlags,
		double	distance
	)

Description: Moves mesh vertices that belong to naked edges to neighboring vertices within the specified distance.

Parameters: MeshArray - [in/out] Input array of meshes. These meshes are modified. VertexFlags - [in] Array of arrays of flags to determine which vertices may be modified. distance - [in] Distance to not exceed when modifying the meshes.

Returns: Count of all vertices that were modified if successful. -1 for error.

◆ RhinoAlignVertices()

RHINO_SDK_FUNCTION int RhinoAlignVertices	(	ON_SimpleArray< const ON_Geometry * > &	meshesSubdsAndPointclouds,
		ON_SimpleArray< ON_Geometry * > &	results,
		double	distance,
		bool	onlyNaked,
		const ON_SimpleArray< const ON_SimpleArray< bool > * > *	vertexFlags,
		bool	averagePoints
	)

Description: Moves mesh vertices that belong to naked edges to neighboring vertices within the specified distance. Does not modify the input array. Parameters: results - [out] The returned results. Nullptr is inserted if the input needs no adjusting. [same as above]

◆ RhinoAlignVerticesInPlace()

RHINO_SDK_FUNCTION int RhinoAlignVerticesInPlace	(	ON_SimpleArray< ON_Geometry * > &	meshesSubdsAndPointclouds,
		double	distance,
		bool	onlyNaked,
		const ON_SimpleArray< const ON_SimpleArray< bool > * > *	vertexFlags,
		bool	averagePoints
	)

Description: Moves mesh vertices that belong to naked edges to neighboring vertices within the specified distance.

Parameters: meshesSubdsAndPointclouds - [in/out] Input array of meshes, meshes pointclouds and subds. These inputs are modified. distance - [in] Distance to not exceed when modifying the meshes. onlyNaked - [in] Only target naked edges for modification and snapping to. vertexFlags - [in] Array of arrays of flags to determine which vertices may be modified. Can be null averagePoints - [in] Instructs Rhino to move candidate points near each other, rather than priviledging one. Returns: Count of all vertices that were modified if successful. -1 for error.

◆ RhinoApp()

RHINO_SDK_FUNCTION class CRhinoApp& RhinoApp ( )

returns theApp

◆ RhinoApplyTopologyLaplacianToScalar()

RHINO_SDK_FUNCTION bool RhinoApplyTopologyLaplacianToScalar	(	const ON_Mesh &	mesh,
		ON_SimpleArray< double > &	scalarValues
	)

Description: Function that will apply the (pure, not area-weighted) cotangent-weighted Laplacian operator to a scalar field, specified at the topology vertices of the mesh. Parameters: mesh - [in] Input mesh scalarValues - [in, out] the scalar values to be Laplaced on input, and the result on output. Their count must be the number of the mesh's topology vertices. Returns: True or false depending on the success of the operation.

◆ RhinoAppVersionBuildDescription()

const RHINO_SDK_FUNCTION char* RhinoAppVersionBuildDescription ( )

Returns: Rhino application version build description.

◆ RhinoAppVersionGetQuartet()

RHINO_SDK_FUNCTION unsigned int RhinoAppVersionGetQuartet ( unsigned int rhino_app_version_quartet[4] )

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. Parameters: rhino_app_version_quartet - [out] rhino_app_version_quartet[0] = major version rhino_app_version_quartet[1] = minor version (service release) rhino_app_version_quartet[2] = (year - 1000)*1000 + (day of year) rhino_app_version_quartet[3] = (hour*1000 + minute*10 + branch) Returns: Rhino application version number = RHINO_VERSION_NUMBER. Remarks: The application version is not the same as the RhinoSdkVersion() or the RhinoSdkServiceRelease().

◆ RhinoAppVersionQuartetAsString()

const RHINO_SDK_FUNCTION char* RhinoAppVersionQuartetAsString ( )

Returns: Rhino application version quartet as a string = RHINO_VERSION_NUMBER_STRING. Remarks: The application version is not the same as the RhinoSdkVersion() or the RhinoSdkServiceRelease().

◆ RhinoAppVersionQuartetAsWideString()

const RHINO_SDK_FUNCTION wchar_t* RhinoAppVersionQuartetAsWideString ( )

Returns: Rhino application version quartet as a wide string = RHINO_VERSION_NUMBER_WSTRING. Remarks: The application version is not the same as the RhinoSdkVersion() or the RhinoSdkServiceRelease().

◆ RhinoArcLineArcBlend()

RHINO_SDK_FUNCTION ON_Curve* RhinoArcLineArcBlend	(	ON_3dPoint	P0,
		ON_3dVector	D0,
		ON_3dPoint	P1,
		ON_3dVector	D1,
		double	radius
	)

Description: Creates an arc-line-arc blend curve between two curves. Parameters: P0 - [in] Point on the first curve. D0 - [in] Tangent direction at P0. P1 - [in] Point on the second curve. D1 - [in] Tangent direction a P1. radius - [in] The radius of the arc segments. Returns: A pointer to a polycurve if successful, nullptr on failure. Note, memory for the output curve is allocated and becomes the responsibility of the caller. Remarks: Output is generally a polycurve with three segments: Arc, Line, Arc. The first arc segment will start at P0, with starting tangent D0. The second arc segment will end at P1 with end tangent D1. The line segment will start from the end of the first arc segment and end at start of the second arc segment, and it will be tangent to both arcs at those points. In some cases, one or more of those segments will be absent because they would have 0 length. If there is only a single segment, the result will not be a polycurve.

◆ RhinoArePointsCoplanar() [1/2]

RHINO_SDK_FUNCTION BOOL32 RhinoArePointsCoplanar	(	ON_SimpleArray< ON_3dPoint > &	points,
		ON_3dPoint *	pPoint = `nullptr`,
		ON_3dVector *	pNormal = `nullptr`,
		double	tolerance = `ON_ZERO_TOLERANCE`
	)

Description: Tests if the points in an array are coplanar Parameters: points [in] - the array of points to test pPlane [in] - Optional pointer to return the plane if the points are coplanar tolerance [in] - Optional tolerance for distance from the plane Returns: @untitled table TRUE Points are Coplanar False Points are not Coplanar

◆ RhinoArePointsCoplanar() [2/2]

RHINO_SDK_FUNCTION BOOL32 RhinoArePointsCoplanar	(	ON_SimpleArray< ON_4dPoint > &	points,
		ON_3dPoint *	pPoint = `nullptr`,
		ON_3dVector *	pNormal = `nullptr`,
		double	tolerance = `ON_ZERO_TOLERANCE`
	)

◆ RhinoAutoAdjustTargetDepth()

RHINO_SDK_FUNCTION bool RhinoAutoAdjustTargetDepth	(	CRhinoViewport *	pViewport,
		const ON_2iPoint *	pMousePoint = `nullptr`,
		const double *	pFocusSize = `nullptr`,
		const double *	pWeight = `nullptr`
	)

Description: Automatically adjusts camera target depth based on objects within the rectangular focus area in the viewport. Parameters: pViewport - [in/out] Viewport to adjust. pMousePoint - [in] Center of focus. Default is viewport center. pFocusSize - [in] Focus rectangle size relative to viewport size. Default is 0.5. pWeight - [in] Weight of adjustment. 0.0 means use old target (=no change), 1.0 means use the new adjusted target. Default is 1.0. Return: True if target was adjusted.

◆ RhinoBackupFile()

RHINO_SDK_FUNCTION BOOL32 RhinoBackupFile	(	const wchar_t *	filename,
		ON_wString &	backup_filename
	)

Description: Rename an existing file for temporary backup purposes. Parameters: filename - [in] name of existing file backup_filename - [out] new file name created by RhinoGetUnusedFilename(drive+path+$$rhino_temp$$+ext,...) Drive drive, path, and ext are from filename. Returns: TRUE if candidate_filename is successfully renamed unused_filename. FALSE if filename did not exist or could not be renamed. If FALSE is returned, then unused_filename is not changed.

◆ RhinoBooleanDifference() [1/2]

RHINO_SDK_FUNCTION bool RhinoBooleanDifference	(	const ON_SimpleArray< const ON_Brep * > &	InBreps0,
		const ON_SimpleArray< const ON_Brep * > &	InBreps1,
		double	tolerance,
		bool *	bResult,
		ON_SimpleArray< ON_Brep * > &	OutBreps,
		ON_SimpleArray< int > &	InputIndexForOutput,
		bool	bManifoldOnly = `true`,
		bool *	bRaisedTol = `nullptr`
	)

Description: Subtract each Brep of Inbreps1 from each Brep of InBreps0. Parameters: InBreps0 - [in] First set of input Breps. InBreps1 - [in] Second set of input Breps. tolerance - [in] Distance tolerance. bResult - [out] True if any of the Breps had intersecting faces. If false, and OutBreps.Count() is less than InBreps0.Count(), then some closed Breps were inside others, or bManifoldOnly == true and some were non-manifold. OutBreps - [out] Resulting Breps. IndexForInputs - [out] OutBrep[i] is the result if subtracting something from InBreps0[InputIndexForOutPut[i]]. bManifoldOnly - [in] If true, leave out any non-manifold input Breps. bRaisedTol - [out] If non-null and Boolean fails at tolerance, try at twice tolerance and indicate success. Returns: false if error Remarks: Think of this as an operation on InBreps0. Each Brep of InBreps1 may remove part of a Brep of InBreps0. If a member of InBreps0 does not intersect any member of InBreps1, then it is copied to OutBreps.

◆ RhinoBooleanDifference() [2/2]

RHINO_SDK_FUNCTION bool RhinoBooleanDifference	(	const ON_SimpleArray< const ON_Brep * > &	InBreps0,
		const ON_SimpleArray< const ON_Brep * > &	InBreps1,
		double	tolerance,
		bool *	bResult,
		ON_SimpleArray< ON_Brep * > &	OutBreps,
		ON_SimpleArray< ON_3dPoint > &	NakedEdgePoints,
		ON_SimpleArray< ON_3dPoint > &	BadIntersectionPoints,
		ON_SimpleArray< ON_3dPoint > &	NonmanifoldEdgePoints,
		ON_SimpleArray< int > &	InputIndexForOutput,
		bool	bManifoldOnly = `true`,
		bool *	bRaisedTol = `nullptr`
	)

Description: Subtract each Brep of Inbreps1 from each Brep of InBreps0. Parameters: InBreps0 - [in] First set of input Breps. InBreps1 - [in] Second set of input Breps. tolerance - [in] Distance tolerance. bResult - [out] True if any of the Breps had intersecting faces. If false, and OutBreps.Count() is less than InBreps0.Count(), then some closed Breps were inside others, or bManifoldOnly == true and some were non-manifold. OutBreps - [out] Resulting Breps. NakedEdgePoints - [out] If Boolean failed because the intersection hit a naked edge, a point will be added where the intersection hits the edge. BadIntersectionPoints - [out] If Boolean failed because an intersection ends on the interior of both surfaces, a point is added. This happens when the surface intersector fails. NonmanifoldEdgePoints - [out] If Boolean failed because the intersection hit a non-manifold edge, a point will be added where the intersection hits the edge. IndexForInputs - [out] OutBrep[i] is the result if subtracting something from InBreps0[InputIndexForOutPut[i]]. bManifoldOnly - [in] If true, leave out any non-manifold input Breps. bRaisedTol - [out] If non-null and Boolean fails at tolerance, try at twice tolerance and indicate success. Returns: false if error Remarks: Think of this as an operation on InBreps0. Each Brep of InBreps1 may remove part of a Brep of InBreps0. If a member of InBreps0 does not intersect any member of InBreps1, then it is copied to OutBreps.

◆ RhinoBooleanIntersection() [1/2]

RHINO_SDK_FUNCTION bool RhinoBooleanIntersection	(	const ON_SimpleArray< const ON_Brep * > &	InBreps0,
		const ON_SimpleArray< const ON_Brep * > &	InBreps1,
		double	tolerance,
		bool *	bResult,
		ON_SimpleArray< ON_Brep * > &	OutBreps,
		bool	bManifoldOnly = `true`,
		bool *	bRaisedTol = `nullptr`
	)

Description: Intersect each Brep of InBreps0 with the Breps of InBreps1, Separate into disjoint pieces. Parameters: InBreps0 - [in] First set of input Breps. InBreps1 - [in] Second set of input Breps. tolerance - [in] Distance tolerance. bResult - [out] True if any of the Breps had intersecting faces, If false, and OutBreps.Count() is not empty, then some closed Breps were inside others, or bManifoldOnly == true and some were non-manifold. OutBreps - [out] Resulting Breps. bManifoldOnly - [in] If true, leave out any non-manifold input Breps. bRaisedTol - [out] If non-null and Boolean fails at tolerance, try at twice tolerance and indicate success. Returns: false if error Remarks: Think of this as an operation on InBreps0. Each Brep of InBreps1 may remove part of a Brep of InBreps0. If a member of InBreps0 does not intersect any member of InBreps1, then it is copied to OutBreps.

◆ RhinoBooleanIntersection() [2/2]

RHINO_SDK_FUNCTION bool RhinoBooleanIntersection	(	const ON_SimpleArray< const ON_Brep * > &	InBreps0,
		const ON_SimpleArray< const ON_Brep * > &	InBreps1,
		double	tolerance,
		bool *	bResult,
		ON_SimpleArray< ON_Brep * > &	OutBreps,
		ON_SimpleArray< ON_3dPoint > &	NakedEdgePoints,
		ON_SimpleArray< ON_3dPoint > &	BadIntersectionPoints,
		ON_SimpleArray< ON_3dPoint > &	NonmanifoldEdgePoints,
		bool	bManifoldOnly = `true`,
		bool *	bRaisedTol = `nullptr`
	)

Description: Intersect each Brep of InBreps0 with the Breps of InBreps1, Separate into disjoint pieces. Parameters: InBreps0 - [in] First set of input Breps. InBreps1 - [in] Second set of input Breps. tolerance - [in] Distance tolerance. bResult - [out] True if any of the Breps had intersecting faces. If false, and OutBreps.Count() is not empty, then some closed Breps were inside others, or bManifoldOnly == true and some were non-manifold. OutBreps - [out] Resulting Breps. NakedEdgePoints - [out] If Boolean failed because the intersection hit a naked edge, a point will be added where the intersection hits the edge. BadIntersectionPoints - [out] If Boolean failed because an intersection ends on the interior of both surfaces, a point is added. This happens when the surface intersector fails. NonmanifoldEdgePoints - [out] If Boolean failed because the intersection hit a non-manifold edge, a point will be added where the intersection hits the edge. bManifoldOnly - [in] If true, leave out any non-manifold input Breps. bRaisedTol - [out] If non-null and Boolean fails at tolerance, try at twice tolerance and indicate success. Returns: false if error Remarks: Think of this as an operation on InBreps0. Each Brep of InBreps1 may remove part of a Brep of InBreps0. If a member of InBreps0 does not intersect any member of InBreps1, then it is copied to OutBreps.

◆ RhinoBooleanSplit()

RHINO_SDK_FUNCTION bool RhinoBooleanSplit	(	const ON_SimpleArray< const ON_Brep * > &	InBreps0,
		const ON_SimpleArray< const ON_Brep * > &	InBreps1,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	OutBreps
	)

Description: Splits shared areas of Breps and creates separate Breps from the shared and unshared parts. Parameters: InBreps0 - [in] The Breps to split. InBreps1 - [in] The cutting Breps. tolerance - [in] distance tolerance OutBreps - [out] Resulting Breps Returns: true if successful Remarks: NOTE, memory for OutBreps is allocated and becomes the responsibility of the caller.

◆ RhinoBooleanUnion() [1/2]

RHINO_SDK_FUNCTION bool RhinoBooleanUnion	(	const ON_SimpleArray< const ON_Brep * > &	InBreps,
		double	tolerance,
		bool *	bResult,
		ON_SimpleArray< ON_Brep * > &	OutBreps,
		bool	bManifoldOnly = `true`,
		bool *	bRaisedTol = `nullptr`
	)

Description: Find the union of the Breps in InBreps. Separate into disjoint pieces. Parameters: InBreps - [in] Breps to be unioned. tolerance - [in] distance tolerance bResult - [out] True if any of the Breps had intersecting faces. If false and OutBreps.Count() is less than InBreps.Count(), then some closed Breps were inside others, or bManifoldOnly == true and some were non-manifold. OutBreps - [out] Resulting Breps. bManifoldOnly - [in] If true, leave out any non-manifold input Breps. bRaisedTol - [out] If non-null and Boolean fails at tolerance, try at twice tolerance and indicate success. Returns: false if error

◆ RhinoBooleanUnion() [2/2]

RHINO_SDK_FUNCTION bool RhinoBooleanUnion	(	const ON_SimpleArray< const ON_Brep * > &	InBreps,
		double	tolerance,
		bool *	bResult,
		ON_SimpleArray< ON_Brep * > &	OutBreps,
		ON_SimpleArray< ON_3dPoint > &	NakedEdgePoints,
		ON_SimpleArray< ON_3dPoint > &	BadIntersectionPoints,
		ON_SimpleArray< ON_3dPoint > &	NonmanifoldEdgePoints,
		bool	bManifoldOnly = `true`,
		bool *	bRaisedTol = `nullptr`
	)

Description: Find the union of the Breps in InBreps. Separate into disjoint pieces. Parameters: InBreps - [in] Breps to be unioned. tolerance - [in] Distance tolerance bResult - [out] True if any of the Breps had intersecting faces. If false and OutBreps.Count() is less than InBreps.Count(), then some closed Breps were inside others, or bManifoldOnly == true and some were non-manifold. OutBreps - [out] Resulting Breps. The caller is reponsible for the allocated memory. NakedEdgePoints - [out] If Boolean failed because the intersection hit a naked edge, a point will be added where the intersection hits the edge. BadIntersectionPoints - [out] If Boolean failed because an intersection ends on the interior of both surfaces, a point is added. This happens when the surface intersector fails. NonmanifoldEdgePoints - [out] If Boolean failed because the intersection hit a non-manifold edge, a point will be added where the intersection hits the edge. bManifoldOnly - [in] If true, leave out any non-manifold input Breps. bRaisedTol - [out] If non-null and Boolean fails at tolerance, try at twice tolerance and indicate success. Returns: false if error

◆ RhinoBrepBaseballSphere()

RHINO_SDK_FUNCTION ON_Brep* RhinoBrepBaseballSphere	(	const ON_3dPoint &	center,
		double	radius,
		double	tolerance,
		ON_Brep *	pBrep = `nullptr`
	)

Description: Get a Brep definition of a sphere. Parameters: center - [in] Center of sphere radius - [in] Radius of sphere tolerance - [in] Used in computing 2d trimming curves. If <= 0.0, then max of 0.0001 * radius and ON_ZERO_TOLERANCE will be used. pBrep - [in] If not nullptr, this Brep will be used and returned. If not nullptr and creation failed, nullptr will be returned and *pBrep will be an empty Brep. Returns: A Brep representation of the sphere with two similar trimmed NURBS surfaces and no singularities. or nullptr if failure. Remarks: NOTE: Memory for the Brep is allocated and becomes the responsibility of the caller.

◆ RhinoBrepCapPlanarHoles() [1/2]

RHINO_SDK_FUNCTION ON_Brep* RhinoBrepCapPlanarHoles	(	const ON_Brep *	pInputBrep,
		const double &	tol
	)

Description: Make planar faces out of planar closed boundaries. Parameters: pInputBrep - [in] the Brep. tol - [in] tolerance to determine planarity and for joining Returns: A joined, capped Brep if successful. Null if it failed.

◆ RhinoBrepCapPlanarHoles() [2/2]

RHINO_SDK_FUNCTION ON_Brep* RhinoBrepCapPlanarHoles	(	const ON_Brep *	pInputBrep,
		const double &	tol,
		const bool &	bDisplayErrors
	)

Description: Make planar faces out of planar closed boundaries. Parameters: pInputBrep - [in] the Brep. tol - [in] tolerance to determine planarity and for joining bDisplayErrors - [in] write error conditions to the command line Returns: A joined, capped Brep if successful. Null if it failed.

◆ RhinoBrepCapPlanarHolesOld()

RHINO_SDK_FUNCTION ON_Brep* RhinoBrepCapPlanarHolesOld	(	const ON_Brep *	pInputBrep,
		const double &	tol,
		const bool &	bDisplayErrors
	)

◆ RhinoBrepClosestPoint()

RHINO_SDK_FUNCTION bool RhinoBrepClosestPoint	(	const ON_Brep &	brep,
		ON_3dPoint	pt,
		ON_COMPONENT_INDEX *	ci,
		double *	s,
		double *	t,
		ON_3dPoint *	brep_point = `nullptr`,
		double	maximum_distance = `0.0`
	)

Description: Finds a point on a Brep that is closest to a test point. Parameters: brep - [in] input Brep pt - [in] base point to project to surface ci - [out] Component index of the Brep component that contains the closest point. Possible types are brep_face, brep_edge or brep_vertex s - [out] If the component_index type is brep_edge, then s is the parameter of the closest edge point. t - [out] If the component_index type is brep_face, then (s,t) is the parameter of the closest edge point. brep_point - [out] if not NULL and true is returned, this is the location of the closest Brep point. maximum_distance - [in]. If maximum_distance > 0, then only points whose distance to p0 is <= maximum_distance will be returned. Using a positive value of maximum_distance can substantially speed up the search. Returns: TRUE - successful FALSE - failure - No point exists within maximum_distance See Also: ON_Surface::GetClosestPoint ON_Brep::ComponentIndexType

◆ RhinoBrepCombineMarkedVerticesAndEdges()

RHINO_SDK_FUNCTION bool RhinoBrepCombineMarkedVerticesAndEdges	(	ON_Brep &	B,
		double	tol,
		bool	bCompact = `true`
	)

Description: Combine vertices with same m_vertex_user.i, Combine edges with same m_edge_user.i that are within tolerance Parameters: B [in] Brep with edges and vertices to be combined. tol [in] 3d distance tolerance for detecting overlapping edges bCompact [in] if true, set Brep flags and tolerances, remove unused faces and edges Returns: true if all indicated edges and vertices were combined. false if some pair could not be combined Remarks: The vertex and edge user fields will be changed by this routine. If bCompact is false, B will have unused edges and vertices. This routine is intended for use in file translation applications for which the topology information is available but not easily accessible at a useful time.

◆ RhinoBrepFaceClosestPoint()

RHINO_SDK_FUNCTION bool RhinoBrepFaceClosestPoint	(	const ON_BrepFace &	face,
		ON_3dPoint	P,
		double *	s,
		double *	t,
		double	maximum_distance = `0.0`,
		const ON_Interval *	sdomain = `nullptr`,
		const ON_Interval *	tdomain = `nullptr`
	)

Description: Get the parameters of the point on the Brep face that is closest to P. Parameters: face - [in] face to test P - [in] test point s - [out] t - [out] (*s,*t) = parameters of the surface point that is closest to P. maximum_distance = 0.0 - [in] optional upper bound on the distance from P to the surface. If you are only interested in finding a point Q on the surface when P.DistanceTo(Q) < maximum_distance, then set maximum_distance to that value. sdomain = 0 - [in] optional domain restriction tdomain = 0 - [in] optional domain restriction Returns: True if successful. If false, the values of *s and *t are undefined. See Also: ON_Surface::GetClosestPoint RhinoBrepClosestPoint

◆ RhinoBrepFaceRemoveInnerLoops()

RHINO_SDK_FUNCTION ON_Brep* RhinoBrepFaceRemoveInnerLoops	(	const ON_Brep &	brep,
		ON_COMPONENT_INDEX	face_ci,
		double	tolerance
	)

Description: Remove all inner loops (holes) in a Brep face. Parameters: brep - [in] the Brep to convert. face_ci - [in] face component index tolerance - [in] tolerance. Returns: Pointer to Brep if success, nullptr if unsuccessful.

◆ RhinoBrepRemoveAllInnerLoops()

RHINO_SDK_FUNCTION ON_Brep* RhinoBrepRemoveAllInnerLoops	(	const ON_Brep &	brep,
		double	tolerance
	)

Description: Remove all inner loops (holes) in a Brep. Parameters: brep - [in] the Brep to convert. tolerance - [in] tolerance. Returns: Pointer to Brep if success, nullptr if unsuccessful.

◆ RhinoBrepRemoveInnerLoops()

RHINO_SDK_FUNCTION ON_Brep* RhinoBrepRemoveInnerLoops	(	const ON_Brep &	brep,
		ON_SimpleArray< ON_COMPONENT_INDEX >	loops_ci,
		double	tolerance
	)

Description: Remove a list of inner loops. Parameters: brep - [in] the Brep to convert. loops_ci - [in] list of loops to remove tolerance - [in] tolerance. Returns: Pointer to Brep if success, nullptr if unsuccessful.

◆ RhinoBrepShrinkSurfaceToEdge()

RHINO_SDK_FUNCTION bool RhinoBrepShrinkSurfaceToEdge	(	ON_Brep &	brep,
		int	face_index
	)

Description: Contracts the underlying untrimmed surface of a Brep face right to the to the trimming boundaries. Note, shrinking the trimmed surface can sometimes cause problems later since having the edges so close to the trimming boundaries can cause commands that use the surface edges as input to fail. Parameters: brep - [in] The Brep. face_index- [in] The index of the Brep face. Returns: true if successful, false otherwise.

◆ RhinoBrepSplit() [1/4]

RHINO_SDK_FUNCTION bool RhinoBrepSplit	(	const ON_Brep &	brep,
		const ON_Brep &	splitter,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	pieces,
		bool *	bRaisedTol = `nullptr`
	)

Description: Splits a Brep into pieces. Parameters: brep - [in] Brep to split. splitter - [in] Splitter is a single possibly non-manifold brep. tolerance - [in] Intersection tolerance pieces - [out] Output array that contains all the split components. Note, the caller is responsible for destroying these objects. bRaisedTol - [in/out] If not null then *bRaisedTol is set to true if the split failed at tolerance but succeeded when the tolerance was increased to twice tolerance. Returns: true if successful.

◆ RhinoBrepSplit() [2/4]

RHINO_SDK_FUNCTION int RhinoBrepSplit	(	const ON_Brep &	brep,
		const ON_SimpleArray< const ON_Brep * > &	cutters,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	pieces
	)

Description: Splits a Brep into pieces using Breps as cutters Parameters: brep - [in] The Brep to split. cutters - [in] An array of one or more Breps to use as cutters. tolerance - [in] The intersection tolerance pieces - [out] Output array that contains the split components. Returns: The number of Breps added to the output array. Remarks: NOTE, memory for the resulting Breps is allocated and becomes the responsibility of the caller.

◆ RhinoBrepSplit() [3/4]

RHINO_SDK_FUNCTION int RhinoBrepSplit	(	const ON_Brep &	brep,
		const ON_SimpleArray< const ON_Curve * > &	cutters,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	pieces
	)

Description: Splits a Brep into pieces using curves (at least partially) on the Brep Parameters: brep - [in] The Brep to split. cutters - [in] An array of curves. Only the portion of the curve on the Brep surface will be used for cutting. tolerance - [in] The intersection tolerance pieces - [out] Output array that contains the split components. Returns: The number of Breps added to the output array. Remarks: This is one of the splitting functions used to split Breps in the Rhino Split command. NOTE, memory for the resulting Breps is allocated and becomes the responsibility of the caller.

◆ RhinoBrepSplit() [4/4]

RHINO_SDK_FUNCTION int RhinoBrepSplit	(	const ON_Brep &	brep,
		const ON_SimpleArray< const ON_Geometry * > &	cutters,
		ON_3dVector	CPlaneNormal,
		bool	PlanView,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	pieces
	)

Description: Splits a Brep into pieces using a combination of curves to be extruded and Breps. Parameters: brep - [in] The Brep to split. cutters - [in] An array of curves, surfaces, faces and Breps, any other geometry is ignored. CPlaneNormal - Construction Plane Normal and PlanView are used in deciding how to extrude a curve into a cutter ( see Remark below) PlanView - true if this view is plan. tolerance - [in] The intersection tolerance pieces - [out] Output array that contains the split components. Returns: The number of Breps added to the output array. Remarks: This is one of the splitting functions used to split Breps in the Rhino Split command.

Extrusion of Cutting Curves A Curve in cutters is extruded to produce a surface to use as a cutter. The extrusion direction is choose as in the Rhino Split command based on the properties of the active view. In particular the Construction Plane Normal and whether the active view is a PlanView ( A parallel projection with construction plane normal as the view direction).

If PlanView is false and the curve is planar then the curve is extruded perpendicular to the curve, otherwise the curve is extruded in the CPlaneNormal direction.

NOTE, memory for the resulting Breps is allocated and becomes the responsibility of the caller.

◆ RhinoBrepTrim() [1/2]

RHINO_SDK_FUNCTION int RhinoBrepTrim	(	const ON_Brep &	B,
		const ON_Brep &	Cutter,
		double	tol,
		ON_SimpleArray< ON_Brep * > &	Trim,
		ON_ClassArray< ON_SimpleArray< int > > *	fmap = `nullptr`,
		ON_ClassArray< ON_SimpleArray< int > > *	emap = `nullptr`
	)

Description: Trim a Brep B with an oriented cutter. The parts of B that lie to inside ( opposite the normal) of the cutter are retained while the parts to the outside ( in the direction of the normal ) are discarded. If the Cutter is closed, or is an ON_Plane, then a connected component of B that does not intersect the Cutter is kept if it is contained in the inside of Cutter. That is the region bounded by Cutter opposite from the normal of Cutter, or in the case of an ON_Plane cutter the half space opposite from the plan normal If Cutter is not closed all these components are kept. Parameters: B -(in) Brep to trim Cutter-(in) cutter is either a Brep or an ON_Plane object tol -(in) intersection tolerance Trim -(out) Results are appended to Trim, user is responsible for deleting these objects. fmap - (out) Optional parameter. fmap[i][fi] is the index of the face in B corresponding to Trim[i].Face(fi).

emap - (out) Optional parameter. emap[i][ei] is the index of the edge in B corresponding to Trim[i].Edge(ei) or -1 it this edge lies on the cutter.

Returns: The number, cnt, of connected components of what is retained from B. If cnt >1 or cnt=1 and the result is different from B then cnt many Breps are appended to Trim. If cnt=0 or the object doesn't get trimmed by the cutter, in which case cnt=1, then no objects are appended to Trim. Details: Trim, *fmap and *emap are parallel arrays so they must have the same count at entry and will have the same count at exit.

The special handling of cnt==1 is provided so that the function does not make extra copies of Breps that are not modified by the trim operation. This could be important for example if this function is applied to many Breps most of which don't actually get trimmed

◆ RhinoBrepTrim() [2/2]

RHINO_SDK_FUNCTION int RhinoBrepTrim	(	const ON_Brep &	B,
		const ON_Plane &	Cutter,
		double	tol,
		ON_SimpleArray< ON_Brep * > &	Trim,
		ON_ClassArray< ON_SimpleArray< int > > *	fmap = `nullptr`,
		ON_ClassArray< ON_SimpleArray< int > > *	emap = `nullptr`
	)

◆ RhinoCalcTriangleArea()

RHINO_SDK_FUNCTION double RhinoCalcTriangleArea	(	ON_3dPoint	A,
		ON_3dPoint	B,
		ON_3dPoint	C
	)

Description: RhinoCalcTriangleArea calculates the area of a triangle using the Heron formula.

Heron Formula Area=SQRT(S(S-A)(S-B)(S-C)), where S=(A+B+C)/2 or perimeter/2.

Parameters: A - [In] First point of the triangle B - [In] Second point of the triangle C - [In] Third point of the triangle Returns: The area of the triangle.

◆ RhinoCalculateAspectRatio()

RHINO_SDK_FUNCTION double RhinoCalculateAspectRatio	(	ON_3dPoint	A,
		ON_3dPoint	B,
		ON_3dPoint	C,
		ON_3dPoint	D
	)

Description: Worker function to determine aspect ratios for the faces in the function above; Parameters: A, B, C, D - [In] 4 vertices of a mesh face, face_points[2] and face_points[3] are identical for triangles

Returns: Aspect ratio of face.

Remarks: This function was is really meant for public consumption outside of the context of
RhinoCollapseMeshFacesByAspectRatio. It's handy if you'd like to determine what faces might be considered as candidates prior to calling RhinoCollapseMeshFacesByAspectRatio.

◆ RhinoCaptureObject()

RHINO_SDK_FUNCTION bool RhinoCaptureObject	(	CRhinoMorphControl *	control_object,
		CRhinoObject *	captive_object
	)

Description: Sets up information that allows a control object to deform a captive. The captive object cannot have grips on. Parameters: control_object - [in] captive_object - [in] Returns: True if capture is successful.

◆ RhinoChangeSeam()

RHINO_SDK_FUNCTION ON_Brep* RhinoChangeSeam	(	const ON_BrepFace &	Face,
		int	di,
		double	t,
		double	tol
	)

Description: Change the seam of a closed trimmed surface. Parameters: Face - [in] A face Brep with a closed underlying surface. di - [in] the parameter direction to 0=u, 1 = v t - [in] the parameter at which to place the seam. tol - [in] tolerance used to cut up surface Returns: a pointer to a new surface or polysurface that has the same geometry as Face with the relocated seam. Notes: Must have the following conditions where: Srf = Face.SurfaceOf() Srf->IsClosed(di), Srf->Domain(di).Includes(t,true)

◆ RhinoCheckMesh() [1/3]

RHINO_SDK_FUNCTION bool RhinoCheckMesh	(	const ON_Mesh *	pMesh,
		ON_TextLog &	text_log,
		RhinoCheckMeshOutput &	output
	)

Description: RhinoCheckMesh examines the input meshand creates a description of what it finds wrong with the input in text_log. The various things the function checks for are described below in the output parameters. Parameters: pMesh - [In] Mesh to examine. text_log - [Out] ON_TextLog with printed output of what was discovered based on the things set to check in the output parameter output - [In/Out] Flags to determine what to check and counts for those things that were checked. See RhinoCheckMeshOutput above. Returns: Returns true if the function determined there was anything wrong with any of the input meshes, false otherwise.

◆ RhinoCheckMesh() [2/3]

RHINO_SDK_FUNCTION bool RhinoCheckMesh	(	const ON_SimpleArray< const CRhinoMeshObject * > &	pMeshObjArray,
		ON_TextLog &	text_log,
		RhinoCheckMeshOutput &	output
	)

Description: RhinoCheckMesh examines the input meshes contained in pMeshObjArray. It creates a description of what it finds wrong with the input in text_log. The various things the function checks for are described below in the output parameters. Parameters: pMeshObjArray - [In] Mesh(es) to examine. Numbers in output make most sense when one mesh is examined at a time though. text_log - [Out] ON_TextLog with printed output of what was discovered based on the things set to check in the output parameter, include description of the CRhinoMeshObject. output - [In/Out] Flags to determine what to check and counts for those things that were checked. See RhinoCheckMeshOutput above. Returns: Returns true if the function determined there was anything wrong with any of the input meshes, false otherwise.

◆ RhinoCheckMesh() [3/3]

RHINO_SDK_FUNCTION bool RhinoCheckMesh	(	const ON_SimpleArray< const ON_Mesh * > &	pMeshArray,
		ON_TextLog &	text_log,
		RhinoCheckMeshOutput &	output
	)

Description: RhinoCheckMesh examines the input meshes contained in pMeshObjArray. It creates a description of what it finds wrong with the input in text_log. The various things the function checks for are described below in the output parameters. Parameters: pMeshObjArray - [In] Mesh(es) to examine. Numbers in output make most sense when one mesh is examined at a time though. text_log - [Out] ON_TextLog with printed output of what was discovered based on the things set to check in the output parameter output - [In/Out] Flags to determine what to check and counts for those things that were checked. See RhinoCheckMeshOutput above. Returns: Returns true if the function determined there was anything wrong with any of the input meshes, false otherwise.

◆ RhinoCleanUpPolyCurve()

RHINO_SDK_FUNCTION ON_Curve* RhinoCleanUpPolyCurve ( const ON_PolyCurve & PC )

Description: Removes any nesting of polycurves. If PC has just a single segment, the segment is returned. If, after nest removal, there are adjacent segments which are polylines, they are combined into a single polyline. Parameters: PC [in] Polycurve to clean up. Returns: NULL if PC is unchanged Otherwise, a new curve that is not necessarily a polycurve. Remarks: The new curve may have a different domain from PC. If the start and end segments of a closed input are polylines, the result may have a different seam location since the start and end segments will be combined. The caller is responsible for destroying the returned curve.

◆ RhinoCollapseMeshEdge()

RHINO_SDK_FUNCTION bool RhinoCollapseMeshEdge	(	ON_Mesh &	mesh,
		int	edgeIndex
	)

Description: Collapses a mesh edge based on criteria found in Stan Melax's polygon reduction, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf

Parameters: mesh - [In/Out] Input mesh edgeIndex - [In] Edge index to collapse

Returns: True on success.

◆ RhinoCollapseMeshEdges()

RHINO_SDK_FUNCTION int RhinoCollapseMeshEdges	(	ON_Mesh &	Mesh,
		bool	bGreaterThan,
		double	edgeLength
	)

Description: Collapses a multiple mesh edges(faces), determined by edge length, based on criteria found in Stan Melax's polygon reduction, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf

Parameters: mesh - [In / Out] Input mesh bGreaterThan - [In] Determines whether edges with lengths greater than or equal to edgeLength are considered candidates. edgeLength - [In] Length of edge to consider as candidates.

Returns: Number of edges that were collapsed in the process. This number may differ from the initial number of edges that meet the input criteria because the lengths of some initial edges may be altered as other edges are collapsed. Returns -1 for general failure (like bad topology or index out of range) or -2 if all of the edges would be collapsed and the resulting mesh would be invalid.

◆ RhinoCollapseMeshFace()

RHINO_SDK_FUNCTION bool RhinoCollapseMeshFace	(	ON_Mesh &	mesh,
		int	faceIndex
	)

Description: Collapses a mesh face based on criteria found in Stan Melax's polygon reduction, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf

Parameters: mesh - [In/Out] Input mesh faceIndex - [In] Face index to collapse

Returns: True on success.

◆ RhinoCollapseMeshFacesByArea()

RHINO_SDK_FUNCTION int RhinoCollapseMeshFacesByArea	(	ON_Mesh &	Mesh,
		double	lessThanArea,
		double	greaterThanArea
	)

Description: Collapses a multiple mesh faces, determined by face area, based on criteria found in Stan Melax's polygon reduction, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf

Parameters: mesh - [In / Out] Input mesh double lessThanArea - [In] Area in which faces are selected if their area is less than or equal to double greaterThanArea - [In] Area in which faces are selected if their area is greater than or equal to

Returns: Number of faces that were collapsed in the process. This number may differ from the initial number of faces that meet the input criteria because the areas of some initial faces may be altered as other faces are collapsed.

Remarks: The face area must be both <= LessThanArea and >= GreaterThanArea in order to be considered. Use large numbers for lessThanArea or zero for greaterThanArea to simulate an or.

◆ RhinoCollapseMeshFacesByAspectRatio()

RHINO_SDK_FUNCTION int RhinoCollapseMeshFacesByAspectRatio	(	ON_Mesh &	Mesh,
		double	aspectRatio
	)

Description: Collapses a multiple mesh faces, determined by face aspect ratio, based on criteria found in Stan Melax's polygon reduction, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf

Parameters: mesh - [In / Out] Input mesh aspectRatio - [In] Faces with an aspect ratio less than aspectRatio are considered as candidates.

Returns: Number of faces that were collapsed in the process. This number may differ from the initial number of faces that meet the input criteria because the aspect ratios of some initial faces may be altered as other faces are collapsed.

◆ RhinoCollapseMeshVertex()

RHINO_SDK_FUNCTION bool RhinoCollapseMeshVertex	(	ON_Mesh &	mesh,
		int	topVertexIndex1,
		int	topVertexIndex2
	)

Description: Collapses a mesh vertex based on criteria found in Stan Melax's polygon reduction, see http://pomax.nihongoresources.com/downloads/PolygonReduction.pdf

Parameters: mesh - [In/Out] Input mesh topVertexIndex1 - [In] 1st vertex index to collapse topVertexIndex2 - [In] 2nd vertex index to collapse (set to -1, if it doesn't matter what vertex topVertexIndex1 is collapsed to)

Returns: True on success.

◆ RhinoColorDialog()

RHINO_SDK_FUNCTION BOOL32 RhinoColorDialog	(	HWND	hwndParent,
		ON_Color &	color,
		bool	include_button_colors = `false`,
		const wchar_t *	dialog_title = `nullptr`
	)

Deprecated:: use RhinoColorDialogEx

◆ RhinoColorDialogEx()

RHINO_SDK_FUNCTION BOOL32 RhinoColorDialogEx	(	HWND	hwndParent,
		ON_Color &	color,
		bool	include_button_colors = `false`,
		const wchar_t *	dialog_title = `nullptr`,
		bool	use_alpha = `false`,
		HWND	hwndMessage = `nullptr`,
		const ON_ClassArray< CRhinoNamedColor > *	pCustomNamedColors = `nullptr`
	)

Description: Display Rhino's color selection dialog. Parameters: hwndParent - [in] Window handle of dialog's parent window. color - [in/out] Default color for dialog, and will receive new color if function returns TRUE. include_button_colors - [in] Display button face and text options at top of named color list. dialog_title - [in] The title of the dialog. use_alpha - [in] Display an alpha slider and use alpha value in color. hwndMessage - [in] Optional window that receives notifications when the color has changed. Uses the registered window message "RhinoColorPickerChangedMessage". The LPARAM of this message is a pointer to an ON_Color object. Example: ON_Color color = RGB(0,0,0); if( RhinoColorDialogEx(RhinoApp().MainWnd(), color) ) { / do something } Returns: TRUE - color changed FALSE - color not changed or dialog canceled

◆ RhinoCompareCCXEvent()

RHINO_SDK_FUNCTION int RhinoCompareCCXEvent	(	const CRhinoCCXEvent *	,
		const CRhinoCCXEvent *
	)

◆ RhinoCompareGeometry() [1/2]

RHINO_SDK_FUNCTION bool RhinoCompareGeometry	(	const CRhinoObject *	a,
		const CRhinoObject *	b
	)

Description: Compares the geometry of two objects, similarly to the SelDup command. Parameters: a - [in] The first object to compare b - [in] The second object to compare Returns: true: The two objects are geometrically equivalent false: The two objects are not geometrically equivalent

◆ RhinoCompareGeometry() [2/2]

RHINO_SDK_FUNCTION bool RhinoCompareGeometry	(	const ON_Geometry *	a,
		const ON_Geometry *	b
	)

Description: Compares the geometry of two objects, similarly to the SelDup command. Parameters: a - [in] The first object to compare b - [in] The second object to compare Returns: true: The two objects are geometrically equivalent false: The two objects are not geometrically equivalent

◆ RhinoComputePrincipalMeshCurvatures()

RHINO_SDK_FUNCTION bool RhinoComputePrincipalMeshCurvatures	(	ON_Mesh &	mesh,
		bool	useLaplacian = `true`
	)

Description: Function that computes the discrete mesh curvatures. On success, the m_K member of the mesh will be filled in. On all naked vertices, the value will be unset. This function triangulates the mesh using the default method. Parameters: mesh - [In, Out] Scrutinee useLaplacian - [In] optional boolean toggle. If false (default), mean curvature is estimated in a robust but simple way. If true, the cotangent-weighted Laplacian is used. Returns: True or false depending on the success of the computation.

◆ RhinoComputerSerialNumber()

RHINO_SDK_FUNCTION ON_wString RhinoComputerSerialNumber ( )

Description: Returns the serial number of the computer running Rhino Returns: ON_wString containing computer serial number

◆ RhinoControlObject()

RHINO_SDK_FUNCTION CRhinoMorphControl* RhinoControlObject ( const CRhinoObject * captive_object )

Description: Get a captive object's control object. Parameters: captive_object - [in] Returns: Point to control object if captive has one.

◆ RhinoConvertCurveToArcs()

RHINO_SDK_FUNCTION ON_PolyCurve* RhinoConvertCurveToArcs	(	const ON_Curve *	pCurve,
		const double	dTol,
		const double	dAngleTol,
		const double	dMinLength,
		const double	dMaxLength
	)

Description: Converts a curve into polycurve consisting of arc segments. Sections of the input curves that are nearly straight are converted to straight-line segments. Parameters: pCurve - [in] the curve to convert. dTol - [in] maximum deviation from arc midpoints to curve. dAngleTol - [in] maximum deviation of the arc end directions from the curve direction in radians dMinLength - [in] minimum segment length dMaxLength - [in] maximum segment length Returns: Pointer to curve if success, nullptr if unsuccessful.

◆ RhinoConvertCurveToLines()

RHINO_SDK_FUNCTION ON_PolyCurve* RhinoConvertCurveToLines	(	const ON_Curve *	pCurve,
		const double	dTol,
		const double	dAngleTol,
		const double	dMinLength,
		const double	dMaxLength
	)

Description: Converts a curve into polycurve consisting of line segments. Parameters: pCurve - [in] the curve to convert. dTol - [in] maximum deviation from line midpoints to curve. dAngleTol - [in] maximum deviation of the line directions in radians dMinLength - [in] minimum segment length dMaxLength - [in] maximum segment length Returns: Pointer to curve if success, nullptr if unsuccessful.

◆ RhinoConvertCurveToPolyline()

RHINO_SDK_FUNCTION bool RhinoConvertCurveToPolyline	(	const ON_Curve &	curve,
		int	main_seg_count,
		int	sub_seg_count,
		double	max_ang_radians,
		double	max_chr,
		double	max_aspect,
		double	tolerance,
		double	min_edge_length,
		double	max_edge_length,
		ON_PolylineCurve &	polyline,
		bool	bKeepStartPoint = `true`,
		ON_Interval *	curve_domain = `nullptr`
	)

Description: Get a polyline approximation of a curve Parameters: curve - [in] main_seg_count - [in] sub_seg_count - [in] If main_seg_count <= 0, then both these parameters are ignored. If main_seg_count > 0, then sub_seg_count must be >= 1. In this case the NURB will be broken into main_seg_count equally spaced chords. If needed, each of these chords can be split into as many sub_seg_count sub-parts if the subdivision is necessary for the mesh to meet the other meshing constraints. In particular, if sub_seg_count = 0, then the curve is broken into main_seg_count pieces and no further testing is performed. max_ang_radians - [in] ( 0 to pi ) Maximum angle (in radians) between unit tangents at adjacent vertices. max_chr - [in] Maximum permitted value of (distance chord midpoint to curve) / (length of chord) max_aspect - [in] If max_aspect < 1.0, the parameter is ignored. If 1 <= max_aspect < sqrt(2), it is treated as if max_aspect = sqrt(2). This parameter controls the maximum permitted value of (length of longest chord) / (length of shortest chord) tolerance - [in] If tolerance = 0, the parameter is ignored. This parameter controls the maximum permitted value of the distance from the curve to the polyline. max_edge_length - [in] If max_edge_length = 0, the parameter is ignored. This parameter controls the maximum permitted edge length. polyline - [out] The polyline approximation of the NURBS curve is appended to this polyline. If bKeepStartPoint is FALSE, the starting point is not appended. bKeepStartPoint - [in] TRUE The starting point of the curve is added to the polyline FALSE The starting point of the curve is not added to the polyline curve_domain - [in] if not NULL, this sub-domain of the NURBS curve is approximated. Returns: TRUE if successful.

◆ RhinoCopyAnalysisModes() [1/2]

RHINO_SDK_FUNCTION int RhinoCopyAnalysisModes	(	const CRhinoObject *	source_object,
		CRhinoObject *	destination_object
	)

Description: Copy analysis modes to destination object. Parameters: source_object - [in] analysis_mode_list - [in] destination_object - [in] Returns: Number of analysis modes enabled on destination_object.

◆ RhinoCopyAnalysisModes() [2/2]

RHINO_SDK_FUNCTION int RhinoCopyAnalysisModes	(	const CRhinoObjectVisualAnalysisMode *	analysis_mode_list,
		CRhinoObject *	destination_object
	)

◆ RhinoCreate1FaceBrepFromPoints()

RHINO_SDK_FUNCTION ON_Brep* RhinoCreate1FaceBrepFromPoints	(	const ON_3dPoint	corners[4],
		int	count,
		double	tolerance = `0`
	)

Description: Make a Brep with 1 face from 3 or 4 points Parameters: ob - [out] pointer to the finished Brep corners - [in] 3 or 4 corner points for the face count - [in] number of corners tolerance - [in] min edge length without collapsing to a singularity Returns: ON_Brep* - The resulting surface or NULL Remarks: Calls RhinoCreateSurfaceFromCorners() to make the surface and trims it to a triangle for 3-corners Makes a singular surface for 4 corners with 2 coincident Memory for the Brep is allocated and becomes the responsibility of the caller.

◆ RhinoCreateAnaglyph()

RHINO_SDK_FUNCTION CRhinoDib* RhinoCreateAnaglyph	(	const CRhinoDib &	LeftEye,
		const CRhinoDib &	RightEye,
		const int	nType = `0`
	)

Description: Creates a single anaglyph image from the two passed in images. Parameters: LeftEye - [in] The image that represents pixels rendered from the "left" eye/camera RightEye - [in] The image that represents pixels rendered from the "right" eye/camera nType - [in] The type of anaglyph being requested... acceptable values are: 0 = red/cyan 1 = red/blue 2 = red/green 3 = amber/blue Returns: A pointer to a new CRhinoDib object containing the anaglyph. NULL if the required criteria are not met (see remarks below). Remarks: Both left and right images MUST have the same dimensions The resulting anaglyph will have the same dimensions as the left and right images. THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CRhinoDib.

◆ RhinoCreateArcBlend()

RHINO_SDK_FUNCTION ON_PolyCurve* RhinoCreateArcBlend	(	const ON_3dPoint &	startpt,
		const ON_3dVector &	startdir,
		const ON_3dPoint &	endpt,
		const ON_3dVector &	enddir,
		const double	controlpolygonlengthratio = `1.0`,
		ON_PolyCurve *	curve_out = `nullptr`
	)

Description: Creates a polycurve consisting of two tangent arc segments that connect two points and two directions. Parameters: startpt - [in] start of the arc blend curve startdir - [in] start direction of the arc blend curve endpt - [in] end of the arc blend curve enddir - [in] end direction of the arc blend curve controlpolygonlengthratio - [in] the ratio of the control polygon lengths of the two arcs curve_out - [out] optional curve out. If nullptr a new curve is created. Returns: polycurve consisting of two arc segments if success, nullptr otherwise

◆ RhinoCreateEdgeSrf()

RHINO_SDK_FUNCTION ON_Brep* RhinoCreateEdgeSrf	(	int	curve_count,
		const ON_Curve **	pCrvs
	)

Description: Creates a coons patch from 2, 3, or 4 curves Parameters: curve_count [in] number of input curves pCrvs [in] Array of pointers to input curves Returns: ON_Brep* - The resulting surface or NULL Memory for the Brep is allocated and becomes the responsibility of the caller.

◆ RhinoCreateErrorMarker()

RHINO_SDK_FUNCTION CRhinoTextDot* RhinoCreateErrorMarker	(	ON_3dPoint	Location,
		const wchar_t *	msg,
		ON_3dmObjectAttributes *	attr,
		unsigned int	RhinoDocSN
	)

Description: Create a text dot at the location of an error. Primary text will be "!". Secondary text is a description of the error. Parameters: Location [in] - the location of the text dot. s [in] - the error message attr [in] - attributes for the dot. If NULL, then the default is used RhinoDocSN [in] - if non-0, add the dot to the document with this runtime serial number. Returns: A pointer to the CRhinoTextDot.
if RhinoDocSN = 0, then it is the caller's responsibility to manage the memory for the returned CRhinoTextDot. Otherwise, if RhinoDocSN is not the serial number for a document, the return will be 0.

◆ RhinoCreateG2ChordalQuinticFilletSrf()

RHINO_SDK_FUNCTION bool RhinoCreateG2ChordalQuinticFilletSrf	(	const ON_BrepFace &	FaceA,
		const ON_2dPoint &	uvA,
		const ON_BrepFace &	FaceB,
		const ON_2dPoint &	uvB,
		double	radius,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	resultsA,
		ON_SimpleArray< ON_Brep * > &	resultsB,
		int	rail_degree,
		bool	bTrim,
		bool	bExtend,
		ON_SimpleArray< ON_Brep * > &	Fillets
	)

Description: Creates a surface fillet using G2 chordal Quintic arc approximations as sections Parameters : FaceA - [in] the first face to use constructing the fillet uvA - [in] The parametric u,v selection point on FaceA close to the edge to fillet FaceB - [in] the second face to use constructing the fillet uvB - [in] The parametric u,v selection point on FaceB close to the edge to fillet radius - [in] The radius of the fillet tol - [in] Tolerance to use in fitting a solution resultsA - [out] if bTrim = true, returns the remains of FaceA trimmed to the fillet resultsB - [out] if bTrim = true, returns the remains of FaceB trimmed to the fillet rail_degree - [in] the degree of the rail curve bTrim - [in] if True, trim the faces and retuen those results in resultsA and resultsB bExtend - [in] if True and if one input surface is longer than the other, the fillet surface is extended to the input surface edges Fillets - [out] returns the resulting fillet surfaces Returns : True if successful. Remarks :

◆ RhinoCreateHatches() [1/2]

RHINO_SDK_FUNCTION bool RhinoCreateHatches	(	CArgsRhinoHatch &	args,
		double	tolerance,
		ON_SimpleArray< ON_Hatch * > &	results
	)

Description: Creates one or more hatches. Parameters: args - [in] The hatching arguments. tolerance - [in] The tolerance used for detecting planar loops. When in doubt, use the document's absolute tolerance. Returns: True if one or more hatches were created, false otherwise.

◆ RhinoCreateHatches() [2/2]

RHINO_SDK_FUNCTION bool RhinoCreateHatches	(	CArgsRhinoHatch &	args,
		ON_SimpleArray< ON_Hatch * > &	results
	)

Description: Creates one or more hatches. Parameters: args - [in] The hatching arguments. tolerance - [in] The tolerance used for detecting planar loops. When in doubt, use the document's absolute tolerance. Returns: True if one or more hatches were created, false otherwise.

Deprecated:: use overload that accepts tolerance parameter

◆ RhinoCreateHSpline()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoCreateHSpline	(	const ON_3dPoint *	Pts,
		int	PntCount,
		const ON_3dVector *	StartTan,
		const ON_3dVector *	EndTan
	)

Description: Construct an H-spline from a sequence of interpolation points and optional start and end derivative information. Parameters: Pts - [in] Points to interpolate. PntCount - [in] Number of points. PntCount > 1 StartTan - [in] Unit tangent vector or nullptr. EndTan - [in] Unit tangent vector or nullptr.

Returns: The H-spline curve, or nullptr if there was an error.

◆ RhinoCreateNonRationalCubicArcsFilletSrf()

RHINO_SDK_FUNCTION bool RhinoCreateNonRationalCubicArcsFilletSrf	(	const ON_BrepFace &	FaceA,
		const ON_2dPoint &	uvA,
		const ON_BrepFace &	FaceB,
		const ON_2dPoint &	uvB,
		double	radius,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	resultsA,
		ON_SimpleArray< ON_Brep * > &	resultsB,
		int	rail_degree,
		bool	bTrim,
		bool	bExtend,
		ON_SimpleArray< ON_Brep * > &	Fillets
	)

Arc approximation.

Description: Creates a surface fillet using Non-rational Cubic arc approximations as sections Parameters : FaceA - [in] the first face to use constructing the fillet uvA - [in] The parametric u,v selection point on FaceA close to the edge to fillet FaceB - [in] the second face to use constructing the fillet uvB - [in] The parametric u,v selection point on FaceB close to the edge to fillet radius - [in] The radius of the fillet tol - [in] Tolerance to use in fitting a solution resultsA - [out] if bTrim = true, returns the remains of FaceA trimmed to the fillet resultsB - [out] if bTrim = true, returns the remains of FaceB trimmed to the fillet rail_degree - [in] the degree of the rail curve bTrim - [in] if True, trim the faces and retuen those results in resultsA and resultsB bExtend - [in] if True and if one input surface is longer than the other, the fillet surface is extended to the input surface edges Fillets - [out] returns the resulting fillet surfaces Returns : True if successful. Remarks :

◆ RhinoCreateNonRationalCubicFilletSrf()

RHINO_SDK_FUNCTION bool RhinoCreateNonRationalCubicFilletSrf	(	const ON_BrepFace &	FaceA,
		const ON_2dPoint &	uvA,
		const ON_BrepFace &	FaceB,
		const ON_2dPoint &	uvB,
		double	radius,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	resultsA,
		ON_SimpleArray< ON_Brep * > &	resultsB,
		int	rail_degree,
		double	TanSlider,
		bool	bTrim,
		bool	bExtend,
		ON_SimpleArray< ON_Brep * > &	Fillets
	)

Description: Creates a fillet using non-rational Cubic sections with a tangent slider Parameters : FaceA - [in] the first face to use constructing the fillet uvA - [in] The parametric u,v selection point on FaceA close to the edge to fillet FaceB - [in] the second face to use constructing the fillet uvB - [in] The parametric u,v selection point on FaceB close to the edge to fillet radius - [in] The radius of the fillet tol - [in] Tolerance to use in fitting a solution resultsA - [out] if bTrim = true, returns the remains of FaceA trimmed to the fillet resultsB - [out] if bTrim = true, returns the remains of FaceB trimmed to the fillet rail_degree - [in] the degree of the rail curve TanSlider - [in] A number between -0.95 and 0.95 indicating how far to push the tangent control points toward or away from the theoretical quadratic middle control point bTrim - [in] if True, trim the faces and retuen those results in resultsA and resultsB bExtend - [in] if True and if one input surface is longer than the other, the fillet surface is extended to the input surface edges Fillets - [out] returns the resulting fillet surfaces Returns : True if successful. Remarks :

◆ RhinoCreateNonRationalQuarticArcsFilletSrf()

RHINO_SDK_FUNCTION bool RhinoCreateNonRationalQuarticArcsFilletSrf	(	const ON_BrepFace &	FaceA,
		const ON_2dPoint &	uvA,
		const ON_BrepFace &	FaceB,
		const ON_2dPoint &	uvB,
		double	radius,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	resultsA,
		ON_SimpleArray< ON_Brep * > &	resultsB,
		int	rail_degree,
		bool	bTrim,
		bool	bExtend,
		ON_SimpleArray< ON_Brep * > &	Fillets
	)

Arc approximation.

Description: Creates a surface fillet using Non-rational Quartic arc approximations as sections Parameters : FaceA - [in] the first face to use constructing the fillet uvA - [in] The parametric u,v selection point on FaceA close to the edge to fillet FaceB - [in] the second face to use constructing the fillet uvB - [in] The parametric u,v selection point on FaceB close to the edge to fillet radius - [in] The radius of the fillet tol - [in] Tolerance to use in fitting a solution resultsA - [out] if bTrim = true, returns the remains of FaceA trimmed to the fillet resultsB - [out] if bTrim = true, returns the remains of FaceB trimmed to the fillet rail_degree - [in] the degree of the rail curve bTrim - [in] if True, trim the faces and retuen those results in resultsA and resultsB bExtend - [in] if True and if one input surface is longer than the other, the fillet surface is extended to the input surface edges Fillets - [out] returns the resulting fillet surfaces Returns : True if successful. Remarks :

◆ RhinoCreateNonRationalQuarticFilletSrf()

RHINO_SDK_FUNCTION bool RhinoCreateNonRationalQuarticFilletSrf	(	const ON_BrepFace &	FaceA,
		const ON_2dPoint &	uvA,
		const ON_BrepFace &	FaceB,
		const ON_2dPoint &	uvB,
		double	radius,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	resultsA,
		ON_SimpleArray< ON_Brep * > &	resultsB,
		int	rail_degree,
		double	TanSlider,
		double	InnerSlider,
		bool	bTrim,
		bool	bExtend,
		ON_SimpleArray< ON_Brep * > &	Fillets
	)

Description: Creates a fillet using non-rational Quartic sections with a tangent and inner slider Parameters : FaceA - [in] the first face to use constructing the fillet uvA - [in] The parametric u,v selection point on FaceA close to the edge to fillet FaceB - [in] the second face to use constructing the fillet uvB - [in] The parametric u,v selection point on FaceB close to the edge to fillet radius - [in] The radius of the fillet tol - [in] Tolerance to use in fitting a solution resultsA - [out] if bTrim = true, returns the remains of FaceA trimmed to the fillet resultsB - [out] if bTrim = true, returns the remains of FaceB trimmed to the fillet rail_degree - [in] the degree of the rail curve TanSlider - [in] A number between -0.95 and 0.95 indicating how far to push the tangent control points toward or away from the theoretical quadratic middle control point InnerSlider - [in] A number between -0.95 and 0.95 indicating how far to push the inner control point toward or away from the theoretical quadratic middle control point bTrim - [in] if True, trim the faces and retuen those results in resultsA and resultsB bExtend - [in] if True and if one input surface is longer than the other, the fillet surface is extended to the input surface edges Fillets - [out] returns the resulting fillet surfaces Returns : True if successful. Remarks :

◆ RhinoCreateNonRationalQuinticArcsFilletSrf()

RHINO_SDK_FUNCTION bool RhinoCreateNonRationalQuinticArcsFilletSrf	(	const ON_BrepFace &	FaceA,
		const ON_2dPoint &	uvA,
		const ON_BrepFace &	FaceB,
		const ON_2dPoint &	uvB,
		double	radius,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	resultsA,
		ON_SimpleArray< ON_Brep * > &	resultsB,
		int	rail_degree,
		bool	bTrim,
		bool	bExtend,
		ON_SimpleArray< ON_Brep * > &	Fillets
	)

Arc approximation.

Description: Creates a surface fillet using Non-rational Quintic arc approximations as sections Parameters : FaceA - [in] the first face to use constructing the fillet uvA - [in] The parametric u,v selection point on FaceA close to the edge to fillet FaceB - [in] the second face to use constructing the fillet uvB - [in] The parametric u,v selection point on FaceB close to the edge to fillet radius - [in] The radius of the fillet tol - [in] Tolerance to use in fitting a solution resultsA - [out] if bTrim = true, returns the remains of FaceA trimmed to the fillet resultsB - [out] if bTrim = true, returns the remains of FaceB trimmed to the fillet rail_degree - [in] the degree of the rail curve bTrim - [in] if True, trim the faces and retuen those results in resultsA and resultsB bExtend - [in] if True and if one input surface is longer than the other, the fillet surface is extended to the input surface edges Fillets - [out] returns the resulting fillet surfaces Returns : True if successful. Remarks :

◆ RhinoCreateNonRationalQuinticFilletSrf()

RHINO_SDK_FUNCTION bool RhinoCreateNonRationalQuinticFilletSrf	(	const ON_BrepFace &	FaceA,
		const ON_2dPoint &	uvA,
		const ON_BrepFace &	FaceB,
		const ON_2dPoint &	uvB,
		double	radius,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	resultsA,
		ON_SimpleArray< ON_Brep * > &	resultsB,
		int	rail_degree,
		double	TanSlider,
		double	InnerSlider,
		bool	bTrim,
		bool	bExtend,
		ON_SimpleArray< ON_Brep * > &	Fillets
	)

Description: Creates a fillet using non-rational Quintic sections with a tangent and inner slider Parameters : FaceA - [in] the first face to use constructing the fillet uvA - [in] The parametric u,v selection point on FaceA close to the edge to fillet FaceB - [in] the second face to use constructing the fillet uvB - [in] The parametric u,v selection point on FaceB close to the edge to fillet radius - [in] The radius of the fillet tol - [in] Tolerance to use in fitting a solution resultsA - [out] if bTrim = true, returns the remains of FaceA trimmed to the fillet resultsB - [out] if bTrim = true, returns the remains of FaceB trimmed to the fillet rail_degree - [in] the degree of the rail curve TanSlider - [in] A number between -0.95 and 0.95 indicating how far to push the tangent control points toward or away from the theoretical quadratic middle control point InnerSlider - [in] A number between -0.95 and 0.95 indicating how far to push the inner control points toward or away from the theoretical quadratic middle control point bTrim - [in] if True, trim the faces and retuen those results in resultsA and resultsB bExtend - [in] if True and if one input surface is longer than the other, the fillet surface is extended to the input surface edges Fillets - [out] returns the resulting fillet surfaces Returns : True if successful. Remarks :

◆ RhinoCreateParabolaFromFocus()

RHINO_SDK_FUNCTION bool RhinoCreateParabolaFromFocus	(	const ON_3dPoint &	focus,
		const ON_3dPoint &	start,
		const ON_3dPoint &	end,
		ON_BezierCurve &	parabola_out
	)

Description: Create parabola from focus and ends. Parameters: focus - [in] parabola focus start - [in] parabola start end - [in] parabola end parabola_out - [out] degree 2 Bézier curve defining the parabola. Returns: true if success

◆ RhinoCreateParabolaFromPoints()

RHINO_SDK_FUNCTION bool RhinoCreateParabolaFromPoints	(	const ON_3dPoint &	P0,
		const ON_3dPoint &	P1,
		const ON_3dPoint &	P2,
		ON_NurbsCurve &	curve_out
	)

Description: Create parabola from three points. Parameters: focus - [in] parabola start start - [in] parabola interior point end - [in] parabola end curve_out - [out] degree 2 NURBS curve defining the parabola. Returns: true if success

◆ RhinoCreateParabolaFromVertex()

RHINO_SDK_FUNCTION bool RhinoCreateParabolaFromVertex	(	const ON_3dPoint &	vertex,
		const ON_3dPoint &	start,
		const ON_3dPoint &	end,
		ON_BezierCurve &	parabola_out
	)

Description: Create parabola from vertex and ends. Parameters: vertex - [in] parabola vertex start - [in] parabola start end - [in] parabola end parabola_out - [out] degree 2 Bézier curve defining the parabola. Returns: true if success

◆ RhinoCreatePictureFrame() [1/3]

const RHINO_SDK_FUNCTION CRhinoObject* RhinoCreatePictureFrame	(	class CRhinoDoc &	doc,
		const ON_Plane &	plane,
		const ON_wString &	texturepath,
		bool	makemesh = `false`,
		bool	usealphaforobjecttransparency = `false`,
		double	width = `0.0`,
		double	height = `0.0`,
		bool	selfillumination = `true`,
		bool	embedbitmap = `false`,
		bool	addtodoc = `true`
	)

Description: Creates a PictureFrame object from a plane (or a mesh, if makemesh is true) and a path to an image file, and adds it to the specified document. Note, a PictureFrame object is just a Plane surface or mesh that has a material with a texture and assigned to it that displays in all display modes. If, for some reason, you need access the PictureFrame's underlying geometry, then just cast the object's geometry as an ON_Brep or an ON_Mesh. For example:

const CRhinoObject* pPF = RhinoCreatePictureFrame(...); if (pPF) { const ON_Brep* pB = ON_Brep::Cast(pPF->Geometry()); if (pB) { / TODO... } }

You can also cast the returned CRhinoObject* as a CRhinoBrepObject* or a CRhinoMeshObject*.

Parameters: doc - [in] Document to which the PictureFrame will be added. plane - [in] Plane in which the PictureFrame will be created. Bottom left corner of picture will be at plane's origin, width will be in the plane's x axis direction, height will be in the plane's y axis direction. texturepath - [in] Path to an image file. File must exist if either width or height are 0.0 or return value will be null.
makemesh - [in] If true, the function will make a PictureFrame object from a mesh rather than a plane. The default is false. width - [in] Width of the resulting PictureFrame. If 0.0, the width of the picture frame is the width of the image if height is also 0.0 or calculated from the height and aspect ratio of the image if height is not 0.0.
The default is 0.0. height - [in] Height of the resulting PictureFrame. If 0.0, the height of the picture frame is the height of the image if width is also 0.0 or calculated from the width and aspect ratio of the image if width is not 0.0.
The default is 0.0. selfillumination - [in] If true, the image mapped to the picture frame plane always displays at full intensity and is not affected by light or shadow.
The default is true. embedbitmap - [in] If true, the function adds the the image to the bitmap table of the document to which the PictureFrame will be added. The default is false. addtodoc - [in] If false, the object will not be added to the document. The material for the PictureFrame will be added regardless and the material index in the attributes will be an index into doc's material table. The default is true. usealphaforobjecttransparency - [in] If false, the picture frame is created without any transparency texture, as in all versions of Rhino previous to Rhino 5 SR2. If true, a transparency texture is created with a "Mask Texture" set to alpha, and an instance of the diffuse texture in the source texture slot. Not that when this flag is set, a full RDK material is created.

Returns: A pointer to a const CRhinoObject in the active document or null if the function fails for any reason.

◆ RhinoCreatePictureFrame() [2/3]

const RHINO_SDK_FUNCTION CRhinoObject* RhinoCreatePictureFrame	(	class CRhinoDoc &	doc,
		const ON_Plane &	plane,
		const ON_wString &	texturepath,
		bool	makemesh = `false`,
		double	width = `0.0`,
		double	height = `0.0`,
		bool	selfillumination = `true`,
		bool	embedbitmap = `false`,
		bool	addtodoc = `true`
	)

Description: This function is the predecessor to the function above and is the same in every regard except for these things. It does not have the argument "usealphaforobjecttransparency" to determine whether the function should create an automatic transparency texture with an alpha mask..

◆ RhinoCreatePictureFrame() [3/3]

const RHINO_SDK_FUNCTION CRhinoObject* RhinoCreatePictureFrame	(	class CRhinoDoc &	doc,
		const ON_Plane &	plane,
		const ON_wString &	texturepath,
		double	width = `0.0`,
		double	height = `0.0`,
		bool	selfillumination = `true`,
		bool	embedbitmap = `false`,
		bool	addtodoc = `true`
	)

Description: This function is the predecessor to the function above and is the same in every regard except for these things. It does not have the argument "makemesh" to determine whether the function should create a CRhinoMeshObject or a CRhinoBrepObject. The CRhinoObject it returns may only be cast as a CRhinoBrepObject.

◆ RhinoCreatePointCloudContours()

RHINO_SDK_FUNCTION int RhinoCreatePointCloudContours	(	const ON_PointCloud *	pPointCloud,
		ON_3dPoint	start_point,
		ON_3dPoint	end_point,
		double	interval,
		double	tolerance,
		double	max_distance,
		double	min_distance,
		bool	bOpenCurves,
		bool	bCreateSpline,
		bool	bCreatePolyline,
		double	fit_tolerance,
		ON_SimpleArray< ON_Curve * > &	out_curves
	)

Description: Creates planar curves by intersecting a plane with a point cloud. Parameters: pPointCloud - [in] The point cloud to intersect. start_point - [in] Start point for vector that is normal to contour plane. end_point - [in] End point for vector that is normal to contour plane. interval - [in] The interval or distance between contours. tolerance - [in] The document's model absolute tolerance. max_distance - [in] Maximum distance to plane. The thickness of the "slab" around the plane from which sample points are taken. Those sample points are projected to the section plane and a polyline is found that connects them. This distance depends on the size of the point cloud and the spacing of the points. min_distance - [in] Minimum distance between points. A threshold for the minimum spacing between adjacent sample points. If there are points closer than that, some are not used. bOpenCurves - [in] Create open curves. bCreateSpline - [in] Creates smooth curves. You can create both a curve and a polyline. bCreatePolyline - [in] Creates a polyline. You can create both a curve and a polyline. fit_tolerance - [in] The tolerance used to fit the curve through the polyline. out_curves - [out] The output curves. Returns: The number of curves added to out_curves. Remarks: Memory for the output curves is allocated and becomes the responsibility of the caller.

◆ RhinoCreatePointCloudSection()

RHINO_SDK_FUNCTION int RhinoCreatePointCloudSection	(	const ON_PointCloud *	pPointCloud,
		ON_Plane	plane,
		double	tolerance,
		double	max_distance,
		double	min_distance,
		bool	bOpenCurves,
		bool	bCreateSpline,
		bool	bCreatePolyline,
		double	fit_tolerance,
		ON_SimpleArray< ON_Curve * > &	out_curves
	)

Description: Creates planar curves by intersecting a plane with a point cloud. Parameters: pPointCloud - [in] The point cloud to intersect. plane - [in] The plane to intersect with. tolerance - [in] The document's model absolute tolerance. max_distance - [in] Maximum distance to plane. The thickness of the "slab" around the plane from which sample points are taken. Those sample points are projected to the section plane and a polyline is found that connects them. This distance depends on the size of the point cloud and the spacing of the points. min_distance - [in] Minimum distance between points. A threshold for the minimum spacing between adjacent sample points. If there are points closer than that, some are not used. bOpenCurves - [in] Create open curves. bCreateSpline - [in] Creates smooth curves. You can create both a curve and a polyline. bCreatePolyline - [in] Creates a polyline. You can create both a curve and a polyline. fit_tolerance - [in] The tolerance used to fit the curve through the polyline. out_curves - [out] The output curves. Returns: The number of curves added to out_curves. Remarks: Memory for the output curves is allocated and becomes the responsibility of the caller.

◆ RhinoCreateRationalArcsFilletSrf()

RHINO_SDK_FUNCTION bool RhinoCreateRationalArcsFilletSrf	(	const ON_BrepFace &	FaceA,
		const ON_2dPoint &	uvA,
		const ON_BrepFace &	FaceB,
		const ON_2dPoint &	uvB,
		double	radius,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	resultsA,
		ON_SimpleArray< ON_Brep * > &	resultsB,
		int	rail_degree,
		bool	bTrim,
		bool	bExtend,
		ON_SimpleArray< ON_Brep * > &	Fillets
	)

Description: Creates a standard surface fillet using rational arc sections Parameters : FaceA - [in] the first face to use constructing the fillet uvA - [in] The parametric u,v selection point on FaceA close to the edge to fillet FaceB - [in] the second face to use constructing the fillet uvB - [in] The parametric u,v selection point on FaceB close to the edge to fillet radius - [in] The radius of the fillet tol - [in] Tolerance to use in fitting a solution resultsA - [out] if bTrim = true, returns the remains of FaceA trimmed to the fillet resultsB - [out] if bTrim = true, returns the remains of FaceB trimmed to the fillet rail_degree - [in] the degree of the rail curve bTrim - [in] if True, trim the faces and retuen those results in resultsA and resultsB bExtend - [in] if True and if one input surface is longer than the other, the fillet surface is extended to the input surface edges Fillets - [out] returns the resulting fillet surfaces Returns : True if successful. Remarks :

◆ RhinoCreateSolid()

RHINO_SDK_FUNCTION int RhinoCreateSolid	(	const ON_SimpleArray< const ON_Brep * > &	InBreps,
		ON_SimpleArray< ON_Brep * > &	OutBreps,
		double	tolerance
	)

Description: Creates closed polysurfaces from surfaces and polysurfaces that bound a region in space. Parameters: InBreps - [in] The intersecting surfaces and polysurfaces to automatically trim and join into closed polysurfaces. OutBreps - [out] The resulting polysurfaces. tolerance - [in] The trim and join tolerance. Returns: The results of the operation, where: 0 - Success. 1 - InBreps has no non-NULL Breps. 2 - Merge failed. 3 - All faces removed. 4 - Non-manifold after fins removed. 5 - Could not determine orientation. Remarks: THE CALLER IS RESPONSIBLE FOR DESTROYING THE RETURNED BREPS.

◆ RhinoCreateSubPictureMaterialIndex()

RHINO_SDK_FUNCTION int RhinoCreateSubPictureMaterialIndex	(	CRhinoDoc &	doc,
		const CRhinoObject *	original_picture_object,
		const ON_Brep *	shrunk_picture_brep
	)

Description: When the brep behind a picture frame object is trimmed/split and the underlying surface is shrunk, a new material needs to be assigned that will display the appropriate subset of the original picture image. Parameters: doc - [in] original_picture_object - [in] shrunk_picture_brep - [in] Returns: Index of new material or ON_UNSET_INT_INDEX if the input is not valid.

◆ RhinoCreateSurfaceFromCorners()

RHINO_SDK_FUNCTION ON_NurbsSurface* RhinoCreateSurfaceFromCorners	(	const ON_3dPoint &	a,
		const ON_3dPoint &	b,
		ON_3dPoint &	c,
		ON_3dPoint &	d,
		double	dtol = `0`
	)

Description: Make a CRhinoNurbsSurface from 4 corner points Parameters: srf - [out] pointer to the finished surface a, b, c, d - [in] 3 or 4 corner points for the face dtol - [in] min edge length without collapsing to a singularity Returns: ON_NurbsSurface* - The resulting surface or NULL Remarks: Memory for the surface is allocated and becomes the responsibility of the caller.

◆ RhinoCreateTaperedExtrude()

RHINO_SDK_FUNCTION bool RhinoCreateTaperedExtrude	(	const ON_Curve *	input_curve,
		double	distance,
		ON_3dVector	direction,
		ON_3dPoint	base,
		double	draft_angle,
		int	cornertype,
		double	tol,
		double	ang_tol,
		ON_SimpleArray< ON_Brep * > &	output_breps
	)

Description Extrude a curve to a taper making a brep (potentially more than 1) Parameters: [in] input_curve - the curve to extrude [in] distance - the distance to extrude [in] direction - the direction of the extrusion [in] base - the basepoint of the extrusion [in] draft_angle - angle of the extrusion [in] cornertype - corner type of the extrusion. valid options are no_corner = 0, sharp = 1, round = 2, smooth = 3, and chamfer = 4 [in] tol - tolerance to be used in calculation, if you don't have a tolerance in mind consider using the absolute tolerance from the document [in] ang_tol - angle tolerance to be used in calculation, if you don't have a tolerance in mind consider using the absolute tolerance from the document [out] output_breps - array of breps Returns: True if successful, false if not.

◆ RhinoCreateTextObjectGeometry()

RHINO_SDK_FUNCTION bool RhinoCreateTextObjectGeometry	(	const ON_Annotation *	pAnno,
		const ON_Viewport *	vp,
		const ON_DimStyle *	dimstyle,
		double	text_scale,
		bool	close_contours,
		double	join_tol,
		double	small_caps_scale,
		ON::object_type	variety,
		double	height,
		double	spacing,
		ON_SimpleArray< ON_Object * > &	output
	)

Description: Creates various "TextObject" type objects from the text of an annotation object. Parameters: pAnno [in] - The text object to create outlines from. viewport [in] - The viewport from which the object was selected. Can be null. dimstyle [in] - The text object's dimension style. Can be null. If null, then ON_DimStyle::Default is used. text_scale [in] - Additional scaling factor. Use 1.0, for no scaling. close_contours [in] - Set this value to true when dealing with normal fonts and when you expect closed loops. You may want to set this to false when specifying a single-stroke font where you don't want closed loops. join_tol [in] - The tolerance used to join contours variety [in] - Determines type of objects the output will be. height [in] - Height of polysurfaces or extrusions. Set to 0.0 and variety to Brep to get trimmed planes as the output. spacing [in] - Additional spacing to add between glyphs. Set to 0.0 to disable. output [out] - An array of output objects. Return: true or false indicating success or failure. NOTE, memory for the output is allocated and becomes the responsibility of the caller. Remarks: A transformation is calculated from the viewport, dimstyle and text_scale arguments for proper placement of the output. See ON_Annotation::GetTextXform().

◆ RhinoCreateTextObjectGeometryByLetter()

RHINO_SDK_FUNCTION bool RhinoCreateTextObjectGeometryByLetter	(	const ON_Annotation *	pAnno,
		const ON_Viewport *	vp,
		const ON_DimStyle *	dimstyle,
		double	text_scale,
		bool	close_contours,
		double	join_tol,
		double	small_caps_scale,
		ON::object_type	variety,
		double	height,
		double	spacing,
		ON_ClassArray< ON_SimpleArray< ON_Object * >> &	letter_output
	)

Description: Creates various "TextObject" type objects from the text of an annotation object. Parameters: pAnno [in] - The text object to create outlines from. viewport [in] - The viewport from which the object was selected. Can be null. dimstyle [in] - The text object's dimension style. Can be null. If null, then ON_DimStyle::Default is used. text_scale [in] - Additional scaling factor. Use 1.0, for no scaling. close_contours [in] - Set this value to true when dealing with normal fonts and when you expect closed loops. You may want to set this to false when specifying a single-stroke font where you don't want closed loops. join_tol [in] - The tolerance used to join contours variety [in] - Determines type of objects the output will be. height [in] - Height of polysurfaces or extrusions. Set to 0.0 and variety to Brep to get trimmed planes as the output. spacing [in] - Additional spacing to add between glyphs. Set to 0.0 to disable. letter_output [out] - An array of contour arrays, one contour array per letter. Return: true or false indicating success or failure. NOTE, memory for the output is allocated and becomes the responsibility of the caller. Remarks: A transformation is calculated from the viewport, dimstyle and text_scale arguments for proper placement of the output. See ON_Annotation::GetTextXform().

◆ RhinoCullControlPolygon()

RHINO_SDK_FUNCTION bool RhinoCullControlPolygon ( )

Returns: True if backfaces of surface and mesh control polygons are culled.

◆ RhinoCullZeroAreaMeshFaces()

RHINO_SDK_FUNCTION ON_Mesh* RhinoCullZeroAreaMeshFaces	(	const ON_Mesh &	MeshIn,
		int &	removed_faces_count,
		int &	fixed_faces_count,
		ON_Mesh *	pMeshOut = `0`
	)

Description: RhinoCullZeroAreaMeshFaces Deletes or fixes mesh faces that have 0 area.

Parameters: MeshIn - [In] Mesh to be culled removed_faces_count - [In] Number of removed wholly degenerate faces fixed_faces_count - [In] Number of fixed partially degenerate faces pMeshOut - [Out] If pMeshOut is not null then the return will be pMeshOut

Returns: The a culled version of the MeshIn.

Notes: Reference ON_Mesh::CullDegenerateFaces for alternate implementation to cull degenerate faces using vertices

◆ RhinoCurve2View()

RHINO_SDK_FUNCTION bool RhinoCurve2View	(	const ON_Curve &	C0,
		const ON_Curve &	C1,
		ON_3dVector	D0,
		ON_3dVector	D1,
		ON_SimpleArray< ON_Curve * > &	output_curves,
		double	tol,
		double	angle_tol
	)

Description: Creates a third curve from two curves that are planar in different construction planes. The new curve looks the same as each of the original curves when viewed in each plane. Parameter: C0 [in] - The first curve. C1 [in] - The second curve. D0 [in] - A vector defining the normal direction of the plane which the first curve is drawn upon. D1 [in] - A vector defining the normal direction of the plane which the second curve is drawn upon. tol [in] - The tolerance for the operation. angle_tol [in] - The angle tolerance for the operation. output_curves [out] - An array containing one or more curves if successful. Return:

◆ RhinoCurveBoolean() [1/2]

RHINO_SDK_FUNCTION bool RhinoCurveBoolean	(	const ON_SimpleArray< const ON_Curve * > &	InCurves,
		const ON_Plane &	plane,
		const ON_SimpleArray< ON_3dPoint > &	InPoints,
		bool	bAllRegions,
		bool	bCombineRegions,
		double	tolerance,
		ON_SimpleArray< ON_Curve * > &	PlanarCurves,
		ON_ClassArray< ON_CurveRegion > &	OutRegions
	)

Description: Trims and splits curves based on their overlapping regions. Parameters: InCurves - [in] An array of curves. plane - [in] Regions will be found in the projection of the curves to this plane. InPoints - [in] These points will be projected to plane. All regions that contain at least one of these points will be found. bAllRegions - [in] InPoints will be ignored. All regions will be found. bCombineRegions - [in] If true, then adjacent regions will be combined. tolerance - [in] Function tolerance. When in doubt, use the document's model absolute tolerance. PlanarCurves - [out] The region curves. Note, memory for these curves is allocated and is the responsibility of the caller. OutRegions - [out] The indices and parameters for the members of PlanarCurves. Returns: true if successful, false otherwise.

◆ RhinoCurveBoolean() [2/2]

RHINO_SDK_FUNCTION bool RhinoCurveBoolean	(	const ON_SimpleArray< const ON_Curve * > &	InCurves,
		const ON_Plane &	plane,
		const ON_SimpleArray< ON_3dPoint > &	InPoints,
		bool	bAllRegions,
		bool	bCombineRegions,
		double	tolerance,
		ON_SimpleArray< ON_Curve * > &	PlanarCurves,
		ON_ClassArray< ON_CurveRegion > &	OutRegions,
		ON_SimpleArray< int > &	PointRegionIds
	)

Description: Trims and splits curves based on their overlapping regions. Parameters: InCurves - [in] An array of curves. plane - [in] Regions will be found in the projection of the curves to this plane. InPoints - [in] These points will be projected to plane. All regions that contain at least one of these points will be found. bAllRegions - [in] InPoints will be ignored. All regions will be found. bCombineRegions - [in] If true, then adjacent regions will be combined. tolerance - [in] Function tolerance. When in doubt, use the document's model absolute tolerance. PlanarCurves - [out] The region curves. Note, memory for these curves is allocated and is the responsibility of the caller. OutRegions - [out] The indices and parameters for the members of PlanarCurves. PointRegionIds - [out] Only used if bAllRegions is false. Parallel to InPoints. Index into OutRegions. PointRegionIds[i] = n means InPoints[i] is contained in OutRegions[n]. If InPoints[i] is not in any region, then PointRegionIds[i] = -1. Also, if InPoints[i] is within tolerance on any of the input curves, not just the final region boundaries, then PointRegionIds[i] = -1. Returns: true if successful, false otherwise.

◆ RhinoCurveBooleanDifference() [1/2]

RHINO_SDK_FUNCTION int RhinoCurveBooleanDifference	(	const ON_Curve *	crvA,
		const ON_Curve *	crvB,
		double	tolerance,
		ON_SimpleArray< ON_Curve * > &	OutCurves
	)

Description: Calculates the boolean difference between two closed, planar curves. Note, curves must be co-planar. Parameters: crvA - [in] The first closed, planar curve. crvB - [in] The second closed, planar curve. tolerance - [in] 3d fitting and intersecting tolerance. OutCurves - [out] The results. NOTE: THE CALLER IS RESPONSIBLE FOR DESTROYING THESE CURVES. Returns: The number of curves added to OutCurves if successful. 0 if not successful. See Also: RhinoCurveBooleanUnion RhinoCurveBooleanIntersection

◆ RhinoCurveBooleanDifference() [2/2]

RHINO_SDK_FUNCTION int RhinoCurveBooleanDifference	(	const ON_Curve *	crvA,
		const ON_SimpleArray< const ON_Curve * > &	crvB,
		double	cbtol,
		ON_SimpleArray< ON_Curve * > &	OutCurves
	)

◆ RhinoCurveBooleanIntersection()

RHINO_SDK_FUNCTION int RhinoCurveBooleanIntersection	(	const ON_Curve *	crvA,
		const ON_Curve *	crvB,
		double	tolerance,
		ON_SimpleArray< ON_Curve * > &	OutCurves
	)

Description: Calculates the boolean intersection of two closed, planar curves. Note, curves must be co-planar. Parameters: crvA - [in] The first closed, planar curve. crvB - [in] The second closed, planar curve. tolerance - [in] 3d fitting and intersecting tolerance. OutCurves - [out] The results. NOTE: THE CALLER IS RESPONSIBLE FOR DESTROYING THESE CURVES. Returns: The number of curves added to OutCurves if successful. 0 if not successful. See Also: RhinoCurveBooleanUnion RhinoCurveBooleanDifference

◆ RhinoCurveBooleanUnion()

RHINO_SDK_FUNCTION int RhinoCurveBooleanUnion	(	const ON_SimpleArray< const ON_Curve * > &	InCurves,
		double	tolerance,
		ON_SimpleArray< ON_Curve * > &	OutCurves
	)

Description: Calculates the boolean union of two or more closed, planar curves. Note, curves must be co-planar. Parameters: InCurves - [in] The curves co-planar curves to union. tolerance - [in] 3d fitting and intersecting tolerance. OutCurves - [out] The results. NOTE: THE CALLER IS RESPONSIBLE FOR DESTROYING THESE CURVES. Returns: The number of curves added to OutCurves if successful. 0 if not successful. See Also: RhinoCurveBooleanIntersection RhinoCurveBooleanDifference

◆ RhinoCurveBrepIntersect()

RHINO_SDK_FUNCTION bool RhinoCurveBrepIntersect	(	const ON_Curve &	crv,
		const ON_Brep &	brep,
		double	tol,
		ON_SimpleArray< ON_Curve * > &	curves,
		ON_3dPointArray &	points
	)

Description: Brep - curve intersector. Gets 3d points of intersection and 3d overlap curves. Returns FALSE if there is an error processing an overlap curve. In that case, partial results will be returned. Parameters: crv - [in] input curve brep - [in] input Brep tol - [in] fitting and near miss tolerance curves - [out] output 3d overlap curves points - [out] output 3d intersection points Returns: TRUE - successful FALSE - failure. Partial results will be returned

◆ RhinoCurveCurveIntersect()

RHINO_SDK_FUNCTION int RhinoCurveCurveIntersect	(	const ON_Curve &	curveA,
		const ON_Curve &	curveB,
		double	tolerance,
		ON_SimpleArray< CRhinoCCXEvent > &	x,
		const ON_Interval *	curveA_domain = `NULL`,
		const ON_Interval *	curveB_domain = `NULL`
	)

Description: Intersect two curves. Parameters: curveA - [in] curveB - [in] x - [out] array of intersection events sorted by curveA parameters. Remarks: The curves must be 2 or 3 dimensional and have the same dimension. If the curves are the same, a single overlap event will be returned. See Also: RhinoCurveSelfIntersect

◆ RhinoCurveExtremeParameters()

RHINO_SDK_FUNCTION int RhinoCurveExtremeParameters	(	const ON_Curve &	curve,
		const ON_3dVector &	dir,
		ON_SimpleArray< double > &	out_parameters
	)

Description: Returns the parameter values of all local extrema. Parameter values are in increasing order so consecutive extrema define an interval on which each component of the curve is monotone. Note, non-periodic curves always return the end points. Parameters: curve [in] - The curve to calculate all local extrema. dir [in] - The direction in which to perform the calculation. out_parameters [out] - The parameter values of all local extrema. Return: The number of parameter values added to out_parameters.

◆ RhinoCurveFaceIntersect()

RHINO_SDK_FUNCTION bool RhinoCurveFaceIntersect	(	const ON_Curve &	crv,
		const ON_BrepFace &	face,
		double	tol,
		ON_SimpleArray< ON_Curve * > &	curves,
		ON_3dPointArray &	points
	)

Description: Brep face - curve intersector. Gets 3d points of intersection and 3d overlap curves. Returns FALSE if there is an error processing an overlap curve. In that case, partial results will be returned. Parameters: crv - [in] input curve face - [in] input face tol - [in] fitting and near miss tolerance curves - [out] output 3d overlap curves points - [out] output 3d intersection points Returns: TRUE - successful FALSE - failure. Partial results will be returned

◆ RhinoCurveInflectionPoints() [1/2]

RHINO_SDK_FUNCTION bool RhinoCurveInflectionPoints	(	const ON_Curve &	curve,
		ON_SimpleArray< ON_3dPoint > &	points
	)

Description: Calculates a curve's inflection points. An inflection point is a location on a curve at which the sign of the curvature (i.e., the concavity) changes. The curvature at these locations is always 0. Parameters: curve - [in] The curve to evaluate. points - [out] The inflection points. Returns: true if successful, false otherwise.

◆ RhinoCurveInflectionPoints() [2/2]

RHINO_SDK_FUNCTION bool RhinoCurveInflectionPoints	(	const ON_Curve &	curve,
		ON_SimpleArray< ON_3dPoint > &	points,
		ON_SimpleArray< double > &	parameters
	)

Description: Calculates a curve's inflection points. An inflection point is a location on a curve at which the sign of the curvature (i.e., the concavity) changes. The curvature at these locations is always 0. Parameters: curve - [in] The curve to evaluate. points - [out] The inflection points. parameters - [out] The inflection parameters. Returns: true if successful, false otherwise.

◆ RhinoCurveMaxCurvaturePoints() [1/2]

RHINO_SDK_FUNCTION bool RhinoCurveMaxCurvaturePoints	(	const ON_Curve &	curve,
		ON_SimpleArray< ON_3dPoint > &	points
	)

Description: Calculates a curve's maximum curvature points. The maximum curvature points identify where the curvature starts to decrease in both directions from the points. Parameters: curve - [in] The curve to evaluate. points - [out] The minimum curvature radius points. Returns: true if successful, false otherwise.

◆ RhinoCurveMaxCurvaturePoints() [2/2]

RHINO_SDK_FUNCTION bool RhinoCurveMaxCurvaturePoints	(	const ON_Curve &	curve,
		ON_SimpleArray< ON_3dPoint > &	points,
		ON_SimpleArray< double > &	parameters
	)

Description: Calculates a curve's maximum curvature points. The maximum curvature points identify where the curvature starts to decrease in both directions from the points. Parameters: curve - [in] The curve to evaluate. points - [out] The minimum curvature radius points. parameters - [out] TThe minimum curvature parameters. Returns: true if successful, false otherwise.

◆ RhinoCurveOnSurfacePoints() [1/2]

RHINO_SDK_FUNCTION bool RhinoCurveOnSurfacePoints	(	const ON_Surface &	Srf,
		const ON_SimpleArray< ON_2dPoint > &	Fixed2,
		const ON_SimpleArray< double > &	Dist,
		const ON_ClassArray< ON_SimpleArray< ON_2dPoint > > &	Geo,
		double	tol,
		bool	Periodic,
		int	init_count,
		int	nlevels,
		ON_SimpleArray< ON_2dPoint > &	out,
		ON_SimpleArray< double > &	t,
		ON_SimpleArray< int > *	pIndex
	)

◆ RhinoCurveOnSurfacePoints() [2/2]

RHINO_SDK_FUNCTION bool RhinoCurveOnSurfacePoints	(	const ON_Surface &	Srf,
		const ON_SimpleArray< ON_2dPoint > &	Fixed2,
		double	tol,
		bool	Periodic,
		int	init_count,
		int	nlevels,
		ON_SimpleArray< ON_2dPoint > &	out,
		ON_SimpleArray< double > &	t,
		ON_SimpleArray< int > *	pIndex = `nullptr`
	)

Description: Detailed tool to compute 'splines' on a surface. This function creates a discrete 'spline' curve on the surface, i.e. a sequence of point on the surface each with a corresponding parameter value. The curve interpolates a sequence of points on the surface. Parameters: Srf - [in] The surface on which the curve is constructed. Fixed2 - [in] Surface points to interpolate given by parameters. These must be distinct. tol - [in] Relative tolerance used in solver. Use 0 for default value. Periodic - [in] Construct a smoothly closed curve when true. Fixed2[0]==Fixed2.Last() (at least up to addition of a period) init_count - [in] Maximum number of points to insert between fixed points on first level. nlevels - [in] Number of levels to be used in multilevel solver. out - [out] Sequence of surface points (given by surface parameters). t - [out] Curve parameter associated with each out value, where: out.Count()==t.Count() pIndex - [out] If not null, then out[(*pIndex)[i]]==Fixed2[i] Remarks: Srf should be G1 continuous. If Srf is closed in the u or the v direction and is G1 at the seam then the function can construct point sequences that cross over the seam. In this case the surface parameter space points in Fixed2 and out are in the covering space of Srf.Domain, i.e they extend across the domain boundaries of Srf.Domain(0) in the the sense of a natural periodic extension. (See ON_PeriodicDomain for more information). Also, the number of out points is approximately 2^(nlevel-1)*init_count*Fixed2.Count()

◆ RhinoCurveOnSurfaceSolver()

RHINO_SDK_FUNCTION bool RhinoCurveOnSurfaceSolver	(	const ON_Surface &	Srf,
		ON_SimpleArray< ON_2dPoint > &	out,
		ON_SimpleArray< int > &	Index,
		ON_SimpleArray< double > &	t,
		ON_SimpleArray< double > &	tol,
		bool	Periodic,
		int	Num_Levels
	)

Description: Expert function to compute CurveOnSurfacePoints using a multilevel solver. On input out, index and t provide a rough approximation of the curve. Parameters: Srf -[in] Surface on which curve lies out- [in/out] on input out is a rough approximation of the curve including all interpolation points. On output out is a discrete version of the curve on surface. On output out.Count() = 2^Num_Multilevels*( n_0 - 1) + 1 where n0 = out<.Count() at input. index -[in/out] The fixed interpolation values are identified by index. On input index.Count()<=out.Count() and the count of index is the same on output as on input. on both input and output index is an increasing list of indices in the range 0 to out.Count()-1. Furthermore index[0]=0 and index.Last()==out.Count()-1. Srf.Evaluate( out[index[j]] ) is a surface point to be interpolated and this value is the same on input as on output. t -[in/out] - on input t is an increasing list of parameters. t[i] is the parameter corresponding to the surface point Srf.Evaluate( out[i] ). t.Count()==out.Count(). on output t is an increasing list of parameters t.Count()=out.Count(). The first and last value in t are the same as they were in the input list. t is a refinement of the list at input. tol -[in] - An array of Num_level tolerance values. tol[0] is used for the top coarsest level etc.. set all tol values to 0 for default values. Periodic -[in] Set to true to generate a periodic curve instead of an open curve. If true then out.First() == out.Last() mod domain. Num_Levels -[in] Number of levels in multilevel solver. Use Num_Level=1 for single level solve, in this case out.Count() doesn't change. Use sparingly probably should have Num_Level<4. Remarks: If Srf is G1-closed in one or both directions the points in out may be taken in a covering space of Srf.Domain. See ON_PeriodicDomain.

◆ RhinoCurveSelfIntersect()

RHINO_SDK_FUNCTION int RhinoCurveSelfIntersect	(	const ON_Curve &	curve,
		double	tolerance,
		ON_SimpleArray< CRhinoCCXEvent > &	x,
		const ON_Interval *	curveA_domain = `NULL`,
		const ON_Interval *	curveB_domain = `NULL`
	)

Description: Intersect two curves. Parameters: curve - [in] tolerance - [in] intesection tolerance x - [out] array of intersection events sorted by curveA parameters. Remarks: The curves must be 2 or 3 dimensional and have the same dimension. If the curves are the same, a single overlap event will be returned. See Also: RhinoCurveSelfIntersect

◆ RhinoCurveSplit()

RHINO_SDK_FUNCTION bool RhinoCurveSplit	(	const ON_Curve &	curve,
		const ON_Brep &	splitter,
		double	tolerance,
		double	angtolrads,
		ON_SimpleArray< ON_Curve * > &	pieces
	)

Description: Splits a curve into pieces using a surface or a polysurface Parameters: curve - [in] Curve to split. splitter - [in] Splitter is a single, non-manifold Brep. tolerance - [in] intersection tolerance angtolrads - [in] angle tolerance in radians pieces - [out] Curves of all the split components. Returns: true if successful, false otherwise. Remarks: The caller is responsible for deleting the pieces when finished.

◆ RhinoCurveSurfaceIntersect()

RHINO_SDK_FUNCTION int RhinoCurveSurfaceIntersect	(	const ON_Curve &	curve,
		const ON_Surface &	surface,
		double	distance_tolerance,
		double	angle_tolerance_radians,
		ON_SimpleArray< CRhinoCSXEvent > &	x,
		const ON_Interval *	curve_domain = `NULL`,
		const ON_Interval *	surface_u_domain = `NULL`,
		const ON_Interval *	surface_v_domain = `NULL`
	)

Description: Intersect a curve and a surface. Parameters: curve - [in] surface - [in] distance_tolerance - [in] intersection 3d tolerance angle_tolerance_radians - in angle tolerance in radians (used to determine when a curve is tangent to the surface) x - [out] intersection event are appended to this array curve_domain - [in] if not NULL, the intersection is restricted to this subdomain of curve1 surface_u_domain - [in] if not NULL, the intersection is restricted to this subdomain of of the first surface parameter. surface_v_domain - [in] if not NULL, the intersection is restricted to this subdomain of of the second surface parameter. Returns: Number of intersection events added to x[]. A return value of zero indicates no intersections were found.

◆ RhinoCutUpSurface()

RHINO_SDK_FUNCTION void RhinoCutUpSurface	(	const ON_Surface &	srf,
		BOOL32	bFlip,
		const ON_SimpleArray< ON_Curve * > &	EdgeCurves,
		double	ftol,
		double	ctol,
		ON_SimpleArray< ON_Brep * > &	Breps,
		double *	max_tol_used = `nullptr`
	)

Description: Surface splitter. Parameters: srf - [in] The surface to be split bFlip - [in] If true, input curves are oriented clockwise. EdgeCurves - [in] The new edge curves (with consistent orientation). ftol - [in] The fitting tolerance. ctol - [in] Used to decide which face to keep. For best results, should be at least 2*ftol. Breps - [out] The results of the split. max_tol_used - [in] Default is NULL. ftol is the desired trimming tolerance. If the curves are not within ftol of the surface, the distance to the surface is used for trimming. max_ftol_used returns the maximum of the tolerances used. Always at least ftol.

◆ RhinoDefaultRendererId()

RHINO_SDK_FUNCTION ON_UUID RhinoDefaultRendererId ( void )

◆ RhinoDegreesSymbol()

RHINO_SDK_FUNCTION wchar_t RhinoDegreesSymbol ( )

Returns: 0x0B0 - the ASCII and Unicode degrees symbol

◆ RhinoDestroyDisplayMeshes()

RHINO_SDK_FUNCTION unsigned int RhinoDestroyDisplayMeshes	(	ON::mesh_type	mesh_type,
		CRhinoObjectIterator &	it,
		bool *	bRedrawNeeded
	)

Description: Destroy temporary meshes used for displaying shaded views of objects that are not mesh objects (like surfaces, polysurfaces and extrusions). Parameters: mesh_type - [in] Type of mesh to destroy. it - [in] Objects to test bRedrawNeeded - [out] If a mesh is destroyed and a viewport is not in wireframe display mode, the *bRedrawNeeded is set to true and the caller should eventually call doc.Redraw() to update Rhino's display. Return: Number of objects that had meshes that were destroyed.

◆ RhinoDihedralMeanMeshCurvature()

RHINO_SDK_FUNCTION bool RhinoDihedralMeanMeshCurvature	(	const ON_Mesh &	MeshIn,
		ON_SimpleArray< double > &	result
	)

Description: Function that computes the discrete mean curvatures, by taking the dihedral angles of the topology edges and dividing them by the edge lengths. The function takes care of mesh topology and quads by internal triangulation. Use at your own risk on nonmanifold meshes.

Parameters: MeshIn - [In] Input mesh result - [out] array to be filled with the curvatures. On success, its Count() will be MeshIn.VertexCount(). Returns: True or false depending on the success of the computation.

◆ RhinoDihedralMeanMeshCurvatureIncludingNaked()

RHINO_SDK_FUNCTION bool RhinoDihedralMeanMeshCurvatureIncludingNaked	(	const ON_Mesh &	MeshIn,
		ON_SimpleArray< double > &	result
	)

Description: Function that computes the discrete mean curvatures like the preceding one, but trying to give a meaningful result on naked edges, too. Moreover, it tries to find each "unwelded" vertex and treat it like such a naked edge. Parameters: MeshIn - [In] Input mesh result - [out] array to be filled with the curvatures. On success, its Count() will be MeshIn.VertexCount(). Returns: True or false depending on the success of the computation.

◆ RhinoDisableContinuousMainLoop()

RHINO_SDK_FUNCTION void RhinoDisableContinuousMainLoop ( )

This function makes it so that Rhino's main loop is not executed continuously. This is default behavior.

◆ RhinoDiscreteGaussianMeshCurvature()

RHINO_SDK_FUNCTION bool RhinoDiscreteGaussianMeshCurvature	(	const ON_Mesh &	MeshIn,
		ON_SimpleArray< double > &	result,
		double *	globalAngleDefect = `nullptr`
	)

Description: Function that computes the discrete Gaussian curvatures, by taking the angle defects and dividing them by the face areas. That definition has the desired property that its integral gives ON_2PI times the Euler characteristic, at least on a closed mesh. Thus, it satisfies the Gauss-Bonnet theorem which arguably characterizes the Gaussian curvature fully. Note that this function will triangulate internally along the short diagonal, but leave the mesh untouched. The function takes care of mesh topology and quads. Use at your own risk on nonmanifold meshes. Parameters: MeshIn - [In] Input mesh result - [out] array to be filled with the curvatures. On success, its Count() will be MeshIn.VertexCount(). globalAngleDefect - [out] optional, the sum of all angle defects before dividing by the vertex areas Returns: True or false depending on the success of the computation.

◆ RhinoDiscreteGaussianMeshCurvatureIncludingNaked()

RHINO_SDK_FUNCTION bool RhinoDiscreteGaussianMeshCurvatureIncludingNaked	(	const ON_Mesh &	MeshIn,
		ON_SimpleArray< double > &	result
	)

Description: Function that computes the discrete Gaussian curvatures like the preceding one, but trying to give a meaningful result on naked edges, too. Moreover, it tries to find each "unwelded" vertex and treat it like such a naked edge. Parameters: MeshIn - [In] Input mesh result - [out] array to be filled with the curvatures. On success, its Count() will be MeshIn.VertexCount(). Returns: True or false depending on the success of the computation.

◆ RhinoDisplaceMesh()

RHINO_SDK_FUNCTION ON_Mesh* RhinoDisplaceMesh	(	const ON_Mesh &	originalMesh,
		const RhDisplacement &	displacement,
		const RhDisplacementArgs &	args,
		ON_wString &	problemString,
		ON_Terminator *	pCancelHandler = `0`,
		ON_ProgressReporter *	pProgressReporter = `0`
	)

Description: Create a mesh displaced by a texture. This operation can be canceled by pressing Esc. Parameters: originalMesh - [in] The mesh which we want to displace. displacement - [in] The texture and transformation data representing the displacement. args - [in] The arguments passed to the displacement algorithm. problemString - [out] If the algorithm fails, this string contains a description of what went wrong. pCancelHandler - [in] Pass an ON_Terminator to provide ability to cancel the operation, use NULL otherwise. pProgressReporter - [in] Used to display algorithm progress information. Pass in NULL to use default progress reporting functionality. Returns: A displaced mesh. NULL if failed or canceled. See Also: RhinoMeshPipeFromCurve, RhinoEdgeSoftenMesh, RhinoAddShutLinesToMesh

◆ RhinoDivideCurve()

RHINO_SDK_FUNCTION bool RhinoDivideCurve	(	const ON_Curve &	curve,
		double	seg_count,
		double	seg_length,
		bool	bReverse,
		bool	bIncludeEnd,
		ON_SimpleArray< ON_3dPoint > *	curve_P,
		ON_SimpleArray< double > *	curve_t
	)

Description: Calculation tool for the Rhino DivideCurve command. Parameters: curve - [in]; seg_count - [in] If > 0, the curve will be divided into this many segments. If > 0, then seg_length must be 0. seg_length -[in] If > 0, the curve will be divided into segments of this length. If > 0, then seg_count must be 0. bReverse - [in] If true and seg_length is used to divide the curve, then the divisions start from the end. bIncludeEnd - [in] If true, then the point at the start of the first division segment is returned. curve_P - [out] If not NULL, the division points are returned here. curve_t - [out] If not NULL, the curve parameters at the division points are returned here.

◆ RhinoDivideCurveEquidistant() [1/2]

RHINO_SDK_FUNCTION int RhinoDivideCurveEquidistant	(	const ON_Curve *	curve,
		double	distance,
		ON_SimpleArray< ON_3dPoint > &	points
	)

Description: Calculates 3d points on a curve where the linear distance between the points is equal. Parameters: curve - [in] The input curve. distance - [in] The distance between division points. points - [out] The results of the division. Returns: The number of points added to the output array if successful. 0 if not successful. See Also: RhinoDivideCurve Remarks: Unlike the RhinoDivideCurve SDK function, which divides a curve based on arc length, or the distance along the curve between two points, this function divides a curve based on the linear distance between points.

◆ RhinoDivideCurveEquidistant() [2/2]

RHINO_SDK_FUNCTION int RhinoDivideCurveEquidistant	(	const ON_Curve *	curve,
		double	distance,
		ON_SimpleArray< ON_3dPoint > &	points,
		ON_SimpleArray< double > *	parameters
	)

Description: Calculates 3d points on a curve where the linear distance between the points is equal. Parameters: curve - [in] The input curve. distance - [in] The distance between division points. points - [out] The results of the division. parameters - [out] The curve parameters at the point locations. Returns: The number of points added to the output array if successful. 0 if not successful. See Also: RhinoDivideCurve Remarks: Unlike the RhinoDivideCurve SDK function, which divides a curve based on arc length, or the distance along the curve between two points, this function divides a curve based on the linear distance between points.

◆ RhinoDoCurveDirectionsMatch()

RHINO_SDK_FUNCTION bool RhinoDoCurveDirectionsMatch	(	const ON_Curve *	c0,
		const ON_Curve *	c1
	)

Description: Tests if two curves are generally in the same direction, or if they would be more in the same direction if they were flipped. Parameters: c0 - [in] the first curve to test. c1 - [in] the second curve to test. Returns: true - generally in the same direction false - would be more in the same direction if they were flipped

◆ RhinoDollyExtents() [1/4]

RHINO_SDK_FUNCTION bool RhinoDollyExtents	(	class CRhinoObjectIterator &	it,
		const CRhinoViewport &	rhino_vp,
		double	border,
		ON_Viewport &	zoomed_vp,
		const ON_SimpleArray< ON_3dPoint > *	extra_points = `nullptr`,
		ON_BoundingBox *	camcoord_box = `nullptr`
	)

Description: Dolly the camera location and so that the view frustum contains the list of objects and the objects are as large as possible. If the projection is perspective, the camera angle is not changed. Parameters: it - [in] list of objects that need to be seen in the view. current_vp - [in] current projection - must be valid. border - [in] If border > 1.0, then the frustum in enlarged by this factor to provide a border around the view. 1.1 works well for parallel projections; 0.0 is suggested for perspective projections. zoomed_vp - [out] (can be the same as current_vp) projection with a view frustum that contains the list of objects. extra_points - [in] (default = NULL) optional list of world 3d points that need to be included in the view. camcoord_bbox - [out] (default = NULL) will be set to the camera coordinate bounding used to compute the extents with respect to the viewport Returns: True if successful. Remarks: This version of RhinoDollyExtents calculates a tight camera coordinate bounding box of the list of objects and calls

RhinoDollyExtents( current_vp, camcoord_bbox, zoomed_vp )

to calculate the new projection.

◆ RhinoDollyExtents() [2/4]

RHINO_SDK_FUNCTION bool RhinoDollyExtents	(	class CRhinoView *	view,
		bool	active_viewport = `true`
	)

Description: Dolly the camera location and so that the view frustum contains all of the selected document objects that can be seen in view. If the projection is perspective, the camera angle is not changed. Parameters: view - [in/out] The view to adjust active_viewport - [in] if true, dolly is performed on the ActiveViewport of the view if false, dolly is performed on the MainViewport of the view Returns: True if successful. Remarks: This version of RhinoDollyExtents determines what border factor would be used by the Rhino Zoom command and calls RhinoDollyExtents(view,border).

◆ RhinoDollyExtents() [3/4]

RHINO_SDK_FUNCTION bool RhinoDollyExtents	(	class CRhinoViewport &	viewport,
		double	border
	)

Description: Dolly the camera location and so that the view frustum contains all of the document objects that can be seen in view. If the projection is perspective, the camera angle is not changed. Parameters: viewport - [in/out] border - [in] If border > 1.0, then the frustum in enlarged by this factor to provide a border around the view. 1.1 works well for parallel projections; 0.0 is suggested for perspective projections. Returns: True if successful. Remarks: This version of RhinoDollyExtents sets up an appropriate iterator and uses:

RhinoDollyExtents( iterator, viewport.VP(), border, viewport.VP() )

to calculate the new projection.

◆ RhinoDollyExtents() [4/4]

RHINO_SDK_FUNCTION bool RhinoDollyExtents	(	const ON_Viewport &	current_vp,
		ON_BoundingBox	camcoord_bbox,
		ON_Viewport &	zoomed_vp
	)

Description: Dolly the camera location and so that the view frustum contains camcoord_bbox and the volume of camcoord_bbox fills the frustum. If the projection is perspective, the camera angle is not changed. Parameters: current_vp - [in] current projection - must be valid. camcoord_bbox - [in] valid bounding box in current_vp camera coordinates zoomed_vp - [out] (can be the same as current_vp projection Returns: True if successful.

◆ RhinoDollyExtentsSelected() [1/2]

RHINO_SDK_FUNCTION bool RhinoDollyExtentsSelected	(	class CRhinoView *	view,
		bool	active_viewport = `true`
	)

Description: Dolly the camera location and so that the view frustum contains all of the selected document objects that can be seen in view. If the projection is perspective, the camera angle is not changed. Parameters: view - [in/out] active_viewport - [in] if true, dolly is performed on the ActiveViewport of the view if false, dolly is performed on the MainViewport of the view Returns: True if successful. Remarks: This version of RhinoDollyExtentsSelected determines what border factor would be used by the Rhino Zoom command and calls RhinoDollyExtentsSelected(view,border).

◆ RhinoDollyExtentsSelected() [2/2]

RHINO_SDK_FUNCTION bool RhinoDollyExtentsSelected	(	class CRhinoViewport &	viewport,
		double	border
	)

Description: Dolly the camera location and so that the view frustum contains all of the selected document objects that can be seen in view. If the projection is perspective, the camera angle is not changed. Parameters: viewport - [in/out] border - [in] If border > 1.0, then the frustum in enlarged by this factor to provide a border around the view. 1.1 works well for parallel projections; 0.0 is suggested for perspective projections. Returns: True if successful. Remarks: This version of RhinoDollyExtentsSelected sets up an appropriate iterator and uses

RhinoDollyExtents( iterator, viewport.VP(), border, viewport.VP() )

to calculate the new projection.

◆ RhinoDuplicateCurveSegments()

RHINO_SDK_FUNCTION int RhinoDuplicateCurveSegments	(	const ON_Curve *	curve,
		ON_SimpleArray< ON_Curve * > &	OutCurves
	)

Description: Curve segment duplicator (exploder). Explodes polylines, polycurves and G1 discontinuous NURBS curves. Parameters: curve - [in] The curve whose segments you want duplicated. OutCurves - [out] The curve segments that were duplicated. Returns: The number of curves added to OutCurves if successful, 0 otherwise. Remarks: THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CURVES.

◆ RhinoDuplicateLayers()

RHINO_SDK_FUNCTION int RhinoDuplicateLayers	(	CRhinoDoc &	doc,
		const ON_SimpleArray< int > &	in_layers,
		bool	bDuplicateObjects,
		bool	bDuplicateSublayers,
		ON_SimpleArray< int > &	out_layers
	)

Description: Duplicates one or more layer and, optionally, all of the objects on the layer. Parameters: doc [in] - The document. in_layers [in] - The indices of one or more layers to duplicate. bDuplicateObjects [in] - If true, then layer objects will also be duplicated. bDuplicateSublayers [in] - If true, then a layer's sublayers will also be duplicated. out_layers [out] - The indices of the newly added layers. Returns: The number of layer indices added to out_layers.

◆ RhinoDupMeshBorder()

RHINO_SDK_FUNCTION ON_PolylineCurve* RhinoDupMeshBorder ( const ON_MeshComponentRef * pMeshEdgeRef )

Description: Given a starting (naked) edge ref, this function attempts to determine a hole/border by chaining additional naked edges together until if returns to the start index.

Parameters: pMeshEdgeRef - [In] Starting naked edge reference

Returns: pointer to curve on success, nullptr on failure

◆ RhinoDynamicViewChange()

RHINO_SDK_FUNCTION void RhinoDynamicViewChange ( CRhinoView * view )

Description: For expert use only. CRhinoView::InterruptDrawing() hook for spacemouse-type devices.

◆ RhinoEdgeSoftenMesh()

RHINO_SDK_FUNCTION ON_Mesh* RhinoEdgeSoftenMesh	(	const ON_Mesh &	originalMesh,
		const RhEdgeSofteningArgs &	args,
		ON_Terminator *	pCancelHandler = `0`
	)

Description: Soften the edges of a mesh. Parameters: originalMesh - [in] The mesh whose edges we want to soften. args - [in] The arguments used in edge softening. pCancelHandler - [in] Pass an ON_Terminator to provide ability to cancel the operation, use NULL otherwise. Returns: A new mesh with softened edges. NULL if failed. See Also: RhinoMeshPipeFromCurve, RhinoDisplaceMesh, RhinoAddShutLinesToMesh

◆ RhinoEnableContinuousMainLoop()

RHINO_SDK_FUNCTION bool RhinoEnableContinuousMainLoop ( )

This function makes it so that Rhino's main loop is executed continuously. This is useful when Rhino needs to be doing something as often as possible, such as rendering a view at interactive frame rates.

◆ RhinoExplodeDimension()

RHINO_SDK_FUNCTION bool RhinoExplodeDimension	(	const ON_Dimension *	dimension,
		const ON_DimStyle *	dimstyle,
		ON_SimpleArray< ON_Curve * > &	out_curves,
		ON_SimpleArray< ON_Geometry * > &	out_objects
	)

Description: Explodes a dimension into its component parts. Parameters: leader - [in] The dimension to explode. dimstyle - [in] The dimension's effective dimension style. out_curves - [out] The output curves. out_objects - [out] The output text and instance references (if the dimension is using user-defined arrowheadsrowheads) Returns: True if successful, false otherwise.

◆ RhinoExplodeLeader()

RHINO_SDK_FUNCTION bool RhinoExplodeLeader	(	const ON_Leader *	leader,
		const ON_DimStyle *	dimstyle,
		ON_SimpleArray< ON_Curve * > &	out_curves,
		ON_SimpleArray< ON_Geometry * > &	out_objects
	)

Description: Explodes a leader into its component parts. Parameters: leader - [in] The leader to explode. dimstyle - [in] The leader's effective dimension style. out_curves - [out] The output curves. out_objects - [out] The output text and instance references (if the leader is using user-defined arrowheadsrowheads) Returns: True if successful, false otherwise.

◆ RhinoExplodeMesh()

RHINO_SDK_FUNCTION int RhinoExplodeMesh	(	const ON_Mesh *	mesh_in,
		ON_SimpleArray< ON_Mesh * > &	meshlist_out
	)

Description: RhinoExplodeMesh "explodes" the input mesh into submeshes where a submesh is a collection of faces that are contained within a closed loop of "unwelded" edges. Unwelded edges are edges where the faces that share the edge have unique mesh vertices (not mesh topology vertices) at both ends of the edge. See the definition of ON_MeshTopologyEdge and ON_MeshFace for more details.

Parameters: mesh_in - [In] Mesh to be exploded meshlist_out - [Out] Array of submeshes that result from exploding the input

Returns: The number of meshes that the input mesh was divided into. If the count is 1 then nothing happened and the output is essentially a copy of the input. Returns 0 on error, -1 if the input mesh has only 1 face, and -2 on user cancel.

◆ RhinoExtendBrepFacesToConnect() [1/2]

RHINO_SDK_FUNCTION bool RhinoExtendBrepFacesToConnect	(	const ON_BrepFace *	pFace0,
		int	edgeIndex0,
		const ON_BrepFace *	pFace1,
		int	edgeIndex1,
		double	tol,
		double	angleTol,
		ON_Brep *&	outBrep0,
		ON_Brep *&	outBrep1
	)

Description: Extends faces to meet and trims the faces to each other. If input faces intersect without extending, the edge indicates the side to keep. Parameters : pFace0 - [in] first face to connect edgeIndex0 - [in] edge to extend. pFace1 - [in] second surface edgeIndex1 - [in] edge to extend. tol - [in] tolerance used for intersecting faces and for simplifying intersection curve. angleTol - [in] angle tolerance in radians used for simplifying intersection curve. outBrep0 - [out] first face extended and trimmed to connect with the second face. outBrep1 - [out] second face extended and trimmed to connect with the first face. Returns : true if valid connection found.

◆ RhinoExtendBrepFacesToConnect() [2/2]

RHINO_SDK_FUNCTION bool RhinoExtendBrepFacesToConnect	(	const ON_BrepFace *	pFace0,
		ON_3dPoint	f0SelPt,
		const ON_BrepFace *	pFace1,
		ON_3dPoint	f1SelPt,
		double	tol,
		double	angleTol,
		ON_Brep *&	outBrep0,
		ON_Brep *&	outBrep1
	)

Description: Extends faces to meet and trims the faces to each other. If input faces intersect without extending, the selection point indicates the side to keep. Parameters : pFace0 - [in] first face to connect f0SelPt - [in] selection point on first face near the edge to extend. pFace1 - [in] second surface f1SelPt - [in] selection point on second face near the edge to extend. tol - [in] tolerance used for intersecting faces and for simplifying intersection curve. angleTol - [in] angle tolerance in radians used for simplifying intersection curve. outBrep0 - [out] first face extended and trimmed to connect with the second face. outBrep1 - [out] second face extended and trimmed to connect with the first face. Returns : true if valid connection found.

◆ RhinoExtendCrvOnSrf()

RHINO_SDK_FUNCTION bool RhinoExtendCrvOnSrf	(	const ON_BrepFace &	face,
		ON_Curve *&	crv,
		int	side = `2`
	)

Description: Extend a curve on a face Parameters: face - [in] a Brep face to extend the curve on crv - [in/out] pointer to the input curve can be either a 2d parameter space curve or a 3d-curve. At output this is a pointer to the output curve, which contains the input curve as a sub-curve. side - [in] end to extend. 0- beginning, 1, end, 2 - both Returns: true the function succeeded false the function failed the crv is left unchanged Details: If crv is a 2d parameter space curve and either end is in the active region of the face the curve is extended at this end,in a C^1 fashion. the extension may not end at the boundary of the face. The resulting curve is a ON_PolyCurve with the original curve as one of the polycurve segments.

If crv is a 3d model space curve and either end projects, via the closest point projection, to the interior of the active region of the face then the curve is extended at this end, in a C^1 fashion.

◆ RhinoExtendCurve() [1/3]

RHINO_SDK_FUNCTION bool RhinoExtendCurve	(	ON_Curve *&	crv,
		CRhinoExtend::Type	type,
		int	side,
		const ON_SimpleArray< const ON_Geometry * > &	geom
	)

Description: Extend a curve by a line, arc or smooth extension until it intersects a collection of objects Parameters: crv -[in/out] curve to extend. Note either *crv can change or the pointer crv can be changed by the routine. type -[in] type of extension, line, arc or smooth side -[in] end to extend. 0- beginning, 1, end, 2 - both geom -[in] collection of objects. Allowable object types are ON_Curve, ON_Surface, ON_Brep, Return: Returns true if the extension hit an object.

◆ RhinoExtendCurve() [2/3]

RHINO_SDK_FUNCTION bool RhinoExtendCurve	(	ON_Curve *&	crv,
		CRhinoExtend::Type	type,
		int	side,
		double	length
	)

Description: Extend a curve by a line, arc or smooth extension for a specified distance Parameters: crv - [in/out] curve to extend. Note either *crv can change or the pointer crv can be changed by the routine. type - [in] type of extension, line, arc or smooth side - [in] end to extend. 0- beginning, 1, end, 2 - both length - [in] length of extension ( >= 0) Returns: true if desired extension achieved. Details: The parametric curve is extended, i.e. if c' is the extension of c then c(t) = c'(t) for any t in the domain of c. The extension is generally C1-continuous at the point of the extension, and may be smoother depending on the type of extension.

When type==RhinoExtend::Smooth the parametric curve is extended by the analytic extension. The curve *crv is modified, in particular the type is unchanged. If the curve is a NURBS curve, or a polycurve with a NURBS curve at the end to be extended, then the extension length is only approximate. Also, refer to the comments in TL_ExtendNurb for warnings about smooth extensions of NURBS curves.

When type==RhinoExtend::Line or RhinoExtend::Arc the result is an ON_PolyCurve with the extensions being the first and/or last segments. The user must delete the returned polycurve.

When type=RhinoExtend::Arc the result is G2-continuous, but generally not C2-continuous.

Even if the function returns false the curve may be extended as far as possible, e.g., an arc may be extended to 360 degrees but not more.

Returns false on closed curves.

◆ RhinoExtendCurve() [3/3]

RHINO_SDK_FUNCTION bool RhinoExtendCurve	(	ON_Curve *&	crv,
		CRhinoExtend::Type	type,
		int	side,
		ON_3dPoint	end
	)

Description: Extend a curve by a line, arc or smooth extension. The extension endpoint is specified. Parameters: crv -[in/out] curve to extend. Note either *crv can change or the pointer crv can be changed by the routine. type -[in] type of extension, line, arc or smooth side -[in] end to extend. 0- beginning, 1- end end -[in] end point of extension Return: Returns true if the extension hit an object.

◆ RhinoExtendLineThroughBox()

RHINO_SDK_FUNCTION BOOL32 RhinoExtendLineThroughBox	(	const ON_Line &	line_in,
		const ON_BoundingBox &	bbox,
		ON_Line &	line_out
	)

Description: Find a line collinear with line_in that goes completely through the box Parameters: line_in [in] - The original line ( not modified) bbox [in] - The box to extend through line_out [out] - The extended line Returns: @untitled table TRUE Success False Failure

◆ RhinoExtendSurface()

RHINO_SDK_FUNCTION bool RhinoExtendSurface	(	ON_Surface *&	srf,
		ON_Surface::ISO	edge_index,
		double	ExtensionLength,
		bool	SmoothToggle
	)

Description: Extend an untrimmed surface along one edge. Parameters: srf - [in/out] surface to modify/ or replace. The surface must be on the heap since it may be deleted and a new object of the appropriate type is returned. edge -[in] edge to extend must be N_iso, E_iso, S_iso, or W_iso length -[in]>0 Smooth -[in] true for smooth (C-infinity) extension false for a C1- ruled extension Returns: true if extension is successfully computed false no changes

◆ RhinoExtractDuplicateMeshFaces() [1/2]

RHINO_SDK_FUNCTION int RhinoExtractDuplicateMeshFaces	(	const ON_Mesh &	MeshIn,
		bool	bBoth,
		ON_Mesh &	MeshOut,
		ON_Mesh &	MeshExtractionOut
	)

Description: RhinoExtractDuplicateMeshFaces extractsduplicate mesh faces. Parameters: MeshIn - [In] Input mesh bBoth, [In] set to true if you want the pair of duplicate faces extracted. MeshOut - [Out] output mesh without duplicate faces MeshExtractionOut - [Out] output extracted duplicate faces Returns: The number of extracted duplicate faces.

◆ RhinoExtractDuplicateMeshFaces() [2/2]

RHINO_SDK_FUNCTION int RhinoExtractDuplicateMeshFaces	(	const ON_Mesh &	MeshIn,
		ON_Mesh &	MeshOut,
		ON_Mesh &	MeshExtractionOut
	)

Description: RhinoExtractDuplicateMeshFaces extractsduplicate mesh faces. Parameters: MeshIn - [In] Input mesh MeshOut - [Out] output mesh without duplicate faces MeshExtractionOut - [Out] output extracted duplicate faces Returns: The number of extracted duplicate faces.

◆ RhinoExtractMeshFaces()

RHINO_SDK_FUNCTION bool RhinoExtractMeshFaces	(	ON_SimpleArray< int > &	FaceIDXArray,
		ON_Mesh &	MeshIn,
		ON_Mesh &	MeshExtracted
	)

Description: RhinoExtractMeshFaces extracts mesh faces using list of indices and return two meshes.

Parameters: FaceIDXArray - [in] input list of face indices to be extracted MeshIn - [In/out] Input mesh. Output with extracted faces removed MeshExtracted - [out] extracted faces

Returns: true if at least one face was extracted.

◆ RhinoExtractNonManifoldMeshEdges() [1/2]

RHINO_SDK_FUNCTION int RhinoExtractNonManifoldMeshEdges	(	const ON_Mesh &	MeshIn,
		bool	bSelective,
		int	minFaceCtAroundEdge,
		ON_Mesh &	MeshOut,
		ON_Mesh &	MeshExtractionOut
	)

Description: RhinoExtractNonManifoldMeshEdges extracts non manifold edges. Parameters: MeshIn - [In] Input mesh bSelective - [In] if true, then extract hanging faces only minFaceCtAroundEdge - [In] NME must have greater than or equal to be included. MeshOut - [Out] output mesh pMeshExtractionOut - [Out] output extracted non-manifold part of the mesh Returns: The number of extracted faces.

◆ RhinoExtractNonManifoldMeshEdges() [2/2]

RHINO_SDK_FUNCTION int RhinoExtractNonManifoldMeshEdges	(	const ON_Mesh &	MeshIn,
		bool	bSelective,
		ON_Mesh &	MeshOut,
		ON_Mesh &	MeshExtractionOut
	)

Description: RhinoExtractNonManifoldMeshEdges extracts non manifold edges. Parameters: MeshIn - [In] Input mesh bSelective - [In] if true, then extract hanging faces only MeshOut - [Out] output mesh pMeshExtractionOut - [Out] output extracted non-manifold part of the mesh Returns: The number of extracted faces.

◆ RhinoExtrudeCurveStraight()

RHINO_SDK_FUNCTION ON_Surface* RhinoExtrudeCurveStraight	(	const ON_Curve *	pCurve,
		ON_3dVector	direction,
		double	scale = `1.0`
	)

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. Description Extrude a curve along a vector direction Parameters: [in] pCurve - curve to extrude [in] direction - the extrude vector [in] scale - optional scalar for the extrude vector Returns: The extruded surface if successful NULL if not Remarks: The direction vector is used for both distance and direction input The direction vector length is multiplied by scale

◆ RhinoExtrudeCurveToPoint()

RHINO_SDK_FUNCTION ON_Surface* RhinoExtrudeCurveToPoint	(	const ON_Curve *	pCurve,
		const ON_3dPoint &	apex
	)

Description Extrude a curve to a point making a coned surface Parameters: [in] pCurve - the curve to extrude [in] apex - the point for the tip of the surface Returns: The extruded surface if successful NULL if not

◆ RhinoFairCurve()

RHINO_SDK_FUNCTION ON_Curve* RhinoFairCurve ( CArgsRhinoFair & args )

Description: Fair a curve according to the settings in args
The input curve, args.m_pCurve, is not changed. Parameters: [in] args - What to fair and how to fair it ( see CArgsRhinoFair) Returns: The resulting faired curve. Caller must free this when done with it.

◆ RhinoFilletCurveCorners()

RHINO_SDK_FUNCTION ON_Curve* RhinoFilletCurveCorners	(	const ON_Curve *	curve,
		double	radius,
		double	tol,
		double	ang_tol
	)

Description: Rounds the corners of a kinked curve with arcs of a single, specified radius. Parameters: curve - [in] The curve to fillet. radius - [in] The fillet radius. tol - [in] The tolerance. When in doubt, use the document's model space absolute tolerance. ang_tol - [in] The angle tolerance in radians. When in doubt, use the document's model space angle tolerance. Returns: The modified curve if successful, NULL otherwise. Remarks: Memory for the result curve is allocated and becomes the responsibility of the caller.

◆ RhinoFilletSurface()

RHINO_SDK_FUNCTION bool RhinoFilletSurface	(	const ON_BrepFace *	pFace0,
		double	u0,
		double	v0,
		double	radius0,
		const ON_BrepFace *	pFace1,
		double	u1,
		double	v1,
		double	radius1,
		RhinoFilletSurfaceType	fillet_type,
		bool	bExtend,
		RhinoFilletSurfaceSplitType	split_type,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	OutFillets,
		ON_SimpleArray< ON_Brep * > &	OutBreps0,
		ON_SimpleArray< ON_Brep * > &	OutBreps1
	)

Description: Creates a surface between two surfaces. Parameters: pFace0 - [in] A pointer to the first face. u0 - [in] A parameter in the u direction of the first face at the side you want to keep after filleting. v0 - [in] A parameter in the v direction of the first face at the side you want to keep after filleting. radius0 - [in] The radius, or distance, from the intersection of pFace0 to the edge of the fillet. Note, radius0 should equal radius1 unless fillet_type == RhinoFilletSurfaceType::Chamfer, in which case the values can differ. pFace1 - [in] A pointer to the second face. u1 - [in] A parameter in the u direction of the second face at the side you want to keep after filleting. v1 - [in] A parameter in the v direction of the second face at the side you want to keep after filleting. radius1 - [in] The radius, or distance, from the intersection of pFace1 to the edge of the fillet. Note, radius0 should equal radius1 unless fillet_type == RhinoFilletSurfaceType::Chamfer, in which case the values can differ. fillet_type - [in] The type of fillet bExtend - [in] If true, then when one input surface is longer than the other, the fillet surface is extended to the input surface edges. split_type - [in] The split type tolerance - [in] The tolerance. In in doubt, the the document's absolute tolerance. OutFillets - [out] The results of the fillet calculation. NOTE: Memory for the output is allocated and is the responsibility of the caller. OutBreps0 - [out] The trim or split results of the Brep owned by pFace0. NOTE: Memory for the output is allocated and is the responsibility of the caller. OutBreps1 - [out] The trim or split results of the Brep owned by pFace1. NOTE: Memory for the output is allocated and is the responsibility of the caller. Returns: true if successful, false otherwise. Remarks: The trim or split input Breps are in OutBreps0, and OutBreps1. If the input faces are from the same Brep, nothing will be added to OutBreps1. If you specified a split type of RhinoFilletSurfaceSplitType::Nothing, then nothing will be added to either OutBreps0 or OutBreps1.

◆ RhinoFilletSurfaceCurve()

RHINO_SDK_FUNCTION bool RhinoFilletSurfaceCurve	(	const ON_Curve *	pCurve,
		double	t,
		const ON_BrepFace *	pFace,
		double	u,
		double	v,
		double	radius,
		int	alignToCurve,
		int	railDegree,
		int	arcDegree,
		double *	arcSliders,
		int	nBezierSrfs,
		double	tolerance,
		ON_SimpleArray< ON_NurbsSurface * > &	out_fillets,
		double *	fitResults
	)

Description: Creates a constant-radius fillet surface between a surface and a curve. Parameters: pCurve - [in] A pointer to the free-standing 3D curve being filleted. t - [in] A parameter on the curve, indicating region of fillet. pFace - [in] A pointer to the face being filleted. u - [in] A parameter in the u direction of the face indicating which side of the curve to fillet. v - [in] A parameter in the v direction of the face indicating which side of the curve to fillet. radius - [in] The radius of the constant-radius fillet desired; NOTE: using arcSliders will change the shape of the arcs themselves alignToCrv - [in] Does the user want the fillet to align to the curve? 0 - No, ignore the curve's b-spline structure 1 - Yes, match the curves's degree, spans, CVs as much as possible 2 - Same as 1, but iterate to fit to tolerance Note that a value of 1 or 2 will cause nBezierSrfs to be ignored railDegree - [in] Desired fillet degree (3 or 5) in the u-direction, along the curve arcDegree - [in] Desired fillet degree (2, 3, 4, or 5) in the v-direction, along the fillet arcs. If 2, then the surface is rational in v arcSliders - [in] Array of 2 sliders to shape the fillet in the arc direction, used for arcDegree = 3, 4, or 5; input { 0.0, 0.0 } to ignore [0] (-1 to 1) slides tangent arms from base (-1) to theoretical (1) [1] (-1 to 1) slides inner CV(s) from base (-1) to theoretical (1) nBezierSrfs - [in] If >0, this indicates the number of equally-spaced fillet surfaces to be output in the rail direction, each surface Bézier in u. tolerance - [in] The tolerance. In in doubt, the the document's absolute tolerance. OutFillets - [out] The results of the fillet calculation. NOTE: Memory for the output is allocated and is the responsibility of the caller. fitResults - [out] array of doubles indicating fitting results: [0] max 3d point deviation along curve [1] max 3d point deviation along face [2] max angle deviation along face (in degrees) [3] max angle deviation between Bézier surfaces (in degrees) [4] max curvature difference between Bézier surfaces Returns: true if successful, false otherwise. Remarks: Face trimming, splitting not yet implemented

◆ RhinoFilletSurfaceNonRational()

RHINO_SDK_FUNCTION bool RhinoFilletSurfaceNonRational	(	const ON_BrepFace *	pFace0,
		double	u0,
		double	v0,
		const ON_BrepFace *	pFace1,
		double	u1,
		double	v1,
		double	radius,
		int	railDegree,
		int	arcDegree,
		double *	arcSliders,
		int	nBezierSrfs,
		bool	bExtend,
		RhinoFilletSurfaceSplitType	split_type,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	out_fillets,
		ON_SimpleArray< ON_Brep * > &	out_breps0,
		ON_SimpleArray< ON_Brep * > &	out_breps1,
		double *	fitResults
	)

Description: Creates a non-rational constant-radius fillet surface between two surfaces. Parameters: pFace0 - [in] A pointer to the first face. u0 - [in] A parameter in the u direction of the first face at the side you want to keep after filleting. v0 - [in] A parameter in the v direction of the first face at the side you want to keep after filleting. pFace1 - [in] A pointer to the second face. u1 - [in] A parameter in the u direction of the second face at the side you want to keep after filleting. v1 - [in] A parameter in the v direction of the second face at the side you want to keep after filleting. radius - [in] The radius of the constant-radius fillet desired; NOTE: using arcSliders will change the shape of the arcs themselves railDegree - [in] Desired fillet degree (3 or 5) in the u-direction, along the rails arcDegree - [in] Desired fillet degree (3, 4, or 5) in the v-direction, along arcs arcSliders - [in] array of 2 sliders to shape the fillet in the arc direction; input { 0.0, 0.0 } to ignore [0] (-1 to 1) slides tangent arms from base (-1) to theoretical (1) [1] (-1 to 1) slides inner CV(s) from base (-1) to theoretical (1) nBezierSrfs - [in] If >0, this indicates the number of equally-spaced fillet surfaces to be output in the rail direction, each surface Bézier in u. fillet_type - [in] The type of fillet bExtend - [in] If true, then when one input surface is longer than the other, the fillet surface is extended to the input surface edges. split_type - [in] The split type tolerance - [in] The tolerance. In in doubt, the the document's absolute tolerance. OutFillets - [out] The results of the fillet calculation. NOTE: Memory for the output is allocated and is the responsibility of the caller. OutBreps0 - [out] The trim or split results of the Brep owned by pFace0. NOTE: Memory for the output is allocated and is the responsibility of the caller. OutBreps1 - [out] The trim or split results of the Brep owned by pFace1. NOTE: Memory for the output is allocated and is the responsibility of the caller. fitResults - [out] array of doubles indicating fitting results: [0] max 3d point deviation along surface 0 [1] max 3d point deviation along surface 1 [2] max angle deviation along surface 0 (in degrees) [3] max angle deviation along surface 1 (in degrees) [4] max angle deviation between Bézier surfaces (in degrees) [5] max curvature difference between Bézier surfaces Returns: true if successful, false otherwise. Remarks: The trim or split input Breps are in OutBreps0, and OutBreps1. If the input faces are from the same Brep, nothing will be added to OutBreps1. If you specified a split type of RhinoFilletSurfaceSplitType::Nothing, then nothing will be added to either OutBreps0 or OutBreps1.

◆ RhinoFilletSurfaceToRail()

RHINO_SDK_FUNCTION bool RhinoFilletSurfaceToRail	(	const ON_BrepFace *	pFace0,
		const ON_Curve *	pRailCurve0,
		const ON_BrepFace *	pFace1,
		double	u1,
		double	v1,
		int	railDegree,
		int	arcDegree,
		double *	arcSliders,
		int	nBezierSrfs,
		bool	bExtend,
		RhinoFilletSurfaceSplitType	split_type,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	out_fillets,
		ON_SimpleArray< ON_Brep * > &	out_breps0,
		ON_SimpleArray< ON_Brep * > &	out_breps1,
		double *	fitResults
	)

Description: Creates a surface between two surfaces, with a fixed rail curve on the first surface. Parameters: pFace0 - [in] A pointer to the first face. pRailCurve0 - [in] A pointer to the desired fillet rail curve (3D) on the first face pFace1 - [in] A pointer to the second face. u1 - [in] A parameter in the u direction of the second face at the side you want to keep after filleting. v1 - [in] A parameter in the v direction of the second face at the side you want to keep after filleting. railDegree - [in] Desired fillet degree (3 or 5) in the u-direction, along the rails arcDegree - [in] Desired fillet degree (2, 3, 4, or 5) in the v-direction, along the fillet arcs. If 2, then the surface is rational in v arcSliders - [in] Array of 2 sliders to shape the fillet in the arc direction, used for arcDegree = 3, 4, or 5; input { 0.0, 0.0 } to ignore [0] (-1 to 1) slides tangent arms from base (-1) to theoretical (1) [1] (-1 to 1) slides inner CV(s) from base (-1) to theoretical (1) nBezierSrfs - [in] If >0, this indicates the number of equally-spaced fillet surfaces to be output in the rail direction, each surface Bézier in u. bExtend - [in] If true, then when one input surface is longer than the other, the fillet surface is extended to the input surface edges. split_type - [in] The split type tolerance - [in] The tolerance. In in doubt, the the document's absolute tolerance. OutFillets - [out] The results of the fillet calculation. NOTE: Memory for the output is allocated and is the responsibility of the caller. OutBreps0 - [out] The trim or split results of the Brep owned by pFace0. NOTE: Memory for the output is allocated and is the responsibility of the caller. OutBreps1 - [out] The trim or split results of the Brep owned by pFace1. NOTE: Memory for the output is allocated and is the responsibility of the caller. fitResults - [out] array of doubles indicating fitting results: [0] max 3d point deviation along surface 0 [1] max 3d point deviation along surface 1 [2] max angle deviation along surface 0 (in degrees) [3] max angle deviation along surface 1 (in degrees) [4] max angle deviation between Bézier surfaces (in degrees) [5] max curvature difference between Bézier surfaces Returns: true if successful, false otherwise. Remarks: The trim or split input Breps are in OutBreps0, and OutBreps1. If the input faces are from the same Brep, nothing will be added to OutBreps1. If you specified a split type of RhinoFilletSurfaceSplitType::Nothing, then nothing will be added to either OutBreps0 or OutBreps1.

◆ RhinoFillMeshHole()

RHINO_SDK_FUNCTION bool RhinoFillMeshHole	(	const int	StartEdgeIdx,
		ON_Mesh *	pMesh,
		ON_Mesh **	pMeshHolePatch = `nullptr`
	)

Description: Given a starting "naked" edge index, this function attempts to determine a "hole" by chaining additional naked edges together until if returns to the start index. Then it triangulates the closed polygon and either adds the faces to pMesh or optionally to pMeshHolePatch.

Parameters: StartEdgeIdx - [In] Starting naked edge index pMesh - [In / Out] Input mesh pMeshHolePatch - [Out] Optional output. New mesh is created rather than adding to pMesh.

Returns: true on success

Remarks: "naked" in the context of RhinoFillMeshHole, RhinoFillMeshHoles and RhinoDupMeshBorder, refers to edges that border a single face.

◆ RhinoFillMeshHoles()

RHINO_SDK_FUNCTION bool RhinoFillMeshHoles ( ON_Mesh * pMesh )

Description: This function attempts to determine "holes" in the input mesh by chaining naked edges together. Then it triangulates the closed polygons adds the faces to pMesh.

Parameters: pMesh - [In / Out] Input mesh

Returns: true on success

Remarks: This function does not differentiate between inner and outer naked edges. If you need that, it would be better to use RhinoFillMeshHole. You should be able to use ON_MeshTopologyFace::m_reve to determine what ought to be inner and outer.

◆ RhinoFindLocalInflection()

RHINO_SDK_FUNCTION bool RhinoFindLocalInflection	(	const ON_Curve &	curve,
		ON_3dVector	N,
		ON_Interval	subdomain,
		double	seed,
		double *	curve_param,
		double *	angle_error
	)

Description: Local minimization for point on a curve with tangent perpendicular to N. Parameters: curve - [in] A valid curve to evaluate. N - [in] N and the curve tangent define a plane, must not be zero. In this plane, there is a vector V perpendicular to the tangent. subdomain - [in] Subdomain to evaluate, must not be empty. seed - [in] A seed parameter, must be contained in the non-empty interval subdomain. curve_param - [out] The parameter on the curve. angle_error - [out] The measure in radians of the angle between N and V. The angle will be zero when the result is an inflection.Returns: Return is true if the minimization succeeds, regardless of angle_error. Remarks: The algorithm minimizes the square of the dot product of N with the curve tangent. It is possible that the result will not be close to zero.

◆ RhinoFitCircleToPoints() [1/2]

RHINO_SDK_FUNCTION bool RhinoFitCircleToPoints	(	const ON_SimpleArray< ON_3dPoint > &	point_array,
		ON_Circle &	circle
	)

Description: Fits a circle through an array of points. Parameters: points [in] - The points through which to fit. circle [out] - The resulting circle. Returns: true if successful, false otherwise. Remarks: Finds a best-fit circle through the points.

◆ RhinoFitCircleToPoints() [2/2]

RHINO_SDK_FUNCTION bool RhinoFitCircleToPoints	(	int	point_count,
		const ON_3dPoint *	points,
		ON_Circle &	circle
	)

◆ RhinoFitCurve()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoFitCurve	(	const ON_Curve &	curve_in,
		int	degree = `3`,
		double	dFitTol = `ON_UNSET_VALUE`,
		double	dAngleTol = `ON_UNSET_VALUE`,
		ON_NurbsCurve *	curve_out = `nullptr`
	)

Description: Fits a new curve through an existing curve. Parameters: curve_in - [in] the curve to fit. degree - [in] the output curve degree. Must be bigger than 1. dFitTol - [in] the fitting tolerance. If dFitTol is ON_UNSET_VALUE or <=0.0, the document absolute tolerance is used. dAngleTol - [in] the kink smoothing tolerance in radians. If dAngleTol is 0.0, all kinks are smoothed. If dAngleTol is >0.0, kinks smaller than dAngleTol are smoothed. If dAngleTol is ON_UNSET_VALUE or <0.0, the document angle tolerance is used for the kink smoothing. curve_out - [in] if not NULL this curve will be used for output. Returns: pointer to curve if success. NULL if unsuccessful. Notes:

◆ RhinoFitCurveToSurface()

RHINO_SDK_FUNCTION int RhinoFitCurveToSurface	(	const ON_NurbsSurface *	surface,
		const ON_Curve *	curve,
		ON_3dVector	projDir,
		ON_SimpleArray< double >	knots,
		double	tolerance,
		bool	bBezierSections,
		ON_SimpleArray< ON_NurbsCurve * > &	FitCurves,
		double *	FitMeasurement
	)

◆ RhinoFitCurveToSurface2()

RHINO_SDK_FUNCTION int RhinoFitCurveToSurface2	(	const ON_NurbsSurface *	surface,
		const ON_Curve *	curve,
		ON_3dVector	projDir,
		ON_SimpleArray< double >	knots,
		double	tolerance,
		bool	bBezierSections,
		ON_SimpleArray< ON_NurbsCurve * > &	FitCurves,
		ON_Curve **	trimCurveOnSurface,
		ON_Curve **	splitCurve,
		double *	FitMeasurement
	)

Parameters

trimCurveOnSurface if not null, returns the actual projected or pulled trim curve used for the split/fit

◆ RhinoFitLineToPoints() [1/2]

RHINO_SDK_FUNCTION bool RhinoFitLineToPoints	(	const ON_SimpleArray< ON_3dPoint > &	point_array,
		ON_Line &	line
	)

Description: Fit a plane through an array of points Parameters: points [in] - The points through which to fit plane [out] - The resulting plane box [out] - The 3d bounding box of the corners of the plane Returns: @untitled table 1 Results were inconclusive, as in collinear points, but some plane was found 0 Success -1 Couldn't find a plane Remarks: Finds a best-fit plane through the points

◆ RhinoFitLineToPoints() [2/2]

RHINO_SDK_FUNCTION bool RhinoFitLineToPoints	(	int	point_count,
		const ON_3dPoint *	points,
		ON_Line &	line
	)

◆ RhinoFitNurbsCurveToPoints()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoFitNurbsCurveToPoints	(	int	point_count,
		const ON_3dPoint *	pPoints,
		ON_3dVector *	pStartTan,
		ON_3dVector *	pEndTan,
		int	degree,
		bool	bPeriodic,
		double	tolerance,
		bool &	bToleranceAchieved
	)

Description: Fits a NURBS curve to a dense, ordered set of points. Parameters: point_count - [in] The number of points. pPoints - [in] The ordered list of points. pStartTan - [in] The tangent direction at the start of the curve. This value can be nullptr. pEndTan - [in] The tangent direction at the end of the curve. This value can be nullptr. degree - [in] The desired degree of the output curve. bPeriodic - [in] Set true if the output curve should be periodic. tolerance - [in] The fitting tolerance. When in doubt, use the document's absolute tolerance. bToleranceAchieved - [out] true if all points are within tolerance of the result. Most likely reason for a value of false is insufficient density of the point list relative to the complexity of the shape of the output. Returns: The output curve if successful, or nullptr on failure. Note, memory for the output curve is allocated and becomes the responsibility of the caller.

◆ RhinoFitPlaneToPoints() [1/2]

RHINO_SDK_FUNCTION int RhinoFitPlaneToPoints	(	const ON_SimpleArray< ON_3dPoint > &	point_array,
		ON_Plane &	plane,
		ON_BoundingBox &	box
	)

Description: Fit a plane through an array of points Parameters: points [in] - The points through which to fit plane [out] - The resulting plane box [out] - The 2d bounding box of the corners of the plane Returns: @untitled table 1 Results were inconclusive, as in collinear points, but some plane was found 0 Success -1 Couldn't find a plane Remarks: Finds a best-fit plane through the points

◆ RhinoFitPlaneToPoints() [2/2]

RHINO_SDK_FUNCTION int RhinoFitPlaneToPoints	(	int	point_count,
		const ON_3dPoint *	points,
		ON_Plane &	plane,
		ON_BoundingBox &	box
	)

◆ RhinoFitPointsOnSurface()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoFitPointsOnSurface	(	const ON_Surface &	srf,
		const ON_SimpleArray< ON_2dPoint > &	points,
		double	tol,
		bool	Periodic
	)

Description: Fit a sequence of 3d points on a surface to make a curve on the surface. Parameters: srf - [in] Surface on which to construct curve. points - [in] Parameter space coordinates of the points to interpolate. If srf is closed the points can be in the domain covering space of srf (See ON_PeriodicDomain). tol - [in] Curve should be within tolerance of surface and points. (srf.Evaluate(points[i]) Periodic - [in] When true make a periodic curve. Returns: A curve interpolating the points.

◆ RhinoFitSphereToPoints() [1/2]

RHINO_SDK_FUNCTION bool RhinoFitSphereToPoints	(	const ON_SimpleArray< ON_3dPoint > &	point_array,
		ON_Sphere &	sphere
	)

Description: Fits a sphere through an array of points. Parameters: points [in] - The points through which to fit. sphere [out] - The resulting sphere. Returns: true if successful, false otherwise. Remarks: Finds a best-fit sphere through the points.

◆ RhinoFitSphereToPoints() [2/2]

RHINO_SDK_FUNCTION bool RhinoFitSphereToPoints	(	int	point_count,
		const ON_3dPoint *	points,
		ON_Sphere &	sphere
	)

◆ RhinoFitSurface()

RHINO_SDK_FUNCTION ON_Surface* RhinoFitSurface	(	const ON_Surface &	surface_in,
		int	udegree = `3`,
		int	vdegree = `3`,
		double	dFitTol = `ON_UNSET_VALUE`,
		double *	pAchievedTol = `nullptr`
	)

Description: Fits a new surface through an existing surface. Parameters: surface_in - [in] the surface to fit. udegree - [in] the output surface U degree. Must be bigger than 1. vdegree - [in] the output surface V degree. Must be bigger than 1. dFitTol - [in] the fitting tolerance. If dFitTol is ON_UNSET_VALUE or <=0.0, the document absolute tolerance is used. pAchievedTol - [out] if not NULL this will be used for the achieved tolerance. pAchievedTol is always <= dFitTol. Returns: pointer to surface if success. NULL if unsuccessful. Notes:

◆ RhinoFitTrimSurface()

RHINO_SDK_FUNCTION int RhinoFitTrimSurface	(	const ON_BrepFace *	face,
		const ON_BrepEdge *	edge,
		ON_SimpleArray< double > &	knots,
		double	tolerance,
		bool	bSections,
		ON_SimpleArray< ON_NurbsSurface * > &	FitSurfaces,
		double *	FitMeasurement
	)

◆ RhinoFitTrimSurface2()

RHINO_SDK_FUNCTION int RhinoFitTrimSurface2	(	const ON_BrepFace *	face,
		const ON_BrepEdge *	edge,
		ON_SimpleArray< double > &	knots,
		double	tolerance,
		bool	bSections,
		ON_SimpleArray< ON_NurbsSurface * > &	FitSurfaces,
		ON_SimpleArray< ON_NurbsCurve * > &	EdgeCurves,
		double *	FitMeasurement,
		ON_Curve **	trimCurveOnSurface,
		ON_Curve **	splitCurve
	)

◆ RhinoFormatColor() [1/2]

RHINO_SDK_FUNCTION void RhinoFormatColor	(	ON_Color	color,
		ON_wString &	string
	)

Description: Format a color for printing. Parameters: color - [in] string - [in/out] string representation of color is appended to this string See Also: RhinoFormatNumber RhinoParseNumber RhinoParsePoint

◆ RhinoFormatColor() [2/2]

RHINO_SDK_FUNCTION void RhinoFormatColor	(	ON_Color	color,
		ON_wString &	string,
		bool	bUseAlpha
	)

Description: Format a color for printing. Parameters: color - [in] string - [in/out] string representation of color is appended to this string bUseAlpha - [in] set to true to set alpha value See Also: RhinoFormatNumber RhinoParseNumber RhinoParsePoint

◆ RhinoFormatDegreesInDMS()

RHINO_SDK_FUNCTION double RhinoFormatDegreesInDMS	(	double	angle_decimal_degrees,
		ON_wString &	str,
		bool	bWithSpaces = `false`
	)

Description: Parse a string to see if it is an angle. Parameters: angle_decimal_degrees - [in] angle in degrees str - [out] angle in deg min sec format. When needed, the seconds have up to 4 decimal points. This provides a linear precision of better than 1 cm on the surface of the earth. bWithSpaces - [in] If true, there will be a space between the degrees, minutes, and seconds. If false, there will not be a space. Returns: Fractional seconds. If this number is not zero, then the number of fractional seconds in the decimal angle. This value can be used to make UI decisions about what format to use.

◆ RhinoFormatDegreesLatitude()

RHINO_SDK_FUNCTION double RhinoFormatDegreesLatitude	(	double	latitude_decimal_degrees,
		ON_wString &	str,
		int	format = `0`
	)

Description: Convert a double to a latitude string. Parameters: latitude_decimal_degrees - [in] latitude in degrees str - [out] latitude in deg min secN/S format If the decimal latitude is not exactly dms, then the decimal format is appended. format - [in] 0 = degrees minutes seconds 1 = decimal degrees Returns: Fractional seconds. If this number is not zero, then the number of fractional seconds in the decimal angle. This value can be used to make UI decisions about what format to use.

◆ RhinoFormatDegreesLongitude()

RHINO_SDK_FUNCTION double RhinoFormatDegreesLongitude	(	double	longitude_decimal_degrees,
		ON_wString &	str,
		int	format = `0`
	)

Description: Convert a double to a longitude string. Parameters: longitude_decimal_degrees - [in] longitude in degrees str - [out] Longitude in deg min secE/W format If the decimal latitude is not exactly dms, then the decimal format is appended. format - [in] 0 = degrees minutes seconds 1 = decimal degrees 2 = degrees minutes seconds (decimal degrees) Returns: Fractional seconds. If this number is not zero, then the number of fractional seconds in the decimal angle. This value can be used to make UI decisions about what format to use.

◆ RhinoFormatNumber() [1/3]

RHINO_SDK_FUNCTION void RhinoFormatNumber	(	double	x,
		const ON_3dmUnitsAndTolerances &	input_units,
		const ON_3dmUnitsAndTolerances &	output_units,
		ON_wString &	string,
		bool	bAppendUnitSystemName = `false`
	)

◆ RhinoFormatNumber() [2/3]

RHINO_SDK_FUNCTION void RhinoFormatNumber	(	double	x,
		const ON_3dmUnitsAndTolerances &	units,
		ON_wString &	string,
		bool	bAppendUnitSystemName = `false`
	)

◆ RhinoFormatNumber() [3/3]

RHINO_SDK_FUNCTION void RhinoFormatNumber	(	double	x,
		ON_wString &	string
	)

Description: Format a number for printing. Parameters: x - [in] string - [in/out] string representation of x is appended to this string number_format - [in] (default=NULL) if not NULL, this string overrides the automatic format used by Rhino. unit_system - [in] If unit_system != ON::LengthUnitSystem::None, then the name of the units is append to string. units - [in] x is assumed to be in units.m_unit_system. The settings on units are used to control the display format and decimal precision. input_units - [in] output_units - [in] If output_units.m_unit_system != input_units.m_unit_system, then x is scaled. If output_units.m_display_mode is decimal or fractional and output_units.m_unit_system is not ON::LengthUnitSystem::None, then a localized unit system name is appended to string. bAppendUnitsName - [in] Example:

/ plain old number double x = ...; ON_wString s1 = L"x = "; RhinoFormatNumber( x, s1 );

/ length in current unit system double length = ...; ON_wString s2 = L"length = "; CRhinoDoc* doc = CRhinoDoc::FromRuntimeSerialNumber(...); if ( doc ) { RhinoFormatNumber( length, doc->UnitSystem(), s2, true ); } else { RhinoFormatNumber( length, s2 ); }

See Also: RhinoFormatPoint RhinoParseNumber RhinoParsePoint

◆ RhinoFormatPoint()

RHINO_SDK_FUNCTION void RhinoFormatPoint	(	ON_3dPoint	point,
		ON_wString &	string,
		const wchar_t *	number_format = `nullptr`
	)

Description: Format a point for printing. Parameters: point - [in] string - [in/out] string representation of point is appended to this string number_format - [in] (default=NULL) if not NULL, this string overrides the automatic format used by Rhino. Example:

  ON_3dPoint point(1,2,3);
  ON_wString s = L"The point is (";
  RhinoFormatPoint( point, s, L"%0.2f" );
  s += ')';

/ The string "The point is (1.00,2.00,3.00)"

See Also: RhinoFormatNumber RhinoParseNumber RhinoParsePoint

◆ RhinoGet1RailFrames()

RHINO_SDK_FUNCTION bool RhinoGet1RailFrames	(	const ON_Curve &	curve,
		int	count,
		const double *	t,
		ON_SimpleArray< ON_Plane > &	frames,
		ON_3dVector	starting_x0
	)

Description: Get relatively parallel frames at selected points along a curve. Parameters: curve - [in] the input curve count - [in] number of values in t[] array t - [in] increasing array of curve parameters frames - [out] frames are appended to this array. The plane's origin is on the curve and the z-axis is the curve's tangent. starting_x0 - [in] optional vector that specifies the x direction to use for the plane at t[0]. If starting_x0 is ON_unset_point, then the curve's curvature vector at t[0] is used.

◆ RhinoGetAnalysisMeshes() [1/2]

RHINO_SDK_FUNCTION int RhinoGetAnalysisMeshes	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_ClassArray< CRhinoObjRef > &	analysis_meshes,
		bool	bOkToCreate,
		bool	bReturnAllObjects,
		bool	bSkipHiddenObjects
	)

Description: Mesh Rhino objects. Parameters: objects - [in] objects to get analysis meshes for. analysis_meshes - [out] analysis_meshes[i].Object() = input object analysis_meshes[i].Mesh() = analysis mesh bOkToCreate - [in] if true and the analysis meshes do not exist, then they will be created. bReturnAllObjects - [in] curves, points, etc., do not have analysis meshes. If you want these objects to appear in the output list with a NULL mesh, then set this flag to true. bSkipHiddenObjects - [in] will not create analysis meshes for hidden objects if set to true. Returns: Number of meshes appended to analysis_meshes[]. Remarks: References to instance definitions that contain multiple objects will appear multiple times in the output list.

When the input object is a CRhinoInstanceObject, one or more CRhinoObjRefs may be returned in the render_meshes[] array. Each atomic object the instance reference ultimately refers to gets a CRhinoObjRef. The Object() returned by the CRhinoObjRef points to a the atomic object in the instance definition table. The Geometry() returned by the CRhinoObjRef is a transformed copy of the mesh. The mesh is correctly located and does not require further transformations. In this case, CRhinoObjRef::GetInstanceTransformation() will return a pointer to the top level instance reference (the input CRhinoInstanceObject) and report the total transformation that was applied to the mesh.
In the case of nested instance references, this transformation may be different from the transformation associated with the input CRhinoInstanceObject.

◆ RhinoGetAnalysisMeshes() [2/2]

RHINO_SDK_FUNCTION int RhinoGetAnalysisMeshes	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_ClassArray< CRhinoObjRef > &	analysis_meshes,
		bool	bOkToCreate = `true`,
		bool	bReturnAllObjects = `false`
	)

◆ RhinoGetBrepFaceIsoCurves()

RHINO_SDK_FUNCTION int RhinoGetBrepFaceIsoCurves	(	const ON_BrepFace &	face,
		int	iso_dir,
		double	iso_constant,
		ON_SimpleArray< ON_Curve * > &	iso_curves
	)

Description: Get isocurves on an ON_BrepFace (trimmed surface) Parameters: face - [in] Brep face iso_dir - [in] 0: intervals are "u" intervals at constant "v" values 1: intervals are "v" intervals at constant "u" values iso_constanct - [in] If iso_dir is 0, then iso_constant is a constant "v" parameter. If iso_dir is 1, then iso_constant is a constant "u" parameter. iso_curves - [out] 3d isocurves are appended to this list Returns: number of curves appended to the iso_curves[] array. See Also: RhinoGetIsoIntervals

◆ RhinoGetBrepFaceIsoIntervals()

RHINO_SDK_FUNCTION int RhinoGetBrepFaceIsoIntervals	(	const ON_BrepFace &	face,
		int	iso_dir,
		double	iso_constant,
		ON_SimpleArray< ON_Interval > &	intervals
	)

Description: Get intervals where the isocurve exists on an ON_BrepFace (trimmed surface) Parameters: face - [in] (trim curves will be promoted to TL_NurbsCurves) iso_dir - [in] 0 intervals are "u" intervals, c = constant "v" value 1 intervals are "v" intervals, c = constant "u" value iso_constant - [in] If iso_dir is 0, then iso_constant is the constant "v" parameter. If iso_dir is 1, then iso_constant is the constant "u" parameter. intervals - [out] intervals are append to this list The isocurve(s) exist on the domain of the intervals. Returns: number of intervals appended to the intervals[] array. Remarks: If iso_dir = 0, the parameter space iso interval connects the 2d points

(intervals[i][0],iso_constant) and (intervals[i][1],iso_constant).

If iso_dir = 0, the parameter space iso interval connects the 2d points

(iso_constant,intervals[i][0]) and (iso_constant,intervals[i][1]). See Also: RhinoGetIsoCurves

◆ RhinoGetCachedTexture()

RHINO_SDK_FUNCTION unsigned int RhinoGetCachedTexture ( const ON_wString & Name )

Texture caching and updating...

Note: The use of these functions must be within the scope of a frame buffer update. For example: Inside any of the pipeline draw channels. Using them outside of this scope can/will have unpredictable results and behavior. Description: Returns the handle to a cached texture the engine will use for the given name.

Parameters: Name - [in] The name of the cached texture. This can be a name in any format, consisting of any alphanumeric characters. The idea is that you choose names that can easily be used for unique identification.

Note: Do not use file names as your cached texture names, otherwise you risk the chance of colliding with textures that have already been or may be loaded by other materials used in the scene. There are other factors used by Rhino when caching textures, so the chances are low for collisions...but there still exists a possibility that textures cached by the use of this method can collide with textures cached by Rhino's material management that contain the same file name(s)...so it's probably best to avoid it by not using file names as your caching name.

Note2: Holding onto the cached value is not recommended since Rhino can decide to free up any OpenGL resources it needs to for any reason at any time. For example: Loading a new file will cause Rhino to destroy all cached OpenGL resources, including all of your cached textures. Which means any handles previously returned by this method will no longer work, or may collide with handles created during the loading of the new file. Therefore it is best to just always call RhinoGetCachedTexture() before using any of the other texture caching methods.

Returns: 0 - if the engine was unable to locate or create a texture with the given name.

0 - Value of cached texture image. Note: The only thing you can do with this value

is use it as a parameter to the other texture caching methods. Do not assume it can be used for anything else.

◆ RhinoGetCaptiveObjects()

RHINO_SDK_FUNCTION int RhinoGetCaptiveObjects	(	const CRhinoMorphControl *	control_object,
		ON_SimpleArray< const CRhinoObject * > &	captives
	)

Description: Get a list of captive objects. Parameters: control_object - [in] captives - [out] Returns: Number of objects appended to captives.

◆ RhinoGetClosestPoint()

RHINO_SDK_FUNCTION bool RhinoGetClosestPoint	(	const ON_NurbsCurve &	crv,
		double &	t_param,
		const ON_SimpleArray< const ON_Geometry * > &	geom,
		int &	obj_index,
		ON_COMPONENT_INDEX &	comp_index,
		double &	u_param,
		double &	v_param,
		double	MaxDist = `0.0`
	)

Description: Finds the object, and the closest point in that object, that is closest to a given test curve. Allowable objects to test the curve against include ON_Brep, ON_Surface, ON_Curve, and ON_PointCloud objects. Parameters: crv - [in] The curve to test. t_param - [out] The parameter of closest point on curve. geom - [in] The geometry to test the curve against. obj_index - [out] index of the geometry object containing the closest point. comp_index - [out] The component_index (see remarks below). u_param - [out] The u parameter of local closest point (see remarks below). v_param - [out] The v parameter of local closest point (see remarks below). MaxDist - [in] The maximum allowable distance. Returns: true if successful, false otherwise. Remarks: The geom array can only contain ON_Brep, ON_Surface, ON_Curve, and ON_PointCloud pointers. If geom[obj_index] is a Brep or face, comp_index is valid. Otherwise it is undefined. If geom[obj_index] is a curve, u_param is the curve parameter, and v_param is undefined.

◆ RhinoGetDibAsTextureFileReference()

RHINO_SDK_FUNCTION ON_FileReference RhinoGetDibAsTextureFileReference	(	const CRhinoDib &	dib,
		ON__UINT32	crc
	)

Description: Inserts dib into Rhino's texture manager and returns an ON_FileReference for use in e.g. ON_Texture::m_image_file_reference. This way it's possible to use a dib with an ON_Texture without having to read the dib from file. Parameters: dib - [in] The dib which will be referenced by the ON_FileReference. crc - [in] The crc of the dib. This should be a unique number which changes if the contents of the dib changes. NOTE: if a different dib is provided using the same crc as a previous dib, then the previous dib will be overwritten in the texture manager and both previously returned ON_FileReferences will reference the newly provided dib. Returns: Returns an ON_FileReference which, when used together with e.g. ON_Texture::m_image_file_reference, is used by Rhino's display to find the texture from the texture manager.

◆ RhinoGetDigitizerInfo()

RHINO_SDK_FUNCTION CRhinoDigitizerInfo RhinoGetDigitizerInfo ( )

Description: Returns the current state of the active 3D digitizing device. Parameters: none. Returns: CRhinoDigitizerInfo - the current state of the active 3D digitizing device. Also See: CRhinoDigitizerInfo

◆ RhinoGetDuplicateMeshFaces() [1/2]

RHINO_SDK_FUNCTION int RhinoGetDuplicateMeshFaces	(	ON_SimpleArray< int > &	FaceIDXArray,
		const ON_Mesh *	pMesh
	)

Description: RhinoGetDuplicateMeshFaces creates a list of duplicate faces in a mesh. Parameters: FaceIDXArray - [Out] List of indexes that are duplicates of other indexes (does not contain pairs) pMesh - [In] Mesh to examine Returns: Count of duplicate faces in mesh.

◆ RhinoGetDuplicateMeshFaces() [2/2]

RHINO_SDK_FUNCTION int RhinoGetDuplicateMeshFaces	(	ON_SimpleArray< int > &	FaceIDXArray,
		const ON_Mesh *	pMesh,
		bool	bGetAll
	)

Description: RhinoGetDuplicateMeshFaces creates a list of duplicate faces in a mesh. Parameters: FaceIDXArray - [Out] List of indexes that are duplicates of other indexes (does not contain pairs) pMesh - [In] Mesh to examine bGetAll - [In] If true, all duplicates will be added, false only one. Returns: Count of duplicate faces in mesh.

◆ RhinoGetFilletPoints()

RHINO_SDK_FUNCTION BOOL32 RhinoGetFilletPoints	(	const ON_Curve &	c0,
		const ON_Curve &	c1,
		double	radius,
		double	t0_base,
		double	t1_base,
		double &	t0,
		double &	t1,
		ON_Plane &	FilletPlane
	)

Description: find points at which to cut a pair of curves so that a fillet of radius r fits. Parameters: c0,c1 - [in] curves radius - [in] fillet radius t0_base -[in] parameter value for base point on curve 0 t1_base -[in] parameter value for base point on curve 1 t0 - [out] parameter value of fillet point on curve 0 t1 - [out] parameter value of fillet point on curve 1 FilletPlane -[out] The fillet is contained in this plane with center at the plane origin. Returns: true - solution found false - no solution found Remarks: A fillet point is a pair of curve parameters (t0,t1) such that there is a circle of radius r tangent to curve c0 at t0 and tangent to curve c1 at t1. Of all possible fillet points this function returns the one which is the closest to the base point t0_base, t1_base. Distance from the base point is measured by the sum of arc lengths along the two curves.

◆ RhinoGetGrevillePoints()

RHINO_SDK_FUNCTION int RhinoGetGrevillePoints	(	const ON_NurbsCurve &	in_curve,
		ON_SimpleArray< ON_3dPoint > &	out_points
	)

Description: Returns a NURBS curve's edit, or Greville, points. Parameters: in_curve - [in] The input NURBS curve. out_points - [out] The edit points. Returns: The number of points added to out_points.

◆ RhinoGetIsoCurves()

RHINO_SDK_FUNCTION int RhinoGetIsoCurves	(	const ON_BrepFace &	face,
		int	iso_dir,
		double	iso_constant,
		ON_SimpleArray< ON_Curve * > &	curves
	)

Description: Gets isoparametric curve(s) from a Brep face. Parameters: face - [in] the Brep face to evaluate. iso_dir - [in] 0 = intervals are "u" intervals, c = constant "v" value 1 = intervals are "v" intervals, c = constant "u" value iso_constant - [in] constant "c" above curves - [out] curves are appended to this array. Returns: Returns number of curves that are appended to array. See Also: RhinoGetIsoIntervals Remarks: The caller is responsible for deleting these curves when finished.

◆ RhinoGetIsoIntervals()

RHINO_SDK_FUNCTION int RhinoGetIsoIntervals	(	const ON_BrepFace &	face,
		int	iso_dir,
		double	iso_constant,
		ON_SimpleArray< ON_Interval > &	intervals
	)

Description: Gets parameter intervals for the active part of Brep face. Parameters: face - [in] the Brep face to evaluate. iso_dir - [in] 0 = intervals are "u" intervals, c = constant "v" value 1 = intervals are "v" intervals, c = constant "u" value iso_constant - [in] constant "c" above intervals - [out] intervals are appended to this array. Returns: Returns number of intervals that are appended to array. See Also: RhinoGetIsoCurves Remarks: The isoparametric curve(s) exist on the domain of the intervals.

◆ RhinoGetLastWindowsError()

RHINO_SDK_FUNCTION DWORD RhinoGetLastWindowsError ( )

Description: Calls Win32 ::GetLastError() to see if a Windows error has occurred. If so, it invokes Rhino's standard error reporting code that is useful for debugging and then calls ::SetLastError(0) so the error is not reported multiple times. Many Windows system calls unconditionally call ::SetLastError(0), so you need to call RhinoGetLastWindowsError() liberally if you want to catch Windows errors. Returns: Value reported by the call to ::GetLastError().

◆ RhinoGetLineExtremes()

RHINO_SDK_FUNCTION BOOL32 RhinoGetLineExtremes	(	const ON_Curve &	curve,
		ON_Line &	line
	)

Description: Find the extreme geometric end points of a curve that may be doubled back on itself as when a circle is collapsed edge-wise Such a curve may have endpoints on the interior of the geometric line Parameters: [in] curve - the curve to examine [out] line - the geometric line representing the curve [in] - optional tolerance for testing if the curve is a line Returns: @untitled table TRUE Success FALSE Failure Remarks - Does not check if the curve is linear or not - just returns the max distance between kinks

◆ RhinoGetMeshOutline() [1/2]

RHINO_SDK_FUNCTION bool RhinoGetMeshOutline	(	const ON_SimpleArray< const ON_Mesh * > &	InMeshes,
		const CRhinoView *	view,
		double	tolerance,
		ON_ClassArray< ON_SimpleArray< ON_PolylineCurve * > > &	OutRegions
	)

Description: Creates polyline curve outlines from meshes. Parameters: InMeshes [in] - The meshes to outline. view [in] - The view that provides the outline direction. tolerance [in] - The tolerance used in the calculation (can be tiny). OutRegions [out] - The output curves Return: True if successful, false otherwise. Remarks: THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CURVE.

◆ RhinoGetMeshOutline() [2/2]

RHINO_SDK_FUNCTION bool RhinoGetMeshOutline	(	const ON_SimpleArray< const ON_Mesh * > &	InMeshes,
		const ON_Viewport &	view,
		const ON_Plane &	plane,
		double	tolerance,
		ON_ClassArray< ON_SimpleArray< ON_PolylineCurve * >> &	OutRegions
	)

Description: Creates polyline curve outlines from meshes. Parameters: InMeshes [in] - The meshes to outline. view [in] - The view that provides the outline direction. plane [in] - Usually the view's construction plane. If parallel projection and view plane is parallel to this one, project results to plane. tolerance [in] - The tolerance used in the calculation (can be tiny). OutRegions [out] - The output curves Return: True if successful, false otherwise. Remarks: THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CURVE.

◆ RhinoGetMeshParameters()

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoGetMeshParameters	(	CRhinoDoc &	doc,
		ON_MeshParameters &	mp,
		int &	ui_style
	)

Description: Displays Rhino mesh object user interface. Parameters: mp - [in/out] meshing parameters. The meshing parameters may change. ui_style - [in/out] 0 = simple dialog 1 = details dialog 2 = script or batch mode If the input value is 0 or 1, the user can switch to the other dialog and the style of dialog that was used is returned. Returns: CRhinoCommand::success - user finished input CRhinoCommand::cancel - user canceled input

◆ RhinoGetOverlapDistance()

RHINO_SDK_FUNCTION bool RhinoGetOverlapDistance	(	const ON_Curve *	crv_a,
		const ON_Interval *	dom_a,
		const ON_Curve *	crv_b,
		const ON_Interval *	dom_b,
		double	tol,
		double	lim,
		int *	cnt,
		double	int_a[3][2],
		double	int_b[3][2],
		double *	max_a,
		double *	max_b,
		double *	max_d,
		double *	min_a,
		double *	min_b,
		double *	min_d
	)

Description: Calculates the minimum and maximum distances between two curves. Parameters: crv_a [in] - curve A dom_a [in] - optional domain for curve A crv_b [in] - curve B dom_b [in] - optional domain for curve B tol [in] - tolerance for common normal detection lim [in] - limits acceptable overlap distance cnt [out] - overlap interval count (0 to 3) int_a [out] - curve A interval(s) int_b [out] - curve B interval(s) max_a [out] - curve A parameter at maximum overlap distance point max_b [out] - curve B parameter at maximum overlap distance point max_d [out] - maximum overlap distance min_a [out] - curve A parameter at minimum distance point min_b [out] - curve B parameter at minimum distance point min_d [out] - minimum distance between curves Returns: true if successful, false on failure or if no no overlap found

◆ RhinoGetPerpendicularCurvePlane()

RHINO_SDK_FUNCTION bool RhinoGetPerpendicularCurvePlane	(	const ON_Curve *	crv,
		double	crv_t,
		ON_Plane &	plane
	)

Description: Finds a "zero-twisting" plane that is perpendicular to a curve at a curve parameter. The result plane is "zero-twisting" in that it does not flip based on the curvature of the curve at the parameter. Parameters: crv [in] - The curve to evaluate. crv_t [in] - The evaluation parameter. plane [out] - A perpendicular plane. Return: True or false indicating success or failure.

◆ RhinoGetPlugInCommandList()

RHINO_SDK_FUNCTION void RhinoGetPlugInCommandList	(	const class CRhinoPlugIn *	plug_in,
		ON_SimpleArray< const class CRhinoCommand * > &	cmd_list
	)

Description: Gets a list of commands associated with a specific plug-in Parameters: plug_in - [in] Plug-in to get command list for cmd_list - [out] Array to add command list to

◆ RhinoGetPointInSolidBrep()

RHINO_SDK_FUNCTION bool RhinoGetPointInSolidBrep	(	const ON_Brep &	brep,
		double	tolerance,
		ON_3dPoint &	point
	)

Description: Finds a point inside of a solid Brep. Parameters: brep - [in] The Brep to search. tolerance - [in] Used for intersecting rays and is not necessarily related to the distance from the Brep to the found point. When in doubt, use the document's model absolute tolerance. point - [out] A point inside of the solid Brep. Returns: Returns false if the input is not solid and manifold, if the Brep's bounding box is less than 2.0 * tolerance wide, or if no point could be found due to ray shooting or other errors. See Also: RhinoIsPointInBrep

◆ RhinoGetPointOnMesh()

RHINO_SDK_FUNCTION int RhinoGetPointOnMesh	(	const CRhinoMeshObject *	mesh_object,
		const wchar_t *	sPrompt,
		BOOL32	bAcceptNothing,
		ON_MESH_POINT &	output_point,
		CRhinoHistory *	history = `NULL`
	)

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. Description: Interactively picks a point on a mesh object Parameters: mesh_object - [in] mesh object sPrompt - [in] command line prompt bAcceptNothing - [in] allows the user to be able to press enter in order to skip selecting the point. output_point - [out] the selected ON_MESH_POINT see opennuurbs_meshtree.h for details on ON_MESH_POINT

Returns: 0 - success 1 - nothing 2 - cancel 3 - failure

◆ RhinoGetRenderMeshes() [1/3]

RHINO_SDK_FUNCTION int RhinoGetRenderMeshes	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_ClassArray< CRhinoObjRef > &	render_meshes,
		bool	bOkToCreate,
		bool	bReturnAllObjects,
		bool	bSkipHiddenObjects
	)

Description: Mesh Rhino objects. Parameters: objects - [in] objects to get render meshes for. render_meshes - [out] render_meshes[i].Object() = input object render_meshes[i].Mesh() = render mesh bOkToCreate - [in] if true and the render meshes do not exist, then they will be created. bReturnAllObjects - [in] curves, points, etc., do not have render meshes. If you want these objects to appear in the output list with a NULL mesh, then set this flag to true. bSkipHiddenObjects - [in] will not create render meshes for hidden objects if set to true. Returns: Number of meshes appended to render_meshes[]. Remarks: References to instance definitions that contain multiple objects will appear multiple times in the output list.

When the input object is a CRhinoInstanceObject, one or more CRhinoObjRefs may be returned in the render_meshes[] array. Each atomic object the instance reference ultimately refers to gets a CRhinoObjRef. The Object() returned by the CRhinoObjRef points to the atomic object in the instance definition table. The Geometry() returned by the CRhinoObjRef is a transformed copy of the mesh. The mesh is correctly located and does not require further transformations. In this case, CRhinoObjRef::GetInstanceTransformation() will return a pointer to the top level instance reference (the input CRhinoInstanceObject) and report the total transformation that was applied to the mesh.
In the case of nested instance references, this transformation may be different from the transformation associated with the input CRhinoInstanceObject.

Deprecated:: Does not support custom render meshes, per-face materials or delivery of the shared pointer meshes. Prefer IRhRdkSdkRenderMeshIterator / CRhRdkSdkRender::NewRenderMeshIterator

◆ RhinoGetRenderMeshes() [2/3]

RHINO_SDK_FUNCTION int RhinoGetRenderMeshes	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_ClassArray< CRhinoObjRef > &	render_meshes,
		bool	bOkToCreate,
		bool	bReturnAllObjects,
		bool	bSkipHiddenObjects,
		bool	bUpdateMeshTCs
	)

Description: Mesh Rhino objects. Parameters: objects - [in] objects to get render meshes for. render_meshes - [out] render_meshes[i].Object() = input object render_meshes[i].Mesh() = render mesh bOkToCreate - [in] if true and the render meshes do not exist, then they will be created. bReturnAllObjects - [in] curves, points, etc., do not have render meshes. If you want these objects to appear in the output list with a NULL mesh, then set this flag to true. bSkipHiddenObjects - [in] will not create render meshes for hidden objects if set to true. bUpdateMeshTCs - [in] updates texture coordinates on the output mesh using the texture mapping if set to true. Returns: Number of meshes appended to render_meshes[]. Remarks: References to instance definitions that contain multiple objects will appear multiple times in the output list.

When the input object is a CRhinoInstanceObject, one or more CRhinoObjRefs may be returned in the render_meshes[] array. Each atomic object the instance reference ultimately refers to gets a CRhinoObjRef. The Object() returned by the CRhinoObjRef points to the atomic object in the instance definition table. The Geometry() returned by the CRhinoObjRef is a transformed copy of the mesh. The mesh is correctly located and does not require further transformations. In this case, CRhinoObjRef::GetInstanceTransformation() will return a pointer to the top level instance reference (the input CRhinoInstanceObject) and report the total transformation that was applied to the mesh. In the case of nested instance references, this transformation may be different from the transformation associated with the input CRhinoInstanceObject.

Deprecated:: Does not support custom render meshes, per-face materials or delivery of the shared pointer meshes. Prefer IRhRdkSdkRenderMeshIterator / CRhRdkSdkRender::NewRenderMeshIterator

◆ RhinoGetRenderMeshes() [3/3]

RHINO_SDK_FUNCTION int RhinoGetRenderMeshes	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_ClassArray< CRhinoObjRef > &	render_meshes,
		bool	bOkToCreate = `true`,
		bool	bReturnAllObjects = `false`
	)

Deprecated:: Does not support custom render meshes, per-face materials or delivery of the shared pointer meshes. Prefer IRhRdkSdkRenderMeshIterator / CRhRdkSdkRender::NewRenderMeshIterator

◆ RhinoGetSplitPoints()

RHINO_SDK_FUNCTION bool RhinoGetSplitPoints	(	const ON_Curve &	curve,
		const ON_Brep &	cutter,
		double	tolerance,
		double	angtolrads,
		ON_SimpleArray< double > &	tsplit
	)

Description: Finds split points on a curve using a cutter Brep Parameters: curve - [in] curve to find the split points on. cutter - [in] Brep to split curve with. tolerance - [in] intersection tolerance angtolrads - [in] angle tolerance in radians tsplit - [out] array of split parameters on curve Returns: True if successful Notes:

◆ RhinoGetSubCurves()

RHINO_SDK_FUNCTION bool RhinoGetSubCurves	(	const ON_Curve *	pCurve,
		const ON_Interval *	pDomain,
		bool	bSkipSingleSegments,
		ON_SimpleArray< ON_Curve * > &	curve_segments
	)

Description: Get sub-curves from a curve. Parameters: curve - [in] bSkipSingleSegmentCurves - [in] This parameter controls what happens with curve does not "explode" into two or more segments. true = append a duplicate to the curve_segments[] array. false = do nothing. curve_segments - [out] segments of curve are appended to this array. Returns: true: The input curve made sense and the function worked as expected. false: Some portion of the input curve was invalid and the function did the best it could. Comment: This function is here because at least for the time being, it matches the way Explode makes sub-curve segments.

◆ RhinoGetTanPerpPoint()

RHINO_SDK_FUNCTION bool RhinoGetTanPerpPoint	(	const ON_Curve &	curve0,
		const ON_Curve &	curve1,
		bool	bPerp0,
		bool	bPerp1,
		double	abs_tol,
		double &	t0,
		double &	t1
	)

Description: Finds a line segment between a pair of curves such that the line segment is either tangent or perpendicular to each of the curves. Parameters: curve0 [in] - The first curve. curve1 [in] - The second curve. bPerp0 [in] - Find line perpendicular to (true) or tangent to (false) curve0. bPerp1 [in] - Find line Perpendicular to (true) or tangent to (false) curve1. abs_tol [in] - The active document's model absolute tolerance. t0 [in/out] - Parameter value of point on curve0. Seed value at input and solution at output. t1 [in/out] - Parameter value of point on curve1. Seed value at input and solution at output. Returns: true on success, false on failure.

◆ RhinoGetTextOutlines() [1/2]

RHINO_SDK_FUNCTION bool RhinoGetTextOutlines	(	const ON_Text *	textobj,
		const ON_DimStyle *	dimstyle,
		bool	close_contours,
		double	join_tol,
		ON_SimpleArray< ON_Curve * > &	out_curves
	)

Description: Creates curve outlines from the specified ON_Text object. Parameters: textobj [in] - The text object to create outlines from. dimstyle [in] - The text object's dimensions style. If nullptr, then ON_DimStyle::Default is used. close_contours [in] - Set this value to true when dealing with normal fonts and when you expect closed loops. You may want to set this to false when specifying a single-stroke font where you don't want closed loops. join_tolerance [in] - The tolerance used to join contours. out_curves [out] - An array of output curves. Return: true or false indicating success or failure. NOTE, memory for the output is allocated and becomes the responsibility of the caller.

◆ RhinoGetTextOutlines() [2/2]

RHINO_SDK_FUNCTION bool RhinoGetTextOutlines	(	const wchar_t *	str,
		const ON_Font *	font,
		double	text_height,
		bool	close_contours,
		double	join_tolerance,
		ON_ClassArray< ON_ClassArray< ON_SimpleArray< ON_Curve * >>> &	out_glyphs
	)

Description: Creates curve outlines from the specified text string using the glyphs from the specified font. Output curves will lie on in World X-Y plane with the lower-left corner of output curves bounding box at (0,0,0). Parameters: str [in] - The text string to create outlines from. font [in] - The font that provides the glyphs. text_height [in] - The height of the outlines. close_contours [in] - Set this value to true when dealing with normal fonts and when you expect closed loops. You may want to set this to false when specifying a single-stroke font where you don't want closed loops. join_tolerance [in] - The tolerance used to join contours out_glyphs [out] - A nested array of output curves that are organized in the following manner: glyphs contours curves ON_ClassArray< ON_ClassArray < ON_SimpleArray< ON_Curve* > > > Return: true or false indicating success or failure. NOTE, memory for the output is allocated and becomes the responsibility of the caller.

◆ RhinoGetTextOutlinesWithSmallCaps() [1/2]

RHINO_SDK_FUNCTION bool RhinoGetTextOutlinesWithSmallCaps	(	const ON_Text *	pText,
		const ON_Viewport *	viewport,
		const ON_DimStyle *	dimstyle,
		double	text_scale,
		bool	close_contours,
		double	join_tol,
		double	small_caps_scale,
		ON_ClassArray< ON_ClassArray< ON_SimpleArray< ON_Curve * >>> &	out_glyphs
	)

Description: Creates curve outlines for all of the runs in the ON_Text object. Output is ordered by glyphs, then contours, then curves making up each contour. There is nothing in place to distinguish glyphs from any particular run but they will be in the same order as they are in ON_Text and transformed to the proper run offset. Parameters: textobj [in] - The text object to create outlines from. viewport [in] - The viewport from which the object was selected. Can be null. dimstyle [in] - The text object's dimension style. Can be null. If null, then ON_DimStyle::Default is used. text_scale [in] - Additional scaling factor. Use 1.0, for no scaling. close_contours [in] - Set this value to true when dealing with normal fonts and when you expect closed loops. You may want to set this to false when specifying a single-stroke font where you don't want closed loops. join_tolerance [in] - The tolerance used to join contours small_caps_scale [in] - Scale for small caps, set to 1.0 for no small caps out_glyphs [out] - A nested array of output curves that are organized in the following manner: glyphs contours curves ON_ClassArray< ON_ClassArray < ON_SimpleArray< ON_Curve* > > > Return: true or false indicating success or failure. NOTE, memory for the output is allocated and becomes the responsibility of the caller. Remarks: A transformation is calculated from the viewport, dimstyle and text_scale arguments for proper placement of the output. See ON_Annotation::GetTextXform().

◆ RhinoGetTextOutlinesWithSmallCaps() [2/2]

RHINO_SDK_FUNCTION bool RhinoGetTextOutlinesWithSmallCaps	(	const wchar_t *	str,
		const ON_Font *	font,
		double	text_height,
		bool	close_contours,
		double	join_tolerance,
		double	small_caps_scale,
		ON_ClassArray< ON_ClassArray< ON_SimpleArray< ON_Curve * >>> &	out_glyphs
	)

Description: Creates curve outlines from the specified text string using the glyphs from the specified font. Output curves will lie on in World X-Y plane with the lower-left corner of output curves bounding box at (0,0,0). Parameters: str [in] - The text string to create outlines from. font [in] - The font that provides the glyphs. text_height [in] - The height of the outlines. close_contours [in] - Set this value to true when dealing with normal fonts and when you expect closed loops. You may want to set this to false when specifying a single-stroke font where you don't want closed loops. join_tolerance [in] - The tolerance used to join contours small_caps_scale [in] - Scale for small caps, set to 1.0 for no small caps out_glyphs [out] - A nested array of output curves that are organized in the following manner: glyphs contours curves ON_ClassArray< ON_ClassArray < ON_SimpleArray< ON_Curve* > > > Return: true or false indicating success or failure. NOTE, memory for the output is allocated and becomes the responsibility of the caller.

◆ RhinoGetTightBoundingBox()

RHINO_SDK_FUNCTION bool RhinoGetTightBoundingBox	(	const ON_SimpleArray< const class CRhinoObject * > &	geom,
		ON_BoundingBox &	box,
		bool	Grow = `false`,
		ON_Plane *	onb = `nullptr`,
		bool	MakeMeshes = `true`
	)

Description Get objects tight axis aligned bounding box or the union of the input box with the object's bounding box. The alignment of the box may be specified by a parameter. Parameters bbox - [in/out] 3d axis aligned bounding box bGrowBox -[in] (default=false) If true, then the union of the input bbox and the object's bounding box is returned. If false, the object's bounding box is returned. onb -[in] If null the box is computed in world coordinates. If not null must *onb must be a valid ON_Plane. onb's origin, x-axis, y-axis and z-axis specify an oriented orthonormal frame. MakeMeshes-[in] Make render meshes for all meshless Breps in a cancelable thread Returns true if success Details If onb points to a valid ON_Plane the geometry is bounded by the plane aligned box defined by the point set: onb->Origin() + x*onb->Xaxis() + y*onb->YAxis() + z*onb->zaxis for all (x,y,z) in bbox. If MakeMeshes is false the Brep surface wireframe is used for Breps without meshes

◆ RhinoGetTimeInSecondsBetween()

RHINO_SDK_FUNCTION double RhinoGetTimeInSecondsBetween	(	const RhTimestamp &	start_time,
		const RhTimestamp &	stop_time
	)

Description: Calculates the time in seconds between the two provided timestamps. Returns: Time in seconds between 'start_time' and 'stop_time'. Remarks: Use RhinoGetTimestamp() to get a timestamp.

◆ RhinoGetTimeInSecondsSince()

RHINO_SDK_FUNCTION double RhinoGetTimeInSecondsSince ( const RhTimestamp & timestamp )

Description: Calculates the time in seconds between now and the provided timestamp. Returns: Time in seconds between now and 'timestamp'. Remarks: Use RhinoGetTimestamp() to get a timestamp.

◆ RhinoGetTimestamp()

RHINO_SDK_FUNCTION RhTimestamp RhinoGetTimestamp ( )

Description: Returns a high-resolution timestamp that can be used for time-interval measurements. Returns: A timestamp object.

◆ RhinoGetTriangulation()

RHINO_SDK_FUNCTION ON_Mesh* RhinoGetTriangulation	(	const ON_SimpleArray< ON_3dPoint > &	InputInnerPoints,
		const ON_SimpleArray< const ON_PolylineCurve * > &	InputInnerBoundaryCurves,
		const ON_SimpleArray< const ON_PolylineCurve * > &	InputInnerBothsideCurves,
		const ON_PolylineCurve *	pInputOuterBoundaryCurve = `nullptr`,
		const ON_Surface *	pInputPullBackSurface = `nullptr`,
		bool	bTrimback = `true`,
		int	divisions = `10`
	)

Description: Create a triangulated mesh from the given input. This is a higher level function that ultimately calls RhinoTriangulate2dRegion above. Any polyline input will become edges as described above and the edge_side will depend on the input variety, i.e. InputInnerBoundaryCurves will have edge_sides of 1, pInputOuterBoundaryCurves will have edge_sides of 2 and InputInnerBothsideCurves will have edge_sides of 3. Parameters: InputInnerPoints - [in] Points to be used to generate the mesh. Note: If pInputOuterBoundaryCurve is not null, points outside of that boundary after it has been pulled to pInputPullBackSurface (or the best plane through the input if pInputPullBackSurface is null) will be ignored. Optional, can be empty. InputInnerBoundaryCurves - [in] These polylines will create holes in the output mesh. Note: If InputInnerBoundaryCurves are the only input then the result may be null if bTrimback is set to false (see comments for bTrimback) because the resulting mesh could be invalid (all faces created contained vertices from the perimeter boundary). Optional, can be empty. InputInnerBothsideCurves - [in] These polylines will create faces on both sides of the edge. Note: If there are only input points (InputInnerPoints) there is no way to guarantee a triangulation that will create an edge between two particular points. Adding a line, or polyline, to InputInnerBothsideCurves that includes points from InputInnerPoints will help guide the triangulation. Optional, can be empty. pInputOuterBoundaryCurve - [in] Outer boundary polyline, if provided this will become the outer boundary of the resulting mesh. Note: Any of the above input that is completely outside the outer boundary will be ignored and have no impact on the result. If any of the above input intersects the outer boundary the result will be unpredictable and is likely to not include the entire outer boundary. Optional, can be null. pInputPullBackSurface - [in] Initial surface where, if provided, 3d input will be pulled to make a 2d representation used by the function that generates the mesh. Providing a pInputPullBackSurface can be helpful when it is similar in shape to the pattern of the input, the pulled 2d points will be a better representation of the 3d points. If all of the input is more or less coplanar to start with providing pInputPullBackSurface has no real benefit. Optional, can be null. If not provided the best plane through all of the given input is used. bTrimback - [in] bTrimback is only used when a pInputOuterBoundaryCurve has not been provided. When that is the case, the function uses the perimeter of the surface as the outer boundary instead. If bTrimback is true, any face of the resulting triangulated mesh that contains a vertex of the perimeter boundary will be removed. Optional, the default is true. divisions - [in] divisions is also only used when a pInputOuterBoundaryCurve has not been provided. When that is the case, division becomes the number of divisions each side of the surface's perimeter will be divided into to create an outer boundary to work with. Optional, the default is 10. Returns: The result will be a mesh that has the given input as vertices and faces that are the triangulation of those vertices. Null will be returned on error, such as would be the case if no valid input was given being that all arguments are optional. Remarks: The calling function should check that the returned ON_Mesh pointer is not null and is responsible for destroying the returned ON_Mesh. Edges that intersect (polyline inputs that intersect) are not allowed. They will generate an error in the function used to triangulate the input. A result may be returned but not all input will have been used to generate the triangulation.

◆ RhinoGetZeroAreaMeshFaces()

RHINO_SDK_FUNCTION bool RhinoGetZeroAreaMeshFaces	(	ON_SimpleArray< int > &	WhollyDegenerateFaces,
		ON_SimpleArray< int > &	PartiallyDegenerateFaces,
		const ON_Mesh *	pMesh
	)

Description: RhinoGetZeroAreaMeshFaces examines pMesh and adds face indexes to WhollyDegenerateFaces if the face is a triangle with zero area or a quad both triangles have zero area. Face indexes are added to PartiallyDegenerateFaces when a quad has one triangle with zero area. Parameters: WhollyDegenerateFaces - [Out] List of indexes for faces, both triangles and quads, that have zero area. PartiallyDegenerateFaces - [Out] List of indexes for quad faces, that have one triangle with zero area. pMesh - [In] Mesh to examine Returns: Returns false if pMesh is null or has zero for a face or vertex count, otherwise returns true.

◆ RhinoHealMesh()

RHINO_SDK_FUNCTION bool RhinoHealMesh	(	const ON_Mesh *	pMeshIn,
		ON_Mesh &	MeshOut,
		const double	distance
	)

Description: Function attempts to "heal" naked edges in a mesh based on a given distance.
First attempts to move vertices to neighboring vertices that are within that distance away. Then it finds edges that have a closest point to the vertex within the distance and splits the edge. When it finds one it splits the edge and makes two new edges using that point. Parameters: pMeshIn - [In] Input mesh MeshOut - [Out] Output Mesh distance - [In] Distance to not exceed when modifying the mesh. Returns: True or false depending on the success of the modification.

◆ RhinoHistoryManager() [1/2]

RHINO_SDK_FUNCTION class CRhinoHistoryManager* RhinoHistoryManager ( )

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. TODO: Change this to a CRhinoApp::RhinoHistoryManager() member function on CRhinoApp as soon as John checks in the CRhinoApp header file.

◆ RhinoHistoryManager() [2/2]

RHINO_SDK_FUNCTION class CRhinoHistoryManager* RhinoHistoryManager ( class CRhinoDoc * doc )

◆ RhinoInsetBrepFaces()

RHINO_SDK_FUNCTION ON_Brep* RhinoInsetBrepFaces	(	const ON_Brep &	brep,
		const ON_SimpleArray< int > &	aFaceIndices,
		double	dDistance,
		bool	bLoose,
		bool	bIgnoreSeams,
		bool	bCreaseCorners,
		double	dTolerance,
		double	dAngleTolerance
	)

Description: Individually insets faces of a brep by offsetting the faces outer edges inward and inner edges out then splitting the face with the offset curves. Parameters: brep - the brep to inset aFaceIndices - the indices of the faces to inset dDistance - The distance to offset along the face bLoose - If true, offset by moving edit points otherwise offset within tolerance. bIgnoreSeams - If true, the seam edges are not offset and adjacent edges are extended to meet the seam. Otherwise offset normally. bCreaseCorners - If true, splitting curves will be made between the creases on edge curves and creases on the inset curves. dTolerance - The fitting tolerance for the offset. When in doubt, use the document's absolute tolerance. dAngleTolerance - The angle tolerance in radians for identifying creases when creasing corners Returns: A brep with the faces inset or nullptr on failure

◆ RhinoInsetMeshFace()

RHINO_SDK_FUNCTION int RhinoInsetMeshFace	(	double	d,
		ON_Mesh *	pMesh,
		ON_COMPONENT_INDEX::TYPE	ci_type,
		int	ci_index,
		bool	bModify,
		ON_3dPointArray &	basepoints,
		ON_3dPointArray &	corners
	)

◆ RhinoInsetSubDFace()

RHINO_SDK_FUNCTION int RhinoInsetSubDFace	(	double	d,
		ON_SubD *	pSubD,
		ON_COMPONENT_INDEX::TYPE	ci_type,
		int	ci_index,
		bool	bModify,
		ON_3dPointArray &	basepoints,
		ON_3dPointArray &	corners
	)

◆ RhinoInstanceArchiveFileStatus()

RHINO_SDK_FUNCTION RHINO_IDEF_STATUS RhinoInstanceArchiveFileStatus ( const CRhinoInstanceDefinition * idef )

◆ RhinoInterpCurve()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoInterpCurve	(	int	degree,
		const ON_SimpleArray< ON_3dPoint > &	Pt,
		const ON_3dVector *	start_tan,
		const ON_3dVector *	end_tan,
		int	knot_style,
		ON_NurbsCurve *	nc = `nullptr`
	)

Description: Interpolates a sequence of points. Used by InterpCurve Command Parameters: degree - [in] The degree of the curve >=1. Note: Even degree > 3 periodic interpolation results in a non-periodic closed curve. Pt -[in] Array of points to interpolate. For periodic curves if the final point is a duplicate of the initial point it is ignored. Pt.Count()>=2 and start_tan - [in] If not NULL this is the unit tangent at the start of the curve. For periodic style curves start_tan must be NULL. end_tan - [in] If not NULL this is unit tangent at the end of the curve. For periodic style curves end_tan must be NULL. knot_style-[in] Knot-style to use and specifies if the curve should be periodic.

              @table
              value       meaning
              0               uniform knots. Parameter spacing between consecutive knots is 1.0
              1               chord length spacing,  requires degree=3 with CV1 and CVn1 specified.
              2               sqrt(chord length),  requires degree=3 with CV1 and CVn1 specified.
              3               periodic with uniform spacing
              4               periodic with chord length spacing.
              5               periodic with sqrt(chord length) spacing.

nurbs_curve-[in] If not NULL, this curve will be used and returned. Returns: Pointer to interpolating curve. Returns NULL if failure. Details: This routine works best when degree=3. This is used by the Rhino InterpCrv command.

◆ RhinoInterpolatePointsOnSurface()

RHINO_SDK_FUNCTION ON_Curve* RhinoInterpolatePointsOnSurface	(	const ON_Surface &	srf,
		const ON_SimpleArray< ON_2dPoint >	PtIn,
		int	is_closed,
		double	tol,
		int	ClosedSrfHandling
	)

Description: returns a curve that interpolates points on a surface. The interpolant lies on the surface. Parameters: srf -[in] Surface containing the points. PtIn -[in] Array of at least 2 parameter points on the surface is_closed -[in] 0 - not closed. The interpolating curve is not closed 1 - closed. The interpolating curve is closed. The last point and first point of PtIn should generally not be equal. tol -[in] tolerance used for the fit of the pushup curve. Generally, the resulting interpolating curve will be within tol of the surface. ClosedSrfHandling - [in] 0 - All points in PtIn must be in the rectangular domain of srf. If srf is closed in some direction then this routine will interpret each point and place it at an appropriate location in the the covering space. This is the simplest option and should give good results. 1 - Use this option for more control of handling curves going across seams. If the surface is closed in some direction then the points in PtIn are taken as points in the covering space. Example: Suppose srf.IsClosed(0)=TRUE and srf.IsClosed(1)=FALSE and srf.Domain(0)=srf.Domain(1)=ON_Interval(0,1) then if ClosedSrfHandling = 1 a point (u,v) in PtIn can have any value for the u coordinate, but must have 0<=v<=1. In particular if PtIn = { (0.0,0.5), (2.0,0.5) } then the interpolating curve will wrap around the surface 2 times in the closed direction before ending at start of the curve. If is_closed=1 the last point should equal the first point plus an integer multiple of the period on a closed direction. Returns: An interpolating curve lying on the surface. Details: This code doesn't make periodic curves, but will make closed curves.

◆ RhinoIntersectBreps() [1/2]

RHINO_SDK_FUNCTION bool RhinoIntersectBreps	(	const ON_Brep &	B0,
		const ON_Brep &	B1,
		double	tolerance,
		bool	bJoinCurves,
		ON_SimpleArray< ON_Curve * > &	curves,
		ON_3dPointArray *	points
	)

Description: Brep intersector. Parameters: B0 - [in] The first input Brep. B1 - [in] The second input Brep. tolerance - [in] The fitting and near miss tolerance. bJoinCurves - [in] If true, join the resulting curves where possible curves - [out] The output 3d curves. NOTE, the caller is responsible for destroying these curves. points - [out] If non-NULL, the 3d intersection points. Returns: TRUE if successful. FALSE if B0 == B1, or on error.

◆ RhinoIntersectBreps() [2/2]

RHINO_SDK_FUNCTION bool RhinoIntersectBreps	(	const ON_Brep &	brep0,
		const ON_Brep &	brep1,
		double	tolerance,
		ON_SimpleArray< ON_Curve * > &	curves,
		ON_3dPointArray *	points = `nullptr`
	)

Description: Brep intersector. Parameters: B0 - [in] The first input Brep. B1 - [in] The second input Brep. tolerance - [in] The fitting and near miss tolerance. curves - [out] The output 3d curves. NOTE, the caller is responsible for destroying these curves. points - [out] If non-NULL, the 3d intersection points. Returns: TRUE if successful. FALSE if B0 == B1, or on error.

◆ RhinoIntersectPlaneBrep() [1/2]

RHINO_SDK_FUNCTION bool RhinoIntersectPlaneBrep	(	const ON_Plane &	plane,
		const ON_Brep &	brep,
		double	tolerance,
		bool	bJoinCurves,
		ON_SimpleArray< ON_Curve * > &	curves,
		ON_3dPointArray *	points
	)

Description: Plane - Brep intersector. Parameters: plan - [in] The plane. brep - [in] The Brep. tolerance - [in] The fitting and near miss tolerance. bJoinCurves - [in] If true, join the resulting curves where possible curves - [out] The output 3d curves. NOTE, the caller is responsible for destroying these curves. points - [out] If non-NULL, the 3d intersection points. Returns: TRUE if successful.

◆ RhinoIntersectPlaneBrep() [2/2]

RHINO_SDK_FUNCTION bool RhinoIntersectPlaneBrep	(	const ON_Plane &	plane,
		const ON_Brep &	brep,
		double	tolerance,
		ON_SimpleArray< ON_Curve * > &	curves,
		ON_3dPointArray *	points
	)

Description: Plane - Brep intersector. Parameters: plan - [in] The plane. brep - [in] The Brep. tolerance - [in] The fitting and near miss tolerance. curves - [out] The output 3d curves. NOTE, the caller is responsible for destroying these curves. points - [out] If non-NULL, the 3d intersection points. Returns: TRUE if successful.

◆ RhinoIntersectPlaneWithBoundingBox()

RHINO_SDK_FUNCTION bool RhinoIntersectPlaneWithBoundingBox	(	ON_3dPoint	origin,
		ON_3dVector	normal,
		const ON_BoundingBox &	bounding_box,
		bool	bAccurate,
		ON_Polyline &	polyline
	)

Description: Fast intersection of plane with bounding box. Parameters: origin [in] - The plane's origin. normal [in] - The plane's normal direction. bounding_box [in] - The bounding box. bAccurate [in] - If false, returns the four segment polyline of the intersection with the box extended infinitely in the max coordinate direction, If true, incorporates the intersection with the Max and Min bounding planes if the four point polyline sticks out a significant distance (0.001*the length of the box in the max normal coordinate direction). polyline [out] - The output polyline if successful. Returns: Returns false if all intersections are out of the same side of the bounding box. If bAccurate is false, returns the four segment polyline of the intersection with the box extended infinitely in the max coord direction Remarks: Intersect the four bounding box infinite lines in the direction of the max coordinate with the plane. Point and single line intersections are ignored.

◆ RhinoIntersectSurfaces()

RHINO_SDK_FUNCTION bool RhinoIntersectSurfaces	(	const ON_Surface &	srf0,
		const ON_Surface &	srf1,
		double	tolerance,
		ON_SimpleArray< ON_Curve * > &	curves,
		ON_3dPointArray *	points = `nullptr`
	)

Description: Surface intersector. Parameters: B0 - [in] The first input surface. B1 - [in] The second input surface. tolerance - [in] The fitting and near miss tolerance. curves - [out] The output 3d curves. NOTE, the caller is responsible for destroying these curves. points - [out] If non-NULL, the 3d intersection points. Returns: TRUE if successful. FALSE if B0 == B1, or on error.

◆ RhinoIsBrepBox()

RHINO_SDK_FUNCTION bool RhinoIsBrepBox	(	const ON_Brep &	brep,
		double	tolerance
	)

Description: Verifies a Brep is in the form of a solid box. Parameters: brep - [in] The Brep to test. tolerance - [in] The tolerance used to determine if faces are planar and to compare face normals. Returns: True if the Brep is in the form of a solid box.

◆ RhinoIsCurveConicSection()

RHINO_SDK_FUNCTION RhinoConicSectionType RhinoIsCurveConicSection	(	const ON_Curve *	curve,
		ON_3dPoint *	focus1,
		ON_3dPoint *	focus2,
		ON_3dPoint *	center
	)

Description: Determines if a curve is a conic section based on the curve's shape. Parameters: curve - [in] The curve to evaluate. focus1 - [out] The point at the conic's first focus. focus2 - [out] The point at the conic's second focus. center - [out] The point at the center of the conic. Returns: The type of conic section.

◆ RhinoIsMainThread()

RHINO_SDK_FUNCTION bool RhinoIsMainThread ( void )

◆ RhinoIsPointInBrep()

RHINO_SDK_FUNCTION bool RhinoIsPointInBrep	(	const ON_Brep *	pBrep,
		ON_3dPoint	pt,
		double	tolerance = `ON_SQRT_EPSILON`,
		bool	bStrictlyIn = `false`
	)

Description: Determine if a 3D point is inside of a Brep. This function only makes sense for closed manifold Breps. Parameters: pBrep - [in] the Brep. pt - [in] 3d point to test. tolerance - [in] 3d distance tolerance used for intersection and determining strict inclusion. bStrictlyIn - [in] if true, pt is in if inside pBrep by at least tolerance. if false, pt is in if truly in or within tolerance of boundary. Returns: true if pt is in, false if not. See parameter bStrictlyIn.

◆ RhinoIsPointOnFace()

RHINO_SDK_FUNCTION bool RhinoIsPointOnFace	(	const ON_BrepFace &	face,
		double	tolerance,
		bool	bOkToWrap,
		double &	s,
		double &	t
	)

Description: Determine if a point is in the active region of a face. Parameters: face - [in] The Brep face to test. tolerance - [in] 3d tolerance bOkToWrap - [in] If true and if surface the face is built on is closed, the the test parameter is permitted to wrap across the surface seam. If the (s,t)parameters are the result of a closest point or intersection query, then you generally want bOkToWrap = true. s - [in/out] (s,t) is the parameter to be tested. t - [in/out] (s,t) is the parameter to be tested. Returns: True if (s,t) is on the active part of the face. Remarks: If true is returned, then the returned values of (s,t) are the parameters of the active point. When bOkToWrap is true and the surface is closed, the return values may differ from the input values.

◆ RhinoIsRefitTrimValid()

RHINO_SDK_FUNCTION bool RhinoIsRefitTrimValid	(	const ON_Surface *	surface,
		const ON_Curve *	trimCurve3d,
		const ON_3dVector	trimProjectionDir,
		double	tolerance,
		bool	oneSideOnly,
		const ON_3dPoint	PtActive,
		ON_NurbsCurve **	trimCrvU,
		ON_NurbsSurface **	surfaceU,
		bool *	isTransposed,
		bool *	isReversed
	)

Parameters

surface	Determines whether the input surface, curve, and projection are valid for a RefitTrim or FitCurveToSurface returns the split surface and (possibly extended) trim curve, adjusted to flow in U returns flags to indicate whether the surface is transposed (i.e. knot vector in V, trim curve is North/South) or reversed (flipped) INPUT: untrimmed surface
trimCurve3d	curve that will trim from one edge to the opposite
trimProjectionDir	How is the trim curve projected onto the surface? ... if non-zero, vector for projection
tolerance	3d tolerance for projection, splitting, fitting...
oneSideOnly	Inputting an "active" point means you only want one side of the "split" to be refit - In other words, you want a "trim refit". Results will be returned in "srfLower"
trimCrvU	OUTPUT: trim curve adjusted to flow in u
surfaceU	input surface adjusted to flow in u, North edge trimmed
isTransposed	true it transposed
isReversed	true if reversed

◆ RhinoIsValidName()

RHINO_SDK_FUNCTION int RhinoIsValidName ( const wchar_t * name )

Description: Tests a string to see if it can be used as a name for an object, layer, material, group, font, etc. Parameters: name - [in] name to test. Remarks: Valid names do not have leading or trailing white space, do not contain DEL characters (127), and do not contain characters with values < 32. Returns: TRUE if the string is valid name for an object, layer, material, group, font, etc. See Also: CRhinoCommand::IsValidCommandName

◆ RhinoJoinBrepNakedEdges()

RHINO_SDK_FUNCTION int RhinoJoinBrepNakedEdges	(	ON_Brep &	brep,
		double	tolerance = `0.0`
	)

Description: Join naked edge pairs within the same Brep that overlap within tolerance. Parameters: B - [in] Brep tolerance - [in] overlap tolerance for joining edges Uses document tolerance if <= 0.0 Returns: number of joins made. See Also:

◆ RhinoJoinBreps() [1/5]

RHINO_SDK_FUNCTION bool RhinoJoinBreps	(	const ON_SimpleArray< const ON_Brep * > &	input_breps,
		double	tolerance,
		double	angle_tolerance,
		ON_SimpleArray< ON_Brep * > &	output_breps
	)

Description: Joins the Breps in the input array at any overlapping edges to form as few as possible resulting Breps. There may be more than one Brep in the output array. Parameters: input_breps [in] Array of Breps to join. tolerance [in] 3d distance tolerance for detecting overlapping edges. When in doubt, use the document's model absolute toleance. angle_tolerance [in] Angle tolerance, in radians, used for merging edges. When in doubt, use the document's model angle toleance. output_breps [out] Empty array to return results of the join. Returns: true if any edges were joined. Remarks: Memory for the output Breps is allocated and becomes the responsibility of the caller.

◆ RhinoJoinBreps() [2/5]

RHINO_SDK_FUNCTION bool RhinoJoinBreps	(	const ON_SimpleArray< const ON_Brep * > &	input_breps,
		double	tolerance,
		double	angle_tolerance,
		ON_SimpleArray< ON_Brep * > &	output_breps,
		ON_ClassArray< ON_SimpleArray< int >> &	output_key
	)

Description: Joins the Breps in the input array at any overlapping edges to form as few as possible resulting Breps. There may be more than one Brep in the output array. Parameters: input_breps [in] Array of Breps to join. tolerance [in] 3d distance tolerance for detecting overlapping edges. When in doubt, use the document's model absolute toleance. angle_tolerance [in] Angle tolerance, in radians, used for merging edges. When in doubt, use the document's model angle toleance. output_breps [out] Empty array to return results of the join. output_key [out] Array of integer arrays, one for each joined result, containing all input Brep indices that went into making it. Returns: true if any edges were joined. Remarks: Memory for the output Breps is allocated and becomes the responsibility of the caller.

◆ RhinoJoinBreps() [3/5]

RHINO_SDK_FUNCTION bool RhinoJoinBreps	(	ON_Brep &	B,
		const ON_Brep &	B1,
		double	tolerance,
		bool	bCompact = `true`
	)

Description: If any edges of B overlap edges of B1, merge a copy of B1 into B joining all edges that overlap within tolerance Parameters: B [in] Base Brep to which faces will be added. B1 [in] Brep to be added to B, tolerance [in] 3d distance tolerance for detecting overlapping edges bCompact [in] if true, set Brep flags and tolerances, remove unused faces and edges Returns: true if any edges were joined. Remarks: if no edges overlap, B is unchanged.

B1 is copied if it is merged with B, and B1 is always unchanged

Use this to join a list of Breps in a series.

given ON_SimpleArray<const ON_Brep*> BList, of manifold , non-solid Breps,

ON_Brep* B = ON_Brep::New(BList[0]); ///<be sure to copy this one, not cast. bool joined_something = false; for (int i=1; i<BList.Count(); i++){ bool joined_something_here = RhinoJoinBreps(*B, *BList[i], tolerance)); if (joined_something_here){ joined_something = true; if (B->IsSolid()) break; } }

When joining multiple Breps in series, bCompact should be set to false. If bCompact is false, the caller should do something like this afterwards:

B.Compact(); B.SetEdgeTolerances(TRUE); B.SetVertexTolerances(TRUE);

◆ RhinoJoinBreps() [4/5]

RHINO_SDK_FUNCTION ON_Brep* RhinoJoinBreps	(	ON_SimpleArray< ON_Brep * > &	Breps,
		double	tolerance
	)

Description: Join Breps into a single Brep. Parameters: breps - [in] Array of Breps to join. (THESE ARE MODIFIED AND SHOULD BE DELETED BY CALLER!) tolerance - [in] 3d join tolerance. Returns: Brep made by joining all the inputs together.

◆ RhinoJoinBreps() [5/5]

RHINO_SDK_FUNCTION bool RhinoJoinBreps	(	ON_SimpleArray< ON_Brep * > &	input_breps,
		ON_SimpleArray< ON_Brep * > &	output_breps,
		double	tolerance
	)

Description: OBSOLETE - USE THE VERSION ABOVE Joins the Breps in the input array at any overlapping edges to form as few as possible resulting Breps. There may be more than one Brep in the result array Parameters: input_breps [in] Array of Breps to join output_breps [in] Empty array to return results of the join tolerance [in] 3d distance tolerance for detecting overlapping edges Returns: true if any edges were joined. Remarks: The Breps sent in to join should be deleted after this call All of the geometry is copied and added to joined_breps in one form or another. ON_SimpleArray<ON_Brep*> joined_breps; RhinoJoinBreps(in_breps, joined_breps, tolerance); for (i=0; i<in_breps.Count(); i++) delete in_breps[i];

◆ RhinoJoinCurves()

RHINO_SDK_FUNCTION int RhinoJoinCurves	(	ON_SimpleArray< const ON_Curve * > &	in_curves,
		ON_SimpleArray< ON_Curve * > &	out_curves,
		double	join_tol,
		bool	bPreserveDir,
		ON_SimpleArray< int > *	key
	)

Description: Join a bunch of ON_Curves into one or more ON_Curves. This is simple version of RhinoMergeCurves that just uses ON_JoinCurve.

◆ RhinoJoinEdges() [1/2]

RHINO_SDK_FUNCTION ON_Brep* RhinoJoinEdges	(	const ON_Brep &	brep0,
		int	edge_index0,
		const ON_Brep &	brep1,
		int	edge_index1,
		double	tolerance
	)

Description: Joins two naked edges, or edges that are coincident or close together, from two Breps. Parameters: brep0 - [in] The first Brep. edge_index0 - [in] The edge index on the first Brep. brep1 - [in] The second Brep. edge_index1 - [in] The edge index on the second Brep. tolerance - [in] The join tolerance. Returns: The resulting Brep if successful, null on failure.

◆ RhinoJoinEdges() [2/2]

RHINO_SDK_FUNCTION bool RhinoJoinEdges	(	ON_Brep &	brep,
		int	edge_index0,
		int	edge_index1,
		double	tolerance,
		bool	bCompact
	)

Description: Joins two naked edges, or edges that are coincident or close together. Parameters: brep - [in] The Brep to modify. edge_index0 - [in] The first edge index on the first Brep. edge_index1 - [in] The second edge index on the second Brep. tolerance - [in] The join tolerance. bCompact - [in] If you are joining more than one edge pair and want the edge indices of subsequent pairs to remain valid, set bCompact = false. But then call ON_Brep::Compact() on the final result when done. Returns: true if successful, false on failure.

◆ RhinoJoinSubDs() [1/2]

RHINO_SDK_FUNCTION int RhinoJoinSubDs	(	const ON_SimpleArray< const ON_SubD * > &	input_subds,
		double	join_tolerance,
		bool	bSubDJoinedEdgesAreCreases,
		bool	bPermitNonmanifoldSubD,
		bool	bPreserveSymmetry,
		ON_SimpleArray< ON_SubD * > &	output_subds
	)

Description: Joins the SubDs in the input array to form as few as possible resulting SubDs. There may be more than one SubD in the result array. Parameters: input_subds - [in] Array of SubDs to join. join_tolerance - [in] The join tolerance. bSubDJoinedEdgesAreCreases - [in] If true, merged boundary edges will be creases. If false, merged boundary edges will be smooth bPermitNonmanifoldSubD - [in] - Permit non-manifold SubDs to be joined. bPreserveSymmetry - [in] If true, and if all inputs share the same symmetry, the output will also be symmetrical wrt. that symmetry. If If false, or true but no common symmetry exists, symmetry information is removed from all newly joined SubDs. output_subds - [out] Array of output SubDs. Returns: The number of SubDs added to the output array. Remarks: NOTE: Memory for the output SubDs is allocated and becomes the responsibility of the caller. All of the geometry is copied and added to output_subds in one form or another.

◆ RhinoJoinSubDs() [2/2]

RHINO_SDK_FUNCTION int RhinoJoinSubDs	(	const ON_SimpleArray< const ON_SubD * > &	input_subds,
		double	join_tolerance,
		bool	bSubDJoinedEdgesAreCreases,
		bool	bPermitNonmanifoldSubD,
		ON_SimpleArray< ON_SubD * > &	output_subds
	)

Description: Joins the SubDs in the input array to form as few as possible resulting SubDs. There may be more than one SubD in the result array. Parameters: input_subds - [in] Array of SubDs to join. join_tolerance - [in] The join tolerance. bSubDJoinedEdgesAreCreases - [in] If true, merged boundary edges will be creases. If false, merged boundary edges will be smooth bPermitNonmanifoldSubD - [in] - Permit non-manifold SubDs to be joined. output_subds - [out] Array of output SubDs. Returns: The number of SubDs added to the output array. Remarks: NOTE: Memory for the output SubDs is allocated and becomes the responsibility of the caller. All of the geometry is copied and added to output_subds in one form or another. NOTE: Symmetry information is removed from newly joined SubDs. See also comments in RhinoJoinSubDs with the bPreserveSymmetry parameter.

◆ RhinoKeyboardModifierKeyFromUnsigned()

RHINO_SDK_FUNCTION RhinoKeyboardModifierKey RhinoKeyboardModifierKeyFromUnsigned ( unsigned int val )

◆ RhinoKillSplash()

RHINO_SDK_FUNCTION void RhinoKillSplash ( )

Description: Destroy the splash screen if it is being displayed

◆ RhinoLaplacianMeanMeshCurvature()

RHINO_SDK_FUNCTION bool RhinoLaplacianMeanMeshCurvature	(	const ON_Mesh &	MeshIn,
		ON_SimpleArray< double > &	result
	)

Description: Function that computes the discrete mean curvatures, by using the cotangent-weighted Laplacian of the coordianate functions. The function takes care of mesh topology and quads by internal triangulation. Use at your own risk on nonmanifold meshes.

Parameters: MeshIn - [In] Input mesh result - [out] array to be filled with the curvatures. On success, its Count() will be MeshIn.VertexCount(). Returns: True or false depending on the success of the computation.

◆ RhinoLayerManagerSelectedLayers() [1/2]

RHINO_SDK_FUNCTION int RhinoLayerManagerSelectedLayers	(	CRhinoDoc &	doc,
		ON_SimpleArray< int > &	layers
	)

Description: If the layer manager window is visible, then the function returns the layer indices of the selected layer items in the list. Parameters: doc - [in] The Rhino document. layers - [out] The layer indices of the selected layer items. Returns: >= 0 - The number of indices added to the output array. -1 - If the layer manager window is not visible, or on error.

◆ RhinoLayerManagerSelectedLayers() [2/2]

RHINO_SDK_FUNCTION int RhinoLayerManagerSelectedLayers ( ON_SimpleArray< int > & layers )

Deprecated:: use overload that takes a CRhinoDoc parameter

◆ RhinoLayerManagerSelectLayers() [1/2]

RHINO_SDK_FUNCTION int RhinoLayerManagerSelectLayers	(	CRhinoDoc &	doc,
		const ON_SimpleArray< int > &	layers,
		bool	bDeselect
	)

Description: If the layer manager window is visible, then the function selects layer items, specified by the layer indices, in the list. Parameters: doc - [in] The Rhino document. layers - [in] The indices of the layers to select. bDeselect - [in] If true, then any previously selected layers will be unselected. Returns: >= 0 - The number layer items that were selected. -1 - If the layer manager window is not visible, or on error.

◆ RhinoLayerManagerSelectLayers() [2/2]

RHINO_SDK_FUNCTION int RhinoLayerManagerSelectLayers	(	ON_SimpleArray< int >	layers,
		bool	bDeselect
	)

Deprecated:: use overload that takes a CRhinoDoc parameter

◆ RhinoLinetypeDialog()

RHINO_SDK_FUNCTION BOOL32 RhinoLinetypeDialog	(	HWND	hwndParent,
		int &	linetype_index,
		bool	bDisplayByLayer = `false`
	)

Description: Display Rhino's linetype selection dialog. Parameters: hwndParent - [in] Window handle of dialog's parent window. linetype_index - [in/out] Default linetype index for dialog, and will receive new linetype index if function returns TRUE. bDisplayByLayer - [in] Displays the "ByLayer" linetype in the list Returns: TRUE - Dialog completed successfully. FALSE - Dialog was canceled. Remarks: If the user selects the "Continuous" linetype, then linetype_index will equal -1. If bDisplayByLayer = true and the user selects the "ByLayer" linetype, then linetype_index will equal -2.

◆ RhinoLocalizedUnitSystemName() [1/2]

const RHINO_SDK_FUNCTION wchar_t* RhinoLocalizedUnitSystemName	(	bool	bCapitalize,
		bool	bSingular,
		bool	bAbbreviate,
		const ON_UnitSystem &	unit_system
	)

◆ RhinoLocalizedUnitSystemName() [2/2]

const RHINO_SDK_FUNCTION wchar_t* RhinoLocalizedUnitSystemName	(	bool	bCapitalize,
		bool	bSingular,
		bool	bAbbreviate,
		ON::LengthUnitSystem	length_unit_system
	)

Description: Returns a unit system name based on Rhino's current locale setting. Parameters: bCapitalize - [in] Capitalize the first character (e.g. "Millimeter" vs "millimeter"). bSingular - [in] Return the name in singular form (e.g. "millimeter" vs "millimeters"). bAbbreviate - [in] Return the abbreviated name (e.g. "mm" vs "millimeter"). Returns: The localized unit system name.

◆ RhinoMakeCompatibleNurbs()

RHINO_SDK_FUNCTION bool RhinoMakeCompatibleNurbs	(	ON_SimpleArray< const ON_Curve * > &	curves,
		ON_3dPoint *	startpt,
		ON_3dPoint *	endpt,
		int	simplify_method,
		int	num_elmo_points,
		double	refit_tolerance,
		double	angle_tolerance_radians,
		ON_SimpleArray< ON_NurbsCurve * > &	compatiblecurves
	)

Description: For expert use only. From the input curves, make an array of compatible NURBS curves. Useful as input shapes for Loft, Sweep, etc.

◆ RhinoMakeCompatibleNurbsSurfaces()

RHINO_SDK_FUNCTION bool RhinoMakeCompatibleNurbsSurfaces	(	const ON_Surface &	S0,
		const ON_Surface &	S1,
		ON_NurbsSurface &	C0,
		ON_NurbsSurface &	C1
	)

Description: For expert use only. Makes a pair of compatible NURBS surfaces based on two input surfaces.

◆ RhinoMakeConnectedMeshFaceList()

RHINO_SDK_FUNCTION int RhinoMakeConnectedMeshFaceList	(	const ON_Mesh *	pMesh,
		int	StartFaceIDX,
		double	AngleInRadians,
		bool	bGreaterThan,
		ON_SimpleArray< int > &	FaceIDXArray
	)

Description: RhinoMakeConnectedMeshFaceList uses StartFaceIDX and finds all connected face indexes where adjacent face normals meet the criteria of AngleInRadians and bGreaterThan Parameters: pMesh - [In] Mesh StartFaceIDX - [In] Initial face index AngleInRadians - [In] Angle between adjacent face normals bGreaterThan - [In] If true angles greater than or equal to are consider, if false, less than or equal to FaceIDXArray - [Out] Array of connected face indexes Returns: The number of face indexes added to FaceIDXArray or 0 on failure.

◆ RhinoMakeContours()

RHINO_SDK_FUNCTION bool RhinoMakeContours	(	const CRhinoContourInput &	input,
		ON_SimpleArray< ON_Polyline * > &	output_PlineArray,
		ON_SimpleArray< ON_Curve * > &	output_CurveArray,
		ON_SimpleArray< ON_3dPoint > &	output_PointArray,
		double	tolerance,
		bool	output,
		int	layer_index,
		CRhinoDoc *	doc
	)

Description: Create contour curves for Breps and contour polylines for meshes that are input.m_interval distance apart and fill the output arrays with the results. If m_bAddOutputToDocument==true, then doc must NOT be NULL If m_bAddOutputToDocument==false, doc can be NULL and is ignored Parameters: input - [in] output_PlineArray = [out] ///<output from mesh and point cloud intersection output_CurveArray = [out] ///<output from surface and polysurface intersection output_PointArray = [out] ///<output from curve intersection tolerance = tolerance output = false outputs curves only, true outputs hatches if set layer_index = input document doc = input document Returns: true or false depending on success or failure Remarks: It is the calling functions responsibility to clean up the memory used by these arrays.

◆ RhinoMakeCubicBeziers()

RHINO_SDK_FUNCTION int RhinoMakeCubicBeziers	(	const ON_Curve &	Curve,
		ON_SimpleArray< ON_BezierCurve * > &	BezArray,
		double	dist_tol,
		double	kink_tol
	)

Description: Makes an array of cubic, non-rational Beziers that fit a curve to a tolerance Parameters: Curve - [in] BezArray - [out] List of Beziers dist_tol - [in] max fitting error. Will use ON_SQRT_EPSILON as a minimum. kink_tol - [in] If the input curve has a g1-discontinuity with angle radian measure greater than kink_tol at some point P, the list of Beziers will also have a kink at P. Returns: Returns 0 if input is bogus. 1 if fit to tolerance, 2 if not fit to tolerance.

◆ RhinoMakeCurveClosed()

RHINO_SDK_FUNCTION BOOL32 RhinoMakeCurveClosed	(	ON_Curve *	pCrv,
		double	tolerance = `0.0`
	)

Description: If pCrv->IsClosed(), just return TRUE. Otherwise, decide if pCrv can be closed as follows: Linear curves polylinear curves with 2 segments, NURBS with 3 or less control points cannot be made closed, Also, if tolerance > 0 and the gap between start and end is larger than tolerance, curve cannot be made closed.Adjust the curve's endpoint to match its start point. Parameters: pCrv [in] curve to adjust tolerance [in] if nonzero, and the gap is more than tolerance, curve cannot be made closed. Returns: @untitled table TRUE Success False Curve could not be made closed.

◆ RhinoMakeCurveEndsMeet()

RHINO_SDK_FUNCTION BOOL32 RhinoMakeCurveEndsMeet	(	ON_Curve *	pCrv0,
		int	end0,
		ON_Curve *	pCrv1,
		int	end1
	)

Description: Make adjustments to the ends of one or both input curves so that they meet at a point Parameters: pCrv0 [in] 1st curve to adjust end0 [in] end of the 1st curve to adjust 0: start, 1: end pCrv1 [in] 2nd curve to adjust end1 [in] end of the 2nd curve to adjust 0: start, 1: end Returns: @untitled table TRUE Success False Failure

◆ RhinoMakeCurvePeriodic()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoMakeCurvePeriodic	(	const ON_Curve &	curve,
		bool	bSmooth
	)

Description: Removes kinks from a curve. Periodic curves deform smoothly without kinks. Parameters: curve [in] - The curve to make periodic. Curve must have degree >= 2. bSmooth [in] - Controls kink removal. If true, smooths any kinks in the curve and moves control points to make a smooth curve. If false, control point locations are not changed or changed minimally (only one point may move) and only the knot vector is altered. Return: ON_NurbsCurve* - The resulting curve or NULL. NOTE, memory for the curve is allocated and becomes the responsibility of the caller. Remarks: A periodic curve is a smooth closed curve. Periodic curves stay smooth when you edit them. If a joined curve is made periodic, it becomes a single-span curve and can no longer explode.

◆ RhinoMakeG1Surface()

RHINO_SDK_FUNCTION bool RhinoMakeG1Surface	(	ON_Surface &	srf,
		double	tol = `0.0`
	)

Description: If a surface is very nearly G1-continuous, move control points to make it exactly G1. Parameters: srf - [in] surface to be made G1 tol - [in] tolerance. Control points will be moved if they do not need to be moved any more than tol. If tol <= 0, the Rhino document tolerance will be used. Returns: true if srf was changed See Also: RhinoStraightenBrep

◆ RhinoMakeMeshPartFaceList()

RHINO_SDK_FUNCTION int RhinoMakeMeshPartFaceList	(	const ON_Mesh *	pMesh,
		int	StartFaceIDX,
		bool	bExtractToNonManifoldEdges,
		ON_SimpleArray< int > &	FaceIDXArray
	)

Description: RhinoMakeMeshPartFaceList uses StartFaceIDX and finds all connected face indexes up to unwelded or naked edges. If bExtractToNonManifoldEdges is true then non-manifold edges will be considered as unwelded or naked. Parameters: pMesh - [In] Mesh StartFaceIDX - [In] Initial face index bExtractToNonManifoldEdges - [In] True means non-manifold edges will be handled like unwelded edges, False means they aren't considered. FaceIDXArray - [Out] Array of connected face indexes Returns: The number of face indexes added to FaceIDXArray or 0 on failure.

◆ RhinoMakePiecewiseLinearCurve()

RHINO_SDK_FUNCTION bool RhinoMakePiecewiseLinearCurve	(	const ON_NurbsCurve &	crv,
		double	tolerance,
		ON_NurbsCurve &	linear
	)

Description: Tries to convert a curve to a piecewise linear curve, by checking for stacked control points and fully multiple knots. Works on curves of dim >= 2, also high-dimensional curves. Parameters: crv [in] - the input curve tolerance [in] - the tolerance for linearity linear [out] - if successful, the linearized degree-1 curve

Return: True or false indicating success or failure. If false is returned, the state of the curve 'linear' is undetermined.

◆ RhinoMakePiecewiseLinearSurface()

RHINO_SDK_FUNCTION bool RhinoMakePiecewiseLinearSurface	(	const ON_NurbsSurface &	srf,
		double	tolerance,
		ON_NurbsSurface &	linear
	)

Description: Tries to convert a surface to a piecewise linear surface, by checking for stacked control points and fully multiple knots in both directions. Parameters: srf [in] - the input surface tolerance [in] - the tolerance for linearity linear [out] - if successful, the linearized degree-1 surface

Return: True or false indicating success or failure. If false is returned, the state of the surface 'linear' is undetermined.

◆ RhinoMakePlanarBreps() [1/2]

RHINO_SDK_FUNCTION BOOL32 RhinoMakePlanarBreps	(	ON_SimpleArray< const ON_Curve * > &	input_loops,
		ON_SimpleArray< ON_Brep * > &	breps,
		double	tolerance,
		ON_SimpleArray< int > *	used = `nullptr`
	)

◆ RhinoMakePlanarBreps() [2/2]

RHINO_SDK_FUNCTION BOOL32 RhinoMakePlanarBreps	(	ON_SimpleArray< const ON_Curve * > &	input_loops,
		ON_SimpleArray< ON_Brep * > &	breps,
		ON_SimpleArray< int > *	used = `nullptr`
	)

Description: Creates planar Breps of 1 face from array of curves Parameters: input_loops [in] loops to sort and use as boundaries breps [out] array of 1 face Breps notused - optional array to hold indices of the input curves that got used Returns: @untitled table TRUE Success FALSE Failure Remarks: calls RhinoMakePlanarFaces() to sort the input curves into faces See Also: RhinoMakePlanarBrep()

Deprecated:: use overload that takes a tolerance

◆ RhinoMakePlanarMeshes()

RHINO_SDK_FUNCTION bool RhinoMakePlanarMeshes	(	ON_SimpleArray< const ON_Curve * > &	curves,
		const ON_MeshParameters &	mp,
		ON_SimpleArray< ON_Mesh * > &	meshes,
		double	tol
	)

Description: Creates one or more planar meshes from one or more planar closed curves. Parameters: curves - [in] The planar closed curves. mp - [in] Mesh parameters to be used in the creation of the meshes meshes - [out] The resulting planar meshes. tol - [in] tolerance used, use document tolerance if you're unsure Returns: true if successful, false otherwise.

◆ RhinoMakeRadiusSpline()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoMakeRadiusSpline	(	ON_Interval	domain,
		ON_SimpleArray< MakeRadiusSplineData >	distance_data,
		bool	bClosed = `false`
	)

◆ RhinoMakeSurfacePeriodic()

RHINO_SDK_FUNCTION ON_NurbsSurface* RhinoMakeSurfacePeriodic	(	const ON_Surface &	surface,
		int	dir,
		bool	bSmooth
	)

Description: Removes kinks from a surface. Periodic surface deform smoothly without kinks. Parameters: surface [in] - The surface to make periodic. dir [in] - The direction to make periodic, where u = 0, v = 1. Surface in dir direction must have degree >= 2. bSmooth [in] - Controls kink removal. If true, smooths any kinks in the surface and moves control points to make a smooth surface. If false, control point locations are not changed or changed minimally (only one point may move) and only the knot vector is altered. Return: ON_NurbsSurface* - The resulting surface or NULL. NOTE, memory for the surface is allocated and becomes the responsibility of the caller. Remarks: Periodic surfaces are closed surfaces (such as a cylindrical surface) that can be deformed without developing kinks. Periodic surfaces are automatically created when the input curves are periodic.

◆ RhinoMaskLastWindowsError()

RHINO_SDK_FUNCTION bool RhinoMaskLastWindowsError ( DWORD winerr )

Description: Allows you to ignore a instance of a Windows errors in order to prevent Rhino from reporting the error as a serious problem. Parameters: winerr - [in] code of error to mask. Example:

  RhinoGetLastWindowsError();
  ...
  call windows open file code in a situation
  where a missing file is a valid situation.
  ..

/ in this case, it is OK if file does not exist RhinoMaskLastWindowsError(ERROR_FILE_NOT_FOUND); RhinoGetLastWindowsError(); ....

Returns: True if the value of ::GetLastError() matched winerr and the error was masked by calling ::SetLastError(0). True if the value of ::GetLastError() was zero. False if the value of ::GetLastError() was non-zero and did not match winerr.

◆ RhinoMatchMeshEdge()

RHINO_SDK_FUNCTION bool RhinoMatchMeshEdge	(	const ON_Mesh *	input,
		ON_Mesh &	output,
		double	distance,
		bool	rachet
	)

Description: Performs same procedure as the MatchMeshEdge command on a single mesh. Parameters: input - [in] Original const mesh. output - [out] If return value is true output will be the modified copy of input. distance - [in] Distance to not exceed when modifying the mesh. ratchet - [in] Divides the initial distance by 1000 and goes through the code 4 times, each time increasing the distance by a factor of 10. Returns: True on success. If false, output has not been modified.

◆ RhinoMeanCurve()

RHINO_SDK_FUNCTION ON_Curve* RhinoMeanCurve	(	const ON_Curve *	pC0,
		const ON_Curve *	pC1,
		double	angle_tolerance = `ON_UNSET_VALUE`
	)

Description: Creates a mean, or average, curve from two curves. Parameters: pC0 - [in] The first curve. pC1 - [in] The second curve. angle_tolerance - [in] The angle tolerance, in radians, used to match kinks between curves. If you are unsure how to set this parameter, then either use the document's angle tolerance (CRhinoDoc::AngleToleranceRadians(), or the default value. Returns: A pointer to a new curve if success. NULL if unsuccessful. Remarks: THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CURVE.

◆ RhinoMemoryErrorHandler()

int RhinoMemoryErrorHandler ( int )

SDK classes.

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer.

◆ RhinoMergeAdjoiningEdges()

RHINO_SDK_FUNCTION ON_BrepEdge* RhinoMergeAdjoiningEdges	(	ON_BrepEdge &	edge,
		double	angtol,
		int *	merge_cnt = `nullptr`
	)

Description: Merge adjacent edges to this edge recursively using tolerance Parameters: edge - [in] on edge in the Brep to be modified angtol - [in] The maximum allowable difference of angle in radian between adjacent edges that can be merged. merge_cnt - [out] Number of edges merged into final edge Returns: A pointer to the resulting merged edge. or NULL if nothing was merged. Details A pair of adjacent edges in a Brep are mergeable if the angle between them is less than tolerance and the valence of the shared vertex is 2.

◆ RhinoMergeBrepCoplanarFaces()

RHINO_SDK_FUNCTION bool RhinoMergeBrepCoplanarFaces	(	ON_Brep *	brep,
		double	tolerance = `ON_UNSET_VALUE`
	)

Description: Merges adjacent coplanar faces into single faces. Parameters: brep - [in/out] The Brep. tolerance - [in] 3d tolerance for determining when edges are adjacent. If <= 0, then the current document tolerance is used. Returns: True if faces were merged. False if no faces were merged. Notes: This function will be deprecated in Rhino 7. Use RhinoMergeCoplanarFaces instead

◆ RhinoMergeBreps()

RHINO_SDK_FUNCTION bool RhinoMergeBreps	(	const ON_SimpleArray< const ON_Brep * > &	InBreps,
		double	tolerance,
		ON_Brep &	MergedBrep
	)

Description: Combines two or more Breps into one. Parameters: InBreps - [in] the Breps to merge. tolerance - [in] the tolerance to use when merging. MergedBrep - [out] the resulting Brep. Returns: true if success. false if unsuccessful. Notes: Faces are split by intersection curves.

◆ RhinoMergeCoplanarFaces() [1/4]

RHINO_SDK_FUNCTION bool RhinoMergeCoplanarFaces	(	ON_Brep *	brep,
		double	tolerance = `ON_UNSET_VALUE`,
		double	angle_tolerance = `ON_UNSET_VALUE`
	)

Description: Merges adjacent coplanar faces into single faces. Parameters: brep - [in/out] The Brep. tolerance - [in] 3d tolerance for determining when edges are adjacent. If <= 0, then the current document tolerance is used. angle_tolerance - [in] 3d angle tolerance for determining when faces are parallel. If <= 0, then the current document angle tolerance is used. Returns: true if faces were merged, false if no faces were merged.

◆ RhinoMergeCoplanarFaces() [2/4]

RHINO_SDK_FUNCTION bool RhinoMergeCoplanarFaces	(	ON_Geometry *	geometry,
		double	tolerance,
		double	angle_tolerance
	)

Description: Merges adjacent coplanar faces into single faces. Parameters: geometry - [in/out] Geometry to modify. Breps, SubDs or meshes. tolerance - [in] 3d tolerance for determining when edges are adjacent. If in doubt, use document tolerance. angle_tolerance - [in] 3d angle tolerance for determining when faces are parallel. If in doubt, use current document angle tolerance. Returns: true if faces were merged, false if no faces were merged.

◆ RhinoMergeCoplanarFaces() [3/4]

RHINO_SDK_FUNCTION bool RhinoMergeCoplanarFaces	(	ON_Geometry *	geometry,
		ON_COMPONENT_INDEX	face_index,
		double	tolerance,
		double	angle_tolerance
	)

Description: Merges coplanar faces adjacent to index into a single face. Parameters: geometry - [in/out] Geometry to modify. Breps, SubDs or meshes. face_index - [in] face index to use as the input (use overload that doesn't have this argument to merge all applicable faces of the entire object) tolerance - [in] 3d tolerance for determining when edges are adjacent. If in doubt, use document tolerance. angle_tolerance - [in] 3d angle tolerance for determining when faces are parallel. If in doubt, use current document angle tolerance. Returns: true if faces were merged, false if no faces were merged.

◆ RhinoMergeCoplanarFaces() [4/4]

RHINO_SDK_FUNCTION bool RhinoMergeCoplanarFaces	(	ON_Geometry *	geometry,
		ON_COMPONENT_INDEX	face_index1,
		ON_COMPONENT_INDEX	face_index2,
		double	tolerance = `ON_UNSET_VALUE`,
		double	angle_tolerance = `ON_UNSET_VALUE`
	)

Description: Merges 2 coplanar, adjacent faces into a single face. Parameters: geometry - [in/out] Geometry to modify. Breps, SubDs or meshes. face_index1 - [in] first face index face_index2 - [in] second face index tolerance - [in] 3d tolerance for determining when edges are adjacent. If in doubt, use document tolerance. angle_tolerance - [in] 3d angle tolerance for determining when faces are parallel. If in doubt, use current document angle tolerance. Returns: true if faces were merged, false if no faces were merged.

◆ RhinoMergeCurves()

RHINO_SDK_FUNCTION BOOL32 RhinoMergeCurves	(	ON_SimpleArray< const ON_Curve * > &	input_curves,
		ON_SimpleArray< ON_Curve * > &	output,
		double	join_tol = `0.0`,
		BOOL32	bPreserveDir = `FALSE`,
		ON_SimpleArray< int > *	key = `nullptr`
	)

Description: Join a bunch of ON_Curves into one or more ON_Curves Parameters: input_curves [in] Array of pointers to ON_Curves to be joined output [out] Array of pointers to joined results join_tol [in] max distance between endpoints to be joined. If join_tol < ON_EPSILON, use CRhinoDoc::AbsoluteTolerance() bPreserveDir [in] if TRUE, don't reverse input curves to get them to join key [out] if non-null, curves[i] is part of output[key[i]] WARNING - key[i] may be -1 for some i, in particular if curves[i] is extremely short, key[i] will be -1 and curves[i] will not contribute to the joined results. Returns: @untitled table TRUE Success False Failure Remarks: Join as many of the input curves as have matching endpoints. If the input curve is a NURBS curve or a line, the endpoints within the specified tolerance are trued up to meet exactly. All of the input curves are copied and the caller must free the results. When curves are joined they are made into polycurves. Memory for the curves is allocated and becomes the responsibility of the caller.

◆ RhinoMergeSrf()

RHINO_SDK_FUNCTION ON_Brep* RhinoMergeSrf	(	const ON_Brep *	in_brep0,
		const ON_Brep *	in_brep1,
		double	tolerance,
		double	angtolrads,
		const ON_2dPoint *	pick_point0 = `nullptr`,
		const ON_2dPoint *	pick_point1 = `nullptr`,
		double	roundness = `1.0`,
		bool	smooth = `true`
	)

Description: Merges two surfaces into one surface at untrimmed edges. Both surfaces must be untrimmed and share an edge. Parameters: in_brep0 - [in] The first single-face Brep to merge. in_brep1 - [in] The second single-face Brep to merge. tolerance - [in] Surface edges must be within this tolerance for the two surfaces to merge. angtolrads - [in] Edge must be within this angle tolerance in order for contiguous edges to be combined into a single edge. pick_point0 - [in] 2-D pick point on the first single-face Brep (optional). pick_point1 - [in] 2-D pick point on the second single-face Brep (optional). roundness - [in] Defines the roundness of the merge. The default is 1.0 (full smoothing). Acceptable values are between 0.0 (sharp) and 1.0 (smooth). smooth - [in] The surface will be smooth. This makes the surface behave better for control point editing, but may alter the shape of both surfaces. Returns: The merged Brep is successful, 0 if not successful. Remarks: THE CALLER IS RESPONSIBLE FOR DESTROYING THE RETURNED BREP.

◆ RhinoMeshBooleanDifference() [1/2]

RHINO_SDK_FUNCTION bool RhinoMeshBooleanDifference	(	const ON_SimpleArray< const ON_Mesh * > &	InMeshes0,
		const ON_SimpleArray< const ON_Mesh * > &	InMeshes1,
		double	Intersection_Tolerance,
		double	Overlap_Tolerance,
		bool *	something_happened,
		ON_SimpleArray< ON_Mesh * > &	OutMeshes,
		const ON_SimpleArray< const ON_3dmObjectAttributes * > *	InputAttributeArray,
		ON_SimpleArray< const ON_3dmObjectAttributes * > *	OuputAttributeArray,
		CRhinoMeshBooleanOptions *	options
	)

◆ RhinoMeshBooleanDifference() [2/2]

RHINO_SDK_FUNCTION bool RhinoMeshBooleanDifference	(	const ON_SimpleArray< const ON_Mesh * > &	InMeshes0,
		const ON_SimpleArray< const ON_Mesh * > &	InMeshes1,
		double	Intersection_Tolerance,
		double	Overlap_Tolerance,
		bool *	something_happened,
		ON_SimpleArray< ON_Mesh * > &	OutMeshes,
		const ON_SimpleArray< const ON_3dmObjectAttributes * > *	InputAttributeArray = `0`,
		ON_SimpleArray< const ON_3dmObjectAttributes * > *	OuputAttributeArray = `0`
	)

Description: RhinoMeshBooleanDifference subtracts the meshes in InMeshes1 from InMeshes0. Meshes from InMeshes1 are unioned together first and the result is differenced with each mesh in InMeshes0. If the attribute arrays are non null then the attributes for InMeshes0 will be used.

Parameters: InMeshes0 - [In] Meshes to be from which to have InMeshes1 subtracted InMeshes1 - [In] Meshes to subtract from InMeshes0 Intersection_Tolerance - [In] General tolerance to be used in mesh-mesh intersection
Overlap_Tolerance - [In] Tolerance used to determine overlaps in mesh-mesh intersection something_happened - [Out] Set to true if something actually happened, independent of function return OutMeshes - [Out] Result of the difference of the input meshes InputAttributeArray - [In] Optional array of attributes. Must be not be null and have count equal to InMeshes to be used. OuputAttributeArray - [Out] Optional array of attributes. Must be not be null to be used.

Returns: True or false based on whether the function was able to complete successfully. It does not indicate whether the function actually unioned the input meshes. The argument, something_happened, is used for that purpose.

See Also: RhinoMeshBooleanIntersection, RhinoMeshBooleanUnion, RhinoMeshBooleanSplit

◆ RhinoMeshBooleanIntersection() [1/2]

RHINO_SDK_FUNCTION bool RhinoMeshBooleanIntersection	(	const ON_SimpleArray< const ON_Mesh * > &	InMeshes0,
		const ON_SimpleArray< const ON_Mesh * > &	InMeshes1,
		double	Intersection_Tolerance,
		double	Overlap_Tolerance,
		bool *	something_happened,
		ON_SimpleArray< ON_Mesh * > &	OutMeshes,
		const ON_SimpleArray< const ON_3dmObjectAttributes * > *	InputAttributeArray,
		ON_SimpleArray< const ON_3dmObjectAttributes * > *	OuputAttributeArray,
		CRhinoMeshBooleanOptions *	options
	)

◆ RhinoMeshBooleanIntersection() [2/2]

RHINO_SDK_FUNCTION bool RhinoMeshBooleanIntersection	(	const ON_SimpleArray< const ON_Mesh * > &	InMeshes0,
		const ON_SimpleArray< const ON_Mesh * > &	InMeshes1,
		double	Intersection_Tolerance,
		double	Overlap_Tolerance,
		bool *	something_happened,
		ON_SimpleArray< ON_Mesh * > &	OutMeshes,
		const ON_SimpleArray< const ON_3dmObjectAttributes * > *	InputAttributeArray = `0`,
		ON_SimpleArray< const ON_3dmObjectAttributes * > *	OuputAttributeArray = `0`
	)

Description: RhinoMeshBooleanIntersection intersects the meshes in InMeshes0 with InMeshes1. Meshes from InMeshes0 and InMeshes1 are unioned together first and the results are intersected. If the attribute arrays are non null then the attributes for InMeshes0 will be used.

Parameters: InMeshes0 - [In] First input mesh set InMeshes1 - [In] Second input mesh set Intersection_Tolerance - [In] General tolerance to be used in mesh-mesh intersection
Overlap_Tolerance - [In] Tolerance used to determine overlaps in mesh-mesh intersection something_happened - [Out] Set to true if something actually happened, independent of function return OutMeshes - [Out] Result of the intersection of the input meshes InputAttributeArray - [In] Optional array of attributes. Must be not be null and have count equal to InMeshes to be used. OuputAttributeArray - [Out] Optional array of attributes. Must be not be null to be used.

Returns: True or false based on whether the function was able to complete successfully. It does not indicate whether the function actually unioned the input meshes. The argument, something_happened, is used for that purpose.

See Also: RhinoMeshBooleanDifference, RhinoMeshBooleanUnion, RhinoMeshBooleanSplit

◆ RhinoMeshBooleanSplit() [1/2]

RHINO_SDK_FUNCTION bool RhinoMeshBooleanSplit	(	const ON_SimpleArray< const ON_Mesh * > &	MeshesToSplit,
		const ON_SimpleArray< const ON_Mesh * > &	MeshSplitters,
		double	Intersection_Tolerance,
		double	Overlap_Tolerance,
		bool *	something_happened,
		ON_SimpleArray< ON_Mesh * > &	OutMeshes,
		bool	bMakeBooleanSplits,
		const ON_SimpleArray< const ON_3dmObjectAttributes * > *	InputAttributeArray,
		ON_SimpleArray< const ON_3dmObjectAttributes * > *	OuputAttributeArray,
		CRhinoMeshBooleanOptions *	options
	)

◆ RhinoMeshBooleanSplit() [2/2]

RHINO_SDK_FUNCTION bool RhinoMeshBooleanSplit	(	const ON_SimpleArray< const ON_Mesh * > &	MeshesToSplit,
		const ON_SimpleArray< const ON_Mesh * > &	MeshSplitters,
		double	Intersection_Tolerance,
		double	Overlap_Tolerance,
		bool *	something_happened,
		ON_SimpleArray< ON_Mesh * > &	OutMeshes,
		bool	bMakeBooleanSplits = `true`,
		const ON_SimpleArray< const ON_3dmObjectAttributes * > *	InputAttributeArray = `0`,
		ON_SimpleArray< const ON_3dmObjectAttributes * > *	OuputAttributeArray = `0`
	)

Description: RhinoMeshBooleanSplit "splits" the meshes in MeshesToSplit with MeshSplitters. That is, each mesh in MeshesToSplit is split with every mesh in MeshSplitters and for every subsequent splitter mesh all of the previous results ar split.
If the attribute arrays are non null then the attributes for MeshesToSplit will be used.

Parameters: MeshesToSplit - [In] Meshes to be split MeshSplitters - [In] Meshes to split with Intersection_Tolerance - [In] General tolerance to be used in mesh-mesh intersection
Overlap_Tolerance - [In] Tolerance used to determine overlaps in mesh-mesh intersection something_happened - [Out] Set to true if something actually happened, independent of function return OutMeshes - [Out] Result of the split of the input meshes InputAttributeArray - [In] Optional array of attributes. Must be not be null and have count equal to InMeshes to be used. OuputAttributeArray - [Out] Optional array of attributes. Must be not be null to be used.

Returns: True or false based on whether the function was able to complete successfully. It does not indicate whether the function actually unioned the input meshes. The argument, something_happened, is used for that purpose.

See Also: RhinoMeshBooleanDifference, RhinoMeshBooleanUnion, RhinoMeshBooleanIntersection

◆ RhinoMeshBooleanUnion() [1/2]

RHINO_SDK_FUNCTION bool RhinoMeshBooleanUnion	(	const ON_SimpleArray< const ON_Mesh * > &	InMeshes,
		double	Intersection_Tolerance,
		double	Overlap_Tolerance,
		bool *	something_happened,
		ON_SimpleArray< ON_Mesh * > &	OutMeshes,
		const ON_SimpleArray< const ON_3dmObjectAttributes * > *	InputAttributeArray,
		ON_SimpleArray< const ON_3dmObjectAttributes * > *	OuputAttributeArray,
		CRhinoMeshBooleanOptions *	options
	)

◆ RhinoMeshBooleanUnion() [2/2]

RHINO_SDK_FUNCTION bool RhinoMeshBooleanUnion	(	const ON_SimpleArray< const ON_Mesh * > &	InMeshes,
		double	Intersection_Tolerance,
		double	Overlap_Tolerance,
		bool *	something_happened,
		ON_SimpleArray< ON_Mesh * > &	OutMeshes,
		const ON_SimpleArray< const ON_3dmObjectAttributes * > *	InputAttributeArray = `0`,
		ON_SimpleArray< const ON_3dmObjectAttributes * > *	OuputAttributeArray = `0`
	)

Description: RhinoMeshBooleanUnion Finds the union of the meshes in InMeshes. If the attribute arrays are non null then the first attribute of each union will be used.

Parameters: InMeshes - [In] Meshes to be unioned Intersection_Tolerance - [In] General tolerance to be used in mesh-mesh intersection
Overlap_Tolerance - [In] Tolerance used to determine overlaps in mesh-mesh intersection something_happened - [Out] Set to true if something actually happened, independent of function return OutMeshes - [Out] Result of the union of the input meshes InputAttributeArray - [In] Optional array of attributes. Must be not be null and have count equal to InMeshes to be used. OuputAttributeArray - [Out] Optional array of attributes. Must be not be null to be used.

Returns: True or false based on whether the function was able to complete successfully. It does not indicate whether the function actually unioned the input meshes. The argument, something_happened, is used for that purpose.

See Also: RhionMeshBooleanIntersection, RhinoMeshBooleanDifference, RhinoMeshBooleanSplit

◆ RhinoMeshBox() [1/2]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshBox	(	ON_3dPoint	box_corners[8],
		const CRhinoMeshDensity &	md
	)

Description: Get a 3d box Parameters: args - [in] controls how the box is picked, prompts, etc. box_corners - [out] corners of the box.

     7______________6
     |\             |\
     | \            | \
     |  \ _____________\
     |   4          |   5
     |   |          |   |
     |   |          |   |
     3---|----------2   |
     \   |          \   |
      \  |           \  |
       \ |            \ |
        \0_____________\1

◆ RhinoMeshBox() [2/2]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshBox	(	ON_3dPoint	box_corners[8],
		int	X,
		int	Y,
		int	Z
	)

◆ RhinoMeshCone() [1/5]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCone	(	const ON_Cone &	cone,
		const CRhinoMeshDensity &	mesh_density
	)

Description: Create a mesh cone.

◆ RhinoMeshCone() [2/5]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCone	(	const ON_Cone &	cone,
		const CRhinoMeshDensity &	mesh_density,
		bool	bQuadCaps
	)

Remarks: bQuadCaps is ignored if around is not an even number.

◆ RhinoMeshCone() [3/5]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCone	(	const ON_Cone &	cone,
		int	vertical,
		int	around
	)

◆ RhinoMeshCone() [4/5]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCone	(	const ON_Cone &	cone,
		int	vertical,
		int	around,
		bool	bSolid
	)

Description: Create a mesh Cone. Parameters: cone - [in] vertical - [in] around - [in] bSolid - [in] If bSolid is false the mesh will be open with no faces on the circular planar portion.

◆ RhinoMeshCone() [5/5]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCone	(	const ON_Cone &	cone,
		int	vertical,
		int	around,
		bool	bSolid,
		bool	bQuadCaps
	)

Remarks: bQuadCaps is ignored if around is not an even number.

◆ RhinoMeshCylinder() [1/6]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCylinder	(	const ON_Cylinder &	cylinder,
		const CRhinoMeshDensity &	mesh_density
	)

Description: Create a mesh sphere.

◆ RhinoMeshCylinder() [2/6]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCylinder	(	const ON_Cylinder &	cylinder,
		const CRhinoMeshDensity &	mesh_density,
		bool	bQuadCaps
	)

Remarks: bQuadCaps is ignored if around is not an even number.

◆ RhinoMeshCylinder() [3/6]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCylinder	(	const ON_Cylinder &	cylinder,
		const CRhinoMeshDensity &	mesh_density,
		bool	CapTop,
		bool	CapBottom,
		bool	bCircumscribe,
		bool	bQuadCaps
	)

Remarks: bQuadCaps is ignored if around is not an even number.

◆ RhinoMeshCylinder() [4/6]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCylinder	(	const ON_Cylinder &	cylinder,
		int	vertical,
		int	around
	)

◆ RhinoMeshCylinder() [5/6]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCylinder	(	const ON_Cylinder &	cylinder,
		int	vertical,
		int	around,
		bool	bQuadCaps
	)

Remarks: bQuadCaps is ignored if around is not an even number.

◆ RhinoMeshCylinder() [6/6]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshCylinder	(	const ON_Cylinder &	cylinder,
		int	vertical,
		int	around,
		bool	CapTop,
		bool	CapBottom,
		bool	bCircumscribe,
		bool	bQuadCaps
	)

◆ RhinoMeshEllipsoid() [1/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshEllipsoid	(	const ON_Surface *	pSrf,
		const CRhinoMeshDensity &	md
	)

◆ RhinoMeshEllipsoid() [2/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshEllipsoid	(	const ON_Surface *	pSrf,
		const CRhinoMeshDensity &	md,
		const bool	bQuadCaps
	)

◆ RhinoMeshEllipsoid() [3/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshEllipsoid	(	const ON_Surface *	pSrf,
		int	vertical,
		int	around
	)

◆ RhinoMeshEllipsoid() [4/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshEllipsoid	(	const ON_Surface *	pSrf,
		int	vertical,
		int	around,
		const bool	bQuadCaps
	)

◆ RhinoMeshFace()

RHINO_SDK_FUNCTION bool RhinoMeshFace	(	ON_Mesh &	mesh,
		const ON_SimpleArray< ON_3dPoint > &	points
	)

Description: Create a mesh face from 3 or 4 points.

◆ RhinoMeshIcoSphere()

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshIcoSphere	(	const ON_Sphere &	sphere,
		int	subdivisions
	)

Description: Creates a icospherical mesh. A mesh icosphere differs from a standard UV mesh sphere in that it's vertices are evenly distributed. A mesh icosphere starts from an icosahedron (a regular polyhedron with 20 equilateral triangles). It is then refined by splitting each triangle into 4 smaller triangles. This splitting can be done several times. Parameters: sphere - [in] The input sphere provides the orienting plane and radius. subdivisions - [in] The number of times you want the faces split, where 0 <= subdivisions <= 7. Note, the total number of mesh faces produces is: 20 * (4 ^ subdivisions) Returns: A pointer to a welded mesh icosphere if successful, or nullptr on failure. Remarks: NOTE: Memory for the mesh is allocated and becomes the responsibility of the caller.

◆ RhinoMeshObjects() [1/6]

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoMeshObjects	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_MeshParameters &	mp,
		class CRhinoMeshObjectsUI &	ui,
		ON_ClassArray< CRhinoObjectMesh > &	meshes
	)

Description: Mesh Rhino objects.

Parameters: objects - [in] objects to mesh

mp - [in/out] meshing parameters. The meshing parameters may change. The parameters used to create the meshes are returned.

ui - [in] Defines a custom ui for setting meshing parameters.

meshes - [out] the created meshes are appended to this array. If an input object is a CRhinoBrepObject, then there will be one mesh in the output list for that brep. If an input object is a CRhinoInstanceObject, then there will be one object in the list for each piece of instance definition geometry that can be meshed. If an input object is not a brep and not an instance reference that has meshable parts, then nothing is added to the output list. Remarks: If you want to create meshes using the UI that is found in the Rhino Mesh command, then you can use the version of RhinoMeshObjects() that takes an int instead of a CRhinoMeshObjectsUI.

Returns: @untitled table CRhinoCommand::success meshes created CRhinoCommand::cancel user canceled meshing CRhinoCommand::exit_rhino user closed Rhino CRhinoCommand::failure unable to create meshes

◆ RhinoMeshObjects() [2/6]

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoMeshObjects	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_MeshParameters &	mp,
		const ON_Xform &	xform,
		class CRhinoMeshObjectsUI &	ui,
		ON_ClassArray< CRhinoObjectMesh > &	meshes
	)

Description: Mesh Rhino objects.

Parameters: objects - [in] objects to mesh

mp - [in/out] meshing parameters. The meshing parameters may change. The parameters used to create the meshes are returned.

xform - [in] If xform is valid, not zero and not the identity, then the transformation is applied to all the returned meshes.

ui - [in] Defines a custom ui for setting meshing parameters.

meshes - [out] the created meshes are appended to this array. If an input object is a CRhinoBrepObject, then there will be one mesh in the output list for that brep. If an input object is a CRhinoInstanceObject, then there will be one object in the list for each piece of instance definition geometry that can be meshed. If an input object is not a brep and not an instance reference that has meshable parts, then nothing is added to the output list. Remarks: If you want to create meshes using the UI that is found in the Rhino Mesh command, then you can use the version of RhinoMeshObjects() that takes an int instead of a CRhinoMeshObjectsUI.

Returns: @untitled table CRhinoCommand::success meshes created CRhinoCommand::cancel user canceled meshing CRhinoCommand::exit_rhino user closed Rhino CRhinoCommand::failure unable to create meshes

◆ RhinoMeshObjects() [3/6]

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoMeshObjects	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_MeshParameters &	mp,
		const ON_Xform &	xform,
		class CRhinoMeshObjectsUI &	ui,
		ON_ClassArray< CRhinoObjectMesh > &	meshes,
		bool	bUseWorkerThread
	)

◆ RhinoMeshObjects() [4/6]

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoMeshObjects	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_MeshParameters &	mp,
		const ON_Xform &	xform,
		int &	ui_style,
		ON_ClassArray< CRhinoObjectMesh > &	meshes
	)

Description: Mesh Rhino objects. Parameters: objects - [in] objects to mesh

mp - [in/out] meshing parameters. The meshing parameters may change. The parameters used to create the meshes are returned.

xform - [in] If xform is valid, not zero and not the identity, then the transformation is applied to all the returned meshes.

ui_style - [in/out] 0 = simple dialog 1 = details dialog 2 = script or batch mode If the input value is 0 or 1, the user can switch to the other dialog and the style of dialog that was used is returned.

meshes - [out] the created meshes are appended to this array. If an input object is a CRhinoBrepObject, then there will be one mesh in the output list for that brep. If an input object is a CRhinoInstanceObject, then there will be one object in the list for each piece of instance definition geometry that can be meshed. If an input object is not a brep and not an instance reference that has meshable parts, then nothing is added to the output list. Returns: @untitled table CRhinoCommand::success meshes created CRhinoCommand::cancel user canceled meshing CRhinoCommand::exit_rhino user closed Rhino CRhinoCommand::failure unable to create meshes

◆ RhinoMeshObjects() [5/6]

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoMeshObjects	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_MeshParameters &	mp,
		const ON_Xform &	xform,
		int &	ui_style,
		ON_ClassArray< CRhinoObjectMesh > &	meshes,
		bool	bUseWorkerThread
	)

◆ RhinoMeshObjects() [6/6]

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoMeshObjects	(	const ON_SimpleArray< const CRhinoObject * > &	objects,
		ON_MeshParameters &	mp,
		int &	ui_style,
		ON_ClassArray< CRhinoObjectMesh > &	meshes
	)

Description: Mesh Rhino objects. Parameters: objects - [in] objects to mesh

mp - [in/out] meshing parameters. The meshing parameters may change. The parameters used to create the meshes are returned.

ui_style - [in/out] 0 = simple dialog 1 = details dialog 2 = script or batch mode If the input value is 0 or 1, the user can switch to the other dialog and the style of dialog that was used is returned.

meshes - [out] the created meshes are appended to this array. If an input object is a CRhinoBrepObject, then there will be one mesh in the output list for that brep. If an input object is a CRhinoInstanceObject, then there will be one object in the list for each piece of instance definition geometry that can be meshed. If an input object is not a brep and not an instance reference that has meshable parts, then nothing is added to the output list. Returns: @untitled table CRhinoCommand::success meshes created CRhinoCommand::cancel user canceled meshing CRhinoCommand::exit_rhino user closed Rhino CRhinoCommand::failure unable to create meshes

◆ RhinoMeshOffset() [1/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshOffset	(	double	d,
		const ON_Mesh *	pMesh
	)

Description: Makes a new mesh with vertices offset at distance d in the opposite direction of the existing vertex normals.

Parameters: d - Input offset distance. pMesh - Input mesh. Returns: Returns a ON_Mesh pointer on success. Returns null on failure.

◆ RhinoMeshOffset() [2/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshOffset	(	double	d,
		const ON_Mesh *	pMesh,
		bool	bSolidify
	)

Description: Makes a new mesh with vertices offset at distance d in the opposite direction of the existing vertex normals. Optionally, based on the value of bSolidify, adds the input mesh and a ribbon of faces along anhy naked edges. If bSolidy if false it acts exactly as the function above.

Essentially this function calls the function above to get an offset output mesh and then the function below to create the ribbon mesh and combine the input, ribbon and output into a single output.

Parameters: d - Input offset distance. pMesh - Input mesh. bSolidify - Input bool to determine whether the output mesh should be turned into a closed mesh, see description above. Returns: Returns a ON_Mesh pointer on success. Returns null on failure.

◆ RhinoMeshOffset() [3/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshOffset	(	double	d,
		const ON_Mesh *	pMesh,
		bool	bSolidify,
		const ON_3dVector &	direction
	)

Description: Makes a new mesh with vertices offset at distance d along the direction vector parameter. Optionally, based on the value of bSolidify, adds the input mesh and a ribbon of faces along any naked edges. If direction is ON_3dVector::UnsetVector it acts exactly as the function above.

Parameters: d - Input offset distance. pMesh - Input mesh. bSolidify - Input bool to determine whether the output mesh should be turned into a closed mesh, see description above. direction - Input vector for offset direction for all vertices or ON_3dVector::UnsetVector to use vertex normals. Returns: Returns a ON_Mesh pointer on success. Returns null on failure.

◆ RhinoMeshOffset() [4/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshOffset	(	double	d,
		const ON_Mesh *	pMesh,
		bool	bSolidify,
		const ON_3dVector &	direction,
		ON_SimpleArray< int > *	pWallFacesOut
	)

Description: Makes a new mesh with vertices offset at distance d along the direction vector parameter. Optionally, based on the value of bSolidify, adds the input mesh and a ribbon of faces along any naked edges. If direction is ON_3dVector::UnsetVector it acts exactly as the function above. Optionally returns list of wall faces, i.e. the faces that connect original and offset mesh when solidified.

Parameters: d - Input offset distance. pMesh - Input mesh. bSolidify - Input bool to determine whether the output mesh should be turned into a closed mesh, see description above. direction - Input vector for offset direction for all vertices or ON_3dVector::UnsetVector to use vertex normals. pWallFacesOut - If not null then gets filled with indices of the wall faces Returns: Returns a ON_Mesh pointer on success. Returns null on failure.

◆ RhinoMeshPipeFromCurve()

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshPipeFromCurve	(	const ON_Curve &	curve,
		const RhMeshPipeArgs &	args,
		ON_Terminator *	pCancelHandler = `0`
	)

Description: Create a mesh pipe from a curve. Parameters: curve - [in] The curve to create a mesh pipe from. args - [in] The arguments used to create the mesh pipe. pCancelHandler - [in] Pass an ON_Terminator to provide ability to cancel the operation, use NULL otherwise. Returns: The created mesh pipe. NULL if failed or canceled. See Also: RhinoDisplaceMesh, RhinoEdgeSoftenMesh, RhinoAddShutLinesToMesh summary>Enumerates sweep resolution formulas DEPRECATED – This is now a duplicate of ON_Displacement::SweepResolutionFormulas.

◆ RhinoMeshPlane() [1/2]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshPlane	(	const ON_Plane &	plane,
		ON_Interval	x_interval,
		ON_Interval	y_interval,
		const CRhinoMeshDensity &	mesh_density
	)

Description: Create a mesh plane. Parameters: plane - [in] x_interval - [in] y_interval - [in] Returns: A mesh of the rectangle with corners plane.PointAt(x_interval[0],x_interval[0]), plane.PointAt(x_interval[1],x_interval[1]). The number of quads is determined by md.

◆ RhinoMeshPlane() [2/2]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshPlane	(	const ON_Plane &	plane,
		ON_Interval	x_interval,
		ON_Interval	y_interval,
		int	X,
		int	Y
	)

Description: Create a mesh plane. Parameters: plane - [in] x_interval - [in] y_interval - [in] X number of faces in X direction - [in] Y number of faces in Y direction - [in] Returns: A mesh of the rectangle with corners plane.PointAt(x_interval[0],x_interval[0]), plane.PointAt(x_interval[1],x_interval[1]). The number of quads is determined by md.

◆ RhinoMeshQuadSphere()

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshQuadSphere	(	const ON_Sphere &	sphere,
		int	subdivisions
	)

Description: Creates a quad mesh sphere. A quad mesh sphere differs from a standard UV mesh sphere in that it's vertices are evenly distributed. A quad mesh sphere starts from an cube (a regular polyhedron with 6 faces). It is then refined by splitting each quad into 4 smaller quads. This splitting can be done several times. Parameters: sphere - [in] The input sphere provides the orienting plane and radius. subdivisions - [in] The number of times you want the faces split, where 0 <= subdivisions <= 8. Note, the total number of mesh faces produces is: 6 * (4 ^ subdivisions) Returns: A pointer to a welded quad mesh sphere if successful, or nullptr on failure. Remarks: NOTE: Memory for the mesh is allocated and becomes the responsibility of the caller.

◆ RhinoMeshSphere() [1/2]

RHINO_SDK_FUNCTION ON_Mesh * RhinoMeshSphere	(	const ON_Sphere &	sphere,
		const CRhinoMeshDensity &	mesh_density
	)

Description: Create a mesh sphere.

◆ RhinoMeshSphere() [2/2]

RHINO_SDK_FUNCTION ON_Mesh * RhinoMeshSphere	(	const ON_Sphere &	sphere,
		int	vertical,
		int	around
	)

◆ RhinoMeshSubdivide()

RHINO_SDK_FUNCTION bool RhinoMeshSubdivide	(	const ON_Mesh &	inMesh,
		ON_Mesh &	outMesh
	)

Subdivides the faces of a mesh.

◆ RhinoMeshSubdivideFaces()

RHINO_SDK_FUNCTION bool RhinoMeshSubdivideFaces	(	const ON_Mesh &	inMesh,
		const ON_SimpleArray< ON_COMPONENT_INDEX >	face_list,
		ON_Mesh &	outMesh
	)

Subdivides specific faces of a mesh.

◆ RhinoMeshTCone() [1/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshTCone	(	const ON_Brep &	TCone,
		const CRhinoMeshDensity &	md
	)

Description: Create a mesh truncated cone.

◆ RhinoMeshTCone() [2/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshTCone	(	const ON_Brep &	TCone,
		const CRhinoMeshDensity &	md,
		bool	bQuadCaps
	)

◆ RhinoMeshTCone() [3/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshTCone	(	const ON_Brep &	TCone,
		int	vertical,
		int	around
	)

◆ RhinoMeshTCone() [4/4]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshTCone	(	const ON_Brep &	TCone,
		int	vertical,
		int	around,
		bool	bQuadCaps
	)

Remarks: bQuadCaps is ignored if around is not an even number.

◆ RhinoMeshTorus() [1/2]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshTorus	(	const ON_RevSurface *	torus,
		const CRhinoMeshDensity &	md
	)

◆ RhinoMeshTorus() [2/2]

RHINO_SDK_FUNCTION ON_Mesh* RhinoMeshTorus	(	const ON_RevSurface *	torus,
		int	vertical,
		int	around
	)

◆ RhinoMessageBox() [1/4]

RHINO_SDK_FUNCTION int RhinoMessageBox	(	const char *	message,
		const char *	title,
		UINT	type
	)

Parameters

message	The main application window is used as HWND text in message box
title	title of message box
type	style of message box

◆ RhinoMessageBox() [2/4]

RHINO_SDK_FUNCTION int RhinoMessageBox	(	const wchar_t *	message,
		const wchar_t *	title,
		UINT	type
	)

Parameters

message	The main application window is used as HWND text in message box
title	title of message box
type	style of message box

◆ RhinoMessageBox() [3/4]

RHINO_SDK_FUNCTION int RhinoMessageBox	(	HWND	hParent,
		const char *	message,
		const char *	title,
		UINT	type
	)

Parameters

message	text in message box
title	title of message box
type	style of message box

◆ RhinoMessageBox() [4/4]

RHINO_SDK_FUNCTION int RhinoMessageBox	(	HWND	hParent,
		const wchar_t *	message,
		const wchar_t *	title,
		UINT	type
	)

Parameters

message	text in message box
title	title of message box
type	style of message box

◆ RhinoNetworkSurface() [1/2]

RHINO_SDK_FUNCTION int RhinoNetworkSurface	(	const ON_SimpleArray< const ON_Curve * > &	curves,
		const int	continuity,
		ON_NurbsSurface &	surface_out,
		const double	dEdgeTol = `0.0`,
		const double	dInteriorTol = `0.0`,
		const double	dAngleTol = `0.0`
	)

Description: Builds a surface from auto-sorted network of curves/edges. Parameters: curves - [in] array of curves/edges, sorted automatically into U and V curves continuity - [in] continuity along edges, 0 = loose, 1 = position, 2 = tangent, 3 = curvature surface_out - [out] the output surface dEdgeTol - [in] tolerance to use along network surface edge dInteriorTol - [in] tolerance to use for the interior curves dAngleTol - [in] angle tolerance to use Returns: 0 = success 1 = curve sorter failed 2 = network initializing failed 3 = failed to build surface 4 = network surface is not valid

◆ RhinoNetworkSurface() [2/2]

RHINO_SDK_FUNCTION int RhinoNetworkSurface	(	const ON_SimpleArray< const ON_Curve * > &	ucurves,
		const int	ucontinuity[2],
		const ON_SimpleArray< const ON_Curve * > &	vcurves,
		const int	vcontinuity[2],
		ON_NurbsSurface &	surface_out,
		const double	dEdgeTol = `0.0`,
		const double	dInteriorTol = `0.0`,
		const double	dAngleTol = `0.0`
	)

Description: Builds a surface from ordered network of curves/edges. Parameters: ucurves - [in] array of U curves/edges ucontinuity - [in] continuity at first and last U segment, 0 = loose, 1 = position, 2 = tangent, 3 = curvature vcurves - [in] array of V curves vcontinuity - [in] continuity at first and last V segment, 0 = loose, 1 = position, 2 = tangent, 3 = curvature surface_out - [out] the output surface dEdgeTol - [in] tolerance to use along network surface edge dInteriorTol - [in] tolerance to use for the interior curves dAngleTol - [in] angle tolerance to use Returns: 0 = success 1 = curve sorter failed 2 = network initializing failed 3 = failed to build surface 4 = network surface is not valid

◆ RhinoNonRationalArcBezier()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoNonRationalArcBezier	(	int	degree,
		ON_3dPoint	ptCenter,
		ON_3dPoint	ptStart,
		ON_3dPoint	ptEnd,
		double	radius,
		double	tanSlider,
		double	midSlider
	)

Description: Creates a non-rational approximation of an arc as a single bezier segment Parameters: degree - [in] The degree of the non-rational approximation, can be either 3, 4, or 5 ptCenter - [in] The arc center ptStart - [in] A point in the direction of the start point of the arc ptEnd - [in] A point in the direction of the end point of the arc radius - [in] the radius of the arc tanSlider - [in] a number between zero and one which moves the tangent control point toward the midpoint of an equivalent rational arc midSlider - [in] a number between zero and one which moves the mid control points toward the midpoint of an equivalent rational arc Returns: A bezier approximation of a rational arc if successful, null if not

◆ RhinoNurbsCurveDirectionsAt()

RHINO_SDK_FUNCTION bool RhinoNurbsCurveDirectionsAt	(	const ON_NurbsCurve &	nc,
		double	t,
		ON_3dVector &	u_dir,
		ON_3dVector &	v_dir,
		ON_3dVector &	n_dir
	)

Description: Calculates the U, V, and N directions of a NURBS curve at a parameter similar to the method used by the MoveUVN command. Parameters: nc - [in] The NURBS curve to evaluate. t - [in] The evaluation parameter. u_dir - [out] The u direction. v_dir - [out] The v direction. n_dir - [out] The n direction. Returns: true if successful, false otherwise.

◆ RhinoNurbsCurveInterpolant()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoNurbsCurveInterpolant	(	int	degree,
		const ON_SimpleArray< ON_3dPoint > &	Pt,
		ON_3dPoint *	CV1,
		ON_3dPoint *	CVn1,
		int	knot_style = `0`,
		ON_NurbsCurve *	nurbs_curve = `nullptr`
	)

Deprecated:: use RhinoInterpCurve

◆ RhinoNurbsSurfaceDirectionsAt()

RHINO_SDK_FUNCTION bool RhinoNurbsSurfaceDirectionsAt	(	const ON_NurbsSurface &	ns,
		double	u,
		double	v,
		ON_3dVector &	u_dir,
		ON_3dVector &	v_dir,
		ON_3dVector &	n_dir
	)

Description: Calculates the U, V, and N directions of a NURBS surface at a u,v parameter similar to the method used by the MoveUVN command. Parameters: ns - [in] The NURBS surface to evaluate. u - [in] The u evaluation parameter. v - [in] The v evaluation parameter. u_dir - [out] The u direction. v_dir - [out] The v direction. n_dir - [out] The n direction. Returns: true if successful, false otherwise.

◆ RhinoObjectClippingPlaneFills()

RHINO_SDK_FUNCTION bool RhinoObjectClippingPlaneFills	(	const CRhinoObject &	obj,
		ON_SimpleArray< const CRhinoClippingPlaneObject * > &	cp,
		ON_SimpleArray< ON_Brep * > &	aBreps,
		bool	bUnclippedFills = `false`
	)

Description: Create fill breps for given CRhinoObject with given clipping planes. Parameters: obj - [in] object to be clipped cps - [in] clipping planes to use aBreps - [out] list of breps as the fill geometry, if any bUnclippedFills - [in] set to true if the fills by a clipping plane shouldn't be clipped by the other clipping planes Returns: true - fills for the object were generated false - no fills for the object were generated

◆ RhinoObjectEnableMeshParameters()

RHINO_SDK_FUNCTION bool RhinoObjectEnableMeshParameters	(	const CRhinoObject *	obj,
		bool	bEnable = `true`
	)

Description: Enables or disables an object's custom render mesh parameters. Parameters: obj - [in] A mesh-able object. bEnable - [in] true to enable, false to disable. Returns: true - the object has custom render mesh parameters. false - the object does not have custom render mesh parameters. See Also: RhinoObjectGetMeshParameters RhinoObjectSetMeshParameters RhinoObjectIsMeshParametersEnabled RhinoObjectRemoveMeshParameters Remarks: If the object has custom render mesh parameters and they are enabled, then the object's render meshes will generated based on these mesh parameters. If the object does not have custom render mesh parameters, or if the object has custom render mesh parameters but the are not enabled, then object's render meshes will be generated based on the document's mesh parameters.

◆ RhinoObjectGetMeshParameters()

RHINO_SDK_FUNCTION bool RhinoObjectGetMeshParameters	(	const CRhinoObject *	obj,
		ON_MeshParameters &	mp
	)

Description: Returns the custom render mesh parameters of an object. Parameters: obj - [in] A mesh-able object. mp - [out] The object's mesh parameters. Returns: true - the object has custom render mesh parameters. false - the object does not have custom render mesh parameters. See Also: RhinoObjectSetMeshParameters RhinoObjectIsMeshParametersEnabled RhinoObjectEnableMeshParameters RhinoObjectRemoveMeshParameters

◆ RhinoObjectIsMeshParametersEnabled()

RHINO_SDK_FUNCTION bool RhinoObjectIsMeshParametersEnabled	(	const CRhinoObject *	obj,
		bool &	bEnabled
	)

Description: Verifies that an object's custom render mesh parameters are enabled. Parameters: obj - [in] A mesh-able object. bEnabled - [out] The current enabled state, either true or false. Returns: true - the object has custom render mesh parameters. false - the object does not have custom render mesh parameters. See Also: RhinoObjectGetMeshParameters RhinoObjectSetMeshParameters RhinoObjectEnableMeshParameters RhinoObjectRemoveMeshParameters Remarks: If the object has custom render mesh parameters and they are enabled, then the object's render meshes will generated based on these mesh parameters. If the object does not have custom render mesh parameters, or if the object has custom render mesh parameters but the are not enabled, then object's render meshes will be generated based on the document's mesh parameters.

◆ RhinoObjectIsPictureFrame()

RHINO_SDK_FUNCTION bool RhinoObjectIsPictureFrame ( const CRhinoObject * rhino_object )

Description: A picture frame object is an object that displays a texture map in all views. Parameters: rhino_object - [in] Returns: True if rhino_object is a picture frame object.

◆ RhinoObjectRemoveMeshParameters()

RHINO_SDK_FUNCTION bool RhinoObjectRemoveMeshParameters ( const CRhinoObject * obj )

Description: Deletes an object's custom render mesh parameters. Parameters: obj - [in] A mesh-able object. Returns: true - the object has custom render mesh parameters and they were deleted. false - the object does not have custom render mesh parameters, or deleting failed. See Also: RhinoObjectGetMeshParameters RhinoObjectSetMeshParameters RhinoObjectIsMeshParametersEnabled RhinoObjectEnableMeshParameters

◆ RhinoObjectSetMeshParameters()

RHINO_SDK_FUNCTION bool RhinoObjectSetMeshParameters	(	const CRhinoObject *	obj,
		const ON_MeshParameters &	mp,
		bool	bEnable = `true`
	)

Description: Sets (adds or modifies) the custom render mesh parameters of an object. Parameters: obj - [in] A mesh-able object. mp - [in] The mesh parameters. bEnable - [in] Enable the custom render mesh parameters. Returns: true - successful. false - unsuccessful. See Also: RhinoObjectGetMeshParameters RhinoObjectIsMeshParametersEnabled RhinoObjectEnableMeshParameters RhinoObjectRemoveMeshParameters Remarks: If bEnable=true, then the custom mesh parameters will be assigned to the object, and the object's render meshes will generated based on these mesh parameters. If bEnable=false, then the custom mesh parameters will be assigned to the object, but the object's render meshes will still be generated based on the document's mesh parameters.

◆ RhinoOffsetBrep() [1/2]

RHINO_SDK_FUNCTION bool RhinoOffsetBrep	(	const ON_Brep &	B,
		double	distance,
		double	tolerance,
		bool	bSolid,
		bool	bExtend,
		bool	bShrinkInputSrfs,
		ON_SimpleArray< ON_Brep * > &	Offsets,
		ON_SimpleArray< ON_Brep * > &	Blends,
		ON_SimpleArray< ON_Brep * > &	Walls
	)

Description: Offsets a Brep. Parameters: brep [in] - The Brep to offset. distance [in] - The distance to offset. This is a signed distance value with respect to face normals and flipped faces. tolerance [in] - The offset tolerance. When in doubt, use the document's absolute tolerance. bSolid [in] - If true, then the function makes a closed solid from the input and offset surfaces by lofting a ruled surface between all of the matching edges. bExtend [in] - If true, then the function maintains the sharp corners when the original surfaces have sharps corner. If False, then the function creates fillets at sharp corners in the original surfaces. bShrinkInputSrfs [in] - If true, then shrink all surfaces to outer loop pboxes. Offsets [out] - The results of the calculation (see Remarks). Blends [out] - The results of the calculation (see Remarks). Walls [out] - The results of the calculation (see Remarks). Return: True if the function succeeds (see Remarks). False if the function did not succeed (see Remarks). NOTE, In either case, caller is responsible for destroying the Breps in the Offsets, Blends, and Walls arrays. Remarks: If the function succeeds in offsetting the Brep, the single result should be Offsets[0]. Otherwise, Offsets will contain the offset surfaces. Blends will contain the set of blends used to fill in gaps if bExtend is false. Walls will contain the set of wall surfaces that was supposed to join the offset to the original if bSolid is true.

◆ RhinoOffsetBrep() [2/2]

RHINO_SDK_FUNCTION bool RhinoOffsetBrep	(	const ON_Brep &	B,
		double	distance,
		double	tolerance,
		bool	bSolid,
		bool	bExtend,
		ON_SimpleArray< ON_Brep * > &	Offsets,
		ON_SimpleArray< ON_Brep * > &	Blends,
		ON_SimpleArray< ON_Brep * > &	Walls
	)

Description: Offsets a Brep. Parameters: brep [in] - The Brep to offset. distance [in] - The distance to offset. This is a signed distance value with respect to face normals and flipped faces. tolerance [in] - The offset tolerance. When in doubt, use the document's absolute tolerance. bSolid [in] - If true, then the function makes a closed solid from the input and offset surfaces by lofting a ruled surface between all of the matching edges. bExtend [in] - If true, then the function maintains the sharp corners when the original surfaces have sharps corner. If False, then the function creates fillets at sharp corners in the original surfaces. Offsets [out] - The results of the calculation (see Remarks). Blends [out] - The results of the calculation (see Remarks). Walls [out] - The results of the calculation (see Remarks). Return: True if the function succeeds (see Remarks). False if the function did not succeed (see Remarks). NOTE, In either case, caller is responsible for destroying the Breps in the Offsets, Blends, and Walls arrays. Remarks: If the function succeeds in offsetting the Brep, the single result should be Offsets[0]. Otherwise, Offsets will contain the offset surfaces. Blends will contain the set of blends used to fill in gaps if bExtend is false. Walls will contain the set of wall surfaces that was supposed to join the offset to the original if bSolid is true.

◆ RhinoOffsetCurve() [1/4]

RHINO_SDK_FUNCTION bool RhinoOffsetCurve	(	const ON_Curve &	curve,
		const ON_3dVector &	normal,
		const ON_3dPoint &	origin,
		double	distance,
		ON_SimpleArray< ON_Curve * > &	offset_curves,
		double	tolerance = `0.0`,
		double	angle_tolerance = `0.0`,
		int	corner_style = `1`
	)

Description: OBSOLETE - Use the version of RhinoOffsetCurve declared below.

Deprecated:: use other version of RhinoOffsetCurve

◆ RhinoOffsetCurve() [2/4]

RHINO_SDK_FUNCTION int RhinoOffsetCurve	(	const ON_Curve &	curve_in,
		double	distance,
		ON_3dPoint	direction_point,
		ON_3dVector	normal,
		int	corner_style,
		double	tolerance,
		double	angle_tolerance,
		bool	bLoose,
		int	end_style,
		ON_SimpleArray< ON_Curve * > &	curves_out
	)

Description: Offsets a curve. Parameters: curve_in - [in] The curve to offset. distance - [in] The distance to offset the curve. direction_point - [in] A point that indicates the direction of the offset. normal - [in] A vector that indicates the normal of the plane in which the offset will occur. corner_style - [in] The corner style, where: no_corner = 0, sharp = 1, round = 2, smooth = 3, chamfer = 4 tolerance - [in] The offset tolerance. angle_tolerance - [in] The angle tolerance in radians, used to decide whether to split at kinks. bLoose - [in] If false, offset within tolerance. If true, offset by moving edit points. end_style - [in] Closes the gap at the curve ends, where: none = 0, flat = 1, 2 = round. curves_out - [out] The offset curves. Returns: Returns number of curves that are appended to array. Remarks: The caller is responsible for deleting these curves when finished.

◆ RhinoOffsetCurve() [3/4]

RHINO_SDK_FUNCTION int RhinoOffsetCurve	(	const ON_Curve &	curve_in,
		double	distance,
		ON_3dPoint	direction_point,
		ON_3dVector	normal,
		int	corner_style,
		double	tolerance,
		double	angle_tolerance,
		ON_SimpleArray< ON_Curve * > &	curves_out
	)

Parameters

curves_out bLoose = false, end_style = 0,

◆ RhinoOffsetCurve() [4/4]

RHINO_SDK_FUNCTION int RhinoOffsetCurve	(	const ON_Curve &	curve_in,
		double	distance,
		ON_3dPoint	direction_point,
		ON_3dVector	normal,
		int	corner_style,
		double	tolerance,
		ON_SimpleArray< ON_Curve * > &	curves_out
	)

Parameters

curves_out angle_tolerance = ON_DEFAULT_ANGLE_TOLERANCE, bLoose = false, end_style = 0,

◆ RhinoOffsetCurveNormal() [1/3]

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoOffsetCurveNormal	(	const ON_Surface *	pSrf,
		const ON_NurbsCurve *	pNC,
		const ON_NurbsCurve *	pHeights
	)

Description: Finds a curve by offsetting an existing curve normal to a surface. The caller is responsible for ensuring that the input curve lies on the input surface. Parameters: pSrf [in] - Surface from which normals are calculated. pCrv [in] - 3d curve lying on the surface along which normals are calculated. pHeights [in] - offset distance (distance from surface to result curve). pHeights is a NURBS curve of dimension 1 with the same domain as pCrv. It is evaluated at points corresponding to the locations where offsets from the surface are calculated to find the height of the offset at those points. Return: ON_NurbsCurve* pointing to offset curve at distance height from the surface. Remarks: Same as the function above, but the offset height is specified by a function spline instead of a constant value. THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CURVE. See Also: RhinoMakeRadiusSpline

◆ RhinoOffsetCurveNormal() [2/3]

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoOffsetCurveNormal	(	const ON_Surface *	pSrf,
		const ON_NurbsCurve *	pNC,
		const ON_SimpleArray< double > &	spine_parameters,
		const ON_NurbsCurve *	pHeights
	)

Description: Finds a curve by offsetting an existing curve normal to a surface. The caller is responsible for ensuring that the input curve lies on the input surface. Parameters: pSrf [in] - Surface from which normals are calculated. pCrv [in] - 3d curve lying on the surface along which normals are calculated. params [in] - parameters in the domain of pCrv for offset points to interpolate pHeights [in] - offset distance (distance from surface to result curve). pHeights is a NURBS curve of dimension 1 with the same domain as pCrv. It is evaluated at points corresponding to the locations where offsets from the surface are calculated to find the height of the offset at those points. Return: ON_NurbsCurve* pointing to offset curve at distance height from the surface. Remarks: Same as the function above, but the offset point locations are specified. THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CURVE. See Also: RhinoMakeRadiusSpline

◆ RhinoOffsetCurveNormal() [3/3]

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoOffsetCurveNormal	(	const ON_Surface *	pSrf,
		const ON_NurbsCurve *	pNC,
		double	height
	)

Description: Finds a curve by offsetting an existing curve normal to a surface. The caller is responsible for ensuring that the input curve lies on the input surface. Parameters: pSrf [in] - Surface from which normals are calculated. pCrv [in] - 3d curve lying on the surface along which normals are calculated. height [in] - offset distance (distance from surface to result curve). Return: ON_NurbsCurve* pointing to offset curve at distance height from the surface. Remarks: The offset curve is interpolated through a small number of points so if the surface is irregular or complicated, the result will not be a very accurate offset. THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CURVE.

◆ RhinoOffsetCurveOnSrf() [1/3]

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoOffsetCurveOnSrf	(	const ON_Curve *	p3dCrv,
		const ON_Brep *	pBrep,
		int	fid,
		double	distance,
		double	tol,
		ON_SimpleArray< ON_Curve * > &	result_curves
	)

NoKeywords

/ / Copyright (c) 1993-2007 Robert McNeel & Associates. All rights reserved. / Rhinoceros is a registered trademark of Robert McNeel & Associates. / / THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. / ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF / MERCHANTABILITY ARE HEREBY DISCLAIMED. /
/ For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. / ////////////////////////////////////////////////////////////// Description: Offset a curve on a surface.
The source curve must lie on the surface. Parameters: p3dCurve [in] - the curve to offset pBrep [in] - brep on which to offset the curve fid [in] - index of the face in the brep distance [in] - distance to offset +: left, -: right tol [in] - fitting tolerance result_curves [out] - results of the offset

◆ RhinoOffsetCurveOnSrf() [2/3]

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoOffsetCurveOnSrf	(	const ON_Curve *	p3dCrv,
		const ON_Brep *	pBrep,
		int	fid,
		ON_2dPoint	through_point,
		double	tol,
		ON_SimpleArray< ON_Curve * > &	result_curves
	)

Description: Offset a curve on a surface.
The source curve must lie on the surface. Parameters: p3dCurve [in] - the curve to offset pBrep [in] - brep on which to offset the curve fid [in] - index of the face in the brep through_point [in] - 2d point on the brep face to offset through tol [in] - fitting tolerance result_curves [out] - results of the offset

◆ RhinoOffsetCurveOnSrf() [3/3]

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoOffsetCurveOnSrf	(	const ON_Curve *	p3dCrv,
		const ON_Brep *	pBrep,
		int	fid,
		ON_SimpleArray< double > &	params,
		ON_SimpleArray< double > &	dists,
		double	tol,
		ON_SimpleArray< ON_Curve * > &	result_curves
	)

Description: Offset a curve on a surface.
The source curve must lie on the surface. Parameters: p3dCurve [in] - the curve to offset pBrep [in] - brep on which to offset the curve fid [in] - index of the face in the brep params [in] - curve parameters corresponding to the offset distances dists [in] - distances to offset +: left, -: right tol [in] - fitting tolerance result_curves [out] - results of the offset

◆ RhinoOffsetCurveOnSrfOld()

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoOffsetCurveOnSrfOld	(	const ON_Curve *	p3dCrv,
		const ON_Brep *	pBrep,
		int	fid,
		ON_SimpleArray< double > &	params,
		ON_SimpleArray< double > &	dists,
		double	tol,
		ON_SimpleArray< ON_Curve * > &	result_curves
	)

◆ RhinoOffsetCurveTangent()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoOffsetCurveTangent	(	const ON_Surface *	pSrf,
		const ON_NurbsCurve *	pNC,
		double	height
	)

Description: Finds a curve by offsetting an existing curve tangent to a surface. The caller is responsible for ensuring that the input curve lies on the input surface. Parameters: pSrf [in] - Surface from which tangents are calculated. pCrv [in] - 3d curve lying on the surface along which tangents are calculated. height [in] - offset distance (distance from surface to result curve). Return: ON_NurbsCurve* pointing to offset curve at distance height from the surface. Remarks: The offset curve is interpolated through a small number of points so if the surface is irregular or complicated, the result will not be a very accurate offset. THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CURVE.

◆ RhinoOffsetSubD()

RHINO_SDK_FUNCTION ON_SubD* RhinoOffsetSubD	(	const ON_SubD &	InSubD,
		double	distance,
		bool	bSolidify
	)

Description: Makes a new SubD with vertices offset at distance in the direction of the control net vertex normals. Optionally, based on the value of bSolidify, adds the input SubD and a ribbon of faces along any naked edges. Parameters: InSubD - [in] Input SubD. distance - [in] Input offset distance. bSolidify - [in] Input bool to determine whether the output SubD should be turned into a closed SubD. Returns: Returns a ON_SubD pointer on success, nullptr on failure. Note, memory for the new SubD is allocated and becomes the responsibility of the caller.

◆ RhinoOffsetSurface()

RHINO_SDK_FUNCTION ON_Brep* RhinoOffsetSurface	(	const ON_BrepFace &	face,
		const double	dOffsetDistance,
		const double	dTolerance = `0.0`,
		const bool	bBothSides = `false`,
		const bool	bSolid = `false`,
		double *	pAchievedTol = `nullptr`
	)

Description: Offsets a Brep face and returns the offset in a Brep. Parameters: face - [in] The Brep face to offset. dOffsetDistance - [in] The offset distance. dTolerance - [in] The offset tolerance. Use 0.0 to make a loose offset. Otherwise, the document's absolute tolerance is usually sufficient. bBothSides - [in] When true, offset to both sides of the input face. bSolid - [in] When true, make a solid object. pAchievedTol - [out] The achieved offset tolerance. Returns: A pointer to a new Brep if success. The Brep can be disjoint if bBothSides is true and bSolid is false, or if bSolid is true and connecting the offsets with side surfaces fails. NULL if unsuccessful. Remarks: THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT BREP.

◆ RhinoOsnapPickboxRadius()

RHINO_SDK_FUNCTION int RhinoOsnapPickboxRadius ( void )

◆ RhinoParseAngle()

RHINO_SDK_FUNCTION int RhinoParseAngle	(	const wchar_t *	string,
		double *	angle_radians_value
	)

Description: Parse a string to see if it is an angle. Parameters: string - [in] string to parse angle_radians_value - [out] value of angle in radians Remarks: A "plain" number is assumed to be in degrees. Returns: 0: string does not parse to an angle >0: number of characters parsed See Also: RhinoParsePoint RhinoFormatPoint RhinoFormatNumber

◆ RhinoParseAngleDegrees()

RHINO_SDK_FUNCTION int RhinoParseAngleDegrees	(	const wchar_t *	string,
		double *	angle_degrees_value
	)

◆ RhinoParseColor() [1/2]

RHINO_SDK_FUNCTION int RhinoParseColor	(	const wchar_t *	string,
		ON_Color *	color_value
	)

Description: Parse a string to see if it is an RGB color. Parameters: string - [in] string to parse color_value - [out] value of number Returns: 0: string does not parse to a color >0: number of characters parsed Remarks: An RGB string can have two formats.

r,g,b where r, g, and b are integers in the range 0 to 255 and no spaces are around the commas.

A name from the color table RhinoApp().AppSettings().NamedColorList().

Since the formats of r,g,b colors and points are the same, care must be taken to avoid confusing points and colors. See Also: RhinoParsePoint RhinoFormatPoint RhinoFormatNumber

◆ RhinoParseColor() [2/2]

RHINO_SDK_FUNCTION int RhinoParseColor	(	const wchar_t *	string,
		ON_Color *	color_value,
		bool	bUseAlpha
	)

Description: Parse a string to see if it is an RGB color. Parameters: string - [in] string to parse color_value - [out] value of number bUseAlpha - [i] set to true if you want to parse for an alpha value Returns: 0: string does not parse to a color >0: number of characters parsed Remarks: An RGB string can have two formats.

r,g,b,a where r, g, b, and a are integers in the range 0 to 255 and no spaces are around the commas.

A name from the color table RhinoApp().AppSettings().NamedColorList().

Since the formats of r,g,b colors and points are the same, care must be taken to avoid confusing points and colors. See Also: RhinoParsePoint RhinoFormatPoint RhinoFormatNumber

◆ RhinoParseDefaultAngleUnitSystem()

RHINO_SDK_FUNCTION ON::AngleUnitSystem RhinoParseDefaultAngleUnitSystem ( )

Returns: The angle unit system that is used when and angles with no explicitly or implicitly specified angle unit system are encountered while parsing formulas, lengths and points.

◆ RhinoParseNumber()

RHINO_SDK_FUNCTION int RhinoParseNumber	(	const wchar_t *	string,
		double *	number_value
	)

Description: Parse a string to see if it is a number. Parameters: string - [in] string to parse number_value - [out] value of number Returns: 0: string does not parse to a number >0: number of characters parsed See Also: RhinoParsePoint RhinoFormatPoint RhinoFormatNumber

◆ RhinoParsePoint()

RHINO_SDK_FUNCTION int RhinoParsePoint	(	const wchar_t *	string,
		ON_3dPoint *	point_value
	)

Description: Parse a string to see if it is a point. Parameters: string - [in] string to parse point_value - [out] value of point Returns: 0: string does not parse to a point >0: number of characters parsed Example: Parse a string that contains an unknown number of space delimited points like "1,2,3 4,5,6 7,8,9".

ON_3dPointArray points;
ON_3dPoint point;
int i;
const wchar_t* string = ...;
for(;;)
{
  i = RhinoParsePoint(string,point);
  if ( !i )
    break;
  points.Append(point);
  string += i;
}

Remarks: RhinoParsePoint will parse strings of the form x,y,z~ where "x", "y", and "z" are numbers, "</em>" can be zero or more white space characters, and "~" is any non-digit value. See Also: RhinoParseNumber RhinoFormatPoint RhinoFormatNumber

◆ RhinoParsePythonFormula()

RHINO_SDK_FUNCTION bool RhinoParsePythonFormula	(	const wchar_t *	sformula,
		unsigned int	sformula_count,
		double *	value
	)

◆ RhinoParseTextFields()

RHINO_SDK_FUNCTION bool RhinoParseTextFields	(	ON_wString *	pParseResults,
		const CRhinoObject *	pRhinoObject,
		const CRhinoObject *	pTopParent,
		const CRhinoInstanceObject *	pImmediateParent
	)

Description: Parses a text field string. Parameters: pParseResults [in/out] - The text formula to parse. pRhinoObject [in] - The Rhino object. Value can be nullptr. pTopParent [in] - The parent Rhino object. Value can be nullptr. pImmediateParent [in] - The immediate parent instance object. Value can be nullptr. Returns: true on success, the parsed text field is returned in pParseResults. false on failure. Since: 8.12

◆ RhinoPatchSingleMeshFace()

RHINO_SDK_FUNCTION ON_Mesh* RhinoPatchSingleMeshFace	(	const ON_Mesh *	pInputMesh,
		const ON_SimpleArray< ON_COMPONENT_INDEX > &	indexes,
		bool	bJoin
	)

Description: Creates a single mesh face from the given input. Parameters: mesh - [in] Vertices and edges from this mesh are used to generate the new mesh face indexes - [in] An array of ON_COMPONENT_INDEXs. Can be 1 of the following combinations. 1 vertex (mesh_vertex or meshtop_vertex) and 1 edge 2 edges 3 vertices bJoin - [in] If bJoin is true then the return, on success, will be the input mesh with the new mesh face added. If bJoin is false the return, on success, will only be the new mesh face. Returns: A pointer to the new mesh if successful, or nullptr on failure. Remarks: NOTE: Memory for the mesh is allocated and becomes the responsibility of the caller.

◆ RhinoPerspectiveMatch()

RHINO_SDK_FUNCTION bool RhinoPerspectiveMatch	(	CRhinoView *	rhino_view,
		const ON_SimpleArray< POINT > &	points2d,
		const ON_SimpleArray< ON_3dPoint > &	points3d,
		ON_3dmView &	view
	)

Description: Given 6 or more pairs of screen (2d) and world (3d) points, together with the viewport, this function determines where the perspective camera is positioned. The image created by the screen points must be centered in the viewport; i.e., non symmetric cropping is not permitted. Parameters: rhino_view [in] - The Rhino view. points2d [in] - The 2d screen points points3d [in] - The 3d world points view [out] - A modified version of the view, maintained by the input Rhino view, containing the calculated camera information. Return: True if successful, false otherwise.

◆ RhinoPipe() [1/2]

RHINO_SDK_FUNCTION bool RhinoPipe	(	const ON_Curve &	rail,
		const ON_SimpleArray< double > &	rail_params,
		const ON_SimpleArray< double > &	radii,
		ON_SimpleArray< ON_Object * > &	results,
		double	abstol,
		double	angtol,
		int	blend_type = `0`,
		int	cap_mode = `0`,
		bool	fit_rail = `false`
	)

Description: Creates a single-walled pipe. Parameters: rail - [in] The rail, or path, curve. rail_params - [in] An array of one or more normalized curve parameters where changes in radius occur. Important: curve parameters must be normalized - ranging between 0.0 and 1.0. Use ON_Interval::NormalizedParameterAt to calculate these. radii - [in] An array of radii - one at each normalized curve parameter in rail_params. results - [out] The results of the pipe creation. If rail is a line segment, rail_params contains two normalized curve parameters, radii contains two identical values, and and cap_mode is either 0 (None) or 1 (Flat), then an ON_Extrusion object will be returned. Otherwise, an ON_Brep object will be returned. Note, it is possible for more than one ON_Brep to be returned (when it is not possible to miter sharp corners, for example). abstol - [in] The sweeping and fitting tolerance. If you are unsure whaat to use, then use the document's absolute tolerance - CRhinoDoc::AbsoluteTolerance(). angtol - [in] The angle tolerance. If you are unsure what to use, then either use the document's angle tolerance in radians - CRhinoDoc::AngleToleranceRadians(). blend_type - [in] The shape blending, where: 0: Local (pipe radius stays constant at the ends and changes more rapidly in the middle) 1: Global (radius is linearly blended from one end to the other, creating pipes that taper from one radius to the other) cap_mode - [in] The end cap mode, where: 0: None 1: Flat (cap with planar surface) 2: Round (cap with hemispherical surface) fit_rail - [in] If the curve is a polycurve of lines and arcs, the curve is fit and a single surface is created; otherwise the result is a polysurface with joined surfaces created from the polycurve segments. Returns: true if success, false otherwise. Remarks: CRITICAL: Memory for the resulting ON_Extrusion or ON_Brep object is allocated. It is the calling functions responsibility to clean up the memory.

◆ RhinoPipe() [2/2]

RHINO_SDK_FUNCTION bool RhinoPipe	(	const ON_Curve &	rail,
		const ON_SimpleArray< double > &	rail_params,
		const ON_SimpleArray< double > &	radii0,
		const ON_SimpleArray< double > &	radii1,
		ON_SimpleArray< ON_Object * > &	results,
		double	abstol,
		double	angtol,
		int	blend_type = `0`,
		int	cap_mode = `0`,
		bool	fit_rail = `false`
	)

Description: Creates a double-walled pipe. Parameters: rail - [in] The rail, or path, curve. rail_params - [in] An array of one or more normalized curve parameters where changes in radius occur. Important: curve parameters must be normalized - ranging between 0.0 and 1.0. Use ON_Interval::NormalizedParameterAt to calculate these. radii0 - [in] An array of radii for the first wall - one at each normalized curve parameter in rail_params. radii1 - [in] An array of radii for the second wall - one at each normalized curve parameter in rail_params. results - [out] The results of the pipe creation. If rail is a line segment, rail_params contains two normalized curve parameters, radii0 contains two identical values, radii1 contains two identical values, and and cap_mode is 1 (Flat), then a single ON_Extrusion object will be returned. If cap_mode is 0 (None), then two ON_Extrusion objects will be returned. Otherwise, an ON_Brep object will be returned. Note, it is possible for more than one ON_Brep to be returned (if cap_mode = 0, or when it is not possible to miter sharp corners, for example). abstol - [in] The sweeping and fitting tolerance. If you are unsure what to use, then use the document's absolute tolerance - CRhinoDoc::AbsoluteTolerance(). angtol - [in] The angle tolerance. If you are unsure what to use, then either use the document's angle tolerance in radians - CRhinoDoc::AngleToleranceRadians(). blend_type - [in] The shape blending, where: 0: Local (pipe radius stays constant at the ends and changes more rapidly in the middle) 1: Global (radius is linearly blended from one end to the other, creating pipes that taper from one radius to the other) cap_mode - [in] The end cap mode, where: 0: None 1: Flat (cap with planar surface) 2: Round (cap with hemispherical surface) fit_rail - [in] If the curve is a polycurve of lines and arcs, the curve is fit and a single surface is created; otherwise the result is a polysurface with joined surfaces created from the polycurve segments. Returns: true if success, false otherwise. Remarks: CRITICAL: Memory for the resulting ON_Extrusion or ON_Brep object is allocated. It is the calling functions responsibility to clean up the memory.

◆ RhinoPlanarClosedCurveContainmentTest()

RHINO_SDK_FUNCTION int RhinoPlanarClosedCurveContainmentTest	(	const ON_Curve &	closed_curveA,
		const ON_Curve &	closed_curveB,
		ON_Plane	plane,
		double	tolerance
	)

Description: Determine the relationship between the regions bounded by two coplanar simple closed curves. Parameters: closed_curveA - [in] simple closed curve closed_curveB - [in] simple closed curve plane - [in] plane containing the closed curves tolerance - [in] intersection tolerance (> 0.0) Returns: -1: invalid input 0: regions bounded by the curves are disjoint 1: curves intersect 2: region bounded by curveA is inside of curveB 3: region bounded by curveB is inside of curveA See Also: RhinoPlanarCurveCollisionTest RhinoPointInPlanarClosedCurve

◆ RhinoPlanarCurveCollisionTest()

RHINO_SDK_FUNCTION bool RhinoPlanarCurveCollisionTest	(	const ON_Curve &	curveA,
		const ON_Curve &	curveB,
		ON_Plane	plane,
		double	tolerance
	)

Description: Determine if two coplanar curves intersect. Parameters: curveA - [in] curveB - [in] plane - [in] plane containing the curves tolerance - [in] intersection tolerance (> 0.0) Returns: false: curves do not intersect or input is not valid true: curves intersect See Also: RhinoPlanarClosedCurveContainmentTest RhinoPointInPlanarClosedCurve

◆ RhinoPlanarSrf()

RHINO_SDK_FUNCTION bool RhinoPlanarSrf	(	const ON_SimpleArray< const ON_Curve * > &	InCurves,
		ON_SimpleArray< ON_Brep * > &	OutBreps,
		double	tolerance
	)

Description: Creates one or more Breps with a single planar face from an array of curves. Parameters: InCurves [in] - Input loops to sort and use as boundaries. OutBreps [out] - Output array of Breps tolerance [in] - The tolerance to be used to perform calculations. Return: True if successful, false otherwise. Remarks: Note, if a input curve is self-intersecting, then curve boolean processing will be used. CRITICAL: Memory for the resulting Breps is allocated. It is the calling functions responsibility to clean up the memory.

◆ RhinoPlugInSDKInstalled()

RHINO_SDK_FUNCTION bool RhinoPlugInSDKInstalled ( )

Description: Returns true if the Rhino pug-in SDK is installed. Several commands, including "CheckNewObjects" and "TestErrorCheck" turn on full debugging dialogs when the Rhino SDK is installed.

◆ RhinoPointCloudRandomSubsample()

RHINO_SDK_FUNCTION ON_PointCloud* RhinoPointCloudRandomSubsample	(	const ON_PointCloud *	pPointCloud,
		const int	points_to_keep,
		ON_PointCloud *	pSubsample = `nullptr`,
		ON_ProgressReporter *	pProgressReporter = `nullptr`,
		ON_Terminator *	pTerminator = `nullptr`
	)

Description: Returns a random subsample of a point cloud. Parameters: pPointCloud - [in] The point cloud to subsample. points_to_keep - [in] The number of points to keep. pSubsample - [in] If not nullptr, this point cloud will be used and returned. pProgressReporter - [in] Allows the caller to see the progress the computation. pTerminator - [in] Allows the caller to terminate computation. Returns: A new ON_PointCloud which is a subsample of pPointCloud. Note: if pSubsample == nullptr, then memory will be allocated for the returned point cloud and becomes the responsibility of the caller.

◆ RhinoPointInPlanarClosedCurve() [1/2]

RHINO_SDK_FUNCTION int RhinoPointInPlanarClosedCurve	(	ON_3dPoint	point,
		const ON_Curve &	closed_curve,
		ON_Plane	plane
	)

Deprecated:: use overload that accepts tolerance parameter

◆ RhinoPointInPlanarClosedCurve() [2/2]

RHINO_SDK_FUNCTION int RhinoPointInPlanarClosedCurve	(	ON_3dPoint	point,
		const ON_Curve &	closed_curve,
		ON_Plane	plane,
		double	tolerance
	)

Description: Determine if a point is inside of a closed curve, on a closed curve, or outside of a closed curve. Parameters: point - [in] closed_curve - [in] simple closed curve plane - [in] plane containing the closed curve and point tolerance - [in] intersection tolerance (> 0) Returns: -1: invalid input 0: point is outside of the closed curve 1: point is inside of the closed curve 2: point is on the closed curve See Also: RhinoPlanarClosedCurveContainmentTest RhinoPlanarCurveCollisionTest

◆ RhinoPrintExportDialog() [1/3]

RHINO_SDK_FUNCTION bool RhinoPrintExportDialog	(	const CRhinoPrintInfo &	initialinfo,
		const CArgsRhinoPrintExportDlg &	args,
		ON_ClassArray< CRhinoPrintInfo > &	settings
	)

Description: Show the Print Dialog for file export purposes Parameters: info - [in/out] initial passed in print settings. These settings are adjusted by the dialog Returns: true if user clicked OK button, false if user clicked cancel

◆ RhinoPrintExportDialog() [2/3]

RHINO_SDK_FUNCTION bool RhinoPrintExportDialog	(	CRhinoPrintInfo &	info,
		const CArgsRhinoPrintExportDlg &	args
	)

Description: Show the Print Dialog for file export purposes Parameters: info - [in/out] initial passed in print settings. These settings are adjusted by the dialog Returns: true if user clicked OK button, false if user clicked cancel

◆ RhinoPrintExportDialog() [3/3]

RHINO_SDK_FUNCTION bool RhinoPrintExportDialog	(	CRhinoPrintInfo &	info,
		const CArgsRhinoPrintExportDlg &	args,
		bool &	bDontShowDialog
	)

Description: Show the Print Dialog for file export purposes Parameters: info - [in/out] initial passed in print settings. These settings are adjusted by the dialog bDontShowDialog - [in/out] checkbox value for "Always use these settings and do not show this dialog." Returns: true if user clicked OK button, false if user clicked cancel

◆ RhinoPrintWidthDialog()

RHINO_SDK_FUNCTION BOOL32 RhinoPrintWidthDialog	(	HWND	hwndParent,
		double &	print_width
	)

Description: Display Rhino's print width selection dialog. Parameters: hwndParent - [in] Window handle of dialog's parent window. print_width - [in/out] Default print width for dialog, and will receive new print width if function returns TRUE. Returns: TRUE - Dialog completed successfully. FALSE - Dialog was canceled.

◆ RhinoProjectCurvesToBreps() [1/2]

RHINO_SDK_FUNCTION bool RhinoProjectCurvesToBreps	(	ON_SimpleArray< const ON_Brep * > &	Breps,
		ON_SimpleArray< const ON_Curve * > &	Curves,
		const ON_3dVector &	ProjDir,
		bool	bLoose,
		ON_SimpleArray< ON_Curve * > &	OutCurves,
		ON_SimpleArray< int > &	CurveIndices,
		ON_SimpleArray< int > &	BrepIndices,
		double	tolerance
	)

Description: Projects curves onto Breps Parameters: Breps - [in] The Breps to project onto Curves - [in] The curves to project ProjDir - [in] The direction to project bLoose - [in] If true, a loose projection is performed. OutCurves - [out] The output, or projected, curves. NOTE: THE CALLER IS RESPONSIBLE FOR DESTROYING THESE CURVES. CurveIndices - [out] OutCurves[i] is a projection of Curves[CurveIndices[i]] BrepIndices - [out] OutCurves[i] was projected onto Breps[BrepIndices[i]] tolerance - [in] The projection tolerance. Returns: true if at least one of the input curves was projected, otherwise false. See Also: RhinoProjectCurvesToMeshes RhinoProjectPointsToBreps RhinoProjectPointsToMeshes

◆ RhinoProjectCurvesToBreps() [2/2]

RHINO_SDK_FUNCTION bool RhinoProjectCurvesToBreps	(	ON_SimpleArray< const ON_Brep * > &	Breps,
		ON_SimpleArray< const ON_Curve * > &	Curves,
		const ON_3dVector &	ProjDir,
		ON_SimpleArray< ON_Curve * > &	OutCurves,
		ON_SimpleArray< int > &	CurveIndices,
		ON_SimpleArray< int > &	BrepIndices,
		double	tolerance
	)

Description: Projects curves onto Breps Parameters: Breps - [in] The Breps to project onto Curves - [in] The curves to project ProjDir - [in] The direction to project OutCurves - [out] The output, or projected, curves. NOTE: THE CALLER IS RESPONSIBLE FOR DESTROYING THESE CURVES. CurveIndices - [out] OutCurves[i] is a projection of Curves[CurveIndices[i]] BrepIndices - [out] OutCurves[i] was projected onto Breps[BrepIndices[i]] tolerance - [in] The projection tolerance. Returns: true if at least one of the input curves was projected, otherwise false. See Also: RhinoProjectCurvesToMeshes RhinoProjectPointsToBreps RhinoProjectPointsToMeshes

◆ RhinoProjectCurvesToMeshes() [1/2]

RHINO_SDK_FUNCTION bool RhinoProjectCurvesToMeshes	(	ON_SimpleArray< const ON_Mesh * > &	Meshes,
		ON_SimpleArray< const ON_Curve * > &	Curves,
		const ON_3dVector &	ProjDir,
		bool	bLoose,
		ON_SimpleArray< ON_Curve * > &	OutCurves,
		ON_SimpleArray< int > &	CurveIndices,
		ON_SimpleArray< int > &	MeshIndices,
		double	tolerance
	)

Description: Projects curves onto meshes Parameters: Meshes - [in] The meshes to project onto Curves - [in] The curves to project ProjDir - [in] The direction to project bLoose = [in] If true, a loosse projection is performed. OutCurves - [out] The output, or projected, curves. NOTE: THE CALLER IS RESPONSIBLE FOR DESTROYING THESE CURVES. CurveIndices - [out] OutCurves[i] is a projection of Curves[CurveIndices[i]] MeshIndices - [out] OutCurves[i] was projected onto Meshes[MeshIndices[i]] tolerance - [in] The projection tolerance. Returns: true if at least one of the input curves was projected, otherwise false. See Also: RhinoProjectCurvesToBreps RhinoProjectPointsToBreps RhinoProjectPointsToMeshes

◆ RhinoProjectCurvesToMeshes() [2/2]

RHINO_SDK_FUNCTION bool RhinoProjectCurvesToMeshes	(	ON_SimpleArray< const ON_Mesh * > &	Meshes,
		ON_SimpleArray< const ON_Curve * > &	Curves,
		const ON_3dVector &	ProjDir,
		ON_SimpleArray< ON_Curve * > &	OutCurves,
		ON_SimpleArray< int > &	CurveIndices,
		ON_SimpleArray< int > &	MeshIndices,
		double	tolerance
	)

Description: Projects curves onto meshes Parameters: Meshes - [in] The meshes to project onto Curves - [in] The curves to project ProjDir - [in] The direction to project OutCurves - [out] The output, or projected, curves. NOTE: THE CALLER IS RESPONSIBLE FOR DESTROYING THESE CURVES. CurveIndices - [out] OutCurves[i] is a projection of Curves[CurveIndices[i]] MeshIndices - [out] OutCurves[i] was projected onto Meshes[MeshIndices[i]] tolerance - [in] The projection tolerance. Returns: true if at least one of the input curves was projected, otherwise false. See Also: RhinoProjectCurvesToBreps RhinoProjectPointsToBreps RhinoProjectPointsToMeshes

◆ RhinoProjectPointsToBreps()

RHINO_SDK_FUNCTION bool RhinoProjectPointsToBreps	(	ON_SimpleArray< const ON_Brep * > &	Breps,
		const ON_3dPointArray &	Points,
		const ON_3dVector &	ProjDir,
		ON_3dPointArray &	OutPoints,
		ON_SimpleArray< int > &	Indices,
		double	tolerance
	)

Description: Projects points onto Breps Parameters: Breps - [in] The Breps to project onto Points - [in] The points to project ProjDir - [in] The direction to project OutPoints - [out] The output, or projected, points. Indices - [out] OutPoints[i] is a projection of Points[Indices[i]] tolerance - [in] The projection tolerance - used for culling close points and for line-Brep intersection. Returns: true if at least one of the input points was projected, otherwise false. See Also: RhinoProjectCurvesToBreps RhinoProjectCurvesToMeshes RhinoProjectPointsToMeshes

◆ RhinoProjectPointsToMeshes()

RHINO_SDK_FUNCTION bool RhinoProjectPointsToMeshes	(	ON_SimpleArray< const ON_Mesh * > &	Meshes,
		const ON_3dPointArray &	Points,
		const ON_3dVector &	ProjDir,
		ON_3dPointArray &	OutPoints,
		ON_SimpleArray< int > &	Indices,
		double	tolerance
	)

Description: Projects points onto meshes Parameters: Meshes - [in] The meshes to project onto Points - [in] The points to project ProjDir - [in] The direction to project OutPoints - [out] The output, or projected, points. Indices - [out] OutPoints[i] is a projection of Points[Indices[i]] tolerance - [in] The projection tolerance - used for culling close points and for line-mesh intersection. Returns: true if at least one of the input points was projected, otherwise false. See Also: RhinoProjectCurvesToBreps RhinoProjectCurvesToMeshes RhinoProjectPointsToBreps

◆ RhinoProjectToPlane() [1/3]

RHINO_SDK_FUNCTION ON_Curve* RhinoProjectToPlane	(	const ON_Curve &	curve,
		const ON_Plane &	plane,
		double	shortSegmentTolerance
	)

Description: Project a curve to a plane. Parameters: curve [in] - Curve to project. plane [in] - Projection plane. shortSegmentTolerance [in] - Short curve segment tolerance. Returns: Pointer to the projected curve if successful, false otherwise. Memory for the output curve is allocated and becomes the responsibility of the caller.

◆ RhinoProjectToPlane() [2/3]

RHINO_SDK_FUNCTION BOOL32 RhinoProjectToPlane	(	ON_BoundingBox &	curve,
		ON_Plane &	plane
	)

Description: Project an ON_BoundingBox to a plane Parameters: box [in] the box to project. [out] the modified box Returns: @untitled table TRUE Success False Failure Remarks: Bounding box is flattered in place

◆ RhinoProjectToPlane() [3/3]

RHINO_SDK_FUNCTION BOOL32 RhinoProjectToPlane	(	ON_NurbsCurve &	curve,
		ON_Plane &	plane
	)

Description: Project a NURBS curve to a plane Parameters: curve [in] the curve to project. [out] the modified curve Returns: @untitled table TRUE Success False Failure Remarks: Curve is flattered in place

◆ RhinoPullCurveToFace()

RHINO_SDK_FUNCTION int RhinoPullCurveToFace	(	const ON_BrepFace &	face,
		const ON_Curve &	curve,
		ON_SimpleArray< ON_Curve * > &	OutCurves,
		double	tolerance
	)

Description: Pulls a curve to a Brep face. Parameters: face - [in] The Brep face that pulls. curve - [in] The curve to pull. OutCurves - [out] The results of the pull. tolerance - [in] The tolerance. Returns: The number of curves added to OutCurves if successful, 0 otherwise. Remarks: THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT CURVES.

◆ RhinoPullCurveToMesh()

RHINO_SDK_FUNCTION ON_PolylineCurve* RhinoPullCurveToMesh	(	const ON_Curve *	pCrv,
		const ON_Mesh *	pMesh,
		const double	tolerance,
		CRhinoPolylineOnMeshUserData *	YDData = `0`
	)

Description: Makes a polyline approximation of the input curve and gets the closest point on the mesh for each point on the mesh. Then it "connects the points" so that you have a polyline on the mesh. Parameters: pCrv - Input curve. pMesh - Input mesh. tolerance - Input tolerance. YDData - Optional userdata. If YDData is not null then it will be filled in. Returns: Returns a ON_PolylineCurve on success. Returns null on failure.

◆ RhinoPullPointsToFace()

RHINO_SDK_FUNCTION int RhinoPullPointsToFace	(	const ON_BrepFace &	face,
		const ON_SimpleArray< ON_3dPoint > &	InPoints,
		ON_SimpleArray< ON_3dPoint > &	OutPoints,
		double	tolerance
	)

Description: Pulls one or more points to a Brep face. Parameters: face - [in] The Brep face that pulls. InPoints - [in] The points to pull. OutPoints - [out] The results of the pull. tolerance - [in] The tolerance. Returns: The number of points added to OutPoints if successful, 0 otherwise.

◆ RhinoPushPullExtend()

RHINO_SDK_FUNCTION ON_Brep* RhinoPushPullExtend	(	const ON_Brep &	brep,
		int	iFaceIdx,
		const ON_Xform &	xform,
		double	dTolerance
	)

Description: If the brep.m_F[iFaceIdx] is planar, and all the adjacent faces are planar, this function transforms brep.m_F[iFaceIdx] with the passed in xform and recomputes the adjacent faces. See the PushPull commands extend mode. Parameters: brep - The brep to extend iFaceIdx - The face being transformed xform - The transformation dTolerance - The tolerance for planarity checks Returns: A brep with the transformed face or nullptr on failure

◆ RhinoQueryImportScaleGeometry()

RHINO_SDK_FUNCTION int RhinoQueryImportScaleGeometry	(	ON::LengthUnitSystem	current,
		ON::LengthUnitSystem	file,
		bool	bInteractive
	)

Description: Asks a question about whether to change the size of the geometry or the unit system for use when importing a file with a unit system different than the current model Parameters: current - [in] Unit system in the current model file - [in] Unit system in the file being imported bInteractive - [in] true: use a dialog, false: use command line Returns: IDYES: Scale the geometry IDNO: Don't scale the geometry IDCANCEL: No answer was provided - user canceled Remarks:

◆ RhinoReadFile()

RHINO_SDK_FUNCTION bool RhinoReadFile	(	const wchar_t *	lpsFileName,
		CRhinoDoc &	doc,
		const CRhinoFileReadOptions &	options
	)

Description: SDK tool to read a file using the Rhino file I/O plug-ins. Parameters: lpsFileName - [in] complete name of the file to write, including full path and extension. The extension is used to determine what type of file is read. doc - [in] options - [in] file reading options Returns: True if reading succeeded. Look at doc.ReadFileResult() if you need to distinguish between partial and complete success. See Also: CRhinoDoc::Read3DM

◆ RhinoReadHatchPatternFile() [1/2]

RHINO_SDK_FUNCTION bool RhinoReadHatchPatternFile	(	const wchar_t *	pFilename,
		ON_ClassArray< ON_HatchPattern > &	hatchPatterns,
		bool	bAllowDuplicates,
		bool	bQuiet
	)

Deprecated:: use overload that has an ON_ObjectArray parameter

◆ RhinoReadHatchPatternFile() [2/2]

RHINO_SDK_FUNCTION bool RhinoReadHatchPatternFile	(	const wchar_t *	pFilename,
		ON_ObjectArray< ON_HatchPattern > &	hatchPatterns,
		bool	bAllowDuplicates,
		bool	bQuiet
	)

Description: Read hatch pattern definitions from a file. Parameters: pFilename - [in] name of existing file. hatchPatterns - [in/out] hatch patterns are appended to this list. ¨ bAllowDuplicates - [in] if false, the function checks before append new patterns that no other hatch pattern exists in the array with the same name. bQuiet - [in] If file doesn't exist, and bQuiet is false, an error message box is shown. Returns: true if success. Notes: If pFilename is NULL, default hatch pattern filename is used. In this case, if file doesn't exist, default hatch patterns will be appended to hatchPatterns.

◆ RhinoReadLinetypesFromFile()

RHINO_SDK_FUNCTION int RhinoReadLinetypesFromFile	(	const wchar_t *	filename,
		ON_ObjectArray< ON_Linetype > &	linetypes
	)

Description: Reads linetypes from either a Rhino .3dm file or an AutoCAD .lin file. Parameters: filename [in] - The name of the file to read. linetypes [out] - The linetypes that were read from the file. Returns: The number of linetypes added to output array.

◆ RhinoRebuildCurve() [1/2]

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoRebuildCurve	(	const ON_Curve &	curve_in,
		int	degree,
		int	pointcount,
		bool	bKeepTangents,
		ON_NurbsCurve *	curve_out = `nullptr`
	)

Description: Rebuilds an existing curve with a new curve to given point count. Parameters: curve_in - [in] the curve to rebuild. degree - [in] the output curve degree. pointcount - [in] the number of points in the output curve. Must be bigger than the degree. With closed curves the minimum point count is three. The highest accepted point count is 1000. bKeepTangents - [in] if set, maintain start and end tangent directions The minimum number of points to do this is degree + 2 curve_out - [in] if not NULL this curve will be used for output. Returns: pointer to curve if success. NULL if unsuccessful.

◆ RhinoRebuildCurve() [2/2]

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoRebuildCurve	(	const ON_Curve &	curve_in,
		int	degree = `3`,
		int	pointcount = `10`,
		ON_NurbsCurve *	curve_out = `nullptr`
	)

Description: Rebuilds an existing curve with a new curve to given point count. Parameters: curve_in - [in] the curve to rebuild. degree - [in] the output curve degree. pointcount - [in] the number of points in the output curve. Must be bigger than the degree. With closed curves the minimum point count is three. The highest accepted point count is 1000. curve_out - [in] if not NULL this curve will be used for output. Returns: pointer to curve if success. NULL if unsuccessful.

◆ RhinoRebuildMeshNormals()

RHINO_SDK_FUNCTION ON_Mesh* RhinoRebuildMeshNormals ( const ON_Mesh * MeshIn )

Description: RebuildMeshNormals Removes mesh normals and reconstructs the face and vertex normals based on the orientation of the faces.

Parameters: MeshIn - [In] Input mesh

Returns: New mesh.

◆ RhinoRebuildSurface()

RHINO_SDK_FUNCTION ON_NurbsSurface* RhinoRebuildSurface	(	const ON_Surface &	surface_in,
		int	udegree = `3`,
		int	vdegree = `3`,
		int	upointcount = `10`,
		int	vpointcount = `10`,
		ON_NurbsSurface *	surface_out = `nullptr`
	)

Description: Rebuilds an existing surface with a new surface to a given point count. Parameters: surface_in - [in] the surface to rebuild. udegree - [in] the output surface u degree. vdegree - [in] the output surface v degree. upointcount - [in] the number of points in the output surface u direction. vpointcount - [in] the number of points in the output surface v direction. Must be bigger than the degree. The highest accepted point count is 1000. surface_out - [in] if not NULL this surface will be used for output. Returns: pointer to surface if success. NULL if unsuccessful. Notes:

◆ RhinoRebuildSurfaceOneDirection()

RHINO_SDK_FUNCTION ON_NurbsSurface* RhinoRebuildSurfaceOneDirection	(	const ON_Surface &	surface_in,
		int	direction,
		int	point_count,
		int	loft_type,
		double	tolerance,
		ON_NurbsSurface *	surface_out = `nullptr`
	)

Description: Rebuilds an existing surface with a new surface to a given point count in either the u or v directions independently. Parameters: surface_in - [in] the surface to rebuild. direction - [in] the direction (0 = U, 1 = V). point_count - [in] the number of points in the output surface in the "direction" direction. loft_type - [in] the loft type (0 = Normal, 1 = Loose, 2 = Tight, 3 = Straight, 4 = Uniform). tolerance - [in] the refit tolerance. When in doubt, use the document's model absolute tolerance. surface_out - [in] if not nullptr this surface will be used for output. Returns: pointer to surface if success. nullptr if unsuccessful.

◆ RhinoRedrawLayerManagerWindow() [1/2]

RHINO_SDK_FUNCTION void RhinoRedrawLayerManagerWindow ( )

Deprecated:: use overload that takes a CRhinoDoc parameter

◆ RhinoRedrawLayerManagerWindow() [2/2]

RHINO_SDK_FUNCTION void RhinoRedrawLayerManagerWindow ( CRhinoDoc & doc )

Description: Redraws the layer manager window, if visible. Parameters: doc - [in] The Rhino document. Returns: Nothing. Remarks: When adding lots of layers to the layer table, if the layer manager window is open, the process can be time consuming. Each addition to the layer table triggers a CRhinoEventWatcher::layer_added event, which in turn causes the layer manager window to repaint. To add bulk layers expeditiously, you will want to: 1.) Turn off viewport redrawing by calling CRhinoView::EnableDrawing(false). 2.) Add your bulk layers. 3.) Turn viewport redrawing back on by calling CRhinoView::EnableDrawing(true). 4.) Redraw the layer manager window by calling RhinoRedrawLayerManagerWindow(doc).

◆ RhinoReduceMesh() [1/2]

RHINO_SDK_FUNCTION bool RhinoReduceMesh	(	ON_Mesh &	mesh,
		int	iDesiredPolygonCount,
		bool	bAllowDistortion = `true`,
		int	iAccuracy = `10`,
		bool	bNormalizeMeshSize = `true`,
		ON_ProgressReporter *	pProgressReporter = `0`,
		ON_Terminator *	pCancelHandler = `0`,
		ON_wString *	pStrProblemOut = `0`,
		ON_SimpleArray< int > *	pFaceTagArray = `0`,
		ON_SimpleArray< ON_COMPONENT_INDEX > *	pLockedComponents = `0`
	)

Description: RhinoReduceMesh reduces mesh polygon count.

Parameters: mesh - Triangular mesh to be reduced iDesiredPolygonCount - Target polygon count bAllowDistortion - If true mesh appearance is not changed even if the target polygon count is not reached iAccuracy - Integer from 1 to 10 telling how accurate reduction algorithm to use. Greater number gives more accurate results. bNormalizeMeshSize - If true mesh is fitted to an axis aligned unit cube until reduction is complete pProgressReporter - Null or a pointer to an ON_ProgressReporter object. Provides custom progress information to caller. pCancelHandler - Null or a pointer to an ON_Terminator object. Provides a custom way to handle cancelling. pStrProblemOut - Null or a pointer to an ON_wString object. Reports possible problems. pFaceTagArray - Null or a pointer to an ON_SimpleArray<int> object with element count equal to mesh face count. Each element is a user defined tag for the mesh face with the same index. Can be used to identify mesh faces before and after calling RhinoReduceMesh. pLockedComponents - Null or a pointer to an array of ON_COMPONENT_INDEX objects containing mesh vertex components that must be kept untouched.

Returns: True if mesh is successfully reduced and false if mesh could not be reduced for some reason. If return value is false then pStrProblemOut may have information what went wrong.

◆ RhinoReduceMesh() [2/2]

RHINO_SDK_FUNCTION bool RhinoReduceMesh	(	ON_Mesh &	mesh,
		RhinoReduceMeshParameters &	parameters
	)

Description: RhinoReduceMesh reduces mesh polygon count.

Parameters: mesh - Triangular mesh to be reduced parameters - Parameters for reduction

Returns: True if mesh is successfully reduced and false if mesh could not be reduced for some reason. If return value is false then parameters.m_sProblemOut may have information what went wrong. summary>Enumerates methods to end a mesh pipe. DEPRECATED – This is now a duplicate of ON_CurvePiping::CapTypes.

◆ RhinoRefitCrvCalculateMaxDeviation()

RHINO_SDK_FUNCTION bool RhinoRefitCrvCalculateMaxDeviation	(	const ON_Curve *	input_curve,
		const ON_Curve *	refit_curve,
		double	tolerance,
		ON_Line *	deviation
	)

Parameters

input_curve	This function calculates the maximum deviation between the original curve and the resulting fit curve returns true if successful INPUT: the original curve
refit_curve	the fit result
tolerance	tolerance to use, typically document tolerance
deviation	OUTPUT: A line segment representing the maximum deviation, from the refit curve to the original curve

◆ RhinoRefitSimplySplitSurface()

RHINO_SDK_FUNCTION bool RhinoRefitSimplySplitSurface	(	const ON_Surface *	surface,
		const ON_Curve *	trimCurve3d,
		const ON_3dVector	trimProjectionDir,
		double	tolerance,
		RhinoRefitTrimKnotMode	knotAdditionMode,
		int	numKnots,
		ON_SimpleArray< double > &	Knots,
		RhinoRefitTrimSectionMode	trimParamSections,
		int	numNonTrimSpans,
		bool	meetCurve,
		bool	oneSideOnly,
		const ON_3dPoint	PtActive,
		bool	outputSurface,
		bool	outputCurve,
		int *	numSections,
		double *	FitMeasurement,
		ON_SimpleArray< ON_NurbsSurface * > &	lowerSurface,
		ON_SimpleArray< ON_NurbsSurface * > &	upperSurface,
		ON_SimpleArray< ON_NurbsCurve * > &	edgeCurves,
		ON_Curve **	trimCurveOnSurface,
		ON_Curve **	splitCurve
	)

Parameters

surface This routine accepts an untrimmed surface (srf) and a 3-d trim curve (trimCrv3d). The trim curve is assumed to run from one surface edge to the opposite edge; this is referred to as a "simple" trim curve, roughly parallel to one of the srf directions (either u or v). We refer to that parameter as the "trim parameter".

The routine splits the surface via the trim curve, and then refits either side ("upper" = "above the trim", and "lower" = "below the trim") as a set of untrimmed Nurbs surfaces. The idea is to retain, as much as possible, the Nurbs structure of srf, especially in the trim parameter.

INPUT: untrimmed surface

Parameters

trimCurve3d	curve that will trim from one edge to the opposite
trimProjectionDir	How is the trim curve projected onto the surface? ... if non-zero, vector for projection
tolerance	3d tolerance for projection, splitting, fitting...
knotAdditionMode	Adding any knots to the surface in the trim parameter?
numKnots	0: no, don't add any 1: Yes, add nKnots knots, spaced regularly over the entire surface 2: Yes, add nKnots knots, spaced regularly PER EXISTING SPAN 3: Yes, add nKnots knots, as provided in the array Knots if addTrimParamKnots != 3, the number of knots to add
trimParamSections	Output surface divided into sections?
numNonTrimSpans	0: no sections, just output one "upper" and one "lower" surface 1: Yes, divide into sections at each of the input surface's existing knots 2: Yes, divide into sections at each of the "nKnot" added knot values 3: Yes, divide into sections at ALL knot values (i.e. both 1 and 2) number of spans in the non-trim parameter.
meetCurve	The same number applies to both the upper and lower output surfaces The routine will calculate a reasonable minimum, so "1" is an OK default Drag the refit surfaces out to meet the original trim curve
oneSideOnly	Inputting an "active" point means you only want one side of the "split" to be refit - In other words, you want a "trim refit". Results will be returned in "srfLower"
outputSurface	What type of output? if true, output fit surfaces: srfLower and, if !bActivePt, srfUpper
outputCurve	if true, output fit curve: nurbsEdge
numSections	OUTPUT: Calculated based on trimParamSections
FitMeasurement	3-d fit to trim curve (projected, or trimCrv3d if bMeetCurve)
lowerSurface	Surfaces (# = nSections) below trim curve in srf's (u,v) domain
upperSurface	Surfaces (# = nSections) above trim curve in srf's (u,v) domain
edgeCurves	Curves (# = nSections) fit to trim curve with srf's u/v parameter
trimCurveOnSurface	if not null, returns the actual projected or pulled trim curve used for the split/fit
splitCurve	if not null, returns the curve fit splitting the two halves Junctions between surfaces in srfLower should be G1; similarly for srfUpper integer return value: true - ok false - error, surfaces not returned

◆ RhinoRegionSelect()

RHINO_SDK_FUNCTION bool RhinoRegionSelect	(	CRhinoViewport &	vp,
		const ON_SimpleArray< ON_3dPoint > &	region,
		const int	selectionmode = `0`,
		unsigned int	geometry_filter = `ON::any_object`,
		ON_ClassArray< CRhinoObjRef > *	output = `nullptr`
	)

Description: Selects objects bounded by a polyline region Parameters: vp - [in] viewport to use for selection region - [in] list of points that define the selection region selectionmode - [in] the selection mode, 0=window, 1=crossing, 2=outside window, 3=outside crossing window geometry_filter - [in] geometry filter, same as in CRhinoGetObject output - [out] optional output array. If NULL, the objects are selected. Returns: true if success

◆ RhinoRegisterCustomMeshHandler()

void RhinoRegisterCustomMeshHandler ( CUSTOM_MESH_HANDLER_FUNC )

Deprecated:: Use RhinoRegisterCustomMeshHandler2 RHINO_SDK_FUNCTION

◆ RhinoRegisterCustomMeshHandler2()

RHINO_SDK_FUNCTION void RhinoRegisterCustomMeshHandler2 ( CUSTOM_MESH_HANDLER_FUNC2 )

◆ RhinoRemoveAllNakedMicroEdges()

RHINO_SDK_FUNCTION int RhinoRemoveAllNakedMicroEdges	(	ON_Brep &	brep,
		double	tolerance,
		bool	bCleanUp
	)

Description: Find any naked edges with same start and end vertex, and arclength less than tolerance, and attempt to remove them by removing trims and extending the adjacents to meet. Parameters: brep - [in] The Brep. tolerance - [in] The tolerance. bCleanUp - [in] If true, sets tolerances, boxes, etc., and compacts the Brep. If false, then the caller should at some point. Returns: The number of edges removed.

◆ RhinoRemoveBrepFins()

RHINO_SDK_FUNCTION bool RhinoRemoveBrepFins ( ON_Brep & brep )

Description: Recursively removes any face with a naked edge. This function is only useful for non-manifold Breps. Parameters: brep - [in] The Brep. Returns: true if successful, false otherwise. See Also: ON_Brep::IsManifold

◆ RhinoRemoveNakedMicroEdge()

RHINO_SDK_FUNCTION bool RhinoRemoveNakedMicroEdge	(	ON_Brep &	brep,
		int	edge_index,
		double	tolerance,
		bool	bCleanUp
	)

Description: Find a nake edges with same start and end vertex, and arclength less than tolerance, and attempt to remove it by removing trims and extending the adjacents to meet. Parameters: brep - [in] The Brep. edge_indices - [in] The edge to process. tolerance - [in] The tolerance. bCleanUp - [in] If true, sets tolerances, boxes, etc., and compacts the Brep. If false, then the caller should at some point. Returns: True if the edge was removed, false otherwise.

◆ RhinoRemoveNakedMicroEdges()

RHINO_SDK_FUNCTION int RhinoRemoveNakedMicroEdges	(	ON_Brep &	brep,
		const ON_SimpleArray< int > &	edge_indices,
		double	tolerance,
		bool	bCleanUp
	)

Description: Find any naked edges with same start and end vertex, and arclength less than tolerance, and attempt to remove them by removing trims and extending the adjacents to meet. Parameters: brep - [in] The Brep. edge_indices - [in] The indices of the edges to process. tolerance - [in] The tolerance. bCleanUp - [in] If true, sets tolerances, boxes, etc., and compacts the Brep. If false, then the caller should at some point. Returns: The number of edges removed.

◆ RhinoRemoveShortSegments()

RHINO_SDK_FUNCTION bool RhinoRemoveShortSegments	(	ON_Curve *	curve,
		double	tolerance = `ON_UNSET_VALUE`
	)

Description: Remove short segments from the input curve. Parameters: curve - [in] curve to check tolerance - [in] if < 0 (default), then an appropriate tolerance is automatically calculated. if == 0, then ON_ZERO_TOLERANCE is used. if > 0, then the input value is used. Returns: @untitled table True short segments were removed. False no changes to curve. See Also: ON_Curve::RemoveShortSegments

◆ RhinoRenderDrawWiresInDIB() [1/2]

RHINO_SDK_FUNCTION bool RhinoRenderDrawWiresInDIB	(	CRhinoDib &	alpha_dib,
		CRhinoDib &	dib2,
		CRhinoDib &	final_dib
	)

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. Description: Composite bitmaps created in CRhinoSdkRenderViewWnd::GetWireframeCompositeDIBs with final_dib. Parameters: alpha_dib [in] - Alpha map for all wireframe and curves. wires_dib [in] - Rendered wireframes and curves in their display colors. final_dib [out] - alpha_dib and wires_dib will be transparently blit to this DIB. Returns: Success == true, failure == false. Comments: See: CRhinoSdkRenderViewWnd::GetWireframeCompositeDIBs CRhinoSdkRenderViewWnd::DrawWiresInDIB RhinoRenderDrawWiresInDIB( CRhinoDoc& doc, ON_3dmView view, CSize size, CRhinoDib& final_dib, bool bGetRenderSettingsFromDoc=true)

◆ RhinoRenderDrawWiresInDIB() [2/2]

RHINO_SDK_FUNCTION bool RhinoRenderDrawWiresInDIB	(	CRhinoDoc &	doc,
		ON_3dmView	view,
		const ON_2iSize &	size,
		CRhinoDib &	final_dib,
		bool	bGetRenderSettingsFromDoc = `true`
	)

Description: Same as calling CRhinoSdkRenderViewWnd::GetWireframeCompositeDIBs( alpha, wires) then CRhinoSdkRenderViewWnd::DrawWiresInDIB( alpha, wires, my_dib); Parameters: doc [in] - Document to iterate view [in] - view to draw size [in] - size of image final_dib [out] - alpha_dib and wires_dib will be created, transparently blit to this DIB. and destroyed. bGetRenderSettingsFromDoc [in] - Tells compositor to setup render engine using the settings from the Document (true) or Display (false) settings. Returns: Success == true, failure == false. Comments: See: CRhinoSdkRenderViewWnd::GetWireframeCompositeDIBs( CRhinoDib& dib1, CRhinoDib& dib2); CRhinoSdkRenderViewWnd::DrawWiresInDIB( CRhinoDib& alpha_dib, CRhinoDib& dib2, CRhinoDib& final_dib); RhinoRenderDrawWiresInDIB( CRhinoDib& alpha_dib, CRhinoDib& dib2, CRhinoDib& final_dib)

◆ RhinoRenderGetWireframeCompositeDIBs()

RHINO_SDK_FUNCTION bool RhinoRenderGetWireframeCompositeDIBs	(	CRhinoDoc &	doc,
		ON_3dmView	view,
		const ON_2iSize &	size,
		CRhinoDib &	alpha_dib,
		CRhinoDib &	wires_dib,
		bool	bGetRenderSettingsFromDoc
	)

Description: Get bitmaps containing curve and annotation which may be used to composite with a rendered bitmap Parameters: doc [in] - Document to iterate view [in] - view to draw size [in] - size of image alpha_dib[out] - Bitmap which defines which pixels contain wires wires_dib [out] - Wire/annotation pixel color bGetRenderSettingsFromDoc [in] - Tells compositor to setup render engine using the settings from the Document (true) or Display (false) settings. Returns: Success == true, failure == false. Comments: See: CRhinoSdkRenderViewWnd::GetWireframeCompositeDIBs( CRhinoDib& dib1, CRhinoDib& dib2); CRhinoSdkRenderViewWnd::DrawWiresInDIB( CRhinoDib& alpha_dib, CRhinoDib& dib2, CRhinoDib& final_dib); RhinoRenderDrawWiresInDIB( CRhinoDib& alpha_dib, CRhinoDib& dib2, CRhinoDib& final_dib)

◆ RhinoRepairBrep() [1/2]

RHINO_SDK_FUNCTION bool RhinoRepairBrep	(	ON_Brep *	pBrep,
		double	repair_tolerance
	)

Description: Fills in missing or fixes incorrect component information from a Brep object. Useful when reading Brep information from other file formats that do not provide as complete of a Brep definition as required by Rhino. Parameters: pBrep - [in] The Brep to repair repair_tolerance - [in] The repair tolerance. When in doubt, use the document's model absolute tolerance. Returns: True if successful, false otherwise.

◆ RhinoRepairBrep() [2/2]

RHINO_SDK_FUNCTION bool RhinoRepairBrep	(	ON_Brep *	pBrep,
		double	repair_tolerance,
		bool	bSpliKinkyEdges
	)

Description: Fills in missing or fixes incorrect component information from a Brep object. Useful when reading Brep information from other file formats that do not provide as complete of a Brep definition as required by Rhino. Parameters: pBrep - [in] The Brep to repair repair_tolerance - [in] The repair tolerance. When in doubt, use the document's model absolute tolerance. bSpliKinkyEdges - [in] Split up kinky edges if true. Use true if in doubt. Some IGES files have edges that are polylines. reading those files in takes a long time if the edges are split up. If the only purpose is visualization, there is no need to splt the edges. Returns: True if successful, false otherwise.

◆ RhinoRepairCurve()

RHINO_SDK_FUNCTION bool RhinoRepairCurve	(	ON_Curve *	pCurve,
		double	repair_tolerance,
		int	dim
	)

Description: Used by RhinoBrepRepair (see below)

◆ RhinoRepairMesh()

RHINO_SDK_FUNCTION bool RhinoRepairMesh	(	ON_Mesh *	pMesh,
		double	repair_tolerance
	)

◆ RhinoRepairSurface()

RHINO_SDK_FUNCTION bool RhinoRepairSurface	(	ON_Surface *	pSurface,
		double	repair_tolerance
	)

Description: Used by RhinoBrepRepair (see below)

◆ RhinoRetrimSurface()

RHINO_SDK_FUNCTION ON_Brep* RhinoRetrimSurface	(	const ON_BrepFace &	trim_source,
		const ON_Surface &	trim_target,
		double	tol
	)

Description: Transfers trims from a Brep face to another surface roughly the same shape and in the same location as the original face, and returns the result in a single surface Brep. This is useful for re-trimming a trimmed surface after rebuild or refit. Parameters: trim_source - [in] the original face to transfer the trims from. trim_target - [in] the surface to transfer the trims to. tol - [in] tolerance used to rebuild edges. Returns: Pointer to single face Brep if success. The target surface is duplicated. nullptr if unsuccessful.

◆ RhinoRibbonOffsetCurve() [1/2]

RHINO_SDK_FUNCTION ON_Curve* RhinoRibbonOffsetCurve	(	const ON_Curve &	curve_in,
		double	distance,
		double	blend_radius,
		ON_3dPoint	direction_point,
		ON_3dVector	normal,
		double	tolerance,
		ON_SimpleArray< ON_2dPoint > &	CrossParams
	)

Description: Offsets a closed curve in the following way: Project the curve to a plane with given normal. Loose Offset the projection by distance + blend_radius and trim off self-intersection. Offset the remaining curve back in the opposite direction by blend_radius, filling gaps with blends. Finally, use the elevations of the input curve to get the correct elevations of the result. Parameters: curve_in - [in] the curve to offset. distance - [in] the positive distance to offset the curve. blend_radius - [in] Positive, typically the same as distance. When the offset results in a self-intersection that gets trimmed off at a kink, the kink will be blended out using this radius direction_point - [in] a point that indicates the direction of the offset. If the offset is inward, the point's projection to the plane should be well within the curve. It will be used to decide which part of the offset to keep if there are self-intersections. normal - [in] a vector that indicates the normal of the plane in which the offset will occur. tolerance - [in] Used to determine self-intersections, not offset error. CrossParams - [out] A list of parameter pairs for creating cross sections. CP[i].x is for the resulting offset curve. CP[i].y is for curve_in. Returns: the result or nullptr. Remarks:

◆ RhinoRibbonOffsetCurve() [2/2]

RHINO_SDK_FUNCTION ON_Curve* RhinoRibbonOffsetCurve	(	const ON_Curve &	curve_in,
		double	distance,
		double	blend_radius,
		ON_3dPoint	direction_point,
		ON_3dVector	normal,
		double	tolerance,
		ON_SimpleArray< ON_Curve * > *	CrossSections,
		ON_SimpleArray< ON_Surface * > *	RuledSrfs
	)

Description: Offsets a closed curve in the following way: Project the curve to a plane with given normal. Loose Offset the projection by distance + blend_radius and trim off self-intersection. Offset the remaining curve back in the opposite direction by blend_radius, filling gaps with blends. Finally, use the elevations of the input curve to get the correct elevations of the result. Parameters: curve_in - [in] the curve to offset. distance - [in] the positive distance to offset the curve. blend_radius - [in] Positive, typically the same as distance. When the offset results in a self-intersection that gets trimmed off at a kink, the kink will be blended out using this radius direction_point - [in] a point that indicates the direction of the offset. If the offset is inward, the point's projection to the plane should be well within the curve. It will be used to decide which part of the offset to keep if there are self-intersections. normal - [in] a vector that indicates the normal of the plane in which the offset will occur. tolerance - [in] Used to determine self-intersections, not offset error. CrossSections - [out] If not NULL, should be a pointer to valid array. It will contain lines between the input and the offset that might be good for use in sweep2 or another surface creation tool. RuledSrfs - [out] If not NULL, should be a pointer to valid array. It will contain ruled surfaces between the input and the parts of the offset that correspond exactly. There will be gaps between these at blends. Returns: the result or nullptr. Remarks:

◆ RhinoScriptGetMeshParameters()

RHINO_SDK_FUNCTION CRhinoCommand::result RhinoScriptGetMeshParameters ( ON_MeshParameters & mp )

Description: Get mesh parameters in a scriptable manner. Parameters: mp - [in/out] in = current settings Returns: CRhinoCommand::result code

◆ RhinoSdkLoft()

RHINO_SDK_FUNCTION bool RhinoSdkLoft	(	CArgsRhinoLoft &	args,
		ON_SimpleArray< ON_Brep * > &	breps,
		CRhinoHistory *	history = `nullptr`
	)

Rhino SDK function to make a loft surface through curves. Results returned as Breps

◆ RhinoSdkLoftSurface()

RHINO_SDK_FUNCTION bool RhinoSdkLoftSurface	(	CArgsRhinoLoft &	args,
		ON_SimpleArray< ON_NurbsSurface * > &	srfs,
		CRhinoHistory *	history = `nullptr`
	)

Rhino SDK function to make a loft surface through curves.

◆ RhinoSdkServiceRelease()

RHINO_SDK_FUNCTION unsigned int RhinoSdkServiceRelease ( )

Description: Service release of the Rhino SDK supported by this executable. Rhino will only load plug-ins that require a service release of <= this release number.

For example, SR1 will load all plug-ins made with any SDK released up through and including the SR1 SDK. But, SR1 will not load a plug-in built using the SR2 SDK. If an "old" Rhino tries to load a "new" plug-in, the user is told that they have to get a free Rhino.exe update in order for the plug-in to load. Rhino.exe updates are available from http://www.rhino3d.com.

Same as RhinoApp().SdkServiceRelease() Returns: Rhino service release number created by ON_VersionNumberConstruct().

◆ RhinoSdkVersion()

RHINO_SDK_FUNCTION unsigned int RhinoSdkVersion ( )

Description: Base version of the Rhino SDK supported by this Rhino executable. Rhino will only load plug-ins that were build with exactly the same version of the SDK. Same as RhinoApp().SdkVersion() Returns: Rhino SDK version number created by ON_VersionNumberConstruct().

◆ RhinoSelectDimstyle() [1/2]

RHINO_SDK_FUNCTION int RhinoSelectDimstyle ( bool interactive )

Old version replaced 11/09/2009 SDKbreak

Deprecated:: use overload that takes a CRhinoDoc parameter

◆ RhinoSelectDimstyle() [2/2]

RHINO_SDK_FUNCTION int RhinoSelectDimstyle	(	CRhinoDoc &	doc,
		bool	interactive
	)

Added 11/10/2009 to eliminate ActiveDoc() call.

Description Ask user to select an existing DimStyle Parameters: [in] interactive - if true, a dialog is used, otherwise, the commandline is used Returns: integer index of selected style or ON_UNSET_INT_INDEX for none.

◆ RhinoSelectHatchPattern()

RHINO_SDK_FUNCTION int RhinoSelectHatchPattern	(	unsigned int	rhino_doc_sn,
		bool	interactive
	)

Description Ask user to select an existing HatchPattern Parameters: rhino_doc_sn - [in] Required to identify and existing document. [in] interactive - if true, a dialog is used, otherwise, the commandline is used Returns: integer index of selected pattern or ON_UNSET_INT_INDEX for none.

◆ RhinoSelectLayerDialog()

RHINO_SDK_FUNCTION BOOL32 RhinoSelectLayerDialog	(	HWND	hwndParent,
		const wchar_t *	lpsPrompt,
		int &	layer_index,
		BOOL32	bDisplayDialog = `TRUE`,
		BOOL32	bEnableNewLayerButton = `FALSE`,
		BOOL32	bEnableSetLayerCurrentButton = `FALSE`,
		BOOL32 *	pbSetLayerCurrentButtonValue = `nullptr`
	)

Description: Display Rhino's single layer selection dialog. Parameters: hwndParent - [in] Window handle of dialog's parent window. lpsPrompt - [in] The prompt, or title, of the dialog window. layer_index - [in/out] Default layer for the dialog, and will receive new layer if function returns TRUE. bDisplayDialog - [in] If TRUE, a dialog box is displayed. Otherwise, a command line version is displayed. bEnableNewLayerButton- [in] Enable the "New" layer button. bEnableSetLayerCurrentButton - [in] Enable the "Set layer current" checkbox. pbSetLayerCurrentButtonValue - [in/out] Default value for "Set layer current checkbox, and will receive dialog value if function return TRUE.

Returns: TRUE - Dialog or command completed successfully. FALSE - Dialog, or command was canceled.

◆ RhinoSelectMultipleLayersDialog()

RHINO_SDK_FUNCTION BOOL32 RhinoSelectMultipleLayersDialog	(	HWND	hwndParent,
		const wchar_t *	lpsPrompt,
		ON_SimpleArray< int > &	layer_indices,
		BOOL32	bDisplayDialog = `TRUE`,
		BOOL32	bEnableNewLayerButton = `FALSE`
	)

Description: Display Rhino's multiple layer selection dialog. Parameters: hwndParent - [in] Window handle of dialog's parent window. lpsPrompt - [in] The prompt, or title, of the dialog window. layer_indices - [in/out] Default layers for the dialog, and will receive new layers if function returns TRUE. bDisplayDialog - [in] If TRUE, a dialog box is displayed. Otherwise, a command line version is displayed. bEnableNewLayerButton- [in] Enable the "New" layer button. Returns: TRUE - Dialog or command completed successfully. FALSE - Dialog, or command was canceled.

◆ RhinoSeparateBreps()

RHINO_SDK_FUNCTION bool RhinoSeparateBreps	(	const ON_Brep &	in_brep,
		ON_SimpleArray< ON_Brep * > &	out_breps,
		ON_ClassArray< ON_SimpleArray< int >> *	out_keys
	)

Description: Separates, or splits, a disjoint Brep into separate Breps. Parameters: in_brep - [in] The disjoint Brep to separate. out_breps - [out] If input is disjoint, the output pieces. out_keys - [out] Optional array of int arrays, where out_keys->At(i) contains all in_brep.m_face_user.j[1] that contribute to out_breps[i]. With this, the original input can be reconstructed and history can be recorded. Returns: true if the input was separated into multiple pieces. false if error or if the input was not disjoint. Remarks: Memory for the output Breps is allocated and becomes the responsibility of the caller.

◆ RhinoSerialNumberOrdinal()

unsigned int RhinoSerialNumberOrdinal ( unsigned int runtime_serial_number )

Parameters: runtime_serial_number - [in]
Returns: The ordinal portion of a Rhino runtime serial number. Remarks: Rhino runtime serial numbers on docs, views, and so on, are created by setting serial number = (type | ordinal). The type identifies the type (doc, view, ...) and the ordinal identifies which object of that type (1,2,...). The functions RhinoSerialNumberType() and RhinoSerialNumberOrdinal() are used to decompose a runtime serial number into a type and ordinal, typically for printing debugging messages. Example: unsigned int rhino_doc_sn = doc->RuntimeSerialNumber(); RhinoApp().Print("Doc sn type = %u, ordinal = %d\n", RhinoSerialNumberType(rhino_doc_sn), RhinoSerialNumberOrdinal(rhino_doc_sn) );

◆ RhinoSerialNumberType()

unsigned int RhinoSerialNumberType ( unsigned int runtime_serial_number )

Parameters: runtime_serial_number - [in]
Returns: The type portion of a Rhino runtime serial number. Remarks: Rhino runtime serial numbers on docs, views, and so on, are created by setting serial number = (type | ordinal). The type identifies the type (doc, view, ...) and the ordinal identifies which object of that type (1,2,...). The functions RhinoSerialNumberType() and RhinoSerialNumberOrdinal() are used to decompose a runtime serial number into a type and ordinal, typically for printing debugging messages. Example: unsigned int rhino_doc_sn = doc->RuntimeSerialNumber(); RhinoApp().Print("Doc sn type = %u, ordinal = %d\n", RhinoSerialNumberType(rhino_doc_sn), RhinoSerialNumberOrdinal(rhino_doc_sn) );

◆ RhinoSetCursor()

RHINO_SDK_FUNCTION HCURSOR RhinoSetCursor ( HCURSOR hCursor )

Description: Sets the display cursor. Parameters: hCursor - [in] Handle to a cursor. Returns: HCURSOR - Handle to the previous cursor.

◆ RhinoSetExternalPackBrepTexturesRoutine()

RHINO_SDK_FUNCTION bool RhinoSetExternalPackBrepTexturesRoutine ( bool(*)(const ON_SimpleArray< const ON_Mesh * > &meshes, ON_SimpleArray< ON_Mesh * > &packed_tex_out) routine )

Description: Sets external texture packing routine. Parameters: routine [in] - Pointer to a texture packing function. This function takes in two parameters: const ON_SimpleArray<const ON_Mesh*>& meshes Array of Brep meshes. Never modify meshes in this array. ON_SimpleArray<ON_Mesh*>& packed_tex_out Array of empty meshes to transfer packing settings. Routine is supposed to fill in m_packed_tex_domain and m_packed_tex_rotate. Return true if the packing settings in packed_tex_out are good to apply, or false if they are to be discarded. Return: True if the routine is successfully hooked up and otherwise false.

◆ RhinoSetGrevillePoints()

RHINO_SDK_FUNCTION ON_NurbsCurve* RhinoSetGrevillePoints	(	const ON_NurbsCurve &	in_curve,
		int	point_count,
		const ON_3dPoint *	in_points,
		ON_NurbsCurve *	out_curve = `nullptr`
	)

Description: Modifies a NURBS curve's edit, or Greville, points. Parameters: pNurbsCurve - [in] The input NURBS curve. point_count - [in] The number of points in the array. The number of points should match the number of point returned by RhinoGetGrevillePoints(in_curve). in_points - [in] The array of points. out_curve - [in] If not nullptr, this curve will be used and returned. Returns: Pointer to the modified curve if successful, or nullptr on failure Note: if out_curve == nullptr, then memory will be allocated for the returned curve and the caller is responsible for deleting it when finished.

◆ RhinoSetNurbsCurveEndCondition()

RHINO_SDK_FUNCTION bool RhinoSetNurbsCurveEndCondition	(	ON_NurbsCurve *	curve,
		int	end,
		int	continuity,
		const ON_3dPoint &	point,
		const ON_3dVector &	tangent,
		const ON_3dVector &	curvature
	)

RhinoSdkMatchCurve.h.

NoKeywords

/ / Copyright (c) 1993-2007 Robert McNeel & Associates. All rights reserved. / Rhinoceros is a registered trademark of Robert McNeel & Associates. / / THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. / ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF / MERCHANTABILITY ARE HEREBY DISCLAIMED. / / For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. / ////////////////////////////////////////////////////////////// Set end geometry of a nurbs curve to match the specified conditions position, tangency and curvature.

ON_NurbsCurve* curve - Curve to be modified in place bool bSetStart - true: Set start of curve, false: set end of curve int continuity - what to set - 0: nothing, 1: position, 2: position & tangency, 3: position, tangency & curvature ON_3dPoint point - Point to set as curve endpoint ON_3dVector* tangent - Tangent for curve end if tangency is being set, or NULL ON_3dVector* curvature - Curvature for curve end if curvature is being set, or NULL returns bool true if sesuccessful, or false if not

input curve is modified If the curve has too few cvs to set the requested condition, function will do nothing and return false Setting an end condition can move the other end of the curve if there are not enough cvs in the curcve

Parameters

end	end to change - 0: change start, 1: change end
continuity	geometry to be changed - 0: nothing, 1: position, 2: tangency, 3: curvature
point	point to set
tangent	tangency to set
curvature	curvature to set

◆ RhinoShellBrep()

RHINO_SDK_FUNCTION int RhinoShellBrep	(	const ON_Brep &	brep,
		const ON_SimpleArray< int > &	faces_to_remove,
		double	distance,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	shells
	)

Description: Creates a hollowed out shell from a solid Brep. Function only operates on simple, solid, manifold Breps. Parameters: brep [in] - The solid Brep to shell. faces_to_remove [in] - The indices of the Brep faces to remove. These surfaces are removed and the remainder is offset inward, using the outer parts of the removed surfaces to join the inner and outer parts. distance [in] - The distance, or thickness, for the shell. This is a signed distance value with respect to face normals and flipped faces. tolerance [in] - The offset tolerance. When in doubt, use the document's absolute tolerance. shells [out] - The results of the shell calculation. Return: The number of Breps added to the output array.

◆ RhinoShortPath()

RHINO_SDK_FUNCTION ON_Curve* RhinoShortPath	(	const ON_Surface &	Srf,
		ON_2dPoint	start,
		ON_2dPoint	end,
		double	tol
	)

Description: Constructs a geodesic between 2 points, used by ShortPath command in Rhino Parameters: Srf - [in] Surface start - [in] endpoints of curve in parameter space. Points must be distinct end - [in] in the domain of Srf tol - [in] tolerance used in fitting discrete solution Return: Returns a geodesic curve on the surface

◆ RhinoSimpleRollingBallFillet() [1/2]

RHINO_SDK_FUNCTION bool RhinoSimpleRollingBallFillet	(	const ON_BrepFace &	FaceA,
		bool	bFlipA,
		const ON_BrepFace &	FaceB,
		bool	bFlipB,
		double	radius,
		double	tol,
		ON_SimpleArray< ON_Surface * > &	Fillets
	)

Description: Create constant radius rolling ball fillets between two faces. Parameters: FaceA - [in] First face. bFlipA - [in] If true, offset FaceA in direction opposite the surface normal. Note that FaceA.m_bRev is not taken into consideration. FaceB - [in] Second face. bFlipB - [in] If true, offset FaceB in direction opposite the surface normal. Note that FaceB.m_bRev is not taken into consideration. radius - [in] Radius of fillet. If negative, absolute value will be used. tol - [in] Tolerance used for approximating and intersecting offset srfs Fillets -[out] Fillet surfaces. Results will be appended without emptying first. Returns: true if all fillets were created. False otherwise. If Fillets.Count() is larger on exit than on entrance, and the return is false, then some but not all fillets were created. Remarks: THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT SURFACE.

Parameters

radius positive

◆ RhinoSimpleRollingBallFillet() [2/2]

RHINO_SDK_FUNCTION bool RhinoSimpleRollingBallFillet	(	const ON_BrepFace &	FaceA,
		const ON_2dPoint &	uvA,
		const ON_BrepFace &	FaceB,
		const ON_2dPoint &	uvB,
		double	radius,
		double	tol,
		ON_SimpleArray< ON_Surface * > &	Fillets
	)

Description: Create constant radius rolling ball fillets between two faces. Parameters: FaceA - [in] First face. uvA - [in] A point in the parameter space of FaceA near where the fillet is expected to hit the surface. FaceB - [in] Second face. uvA - [in] A point in the parameter space of FaceA near where the fillet is expected to hit the surface. radius - [in] Radius of fillet. If negative, absolute value will be used. tol - [in] Tolerance used for approximating and intersecting offset srfs Fillets -[out] Fillet surfaces. Results will be appended without emptying first. Returns: true if all fillets were created. False otherwise. If Fillets.Count() is larger on exit than on entrance, and the return is false, then some but not all fillets were created. Remarks: uvA and uvB determine the directions of the offsets. The surfaces will be offset towards the middle of the segment from FaceA(uvA) to FaceB(uvB). THE CALLER IS RESPONSIBLE FOR DESTROYING THE OUTPUT SURFACE.

Parameters

radius positive

◆ RhinoSimplifyCurve() [1/2]

RHINO_SDK_FUNCTION bool RhinoSimplifyCurve	(	ON_Curve *&	crv,
		double	dist_tol,
		double	angle_tol
	)

◆ RhinoSimplifyCurve() [2/2]

RHINO_SDK_FUNCTION bool RhinoSimplifyCurve	(	ON_Curve *&	crv,
		int	flags,
		double	dist_tol,
		double	angle_tol
	)

Description Simplify curve replaces the curve with a geometrically equivalent curve. The result is a simple curve or a ON_PolyCurve of at least two simple curve segments.

Simple curves are either ON_LineCurve, ON_PolylineCurve ON_ArcCurve, or ON_NurbsCurve.
Simple NURBS curves do not have fully multiple interior knots.
Simple rational NURBS curves do not have constant weights.
A curve for which IsLinear() is true is simplified to an ON_Line.

A curve for which IsArc() is true and IsLinear() is false is simplified to an ON_Arc.
Adjacent Collinear or Co-circular segments are combined.
Segments that meet with G1-continuity have there ends tuned up so that they meet with G1-continuity to within machine precision NOTE* Unlike V3, V4 RhinoSimplifyCurve can return a simple curve, instead of a one-segment polycurve. Parameters: crv [in/out] - input curve can be of any ON_Curve type. output curve is an ON_PolyCurve. flags - [in] - flags specifying which function to use to simplify curve. dist_tol [in] - angle_tol [in] - Details: The default of flags=0 implies all of the simplification functions will be used. DONT_SPLIT_FMK Don't split NurbsCurves at fully multiple knots DONT_REBUILD_LINES Don't replace segments with IsLinear()==true with ON_LineCurves DONT_REBUILD_ARCS Don't replace segments with IsArc()==true with ON_Arc DONT_REBUILD_RATIONALS Don't replace rational NURBS curves with constant denominator with an equivalent non-rational ON_NurbsCurve DONT_ADJUST_G1 Don't adjust Curves at G1-joins. DONT_MERGE Don't merge adjacent co-linear lines or co-circular arc or combine consecutive line segments into a polyline

The distance_tolerance is used in the following stages Detecting lines and arcs

Both distance_tolerance and angle_tolerance are used in the following stages Detecting G1 continuity Detecting co-linearity of adjacent line segments and co-circularity of adjacent arcs

If in doubt about what to use for the tolerance settings use dist_tol = CRhinoDoc.AbsoluteTolerance(), and angle_tol = CRhinoDoc.AngleToleranceRadians()

Returns: true if the curve is modified

◆ RhinoSimplifyCurveEnd()

RHINO_SDK_FUNCTION bool RhinoSimplifyCurveEnd	(	ON_Curve *&	pC,
		int	side,
		int	flags,
		double	dist_tol,
		double	angle_tol
	)

Description: Same as RhinoSimplifyCurve, but simplifies only the last two segments at "side" end. Parameters: side - [in] - specifies end to simplify. 0=start, 1=end See Also RhinoSimplifyCurve

◆ RhinoSmoothCurve() [1/2]

RHINO_SDK_FUNCTION ON_Curve* RhinoSmoothCurve	(	const ON_Curve *	pInput,
		double	dSmoothFactor,
		bool	bXSmooth,
		bool	bYSmooth,
		bool	bZSmooth,
		bool	bFixBoundaries,
		int	nCoordinateSystem
	)

Deprecated:: use the version of RhinoSmoothCurve that accepts a plane parameter

◆ RhinoSmoothCurve() [2/2]

RHINO_SDK_FUNCTION ON_Curve* RhinoSmoothCurve	(	const ON_Curve *	pInput,
		double	dSmoothFactor,
		bool	bXSmooth,
		bool	bYSmooth,
		bool	bZSmooth,
		bool	bFixBoundaries,
		int	nCoordinateSystem,
		const ON_Plane *	pPlane
	)

Description: Smooths curves. The parameters are the same as in Smooth command. Parameters: pInput [in] - Curve to smooth dSmoothFactor [in] - The smoothing factor. Controls how much control points move towards the average of the neighboring points. bXSmooth [in] - When true control points move in X axis direction bYSmooth [in] - When true control points move in Y axis direction bZSmooth [in] - When true control points move in Z axis direction bFixBoundaries [in] - When true the curve ends don't move nCoordinateSystem [in] - Current coordinate system. 0=World, 1=CPlane, 2=Object. pPlane [in] = If nCoordinateSystem == 1, then the construction plane. Otherwise pass nullptr. Return: ON_Curve* - The resulting curve or nullptr. NOTE, memory for the curve is allocated and becomes the responsibility of the caller.

◆ RhinoSmoothMesh() [1/5]

RHINO_SDK_FUNCTION ON_Mesh* RhinoSmoothMesh	(	const ON_Mesh *	pInput,
		const ON_SimpleArray< int > &	InVertices,
		double	dSmoothFactor,
		bool	bXSmooth,
		bool	bYSmooth,
		bool	bZSmooth,
		bool	bFixBoundaries,
		int	nCoordinateSystem,
		const ON_Plane *	pPlane
	)

Description: Smooths part of a mesh. The parameters are the same as in Smooth command. Parameters: pInput [in] - Mesh to smooth InVertices [in] - The mesh vertex indices that specify the part of the mesh to smooth. dSmoothFactor [in] - The smoothing factor. Controls how much control points move towards the average of the neighboring points. bXSmooth [in] - When true control points move in X axis direction bYSmooth [in] - When true control points move in Y axis direction bZSmooth [in] - When true control points move in Z axis direction bFixBoundaries [in] - When true the mesh edges don't move nCoordinateSystem [in] - Current coordinate system. 0=World, 1=CPlane, 2=Object. pPlane [in] = If nCoordinateSystem == 1, then the construction plane. Otherwise pass nullptr. Return: ON_Mesh* - The resulting mesh or nullptr. NOTE, memory for the mesh is allocated and becomes the responsibility of the caller.

◆ RhinoSmoothMesh() [2/5]

RHINO_SDK_FUNCTION ON_Mesh* RhinoSmoothMesh	(	const ON_Mesh *	pInput,
		const ON_SimpleArray< int > &	InVertices,
		double	dSmoothFactor,
		int	numSteps,
		bool	bXSmooth,
		bool	bYSmooth,
		bool	bZSmooth,
		bool	bFixBoundaries,
		int	nCoordinateSystem,
		const ON_Plane *	pPlane
	)

Description: Smooths part of a mesh. The parameters are the same as in Smooth command. Parameters: pInput [in] - Mesh to smooth InVertices [in] - The mesh vertex indices that specify the part of the mesh to smooth. dSmoothFactor [in] - The smoothing factor. Controls how much control points move towards the average of the neighboring points. numSteps [in] - The number of smoothing iterations. bXSmooth [in] - When true control points move in X axis direction bYSmooth [in] - When true control points move in Y axis direction bZSmooth [in] - When true control points move in Z axis direction bFixBoundaries [in] - When true the mesh edges don't move nCoordinateSystem [in] - Current coordinate system. 0=World, 1=CPlane, 2=Object. pPlane [in] = If nCoordinateSystem == 1, then the construction plane. Otherwise pass nullptr. Return: ON_Mesh* - The resulting mesh or nullptr. NOTE, memory for the mesh is allocated and becomes the responsibility of the caller.

◆ RhinoSmoothMesh() [3/5]

RHINO_SDK_FUNCTION ON_Mesh* RhinoSmoothMesh	(	const ON_Mesh *	pInput,
		double	dSmoothFactor,
		bool	bXSmooth,
		bool	bYSmooth,
		bool	bZSmooth,
		bool	bFixBoundaries,
		int	nCoordinateSystem
	)

Deprecated:: use the version of RhinoSmoothMesh that accepts a plane parameter

◆ RhinoSmoothMesh() [4/5]

RHINO_SDK_FUNCTION ON_Mesh* RhinoSmoothMesh	(	const ON_Mesh *	pInput,
		double	dSmoothFactor,
		bool	bXSmooth,
		bool	bYSmooth,
		bool	bZSmooth,
		bool	bFixBoundaries,
		int	nCoordinateSystem,
		const ON_Plane *	pPlane
	)

Description: Smooths meshes. The parameters are the same as in Smooth command. Parameters: pInput [in] - Mesh to smooth dSmoothFactor [in] - The smoothing factor. Controls how much control points move towards the average of the neighboring points. bXSmooth [in] - When true control points move in X axis direction bYSmooth [in] - When true control points move in Y axis direction bZSmooth [in] - When true control points move in Z axis direction bFixBoundaries [in] - When true the mesh edges don't move nCoordinateSystem [in] - Current coordinate system. 0=World, 1=CPlane, 2=Object. pPlane [in] = If nCoordinateSystem == 1, then the construction plane. Otherwise pass nullptr. Return: ON_Mesh* - The resulting mesh or nullptr. NOTE, memory for the mesh is allocated and becomes the responsibility of the caller.

◆ RhinoSmoothMesh() [5/5]

RHINO_SDK_FUNCTION ON_Mesh* RhinoSmoothMesh	(	const ON_Mesh *	pInput,
		double	dSmoothFactor,
		int	numSteps,
		bool	bXSmooth,
		bool	bYSmooth,
		bool	bZSmooth,
		bool	bFixBoundaries,
		int	nCoordinateSystem,
		const ON_Plane *	pPlane
	)

Description: Smooths meshes. The parameters are the same as in Smooth command. Parameters: pInput [in] - Mesh to smooth dSmoothFactor [in] - The smoothing factor. Controls how much control points move towards the average of the neighboring points. numSteps [in] - The number of smoothing iterations. bXSmooth [in] - When true control points move in X axis direction bYSmooth [in] - When true control points move in Y axis direction bZSmooth [in] - When true control points move in Z axis direction bFixBoundaries [in] - When true the mesh edges don't move nCoordinateSystem [in] - Current coordinate system. 0=World, 1=CPlane, 2=Object. pPlane [in] = If nCoordinateSystem == 1, then the construction plane. Otherwise pass nullptr. Return: ON_Mesh* - The resulting mesh or nullptr. NOTE, memory for the mesh is allocated and becomes the responsibility of the caller.

◆ RhinoSmoothSurface() [1/2]

RHINO_SDK_FUNCTION ON_Surface* RhinoSmoothSurface	(	const ON_Surface *	pInput,
		double	dSmoothFactor,
		bool	bXSmooth,
		bool	bYSmooth,
		bool	bZSmooth,
		bool	bFixBoundaries,
		int	nCoordinateSystem
	)

Deprecated:: use the version of RhinoSmoothSurface that accepts a plane parameter

◆ RhinoSmoothSurface() [2/2]

RHINO_SDK_FUNCTION ON_Surface* RhinoSmoothSurface	(	const ON_Surface *	pInput,
		double	dSmoothFactor,
		bool	bXSmooth,
		bool	bYSmooth,
		bool	bZSmooth,
		bool	bFixBoundaries,
		int	nCoordinateSystem,
		const ON_Plane *	pPlane
	)

Description: Smooths surfaces. The parameters are the same as in Smooth command. Parameters: pInput [in] - Surface to smooth dSmoothFactor [in] - The smoothing factor. Controls how much control points move towards the average of the neighboring points. bXSmooth [in] - When true control points move in X axis direction bYSmooth [in] - When true control points move in Y axis direction bZSmooth [in] - When true control points move in Z axis direction bFixBoundaries [in] - When true the surface edges don't move nCoordinateSystem [in] - Current coordinate system. 0=World, 1=CPlane, 2=Object. pPlane [in] = If nCoordinateSystem == 1, then the construction plane. Otherwise pass nullptr. Return: ON_Surface* - The resulting surface or nullptr. NOTE, memory for the surface is allocated and becomes the responsibility of the caller.

◆ RhinoSnapToNurbsCurve()

RHINO_SDK_FUNCTION bool RhinoSnapToNurbsCurve	(	const CRhinoObject *	object,
		const ON_NurbsCurve &	nurbs_curve,
		const CRhinoSnapContext &	snap_context,
		CRhinoSnapEvent &	snap_event
	)

Description: A function to help CRhinoPhantomObject support snapping. Parameters: object - [in] nurbs_curve - [in] snap_context - [in] snap_event - [in] Example: Add snapping support to a widget.

    class CMyWidget : public CRhinoPhantomObject
    {
      ...
      bool SnapTo( 
        const CRhinoSnapContext& snap_context,
        CRhinoSnapEvent& snap_event
        ) const;
      ...
    };

    bool CMyWidget::SnapTo( 
        const CRhinoSnapContext& snap_context,
        CRhinoSnapEvent& snap_event
        ) const
    {

/ Get a NURBS curve representation of the wire objects / to snap to. ON_NurbsCurve nurbs_curve = ...; return RhinoSnapToNurbsCurve(this,nurbs_curve,snap_context,snap_event); }

◆ RhinoSoftEditCrv()

RHINO_SDK_FUNCTION ON_Curve* RhinoSoftEditCrv	(	const ON_Curve *	curve,
		double	curve_t,
		const ON_3dVector &	delta,
		double	length,
		bool	bFixEnds
	)

Description: Soft edit of a curve from a parameter on curve using smooth field of influence. Parameters: curve - [in] The curve to soft edit. curve_t - [in] A parameter on the curve to move from. This location on the curve is moved, and the move is smoothly tapered off with increasing distance along the curve from this parameter. delta - [in] The direction and magnitude, or maximum distance, of the move. length - [in] The distance along the curve from the editing point over which the strength of the editing falls off smoothly. bFixEnds - [in] Keeps the position of the curve ends fixed. Returns: The modified curve if successful, NULL otherwise. Remarks: Memory for the result curve is allocated and becomes the responsibility of the caller.

◆ RhinoSoftEditSrf()

RHINO_SDK_FUNCTION ON_Surface* RhinoSoftEditSrf	(	const ON_Surface *	surface,
		const ON_2dPoint &	uv,
		const ON_3dVector &	delta,
		double	u_length,
		double	v_length,
		double	tolerance,
		bool	bFixEnds
	)

Description: Soft edit of a surface from a uv parameter using smooth field of influence Parameters: surface - [in] The surface to soft edit. uv - [in] A point in the parameter space to move from. This location on the surface is moved, and the move is smoothly tapered off with increasing distance along the surface from this parameter. delta - [in] The direction and magnitude, or maximum distance, of the move. u_length - [in] The distance along the surface's u-direction from the editing point over which the strength of the editing falls off smoothly. v_length - [in] The distance along the surface's v-direction from the editing point over which the strength of the editing falls off smoothly. tolerance - [in] The active document's model absolute tolerance. bFixEnds - [in] Keeps edge locations fixed. Returns: The modified surface if successful, NULL otherwise. Remarks: Memory for the result surface is allocated and becomes the responsibility of the caller.

◆ RhinoSortPointList() [1/3]

RHINO_SDK_FUNCTION bool RhinoSortPointList	(	int	point_count,
		const ON_2dPoint *	points,
		int *	order,
		double	mindist
	)

Description: Sort a list of points so they will be connected in "reasonable polyline" order. Parameters: point_count - [in] number of points points - [in] array of point_count 2d points order - [out] sorted list of indices so that points[order[0]], points[order[1]], , points[order[n]] will be a reasonable polyline. mindist - [in] minimum distance between points to use. Throw out ones closer than this. Returns: true if it works.

◆ RhinoSortPointList() [2/3]

RHINO_SDK_FUNCTION bool RhinoSortPointList	(	int	point_count,
		const ON_3dPoint *	points,
		int *	order,
		double	mindist
	)

Description: Sort a list of points so they will be connected in "reasonable polyline" order. Parameters: point_count - [in] number of points points - [in] array of point_count 3d points order - [out] sorted list of indices so that points[order[0]], points[order[1]], , points[order[n]] will be a reasonable polyline. mindist - [in] minimum distance between points to use. Throw out ones closer than this. Returns: true if it works.

◆ RhinoSortPointList() [3/3]

RHINO_SDK_FUNCTION bool RhinoSortPointList	(	ON_SimpleArray< ON_3dPoint > &	points,
		double	mindist = `ON_ZERO_TOLERANCE`
	)

Description: Sort a list of points so they will be connected in "reasonable polyline" order. Parameters: points - [in/out] list of 3d points that is sorted to be in reasonable polyline order. mindist - [in] minimum distance between points to use. Throw out ones closer than this. Returns: true if it works.

◆ RhinoSplitBrepFace()

RHINO_SDK_FUNCTION ON_Brep* RhinoSplitBrepFace	(	const ON_Brep &	brep,
		int	face_index,
		const ON_SimpleArray< const ON_Curve * > &	curves,
		double	tolerance,
		bool	bCopySurface = `false`
	)

Description: Splits a face into pieces using 3d trimming curves. Parameters: brep - [in] the base Brep. face_index - [in] index of face in m_F[] array to split. curves - [in] array of 3d curves used for trimming. tolerance - [in] fitting and intersecting tolerance. When in doubt, use the document's absolute tolerance. bCopySurface - [in] if TRUE and the face is split, then the surface(s) used by the new face(s) will be copied. Returns The resulting Brep or nullptr. Note, memory for the Brep is allocated and becomes the responsibility of the caller. Remarks: If the face is split, the portion of the face to the left of the trim at the start of the trim remains in m_F[face_index]. Any additional faces are appended to the m_F[] array.

◆ RhinoSplitDisjointMesh()

RHINO_SDK_FUNCTION int RhinoSplitDisjointMesh	(	const ON_Mesh *	pMesh,
		ON_SimpleArray< ON_Mesh * > &	MeshArray,
		bool	bJustCount = `false`
	)

Description: Splits up the input mesh into its unconnected pieces. If bJustCount is true then it returns the number of meshes that the input mesh would be split into.

Parameters: pMesh - Input mesh. MeshArray - Output array of meshes. bJustCount - Input flag to determine whether to actually split the input mesh Returns: Returns number of meshes the input mesh would be split into, 0 on failure.

◆ RhinoSplitFaceAtTangents()

RHINO_SDK_FUNCTION bool RhinoSplitFaceAtTangents	(	ON_Brep &	brep,
		int	face_index
	)

Description: Splits a face of a Brep at tangent locations. Parameters: brep - [in/out] The Brep. face_index - [in] The index of the Brep face to split. Returns: True if successful, false otherwise.

◆ RhinoSplitFacesAtTangents()

RHINO_SDK_FUNCTION bool RhinoSplitFacesAtTangents ( ON_Brep & brep )

Description: Splits all of the faces of a Brep at tangent locations. Parameters: brep - [in/out] The Brep. Returns: True if successful, false otherwise.

◆ RhinoSplitMeshEdge() [1/2]

RHINO_SDK_FUNCTION bool RhinoSplitMeshEdge	(	ON_Mesh *	pMesh,
		const int	edgeidx,
		const ON_SimpleArray< double > &	params
	)

Description: This function will split up a mesh edge at the given parameters.

Parameters: pMesh - [In / Out] Mesh to be altered topei - [In] Topological edge index to be swapped params - [In] Parameters at which to split up the edge

Returns: true on success.

Remarks: All parameters must be 0.0 <= t >= 1.0 or the function will bail early and return false;

◆ RhinoSplitMeshEdge() [2/2]

RHINO_SDK_FUNCTION bool RhinoSplitMeshEdge	(	ON_Mesh *	pMesh,
		const int	edgeidx,
		const ON_SimpleArray< ON_3dPoint > &	points
	)

Description: This function will split up a mesh edge at the given points.

Parameters: pMesh - [In / Out] Mesh to be altered topei - [In] Topological edge index to be swapped points - [In] Points at which to split up the edge

Returns: true on success.

Remarks: Points must be on the line, created by the edge at edgeidx, on or between the start and end points. If any point does not fit that criteria the function will bail early and return false.

◆ RhinoSplitRefitSurface()

RHINO_SDK_FUNCTION int RhinoSplitRefitSurface	(	const ON_Surface *	surface,
		const ON_Curve *	curve,
		ON_3dVector	projDir,
		bool	bMeetCurve,
		ON_SimpleArray< double >	knots,
		double	tolerance,
		bool	bBezierSections,
		ON_SimpleArray< ON_NurbsSurface * > &	FitSurfacesLower,
		ON_SimpleArray< ON_NurbsSurface * > &	FitSurfacesUpper,
		ON_SimpleArray< ON_NurbsCurve * > &	FitCurves,
		ON_Curve **	trimCurveOnSurface,
		ON_Curve **	splitCurve,
		double *	FitMeasurement
	)

Parameters

trimCurveOnSurface if not null, returns the actual projected or pulled trim curve used for the split/fit

◆ RhinoSrfControlPtGrid()

RHINO_SDK_FUNCTION ON_NurbsSurface* RhinoSrfControlPtGrid	(	int	point_count[2],
		int	degree[2],
		const ON_3dPointArray &	point_array,
		ON_NurbsSurface *	nurbs_surface = `nullptr`
	)

Description: Creates a NURBS surface from a 2D grid of control points Parameters: point_count - [in] The number of points in the U and V directions. degree - [in] The surface degree in the U and V directions. point_array - [in] The grid (array) of control points. nurbs_surface - [in] If not NULL, this surface will be used and returned. Returns: Pointer to a NURBS surface curve. Returns NULL if failure. If nurbs_surface == NULL, the default, the user must delete the curve when done with it.

◆ RhinoSrfPtGrid()

RHINO_SDK_FUNCTION ON_NurbsSurface* RhinoSrfPtGrid	(	int	point_count[2],
		int	degree[2],
		BOOL32	is_closed[2],
		const ON_3dPointArray &	point_array,
		ON_NurbsSurface *	nurbs_surface = `nullptr`
	)

Description: Creates a NURBS surface from a 2D grid of points Parameters: point_count - [in] The number of points in the U and V directions. degree - [in] The surface degree in the U and V directions. is_closed - [in] Whether or not the surface is closed in the U and V directions. point_array - [in] The grid (array) of points. nurbs_surface - [in] If not NULL, this surface will be used and returned. Returns: Pointer to a NURBS surface curve. Returns NULL if failure. If nurbs_surface == NULL, the default, the user must delete the curve when done with it.

◆ RhinoStraightenBrep()

RHINO_SDK_FUNCTION int RhinoStraightenBrep	(	ON_Brep &	B,
		double	tol = `0.0`
	)

Description: If any surface in a Brep is very nearly G1-continuous, move control points to make it exactly G1. Parameters: B - [in] Brep to straighten. tol - [in] tolerance. Control points will be moved if they do not need to be moved any more than tol. If tol <= 0, the Rhino document tolerance will be used. Returns: number of surfaces that were changed See Also: RhinoMakeG1Surface

◆ RhinoSubDLoft()

RHINO_SDK_FUNCTION bool RhinoSubDLoft	(	const ON_SimpleArray< const ON_NurbsCurve * > &	shape_curves,
		bool	bClosedLoft,
		bool	bSubDCorners,
		bool	bSubDCreases,
		int	nDivisions,
		ON_SubD *	result_subd
	)

Description: Creates a SubD surface lofted through shape curves. Parameters: shape_curves [in] - Array of SubD-friendly NURBS curves to loft through bClosedLoft [in] - Creates a SubD that is closed in the lofting direction. Must have three or more shape curves. bSubDCorners [in] - With open curves, adds creased vertices to the SubD at both ends of the first and last curves. bSubDCreases [in] - With kinked curves, adds creased edges to the SubD along the kinks. nDivisions [in] - The segment number between adjacent input curves. result_subd [in/out] - Pointer to an empty SubD to return the loft result. Returns: true if successful, false otherwise. Remarks: Curves must be in the proper order and orientation and have point counts for the desired surface. Curves must be either all open or all closed.

◆ RhinoSubDSweep1()

RHINO_SDK_FUNCTION bool RhinoSubDSweep1	(	const ON_NurbsCurve *	rail_curve,
		const ON_SimpleArray< const ON_NurbsCurve * > &	shape_curves,
		bool	bSubDCorners,
		bool	bClosedSweep,
		bool	bFrameStyle,
		ON_3dVector	frame_up,
		ON_SubD *	result_subd
	)

Description: Fits a SubD surface through a series of profile curves that define the SubD cross-sections and one curve that defines a SubD edge. Parameters: rail_curve [in] - A SubD-friendly NURBS curve to sweep along. shape_curves [in] - Array of SubD-friendly NURBS curves to sweep through. bSubDCorners [in] - With open curves, adds creased vertices to the SubD at both ends of the first and last curves. bClosedSweep [in] - Creates a SubD that is closed in the rail curve direction. bFrameStyle [in] - Determines how sweep frame rotations are calculated: true: Freeform - Frames are propagated based on a reference direction taken from the rail curve curvature direction. false: Roadlike - Frame rotations are calculated based on a vector supplied in "frameup" and the world coordinate system. frame_up [in] - A 3D vector used to calculate the frame rotations for sweep shapes (not used if bFrameStyle is true). result_subd [in/out] - Pointer to an empty SubD to return the sweep result. Returns: true if successful, false otherwise. Remarks: Shape curves must be in the proper order and orientation. Shape curves must have the same point counts and rail curves must have the same point counts. Shape curves will relocated to the nearest pair of Greville points on the rails. Shape curves will be made at each pair of rail edit points where there isn't an input shape.

◆ RhinoSubDSweep2()

RHINO_SDK_FUNCTION bool RhinoSubDSweep2	(	const ON_SimpleArray< const ON_NurbsCurve * > &	rail_curves,
		const ON_SimpleArray< const ON_NurbsCurve * > &	shape_curves,
		bool	bSubDCorners,
		bool	bClosedSweep,
		ON_SubD *	result_subd
	)

Description: Fits a SubD surface through a series of profile curves that define the SubD cross-sections and two curves that defines SubD edges. Parameters: rail_curves [in] - Array of 2 SubD-friendly NURBS curve to sweep along. shape_curves [in] - Array of SubD-friendly NURBS curves to sweep through. bSubDCorners [in] - With open curves, adds creased vertices to the SubD at both ends of the first and last curves. bClosedSweep [in] - Creates a SubD that is closed, continuing past the last curve around to the first curve. result_subd [in/out] - Pointer to an empty SubD to return the sweep result. Returns: true if successful, false otherwise. Remarks: Shape curves must be in the proper order and orientation. Shape curves must have the same point counts and rail curves must have the same point counts. Shape curves will relocated to the nearest pair of Greville points on the rails. Shape curves will be made at each pair of rail edit points where there isn't an input shape.

◆ RhinoSurfaceDraftAnglePoint()

RHINO_SDK_FUNCTION bool RhinoSurfaceDraftAnglePoint	(	const ON_BrepFace &	face,
		const ON_2dPoint &	test_point,
		double	test_angle,
		const ON_3dVector &	direction,
		bool	bEdge,
		ON_3dPoint &	draft_point,
		double *	draft_angle
	)

Description: Returns the surface draft angle and point at a parameter. Parameters: face - [in] The Brep face to evaluate. uv - [in] The u,v parameter on the face to evaluate. test_angle - [in] The angle in radians to test. direction - [in] The pull direction. bEdge - [in] Restricts the point placement to an edge. draft_point - [out] The draft angle point. draft_angle - [out] The draft angle in radians. Returns: True if successful, false otherwise.

◆ RhinoSurfaceFromPlane()

RHINO_SDK_FUNCTION ON_NurbsSurface* RhinoSurfaceFromPlane	(	const ON_Plane &	plane,
		ON_Interval	u_interval,
		ON_Interval	v_interval,
		int	u_degree,
		int	v_degree,
		int	u_points,
		int	v_points,
		ON_NurbsSurface *	pOutSrf = `nullptr`
	)

Description: Creates a NURBS surface from a plane and additional parameters. Parameters: plane - [in] The plane. u_extents - [in] The interval of the output surface in the U direction. v_extents - [in] The interval of the output surface in the V direction. u_degree - [in] The degree of the output surface in the U direction. v_degree - [in] The degree of the output surface in the V direction. u_points - [in] The number of control points of the output surface in the U direction. v_points - [in] The number of control points of the output surface in the V direction. pOutSrf - [in/out] If not nullptr, this surface will be used for output. Returns: The output surface or nullptr. Note, if nullptr is passed as pOutSrf, then memory for the output surface is allocated and becomes the responsibility of the caller.

◆ RhinoSwapMeshEdge()

RHINO_SDK_FUNCTION bool RhinoSwapMeshEdge	(	const ON_Mesh *	pInputMesh,
		int	topei,
		ON_Mesh **	pOutputMesh = `nullptr`
	)

Description: This function will swap the orientation of an edge shared by two (only) triangles.

| /| |\ | | / | -> | \ | |/ | | |

Parameters: mesh - [In] Input mesh topei - [In] Topological edge index to be swapped pOutputMesh - [In] Optional output mesh. If null, the return indicates whether the edge could be swapped. If not null, and success, *pOutputMesh will be a copy of mesh with the edge swapped.

Returns: true on success.

◆ RhinoSweep1()

RHINO_SDK_FUNCTION BOOL32 RhinoSweep1	(	CArgsRhinoSweep1 &	args,
		ON_SimpleArray< ON_Brep * > &	brep_array
	)

Public Sweep functions Results are returned in brep_array

◆ RhinoSweep1Ex()

RHINO_SDK_FUNCTION BOOL32 RhinoSweep1Ex	(	CArgsRhinoSweep1 &	args,
		int	shape_blending,
		ON_SimpleArray< ON_Brep * > &	brep_array
	)

Description: Creates a surface through profile curves that define the surface shape and one curve that defines a surface edge. Parameters: args - [in] The sweep1 arguments shape_blending - [in] Shape blending, where: Local (shape_blending = 0), the sweep stays constant at the ends and changes more rapidly in the middle. Global (shape_blending = 1), the sweep is linearly blended from one end to the other, creating sweeps that taper from one cross-section curve to the other. brep_array - [out] The results of the sweep. NOTE: THE CALLER IS RESPONSIBLE FOR DESTROYING THESE OBJECTS. Returns: TRUE if successful

◆ RhinoSweep2()

RHINO_SDK_FUNCTION BOOL32 RhinoSweep2	(	CArgsRhinoSweep2 &	args,
		ON_SimpleArray< ON_Brep * > &	brep_array
	)

◆ RhinoTaperedExtrudeCurveWithRef() [1/2]

RHINO_SDK_FUNCTION bool RhinoTaperedExtrudeCurveWithRef	(	const ON_Curve &	Crv,
		const ON_3dVector &	ExtrudeDir,
		double	dist,
		double	draft,
		const ON_3dPoint &	ReferencePoint,
		const ON_3dVector &	ReferenceDir,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	Extrusions
	)

Parameters

tolerance For intersecting and trimming

◆ RhinoTaperedExtrudeCurveWithRef() [2/2]

RHINO_SDK_FUNCTION bool RhinoTaperedExtrudeCurveWithRef	(	const ON_Curve &	Crv,
		const ON_3dVector &	ExtrudeDir,
		double	dist,
		double	draft,
		const ON_3dPoint &	ReferencePoint,
		const ON_3dVector &	ReferenceDir,
		ON_SimpleArray< ON_Surface * > &	ExtrusionSrfs
	)

Description: Create a polysurface by extruding a curve a distance along an axis with draft angle. The end of the extrusion will be on a plane parallel to ReferenceDir, a distance of dist from ReferencePoint. Parameters: Crv - [in] The curve to extrude. ExtrudeDir - [in] The extrusion direction. dist - [in] The extrusion distance. draft - [in] The extrusion draft angle. ReferencePoint - [in] The reference point, generally be a point on the curve. ReferenceDir - [in] The reference direction. For planar curves, a natural choice for ReferenceDir will be the plane's normal. In any case, ReferenceDir = ExtrudeDir may make sense. ExtrusionSrfs - [out] The results of the extrusion. Returns: true if successful, false otherwise. Remarks; The result will have a face for each G1 section of Crv, and may be disjoint. NOTE: Memory for the surfaces is allocated and becomes the responsibility of the caller.

◆ RhinoTaperedExtrudeSmoothCurveWithRef()

RHINO_SDK_FUNCTION ON_Surface* RhinoTaperedExtrudeSmoothCurveWithRef	(	const ON_Curve &	Crv,
		const ON_3dVector &	ExtrudeDir,
		double	dist,
		double	draft,
		const ON_3dPoint &	ReferencePoint,
		const ON_3dVector &	ReferenceDir
	)

Description: Create a surface by extruding a smooth, G1 curve a distance along an axis with draft angle. The end of the extrusion will be on a plane parallel to ReferenceDir, a distance of dist from ReferencePoint. Parameters: Crv - [in] The smooth, G1 curve to extrude. ExtrudeDir - [in] The extrusion direction. dist - [in] The extrusion distance. draft - [in] The extrusion draft angle. ReferencePoint - [in] The reference point, generally be a point on the curve. ReferenceDir - [in] The reference direction. For planar curves, a natural choice for ReferenceDir will be the plane's normal. In any case, ReferenceDir = ExtrudeDir may make sense. Returns: A surface if successful, nullptr otherwise. Remarks; If Crv is not G1, nullptr will be returned. Use RhinoTaperedExtrudeCurveWithRef instead. NOTE: Memory for the surface is allocated and becomes the responsibility of the caller.

◆ RhinoTransformBrepComponents()

RHINO_SDK_FUNCTION bool RhinoTransformBrepComponents	(	ON_Brep *	brep,
		int	brep_component_count,
		const ON_COMPONENT_INDEX *	brep_components,
		ON_Xform	xform,
		double	tolerance,
		double	time_limit,
		bool	bUseMultipleThreads
	)

Description: Transform a list of Brep components, bend neighbors to match, and leave the rest fixed. Parameters: brep - [in] The Brep to modify component_count - [in] Length of brep_components[] array brep_components - [in] Components to transform. xform - [in] Transformation to apply to components tolerance - [in] Desired fitting tolerance to use when bending faces that share edges with both fixed and transformed components. time_limit - [in] If the deformation is extreme, it can take a long time to calculate the result. If time_limit > 0, then the value specifies the maximum amount of time in seconds you want to spend before giving up. bMultipleThreads - [in] True if multiple threads can be used. Returns: True if successful.

◆ RhinoTriangulate2dRegion()

RHINO_SDK_FUNCTION int RhinoTriangulate2dRegion	(	int	point_count,
		int	point_stride,
		const double *	point,
		int	edge_count,
		int	edge_stride,
		const int *	edge,
		const int *	edge_side,
		ON_SimpleArray< ON_3dex > &	triangles
	)

Description: Fill in a 2d region with triangles. Parameters: point_count - [in] number of 2d points. point_stride - [in] i-th point = (point[j],point[j+1]), where j = i*point_stride. point - [in] 2d point locations. It is OK to include points that are inside the region but not at the end of an edge. Duplicate points are not permitted. edge_count - [in] number of edges (if 0, then the input list of point is treated as a counterclockwise closed polyline. edge_stride - [in] i-th edge connects points (edge[j],edge[j+1]) where j = i*edge_stride. edge - [in] indices of edge ends. Edges can intersect only at shared end points. edge_side - [in] if NULL, the triangles are built on the left side of the edges. If not NULL, then edge[i] determines which side(s) of the edge need triangles. 1 = left side only, 2 = right side only, 3 = both sides triangles - [out] triangles are appended to this list. The (i,j,k) are vertex indices. Returns: Number of triangles appended to triangles[] array.

◆ RhinoTriangulate3dPolygon()

RHINO_SDK_FUNCTION int RhinoTriangulate3dPolygon	(	int	point_count,
		int	point_stride,
		const double *	P,
		int	tri_stride,
		int *	triangle
	)

Description: Triangulate a 3D simple closed polygon that projects onto a plane. The polygon must project to a plane and the projected polygon must be a simple closed curve. Do NOT duplicate the start/end point; i.e., a triangle will have a point count of 3 and P will specify 3 distinct non-collinear points. Parameters: point_count - [in] number of points in polygon ( >= 3 ) point_stride - [in] the point stride P - [in] an array of points, where: i-th point = {P[i*point_stride], P[i*point_stride+1], P[i*point_stride+2]} tri_stride - [in] the triangle stride triangle - [out] an array of (point_count-2)*tri_stride integers Returns: 0 if successful <0 on failure Remarks: The polygon is trianglulated into point_count-2 triangles. The indices of the 3 points that are the corner of the i-th (0<= i < point_count-2) triangle are {triangle[i*tri_stride], triangle[i*tri_stride+1], triangle[i*tri_stride+2]}.

◆ RhinoTurnOnCaptiveGrips()

RHINO_SDK_FUNCTION CRhinoObjectGrips* RhinoTurnOnCaptiveGrips	(	const CRhinoMorphControl *	control_object,
		const CRhinoObject *	captive_object
	)

Description: Turns on captive's grips. 1) The captive object must already be captured by RhinoCaptureObject()
2) The control object must have grips on. 3) The captive object must not have grips on. Parameters: control_object - [in] captive_object - [in] Returns: Pointer to captive grips if successful.

◆ RhinoTweenCurves()

RHINO_SDK_FUNCTION bool RhinoTweenCurves	(	const ON_Curve *	start_crv,
		const ON_Curve *	end_crv,
		int	num_of_crvs,
		double	tol,
		ON_SimpleArray< ON_Curve * > &	tween_crvs
	)

Description: Creates curves between two open or closed input curves. Parameters: start_crv [in] - Start curve. end_crv [in] - End curve. num_of_crvs [in] - Number of tween curves. tol [in] - Tolerance to use, if unsure use document tolerance. tween_crvs [out] - Output array of tween curves Return: True if successful, false otherwise. Remarks: Uses the control points of the curves for finding tween curves. That means the first control point of first curve is matched to first control point of the second curve and so on. There is no matching of curves direction. Caller must match input curves direction before calling the function.

◆ RhinoTweenCurvesWithMatching()

RHINO_SDK_FUNCTION bool RhinoTweenCurvesWithMatching	(	const ON_Curve *	start_crv,
		const ON_Curve *	end_crv,
		int	num_of_crvs,
		double	tol,
		ON_SimpleArray< ON_Curve * > &	tween_crvs
	)

Description: Creates curves between two open or closed input curves. Make the structure of input curves compatible if needed. Parameters: start_crv [in] - Start curve. end_crv [in] - End curve. num_of_crvs [in] - Number of tween curves. tol [in] - Tolerance to use, if unsure use document tolerance. tween_crvs [out] - Output array of tween curves Return: True if successful, false otherwise. Remarks: Refits the input curves to have the same structure. The resulting curves are usually more complex than input unless input curves are compatible and no refit is needed. There is no matching of curves direction. Caller must match input curves direction before calling the function.

◆ RhinoTweenCurveWithSampling()

RHINO_SDK_FUNCTION bool RhinoTweenCurveWithSampling	(	const ON_Curve *	start_crv,
		const ON_Curve *	end_crv,
		int	num_of_crvs,
		int	sample_num,
		double	tol,
		ON_SimpleArray< ON_Curve * > &	tween_crvs
	)

Description: Creates curves between two open or closed input curves. Use sample points method to make curves compatible. Parameters: start_crv [in] - Start curve. end_crv [in] - End curve. num_of_crvs [in] - Number of tween curves. sample_num [in] - Number of sample points along input curves. tol [in] - Tolerance to use, if unsure use document tolerance. tween_crvs [out] - Output array of tween curves. Return: True if successful, false otherwise. Remarks: This is how the algorithm works: Divides the two curves into an equal number of points, finds the midpoint between the corresponding points on the curves and interpolates the tween curve through those points. There is no matching of curves direction. Caller must match input curves direction before calling the function.

◆ RhinoTweenSurfacesSamplePoints()

RHINO_SDK_FUNCTION bool RhinoTweenSurfacesSamplePoints	(	const ON_Surface *	srf0,
		const ON_Surface *	srf1,
		int	num_of_tween_srfs,
		int	num_of_sample_pts,
		double	tol,
		ON_SimpleArray< ON_Surface * > &	out_srfs
	)

Description: Create tween surfaces that gradually transition between 2 bounding surfaces using point sampling Parameters : srf0 - [in] first surface. srf1 - [in] second surface. num_of_tween_srfs - [in] number of tween surfaces. num_of_sample_pts - [in] number of sample points. tol - [in] tolerance. out_srfs - [out] output tween surfaces Returns : true if valid tween surfaces found.

◆ RHINOUI_DIB_CALLOC()

void* RHINOUI_DIB_CALLOC	(	size_t	num,
		size_t	size
	)

◆ RHINOUI_DIB_FREE()

void RHINOUI_DIB_FREE ( void * memblock )

◆ RHINOUI_DIB_MALLOC()

void* RHINOUI_DIB_MALLOC ( size_t size )

◆ RhinoUiCopyHBitmap()

RHINO_SDK_FUNCTION HBITMAP RhinoUiCopyHBitmap ( HBITMAP hBitmapSrc )

◆ RhinoUiDIBBltToDib()

RHINO_SDK_FUNCTION bool RhinoUiDIBBltToDib	(	BITMAPINFO &	bmi_target,
		LPBYTE	dest_bits,
		long	x_dest,
		long	y_dest,
		long	cx,
		long	cy,
		BITMAPINFO &	bmi_source,
		LPBYTE	src_bits,
		long	x_src,
		long	y_src
	)

◆ RhinoUiDIBColorDepth() [1/2]

RHINO_SDK_FUNCTION int RhinoUiDIBColorDepth ( const BITMAPINFO & bmi )

◆ RhinoUiDIBColorDepth() [2/2]

RHINO_SDK_FUNCTION int RhinoUiDIBColorDepth ( const BITMAPINFOHEADER & bmih )

◆ RhinoUiDIBCopy()

RHINO_SDK_FUNCTION LPBITMAPINFO RhinoUiDIBCopy ( const BITMAPINFO & bmi )

◆ RhinoUiDIBCopyFromClipboard()

RHINO_SDK_FUNCTION LPBITMAPINFO RhinoUiDIBCopyFromClipboard ( HWND hwnd )

◆ RhinoUiDIBCopyToClipboard()

RHINO_SDK_FUNCTION bool RhinoUiDIBCopyToClipboard	(	HWND	hwnd,
		const BITMAPINFO &	bmi
	)

◆ RhinoUiDIBCopyToHandle()

RHINO_SDK_FUNCTION HANDLE RhinoUiDIBCopyToHandle ( const BITMAPINFO & bmi )

◆ RhinoUiDIBCreate()

RHINO_SDK_FUNCTION LPBITMAPINFO RhinoUiDIBCreate	(	long	width,
		long	height,
		int	color_depth
	)

◆ RhinoUiDIBCreateHBitmap()

RHINO_SDK_FUNCTION HBITMAP RhinoUiDIBCreateHBitmap	(	const BITMAPINFO &	bmi,
		HPALETTE	hpal = `nullptr`
	)

◆ RhinoUiDIBFindBits()

RHINO_SDK_FUNCTION LPBYTE RhinoUiDIBFindBits ( const BITMAPINFO & bmi )

◆ RhinoUiDIBGet256Palette()

RHINO_SDK_FUNCTION bool RhinoUiDIBGet256Palette	(	const BITMAPINFO &	bmi,
		RGBQUAD *	rgb
	)

◆ RhinoUiDIBGetPixel() [1/3]

RHINO_SDK_FUNCTION bool RhinoUiDIBGetPixel	(	BITMAPINFO &	bmi,
		const LPBYTE	dib_bits,
		int	c_depth,
		long	x,
		long	y,
		unsigned char *	r,
		unsigned char *	g,
		unsigned char *	b,
		unsigned char *	a = `nullptr`
	)

◆ RhinoUiDIBGetPixel() [2/3]

RHINO_SDK_FUNCTION bool RhinoUiDIBGetPixel	(	BITMAPINFO &	bmi,
		long	x,
		long	y,
		unsigned char *	r,
		unsigned char *	g,
		unsigned char *	b,
		unsigned char *	a = `nullptr`
	)

◆ RhinoUiDIBGetPixel() [3/3]

RHINO_SDK_FUNCTION bool RhinoUiDIBGetPixel	(	BITMAPINFO &	bmi,
		unsigned char *	base,
		long	x,
		unsigned char *	r,
		unsigned char *	g,
		unsigned char *	b
	)

◆ RhinoUiDIBHBitmapToDIB()

BITMAPINFO* RhinoUiDIBHBitmapToDIB	(	HBITMAP	hBitmap,
		HPALETTE	hpal = `nullptr`
	)

◆ RhinoUiDIBHeight() [1/2]

RHINO_SDK_FUNCTION long RhinoUiDIBHeight ( const BITMAPINFO & bmi )

◆ RhinoUiDIBHeight() [2/2]

RHINO_SDK_FUNCTION long RhinoUiDIBHeight ( const BITMAPINFOHEADER & bmih )

◆ RhinoUiDibInstallMemManager()

void RhinoUiDibInstallMemManager	(	void ()(size_t num, size_t size)	my_calloc,
		void ()(size_t size)	my_malloc,
		void()(void memblock)	my_free
	)

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer.

◆ RhinoUiDIBLineSize() [1/2]

RHINO_SDK_FUNCTION DWORD RhinoUiDIBLineSize ( const BITMAPINFO & bmi )

◆ RhinoUiDIBLineSize() [2/2]

RHINO_SDK_FUNCTION DWORD RhinoUiDIBLineSize ( const BITMAPINFOHEADER & bmih )

◆ RhinoUiDIBNumColors() [1/2]

RHINO_SDK_FUNCTION int RhinoUiDIBNumColors ( const BITMAPINFO & bmi )

◆ RhinoUiDIBNumColors() [2/2]

RHINO_SDK_FUNCTION int RhinoUiDIBNumColors ( const BITMAPINFOHEADER & bmih )

◆ RhinoUiDIBPaletteSize() [1/2]

RHINO_SDK_FUNCTION long RhinoUiDIBPaletteSize ( const BITMAPINFO & bmi )

◆ RhinoUiDIBPaletteSize() [2/2]

RHINO_SDK_FUNCTION long RhinoUiDIBPaletteSize ( const BITMAPINFOHEADER & bmih )

◆ RhinoUiDIBScanWidth()

RHINO_SDK_FUNCTION DWORD RhinoUiDIBScanWidth ( const BITMAPINFO & bmi )

◆ RhinoUiDIBSet256IdentityPalette()

RHINO_SDK_FUNCTION bool RhinoUiDIBSet256IdentityPalette	(	BITMAPINFO &	bmi,
		HPALETTE	hpal
	)

◆ RhinoUiDIBSet256PalColors()

RHINO_SDK_FUNCTION bool RhinoUiDIBSet256PalColors ( BITMAPINFO & bmi )

◆ RhinoUiDIBSet256Palette()

RHINO_SDK_FUNCTION bool RhinoUiDIBSet256Palette	(	BITMAPINFO &	bmi,
		RGBQUAD *	rgb
	)

◆ RhinoUiDIBSetPixel() [1/2]

RHINO_SDK_FUNCTION bool RhinoUiDIBSetPixel	(	BITMAPINFO &	bmi,
		long	x,
		long	y,
		unsigned char	r,
		unsigned char	g,
		unsigned char	b,
		unsigned char	a
	)

◆ RhinoUiDIBSetPixel() [2/2]

RHINO_SDK_FUNCTION bool RhinoUiDIBSetPixel	(	BITMAPINFO &	bmi,
		LPBYTE	dib_bits,
		int	c_depth,
		long	x,
		long	y,
		unsigned char	r,
		unsigned char	g,
		unsigned char	b,
		unsigned char	a
	)

◆ RhinoUiDIBSize()

RHINO_SDK_FUNCTION DWORD RhinoUiDIBSize ( const BITMAPINFO bmi )

◆ RhinoUiDIBSizeBits()

RHINO_SDK_FUNCTION DWORD RhinoUiDIBSizeBits ( const BITMAPINFO bmi )

◆ RhinoUiDIBWidth() [1/2]

RHINO_SDK_FUNCTION long RhinoUiDIBWidth ( const BITMAPINFO & bmi )

◆ RhinoUiDIBWidth() [2/2]

RHINO_SDK_FUNCTION long RhinoUiDIBWidth ( const BITMAPINFOHEADER & bmih )

◆ RhinoUiDIBXPixelsPerMeter() [1/2]

RHINO_SDK_FUNCTION long RhinoUiDIBXPixelsPerMeter ( const BITMAPINFO & bmi )

◆ RhinoUiDIBXPixelsPerMeter() [2/2]

RHINO_SDK_FUNCTION long RhinoUiDIBXPixelsPerMeter ( const BITMAPINFOHEADER & bmih )

◆ RhinoUiDIBYPixelsPerMeter() [1/2]

RHINO_SDK_FUNCTION long RhinoUiDIBYPixelsPerMeter ( const BITMAPINFO & bmi )

◆ RhinoUiDIBYPixelsPerMeter() [2/2]

RHINO_SDK_FUNCTION long RhinoUiDIBYPixelsPerMeter ( const BITMAPINFOHEADER & bmih )

◆ RhinoUiSetDIBGray256Palette()

RHINO_SDK_FUNCTION bool RhinoUiSetDIBGray256Palette	(	BITMAPINFO &	bmi,
		HPALETTE	hpal,
		COLORREF	base_color = `RGB(0, 0, 255)`
	)

◆ RhinoUnifyMeshNormals()

RHINO_SDK_FUNCTION ON_Mesh* RhinoUnifyMeshNormals	(	const ON_Mesh &	origmesh,
		ON_Mesh *	pNewMesh = `0`,
		bool	bGetCountOnly = `false`,
		int *	pCount = `0`
	)

Description: Function that attempts to fix inconsistenties in the directions of meshfaces for a mesh. Parameters: origmesh - Input. pNewMesh - Output. If pNewMesh is not null the the return will be pNewMesh also. bGetCountOnly - Input. Default is false. If set to true no mesh is modified and the return is null. pCount - Output. If pCount is not null and bGetCountOnly is true then pCount is the number of faces that would be modified. Returns: If bGetCountOnly is false then the return is a pointer to a copy of origmesh with the appropriate faces flipped. If pNewMesh is not null then the return is pNewMesh. If pNewMesh is null and bGetCountOnly is true then the return will be null. Remarks: bGetCountOnly and pCount were added so the function could be used to examine the origmesh without the need to create a new modified mesh.

◆ RhinoUnjoinEdges()

RHINO_SDK_FUNCTION bool RhinoUnjoinEdges	(	const ON_Brep &	InBrep,
		const ON_SimpleArray< int > &	eids,
		ON_SimpleArray< ON_Brep * > &	OutBreps
	)

Description: Unjoins, or separates, edges within a Brep. Note, seams in closed surfaces will not separate. Parameters: InBrep - [in] The input Brep eids - [in] An array of one or more Brep edge indices. OutBreps - [out] The results of the unjoin operation. Returns: true if successful, false otherwise.

◆ RhinoUnWeldMesh() [1/2]

RHINO_SDK_FUNCTION ON_Mesh* RhinoUnWeldMesh	(	const ON_Mesh &	OldMesh,
		double	angle_tol,
		bool	ModifyNormals,
		ON_Mesh *	pOutputMesh = `0`
	)

Description: RhinoUnWeldMesh will make sure that faces sharing an edge and having a difference of normal greater than or equal to angle_tol have unique vertices along that edge, adding vertices if necessary.

Parameters: OldMesh - [In] Mesh to be unwelded angle_tol - [In] Angle at which to make unique vertices as described above ModifyNormals - [In] Determines whether new vertex normals will have the same vertex normal as the original (false) or vertex normals made from the corresponding face normals (true) pOutputMesh - [Out] If pOutputMesh is not null then the return will be pOutputMesh;

Returns: The an unwelded version of the OldMesh.

◆ RhinoUnWeldMesh() [2/2]

RHINO_SDK_FUNCTION ON_Mesh* RhinoUnWeldMesh	(	const ON_Mesh &	OldMesh,
		double	angle_tol,
		ON_Mesh *	pOutputMesh = `0`
	)

Description: RhinoUnWeldMesh will make sure that faces sharing an edge and having a difference of normal greater than or equal to angle_tol have unique vertices along that edge, adding vertices if necessary.

Parameters: OldMesh - [In] Mesh to be unwelded angle_tol - [In] Angle at which to make unique vertices as described above pOutputMesh - [Out] If pOutputMesh is not null then the return will be pOutputMesh;

Returns: The an unwelded version of the OldMesh.

◆ RhinoUnweldMeshEdge()

RHINO_SDK_FUNCTION ON_Mesh* RhinoUnweldMeshEdge	(	const ON_Mesh &	mesh,
		const ON_SimpleArray< int > &	edges,
		bool	bModifyNormal
	)

Description: Adds creases to a smooth mesh by creating coincident vertices along selected edges. Parameters: mesh - [in] The mesh to unweld edges on. edges - [in] An array of mesh topology edge indices. bModifyNormals - [in] If true, the vertex normals on each side of the edge take the same value as the face to which they belong, giving the mesh a hard edge look. If false, each of the vertex normals on either side of the edge is assigned the same value as the original normal that the pair is replacing, keeping a smooth look. Returns: A pointer to the modified mesh if successful, or nullptr on failure. Remarks: NOTE: Memory for the mesh is allocated and becomes the responsibility of the caller.

◆ RhinoUnWeldMeshVertexes()

RHINO_SDK_FUNCTION ON_Mesh* RhinoUnWeldMeshVertexes	(	const ON_Mesh &	input,
		ON_SimpleArray< int >	indexes,
		bool	ModifyNormals
	)

Description: RhinoUnWeldMeshVertexes will make sure that faces sharing a common topological vertex have unique indexes into the output meshes m_V array.

Parameters: input - [In] Mesh to be unwelded indexes - [In] Topological vertex indices to be unwelded (see ON_MeshTopology::m_topv, use ON_MeshTopology::m_topv_map to convert from mesh vertex indices) ModifyNormals - [In] If true, the new vertex normals will be calculated from the face normal.

Returns: The an unwelded version of the input mesh. Should not happen, but calling function confirm that the pointer returned is not null.

◆ RhinoUpdateCachedTextureFromDib()

RHINO_SDK_FUNCTION bool RhinoUpdateCachedTextureFromDib	(	unsigned int	hTexture,
		const CRhinoDib &	Dib
	)

Description: Updates the given cached texture's contents with the contents of the passed in Dib. Note: If the resolution of the Dib is not the same as the cached texture's, then a new cached texture will be created in its place, re-using the same cached handle. For performance purposes, it is recommended that you try to manage using matching resolutions when updating cached textures.

Parameters: hTexture - handle to a valid cached texture (obtained by calling GetCachedTexture()) Dib - Image contents used to update the cached texture's contents.

Returns: True - if/when the updating of the cached texture succeeds. False - if/when something failed during the update process.

◆ RhinoUpdateCachedTextureFromFile()

RHINO_SDK_FUNCTION bool RhinoUpdateCachedTextureFromFile	(	unsigned int	hTexture,
		const ON_wString &	Filename
	)

Description: Updates the given cached texture's contents with the contents of the passed in file name. Obviously the file name must represent one of the many image file formats currently supported by Rhino.

Note: Calling this method can cause performance hits since it reads in files from disk. Therefore it is important that you keep track of when a cached texture needs updating, and only update it when necessary and not just blindly call the update method for every frame update.

Parameters: hTexture - handle to a valid cached texture (obtained by calling GetCachedTexture()) Filename - Name of an existing and supported image file on disk.

Returns: True - if/when the updating of the cached texture succeeds. False - if/when something failed during the updating process or if the file could not be opened or is an invalid/unsupported image file format.

◆ RhinoUpdateGripOwner()

RHINO_SDK_FUNCTION CRhinoObject* RhinoUpdateGripOwner	(	CRhinoObject *	old_object,
		bool	bCopyObject,
		ON_2dexMap *	group_remap
	)

Description: The grips positions are used to calculate updated objects and these objects are added to the Rhino document. Parameters: old_object - [in] Object in document with grips currently on. bCopyObject - [in] If false, the updated object(s) replace the originals in the document. Otherwise, the new objects are simply added to the document group_remap - [in] If bCopyObject is true and group_remap is not NULL, the copies are put in new groups. If bCopyObject is false, then group_remap is ignored. Returns: A pointer to the new object if successful.

◆ RhinoUpdateObjectGroups() [1/2]

RHINO_SDK_FUNCTION void RhinoUpdateObjectGroups	(	CRhinoObject *	new_object,
		ON_2dexMap &	group_map
	)

Description: In some situations, a bunch of objects are copied, new new groups need to be created. This function handles the details. Parameters: new_object - [in/out] New object with group attributes of the old object. group_map - [in/out] A map from old group indices to new group indices.

◆ RhinoUpdateObjectGroups() [2/2]

RHINO_SDK_FUNCTION void RhinoUpdateObjectGroups	(	CRhinoObjectAttributes &	attributes,
		ON_2dexMap &	group_map
	)

Description: In some situations, a bunch of objects are copied, new new groups need to be created. This function handles the details. Parameters: attributes - [in/out] Attributes of the new object with group indices copied from the old object. group_map - [in/out] A map from old group indices to new group indices.

◆ RhinoUuidToString() [1/2]

RHINO_SDK_FUNCTION void RhinoUuidToString	(	const UUID &	uuid,
		char	s[37]
	)

◆ RhinoUuidToString() [2/2]

RHINO_SDK_FUNCTION void RhinoUuidToString	(	const UUID &	uuid,
		wchar_t	s[37]
	)

Description: Converts a UUID to a string.

◆ RhinoVariableOffsetSurface()

RHINO_SDK_FUNCTION ON_Surface* RhinoVariableOffsetSurface	(	const ON_Surface &	InputSrf,
		const double	corner_dists[2][2],
		const ON_SimpleArray< ON_2dPoint > &	uv,
		const ON_SimpleArray< double > &	dists,
		double	tolerance
	)

Description: Copies a surface so that all locations at the corners of the copied surface are specified distances from the original surface. Optionally, you can specify interior locations and their offset distances. If the uv and dist arrays are empty, then the distance at any interior point will be found by doing a bilinear interpolation of the corner distances. Parameters: InputSrf - [in] The surface to offset. corner_dists - [in] The offset distances as the corners. uv - [in] An array of surface interior uv parameters to offset at. The count of this array much match that of the dists array. dists - [in] An array of offset distances at the interior uv parameters. The count of this array much match that of the uv array. tolerance - [in] The tolerance used when offsetting. Returns: A pointer to the offset surface if successful. Remarks: NOTE: Memory for the surface is allocated and becomes the responsibility of the caller.

Parameters

[in]	corner_dists	[umin,umax][vmin,vmax]
	uv	Not at the corners, all different

◆ RhinoWeldMesh()

RHINO_SDK_FUNCTION ON_Mesh* RhinoWeldMesh	(	const ON_Mesh &	MeshIn,
		double	angle_tol,
		ON_Mesh *	pMeshOut = `0`
	)

Description: RhinoWeldMesh will make sure that faces sharing an edge and having a difference of normal greater than or equal to angle_tol share vertices along that edge, vertex normals are averaged.

Parameters: MeshIn - [In] Mesh to be welded angle_tol - [In] Angle at which to make unique vertices as described above pMeshOut - [Out] If pMeshOut is not null then the return will be pMeshOut;

Returns: The a welded version of the MeshIn.

◆ RhinoWeldMeshEdges()

RHINO_SDK_FUNCTION ON_Mesh* RhinoWeldMeshEdges	(	const ON_Mesh &	mesh,
		const ON_SimpleArray< int > &	edges
	)

◆ RhinoWriteHatchPatternFile()

RHINO_SDK_FUNCTION bool RhinoWriteHatchPatternFile	(	const wchar_t *	filename,
		const ON_ObjectArray< ON_HatchPattern > &	patterns
	)

Description: Write hatch pattern definitions to a file. Parameters: filename - [in] Name of file to create. If file exists, it will be overwritten. patterns - [in] Hatch patterns to be written to the file. Returns: true if success, false otherwise. Notes: File will be in AutoCAD .PAT format.

◆ RhinoYesNoMessageBox() [1/2]

RHINO_SDK_FUNCTION RhinoYesNoResponse RhinoYesNoMessageBox	(	const wchar_t *	lpsText,
		const wchar_t *	lpsCaption = `nullptr`,
		int	nIncludeButtons = `1\|4`,
		UINT	nMessageBoxTypeCodes = `MB_ICONQUESTION\|MB_DEFBUTTON1`
	)

Description: Display Rhino question message box. This is a special Rhino dialog which may be used to ask Yes/No questions. If you are going to ask the same question more than once you can include "Yes to All" and "No to All" buttons, see the nIncludeButtons parameter for details. Parameters: lpsText - [in] Message to display lpsCaption - [in] Optional caption to display as dialog title. If this is NULL or "" then default application title is used. nIncludeButtons - [in] Buttons to display, you may or the following: 1 = yes button 2 = yes to all button 4 = no button 8 = no to all button 16 = cancel_button 0xffffffff = all buttons nMessageBoxTypeCodes - [in] Optional message box codes. Currently supports MB_ICON... and MB_DEFBUTTON? arguments. See documentation for MessageBox() Returns: 0 = error displaying dialog 1 = yes button 2 = yes to all button 3 = no button 4 = no to all button 5 = cancel button

Parameters

nIncludeButtons Yes and No buttons

◆ RhinoYesNoMessageBox() [2/2]

RHINO_SDK_FUNCTION RhinoYesNoResponse RhinoYesNoMessageBox	(	HWND	hWndParent,
		const wchar_t *	lpsText,
		const wchar_t *	lpsCaption = `nullptr`,
		int	nIncludeButtons = `1\|4`,
		UINT	nMessageBoxTypeCodes = `MB_ICONQUESTION\|MB_DEFBUTTON1`
	)

Description: Display Rhino question message box. This is a special Rhino dialog which may be used to ask Yes/No questions. If you are going to ask the same question more than once you can include "Yes to All" and "No to All" buttons, see the nIncludeButtons parameter for details. Parameters: hWndParent - [in] Parent for message box. lpsText - [in] Message to display lpsCaption - [in] Optional caption to display as dialog title. If this is NULL or "" then default application title is used. nIncludeButtons - [in] Buttons to display, you may or the following: 1 = yes button 2 = yes to all button 4 = no button 8 = no to all button 16 = cancel_button nMessageBoxTypeCodes - [in] Optional message box codes. Currently supports MB_ICON... and MB_DEFBUTTON? arguments. See documentation for MessageBox() Returns: 0 = error displaying dialog 1 = yes button 2 = yes to all button 3 = no button 4 = no to all button 5 = cancel button

Parameters

nIncludeButtons Yes and No buttons

◆ RhMaxIntSnapCandidateCount()

int RhMaxIntSnapCandidateCount ( )

12 April 2021, Mikko, RH-63759: Global clamp for max int snap candiadte count. For the last 15 or so years it was set to 1000, but it made block snapping slow due to int snap candidate array duplication. Trying setting the clamp to 100.

◆ RhPlanarRegionBoolean()

RHINO_SDK_FUNCTION bool RhPlanarRegionBoolean	(	const ON_SimpleArray< const ON_Brep * > &	InRegions,
		const ON_Plane &	plane,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	OutRegions,
		ON_SimpleArray< bool > *	pbRev = `nullptr`
	)

Description: Merges planar faces. Parameters: InRegions - [in] Array of Breps, each with a single face with a planar surface. Will fail if any do not satisfy this requirement. plane - [in] The planar faces should be on or parallel to this plane. The results will be on this plane. tolerance - [in] Used to detect overlapping and near-missing edges. OutRegion - [out] OutRegions will consist of the union of the projected regions, each member will have a single face with a planar surface based on plane. pbRev - [in] if non-null, pbRev must have the same size as InRegions. if null, the array will be assumed to have all elements = false if pbRev[i] = true, the complement of InRegions[i] will be used in the boolean. if pbRev is non-null, the complement of the union of the regions or complements will be returned. For Union, no array is necessary. For intersection of 2 regions, bRev[0] = bRev[1] = true. For A-B bRev[0] = true, bRev[1] = false Returns: true if successful, false otherwise.

◆ RhPlanarRegionDifference()

RHINO_SDK_FUNCTION bool RhPlanarRegionDifference	(	const ON_Brep *	B0,
		const ON_Brep *	B1,
		const ON_Plane &	plane,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	OutRegions
	)

Description: Find difference of two planar faces, B0 - B1. Parameters: B0, B1 - [in] Breps to be subtracted, each with a single face with a planar surface. plane - [in] The planar faces should be on or parallel to this plane. The results will be on this plane. OutRegions - [out] OutRegions will consist of the union of the projected regions, each member will have a single face with a planar surface based on plane. Returns: true if successful, false otherwise.

◆ RhPlanarRegionIntersection()

RHINO_SDK_FUNCTION bool RhPlanarRegionIntersection	(	const ON_Brep *	B0,
		const ON_Brep *	B1,
		const ON_Plane &	plane,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	OutRegions
	)

Description: Find intersection of two planar faces. Parameters: B0, B1 - [in] Breps to be intersected, each with a single face with a planar surface. plane - [in] The planar faces should be on or parallel to this plane. The results will be on this plane. tolerance - [in] Used to decide if edges overlap. OutRegions - [out] OutRegions will consist of the union of the projected regions, each member will have a single face with a planar surface based on plane. Returns: true if successful, false otherwise.

◆ RhPlanarRegionUnion() [1/2]

RHINO_SDK_FUNCTION bool RhPlanarRegionUnion	(	const ON_Brep *	B0,
		const ON_Brep *	B1,
		const ON_Plane &	plane,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	OutRegions
	)

Description: Find Union of multiple planar faces. Parameters: InRegions - [in] Array of Breps, each with a single face with a planar surface. Will fail if any do not satisfy this requirement. plane - [in] The planar faces should be on or parallel to this plane. The results will be on this plane. tolerance - [in] Used to decide if edges overlap. OutRegions - [out] OutRegions will consist of the union of the projected regions, each member will have a single face with a planar surface based on plane. Returns: true if successful, false otherwise.

◆ RhPlanarRegionUnion() [2/2]

RHINO_SDK_FUNCTION bool RhPlanarRegionUnion	(	const ON_SimpleArray< const ON_Brep * > &	InRegions,
		const ON_Plane &	plane,
		double	tolerance,
		ON_SimpleArray< ON_Brep * > &	OutRegions
	)

Description: Find Union of two planar faces. Parameters: B0, B1 - [in] Breps to be unioned, each with a single face with a planar surface. plane - [in] The planar faces should be on or parallel to this plane. The results will be on this plane. tolerance - [in] Used to decide if edges overlap. OutRegions - [out] OutRegions will consist of the union of the projected regions, each member will have a single face with a planar surface based on plane. Returns: true if successful, false otherwise.

◆ RhResetAllMessageBoxes()

RHINO_SDK_FUNCTION void RhResetAllMessageBoxes ( )

◆ UnregisterDisplayPipeline()

RHINO_SDK_FUNCTION bool UnregisterDisplayPipeline ( const ON_ClassId * )

Variable Documentation

◆ angTolerance

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Brep const ON_Plane ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > double double angTolerance

Initial value:

= ON_UNSET_VALUE

)

◆ brepObjects

const ON_SimpleArray< const CRhinoBrepObject * > & brepObjects

◆ brepSplitter

const ON_SimpleArray<const CRhinoBrepObject*> const ON_Brep& brepSplitter

◆ distTolerance

const ON_SimpleArray< const CRhinoBrepObject * > const ON_Brep const ON_Plane ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > ON_SimpleArray< CRhinoCurveObject * > double distTolerance = ON_UNSET_VALUE

◆ LPCRECT

const typedef RECT* LPCRECT

◆ LPCSTR

const typedef char* LPCSTR

◆ LPCTSTR

const typedef wchar_t* LPCTSTR

◆ LPCWSTR

const typedef wchar_t* LPCWSTR

◆ pBackgroundCurves

const ON_SimpleArray<const CRhinoBrepObject*> const ON_Brep const ON_Plane ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*>* pBackgroundCurves = nullptr

◆ pBackgroundHiddenCurves

const ON_SimpleArray<const CRhinoBrepObject*> const ON_Brep const ON_Plane ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*>* pBackgroundHiddenCurves = nullptr

◆ pForegroundCurves

const ON_SimpleArray<const CRhinoBrepObject*> const ON_Brep const ON_Plane ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*>* pForegroundCurves = nullptr

◆ pForegroundHiddenCurves

const ON_SimpleArray<const CRhinoBrepObject*> const ON_Brep const ON_Plane ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*>* pForegroundHiddenCurves = nullptr

◆ pProjectedHiddenCurves

const ON_SimpleArray<const CRhinoBrepObject*> const ON_Plane ON_SimpleArray<CRhinoCurveObject*> ON_SimpleArray<CRhinoCurveObject*>* pProjectedHiddenCurves = nullptr

◆ projectedCurves

const ON_SimpleArray<const CRhinoBrepObject*> const ON_Plane ON_SimpleArray<CRhinoCurveObject*>& projectedCurves

◆ projectionPlane

=

{ 0x2e5fe617, 0x7d66, 0x4ea0, { 0x85, 0x72, 0xa1, 0xc3, 0xf8, 0xf0, 0x6b, 0x84 } }

THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY DISCLAIMED.

For complete Rhino SDK copyright information see http://www.rhino3d.com/developer. These ids are passed to CRhinoObject::InAnalysisMode() to answer queries about what types of analysis modes are active. This ID is used to check for any shaded analysis mode: false color (like draft angle) or texture based (like zebra and emap). {2E5FE617-7D66-4ea0-8572-A1C3F8F06B84} NOTE: The static is a mistake - it should not be here, however removing it will break the SDK. Because of the static, in each file that includes this header, there is source file scope copy of this id.

◆ RHINO_TEXTURED_ANALYSIS_MODE_ID

const ON_UUID RHINO_TEXTURED_ANALYSIS_MODE_ID

static

Initial value:

=

{ 0xdf0d8626, 0x3bea, 0x4471, { 0xb8, 0xd9, 0x1e, 0x85, 0xa7, 0x96, 0x79, 0x85 } }

This ID is used to check for any texture based analysis mode like zebra or emap. {DF0D8626-3BEA-4471-B8D9-1E85A7967985} NOTE: The static is a mistake - it should not be here, however removing it will break the SDK. Because of the static, in each file that includes this header, there is source file scope copy of this id.

◆ RHINO_THICKNESS_ANALYSIS_MODE_ID

const ON_UUID RHINO_THICKNESS_ANALYSIS_MODE_ID

static

Initial value:

=

{ 0xb28e5435, 0xd299, 0x4933, { 0xa9, 0x5d, 0x37, 0x83, 0xc4, 0x96, 0xfc, 0x66 } }

{B28E5435-D299-4933-A95D-3783C496FC66} NOTE: The static is a mistake - it should not be here, however removing it will break the SDK. Because of the static, in each file that includes this header, there is source file scope copy of this id.

◆ RHINO_WIREFRAME_ANALYSIS_MODE_ID

const ON_UUID RHINO_WIREFRAME_ANALYSIS_MODE_ID

static

Initial value:

=

{ 0x43bb9491, 0x51e9, 0x493a, { 0xb8, 0x38, 0x89, 0x53, 0x6d, 0xd0, 0x9, 0x60 } }

{43BB9491-51E9-493a-B838-89536DD00960} NOTE: The static is a mistake - it should not be here, however removing it will break the SDK. Because of the static, in each file that includes this header, there is source file scope copy of this id.

◆ RHINO_ZEBRA_STRIPE_ANALYSIS_MODE_ID

const ON_UUID RHINO_ZEBRA_STRIPE_ANALYSIS_MODE_ID

static

Initial value:

=

{ 0xcca817c, 0x95d0, 0x4b79, { 0xb5, 0xd7, 0xce, 0xb5, 0xa2, 0x97, 0x5c, 0xe0 } }

In zebra stripe analysis mode, zebra stripes are shown on surfaces and meshes. {0CCA817C-95D0-4b79-B5D7-CEB5A2975CE0} NOTE: The static is a mistake - it should not be here, however removing it will break the SDK. Because of the static, in each file that includes this header, there is source file scope copy of this id.

Namespaces

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ _CRT_SECURE_NO_DEPRECATE

◆ _WIN32_IE

◆ _WIN32_WINDOWS

◆ _WIN32_WINNT

◆ CONST

◆ CRhinoPickList

◆ DECLARE_DYNAMIC_PIPELINE

◆ DECLARE_PIPELINE_ATTRIBUTE_CLASS

◆ ERROR_ACCESS_DENIED

◆ ERROR_FILE_NOT_FOUND

◆ ERROR_INVALID_DATA

◆ ERROR_INVALID_FUNCTION

◆ ERROR_INVALID_PIXEL_FORMAT

◆ ERROR_MOD_NOT_FOUND

◆ ERROR_MORE_DATA

◆ ERROR_NO_MORE_ITEMS

◆ ERROR_PROC_NOT_FOUND

◆ ERROR_SUCCESS

◆ GetAValue

◆ GetBValue

◆ GetGValue

◆ GetRValue

◆ HIBYTE

◆ IMPLEMENT_DYNAMIC_PIPELINE

◆ LOBYTE

◆ MAC_DEPRECATED

◆ MB_APPLMODAL

◆ MB_DEFAULT_DESKTOP_ONLY

◆ MB_DEFBUTTON1

◆ MB_DEFBUTTON2

◆ MB_DEFBUTTON3

◆ MB_DEFMASK

◆ MB_HELP

◆ MB_ICONASTERISK

◆ MB_ICONERROR

◆ MB_ICONEXCLAMATION

◆ MB_ICONHAND

◆ MB_ICONINFORMATION

◆ MB_ICONMASK

◆ MB_ICONQUESTION

◆ MB_ICONSTOP

◆ MB_ICONWARNING

◆ MB_MISCMASK

◆ MB_MODEMASK

◆ MB_NOFOCUS

◆ MB_RIGHT

◆ MB_RTLREADING

◆ MB_SERVICE_NOTIFICATION

◆ MB_SERVICE_NOTIFICATION_NT3X

◆ MB_SETFOREGROUND

◆ MB_SYSTEMMODAL

◆ MB_TASKMODAL

◆ MB_TOPMOST

◆ MB_TYPEMASK

◆ MB_USERICON

◆ MF_BYCOMMAND

◆ MF_BYPOSITION

◆ MF_CHECKED

◆ MF_SEPARATOR

◆ MF_STRING

◆ MF_UNCHECKED

◆ NTDDI_VERSION

◆ OPENNURBS_IMPORTS [1/2]

◆ OPENNURBS_IMPORTS [2/2]

◆ OPENNURBS_VERSION_DEFINITION

◆ PS_ALTERNATE

◆ PS_COSMETIC

◆ PS_DASH

◆ PS_DASHDOT

◆ PS_DASHDOTDOT

◆ PS_DOT

◆ RHINOSDKVERSIONDEFINITION

◆ RHINO_SDK_CHECKSLINKERINSTRUCTIONS__

◆ RHINO_SDK_HINCLUDED