Struct FixtureDefinition 

pub struct FixtureDefinition {
    pub size_m: [f32; 3],
    pub models: Vec<Model>,
    pub outline: Option<usize>,
    pub pixels: Vec<Pixel>,
    pub modes: Vec<Mode>,
    pub scaling: Scaling,
    pub photo: Option<Photo>,
}

Everything relevant about a physical lamp which may be installed. Physical dimensions are authoritative; a layout only places and scales the fixture.

Fields

size_m: [f32; 3]

Overall physical extent, in metres.

models: Vec<Model>

outline: Option<usize>

Model drawn as the fixture’s outline in the patch editor.

pixels: Vec<Pixel>

modes: Vec<Mode>

scaling: Scaling

How a layout may distort the fixture.

photo: Option<Photo>

A picture of the lamp drawn under its pixels, in the editors and when picking a fixture to patch; definitions without one show only their own drawing.

Implementations

impl FixtureDefinition

pub fn insert_pixels(&mut self, pixels: Vec<Pixel>) -> Range<usize>

Appends pixels; each gets a group of its own in every mode. Returns where they landed.

pub fn remove_pixels(&mut self, indices: &BTreeSet<usize>)

pub fn reorder(&mut self, order: &[usize]) -> Result<(), DefinitionError>

Rearranges the pixels, and with them the DMX order: new pixel i is old pixel order[i].

pub fn reverse_pixels(&mut self, indices: &BTreeSet<usize>)

Reverses the DMX order of the selected pixels among the slots they occupy; every other pixel keeps its place.

pub fn move_to_front(&mut self, indices: &BTreeSet<usize>)

Makes the selected pixels the first ones in DMX order, keeping their relative order, the rest following as before.

pub fn duplicate_pixels( &mut self, indices: &BTreeSet<usize>, offset_m: [f32; 3], ) -> Range<usize>

Appends a copy of every selected pixel, moved by offset_m. Returns where the copies landed.

pub fn set_model_of( &mut self, indices: &BTreeSet<usize>, model: usize, ) -> Result<(), DefinitionError>

pub fn remove_model(&mut self, model: usize) -> Result<(), DefinitionError>

Removes a model no pixel draws with.

pub fn pixel_bounds_m(&self) -> Option<([f32; 2], [f32; 2])>

The smallest rectangle around every pixel’s drawing, in metres, as (min, max). A pixel whose model is missing counts as a point.

pub fn fit_size(&mut self)

Sizes the fixture to cover its pixels and its outline. The footprint is centred on the fixture’s origin, as a layout draws it, so pixels off centre widen it on both sides; the depth is kept.

pub fn fit_size_to_photo(&mut self)

Like FixtureDefinition::fit_size, and covering the photo too, so the fixture’s frame (what a layout selects and outlines) holds the whole picture of the lamp.

pub fn centre_pixels(&mut self)

Moves every pixel so their drawings are centred on the fixture’s origin, which is where a layout places and rotates the fixture. The photo moves along, so it stays under its LEDs.

pub fn add_mode(&mut self, name: impl Into<String>) -> usize

Adds a mode in which every pixel has its own group, for the user to group from there. Returns its index.

pub fn remove_mode(&mut self, index: usize) -> Result<(), DefinitionError>

Removes a mode. Layouts refer to a definition’s modes by index, so a fixture that used a later mode moves to its neighbour or falls back to “individual”.

pub fn group_selection( &mut self, mode: usize, pixels: &BTreeSet<usize>, ) -> Result<(), DefinitionError>

Puts the selected pixels into one group of mode.

pub fn ungroup_selection( &mut self, mode: usize, pixels: &BTreeSet<usize>, ) -> Result<(), DefinitionError>

Gives every selected pixel a group of its own in mode.

pub fn each_own_group(&mut self, mode: usize) -> Result<(), DefinitionError>

Gives every pixel a group of its own in mode, keeping its name.

pub fn next_pixel_number(&self) -> usize

The number the next generated pixel is named with.

impl FixtureDefinition

pub fn channel_count(&self) -> u16

The DMX channels the fixture occupies. Saturates at u16::MAX: a malformed definition with more channels is far wider than a universe either way, and gets no address (see Patch::addresses).

pub fn channel_offset(&self, pixel: usize) -> u16

DMX offset of pixel from the fixture’s address. Saturates like Self::channel_count.

pub fn default_mode(&self) -> usize

Index of the definition’s default mode. Always the first one.

pub fn mode(&self, index: usize) -> Option<&Mode>

pub fn mode_names(&self) -> Vec<&str>

pub fn model(&self, index: usize) -> Option<&Model>

pub fn non_rgb_pixel(&self) -> Option<&Pixel>

The first pixel that is not a permutation of red, green and blue, if any. gled drives three-channel RGB pixels in any order, nothing else.

impl FixtureDefinition

pub fn pixel_scene_positions(&self, position: &LayoutPosition) -> Vec<Pos2>

Scene position of every pixel at position, in pixel order.

Trait Implementations

impl AssetTrait for FixtureDefinition

const DIR_NAME: &'static str = "fixture_definitions"

const NAME: &'static str = "Fixture Definition"

const SHOW_NAME_IF_SELECTED: bool = true

impl Clone for FixtureDefinition

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FixtureDefinition

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

Formats the value using the given formatter.

impl Default for FixtureDefinition

fn default() -> Self

An empty definition, as a newly created asset starts out. Definitions are assets on disk; nothing about a physical lamp is compiled in. A fresh installation has none: draw one in the definition editor, or old SVG lamps are converted on start.

impl<'de> Deserialize<'de> for FixtureDefinition

where FixtureDefinition: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FixtureDefinition

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for FixtureDefinition

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FixtureDefinition