Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## de.grogra.imp3d.shading
Class RGBAShader

    java.lang.Object
      javax.vecmath.Tuple4f
          javax.vecmath.Color4f
              de.grogra.imp3d.shading.RGBAShader

All Implemented Interfaces:
  Icon, IconSource, Manageable, Shareable, Scattering, Shader, java.io.Serializable, java.lang.Cloneable

    public final class RGBAShader

extends Color4f
implements Shader, Shareable, Manageable, IconSource, Icon

A `RGBAShader` implements a simple lambertian material with a single color and an alpha-value for the transparency. Some methods which are related to the color palette of the EGA graphics card are declared, they are used in the context of the emulation of the GROGRA software.

Author:
  Ole Kniemeyer
See Also:
  Serialized Form

Field Summary
`static ManageableType` | `$TYPE`
`static RGBAShader` | `BLACK` `RGBAShader` whose color is `Color.BLACK`.
`static RGBAShader` | `BLUE` `RGBAShader` whose color is `Color.BLUE`.
`static RGBAShader` | `CYAN` `RGBAShader` whose color is `Color.CYAN`.
`static RGBAShader` | `DARK_GRAY` `RGBAShader` whose color is `Color.DARK_GRAY`.
`static RGBAShader` | `EGA_0` `RGBAShader` whose color is EGA color number 0.
`static RGBAShader` | `EGA_1` `RGBAShader` whose color is EGA color number 1.
`static RGBAShader` | `EGA_10` `RGBAShader` whose color is EGA color number 10.
`static RGBAShader` | `EGA_11` `RGBAShader` whose color is EGA color number 11.
`static RGBAShader` | `EGA_12` `RGBAShader` whose color is EGA color number 12.
`static RGBAShader` | `EGA_13` `RGBAShader` whose color is EGA color number 13.
`static RGBAShader` | `EGA_14` `RGBAShader` whose color is EGA color number 14.
`static RGBAShader` | `EGA_15` `RGBAShader` whose color is EGA color number 15.
`static RGBAShader` | `EGA_2` `RGBAShader` whose color is EGA color number 2.
`static RGBAShader` | `EGA_3` `RGBAShader` whose color is EGA color number 3.
`static RGBAShader` | `EGA_4` `RGBAShader` whose color is EGA color number 4.
`static RGBAShader` | `EGA_5` `RGBAShader` whose color is EGA color number 5.
`static RGBAShader` | `EGA_6` `RGBAShader` whose color is EGA color number 6.
`static RGBAShader` | `EGA_7` `RGBAShader` whose color is EGA color number 7.
`static RGBAShader` | `EGA_8` `RGBAShader` whose color is EGA color number 8.
`static RGBAShader` | `EGA_9` `RGBAShader` whose color is EGA color number 9.
`static RGBAShader` | `GRAY` `RGBAShader` whose color is `Color.GRAY`.
`static RGBAShader` | `GREEN` `RGBAShader` whose color is `Color.GREEN`.
`static RGBAShader` | `LIGHT_GRAY` `RGBAShader` whose color is `Color.LIGHT_GRAY`.
`static RGBAShader` | `MAGENTA` `RGBAShader` whose color is `Color.MAGENTA`.
`static RGBAShader` | `ORANGE` `RGBAShader` whose color is `Color.ORANGE`.
`static RGBAShader` | `PINK` `RGBAShader` whose color is `Color.PINK`.
`static RGBAShader` | `RED` `RGBAShader` whose color is `Color.RED`.
`static RGBAShader` | `WHITE` `RGBAShader` whose color is `Color.WHITE`.
`static RGBAShader` | `YELLOW` `RGBAShader` whose color is `Color.YELLOW`.

Fields inherited from class javax.vecmath.Tuple4f
`w, x, y, z`

Fields inherited from interface de.grogra.ray.physics.Shader
`LAMBERTIAN_VARIANCE`

Fields inherited from interface de.grogra.ray.physics.Scattering
`DELTA_FACTOR, IS_NON_OPAQUE, MIN_UNUSED_FLAG, NEEDS_NORMAL, NEEDS_POINT, NEEDS_TANGENTS, NEEDS_TRANSFORMATION, NEEDS_UV, RANDOM_RAYS_GENERATE_ORIGINS`

Fields inherited from interface de.grogra.icon.Icon
`DEFAULT, DISABLED`

