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
Returns: index for the added clipping plane
If Rhino is using OpenGL for display, this function will return major.minor version of OpenGL available for this instance of Rhino
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.
Clones the pipeline. Creates an identical copy of "this" pipeline. Copies all conduits from "this" pipeline to the new pipeline.
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.
public void Draw2dLine()
from,
Start of the line, in screen coordinates.
to,
End of the line, in screen coordinates.
pen
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.
public void Draw2dLine()
from,
Start of the line, in screen coordinates.
to,
End of the line, in screen coordinates.
pen
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.
public void Draw2dPolyline()
Point2f[]
points,
The polyline vertices, in screen coordinates. Fewer than two draws nothing.
pen,
Pen to stroke the polyline with.
closed
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.
public void Draw2dPolyline()
Point2f[]
points,
The polyline vertices, in screen coordinates. Fewer than two draws nothing.
pen
Pen to stroke the polyline with.
Draws 2D text on the viewport.
public void Draw2dText()
text,
the string to draw.
color,
text color.
screenCoordinate,
definition point in screen coordinates (0,0 is top-left corner)
middleJustified,
if true text is centered around the definition point, otherwise it is lower-left justified.
height,
height in pixels (good default is 12)
fontface
font name (good default is "Arial")
Draws 2D text on the viewport.
public void Draw2dText()
text,
the string to draw.
color,
text color.
screenCoordinate,
definition point in screen coordinates (0,0 is top-left corner)
middleJustified,
if true text is centered around the definition point, otherwise it is lower-left justified.
height
height in pixels (good default is 12)
Draws 2D text on the viewport.
Draws 2D text on the viewport.
public void Draw2dText()
text,
The string to draw.
color,
Text color.
screenCoordinate,
Definition point in screen coordinates (0,0 is top-left corner). The alignment attaches to this point.
horizontalAlignment,
Where the definition point sits across the text's horizontal advance.
verticalAlignment,
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,
Height in pixels (good default is 12).
fontface,
Font name (good default is "Arial").
bold,
If true, the bold face of the font family is used.
italic,
If true, the italic face of the font family is used.
underline,
If true, the text is underlined.
strikethrough,
If true, the text is struck through.
applyKerning
If true, the font's kerning pairs are used to space the glyphs.
Draws 2D text on the viewport.
public void Draw2dText()
text,
The string to draw.
color,
Text color.
worldCoordinate,
Definition point in world coordinates.
middleJustified,
If true text is centered around the definition point, otherwise it is lower-left justified.
height,
Height in pixels (good default is 12).
fontface
Font name (good default is "Arial").
Draws 2D text on the viewport.
Draws 2D text on the viewport.
Draws 2D text on the viewport.
public void Draw2dText()
text,
The string to draw.
color,
Text color.
worldCoordinate,
Definition point in world coordinates. The alignment attaches to this point.
horizontalAlignment,
Where the definition point sits across the text's horizontal advance.
verticalAlignment,
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,
Height in pixels (good default is 12).
fontface,
Font name (good default is "Arial").
bold,
If true, the bold face of the font family is used.
italic,
If true, the italic face of the font family is used.
underline,
If true, the text is underlined.
strikethrough,
If true, the text is struck through.
applyKerning
If true, the font's kerning pairs are used to space the glyphs.
public void Draw3dText()
text,
color,
textPlane,
height,
fontface,
bold,
italic,
horizontalAlignment,
verticalAlignment
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
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.
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.
public void DrawArrow()
line,
Arrow shaft.
color,
Color of arrow.
screenSize,
If screenSize != 0.0 then the size (in screen pixels) of the arrow head will be equal to screenSize.
relativeSize
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.
public void DrawArrow()
line,
Vector shaft to draw.
headSize,
Size of the head as a factor of arrow length. 0.1 would be a decent size.
color,
Color of arrow geometry.
shaftWidth
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.
Draws a single arrow head.
public void DrawArrowHead()
tip,
Point of arrow head tip.
direction,
Direction in which arrow head is pointing.
color,
Color of arrow head.
screenSize,
If screenSize != 0.0, then the size (in screen pixels) of the arrow head will be equal to the screenSize.
worldSize
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.
Draws a collection of arrow objects. An arrow consists of a Shaft and an Arrow head at the end of the shaft.
Draws a bitmap in screen coordinates, scaled to fit the given size, through a 2d transform.
public void DrawBitmap()
bitmap,
bitmap to draw
left,
where the left edge of the bitmap should appear in screen coordinates
top,
where the top edge of the bitmap should appear in screen coordinates
width,
width (in pixels) to draw the bitmap at
height,
height (in pixels) to draw the bitmap at
transform
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.
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.
Draws a bitmap in screen coordinates, scaled to fit the given size.
public void DrawBitmap()
bitmap,
bitmap to draw
left,
where the left edge of the bitmap should appear in screen coordinates
top,
where the top edge of the bitmap should appear in screen coordinates
width,
width (in pixels) to draw the bitmap at
height
height (in pixels) to draw the bitmap at
Draws a bitmap in screen coordinates
public void DrawBitmap()
bitmap,
bitmap to draw
left,
where top/left corner of bitmap should appear in screen coordinates
top
where top/left corner of bitmap should appear in screen coordinates
Draws the edges of a BoundingBox.
public void DrawBox()
box,
Box to draw.
color,
Color to draw in.
thickness
Thickness (in pixels) of box edges.
Draws the edges of a BoundingBox.
Draws the edges of a Box object.
Draws the edges of a Box object.
Draws corner widgets of a world aligned bounding box.
public void DrawBoxCorners()
box,
Box to draw.
color,
Color to draw with.
size,
Size (in model units) of the corner widgets.
thickness
Thickness (in pixels) of the corner widgets.
Draws corner widgets of a world aligned bounding box.
public void DrawBoxCorners()
box,
Box to draw.
color,
Color to draw with.
size
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.
Draws a shaded mesh representation of a brep.
public void DrawBrepShaded()
Draws all the wireframe curves of a brep object.
Draws all the wireframe curves of a brep object in the color provided.
DrawBrepWires
#Draws all the wireframe curves of a brep object with the color(s) defined by the display mode.
Draw a single circle object.
Draw a single circle object.
Draw a cipping plane
Draw a wireframe cone.
Draw a wireframe cone.
Draws a construction plane.
public void DrawConstructionPlane()
Draw a typical Rhino Curvature Graph.
public void DrawCurvatureGraph()
curve,
Base curve for curvature graph.
color,
Color of curvature graph.
hairScale,
100 = true length, > 100 magnified, < 100 shortened.
hairDensity,
>= 0 larger numbers = more hairs (good default is 1).
sampleDensity
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.
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).
public void DrawDottedPolyline()
points,
End points of each line segment.
color,
Color of polyline.
close
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.
public void DrawEmapPreview()
brep,
Brep to draw.
color,
Object color.
settings
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.
public void DrawEmapPreview()
Mesh
mesh,
Mesh to draw.
color,
Object color.
settings
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.
Draw a two point gradient filled hatch
public void DrawGradientHatch()
hatch,
stops,
point1,
point2,
linearGradient,
repeat,
boundary,
backgroundFillColor
public void DrawGradientLines()
lines,
strokeWidth,
stops,
point1,
point2,
linearGradient,
repeat
Draw an inference line used in gesture based snapping
public void DrawInferenceLine()
P,
First point used to define the line in world coordinates
O,
Second point used to define the line in world coordinates
color,
Color of line
type
Type of line DisplayPipeline.InferenceLineType
Draws an InstanceDefinition.
public void DrawInstanceDefinition()
Draws an InstanceDefinition.
Draws a shaded InstanceDefinition.
public void DrawInstanceDefinitionShaded()
instanceDefinition,
The instance definition.
material,
Material to draw faces with.
xform
The transformation.
Draws a shaded InstanceDefinition.
public void DrawInstanceDefinitionShaded()
instanceDefinition,
The instance definition.
material
Material to draw faces with.
Draws a light.
Draws a single line object.
Draws a single line object.
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.
public void DrawLines()
lines,
Lines to draw.
color,
Color to draw with.
thickness
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.
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
public void DrawLinesNoClip()
lines,
the lines to draw
color,
Color to draw lines in
thickness
Thickness (in pixels) of lines
Draws an arrow marker as a view-aligned widget.
public void DrawMarker()
tip,
Location of arrow tip point.
direction,
Direction of arrow.
color,
Color of arrow widget.
thickness,
Thickness of arrow widget lines.
size,
Size (in pixels) of the arrow shaft.
rotation
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.
public void DrawMeshesShaded()
meshes,
The meshes to draw as one batch. Each should have current single-precision vertices and vertex normals (see remarks); null entries are skipped.
material
The G2 shaded settings to draw with. When null, default settings are used.
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.
Draws the mesh faces as false color patches. The mesh must have Vertex Colors defined for this to work.
public void DrawMeshFalseColors()
Mesh
mesh
Mesh to draw.
Draws shaded mesh with isodraw settings applied (zebra)
Draws the shaded faces of a given mesh.
public void DrawMeshShaded()
Mesh
mesh,
Mesh to draw.
material,
Material to draw faces with.
faceIndices
An enumeration of the indices of specific faces to draw.
Draws the shaded faces of a given mesh.
public void DrawMeshShaded()
Mesh
mesh,
Mesh to draw.
material,
Material to draw faces with.
int[]
faceIndices
Indices of specific faces to draw.
Draws the shaded faces of a given mesh.
public void DrawMeshShaded()
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.
public void DrawMeshShaded()
Mesh
mesh,
The mesh to draw. Should have current single-precision vertices and vertex normals (see DrawMeshesShaded(IEnumerable<Mesh>, GrasshopperDisplayMaterial)).
material
The G2 shaded settings to draw with. When null, default settings are used.
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.
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.
Draws a RhinoObject.
Draws a single line with specified pattern.
Draws a single line with specified pattern.
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.
public void DrawPoint()
point,
Location of point in world coordinates.
style,
Point display style.
radius,
Point size in pixels.
color
Color of point. If style is ControlPoint, this will be the border color.
Draws a point with a given radius, style and color.
public void DrawPoint()
point,
Location of point in world coordinates.
style,
Point display style.
radius,
Point size in pixels.
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
Draws a point cloud.
public void DrawPointCloud()
cloud,
Point cloud to draw.
size,
Size of points.
color
Color of points in the cloud, if the cloud has a color array this setting is ignored.
Draws a point cloud.
public void DrawPointCloud()
cloud,
Point cloud to draw, if the cloud has a color array, it will be used, otherwise the points will be black.
size
Size of points.
Draws a point cloud.
public void DrawPointCloud()
cloud,
Point cloud to draw.
size,
Size of points.
color
Color of points in the cloud, if the cloud has a color array this setting is ignored.
Draws a point cloud.
public void DrawPointCloud()
cloud,
Point cloud to draw, if the cloud has a color array, it will be used, otherwise the points will be black.
size
Size of points.
public void DrawPoints()
points,
fallbackAttributes,
overrideAttributes
Draw a set of points with a given radius, style and color.
public void DrawPoints()
points,
Location of points in world coordinates.
style,
Point display style.
radius,
Point size in pixels.
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.
public void DrawPoints()
points,
Location of points in world coordinates.
style,
Point display style.
radius,
Point size in pixels.
color
Color of points. If style is ControlPoint, this will be the border color.
Draws a filled, convex polygon from a collection of points.
public void DrawPolygon()
points,
Collection of world coordinate points that are connected by lines to form a closed shape. Collection must contain at least 3 points.
color,
Color to draw with.
filled
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.
public void DrawPolyline()
polyline,
Polyline to draw.
color,
Color to draw in.
thickness
Thickness (in pixels) of the Polyline.
Draws a single Polyline object.
public void DrawPolyline()
Draw a wireframe sphere.
Draw a wireframe sphere.
Draw screen oriented image centered at 2d screen location
public void DrawSprite()
public void DrawSprites()
public void DrawSprites()
bitmap,
items,
size,
translation,
sizeInWorldSpace
Draws the viewport as seen from the left and the right eye viewports and returns the result as OpenGL texture handles.
[CLSCompliant(false)]
public bool DrawStereoFrameBuffer()
viewportLeft,
The viewport representing the left eye location and look direction.
viewportRight,
The viewport representing the right eye location and look direction.
out uint
handleLeft,
Will contain the OpenGL texture handle which references the left output color buffer.
out uint
handleRight
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
public void DrawSubDShaded()
Draws all the wireframe curves of a SubD object
Draws all the wireframe curves os a SubD object using different pens
public void DrawSubDWires()
subd,
SubD to draw
boundaryPen,
Pen to use for boundary wires. If null, no boundary wires will be drawn
smoothInteriorPen,
Pen to use for smooth interior wires. If null, no smooth interior wires will be drawn
creasePen,
Pen to use for crease wires. If null, no crease wires will be drawn
nonmanifoldPen
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
Draw a given viewport to an off-screen bitmap.
public static Bitmap DrawToBitmap()
viewport,
Viewport to draw.
width,
Width of target image.
height
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.
Enable or disable the ColorWriting behavior of the engine.
Enable or disable the DepthTesting behavior of the engine. When DepthTesting is disabled, objects in front will no longer occlude objects behind them.
Enable or disable the DepthWriting behavior of the engine. When DepthWriting is disabled, drawn geometry does not affect the Z-Buffer.
Enable or disable the Lighting logic of the engine.
Force the pipeline to immediately flush any cached geometry to the display
public void Flush()
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.
public nint GetDirect3d11Device()
Returns: Pointer to an ID3D11Device, or IntPtr.Zero.
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.
public nint GetDirect3d11DeviceContext()
Returns: Pointer to an ID3D11DeviceContext1, or IntPtr.Zero.
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.
[CLSCompliant(false)]
public static void GetDrawListSerialNumbers()
out uint
modelSerialNumber,
The current model draw list serial number.
out uint
pageSerialNumber
The current page view draw list serial number.
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
Get an array of 16 floats that represents the "world" to "clip" coordinate transformation in OpenGL's right handed coordinate system
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.
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.
Returns: true if a tiled capture is being performed. If false, the fullSize parameter will have the same size as currentTile
Test a given box for visibility inside the view frustum under the current viewport and model transformation settings.
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.
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.
Returns: true if the object is visible, false if not.
Make a "default" OpenGL context current
Determines screen rectangle that would be drawn to using the Draw2dText(..) function with the same parameters.
public Rectangle Measure2dText()
text,
text to measure.
definitionPoint,
either lower-left or middle of text.
middleJustified,
true=middle justified. false=lower-left justified.
rotationRadians,
text rotation in radians
height,
height in pixels (good default is 12)
fontFace
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.
Pop a ClipTesting flag off the engine's stack.
public void PopClipTesting()
obsoleteUse PopDepthTesting
Pop a DepthTesting flag off the engine's stack.
public void PopDepthTesting()
Pop a DepthWriting flag off the engine's stack.
public void PopDepthWriting()
Pop a model transformation off the engine's model transform stack.
public void PopModelTransform()
Pop a view projection off this pipelines projection stack
public void PopProjection()
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
public void Push2dProjection()
Push a ClipTesting flag on the engine's stack.
obsoleteUse PushDepthTesting
Push a FaceCull flag on the engine's stack.
Push a DepthTesting flag on the engine's stack.
Push a DepthWriting flag on the engine's stack.
Push a model transformation on the engine's model transform stack.
Remove a clipping plane from the pipeline for this frame
Sets up a display material.
public DisplayMaterial SetupDisplayMaterial()
doc,
The active document.
rhinoObject,
The Rhino object.
attributes,
The object attributes.
instanceTransform
The instance object transformation.
Returns: A display material if successful, null otherwise.
Sets up a display material.
public DisplayMaterial SetupDisplayMaterial()
doc,
The active document.
rhinoObject,
The Rhino object.
attributes
The object attributes.
Returns: A display material if successful, null otherwise.
Sets up a display material.
Returns: A display material if successful, null otherwise.
Multisample modes available
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.