## javax.media.j3d
Class Light

    java.lang.Object
      javax.media.j3d.SceneGraphObject
          javax.media.j3d.Node
              javax.media.j3d.Leaf
                  javax.media.j3d.Light

Direct Known Subclasses:
  AmbientLight, DirectionalLight, PointLight

    public abstract class Light

extends Leaf

The Light leaf node is an abstract class that defines a set of parameters common to all types of light. These parameters include the light color, an enable flag, and a region of influence in which this Light node is active. A Light node also contains a list of Group nodes that specifies the hierarchical scope of this Light. If the scope list is empty, the Light node has universe scope: all nodes within the region of influence are affected by this Light node. If the scope list is non-empty, only those Leaf nodes under the Group nodes in the scope list are affected by this Light node (subject to the influencing bounds).

The light in a scene may come from several light sources that can be individually defined. Some of the light in a scene may come from a specific direction, known as a directional light, from a specific position, known as a point light, or from no particular direction or source as with ambient light.

Java 3D supports an arbitrary number of lights. However, the number of lights that can be active within the region of influence is implementation-dependent and cannot be defined here.

Light Color

The Java 3D lighting model approximates the way light works in the real world. Light is defined in terms of the red, green, and blue components that combine to create the light color. The three color components represent the amount of light emitted by the source.

Each of the three colors is represented by a floating point value that ranges from 0.0 to 1.0. A combination of the three colors such as (1.0, 1.0, 1.0), representing the red, green, and blue color values respectively, creates a white light with maximum brightness. A combination such as (0.0, 0.0, 0.0) creates no light (black). Values between the minimum and maximum values of the range produce corresponding brightness and colors. For example, a combination of (0.5, 0.5, 0.5) produces a 50% grey light. A combination of (1.0, 1.0, 0.0), red and green but no blue, produces a yellow light.

If a scene has multiple lights and all lights illuminate an object, the effect of the light on the object is the sum of the lights. For example, in a scene with two lights, if the first light emits (R1, G1, B1) and the second light emits (R2, G2, B2), the components are added together giving (R1+R2, G1+G2, B1+B2). If the sums of any of the color values is greater than 1.0, brighter than the maximum brightness permitted, the color value is clamped to 1.0.

Material Colors

In the Java 3D lighting model, the light sources have an effect on the scene only when there are object surfaces to absorb or reflect the light. Java 3D approximates an object's color by calculating the percentage of red, green, and blue light the object reflects. An object with a surface color of pure green absorbs all of the red and blue light that strikes it and reflects all of the green light. Viewing the object in a white light, the green color is reflected and you see a green object. However, if the green object is viewed in a red light, all of the red light is absorbed and the object appears black.

The surface of each object in the scene has certain material properties that define how light affects its appearance. The object might reflect light in various ways, depending on the object's surface type. The object might even emit its own light. The Java 3D lighting model specifies these material properties as five independent components: emitted color, ambient color, diffuse color, specular color, and shininess. All of these properties are computed independently, then added together to define how the surface of the object appears under light (an exception is Ambient light, which does not contribute to specular reflection). The material properties are defined in the Material class.

Influencing Bounds

Since a scene may be quite large, as large as the universe for example, it is often reasonable to limit the influence of lighting to a region that is within viewing range. There is no reason to waste all that computing power on illuminating objects that are too far away to be viewed. In Java 3D, the influencing bounds is defined by a Bounds object or a BoundingLeaf object. It should be noted that a BoundingLeaf object overrides a Bounds object, should both objects be set.

A Bounds object represents a convex, closed volume. Bounds defines three different types of containing volumes: an axis-aligned-box volume, a spherical volume, and a bounding polytope. A BoundingLeaf object also specifies a region of influence, but allows an application to specify a bounding region in one coordinate system (the local coordinate system of the BoundingLeaf node) other than the local coordinate system of the node that references the bounds (the Light).

Limiting the Scope

In addition to limiting the lighting calculations to a given region of a scene, lighting can also be limited to groups of nodes, defined by a Group object. This is known as "scoping." All nodes attached to a Group node define a list of scopes. Methods in the Light class permit the setting, addition, insertion, removal, and enumeration of nodes in the list of scopes.

Two-sided Lighting of Polygons

Java 3D performs lighting calculations for all polygons, whether they are front-facing or back-facing. Since most polygon objects are constructed with the front face in mind, the back-facing portion may not be correctly illuminated. For example, a sphere with part of the face cut away so you can see its inside. You might want to have the inside surface lit as well as the outside surface and you mught also want to define a different Material description to reduce shininess, specular color, etc.

