LXFixture (LX API)

java.lang.Object
- heronarts.lx.LXComponent
- - heronarts.lx.structure.LXFixture

All Implemented Interfaces:

LXComponent.Renamable, LXPath, LXSerializable, LXParameterListener, LXFixtureContainer

Direct Known Subclasses:

JsonFixture, LXProtocolFixture
```
public abstract class LXFixture
extends LXComponent
implements LXFixtureContainer, LXComponent.Renamable
```
An LXFixture is a rich LXComponent representing a physical lighting fixture which may be addressed by output packets. This class encapsulates the ability to configure the dimensions and location of the lighting fixture as well as to specify its output modes and protocol.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`LXFixture.DynamicIndexBuffer` An internal utility class which dynamically keeps the index values inside an index buffer up to date and in sync with this fixture.
`static class`	`LXFixture.IndexBufferSegment`
`static class`	`LXFixture.Protocol` Output protocols
`class`	`LXFixture.Submodel` Helper class to ensure that Submodels are only constructed using the points from the produced LXModel array.

Nested classes/interfaces inherited from class heronarts.lx.LXComponent
LXComponent.Placeholder, LXComponent.Renamable

Nested classes/interfaces inherited from interface heronarts.lx.LXSerializable
LXSerializable.Utils

Field Summary

Fields
Modifier and Type	Field and Description
`BoundedParameter`	`brightness`
`protected List<LXFixture>`	`children`
`BooleanParameter`	`enabled`
`BooleanParameter`	`identify`
`BooleanParameter`	`mute`
`protected static LXFixture.Submodel[]`	`NO_SUBMODELS`
`List<LXOutput>`	`outputs` Publicly accessible list of the outputs that should be sent to this fixture
`BoundedParameter`	`pitch`
`List<LXPoint>`	`points` Publicly accessible immutable view of the points in this fixture.
`BoundedParameter`	`roll`
`BooleanParameter`	`selected`
`BooleanParameter`	`solo`
`BoundedParameter`	`x`
`BoundedParameter`	`y`
`BoundedParameter`	`yaw`
`BoundedParameter`	`z`

Fields inherited from class heronarts.lx.LXComponent
controlSurfaceSemaphore, KEY_CLASS, KEY_COMPONENT_ID, KEY_ID, KEY_PARAMETER_PATH, KEY_PATH, label, lx, modulationColor

Constructor Summary

Constructors
Modifier Constructor and Description

protected LXFixture(LX lx)

protected LXFixture(LX lx, String label)

