bevy_polyline

The PolylineMaterial automatically determines its transparency behavior based on the alpha channel of the color property. While the AlphaMode enum is used internally by the renderer to select the correct pipeline, you control this behavior by setting the alpha value of your LinearRgba color.

Supported modes (determined by the renderer):

• Opaque: Used when color.alpha() >= 1.0.
• Blend: Used when color.alpha() < 1.0. This uses standard alpha-blending.

Note: The renderer also supports internal modes like Mask, Premultiplied, Add, and Multiply, but the primary way to trigger transparency in the current implementation is via the color's alpha channel.

To spawn a polyline in your world, use the PolylineBundle. This bundle includes the PolylineHandle (which points to the actual vertex data), a PolylineMaterialHandle, and standard Bevy transform and visibility components.

use bevy::prelude::*;
use bevy_polyline::{Polyline, Polyline, PolylineBundle, PolylineHandle};

fn spawn_polyline(mut commands: Commands, mut polylines: ResMut<Assets<Polyline>>) {
    let polyline_asset = Polylines::add(Polyline {
        vertices: vec![Vec3::ZERO, Vec3::X, Vec3::Y],
    });

    commands.spawn(PolylineBundle {
        polyline: PolylineHandle(polyline_asset),
        // material: PolylineMaterialHandle(your_material_handle),
        ..default()
    });
}

To enable polyline rendering in your Bevy application, add the PolylinePlugin to your app. This plugin initializes the necessary internal assets (like the polyline shader) and registers the core polyline plugins: PolylineBasePlugin, PolylineRenderPlugin, and PolylineMaterialPlugin.

use bevy::prelude::*;
use bevy_polyline::PolylinePlugin;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(PolylinePlugin)
        .run();
}

To enable rendering of entities using PolylineMaterial, you must add the PolylineMaterialPlugin to your Bevy App. This plugin initializes the necessary assets, extraction logic, and render pipelines for both opaque and transparent polylines.

use bevy_polyline::material::PolylineMaterialPlugin;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(PolylineMaterialPlugin)
        .run();
}

To use the core polyline functionality, add PolylineBasePlugin to your Bevy App. This plugin initializes the Polyline asset and sets up the necessary rendering infrastructure for GPU polylines.

use bevy_polyline::PolylineBasePlugin;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(PolylineBasePlugin)
        .run();
}

While Bevy Polyline implements line thinness fade to reduce aliasing, you may still encounter shimmering if line segments are extremely short (triangles smaller than 1 pixel).

Best Practice: To minimize shimmering, ensure that you only add line segments that meet a minimum length threshold.

You can customize the visual properties of a Polyline using the PolylineMaterial. It provides control over the line's thickness, color, and how width behaves in 3D space.

Key fields:

• width: Determines the thickness. In non-perspective mode, this correlates directly to screen pixels. In perspective mode, the width is divided by the w component of the homogeneous coordinate, meaning the line appears to have a constant size at the near plane and becomes smaller as it moves further away.
• color: Sets the line color.
• perspective: A boolean determining if the width should scale with distance.

Bevy Polyline tracks the main branch of Bevy. Ensure your version of bevy_polyline matches your bevy version according to the compatibility table below:

The bevy_polyline::prelude module provides the primary types needed to work with polylines and their materials. Use this prelude to access:

• Polyline: The core component representing a polyline.
• PolylineBundle: A bundle containing all necessary components for spawning a polyline.
• PolylineHandle: A handle to a polyline.
• PolylineMaterial: The material used for rendering polylines.
• PolylineMaterialHandle: A handle to a PolylineMaterial.

use bevy_polyline::prelude::*;

The following types are the primary interfaces for managing polylines:

• Polyline: The source asset containing a Vec<Vec3> of vertices.
• PolylineHandle: A component wrapping a Handle<Polyline>, used to associate an entity with specific vertex data.
• PolylineBundle: A bundle containing PolylineHandle, PolylineMaterialHandle, Transform, GlobalTransform, Visibility, InheritedVisibility, and ViewVisibility for easy spawning.