For more information, see the "Face culling" and "Back-facing normal flip" descriptions in the PolygonAttributes class description.

Turning on the Lights

Lighting needs to be explicitly enabled with the setEnable method or with the lightOn parameter in the constructor before any of the child light sources have any effect on illuminating the scene. The child lights may also be enabled or disabled individually.

If lighting is not enabled, the current color of an object in the scene is simply mapped onto the object, and none of the lighting equations regarding Material properties, such as ambient color, diffuse color, specular color, and shininess, are performed. However, an object's emitted color, if specified and enabled, will still affect that object's appearance.

To disable lighting, call setEnable with `false` as the argument.

See Also:
  `Material`, `Bounds`, `BoundingLeaf`, `Group`, `PolygonAttributes`

Field Summary
`static int` `ALLOW_COLOR_READ` Specifies that this Light allows read access to its color information at runtime.
`static int` `ALLOW_COLOR_WRITE` Specifies that this Light allows write access to its color information at runtime.
`static int` `ALLOW_INFLUENCING_BOUNDS_READ` Specifies that this Light allows read access to its influencing bounds and bounds leaf information.
`static int` `ALLOW_INFLUENCING_BOUNDS_WRITE` Specifies that this Light allows write access to its influencing bounds and bounds leaf information.
`static int` `ALLOW_SCOPE_READ` Specifies that this Light allows read access to its scope information at runtime.
`static int` `ALLOW_SCOPE_WRITE` Specifies that this Light allows write access to its scope information at runtime.
`static int` `ALLOW_STATE_READ` Specifies that this Light allows read access to its current state information at runtime.
`static int` `ALLOW_STATE_WRITE` Specifies that this Light allows write access to its current state information at runtime.

Fields inherited from class javax.media.j3d.Node
`ALLOW_AUTO_COMPUTE_BOUNDS_READ, ALLOW_AUTO_COMPUTE_BOUNDS_WRITE, ALLOW_BOUNDS_READ, ALLOW_BOUNDS_WRITE, ALLOW_COLLIDABLE_READ, ALLOW_COLLIDABLE_WRITE, ALLOW_LOCAL_TO_VWORLD_READ, ALLOW_LOCALE_READ, ALLOW_PARENT_READ, ALLOW_PICKABLE_READ, ALLOW_PICKABLE_WRITE, ENABLE_COLLISION_REPORTING, ENABLE_PICK_REPORTING`

Constructor Summary
`Light()` Constructs a Light node with default parameters.
`Light(boolean lightOn, Color3f color)` Constructs and initializes a Light node using the specified enable flag and color.
`Light(Color3f color)` Constructs and initializes a Light node using the specified color.

Method Summary
`void` `addScope(Group scope)` Appends the specified Group node to this Light node's list of scopes.
`java.util.Enumeration` `getAllScopes()` Returns an enumeration of this Light node's list of scopes.
`void` `getColor(Color3f color)` Gets this Light's current color and places it in the parameter specified.
`boolean` `getEnable()` Retrieves this Light's current state (on/off).
`BoundingLeaf` `getInfluencingBoundingLeaf()` Retrieves the Light node's influencing bounding leaf.
`Bounds` `getInfluencingBounds()` Retrieves the Light node's influencing bounds.
`Group` `getScope(int index)` Retrieves the Group node at the specified index from this Light node's list of scopes.
`int` `indexOfScope(Group scope)` Retrieves the index of the specified Group node in this Light node's list of scopes.
`void` `insertScope(Group scope, int index)` Inserts the specified Group node into this Light node's list of scopes at the specified index.
`int` `numScopes()` Returns the number of nodes in this Light node's list of scopes.
`void` `removeAllScopes()` Removes all Group nodes from this Light node's list of scopes.
`void` `removeScope(Group scope)` Removes the specified Group node from this Light node's list of scopes.
`void` `removeScope(int index)` Removes the node at the specified index from this Light node's list of scopes.
`void` `setColor(Color3f color)` Sets the Light's current color.
`void` `setEnable(boolean state)` Turns the light on or off.
`void` `setInfluencingBoundingLeaf(BoundingLeaf region)` Sets the Light's influencing region to the specified bounding leaf.
`void` `setInfluencingBounds(Bounds region)` Sets the Light's influencing region to the specified bounds.
`void` `setScope(Group scope, int index)` Replaces the node at the specified index in this Light node's list of scopes with the specified Group node.
`void` `updateNodeReferences(NodeReferenceTable referenceTable)` Callback used to allow a node to check if any scene graph objects referenced by that node have been duplicated via a call to `cloneTree`.

