PhBAppearance {exposedField SFNodesurface NULLexposedField SFNodemedium NULLexposedField SFNodebumpMap NULLexposedField SFNodedisplacementMap NULLexposedField SFNodetextureProjection NULLexposedField SFNodetextureTransform NULLexposedField SFNodetextureTransform3D NULL}

Physics based appearance description. A replacement for the VRML'97 Appearance node. The new node may appear everywhere and only there where an Appearance node can appear in a VRML scene graph.

The **surface** child node describes surface scattering. It should be
a physically based surface node.
If not specified, a neutral diffuse reflecting surface appearance with
reflectance 0.8 will be used.

The **medium** child node describes volume scattering properties in the interior of a object. It should be a
physically based medium node.
If not specified, the inside medium will be the same as the medium outside
the object. No volume scattering properties should be specified for
non-closed objects. Specifying volume scattering properties for an object
that is not geometrically closed will lead to undefined rendering results.

The **bumpMap** child node describes local distortions to the object
normal. It should be a geometry distortion node.
If not specified, no bump mapping will be applied.
**To be described in more detail.**

The **displacementMap** child node describes local distortions to the
object geometry. It should be a
geometry distortion node.
If not specified, no displacement mapping will be applied.
**To be described in more detail.**

The **textureProjection** child node describes a mapping from local
object coordinates to texture coordinates. It should be a
texture projection node.
If not specified, the default texture projection transform for the object
will be used. The default texture projection transform is the one described
with each geometry node
in the VRML node reference.

The **textureTransform** child node describes a transformation
to be applied to 2D texture coordinates.
If specified, it shall be a
TextureTransform node. If not specified, this field has no effect.

The **textureTransform3D** child node describes a transformation
to be applied to local coordinates before used in 3D texturing.
If specified, it shall be a
PhB3DTextureTransform node.
If not specified, this field has no effect.

PhBHomogeneousSurface {exposedField MFNodeedf [ ]exposedField MFNodebsdf [ ]}

Describes the spontaneous light emission and scattering properties of a object. The optical properties are assumed constant over the object surface. In order to specify optical properties that vary over the object surface, a PhBTexturedSurface node should be used.

If specified, **edf** shall contain one or more
PhBEDF nodes expressing spontaneously
emitted radiation from the surface. The total emittance distribution
function (EDF) of the surface shall be the sum of the listed components.
If not specified, or if the list
is empty, the surface is assumed not to be a light source.

Similarly, **bsdf** shall contain a list of
PhBSDF nodes expressing surface light scattering.
If not specified, the surface is assumed to absorb all incident
radiation.

