DisplayPipeline
ReferencesThe display pipeline calls events during specific phases of drawing During the drawing of a single frame the events are called in the following order.
[Begin Drawing of a Frame]- CalculateBoundingBox
- CalculateClippingPanes
- SetupFrustum
- SetupLighting
- InitializeFrameBuffer
- DrawBackground
- If this is a layout and detail objects exist the channels are called in the same order for each detail object (drawn as a nested viewport)
- PreDrawObjects
- For Each Visible Non Highlighted Object
- PostDrawObjects - depth writing/testing on
- DrawForeGround - depth writing/testing off
- For Each Visible Highlighted Object
- PostProcessFrameBuffer (If a delegate exists that requires this)
- DrawOverlay (if Rhino is in a feedback mode)
NOTE: There may be multiple DrawObject calls for a single object. An example of when this could happen would be with a shaded sphere. The shaded mesh is first drawn and these channels would be processed; then at a later time the isocurves for the sphere would be drawn.
Properties
Gets the curve thickness as defined by the current display mode. Note: this only applies to curve objects, Brep and Mesh wires may have different settings.
Scale factor used for high resolution displays. When a monitor that this pipeline is drawing to is at a DPI of 96, this value is one. On high DPI monitors, this value will commonly be greater than one.
Gets a value that indicates whether the pipeline is currently in a grip drawing operation.
Gets a value that indicates whether the pipeline is currently in a surface drawing operation. Surface drawing means draw the shaded triangles of a mesh representing the surface (mesh, extrusion, or brep). This is useful when inside of a draw event or display conduit to check and see if the geometry is about to be drawn as a shaded set of triangles representing the geometry. See DrawingWires to check and see if the wireframe representation of the geometry is going to be drawn.
Gets a value that indicates whether the pipeline is currently in a curve drawing operation. This is useful when inside of a draw event or display conduit to check and see if the geometry is about to be drawn is going to be drawing the wire representation of the geometry (mesh, extrusion, or brep). See DrawingSurfaces to check and see if the shaded mesh representation of the geometry is going to be drawn.
Gets the contents of the frame buffer that this pipeline is drawing to.
Gets the size of the frame buffer that this pipeline is drawing to.
Gets a value that indicates whether the viewport is in Dynamic Display state. Dynamic display is the state a viewport is in when it is rapidly redrawing because of an operation like panning or rotating. The pipeline will drop some level of detail while inside a dynamic display state to keep the frame rate as high as possible.
Gets a value that indicates whether this pipeline is currently drawing for ViewCaptureToFile or ViewCaptureToClipboard
Gets a value indicating whether or not this pipeline is drawing into an OpenGL context.
Gets a value that indicates whether this pipeline is currently drawing for printing purposes.
Gets a value that indicates whether this pipeline is currently using an engine that is performing stereo style drawing. Stereo drawing is for providing an "enhanced 3-D" effect through stereo viewing devices.
Gets or sets the current model transformation that is applied to vertices when drawing.
Gets a value that indicates whether the Model Transform is an Identity transformation.
Gets the current nested viewport drawing level. This is used to know if you are currently inside the drawing of a nested viewport (detail object in Rhino).
Nest level = 0 Drawing is occurring in a standard Rhino viewport or on the page viewport.
Nest level = 1 Drawing is occurring inside a detail view object.
Gets the current pass that the pipeline is in for drawing a frame. Typically drawing a frame requires a single pass through the DrawFrameBuffer function, but some special display effects can be achieved through drawing with multiple passes.
Gets or sets the "ShadingRequired" flag. This flag gets set inside the pipeline when a request is made to draw a shaded mesh but the current render engine doesn't support shaded mesh drawing...at this point the redraw mechanism will make sure everything will work the next time around.
Gets the current stereo projection if stereo mode is on.
0 = left
1 = right
If stereo mode is not enables, this property always returns 0.Gets whether or not this pipeline supports shaded meshes.
Get the GPU technology that this pipeline is actively using
Methods
Add a clipping plane to be used during the drawing of this frame
If Rhino is using OpenGL for display, this function will return major.minor version of OpenGL available for this instance of Rhino
Parameters:
| coreProfile (out bool) | If true, OpenGL is being used in "core profile" mode |
Returns: major version * 10 + minor version For example, OpenGL 4.5 returns 45
Fill the frame buffer with a single color. This function also clears the depth buffer for engines that support depth buffered drawing.
Parameters:
| color (Color) | the color to fill the frame buffer with |
Clones the pipeline. Creates an identical copy of "this" pipeline. Copies all conduits from "this" pipeline to the new pipeline.
Parameters:
| viewport (RhinoViewport) |
Returns: The newly cloned pipeline if successful, null otherwise. or failed to close.
Closes the pipeline.
Returns: True if the pipeline was closed, false if it was already closed or failed to close.
Returns a value indicating if only points on the side of the surface that face the camera are displayed.
Returns: true if back faces of surface and mesh control polygons are culled. This value is determined by the _CullControlPolygon command.
Draws a line whose coordinates are viewport pixels rather than world units. The origin is the top left of the frame, with y increasing downwards - the same space Draw2dText and DrawBitmap work in.
Parameters:
| from (Point2f) | Start of the line, in screen coordinates. |
| to (Point2f) | End of the line, in screen coordinates. |
| pen (DisplayPen) | Pen to stroke the line with. |
Draws a line whose coordinates are viewport pixels rather than world units. The origin is the top left of the frame, with y increasing downwards - the same space Draw2dText and DrawBitmap work in.
Parameters:
| from (PointF) | Start of the line, in screen coordinates. |
| to (PointF) | End of the line, in screen coordinates. |
| pen (DisplayPen) | Pen to stroke the line with. |
Draws a polyline whose coordinates are viewport pixels rather than world units. The origin is the top left of the frame, with y increasing downwards - the same space Draw2dText and DrawBitmap work in.
Parameters:
| points (Point2f[]) | The polyline vertices, in screen coordinates. Fewer than two draws nothing. |
| pen (DisplayPen) | Pen to stroke the polyline with. |
| closed (bool) | When true the polyline is closed back to its first point as part of the same figure, so that corner is stroked as a join rather than as two loose ends. Do not repeat the first point at the end when passing true. |
Draws a polyline whose coordinates are viewport pixels rather than world units. The origin is the top left of the frame, with y increasing downwards - the same space Draw2dText and DrawBitmap work in.
Parameters:
| points (Point2f[]) | The polyline vertices, in screen coordinates. Fewer than two draws nothing. |
| pen (DisplayPen) | Pen to stroke the polyline with. |
public void Draw2dText(string text, Color color, Point2d screenCoordinate, bool middleJustified, int height, string fontface)
Draws 2D text on the viewport.
Parameters:
| text (string) | the string to draw. |
| color (Color) | text color. |
| screenCoordinate (Point2d) | definition point in screen coordinates (0,0 is top-left corner) |
| middleJustified (bool) | if true text is centered around the definition point, otherwise it is lower-left justified. |
| height (int) | height in pixels (good default is 12) |
| fontface (string) | font name (good default is "Arial") |
public void Draw2dText(string text, Color color, Point2d screenCoordinate, bool middleJustified, int height)
Draws 2D text on the viewport.
Parameters:
| text (string) | the string to draw. |
| color (Color) | text color. |
| screenCoordinate (Point2d) | definition point in screen coordinates (0,0 is top-left corner) |
| middleJustified (bool) | if true text is centered around the definition point, otherwise it is lower-left justified. |
| height (int) | height in pixels (good default is 12) |
Draws 2D text on the viewport.
public void Draw2dText(string text, Color color, Point2d screenCoordinate, TextHorizontalAlignment horizontalAlignment, TextVerticalAlignment verticalAlignment, float height, string fontface, bool bold, bool italic, bool underline, bool strikethrough, bool applyKerning)
Draws 2D text on the viewport.
Parameters:
| text (string) | The string to draw. |
| color (Color) | Text color. |
| screenCoordinate (Point2d) | Definition point in screen coordinates (0,0 is top-left corner). The alignment attaches to this point. |
| horizontalAlignment (TextHorizontalAlignment) | Where the definition point sits across the text's horizontal advance. |
| verticalAlignment (TextVerticalAlignment) | Where the definition point sits down the text's lines. BottomOfTop puts the first line's baseline on the point; Top puts the top of a capital there, which is what the middleJustified=false overloads draw. |
| height (float) | Height in pixels (good default is 12). |
| fontface (string) | Font name (good default is "Arial"). |
| bold (bool) | If true, the bold face of the font family is used. |
| italic (bool) | If true, the italic face of the font family is used. |
| underline (bool) | If true, the text is underlined. |
| strikethrough (bool) | If true, the text is struck through. |
| applyKerning (bool) | If true, the font's kerning pairs are used to space the glyphs. |
public void Draw2dText(string text, Color color, Point3d worldCoordinate, bool middleJustified, int height, string fontface)
Draws 2D text on the viewport.
Parameters:
| text (string) | The string to draw. |
| color (Color) | Text color. |
| worldCoordinate (Point3d) | Definition point in world coordinates. |
| middleJustified (bool) | If true text is centered around the definition point, otherwise it is lower-left justified. |
| height (int) | Height in pixels (good default is 12). |
| fontface (string) | Font name (good default is "Arial"). |
public void Draw2dText(string text, Color color, Point3d worldCoordinate, bool middleJustified, int height)
Draws 2D text on the viewport.
Draws 2D text on the viewport.
public void Draw2dText(string text, Color color, Point3d worldCoordinate, TextHorizontalAlignment horizontalAlignment, TextVerticalAlignment verticalAlignment, float height, string fontface, bool bold, bool italic, bool underline, bool strikethrough, bool applyKerning)
Draws 2D text on the viewport.
Parameters:
| text (string) | The string to draw. |
| color (Color) | Text color. |
| worldCoordinate (Point3d) | Definition point in world coordinates. The alignment attaches to this point. |
| horizontalAlignment (TextHorizontalAlignment) | Where the definition point sits across the text's horizontal advance. |
| verticalAlignment (TextVerticalAlignment) | Where the definition point sits down the text's lines. BottomOfTop puts the first line's baseline on the point; Top puts the top of a capital there, which is what the middleJustified=false overloads draw. |
| height (float) | Height in pixels (good default is 12). |
| fontface (string) | Font name (good default is "Arial"). |
| bold (bool) | If true, the bold face of the font family is used. |
| italic (bool) | If true, the italic face of the font family is used. |
| underline (bool) | If true, the text is underlined. |
| strikethrough (bool) | If true, the text is struck through. |
| applyKerning (bool) | If true, the font's kerning pairs are used to space the glyphs. |
public void Draw3dText(string text, Color color, Plane textPlane, double height, string fontface, bool bold, bool italic, TextHorizontalAlignment horizontalAlignment, TextVerticalAlignment verticalAlignment)
Parameters:
| text (string) | |
| color (Color) | |
| textPlane (Plane) | |
| height (double) | |
| fontface (string) | |
| bold (bool) | |
| italic (bool) | |
| horizontalAlignment (TextHorizontalAlignment) | |
| verticalAlignment (TextVerticalAlignment) |
Draws 3d text with a different plane than what is defined in the Text3d class.
Draws 3d text using the Text3d plane with an adjusted origin.
Draws a point in style used during "GetPoint" operations
Parameters:
| point (Point3d) | Location of the point in world coordinates |
Parameters:
| annotation (AnnotationBase) | |
| color (Color) |
Draws an annotation geometry while evaluating any embedded text fields (e.g. %<Date>%, %<DocumentText("...")>%) against the supplied parent RhinoObject. Intended for preview conduits that draw a modified copy of an annotation's geometry while the user is editing it — the regular geometry-only overload skips field evaluation because it has no display cache to anchor to.
Parameters:
| annotation (AnnotationBase) | |
| parentObject (RhinoObject) | |
| color (Color) |
Draw a single arc object.
Draw a single arc object.
Draws a single arrow object. An arrow consists of a Shaft and an Arrow head at the end of the shaft.
Parameters:
| line (Line) | Arrow shaft. |
| color (Color) | Color of arrow. |
| screenSize (double) | If screenSize != 0.0 then the size (in screen pixels) of the arrow head will be equal to screenSize. |
| relativeSize (double) | If relativeSize != 0.0 and screen size == 0.0 the size of the arrow head will be proportional to the arrow shaft length. |
Draws a single arrow object. An arrow consists of a Shaft and an Arrow head at the end of the shaft.
Draw a Grasshopper 2 style vector arrow. This method is relatively slow as it requires the construction of a DisplayPen and a PolylineCurve. However it is more accurate than other arrow drawing methods in that the tip of the drawn arrow is very close to the actual end of the line, the tip is always sharp, and the arrow head is resized to never be too small or large. Also note this method already takes into account logical pixel scaling.
Parameters:
| line (Line) | Vector shaft to draw. |
| headSize (double) | Size of the head as a factor of arrow length. 0.1 would be a decent size. |
| color (Color) | Color of arrow geometry. |
| shaftWidth (float) | Width of arrow geometry. Note that the shaft is drawn using a method which only supports integer thicknesses and the arrow head is drawn thicker to counter the human perception of seeing angled lines thinner than they really are. |
public void DrawArrowHead(Point3d tip, Vector3d direction, Color color, double screenSize, double worldSize)
Draws a single arrow head.
Parameters:
| tip (Point3d) | Point of arrow head tip. |
| direction (Vector3d) | Direction in which arrow head is pointing. |
| color (Color) | Color of arrow head. |
| screenSize (double) | If screenSize != 0.0, then the size (in screen pixels) of the arrow head will be equal to the screenSize. |
| worldSize (double) | If worldSize != 0.0 and screen size == 0.0 the size of the arrow head will be equal to the number of units in worldSize. |
Draws a collection of arrow objects. An arrow consists of a Shaft and an Arrow head at the end of the shaft.
Parameters:
| lines (IEnumerable<Line>) | Arrow shafts. |
| color (Color) | Color of arrows. |
Draws a collection of arrow objects. An arrow consists of a Shaft and an Arrow head at the end of the shaft.
public void DrawBitmap(DisplayBitmap bitmap, int left, int top, int width, int height, Transform2d transform)
Draws a bitmap in screen coordinates, scaled to fit the given size, through a 2d transform.
Remarks: The transform is honoured by the shader based display engines. The GDI engine and the fixed function OpenGL fallback blit the image at a screen position and have no matrix to apply it with, so on those the bitmap is drawn untransformed.
Parameters:
| bitmap (DisplayBitmap) | bitmap to draw |
| left (int) | where the left edge of the bitmap should appear in screen coordinates |
| top (int) | where the top edge of the bitmap should appear in screen coordinates |
| width (int) | width (in pixels) to draw the bitmap at |
| height (int) | height (in pixels) to draw the bitmap at |
| transform (Transform2d) | A 2d transform applied to the destination rectangle when the bitmap is drawn, in viewport pixels - the same space left, top, width and height are in. It moves the rectangle the image lands on and nothing else, so a rotation, a shear or a non-uniform scale all work and the image is resampled to suit. |
Draws a bitmap in screen coordinates, scaled to fit the given size.
Parameters:
| bitmap (DisplayBitmap) | bitmap to draw |
| left (int) | where the left edge of the bitmap should appear in screen coordinates |
| top (int) | where the top edge of the bitmap should appear in screen coordinates |
| width (int) | width (in pixels) to draw the bitmap at |
| height (int) | height (in pixels) to draw the bitmap at |
Draws a bitmap in screen coordinates
Parameters:
| bitmap (DisplayBitmap) | bitmap to draw |
| left (int) | where top/left corner of bitmap should appear in screen coordinates |
| top (int) | where top/left corner of bitmap should appear in screen coordinates |
Draws the edges of a BoundingBox.
Parameters:
| box (BoundingBox) | Box to draw. |
| color (Color) | Color to draw in. |
| thickness (int) | Thickness (in pixels) of box edges. |
Draws the edges of a BoundingBox.
Parameters:
| box (BoundingBox) | Box to draw. |
| color (Color) | Color to draw in. |
Draws the edges of a Box object.
Draws the edges of a Box object.
Draws corner widgets of a world aligned bounding box.
Parameters:
| box (BoundingBox) | Box to draw. |
| color (Color) | Color to draw with. |
| size (double) | Size (in model units) of the corner widgets. |
| thickness (int) | Thickness (in pixels) of the corner widgets. |
Draws corner widgets of a world aligned bounding box.
Parameters:
| box (BoundingBox) | Box to draw. |
| color (Color) | Color to draw with. |
| size (double) | Size (in model units) of the corner widgets. |
Draws corner widgets of a world aligned bounding box. Widget size will be 5% of the Box diagonal.
Parameters:
| box (BoundingBox) | Box to draw. |
| color (Color) | Color to draw with. |
Draws a shaded mesh representation of a brep.
Parameters:
| brep (Brep) | Brep to draw. |
| material (DisplayMaterial) | Material to draw faces with. |
Draws all the wireframe curves of a brep object.
Draws all the wireframe curves of a brep object.
Draw a single circle object.
Draw a single circle object.
Draw a cipping plane
Parameters:
| clippingPlane (ClippingPlaneSurface) | |
| color (Color) |
Draw a wireframe cone.
Draw a wireframe cone.
Draws a construction plane.
Parameters:
| constructionPlane (ConstructionPlane) | The construction plane to draw. |
public void DrawCurvatureGraph(Curve curve, Color color, int hairScale, int hairDensity, int sampleDensity)
Draw a typical Rhino Curvature Graph.
Parameters:
| curve (Curve) | Base curve for curvature graph. |
| color (Color) | Color of curvature graph. |
| hairScale (int) | 100 = true length, > 100 magnified, < 100 shortened. |
| hairDensity (int) | >= 0 larger numbers = more hairs (good default is 1). |
| sampleDensity (int) | Between 1 and 10. Higher numbers draw smoother outer curves. (good default is 2). |
Draw a typical Rhino Curvature Graph.
Draw a typical Rhino Curvature Graph.
Draws a Brep in Curvature Analysis preview.
Draws a Mesh in Curvature Analysis preview.
Draw a single Curve object.
Draw a single Curve object.
Parameters:
| curve (Curve) | |
| pen (DisplayPen) |
Draw a wireframe cylinder.
Draw a wireframe cylinder.
Draws a text dot in screen coordinates.
Draws a text dot in screen coordinates.
Draw a text dot in world coordinates.
Draws a text dot in world coordinates.
Draw a text dot as defined by the text dot class
Draws a single dotted line.
Draws a single dotted line.
Draws a set of connected lines (polyline) in a dotted pattern (0x00001111).
Parameters:
| points (IEnumerable<Point3d>) | End points of each line segment. |
| color (Color) | Color of polyline. |
| close (bool) | Draw a line between the first and last points. |
Draws a Brep in Draft Angle preview.
Draws a Mesh in Draft Angle preview.
Draw inference point used in gesture based snapping
Draws a Brep in Environment Map preview with a texture of your own, instead of the one in EmapAnalysisSettings.
Parameters:
| brep (Brep) | Brep to draw. |
| color (Color) | Object color. |
| settings (EmapAnalysisSettingsState) | Settings for this call only. Get a copy of the current ones from EmapAnalysisSettings.GetCurrentState() and change what you need. A null or empty EmapAnalysisSettingsState.FileName keeps the texture the application settings name. |
Draws a Brep in Environment Map preview.
Draws a Mesh in Environment Map preview with a texture of your own, instead of the one in EmapAnalysisSettings.
Parameters:
| mesh (Mesh) | Mesh to draw. |
| color (Color) | Object color. |
| settings (EmapAnalysisSettingsState) | Settings for this call only. Get a copy of the current ones from EmapAnalysisSettings.GetCurrentState() and change what you need. A null or empty EmapAnalysisSettingsState.FileName keeps the texture the application settings name. |
Draws a Mesh in Environment Map preview.
Draws all the wireframe curves of an extrusion object.
Draws all the wireframe curves of an extrusion object.
public void DrawGradientHatch(Hatch hatch, Color color1, Color color2, Point3d point1, Point3d point2, bool linearGradient, float boundaryThickness, Color boundaryColor)
Draw a two point gradient filled hatch
public void DrawGradientHatch(Hatch hatch, IEnumerable<ColorStop> stops, Point3d point1, Point3d point2, bool linearGradient, float repeat, DisplayPen boundary, Color backgroundFillColor)
Parameters:
| hatch (Hatch) | |
| stops (IEnumerable<ColorStop>) | |
| point1 (Point3d) | |
| point2 (Point3d) | |
| linearGradient (bool) | |
| repeat (float) | |
| boundary (DisplayPen) | |
| backgroundFillColor (Color) |
public void DrawGradientLines(IEnumerable<Line> lines, float strokeWidth, IEnumerable<ColorStop> stops, Point3d point1, Point3d point2, bool linearGradient, float repeat)
Parameters:
| lines (IEnumerable<Line>) | |
| strokeWidth (float) | |
| stops (IEnumerable<ColorStop>) | |
| point1 (Point3d) | |
| point2 (Point3d) | |
| linearGradient (bool) | |
| repeat (float) |
public void DrawHatch(Hatch hatch, Color hatchColor, DisplayPen boundary, Color backgroundFillColor)
Parameters:
| hatch (Hatch) | |
| hatchColor (Color) | |
| boundary (DisplayPen) | |
| backgroundFillColor (Color) |
Draw an inference line used in gesture based snapping
Parameters:
| P (Point3d) | First point used to define the line in world coordinates |
| O (Point3d) | Second point used to define the line in world coordinates |
| color (Color) | Color of line |
| type (DisplayPipeline.InferenceLineType) | Type of line DisplayPipeline.InferenceLineType |
Draws an InstanceDefinition.
Parameters:
| instanceDefinition (InstanceDefinition) | The instance definition. |
| xform (Transform) | The transformation. |
Draws an InstanceDefinition.
Parameters:
| instanceDefinition (InstanceDefinition) | The instance definition. |
public void DrawInstanceDefinitionShaded(InstanceDefinition instanceDefinition, DisplayMaterial material, Transform xform)
Draws a shaded InstanceDefinition.
Parameters:
| instanceDefinition (InstanceDefinition) | The instance definition. |
| material (DisplayMaterial) | Material to draw faces with. |
| xform (Transform) | The transformation. |
public void DrawInstanceDefinitionShaded(InstanceDefinition instanceDefinition, DisplayMaterial material)
Draws a shaded InstanceDefinition.
Parameters:
| instanceDefinition (InstanceDefinition) | The instance definition. |
| material (DisplayMaterial) | Material to draw faces with. |
Draws a light.
Draws a single line object.
Draws a single line object.
Parameters:
| line (Line) | |
| pen (DisplayPen) |
Draws a single line object.
Draws a single line object.
Draws an arrow made up of three line segments.
Draws a single line object .This version of line drawing will draw the segments of the line that extend beyond the near and far planes of the view frustum with depths on those planes
Draws a set of lines with a given color and thickness. If you want the fastest possible set of lines to be drawn, pass a Line[] for lines.
Parameters:
| lines (IEnumerable<Line>) | Lines to draw. |
| color (Color) | Color to draw with. |
| thickness (int) | Thickness (in pixels) of lines. |
Draws a set of lines with a given color and thickness. If you want the fastest possible set of lines to be drawn, pass a Line[] for lines.
Parameters:
| lines (IEnumerable<Line>) | Lines to draw. |
| color (Color) | Color to draw with. |
Parameters:
| lines (Line[]) | |
| pen (DisplayPen) |
Draws a multiple lines. This version of line drawing will draw the segments of the line that extend beyond the near and far planes of the view frustum with depths on those planes
Parameters:
| lines (IEnumerable<Line>) | the lines to draw |
| color (Color) | Color to draw lines in |
| thickness (int) | Thickness (in pixels) of lines |
public void DrawMarker(Point3d tip, Vector3d direction, Color color, int thickness, double size, double rotation)
Draws an arrow marker as a view-aligned widget.
Parameters:
| tip (Point3d) | Location of arrow tip point. |
| direction (Vector3d) | Direction of arrow. |
| color (Color) | Color of arrow widget. |
| thickness (int) | Thickness of arrow widget lines. |
| size (double) | Size (in pixels) of the arrow shaft. |
| rotation (double) | Rotational angle adjustment (in radians, counter-clockwise of direction. |
Draws an arrow marker as a view-aligned widget.
Draws an arrow marker as a view-aligned widget.
Draws an arrow marker as a view-aligned widget.
Draws a batch of meshes with the Grasshopper 2 ("G2") shaded display: a gradient-shaded look driven by a GrasshopperDisplayMaterial — a diffuse colour plus optional striping, stippling and dark-area desaturation — rather than a full DisplayMaterial. The whole batch is uploaded as one combined GPU buffer and shares one material; for per-mesh settings, call once per mesh instead.
Remarks:
The meshes are uploaded to the GPU on every redraw. Nothing is cached between frames, so every redraw re-uploads the whole batch. This is the dominant cost of the call and needs to be planned around: draw only the geometry you actually need, and prefer one batched call over many single-mesh calls.
Mesh requirements. Every mesh must have up-to-date single-precision vertices and vertex normals. The G2 shader reads those directly; a mesh that carries only double-precision vertices, or no normals, will render badly (missing geometry or flat/garbage shading). Compute the vertex normals and make sure the single-precision vertices are current before drawing if in doubt. Null entries in meshes are skipped.
Vertex colours. If a mesh has vertex colours, those colours are drawn in place of the material's diffuse colour, and GrasshopperDisplayMaterial.ShadeFalseColor decides whether they are shaded or drawn flat. Meshes without vertex colours are shaded from the material's diffuse colour alone.
Mixed meshes are safe. A batch is uploaded as one interleaved vertex buffer whose layout is the union of its meshes' attributes, and a mesh lacking an attribute the union has would be zero-filled for it, so a colourless mesh batched with a vertex-coloured one would draw black. This method therefore splits the meshes into groups that share the same attributes and draws one batch per group, so any mix may be passed in. Meshes keep their relative order within a group and the groups are drawn in order of first appearance; order between groups is not otherwise guaranteed.
Parameters:
| meshes (IEnumerable<Mesh>) | The meshes to draw as one batch. Each should have current single-precision vertices and vertex normals (see remarks); null entries are skipped. |
| material (GrasshopperDisplayMaterial) | The G2 shaded settings to draw with. When null, default settings are used. |
public void DrawMeshFalseColors(Mesh mesh)
Draws the mesh faces as false color patches. The mesh must have Vertex Colors defined for this to work.
Parameters:
| mesh (Mesh) | Mesh to draw. |
Draws shaded mesh with isodraw settings applied (zebra)
Parameters:
| mesh (Mesh) | |
| diffuseMaterialColor (Color) | |
| zebraSettings (IsoDrawEffect) |
Draws the shaded faces of a given mesh.
Parameters:
| mesh (Mesh) | Mesh to draw. |
| material (DisplayMaterial) | Material to draw faces with. |
| faceIndices (IEnumerable<int>) | An enumeration of the indices of specific faces to draw. |
Draws the shaded faces of a given mesh.
Parameters:
| mesh (Mesh) | Mesh to draw. |
| material (DisplayMaterial) | Material to draw faces with. |
| faceIndices (int[]) | Indices of specific faces to draw. |
Draws the shaded faces of a given mesh.
Parameters:
| mesh (Mesh) | Mesh to draw. |
| material (DisplayMaterial) | Material to draw faces with. |
Draws a single mesh with the Grasshopper 2 ("G2") shaded display. This is a convenience overload of DrawMeshesShaded(IEnumerable<Mesh>, GrasshopperDisplayMaterial); see it for the mesh requirements and vertex-colour handling.
Remarks:
The mesh is uploaded to the GPU on every redraw. Nothing is cached between frames, so every redraw re-uploads the mesh. When drawing more than one mesh, prefer a single batched DrawMeshesShaded(IEnumerable<Mesh>, GrasshopperDisplayMaterial) call over many single-mesh calls.
Parameters:
| mesh (Mesh) | The mesh to draw. Should have current single-precision vertices and vertex normals (see DrawMeshesShaded(IEnumerable<Mesh>, GrasshopperDisplayMaterial)). |
| material (GrasshopperDisplayMaterial) | The G2 shaded settings to draw with. When null, default settings are used. |
Draws all the vertices in a given mesh.
Draws all the wires in a given mesh.
Draws all the wires in a given mesh.
Draws a RhinoObject with an applied transformation.
Parameters:
| rhinoObject (RhinoObject) | The Rhino object. |
| xform (Transform) | The transformation. |
Draws a RhinoObject.
Parameters:
| rhinoObject (RhinoObject) | The Rhino object. |
Parameters:
| particles (ParticleSystem) | |
| bitmap (DisplayBitmap) |
Parameters:
| particles (ParticleSystem) | |
| bitmaps (DisplayBitmap[]) |
Parameters:
| particles (ParticleSystem) |
Draws a single line with specified pattern.
Draws a single line with specified pattern.
public void DrawPatternedPolyline(IEnumerable<Point3d> points, Color color, int pattern, int thickness, bool close)
Draws a set of connected lines (polyline) with specified pattern.
Draws a point with a given radius, style and color.
Draws a point with a given radius, style and color.
Parameters:
| point (Point3d) | Location of point in world coordinates. |
| style (PointStyle) | Point display style. |
| radius (float) | Point size in pixels. |
| color (Color) | Color of point. If style is ControlPoint, this will be the border color. |
Draws a point with a given radius, style and color.
Parameters:
| point (Point3d) | Location of point in world coordinates. |
| style (PointStyle) | Point display style. |
| radius (int) | Point size in pixels. |
| color (Color) | Color of point. If style is ControlPoint, this will be the border color. |
Draws a point using the current display attribute size, style and color
Parameters:
| point (Point3d) | Location of point in world coordinates. |
Draws a point cloud.
Parameters:
| cloud (PointCloud) | Point cloud to draw. |
| size (float) | Size of points. |
| color (Color) | Color of points in the cloud, if the cloud has a color array this setting is ignored. |
Draws a point cloud.
Parameters:
| cloud (PointCloud) | Point cloud to draw, if the cloud has a color array, it will be used, otherwise the points will be black. |
| size (float) | Size of points. |
Draws a point cloud.
Parameters:
| cloud (PointCloud) | Point cloud to draw. |
| size (int) | Size of points. |
| color (Color) | Color of points in the cloud, if the cloud has a color array this setting is ignored. |
Draws a point cloud.
Parameters:
| cloud (PointCloud) | Point cloud to draw, if the cloud has a color array, it will be used, otherwise the points will be black. |
| size (int) | Size of points. |
public void DrawPoints(DisplayPointSet points, DisplayPointAttributes fallbackAttributes, DisplayPointAttributes overrideAttributes)
Parameters:
| points (DisplayPointSet) | |
| fallbackAttributes (DisplayPointAttributes) | |
| overrideAttributes (DisplayPointAttributes) |
Parameters:
| points (DisplayPointSet) |
Draw a set of points with a given radius, style and color.
Parameters:
| points (IEnumerable<Point3d>) | Location of points in world coordinates. |
| style (PointStyle) | Point display style. |
| radius (float) | Point size in pixels. |
| color (Color) | Color of points. If style is ControlPoint, this will be the border color. |
Draw a set of points with a given radius, style and color.
Parameters:
| points (IEnumerable<Point3d>) | Location of points in world coordinates. |
| style (PointStyle) | Point display style. |
| radius (int) | Point size in pixels. |
| color (Color) | Color of points. If style is ControlPoint, this will be the border color. |
Draws a filled, convex polygon from a collection of points.
Parameters:
| points (IEnumerable<Point3d>) | Collection of world coordinate points that are connected by lines to form a closed shape. Collection must contain at least 3 points. |
| color (Color) | Color to draw with. |
| filled (bool) | true if the closed area should be filled with color. false if you want to draw just the border of the closed shape. |
Draws a single Polyline object.
Parameters:
| polyline (IEnumerable<Point3d>) | Polyline to draw. |
| color (Color) | Color to draw in. |
| thickness (int) | Thickness (in pixels) of the Polyline. |
Draws a single Polyline object.
Parameters:
| polyline (IEnumerable<Point3d>) | Polyline to draw. |
| color (Color) | Color to draw in. |
Draw a wireframe sphere.
Draw a wireframe sphere.
Parameters:
| bitmap (DisplayBitmap) | |
| screenLocation (Point2d) | |
| size (float) | |
| blendColor (Color) |
Parameters:
| bitmap (DisplayBitmap) | |
| screenLocation (Point2d) | |
| size (float) |
Draw screen oriented image centered at 2d screen location
Parameters:
| bitmap (DisplayBitmap) | |
| screenLocation (Point2d) | |
| width (float) | |
| height (float) |
public void DrawSprite(DisplayBitmap bitmap, Point3d worldLocation, float size, bool sizeInWorldSpace)
Parameters:
| bitmap (DisplayBitmap) | |
| worldLocation (Point3d) | |
| size (float) | |
| sizeInWorldSpace (bool) |
public void DrawSprite(DisplayBitmap bitmap, Point3d worldLocation, float size, Color blendColor, bool sizeInWorldSpace)
Parameters:
| bitmap (DisplayBitmap) | |
| worldLocation (Point3d) | |
| size (float) | |
| blendColor (Color) | |
| sizeInWorldSpace (bool) |
public void DrawSprites(DisplayBitmap bitmap, DisplayBitmapDrawList items, float size, bool sizeInWorldSpace)
Parameters:
| bitmap (DisplayBitmap) | |
| items (DisplayBitmapDrawList) | |
| size (float) | |
| sizeInWorldSpace (bool) |
public void DrawSprites(DisplayBitmap bitmap, DisplayBitmapDrawList items, float size, Vector3d translation, bool sizeInWorldSpace)
Parameters:
| bitmap (DisplayBitmap) | |
| items (DisplayBitmapDrawList) | |
| size (float) | |
| translation (Vector3d) | |
| sizeInWorldSpace (bool) |
[CLSCompliant(false)]
public bool DrawStereoFrameBuffer(ViewportInfo viewportLeft, ViewportInfo viewportRight, out uint handleLeft, out uint handleRight)
Draws the viewport as seen from the left and the right eye viewports and returns the result as OpenGL texture handles.
Parameters:
| viewportLeft (ViewportInfo) | The viewport representing the left eye location and look direction. |
| viewportRight (ViewportInfo) | The viewport representing the right eye location and look direction. |
| handleLeft (out uint) | Will contain the OpenGL texture handle which references the left output color buffer. |
| handleRight (out uint) | Will contain the OpenGL texture handle which references the right output color buffer. |
Returns: true if drawing succeeded, false otherwise.
Draw a shaded mesh representation of a SubD
Parameters:
| subd (SubD) | SubD to draw |
| material (DisplayMaterial) | Material to draw faces with |
Draws all the wireframe curves of a SubD object
public void DrawSubDWires(SubD subd, DisplayPen boundaryPen, DisplayPen smoothInteriorPen, DisplayPen creasePen, DisplayPen nonmanifoldPen)
Draws all the wireframe curves os a SubD object using different pens
Parameters:
| subd (SubD) | SubD to draw |
| boundaryPen (DisplayPen) | Pen to use for boundary wires. If null, no boundary wires will be drawn |
| smoothInteriorPen (DisplayPen) | Pen to use for smooth interior wires. If null, no smooth interior wires will be drawn |
| creasePen (DisplayPen) | Pen to use for crease wires. If null, no crease wires will be drawn |
| nonmanifoldPen (DisplayPen) | Pen to use for non-manifold wires. If null, no non-manifold wires will be drawn |
Draw wireframe display for a single surface.
Draw surface indicators
Parameters:
| directionIndicators (SurfaceDirectionIndicators) |
Parameters:
| text (TextEntity) | |
| color (Color) | |
| scale (double) |
Parameters:
| text (TextEntity) | |
| color (Color) | |
| xform (Transform) |
Parameters:
| text (TextEntity) | |
| color (Color) |
Draw a given viewport to an off-screen bitmap.
Parameters:
| viewport (RhinoViewport) | Viewport to draw. |
| width (int) | Width of target image. |
| height (int) | Height of target image. |
Returns: A bitmap containing the given view, or null on error.
Draw a wireframe torus.
Draw a wireframe torus.
Draws a shaded Brep with Zebra stripe preview.
Draws a shaded Mesh with Zebra stripe preview.
Enable or disable the Clipping Plane logic of the engine.
Parameters:
| enable (bool) | true to enable Clipping Planes, false to disable. |
Enable or disable the ColorWriting behavior of the engine.
Parameters:
| enable (bool) | true to enable ColorWriting, false to disable. |
Enable or disable the DepthTesting behavior of the engine. When DepthTesting is disabled, objects in front will no longer occlude objects behind them.
Parameters:
| enable (bool) | true to enable DepthTesting, false to disable. |
Enable or disable the DepthWriting behavior of the engine. When DepthWriting is disabled, drawn geometry does not affect the Z-Buffer.
Parameters:
| enable (bool) | true to enable DepthWriting, false to disable. |
Enable or disable the Lighting logic of the engine.
Parameters:
| enable (bool) | true to enable Lighting, false to disable. |
public void Flush()
Force the pipeline to immediately flush any cached geometry to the display
public nint GetDirect3d11Device()
If the pipeline is running on top of Direct3D 11, this function will return a pointer to the ID3D11Device being used. IntPtr.Zero is returned if the pipeline is running on some other GPU technology. NOTE: AddRef is NOT called on this IUnknown instance.
Returns: Pointer to an ID3D11Device, or IntPtr.Zero.
public nint GetDirect3d11DeviceContext()
If the pipeline is running on top of Direct3D 11, this function will return a pointer to the ID3D11DeviceContext1 actively being used. IntPtr.Zero is returned if the pipeline is running on some other GPU technology. NOTE: AddRef is NOT called on this IUnknown instance.
Returns: Pointer to an ID3D11DeviceContext1, or IntPtr.Zero.
[CLSCompliant(false)]
public static void GetDrawListSerialNumbers(out uint modelSerialNumber, out uint pageSerialNumber)
Gets the current model and page view draw list serial numbers, which can be used to determine if a model or page view needs to be redrawn.
Get an array of 16 floats that represents the "camera" to "clip" coordinate transformation in OpenGL's right handed coordinate system
Get an array of 16 floats that represents the "world" to "camera" coordinate transformation in OpenGL's right handed coordinate system
Parameters:
| includeModelTransform (bool) |
Get an array of 16 floats that represents the "world" to "clip" coordinate transformation in OpenGL's right handed coordinate system
Parameters:
| includeModelTransform (bool) |
Tests to see if the pipeline should stop drawing more geometry and just show what it has so far. If a drawing operation is taking a long time, this function will return true and tell Rhino it should just finish up and show the frame buffer. This is used in dynamic drawing operations.
Returns: true if the pipeline should stop attempting to draw more geometry and just show the frame buffer.
Determines if an object can be visible in this viewport based on it's object type and display attributes. This test does not check for visibility based on location of the object. NOTE: Use CRhinoDisplayPipeline::IsVisible() to perform "visibility" tests based on location (is some part of the object in the view frustum). Use CRhinoDisplayPipeline::IsActive() to perform "visibility" tests based on object type.
Parameters:
| rhinoObject (RhinoObject) | Object to test. |
Returns: true if this object can be drawn in the pipeline's viewport based on it's object type and display attributes.
Returns true if the currently drawn frame is part of a tiled capture. Tiled captures are performed when creating large raster outputs.
Test a given box for visibility inside the view frustum under the current viewport and model transformation settings.
Parameters:
| bbox (BoundingBox) | Box to test for visibility. |
Returns: true if at least some portion of the box is visible, false if not.
Test a given 3d world coordinate point for visibility inside the view frustum under the current viewport and model transformation settings.
Parameters:
| worldCoordinate (Point3d) | Point to test for visibility. |
Returns: true if the point is visible, false if it is not.
Test a given object for visibility inside the view frustum under the current viewport and model transformation settings. This function calls a virtual IsVisibleFinal function that sub-classed pipelines can add extra tests to. In the base class, this test only tests visibility based on the objects world coordinates location and does not pay attention to the object's attributes. NOTE: Use CRhinoDisplayPipeline::IsVisible() to perform "visibility" tests based on location (is some part of the object in the view frustum). Use CRhinoDisplayPipeline::IsActive() to perform "visibility" tests based on object type.
Parameters:
| rhinoObject (RhinoObject) | Object to test. |
Returns: true if the object is visible, false if not.
Make a "default" OpenGL context current
public Rectangle Measure2dText(string text, Point2d definitionPoint, bool middleJustified, double rotationRadians, int height, string fontFace)
Determines screen rectangle that would be drawn to using the Draw2dText(..) function with the same parameters.
Parameters:
| text (string) | text to measure. |
| definitionPoint (Point2d) | either lower-left or middle of text. |
| middleJustified (bool) | true=middle justified. false=lower-left justified. |
| rotationRadians (double) | text rotation in radians |
| height (int) | height in pixels (good default is 12) |
| fontFace (string) | font name (good default is "Arial") |
Returns: rectangle in the viewport's screen coordinates on success.
Opens the pipeline.
Returns: True if the pipeline was opened, false if it was already open or failed to open.
public void PopClipTesting()
obsoleteUse PopDepthTesting
Pop a ClipTesting flag off the engine's stack.
public void PopDepthTesting()
Pop a DepthTesting flag off the engine's stack.
public void PopDepthWriting()
Pop a DepthWriting flag off the engine's stack.
public void PopModelTransform()
Pop a model transformation off the engine's model transform stack.
public void PopProjection()
Pop a view projection off this pipelines projection stack
public void Push2dProjection()
Push the current view projection and set the viewport up to be a simple 2D top projection where the camera frustum matches the same size as the screen port. This allows geometry draw functions to act like they are working with typical 2d graphics APIs on a window
obsoleteUse PushDepthTesting
Push a ClipTesting flag on the engine's stack.
Parameters:
| enable (bool) | ClipTesting flag. |
Push a FaceCull flag on the engine's stack.
Parameters:
| mode (CullFaceMode) | FaceCull flag. |
Push a DepthTesting flag on the engine's stack.
Parameters:
| enable (bool) | DepthTesting flag. |
Push a DepthWriting flag on the engine's stack.
Parameters:
| enable (bool) | DepthWriting flag. |
Push a model transformation on the engine's model transform stack.
Parameters:
| xform (Transform) | Transformation to push. |
Remove a clipping plane from the pipeline for this frame
Parameters:
| index (int) |
Parameters:
| color (Color) |
public DisplayMaterial SetupDisplayMaterial(RhinoDoc doc, RhinoObject rhinoObject, ObjectAttributes attributes, Transform instanceTransform)
Sets up a display material.
Parameters:
| doc (RhinoDoc) | The active document. |
| rhinoObject (RhinoObject) | The Rhino object. |
| attributes (ObjectAttributes) | The object attributes. |
| instanceTransform (Transform) | The instance object transformation. |
Returns: A display material if successful, null otherwise.
public DisplayMaterial SetupDisplayMaterial(RhinoDoc doc, RhinoObject rhinoObject, ObjectAttributes attributes)
Sets up a display material.
Parameters:
| doc (RhinoDoc) | The active document. |
| rhinoObject (RhinoObject) | The Rhino object. |
| attributes (ObjectAttributes) | The object attributes. |
Returns: A display material if successful, null otherwise.
Sets up a display material.
Parameters:
| doc (RhinoDoc) | The active document. |
| rhinoObject (RhinoObject) | The Rhino object. |
Returns: A display material if successful, null otherwise.
Multisample modes available
Parameters:
| technology (DisplayTechnology) |
Events
Calculate a bounding to include in the Zoom Extents command.
Called after all non-highlighted objects have been drawn and PostDrawObjects has been called. Depth writing and testing are turned OFF. If you want to draw with depth writing/testing, see PostDrawObjects.
Remarks: This event is actually passed a DrawForegroundEventArgs, but we could not change the event declaration without breaking the SDK. Cast to a DrawForegroundEventArgs if you need it.
If Rhino is in a feedback mode, the draw overlay call allows for temporary geometry to be drawn on top of everything in the scene. This is similar to the dynamic draw routine that occurs with custom get point.
Called right after an individual object has been drawn. NOTE: Do not use this event unless you absolutely need to. It is called for every object in the document and can slow display down if a large number of objects exist in the document
Called after all non-highlighted objects have been drawn. Depth writing and testing are still turned on. If you want to draw without depth writing/testing, see DrawForeground.
PostProcessFrameBuffer
#Called after the frame has been drawn, with the finished frame available to be read. Use this to record or stream a viewport: PostProcessFrameBufferEventArgs.TryCopyFrameBuffer(nint, int, int) copies the frame that was just drawn, and never redraws the scene.
Every frame drawn while this event is subscribed costs an extra frame buffer read back, whether or not the handler reads anything. Unsubscribe as soon as the frames are no longer needed.
The handler runs on the thread that drew the frame and holds up the next one. Copy the pixels here and do the rest of the work somewhere else.
Called right before an individual object is being drawn. NOTE: Do not use this event unless you absolutely need to. It is called for every object in the document and can slow display down if a large number of objects exist in the document
Called before objects are been drawn. Depth writing and testing are on.
Called before transparent objects have been drawn. Depth writing and testing are on.
Called when the projection changes for a viewport being drawn.