Struct SceneDrawingContext

pub struct SceneDrawingContext {
    pub lines: Vec<Line>,
}

Drawing context for simple graphics, it allows you to draw simple figures using a set of lines. Most common use of the context is to draw some debug geometry in your game, draw physics info (contacts, meshes, shapes, etc.), draw temporary geometry in editor and so on.

This drawing context is meant to be used only for debugging purposes, it draws everything as set of lines and no solid faces supported.

It should be noted that the actual drawing is not immediate, provided methods just populate internal array of lines and it will be drawn on special render stage.

Example

The usage of the drawing context is a bit unusual, at the beginning of the frame you should clear the contents of the context and only then call “drawing” methods. Otherwise, the internal buffer will increase in size to values which will take lots of time draw and the FPS will significantly drop with every frame until it reaches zero.

So typical usage would be:

fn draw_debug_objects(ctx: &mut SceneDrawingContext) {
    // Clear at the beginning of the frame.
    ctx.clear_lines();

    // Draw something.
    ctx.draw_cone(20, 1.0, 2.0, Matrix4::identity(), Color::WHITE, true);
}

You could avoid calling clear_lines in specific cases where your debug geometry is not changing, then the context could be populated once and rendered multiple times without any issues. Another case when you could not call clear_lines each frame, is “tracing” scenario - for example you may need to trace moving objects. In this case call clear_lines once in a few seconds, and you’ll see the “track” of moving objects.

Rendering performance

The engine renders the entire set of lines in a single draw call, so it very fast - you should be able to draw up to few millions of lines without any significant performance issues.

Fields

lines: Vec<Line>

List of lines to draw.

Implementations

impl SceneDrawingContext

pub fn draw_frustum(&mut self, frustum: &Frustum, color: Color)

Draws frustum with given color.

pub fn draw_aabb(&mut self, aabb: &AxisAlignedBoundingBox, color: Color)

Draws axis-aligned bounding box with given color.

pub fn draw_oob( &mut self, aabb: &AxisAlignedBoundingBox, transform: Matrix4<f32>, color: Color, )

Draws object-oriented bounding box with given color.

pub fn draw_transform(&mut self, matrix: Matrix4<f32>)

Draws transform as basis vectors.

pub fn draw_triangle( &mut self, a: Vector3<f32>, b: Vector3<f32>, c: Vector3<f32>, color: Color, )

Draws a triangle by given points.

pub fn draw_pyramid( &mut self, top: Vector3<f32>, a: Vector3<f32>, b: Vector3<f32>, c: Vector3<f32>, d: Vector3<f32>, color: Color, transform: Matrix4<f32>, )

Draws a pyramid by given points.

pub fn draw_wire_sphere( &mut self, position: Vector3<f32>, radius: f32, segments: usize, color: Color, )

Draws a sphere as a set of three circles around each axes.

pub fn draw_circle( &mut self, position: Vector3<f32>, radius: f32, segments: usize, transform: Matrix4<f32>, color: Color, )

Draws a circle at given world-space position with given radius. segments could be used to control quality of the circle.

pub fn draw_circle_segment( &mut self, position: Vector3<f32>, radius: f32, segments: usize, begin_angle: f32, end_angle: f32, transform: Matrix4<f32>, color: Color, )

Draws a circle segment between two given angles. Center of the segment is defined by position, segments defines quality of the shape.

pub fn draw_rectangle( &mut self, half_width: f32, half_height: f32, transform: Matrix4<f32>, color: Color, )

Draws a rectangle with given width and height.

pub fn draw_sphere( &mut self, position: Vector3<f32>, slices: usize, stacks: usize, radius: f32, color: Color, )

Draws a wire sphere with given parameters.

pub fn draw_sphere_section( &mut self, radius: f32, theta_range: Range<f32>, theta_steps: usize, phi_range: Range<f32>, phi_steps: usize, transform: Matrix4<f32>, color: Color, )

Draws a wire sphere with given parameters.