Constructors
Modifier	Constructor and Description
`protected`	`LXFixture(LX lx)`
`protected`	`LXFixture(LX lx, String label)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addChild(LXFixture child)`
`protected LXFixture`	`addGeometryParameter(String path, LXParameter parameter)` Adds a parameter which impacts the position of points in the fixture.
`protected LXFixture`	`addMetricsParameter(String path, LXParameter parameter)` Adds a parameter which impacts the number of LEDs that are in the fixture.
`protected void`	`addOutput(LXOutput output)` Subclasses call this method to add an output to thix fixture.
`protected LXFixture`	`addOutputParameter(String path, LXParameter parameter)` Adds a parameter which impacts the outputs of the fixture.
`protected LXComponent`	`addParameter(String path, LXParameter parameter)` Adds a parameter to the component at a fixed path.
`protected void`	`beforeRegenerate()` Subclasses may override this method to do custom preparation work before `computeGeometryMatrix(LXMatrix)` is called.
`protected abstract void`	`buildOutputs()` Subclasses must override this method to provide an implementation that produces the necessary set of outputs for this fixture to be sent.
`protected void`	`computeGeometryMatrix(LXMatrix geometryMatrix)` Subclasses may override this if they perform geometric transformations in a different order or using totally different parameters.
`protected abstract void`	`computePointGeometry(LXMatrix transform, List<LXPoint> points)` This method should be implemented by subclasses to generate the geometry of the fixture any time its geometry parameters have changed.
`protected LXModel`	`constructModel(List<LXPoint> modelPoints, List<? extends LXModel> childModels, String[] modelKeys)` Subclasses may override this method to use custom model type
`protected LXPoint`	`constructPoint(int localIndex)` Subclasses may override this method to use custom point types
`protected LXPoint`	`copyPoint(LXPoint copy)` Subclasses may override this method to use custom point types
`void`	`dispose()` Invoked when a component is being removed from the system and will no longer be used at all.
`void`	`fixtureGenerationChanged(LXFixture fixture)` The generation of this fixture has changed, its metrics or hierarchy are now different.
`void`	`fixtureGeometryChanged(LXFixture fixture)` The geometry of this fixture has changed, its metrics and hierarchy are consistent but the point locations may have changed.
`protected int`	`getFirstPointIndex()`
`LXMatrix`	`getGeometryMatrix()` Returns a copy of the geometry matrix for this fixture
`LXMatrix`	`getGeometryMatrix(LXMatrix m)` Returns the geometry transformation matrix, copied into the given matrix
`int`	`getIndex()`
`int`	`getIndexBufferOffset()` Returns the offset of this fixture in the index buffer
`protected Map<String,String>`	`getMetaData()` Subclasses may override to provide a map of String key/value pairs that are attached as metadata onto the resulting LXModel object
`protected String`	`getModelKey()` Subclasses should implement, specifying the type key of this fixture in the model hierarchy.
`protected String[]`	`getModelKeys()` Subclasses may override to return an array of multiple key types.
`String`	`getPath()` Accessor for the path of this object.
`void`	`load(LX lx, JsonObject obj)` Loads the LX component.
`void`	`onParameterChanged(LXParameter p)` Subclasses are free to override this if desired.
`protected void`	`regenerate()` Invoked when this fixture has been loaded or added to some container.
`protected void`	`reindexOutputs()` Subclasses may override this method to update their outputs in the case that the point indexing of this fixture has changed.
`protected void`	`removeChild(LXFixture child)`
`protected void`	`removeOutput(LXOutput output)` Subclasses call this method to remove a output from the fixture.
`protected void`	`setStructure(LXStructure structure)`
`protected abstract int`	`size()` Subclasses must implement to specify the number of points in the fixture.
`protected int[]`	`toDynamicIndexBuffer()` Get an index buffer version of this fixture.
`protected int[]`	`toDynamicIndexBuffer(int start, int num)` Get an index buffer version of this fixture.
`protected int[]`	`toDynamicIndexBuffer(int start, int num, int stride)` Get an index buffer version of this fixture.
`protected int[]`	`toDynamicIndexBuffer(LXFixture.IndexBufferSegment... segments)` Get an index buffer version of this fixture.
`protected LXFixture.Submodel[]`	`toSubmodels()` Subclasses may override when they specify submodels
`int`	`totalSize()` Total points in this model and all its submodels

Methods inherited from class heronarts.lx.LXComponent
addArray, addChild, addInternalParameter, addParameter, contains, copyParameters, getChild, getComponentName, getComponentName, getComponentName, getId, getLabel, getLX, getOscAddress, getOscLabel, getOscPath, getParameter, getParameters, getParent, handleOscMessage, loadParameters, removeParameter, removeParameter, save, saveParameters, setParent, toString, toString

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface heronarts.lx.LXPath
get, get, getCanonicalLabel, getCanonicalLabel, getCanonicalPath, getCanonicalPath, getComponent, getComponent, getParameter, getParameter

- Field Detail
  - selected
```
public final BooleanParameter selected
```
  - identify
```
public final BooleanParameter identify
```
  - x
```
public final BoundedParameter x
```
  - y
```
public final BoundedParameter y
```
  - z
```
public final BoundedParameter z
```
  - yaw
```
public final BoundedParameter yaw
```
  - pitch
```
public final BoundedParameter pitch
```
  - roll
```
public final BoundedParameter roll
```
  - enabled
```
public final BooleanParameter enabled
```
  - brightness
```
public final BoundedParameter brightness
```
  - mute
```
public final BooleanParameter mute
```
  - solo
```
public final BooleanParameter solo
```
  - children
```
protected final List<LXFixture> children
```
  - outputs
```
public final List<LXOutput> outputs
```
    Publicly accessible list of the outputs that should be sent to this fixture
  - points
```
public final List<LXPoint> points
```
    Publicly accessible immutable view of the points in this fixture. Should not be directly modified. Only contains this fixture's direct points, not any of its children.
  - NO_SUBMODELS
```
protected static final LXFixture.Submodel[] NO_SUBMODELS
```
- Constructor Detail
  - LXFixture
```
protected LXFixture(LX lx)
```
  - LXFixture