Constructor Summary
`RGBAShader()`
`RGBAShader(Color4f color)`
`RGBAShader(float red, float green, float blue)`
`RGBAShader(float red, float green, float blue, float alpha)`
`RGBAShader(int rgba)` Specify colors as ARGB integer.
`RGBAShader(Shader a)`

Method Summary
`void` | `accept(ShaderVisitor visitor)`
`void` | `addReference(SharedObjectReference ref)`
`void` | `appendReferencesTo(java.util.List out)`
`java.lang.Object` | `clone()`
`float` | `computeBSDF(Environment env, Vector3f in, Spectrum specIn, Vector3f out, boolean adjoint, Spectrum bsdf)` Evaluates bidirectional scattering distribution function for given input.
`void` | `computeMaxRays(Environment env, Vector3f in, Spectrum specIn, Ray reflected, Tuple3f refVariance, Ray transmitted, Tuple3f transVariance)` Computes, for the given input, the reflected and transmitted importance rays for which the reflection/transmission probability densities (integrated over the spectrum) attain a maximum.
`void` | `fieldModified(PersistenceField field, int[] indices, Transaction t)`
`static RGBAShader` | `forEGAColor(int index)` Returns the `RGBAShader` whose color has the specified index in the palette of the EGA graphics card.
`void` | `generateRandomRays(Environment env, Vector3f out, Spectrum specOut, RayList rays, boolean adjoint, java.util.Random rnd)` Pseudorandomly generates, for the given input, a set of scattered rays.
`int` | `getAverageColor()` Returns an average color for the scattering entity.
`static int` | `getEGAColorIndex(Color3f c)` Returns the index of the color in the palette of the EGA graphics card which is closest to the specified color.
`static int` | `getEGAColorIndex(Color4f c)` Returns the index of the color in the palette of the EGA graphics card which is closest to the specified color.
`static int` | `getEGAColorIndex(float r, float g, float b)` Returns the index of the color in the palette of the EGA graphics card which is closest to the specified color.
`int` | `getFlags()`
`Icon` | `getIcon(java.awt.Dimension size, int state)`
`java.awt.Rectangle` | `getIconBounds()`
`IconSource` | `getIconSource()`
`java.awt.Image` | `getImage()`
`java.awt.Image` | `getImage(int w, int h)`
`java.net.URL` | `getImageSource()`
`ManageableType` | `getManageableType()`
`java.awt.Dimension` | `getPreferredIconSize(boolean small)`
`SharedObjectProvider` | `getProvider()`
`int` | `getStamp()` Returns a stamp for this object.
`void` | `initProvider(SharedObjectProvider provider)`
`boolean` | `isMutable()`
`boolean` | `isPredefined()`
`boolean` | `isTransparent()`
`Manageable` | `manageableReadResolve()`
`java.lang.Object` | `manageableWriteReplace()`
`void` | `paintIcon(java.awt.Component c, java.awt.Graphics2D g, int x, int y, int w, int h, int state)`
`void` | `prepareIcon()`
`void` | `removeReference(SharedObjectReference ref)`
`void` | `scale(double r, Tuple3d color)`
`void` | `shade(Environment env, RayList in, Vector3f out, Spectrum specOut, Tuple3d color)` Computes color of outgoing light ray for given input.

Methods inherited from class javax.vecmath.Color4f
`get, set`

Methods inherited from class javax.vecmath.Tuple4f
`absolute, absolute, add, add, clamp, clamp, clampMax, clampMax, clampMin, clampMin, epsilonEquals, equals, equals, get, get, hashCode, interpolate, interpolate, negate, negate, scale, scale, scaleAdd, scaleAdd, set, set, set, set, sub, sub, toString`

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

Field Detail

### $TYPE

    public static final ManageableType $TYPE

### BLACK

    public static final RGBAShader BLACK

  `RGBAShader` whose color is `Color.BLACK`.

### BLUE

    public static final RGBAShader BLUE

  `RGBAShader` whose color is `Color.BLUE`.

### CYAN

    public static final RGBAShader CYAN

  `RGBAShader` whose color is `Color.CYAN`.

### DARK_GRAY

    public static final RGBAShader DARK_GRAY

  `RGBAShader` whose color is `Color.DARK_GRAY`.

### EGA_0

    public static final RGBAShader EGA_0

  `RGBAShader` whose color is EGA color number 0.

### EGA_1

    public static final RGBAShader EGA_1

  `RGBAShader` whose color is EGA color number 1.