pub fn draw_cone( &mut self, sides: usize, r: f32, h: f32, transform: Matrix4<f32>, color: Color, cap: bool, )

Draws a wire Y oriented cone where the tip is on +Y with given parameters.

pub fn draw_cylinder( &mut self, sides: usize, r: f32, h: f32, caps: bool, transform: Matrix4<f32>, color: Color, )

Draws a wire cylinder with given parameters.

pub fn draw_flat_capsule( &mut self, radius: f32, height: f32, segments: usize, transform: Matrix4<f32>, color: Color, )

Draws a flat capsule with given height and radius. segments defines quality of the shape.

pub fn draw_capsule( &mut self, radius: f32, height: f32, transform: Matrix4<f32>, color: Color, )

Draws vertical capsule with given radius and height and then applies given transform.

pub fn draw_segment_flat_capsule( &mut self, begin: Vector2<f32>, end: Vector2<f32>, radius: f32, segments: usize, transform: Matrix4<f32>, color: Color, )

Draws a flat capsule between two points with given radius. segments defines quality of the shape.

pub fn draw_segment_capsule( &mut self, begin: Vector3<f32>, end: Vector3<f32>, radius: f32, v_segments: usize, h_segments: usize, transform: Matrix4<f32>, color: Color, )

Draws capsule between two points with given tesselation and then applies given transform to all points.

pub fn draw_arrow( &mut self, sides: usize, color: Color, length: f32, radius: f32, transform: Matrix4<f32>, )

Draws an Y+ oriented arrow with the given parameters.

pub fn add_line(&mut self, line: Line)

Adds single line into internal buffer.

pub fn clear_lines(&mut self)

Removes all lines from internal buffer. For dynamic drawing you should call it every update tick of your application.

Trait Implementations

impl Clone for SceneDrawingContext

fn clone(&self) -> SceneDrawingContext

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SceneDrawingContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DebugRenderBackend for SceneDrawingContext

fn draw_line( &mut self, _object: DebugRenderObject<'_>, a: Point<f32>, b: Point<f32>, color: [f32; 4], )

Draws a colored line.

fn filter_object(&self, _object: DebugRenderObject<'_>) -> bool

Predicate to filter-out some objects from the debug-rendering.

fn draw_polyline( &mut self, object: DebugRenderObject<'_>, vertices: &[OPoint<f32, Const<2>>], indices: &[[u32; 2]], transform: &Isometry<f32, Unit<Complex<f32>>, 2>, scale: &Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, color: [f32; 4], )

Draws a set of lines.

fn draw_line_strip( &mut self, object: DebugRenderObject<'_>, vertices: &[OPoint<f32, Const<2>>], transform: &Isometry<f32, Unit<Complex<f32>>, 2>, scale: &Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, color: [f32; 4], closed: bool, )

Draws a chain of lines.

impl DebugRenderBackend for SceneDrawingContext

fn draw_line( &mut self, _object: DebugRenderObject<'_>, a: Point<f32>, b: Point<f32>, color: [f32; 4], )

Draws a colored line.

fn filter_object(&self, _object: DebugRenderObject<'_>) -> bool

Predicate to filter-out some objects from the debug-rendering.

fn draw_polyline( &mut self, object: DebugRenderObject<'_>, vertices: &[OPoint<f32, Const<3>>], indices: &[[u32; 2]], transform: &Isometry<f32, Unit<Quaternion<f32>>, 3>, scale: &Matrix<f32, Const<3>, Const<1>, ArrayStorage<f32, 3, 1>>, color: [f32; 4], )

Draws a set of lines.

fn draw_line_strip( &mut self, object: DebugRenderObject<'_>, vertices: &[OPoint<f32, Const<3>>], transform: &Isometry<f32, Unit<Quaternion<f32>>, 3>, scale: &Matrix<f32, Const<3>, Const<1>, ArrayStorage<f32, 3, 1>>, color: [f32; 4], closed: bool, )

Draws a chain of lines.

impl Default for SceneDrawingContext

fn default() -> SceneDrawingContext

Returns the “default value” for a type.