PhBEDF {exposedField SFFloatintensity 1.# (-infty,infty) exposedField SFNodespectrum NULLexposedField SFNodeemitter NULL}

This node expresses a primitive surface Emittance Distribution Function (EDF), describing the spectral and directional distribution of selfemitted radiation from a light source.

The spectral dependence is expressed by **spectrum**. If
specified, **spectrum** shall be a
spectrum node.
If not specified, a neutral spectrum of unit luminance is assumed.

The directional distribution of selfemitted light is expressed by
**emitter**, which shall be a
emitter node. If not
specified, a diffuse light source is assumed.

PhBProceduralEmitter {eventIn SFVec3fdirection# [-1,1] eventIn SFVec2fsampleNum# [0,1] eventIn SFInt32glossinessRange# [0,7] field MFStringurl[ ] eventOut SFFloatvalue# [0,infty) eventOut SFFloatsampleDir# [-1,1] eventOut SFFloatemittance# [0,infty)}

This node expresses the directional distribution of self-emitted radiance as a set of three procedures in a script: a procedure for evaluating the directional distribution, one for computing a sample direction according to the directional distribution and a last one returning integral of the directional distribution over the full hemisphere.

The field **url** contains a list of URLs with the implementation.
**url** will be handled identical as for the
Script node.

A first procedure will evaluate the directional distribution for
a given **direction** and return the result as **value**.
When multiplied with the corresponding spectrum and intensity in the
parent PhBEDF node, the
spectral self-emitted radiance [W/m^2sr/m] into the given direction
is obtained.

A second procedure computes a direction **sampleDir** as
a function of a set of two numbers **sampleNum** in the range
[0,1]. This procedure will be used to generate sample directions
whose distribution should be close to the directional distribution
of the self-emitted light times the cosine of the angle w.r.t the surface
normal. **value** shall contain the value of the distribution for
the generated direction. In addition, the sampling probability density
of the direction is returned in **pdf**.
Example: when the direction is generated according to a uniform
distribution, the probability density is 1/(2*PI).

The third procedure returns in **emittance** the integral over
the full hemisphere of the directional distribution times
cosine w.r.t. the surface normal. When multiplied
with the corresponding spectrum and intensity in the
PhBEDF parent node, this integral yields
the self-emitted spectral radiant exitance [W/m^2/m] of the light source.
Multiplying this with the light source surface area yields the spectral
power [W/m] of the light source.

Directions are specified as 3D vectors in a coordinate system with Z-axis equal to the object surface normal. The X axis is the axis in which the first texture coordinate varies most at the point under consideration.

**glossinessRange** is the combination of three flags: 1 (diffuse),
2 (glossy) and 4 (specular). These flags correspond to a glossiness range for
which results are to be returned. The diffuse range corresponds to the
directionally constant part of self-emitted light. The glossy range and
specular range divide the directionally-dependent part of self-emitted light.
The distinction should be such that it is feasible to explicitly compute
and store the glossy part in a world-space global illumination algorithm
while the specular part is considered to be of too high frequency to
explicitly store in computer memory. The distinction serves as a hint for
multi-pass global illumination algorithms.

PhBDiffuseEmitter {exposedField SFFloatnormalisation 1.# [0,infty)}

This node expresses a directionally constant self-emitted light
distribution
normalised such that the integral of the distribution
times the cosine w.r.t. the surface normal equals **normalisation**.

PhBPhongEmitter {exposedField SFFloatsharpness 0.# [0,infty) exposedField SFFloatnormalisation 1.# [0,infty)}

This node expresses a Phong-like directional distribution for
self-emitted light. **sharpness** expresses the specular power
of the Phong distribution.
The distribution is normalised such that the integral of the distribution
times the cosine w.r.t. the surface normal equals **normalisation**.

PhBSampledIsotropicEmitter {exposedField MFFloatsamples [ ]# [0,infty) exposedField SFFloatminAngle 0.# [0,pi] exposedField SFFloatmaxAngle 3.141592# [0,pi] exposedField SFFloatnormalisation 1.# [0,infty)}

This node expresses the directional dependence of a isotropic light source
by a profile curve of the intensity as a function of angle w.r.t. the
surface normal. The curve is specified as a list of equidistant
**samples** in the range **minAngle** to **maxAngle** inclusive.
Linear interpolation is used between the samples. The first sample
value is used for angles smaller than **minAngle**. The last sample value
is used for angles larger than **maxAngle**.

The distribution is normalised such that the integral of the distribution
times the cosine w.r.t. the surface normal equals **normalisation**.

PhBTextureEmitter {exposedField SFNodetexture NULLexposedField SFInt32channel 1# [1,infty) exposedField SFFloatnormalisation 1.# [0,infty)}

The directional distribution of emitted light is expressed as a channel in a texture map. The first texture coordinate is proportional to the angle between the XY-projected direction and the X-axis of the local object point coordinate system. The second texture coordinate is proportional to the angle of the direction w.r.t. the surface normal (Z-axis).

If specified, **texture** shall be a
texture node. **channel**
denotes the texture image channel to be used. If **texture** is not
specified, a non-emitting surface results.

The distribution is normalised such that the integral of the distribution
times the cosine w.r.t. the surface normal equals **normalisation**.

PhBSDF {exposedField SFFloatintensity 1.# (-infty,infty) exposedField SFNodespectrum NULLexposedField SFNodescatterer NULL}

This node expresses a Bidirectional Scattering Distribution Function
(BSDF) describing the spectral and directional characteristics
of surface light scattering. The semantics are the same as for the
PhBEDF node except that **scatterer** shall
contain a list of scatterer
nodes.

PhBProceduralScatterer {eventIn SFVec3finDir# [-1,1] eventIn SFVec3foutDir# [-1,1] eventIn SFVec2fsampleNum# [0,1] eventIn SFInt32glossinessRange# [0,7] field MFStringurl[ ] eventOut SFFloatvalue# [0,infty) eventOut SFFloatsampleDir# [-1,1] eventOut SFFloatreflectance# [0,infty) eventOut SFFloattransmittance# [0,infty)}

This node expresses the light scattering intensity as a function of incoming and outgoing directions using four procedures implemented in a script, much like the PhBProceduralEmitter node.

The field **url** contains a list of URLs with the implementation.
**url** will be handled identical as for the
Script node.

A first procedure will evaluate the directional scattering distribution
for given incoming and outgoing directions **inDir** and
**outDir**. The result is returned in **value**. When
multiplied with the corresponding spectrum and intensity in the
parent PhBSDF node, the value of the
Bidirectional Scattering Distribution Function (BSDF) for the given
incoming and outgoing direction is obtained.

A second procedure will sample a outgoing direction **sampleDir**
for given incoming direction **inDir**,
using the sample number pair **sampleNum**. The sample direction
distribution should be close to the directional distribution times the cosine
w.r.t. the surface normal. In **value**, the value of the directional
distribution for given incoming and generated outgoing direction is returned.
In addition, **pdf** shall contain the probability density of the sampled
direction.

A third and fourth procedure compute the integral over the
hemisphere of reflected and refracted directions of the directional
scattering distribution times cosine w.r.t. the surface normal for the
given incoming direction **inDir**. Multiplication with the
corresponding spectrum and intensity in the
parent PhBSDF node yields the BSDF
reflectance and transmittance for the incoming direction.

The meaning and function of the **glossinessRange**
eventIn, as well as the specification of directions, is the same as
described for the PhBProceduralEmitter
node.

PhBDiffuseReflector {exposedField SFFloatnormalisation 1.# [0,infty)}

This node expresses a directionally constant reflected light
distribution.
The distribution is normalised such that the integral
of the distribution
times the cosine w.r.t. the surface normal equals **normalisation**.

PhBPerfectSpecularReflector {exposedField SFFloatnormalisation 1.# [0,infty)}

This node expresses a perfect specular reflector: all incident light is
reflected into the ideal reflection direction.
The distribution is normalised such that the integral
of the distribution
times the cosine w.r.t. the surface normal equals **normalisation**.

PhBPhongReflector {exposedField SFFloatsharpness 0.# [0,infty) exposedField SFFloatnormalisation 1.# [0,infty)}

This node expresses a Phong-like directional distribution for
reflected light. **sharpness** expresses the specular power
of the Phong distribution.

The distribution is normalised such that
the integral of the distribution
times the cosine w.r.t. the surface normal apprimxately
equals **normalisation**.times cosine of incoming direction w.r.t.
surface normal.

PhBDiffuseRefractor {exposedField SFFloatnormalisation 1.# [0,infty)}

This node expresses a directionally constant refracted light
distribution. The distribution is normalised such that the integral
of the distribution
times the cosine w.r.t. the surface normal equals **normalisation**.

PhBPerfectSpecularRefractor {exposedField SFFloatnormalisation 1.# [0,infty)}

This node expresses a perfect specular refractor: all incident light is
reflected into the ideal refraction direction.
The distribution is normalised such that the integral
of the distribution
times the cosine w.r.t. the surface normal equals **normalisation**.

**This distribution is not reciprocal and may be omitted in the future**.

PhBPhongRefractor {exposedField SFFloatsharpness 0.# [0,infty) exposedField SFFloatnormalisation 1.# [0,infty)}

This node expresses a Phong-like directional distribution for
refracted light. **sharpness** expresses the specular power
of the Phong distribution.

The distribution is normalised such that
the integral of the distribution
times the cosine w.r.t. the surface normal equals **normalisation**.

**This distribution is not reciprocal and may be omitted in the future**.

PhBTexturedSurface {exposedField SFNodetexture NULLexposedField MFNodesurfaces [ ]exposedField SFNodetextureTransform NULLexposedField SFNodetextureProjection NULL}

This node expresses optical surface properties that can vary as a function of position on the object surface. Position is expressed by 2D texture coordinates, obtained by applying a implicit or explicit texture projection transform on local object coordinates and possibly transformed by 2D texture transforms.

The resulting surface characteristics at a given point
are obtained by looking up the texture map values in the given
**texture** and using these values as weights in a linear
combination of the primitive surfaces in **surfaces**.

If specified, **texture** shall contain a
texture node.
If not specified, the texture is treated as a texture with 0 channels
(see below) and the first surface description in **surface** shall
be used.

**surface** shall contain a list of one or more
surface nodes.
The number of surfaces shall be equal to the number of texture channels,
or exceed it by one. In the latter case, the last surface weight at
a point is taken to be one minus the sum of the previous weights
at the point. Example: a one-channel texture to combine two surface
descriptions. If not specified, or if **surface** is an empty list,
a perfect absorbing non-self-emitting surface results.

If specified, **textureTransform** shall contain a
TextureTransform
node. If not specified, an identity texture transform is assumed.
Texture transforms can be specified at several levels in the scene
graph. They shall be maintained in a texture transform stack and
be combined in an identical manner as coordinate transform coordinates.

If specified, **textureProjection** shall contain a
texture projection
node that specifies a new texture projection which replaces
the one specified at a higher level. If not specified, this field has
no effect.

PhB3DTexturedSurface {exposedField SFNodetexture NULLexposedField MFNodesurfaces [ ]exposedField SFNodetextureTransform3D NULL}

This node expresses optical surface properties that can vary as a function of position on the object surface. Position is expressed by 3D texture coordinates, which are local object coordinates transformed by 3D texture transforms specified at this and/or higher levels.

The semantics of this node is identical to that of the
PhBTexturedSurface node
except that **texture** shall be a
3D texture node
instead of a 2D texture node. **textureTransform3D** shall
contain a
PhB3DTextureTransform node.
instead of a 2D TextureTransform.

PhBLayeredSurface {exposedField MFNodemedia [ ]exposedField MFNodesurfaces [ ]exposedField MFFloatthicknesses [ ]}

This node expresses a layered surface (ref: Hanrahan et al, SIGGRAPH'93),
such as lacquered wood, human skin and plant tissue. The surface consists of
a number of thin layers, specified by **media** and **thicknesses**
and separated by **surfaces**.

**media** shall contain a list of
medium nodes. **thicknesses**
shall be an array of floating point thicknesses, expressed in meters,
indicating the thickness of the corresponding layer. The number of
floating point values in **thicknesses** and the number of nodes
in **media** shall be equal. The first medium and thickness
apply to the most outside layer of the surface.

**surfaces** shall contain a list of
surface nodes. The number
of surface nodes shall be one more than the number of layers. The first
surface separates the first, out-most, layer from the outside medium
of the object. The last surface separates the last, innermost, layer from
the inside medium of the object as specified in the parent
PhBAppearance node.

If no **surfaces** are specified, a total absorbing, non-self-emitting
surface results. If the number of surfaces and media and thicknesses does not
match, excess elements are ignored. If only one surface remains, that
surface fully describes the surface optical characteristics of the object.

PhBInterpolatedSurface {exposedFieldSFFloat fraction 0.exposedFieldMFFloat key [ ]exposedFieldMFNode keySurfaces [ ]}

This node describes a surface that is interpolated from two key surfaces
from **keySurfaces**
corresponding to two subsequent key values in **key**
forming an interval containing **fraction**. The interpolation
has the same semantics as in
interpolator nodes.

**keySurfaces** shall contain a list of
surface nodes.

PhBHomogeneousMedium {exposedField SFVec2findexOfRefraction 1. 0.exposedField SFFloatscatteringCrossSection 0.# [0,infty) exposedField SFFloatabsorptionCrossSection 0.# [0,infty) exposedField MFNodephaseFunction [ ]exposedField SFNodeselfEmittedFluxDensity NULL}

This node describes a homogeneous isotropic
participating medium with given
complex index of refraction **indexOfRefraction** and
scattering and absorption cross sections [1/m] **scatteringCrossSection**
and **absorptionCrossSection**. Isotropic means that scattering
intensity does not depend on the incident direction but rather only
on the angle between incident and scattered direction, and that
self-emitted radiance is not directionally dependent. Inhomogeneous
participating media shall be described with the
PhBTexturedMedium node.
The current proposal does not include a means to express anisotropic
media.

If specified, **phaseFunction** shall be a list of one or more
PhBPhF
nodes.
If not specified, an isotropic phase function with neutral colour and
unit intensity is assumed.

If specified, **selfEmittedFluxDensity** shall contain a
spectrum node expressing
the self-emitted spectral radiant flux density [W/m^3/m]. Emission is
always assumed to be isotropic. If not specified, the medium shall
not spontaneously emit light. An example of an emissive gas
is fire.

**indexOfRefraction**, **scatteringCrossSection**,
**absorptionCrossSection** are assumed to be independent of
wavelength.

PhBPhF {exposedField SFFloatintensity 1.# (-infty,infty) exposedField SFNodespectrum NULLexposedField SFNodephaseFunction NULL}

This node expresses the spectral and directional characteristics of
light scattering in a isotropic medium. The semantics are the same
as of the PhBEDF node, except that
**phaseFunction** shall contain a list of
phase function
nodes.

PhBIsotropicPhaseFunction {exposedField SFFloatnormalisation 1.# [0,infty)}

This node describes a isotropic light scattering distribution
in a participating medium. The distribution is normalised such that
its integral over the full sphere of outgoing directions will equal
**normalisation**.

PhBProceduralPhaseFunction {eventIn SFFloatalphaeventIn SFFloatsampleNumfield MFStringurl [ ]eventOut SFFloatvalueeventOut SFFloatsampleAlphaeventOut SFFloatnormalisation}

This node expresses a phase function implemented by three procedures in a script.

**url** shall contain a list of URL's where the implementation can be
found. This field is handled identical as in the
Script node.

A first procedure evaluates the phase function for a given
angle between incident and scattered direction. The angle is specified
by its cosine **alpha**. The result shall be multiplied
with the corresponding spectral basis function and weight
specified in the parent PhBMedium node in order to
obtain the full spectral scattering intensity.

A second procedure generates a sample scattering angle using one
sample number **sampleNum** in the range [0,1]. The resulting
angle is returned by means of its cosine **sampleAlpha**. In addition,
the value of the phase function for the generated angle
and the probability density are returned in **value** and **pdf**.

A third procedure returns the integral of the phase function over
the full sphere of directions in **normalisation**.

PhBTexturedMedium {exposedField SFNodetexture NULLexposedField MFNodemedia [ ]exposedField SFNodetextureTransform3D NULL}

This node describes a inhomogeneous
isotropic participating medium. The semantics
are identical to that of the
PhB3DTexturedSurface node except
that **media** shall be a list of
medium nodes to be
mixed instead of surface nodes.

PhBInterpolatedMedium {exposedFieldSFFloat fraction 0.exposedFieldMFFloat key [ ]exposedFieldMFNode keyMedia [ ]}

This node describes a medium that is interpolated from two key media
from **keyMedia**
corresponding to two subsequent key values in **key**
forming an interval containing **fraction**. The interpolation
has the same semantics as in
interpolator nodes.

**keyMedia** shall contain a list of
medium nodes.

PhBSurfaceDistortion {exposedField SFNodetexture NULLexposedField SFNodetransform NULL}

This node describes a geometry distortion expressed by a 2D texture map, used to map 2D texture coordinates into 3D geometry distortion vectors.

**texture** shall contain a
texture node with at least
three channels. The texture values are rescaled into the range
[-1,1]. The channels correspond respectively to the X, Y and Z component
of the geometry distortion vector.

If specified, **transform** shall contain a
PhB3DTextureTransform node.
This optional transform will be applied to the geometry distortion
vectors obtained as above. If not specified, this field has no effect.

PhBVolumeDistortion {exposedField SFNodetexture NULLexposedField SFNodetransform NULL}

This node describes a geometry distortion expressed by a
3D texture map, used to map 3D texture coordinates into 3D geometry
distortion vectors. Except that **texture** shall be a 3D texture
node, the semantics of this node are identical to that of the
PhBSurfaceDistortion node.

PhBProceduralTexture {eventIn SFVec2ftextureCoordinatefield MFStringurl [ ]eventOut MFFloattextureValues}

This node describes a 2D texture, implemented as a procedure
in a script that can be found by following the list **url** of URL's.
The procedure computes an array of floating point values **mapValues**
as a response on a 2D texture coordinate pair **textureCoordinate**.

PhBProcedural3DTexture {eventIn SFVec3ftextureCoordinatefield MFStringurl [ ]eventOut MFFloattextureValues}

This node describes a 3D texture. It is identical to the PhBProceduralTexture node except that the input consists of a 3D instead of a 2D texture coordinate.

PhBProceduralTextureProjection {eventIn SFVec3fcoordinatefield MFStringurl [ ]eventOut SFVec2ftextureCoordinate}

This node describes a texture projection transform implemented as a
procedure in a script that can be found by following the given list
**url** of URL's. The procedure computes a 2D texture coordinate
**textureCoordinate** from a 3D local object coordinate **coordinate**.
It can be used to define other texture projections than the defaults
provided in the VRML'97 specifications.

PhB3DTextureTransform {exposedField SFVec3fcenter 0 0 0# (-infty,infty) exposedField SFRotationrotation 0 0 1 0# [-1,1],(-infty,infty) exposedField SFVec3fscale 1 1 1# (0,infty) exposedField SFRotationscaleOrientation 0 0 1 0# [-1,1],(-infty,infty exposedField SFVec3ftranslation 0 0 0# (0,infty)}

This node describes a 3D transform to be applied to 3D texture coordinates. The semantics are the same as that of the Transform node, except that this node has no children nodes or bounding box. It is the 3D equivalent of the TextureTransform node.

PhBTexturedBackground {exposedField SFNodetexture NULLexposedField MFNodespectralBasis [ ]exposedField MFFloatspectralWeights [ ]exposedField SFFloatminAngle 0exposedField SFFloatmaxAngle 1.570}

Bindable node similar to Background describing background radiation as a function of direction. Examples: sky illumination, environment radiance maps (for putting virtual objects in real environments). Background radiance is assumed to originate at a very large distance and is already includes atmospheric effects, meaning that background radiation is not modified by the PhBAtmosphere node.

**texture** shall contain a
texture node. The first
texture coordinate is proportional to the angle of the direction w.r.t.
the global Y-axis. The second texture coordinate is proportional with
the angle between the direction, projected onto the global XZ plane,
and the global Z axis. **minAngle** and **maxAngle**, both
angles w.r.t. the global Y axis describe
the region of the sphere covered by the texture map. The remaining
region of the sphere, not covered by the texture map, is assumed not
to radiate any light towards the scene.

**spectralBasis** shall contain a list of
spectrum nodes. The number
of basis spectra shall be equal to the number of channels in the texture
map.

If specified, **spectralWeights** shall contain a list of
floating point weights to be associated with each basis spectrum
and texture channel. If not specified, or if the number of weights is
less than the number of spectra and texture channels, missing weights
are assumed to be 1.

The background spectral radiance [W/m^2sr/m] received from a given global direction shall be obtained as a linear combination of the basis spectra weighted by the texture map values and spectral weights.

By default, no background radiation is assumed in a scene.

PhBproceduralBackground {field MFStringurl [ ]}

Procedural background radiation description.

PhBAtmosphere {exposedField SFNodemedium NULL}

Bindable node similar to Fog used to express the medium outside the objects in the scene. Examples: mist, fog, ...

If specified, **medium** should be a
medium node. If not
specified, vacuum is assumed.

By default, a vacuum atmosphere is assumed in a scene.

PhBLxySpectrum {exposedField SFVec2fxy 0.3333333 0.3333333# [0,1] exposedField SFFloatluminance 1.# [0,infty)}

Spectrum given as CIE xy chromaticity and luminance.

PhBXYZSpectrum {exposedField SFVec3fxyz 1. 1. 1.# [0,infty)}

Spectrum given as CIE XYZ triplet.

PhBMonochromaticSpectrum {exposedField SFFloatwavelength 550.# [0,infty) exposedField SFFloatluminance 1.# [0,infty)}

Monochromatic spectrum. Example: the typical yellow light emitted by Sodium (Na) street lanterns.

PhBBlackBodySpectrum {exposedField SFFloattemperature 0.# [0,infty) exposedField SFFloatluminance 1.# [0,infty)}

Black body spectrum at given **temperature** (in degrees Kelvin) and
**luminance**. Examples: the sun, incandescent light bulbs.

PhBSampledSpectrum {exposedField MFFloatsamples [ ]exposedField SFFloatscale 1.# [0,infty) exposedField SFFloatmin 380.# [380.,770] exposedField SFFloatmax 770.# [380.,770]}

Spectrum given as an array of equidistant spectral samples between
wavelengths **min** and **max** inclusive. The sample values shall be
multiplied by the factor **scale**.

PhBTabulatedSpectrum {exposedField MFFloatwavelengths [ ]# [380.,770.] exposedField MFFloatvalues [ ]# [0,infty) exposedField SFFloatscale 1.# [0,infty)}

Spectrum given as a table of **wavelengths** and corresponding spectral
**values**. The number of given wavelengths and values shall be equal.
The values will be scaled by the optional **scale** factor.

Spectrum given in procedural form.PhBProceduralSpectrum {eventIn SFFloatwavelength# [380.,770.] field MFStringurl [ ]eventOut SFFloatspectralValue# [0,infty)}

PhBMixedSpectrum {exposedField MFNodespectra [ ]exposedField MFFloatweight [ ]}

Linear combination of primitive spectra with given weights.

The nodes in the **spectra** node list shall be
spectrum nodes.
The number of weights shall match the number of specified spectra.
If **spectra** is not specified or is a empty list, a perfect
black spectrum results.

PhBInterpolatedSpectrum {exposedFieldSFFloat fraction 0.exposedFieldMFFloat key [ ]exposedFieldMFNode keySpectra [ ]}

This node describes a spectrum that is interpolated from two key spectra
from **keySpectra**
corresponding to two subsequent key values in **key**
forming an interval containing **fraction**. The interpolation
has the same semantics as in
interpolator nodes.

**keySpectra** shall contain a list of
spectrum nodes.

This page is maintained by Philippe Bekaert