### EGA_10

    public static final RGBAShader EGA_10

  `RGBAShader` whose color is EGA color number 10.

### EGA_11

    public static final RGBAShader EGA_11

  `RGBAShader` whose color is EGA color number 11.

### EGA_12

    public static final RGBAShader EGA_12

  `RGBAShader` whose color is EGA color number 12.

### EGA_13

    public static final RGBAShader EGA_13

  `RGBAShader` whose color is EGA color number 13.

### EGA_14

    public static final RGBAShader EGA_14

  `RGBAShader` whose color is EGA color number 14.

### EGA_15

    public static final RGBAShader EGA_15

  `RGBAShader` whose color is EGA color number 15.

### EGA_2

    public static final RGBAShader EGA_2

  `RGBAShader` whose color is EGA color number 2.

### EGA_3

    public static final RGBAShader EGA_3

  `RGBAShader` whose color is EGA color number 3.

### EGA_4

    public static final RGBAShader EGA_4

  `RGBAShader` whose color is EGA color number 4.

### EGA_5

    public static final RGBAShader EGA_5

  `RGBAShader` whose color is EGA color number 5.

### EGA_6

    public static final RGBAShader EGA_6

  `RGBAShader` whose color is EGA color number 6.

### EGA_7

    public static final RGBAShader EGA_7

  `RGBAShader` whose color is EGA color number 7.

### EGA_8

    public static final RGBAShader EGA_8

  `RGBAShader` whose color is EGA color number 8.

### EGA_9

    public static final RGBAShader EGA_9

  `RGBAShader` whose color is EGA color number 9.

### GRAY

    public static final RGBAShader GRAY

  `RGBAShader` whose color is `Color.GRAY`.

### GREEN

    public static final RGBAShader GREEN

  `RGBAShader` whose color is `Color.GREEN`.

### LIGHT_GRAY

    public static final RGBAShader LIGHT_GRAY

  `RGBAShader` whose color is `Color.LIGHT_GRAY`.

### MAGENTA

    public static final RGBAShader MAGENTA

  `RGBAShader` whose color is `Color.MAGENTA`.

### ORANGE

    public static final RGBAShader ORANGE

  `RGBAShader` whose color is `Color.ORANGE`.

### PINK

    public static final RGBAShader PINK

  `RGBAShader` whose color is `Color.PINK`.

### RED

    public static final RGBAShader RED

  `RGBAShader` whose color is `Color.RED`.

### WHITE

    public static final RGBAShader WHITE

  `RGBAShader` whose color is `Color.WHITE`.

### YELLOW

    public static final RGBAShader YELLOW

  `RGBAShader` whose color is `Color.YELLOW`.

Constructor Detail

### RGBAShader

    public RGBAShader()

### RGBAShader

    public RGBAShader(Color4f color)

### RGBAShader

    public RGBAShader(float red,
                      float green,
                      float blue)

### RGBAShader

    public RGBAShader(float red,
                      float green,
                      float blue,
                      float alpha)

### RGBAShader

    public RGBAShader(int rgba)

  Specify colors as ARGB integer. This means the bits 31-24 are alpha, 23-16 are red, 15-8 are green and 7-0 are blue.

  Parameters:
    `rgba` - color as 0xAARRGGBB

### RGBAShader

    public RGBAShader(Shader a)

Method Detail

### accept

    public void accept(ShaderVisitor visitor)

### addReference

    public void addReference(SharedObjectReference ref)

  Specified by:
    `addReference` in interface `Shareable`

### appendReferencesTo

    public void appendReferencesTo(java.util.List out)

  Specified by:
    `appendReferencesTo` in interface `Shareable`

### clone

    public java.lang.Object clone()

  Overrides:
    `clone` in class `Color4f`

