Module imp3d

Class RGBAShader

All Implemented Interfaces:
Icon, IconSource, Scattering, Shader, Manageable, Shareable, Scattering, Shader, Serializable, 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:
  • Field Details

    • 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.
    • 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.
    • YELLOW

      public static final RGBAShader YELLOW
      RGBAShader whose color is Color.YELLOW.
    • WHITE

      public static final RGBAShader WHITE
      RGBAShader whose color is Color.WHITE.
    • 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_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.
    • 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.
    • $TYPE

      public static final ManageableType $TYPE
  • Constructor Details

    • RGBAShader

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

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

      public RGBAShader()
    • RGBAShader

      public RGBAShader(Shader a)
    • RGBAShader

      public RGBAShader(Color4f color)
    • 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
  • Method Details

    • 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
    • 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
    • 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
    • scale

      public void scale(double r, Tuple3d color)
    • clone

      public Object clone()
      Overrides:
      clone in class Color4f
    • isPredefined

      public boolean isPredefined()
    • 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).
    • getFlags

      public int getFlags()
      Specified by:
      getFlags in interface Scattering
    • initProvider

      public void initProvider(SharedObjectProvider provider)
      Specified by:
      initProvider in interface Shareable
    • getProvider

      public SharedObjectProvider getProvider()
      Specified by:
      getProvider in interface Shareable
    • addReference

      public void addReference(SharedObjectReference ref)
      Specified by:
      addReference in interface Shareable
    • removeReference

      public void removeReference(SharedObjectReference ref)
      Specified by:
      removeReference in interface Shareable
    • appendReferencesTo

      public void appendReferencesTo(List out)
      Specified by:
      appendReferencesTo in interface Shareable
    • getManageableType

      public ManageableType getManageableType()
      Specified by:
      getManageableType in interface Manageable
    • fieldModified

      public void fieldModified(PersistenceField field, int[] indices, Transaction t)
      Specified by:
      fieldModified in interface Manageable
    • 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
    • manageableReadResolve

      public Manageable manageableReadResolve()
      Specified by:
      manageableReadResolve in interface Manageable
    • manageableWriteReplace

      public Object manageableWriteReplace()
      Specified by:
      manageableWriteReplace in interface Manageable
    • getIcon

      public Icon getIcon(Dimension size, int state)
      Specified by:
      getIcon in interface IconSource
    • getPreferredIconSize

      public Dimension getPreferredIconSize(boolean small)
      Specified by:
      getPreferredIconSize in interface IconSource
    • paintIcon

      public void paintIcon(Component c, Graphics2D g, int x, int y, int w, int h, int state)
      Specified by:
      paintIcon in interface Icon
    • getIconSource

      public IconSource getIconSource()
      Specified by:
      getIconSource in interface Icon
    • prepareIcon

      public void prepareIcon()
      Specified by:
      prepareIcon in interface Icon
    • isMutable

      public boolean isMutable()
      Specified by:
      isMutable in interface Icon
    • getImage

      public Image getImage()
      Specified by:
      getImage in interface Icon
    • getImage

      public Image getImage(int w, int h)
      Specified by:
      getImage in interface Icon
    • getImageSource

      public URL getImageSource()
      Specified by:
      getImageSource in interface Icon
    • getIconBounds

      public Rectangle getIconBounds()
      Specified by:
      getIconBounds in interface Icon
    • 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| BSDFjk, 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
    • 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
    • generateRandomRays

      public void generateRandomRays(Environment env, Vector3f out, Spectrum specOut, RayList rays, boolean adjoint, 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:
    • 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, ν) specIni) 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) specIno) 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
    • isTransparent

      public boolean isTransparent()
      Specified by:
      isTransparent in interface Shader
    • accept

      public void accept(ShaderVisitor visitor)
      Specified by:
      accept in interface Shader