Methods inherited from class javax.media.j3d.Node
`cloneNode, cloneTree, cloneTree, cloneTree, cloneTree, cloneTree, cloneTree, duplicateNode, getBounds, getBoundsAutoCompute, getCollidable, getLocale, getLocalToVworld, getLocalToVworld, getParent, getPickable, setBounds, setBoundsAutoCompute, setCollidable, setPickable`

Methods inherited from class javax.media.j3d.SceneGraphObject
`clearCapability, clearCapabilityIsFrequent, duplicateSceneGraphObject, getCapability, getCapabilityIsFrequent, getName, getUserData, isCompiled, isLive, setCapability, setCapabilityIsFrequent, setName, setUserData, toString`

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

Field Detail

### ALLOW_STATE_READ

    public static final int ALLOW_STATE_READ

  Specifies that this Light allows read access to its current state information at runtime.

  See Also:
    Constant Field Values

### ALLOW_STATE_WRITE

    public static final int ALLOW_STATE_WRITE

  Specifies that this Light allows write access to its current state information at runtime.

  See Also:
    Constant Field Values

### ALLOW_COLOR_READ

    public static final int ALLOW_COLOR_READ

  Specifies that this Light allows read access to its color information at runtime.

  See Also:
    Constant Field Values

### ALLOW_COLOR_WRITE

    public static final int ALLOW_COLOR_WRITE

  Specifies that this Light allows write access to its color information at runtime.

  See Also:
    Constant Field Values

### ALLOW_INFLUENCING_BOUNDS_READ

    public static final int ALLOW_INFLUENCING_BOUNDS_READ

  Specifies that this Light allows read access to its influencing bounds and bounds leaf information.

  See Also:
    Constant Field Values

### ALLOW_INFLUENCING_BOUNDS_WRITE

    public static final int ALLOW_INFLUENCING_BOUNDS_WRITE

  Specifies that this Light allows write access to its influencing bounds and bounds leaf information.

  See Also:
    Constant Field Values

### ALLOW_SCOPE_READ

    public static final int ALLOW_SCOPE_READ

  Specifies that this Light allows read access to its scope information at runtime.

  See Also:
    Constant Field Values

### ALLOW_SCOPE_WRITE

    public static final int ALLOW_SCOPE_WRITE

  Specifies that this Light allows write access to its scope information at runtime.

  See Also:
    Constant Field Values

Constructor Detail

### Light

    public Light()

  Constructs a Light node with default parameters. The default values are as follows:
  enable flag : true
  color : white (1,1,1)
  scope : empty (universe scope)
  influencing bounds : null
  influencing bounding leaf : null

### Light

    public Light(Color3f color)

  Constructs and initializes a Light node using the specified color.

  Parameters:
    `color` - the color of the light source

### Light

    public Light(boolean lightOn,
                 Color3f color)

  Constructs and initializes a Light node using the specified enable flag and color.

  Parameters:
    `lightOn` - flag indicating whether this light is on or off
    `color` - the color of the light source

Method Detail

### setEnable

    public void setEnable(boolean state)

  Turns the light on or off.

  Parameters:
    `state` - true or false to set light on or off
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### getEnable

    public boolean getEnable()

  Retrieves this Light's current state (on/off).

  Returns:
    this node's current state (on/off)
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### setColor

    public void setColor(Color3f color)

  Sets the Light's current color.

  Parameters:
    `color` - the value of this node's new color
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### getColor

    public void getColor(Color3f color)

  Gets this Light's current color and places it in the parameter specified.

  Parameters:
    `color` - the vector that will receive this node's color
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### setScope

    public void setScope(Group scope,
                         int index)

  Replaces the node at the specified index in this Light node's list of scopes with the specified Group node. By default, Light nodes are scoped only by their influencing bounds. This allows them to be further scoped by a list of nodes in the hierarchy.

  Parameters:
    `scope` - the Group node to be stored at the specified index.
    `index` - the index of the Group node to be replaced.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph
    `RestrictedAccessException` - if the specified group node is part of a compiled scene graph

### getScope

    public Group getScope(int index)

  Retrieves the Group node at the specified index from this Light node's list of scopes.

  Parameters:
    `index` - the index of the Group node to be returned.
  Returns:
    the Group node at the specified index.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### insertScope

    public void insertScope(Group scope,
                            int index)

  Inserts the specified Group node into this Light node's list of scopes at the specified index. By default, Light nodes are scoped only by their influencing bounds. This allows them to be further scoped by a list of nodes in the hierarchy.

  Parameters:
    `scope` - the Group node to be inserted at the specified index.
    `index` - the index at which the Group node is inserted.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph
    `RestrictedAccessException` - if the specified group node is part of a compiled scene graph