### computeBSDF

    public float computeBSDF(Environment env,
                             Vector3f in,
                             Spectrum specIn,
                             Vector3f out,
                             boolean adjoint,
                             Spectrum bsdf)

  Description copied from interface: `Scattering`
  Evaluates bidirectional scattering distribution function for given input.

  The computed spectrum is an integral over the spectrum of the following product:

  |cos θ| BSDF(ωi, νi; ωo, νo)
  where BSDF is the bidirectional scattering distribution function (= BRDF + BTDF) at the point `env.point`, ωi the (negated) direction of the incoming light ray, νi the frequency where the incoming ray is sampled, ωo the direction of the outgoing light ray, νo the frequency where the outgoing ray is sampled, and θ the angle between the surface normal and `out`.

  If `adjoint` is `false`, `in` and `out` describe true light rays from light sources to sensors. In this case, ωi = `in`, ωo = `out`, and the integral is

  `bsdf`(ν) = |cos θ| ∫ BSDF(`in`, νi; `out`, ν) `specIn`(νi) dνi
  Otherwise, `adjoint` is `true`. `in` and `out` then describe importance rays (inverse light rays from sensors to light sources). In this case, ωi = `out`, ωo = `in`, and the integral is
  `bsdf`(ν) = |cos θ| ∫ BSDF(`out`, ν; `in`, νo) `specIn`(νo) dνo

  If this `Scattering` instance is in fact a `Light` source, `adjoint` is `false`, and the BSDF is defined as BSDF(`in`, μ; ω, ν) = L1(ω, ν) δ(μ - ν), i.e., the directional distribution of the emitted radiance at `env.point`, see `Emitter`. In this case, `in` is not used.

  If this `Scattering` instance is in fact a `Sensor`, `adjoint` is `true`, and the BSDF is defined as BSDF(ω, ν; `in`, μ) = W1(ω, ν) δ(μ - ν), i.e., the directional distribution of the emitted importance at `env.point`, see `Emitter`. In this case, `in` is not used.

  The computation should be physically valid. This excludes, e.g., ambient or emissive light contributions.

  The returned value is the value of the probability density pω that would be calculated by `Scattering.generateRandomRays(de.grogra.ray.physics.Environment, javax.vecmath.Vector3f, de.grogra.ray.physics.Spectrum, de.grogra.ray.util.RayList, boolean, java.util.Random)` if the ray happened to be one of the randomly generated rays.

  Specified by:
    `computeBSDF` in interface `Scattering`
  Parameters:
    `env` - the environment for scattering
    `in` - the (negated) direction unit vector of the incoming ray (i.e., pointing away from the surface)
    `specIn` - the spectrum of the incoming ray
    `out` - the direction unit vector of the outgoing ray (i.e., pointing away from the surface)
    `adjoint` - light ray or importance ray?
    `bsdf` - the computed spectrum of the outgoing ray will be placed in here
  Returns:
    the value of the probability density for the ray direction

### computeMaxRays

    public void computeMaxRays(Environment env,
                               Vector3f in,
                               Spectrum specIn,
                               Ray reflected,
                               Tuple3f refVariance,
                               Ray transmitted,
                               Tuple3f transVariance)

  Description copied from interface: `Shader`
  Computes, for the given input, the reflected and transmitted importance rays for which the reflection/transmission probability densities (integrated over the spectrum) attain a maximum. The reflection probability density (measured with respect to solid angle) for the outgoing importance direction (i.e., incoming light direction) ω, given a fixed incident direction `in`, is
  pr(ω) = cos θ BRDF(ω, `in`) / R
  where BRDF is the bidirectional reflectivity distribution function, θ the angle between the surface normal and ω, and R the total reflectivity for the incident direction, i.e., the integral over cos θ BRDF(ω, `in`). The transmission probability density is defined correspondingly.

  The `color`-fields are set to the total reflectivity/transparency for the incident direction for each color component R, G, B. Thus, for physically plausible BRDF/BTDF, the component-wise sum of `reflected.color` and `transmitted.color` lies in the interval [0, 1], and the difference to 1 is the amount absorbed.

  The `color` may be zero if there is no reflected or transmitted ray, respectively, i.e., if the surface is fully transparent, opaque, or absorbing. The origin-fields of the rays will never be set.

  The computed variances are defined to be, for each color component, (approximations for) the angular mean quadratic deviations of the densities from the returned maximal ray directions. E.g., for perfect reflection/transmission, these variances are zero, whereas for a perfect lambertian reflector, the variance of reflection is ∫ cos θ (1 / π) θ2 dω = (π2 - 4) / 8. This is the value of `Shader.LAMBERTIAN_VARIANCE`.

  The ray properties which are not mentioned are neither used nor modified. These are the origin and its density, and the direction density.

  Specified by:
    `computeMaxRays` in interface `Shader`
  Parameters:
    `env` - the environment for scattering
    `in` - the (negated) direction unit vector of the incoming ray (i.e., pointing away from the surface)
    `specIn` - spectrum of incoming ray
    `reflected` - the reflected ray with maximal probability
    `refVariance` - the angular mean quadratic deviation from `reflected`
    `transmitted` - the transmitted ray with maximal probability
    `transVariance` - the angular mean quadratic deviation from `transmitted`