```
protected LXFixture(LX lx,
                    String label)
```
- Method Detail
  - addParameter
```
protected LXComponent addParameter(String path,
                                   LXParameter parameter)
```
    Description copied from class: LXComponent
    
    Adds a parameter to the component at a fixed path. The parameter will be registered in the LX hierarchy, and if it is of a listenable type will also send and receive OSC messages. Listenable parameters will also be automatically registered with their parent component as a listener for notifications upon any change of value.
    
    Overrides:
    
    addParameter in class LXComponent
    
    Parameters:
    
    path - String key path to the parameter, must be unique
    
    parameter - Parameter to add to the component
    
    Returns:
    
    this
  - getPath
```
public String getPath()
```
    Description copied from class: LXComponent
    
    Accessor for the path of this object. Returns the path this component was registered with. Some subclasses may override this if path structure is dynamic.
    
    Specified by:
    
    getPath in interface LXPath
    
    Overrides:
    
    getPath in class LXComponent
    
    Returns:
    
    path of this component relative to its parent
  - getIndex
```
public int getIndex()
```
  - getFirstPointIndex
```
protected int getFirstPointIndex()
```
  - setStructure
```
protected void setStructure(LXStructure structure)
```
  - addChild
```
protected void addChild(LXFixture child)
```
  - removeChild
```
protected void removeChild(LXFixture child)
```
  - fixtureGenerationChanged
```
public final void fixtureGenerationChanged(LXFixture fixture)
```
    Description copied from interface: LXFixtureContainer
    
    The generation of this fixture has changed, its metrics or hierarchy are now different. The container will need to take this into account.
    
    Specified by:
    
    fixtureGenerationChanged in interface LXFixtureContainer
    
    Parameters:
    
    fixture - Fixture that has changed
  - fixtureGeometryChanged
```
public final void fixtureGeometryChanged(LXFixture fixture)
```
    Description copied from interface: LXFixtureContainer
    
    The geometry of this fixture has changed, its metrics and hierarchy are consistent but the point locations may have changed.
    
    Specified by:
    
    fixtureGeometryChanged in interface LXFixtureContainer
    
    Parameters:
    
    fixture - Fixture that has changed
  - addMetricsParameter
```
protected LXFixture addMetricsParameter(String path,
                                        LXParameter parameter)
```
    Adds a parameter which impacts the number of LEDs that are in the fixture. Changes to these parameters require re-generating the whole points array.
    
    Parameters:
    
    path - Path to parameter
    
    parameter - Parameter
    
    Returns:
    
    this
  - addGeometryParameter
```
protected LXFixture addGeometryParameter(String path,
                                         LXParameter parameter)
```
    Adds a parameter which impacts the position of points in the fixture. Changes to these parameters do not require rebuilding the points array, but the point positions are updated and model change notifications are required.
    
    Parameters:
    
    path - Path to parameter
    
    parameter - Parameter
    
    Returns:
    
    this
  - addOutputParameter
```
protected LXFixture addOutputParameter(String path,
                                       LXParameter parameter)
```
    Adds a parameter which impacts the outputs of the fixture. Whenever one is changed, the outputs will be regenerated.
    
    Parameters:
    
    path - Path to parameter
    
    parameter - Parameter
    
    Returns:
    
    this
  - onParameterChanged
```
public void onParameterChanged(LXParameter p)
```
    Description copied from class: LXComponent
    
    Subclasses are free to override this if desired. It will automatically fire for any listenable parameter that is registered with this component.
    
    Specified by:
    
    onParameterChanged in interface LXParameterListener
    
    Overrides:
    
    onParameterChanged in class LXComponent
    
    Parameters:
    
    p - Parameter that has a value change
  - toDynamicIndexBuffer
```
protected int[] toDynamicIndexBuffer()
```
    Get an index buffer version of this fixture. The index buffer will be dynamic and have its point indices updated automatically anytime this fixture is moved or the larger structure is rearranged. The buffer will stop being updated if this fixture's metrics are changed or if it is regenerated for any other reason.
    
    Returns:
    
    Index buffer of the points in this fixture
  - toDynamicIndexBuffer