### removeScope

    public void removeScope(int index)

  Removes the node at the specified index from this Light node's list of scopes. If this operation causes the list of scopes to become empty, then this Light will have universe scope: all nodes within the region of influence will be affected by this Light node.

  Parameters:
    `index` - the index of the Group node to be removed.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph
    `RestrictedAccessException` - if the group node at the specified index is part of a compiled scene graph

### getAllScopes

    public java.util.Enumeration getAllScopes()

  Returns an enumeration of this Light node's list of scopes.

  Returns:
    an Enumeration object containing all nodes in this Light node's list of scopes.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### addScope

    public void addScope(Group scope)

  Appends the specified Group node to this Light node's list of scopes. By default, Light nodes are scoped only by their influencing bounds. This allows them to be further scoped by a list of nodes in the hierarchy.

  Parameters:
    `scope` - the Group node to be appended.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph
    `RestrictedAccessException` - if the specified group node is part of a compiled scene graph

### numScopes

    public int numScopes()

  Returns the number of nodes in this Light node's list of scopes. If this number is 0, then the list of scopes is empty and this Light node has universe scope: all nodes within the region of influence are affected by this Light node.

  Returns:
    the number of nodes in this Light node's list of scopes.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### indexOfScope

    public int indexOfScope(Group scope)

  Retrieves the index of the specified Group node in this Light node's list of scopes.

  Parameters:
    `scope` - the Group node to be looked up.
  Returns:
    the index of the specified Group node; returns -1 if the object is not in the list.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph
  Since:
    Java 3D 1.3

### removeScope

    public void removeScope(Group scope)

  Removes the specified Group node from this Light node's list of scopes. If the specified object is not in the list, the list is not modified. If this operation causes the list of scopes to become empty, then this Light will have universe scope: all nodes within the region of influence will be affected by this Light node.

  Parameters:
    `scope` - the Group node to be removed.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph
    `RestrictedAccessException` - if the specified group node is part of a compiled scene graph
  Since:
    Java 3D 1.3

### removeAllScopes

    public void removeAllScopes()

  Removes all Group nodes from this Light node's list of scopes. The Light node will then have universe scope: all nodes within the region of influence will be affected by this Light node.

  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph
    `RestrictedAccessException` - if any group node in this node's list of scopes is part of a compiled scene graph
  Since:
    Java 3D 1.3

### setInfluencingBounds

    public void setInfluencingBounds(Bounds region)

  Sets the Light's influencing region to the specified bounds. This is used when the influencing bounding leaf is set to null.

  Parameters:
    `region` - the bounds that contains the Light's new influencing region.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### getInfluencingBounds

    public Bounds getInfluencingBounds()

  Retrieves the Light node's influencing bounds.

  Returns:
    this Light's influencing bounds information
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### setInfluencingBoundingLeaf

    public void setInfluencingBoundingLeaf(BoundingLeaf region)

  Sets the Light's influencing region to the specified bounding leaf. When set to a value other than null, this overrides the influencing bounds object.

  Parameters:
    `region` - the bounding leaf node used to specify the Light node's new influencing region.
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### getInfluencingBoundingLeaf

    public BoundingLeaf getInfluencingBoundingLeaf()

  Retrieves the Light node's influencing bounding leaf.

  Returns:
    this Light's influencing bounding leaf information
  Throws:
    `CapabilityNotSetException` - if appropriate capability is not set and this object is part of live or compiled scene graph

### updateNodeReferences

    public void updateNodeReferences(NodeReferenceTable referenceTable)

  Callback used to allow a node to check if any scene graph objects referenced by that node have been duplicated via a call to `cloneTree`. This method is called by `cloneTree` after all nodes in the sub-graph have been duplicated. The cloned Leaf node's method will be called and the Leaf node can then look up any object references by using the `getNewObjectReference` method found in the `NodeReferenceTable` object. If a match is found, a reference to the corresponding object in the newly cloned sub-graph is returned. If no corresponding reference is found, either a DanglingReferenceException is thrown or a reference to the original object is returned depending on the value of the `allowDanglingReferences` parameter passed in the `cloneTree` call.

  NOTE: Applications should not call this method directly. It should only be called by the cloneTree method.

  Overrides:
    `updateNodeReferences` in class `SceneGraphObject`
  Parameters:
    `referenceTable` - a NodeReferenceTableObject that contains the `getNewObjectReference` method needed to search for new object instances.
  See Also:
    `NodeReferenceTable`, `Node.cloneTree()`, `DanglingReferenceException`

Copyright 1996-2008 Sun Microsystems, Inc. All Rights Reserved. Use is subject to license terms.