### fieldModified

    public void fieldModified(PersistenceField field,
                              int[] indices,
                              Transaction t)

  Specified by:
    `fieldModified` in interface `Manageable`

### forEGAColor

    public static final RGBAShader forEGAColor(int index)

  Returns the `RGBAShader` whose color has the specified index in the palette of the EGA graphics card.

  Parameters:
    `index` - palette index (only the lowest 4 bits are used)
  Returns:
    corresponding shader

### generateRandomRays

    public void generateRandomRays(Environment env,
                                   Vector3f out,
                                   Spectrum specOut,
                                   RayList rays,
                                   boolean adjoint,
                                   java.util.Random rnd)

  Description copied from interface: `Scattering`
  Pseudorandomly generates, for the given input, a set of scattered rays. The scattered rays are generated such that they can be used for a Monte Carlo integration of a function f(ω;ν) over cos θ BSDF(ωi, νi; ωo, νo) in the following way:
  - If `adjoint` is `false`, `out` = ωo describes the direction of an outgoing light ray. In this case, the integration is with respect to ωi. Let g(ω, ν; `out`, μ) = BSDF(ω, ν; `out`, μ)
  - Otherwise, `adjoint` is `true`. In this case, `out` = ωi describes the direction of an outgoing importance ray (an inverse light ray). Now the integration is with respect to ωo. Let g(ω, ν; `out`, μ) = BSDF(`out`, μ; ω, ν)
  Let di and si denote the directions and spectra of the N generated rays (N = `rays.size`). Then, for every frequency ν the sum
  1 / N ∑i si(ν) f(di; ν)
  is an unbiased estimate for the integral
  ∫ cos θ f(ω; ν) g(ω, ν; `out`, μ) `specOut`(μ) dμ dω
  θ is the angle between the surface normal and ω. The domain of integration is the whole sphere, since the bidirectional scattering distribution includes both reflection and transmission (BSDF = BRDF + BTDF).

  If this `Scattering` instance is in fact a `Light` source, `adjoint` is `true`, and the BSDF is defined as BSDF(`out`, μ; ω, ν) = L1(ω, ν) δ(μ - ν), i.e., the directional distribution of the emitted radiance at `env.point`, see `Emitter`. In this case, `out` is not used.

  If this `Scattering` instance is in fact a `Sensor`, `adjoint` is `false`, and the BSDF is defined as BSDF(ω, ν; `out`, μ) = W1(ω, ν) δ(μ - ν), i.e., the directional distribution of the emitted importance at `env.point`, see `Emitter`. In this case, `out` is not used.

  Let pω be the probability density used for the ray direction (measured with respect to solid angle ω), then the field `directionDensity` of the ray i is set to pω(di). For ideal specular reflection or transmission, or for directional lights or sensors, pω is not a regular function, the value `directionDensity` will be set to a multiple of `Scattering.DELTA_FACTOR`.

  The ray properties which are not mentioned in the given formulas are neither used nor modified. These are the origin and its density.

  Specified by:
    `generateRandomRays` in interface `Scattering`
  Parameters:
    `env` - the environment for scattering
    `out` - the direction unit vector of the outgoing ray (i.e., pointing away from the surface)
    `specOut` - the spectrum of the outgoing ray
    `rays` - the rays to be generated
    `adjoint` - represents `out` a light ray or an importance ray?
    `rnd` - pseudorandom generator
  See Also:
    `Scattering.computeBSDF(de.grogra.ray.physics.Environment, javax.vecmath.Vector3f, de.grogra.ray.physics.Spectrum, javax.vecmath.Vector3f, boolean, de.grogra.ray.physics.Spectrum)`

### getAverageColor

    public int getAverageColor()

  Description copied from interface: `Scattering`
  Returns an average color for the scattering entity. This color is used for simplified graphical representations of the corresponding objects.

  Specified by:
    `getAverageColor` in interface `Scattering`
  Returns:
    an average color in Java's default sRGB color space, encoded as an int (0xAARRGGBB).

### getEGAColorIndex

    public static final int getEGAColorIndex(Color3f c)

  Returns the index of the color in the palette of the EGA graphics card which is closest to the specified color.

  Parameters:
    `c` - a color
  Returns:
    index of closest EGA color