```
protected int[] toDynamicIndexBuffer(int start,
                                     int num)
```
    Get an index buffer version of this fixture. The index buffer will be dynamic and have its point indices updated automatically anytime this fixture is moved or the larger structure is rearranged. The buffer will stop being updated if this fixture's metrics are changed or if it is regenerated for any other reason.
    
    Parameters:
    
    start - Start index relative to this fixture
    
    num - Total number of points
    
    Returns:
    
    Index buffer of the points in this fixture
  - toDynamicIndexBuffer
```
protected int[] toDynamicIndexBuffer(int start,
                                     int num,
                                     int stride)
```
    Get an index buffer version of this fixture. The index buffer will be dynamic and have its point indices updated automatically anytime this fixture is moved or the larger structure is rearranged. The buffer will stop being updated if this fixture's metrics are changed or if it is regenerated for any other reason.
    
    Parameters:
    
    start - Start index relative to this fixture
    
    num - Total number of points
    
    stride - How many points to stride over for each step
    
    Returns:
    
    Index buffer of the points in this fixture
  - toDynamicIndexBuffer
```
protected int[] toDynamicIndexBuffer(LXFixture.IndexBufferSegment... segments)
```
    Get an index buffer version of this fixture. The index buffer will be dynamic and have its point indices updated automatically anytime this fixture is moved or the larger structure is rearranged. The buffer will stop being updated if this fixture's metrics are changed or if it is regenerated for any other reason.
    
    Parameters:
    
    segments - Segments in the index buffer
    
    Returns:
    
    Index buffer of the points in this fixture, as defined by segments
  - buildOutputs
```
protected abstract void buildOutputs()
```
    Subclasses must override this method to provide an implementation that produces the necessary set of outputs for this fixture to be sent. The subclass should call addOutput(LXOutput) for each output.
  - reindexOutputs
```
protected void reindexOutputs()
```
    Subclasses may override this method to update their outputs in the case that the point indexing of this fixture has changed. Outputs may be removed and readded inside this method if necessary. If the LXFixture.DynamicIndexBuffer class has been used to construct indices for outputs, then no action should typically be necessary.
  - addOutput
```
protected void addOutput(LXOutput output)
```
    Subclasses call this method to add an output to thix fixture. This may only be called from within the buildOutputs() function.
    
    Parameters:
    
    output - Output to add
  - removeOutput
```
protected void removeOutput(LXOutput output)
```
    Subclasses call this method to remove a output from the fixture. This may only be performed from within the reindexOutputs or buildOutputs methods.
    
    Parameters:
    
    output - Output to remove
  - regenerate
```
protected final void regenerate()
```
    Invoked when this fixture has been loaded or added to some container. Will rebuild the points and the metrics, and notify container of the change to this fixture's generation
  - beforeRegenerate
```
protected void beforeRegenerate()
```
    Subclasses may override this method to do custom preparation work before computeGeometryMatrix(LXMatrix) is called.
  - computeGeometryMatrix
```
protected void computeGeometryMatrix(LXMatrix geometryMatrix)
```
    Subclasses may override this if they perform geometric transformations in a different order or using totally different parameters. The supplied parameter is a mutable matrix which will initially hold the value of the parent transformation matrix. It can then be further manipulated based upon the parameters.
    
    Parameters:
    
    geometryMatrix - The geometry transformation matrix for this object
  - computePointGeometry
```
protected abstract void computePointGeometry(LXMatrix transform,
                                             List<LXPoint> points)
```
    This method should be implemented by subclasses to generate the geometry of the fixture any time its geometry parameters have changed. The correct number of points will have already been computed, and merely need to have their positions set.
    
    Parameters:
    
    transform - A transform matrix representing the fixture's position
    
    points - The list of points that need to have their positions set
  - constructModel
```
protected LXModel constructModel(List<LXPoint> modelPoints,
                                 List<? extends LXModel> childModels,
                                 String[] modelKeys)
```
    Subclasses may override this method to use custom model type
    
    Parameters:
    
    modelPoints - Points in the model
    
    childModels - Child models
    
    modelKeys - Model keys
    
    Returns:
    
    LXModel instance, or concrete subclass
  - constructPoint
```
protected LXPoint constructPoint(int localIndex)
```
    Subclasses may override this method to use custom point types
    
    Parameters:
    
    localIndex - Index of the point relative to this fixture
    
    Returns:
    
    LXPoint or concrete subclass
  - copyPoint
```
protected LXPoint copyPoint(LXPoint copy)
```
    Subclasses may override this method to use custom point types
    
    Parameters:
    
    copy - Point to make a copy of
    
    Returns:
    
    LXPoint or concrete subclass, should be deep copy of the original
  - getMetaData
```
protected Map<String,String> getMetaData()
```
    Subclasses may override to provide a map of String key/value pairs that are attached as metadata onto the resulting LXModel object
    
    Returns:
    
    Map of key-value String pairs, or null if none
  - getModelKey
```
protected String getModelKey()
```
    Subclasses should implement, specifying the type key of this fixture in the model hierarchy.
    
    Returns:
    
    String key for the model type
  - getModelKeys
```
protected String[] getModelKeys()
```
    Subclasses may override to return an array of multiple key types.
    
    Returns:
    
    List of model key types for this fixture
  - toSubmodels
```
protected LXFixture.Submodel[] toSubmodels()
```
    Subclasses may override when they specify submodels
    
    Returns:
    
    Array of submodel objects
  - size
```
protected abstract int size()
```
    Subclasses must implement to specify the number of points in the fixture. This does not include the number of points that are in children.
    
    Returns:
    
    number of points immediately in the fixture
  - getIndexBufferOffset
```
public final int getIndexBufferOffset()
```
    Returns the offset of this fixture in the index buffer
    
    Returns:
    
    Offset into the index buffer
  - getGeometryMatrix
```
public LXMatrix getGeometryMatrix()
```
    Returns a copy of the geometry matrix for this fixture
    
    Returns:
    
    Copy of geometry matrix
  - getGeometryMatrix
```
public LXMatrix getGeometryMatrix(LXMatrix m)
```
    Returns the geometry transformation matrix, copied into the given matrix
    
    Parameters:
    
    m - LXMatrix object to copy into
    
    Returns:
    
    Geometric transformation matrix, copied into parameter value
  - totalSize
```
public final int totalSize()
```
    Total points in this model and all its submodels
    
    Returns:
    
    Total number of points in this model and all submodels
  - dispose
```
public void dispose()
```
    Description copied from class: LXComponent
    
    Invoked when a component is being removed from the system and will no longer be used at all. This unregisters the component and should free up any resources and parameter listeners. Ideally after this method is called the object should be eligible for garbage collection. Subclasses are generally expected to override this method to handle their particular cleanup work. They should also generally call super.dispose() at the appropriate time to perform the basic cleanup, which may need to happen either before or after cleaning up other objects.
    
    Overrides:
    
    dispose in class LXComponent
  - load
```
public void load(LX lx,
                 JsonObject obj)
```
    Description copied from class: LXComponent
    
    Loads the LX component. Restores the ID of the component, as well as its internal and user-facing parameters. Any explicitly registered children will be automatically loaded, so long as they are direct descendants. Dynamic arrays will not be automatically loaded, this is left to subclasses to implement.
    
    Specified by:
    
    load in interface LXSerializable
    
    Overrides:
    
    load in class LXComponent
    
    Parameters:
    
    lx - LX instance
    
    obj - Object to deserialize

Class LXFixture

Nested Class Summary

Nested classes/interfaces inherited from class heronarts.lx.LXComponent

Nested classes/interfaces inherited from interface heronarts.lx.LXSerializable

Field Summary

Fields inherited from class heronarts.lx.LXComponent

Constructor Summary

Method Summary

Methods inherited from class heronarts.lx.LXComponent

Methods inherited from class java.lang.Object

Methods inherited from interface heronarts.lx.LXPath

Field Detail

selected

identify

x

y

z

yaw

pitch

roll

enabled

brightness

mute

solo

children

outputs

points

NO_SUBMODELS

Constructor Detail

LXFixture

LXFixture

Method Detail

addParameter

getPath

getIndex

getFirstPointIndex

setStructure

addChild

removeChild

fixtureGenerationChanged

fixtureGeometryChanged

addMetricsParameter

addGeometryParameter

addOutputParameter

onParameterChanged

toDynamicIndexBuffer

toDynamicIndexBuffer

toDynamicIndexBuffer

toDynamicIndexBuffer

buildOutputs

reindexOutputs

addOutput

removeOutput

regenerate

beforeRegenerate

computeGeometryMatrix

computePointGeometry

constructModel

constructPoint

copyPoint

getMetaData

getModelKey

getModelKeys

toSubmodels

size

getIndexBufferOffset

getGeometryMatrix

getGeometryMatrix

totalSize

dispose

load