### getEGAColorIndex

    public static final int getEGAColorIndex(Color4f c)

  Returns the index of the color in the palette of the EGA graphics card which is closest to the specified color.

  Parameters:
    `c` - a color
  Returns:
    index of closest EGA color

### getEGAColorIndex

    public static final int getEGAColorIndex(float r,
                                             float g,
                                             float b)

  Returns the index of the color in the palette of the EGA graphics card which is closest to the specified color.

  Parameters:
    `r` - red value of color (between 0 and 1)
    `g` - green value of color (between 0 and 1)
    `b` - blue value of color (between 0 and 1)
  Returns:
    index of closest EGA color

### getFlags

    public int getFlags()

  Specified by:
    `getFlags` in interface `Scattering`

### getIcon

    public Icon getIcon(java.awt.Dimension size,
                        int state)

  Specified by:
    `getIcon` in interface `IconSource`

### getIconBounds

    public java.awt.Rectangle getIconBounds()

  Specified by:
    `getIconBounds` in interface `Icon`

### getIconSource

    public IconSource getIconSource()

  Specified by:
    `getIconSource` in interface `Icon`

### getImage

    public java.awt.Image getImage()

  Specified by:
    `getImage` in interface `Icon`

### getImage

    public java.awt.Image getImage(int w,
                                   int h)

  Specified by:
    `getImage` in interface `Icon`

### getImageSource

    public java.net.URL getImageSource()

  Specified by:
    `getImageSource` in interface `Icon`

### getManageableType

    public ManageableType getManageableType()

  Specified by:
    `getManageableType` in interface `Manageable`

### getPreferredIconSize

    public java.awt.Dimension getPreferredIconSize(boolean small)

  Specified by:
    `getPreferredIconSize` in interface `IconSource`

### getProvider

    public SharedObjectProvider getProvider()

  Specified by:
    `getProvider` in interface `Shareable`

### getStamp

    public int getStamp()

  Description copied from interface: `Manageable`
  Returns a stamp for this object. Each modification to this object increments the stamp. The initial stamp is non-negative.

  Specified by:
    `getStamp` in interface `Manageable`
  Returns:
    a stamp

### initProvider

    public void initProvider(SharedObjectProvider provider)

  Specified by:
    `initProvider` in interface `Shareable`

### isMutable

    public boolean isMutable()

  Specified by:
    `isMutable` in interface `Icon`

### isPredefined

    public boolean isPredefined()

### isTransparent

    public boolean isTransparent()

  Specified by:
    `isTransparent` in interface `Shader`

### manageableReadResolve

    public Manageable manageableReadResolve()

  Specified by:
    `manageableReadResolve` in interface `Manageable`

### manageableWriteReplace

    public java.lang.Object manageableWriteReplace()

  Specified by:
    `manageableWriteReplace` in interface `Manageable`

### paintIcon

    public void paintIcon(java.awt.Component c,
                          java.awt.Graphics2D g,
                          int x,
                          int y,
                          int w,
                          int h,
                          int state)

  Specified by:
    `paintIcon` in interface `Icon`

### prepareIcon

    public void prepareIcon()

  Specified by:
    `prepareIcon` in interface `Icon`

### removeReference

    public void removeReference(SharedObjectReference ref)

  Specified by:
    `removeReference` in interface `Shareable`

### scale

    public void scale(double r,
                      Tuple3d color)

### shade

    public void shade(Environment env,
                      RayList in,
                      Vector3f out,
                      Spectrum specOut,
                      Tuple3d color)

  Description copied from interface: `Shader`
  Computes color of outgoing light ray for given input. The computed value is, for each color component j = R, G, B, the following sum over all incident rays k:
  ∑k |cos θk| BSDFj(ωk, `out`) ck,j
  where BSDFj is the bidirectional scattering distribution function (= BRDF + BTDF) at the point `env.point`, ωk and ck the direction and color of ray k, and θk the angle between the surface normal and ωk.

  The computation may include physically invalid contributions, which may not fit into the formula above, e.g., ambient or emissive light contributions.

  Specified by:
    `shade` in interface `Shader`
  Parameters:
    `env` - the environment for scattering
    `in` - the incoming rays
    `out` - the direction unit vector of the outgoing ray (i.e., pointing away from the surface)
    `specOut` - spectrum of outgoing ray
    `color` - the output color will be placed in here

Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD