17.2.2.1 Introduction

The X3D lighting model provides detailed equations that specify the colours to apply to each geometric object. For each object, the values of the material, color, and/or texture currently being applied to the object are combined with the lights illuminating the object and the currently bound X3DFogObject (if specified). These equations are designed to simulate the physical properties of light striking a surface.

If a programmable shader is defined for an Appearance node, the lighting model shall be disabled and replaced by the functionality implemented by the shader program. See 31 Programmable shaders component for more information.

NOTE  Geometry nodes that represent lines or points do not support lighting.

17.2.2.2 Texture sampling

A grayscale texture is exactly equivalent to using an RGB texture with all 3 components (red, green, blue) equal.

A texture without an alpha channel is exactly equivalent to using a texture with an alpha channel filled with 1 (indicating opaque).

17.2.2.3 Common definitions for all lighting models

The declarations and definitions below are presented using pseudocode similar to shading language code (see 31.2.2.1 Shader language options).

• The function declarations look like this: functionName(typeOfParameter1parameter1,typeOfParameter2parameter2, ...). Type names are underlined.
• The types can be X3D nodes, scalars (float), vectors with 2, 3 or 4 components (vector2, vector3, vector4), universal type (vectorAny which can represent any vector or scalar).
• In function definitions, we often extract vector components with syntax like: thisVector.rgb (converts vector4 to vector3, discarding alpha channel) or thisVector.a (converts vector4 to float, extracting alpha channel value).
• The symbol × performs a component-wise multiplication of vectors.
• The symbol · is a modified vector dot product that always returns value >= 0, defined like this:

  x · y = max(0.0, dotProduct(x, y))

The mixTexture(vector4color,X3DTextureNodetexture) function, used in the equations below, takes care of mixing an RGBA color with the RGBA value sampled from the texture at the given shape point.

• If the texture is NULL, then this function just returns unmodified color.
• Otherwise, if the texture is not a MultiTexture, then

  mixTexture(color, texture) = color × textureSample(texture)

  The textureSample(texture) is a function sampling the texture (recovering a single color from an array of pixels), with the correct texture coordinates and transformation.

  In effect the color modulates the color from the texture.

  • color.rgb = white = (1, 1, 1) results in the pure color of the texture,
  • color.rgb = black = (0, 0, 0) results in a black output, regardless of the texture.

  The alpha (opacity) values are multiplied too, hence:

  • color.a equal 1 (transparency equal 0) results in an alpha equal to that of the texture,
  • color.a equal 0 (transparency equal 1) results in an alpha of 0 regardless of the value in the texture.
• Otherwise, if the texture is a MultiTexture, then the mixTexture modifies this color following the MultiTexture mode specification. This is only possible when the MultiTexture is provided in the Appearance.texture field. See 12.2.5 Coexistence of textures specified in material nodes with the "Appearance.texture" field for details when multi-texturing is used.

The lerp(floatfactor,vectorAnyx,vectorAnyy) function performs a standard linear interpolation, applicable to scalars or vectors of any dimension:

lerp(factor, x, y) = x * (1 - factor) + y * factor = x + (y - x) * factor

The occlusion(vector4color) function, used in the equations below for Phong and physical lighting model, is used to apply the occlusionTexture effect that can be specified in these nodes.

• If the occlusionTexture was not provided (left NULL) then this function just returns unmodified color.
• If the occlusionTexture was provided, then

  occlusion(color) = lerp(occlusionStrength, color, color * textureSample(occlusionTexture).r)

  In effect, the occlusionTexture multiplies the input color when occlusionStrength is 1.0. the occlusionTexture has no effect when when occlusionStrength is 0.0. Values in-between of occlusionStrength allow to smoothly interpolate between these two states.

The applyColorPerVertex(vector4color) is used to change the color in case geometry uses Color or ColorRGBA nodes. All the lighting models use this function, although it affects a different parameter: emissiveParameter in case of unlit model, diffuseParameter in case of Phong model, and baseParameter in case of physical model. The function returns:

• The interpolated per-vertex colour, or per-face colour, from the Color node, if the Color node is provided in the geometry color field.

  Resulting rgb is derived from the values in the Color node.

  Resulting a (alpha component) is taken from input color.a in this case.

• Otherwise, the interpolated per-vertex colour, or per-face colour, from the ColorRGBA node, if the ColorRGBA node is provided in the geometry color field.

  Resulting rgba vector is derived from the values in the ColorRGBA node.

• Otherwise (if the geometry color field is empty) then it returns unmodified color.

The future X3D versions may introduce an option for Color and ColorRGBA to multiply the input color, instead of replacing it.

Moreover we define the following vectors:

• N = normalized normal vector at this point on geometry. This vector is interpolated from vertex normals specified in a node derived from X3DNormalNode or calculated by the X3D browser. It is modified by the normalTexture providing normals in the tangent space (see X3DOneSidedMaterialNode definition).
• V = normalized vector from point on geometry to viewer's position.

The following definitions are specific to a light source i, which is indicated by a subscript in this text:

• L_i is, conceptually, direction to the light i. It is precisely defined like this:
  • L_i = (PointLight/SpotLight) normalized vector from point on geometry to light source i position
  • L_i = (DirectionalLight) negated and normalized direction of light source i

• attenuation_i= 1 / max(c₁ + c₂ × lightDistance + c₃ × lightDistance² , 1)

  where

  c₁, c₂, c₃ are the values from light i attenuation field.

  lightDistance is the distance from light to point on geometry, in light's coordinate system.

• on_i = 1, if light source i affects this point on the geometry or 0 if it does not.

  The following conditions indicate that light source i does not affect this geometry:

  1. if the geometry is farther away than radius for PointLight or SpotLight
  2. if the geometry is outside the enclosing X3DGroupingNode in case of lights with global FALSE
  3. if the lightSource.on field is FALSE.

• shadowTest_i scales down the light contribution if the light source is obscured by a shape casting shadow.

  • shadowTest_i is 1.0 if the light source i has shadows field equal FALSE.

  • Otherwise, shadowTest_i is 1.0 if the light source i has shadows field equal TRUE but nothing obscures the light. That is, there is no Shape (that has visible and castShadow equal TRUE) between the light source position and the given point. The DirectionalLight is treated like a point in infinity for this purpose, which means that shadow rays are all parallel to the light direction.

  • Otherwise, shadowTest_i is 1.0 - shadowIntensity. This case occurs when shadows field equals TRUE and the light is obscured. For example, shadowIntensity equal 1.0 (the default) means that light contribution drops to zero when the light is obscured by the shadow caster.

• lightColor_i equals the color field of light source i.
• spot_i is the spotlight factor. It calculates intensity within the SpotLight cone. Table 17.4 specifies how it is calculated. It relies on the following terms:
  • spotDirection_i = normalized SpotLight i direction field.
  • spotAngle = arcCosine( -L· spotDirection_i)

The applyFog(vector4color) is used to change the color using the currently bound fog node. Is it used by all lighting models, as the last operation performed on the color. The definition is:

applyFog(color) = lerp(fogInterpolant(fogDistance), fogColor, color)

where:

• fogInterpolant is the fog interpolant, see Table 17.5 for calculation.
• fogDistance is the distance from point on geometry to viewer's position, in coordinate system of the currently bound fog node.
• fogColor is the currently bound fog node's color.
• fogVisibility is the currently bound fog node's visibilityRange, in the same coordinate system as fogDistance.

17.2.2.4 Unlit lighting model

A Shape node is unlit if either of the following is true:

1. The shape's appearance field is NULL (default).
2. The material field in the Appearance node is NULL (default).
3. The material field in the Appearance node contains a node of type UnlitMaterial.

In the first two cases above, the rendering is exactly equivalent as if the Appearance node was provided (not NULL), and the material field inside contained an UnlitMaterial with all the fields at their default. Effectively, it means a white untextured unlit material is the default.

NOTE  Geometry nodes that represent lines or points do not support lighting if the normal vectors for them are not provided.

If the shape is unlit, the RGBA color of the shape at each point on the shape's geometry is calculated using this equation:

fragmentColor = applyFog(mixTexture(applyColorPerVertex(emissiveParameter), emissiveTextureParameter))

where:

• emissiveParameter.rgb (RGB channels) are taken from UnlitMaterial.emissiveColor.
• emissiveParameter.a (alpha channel) is taken from 1 - UnlitMaterial.transparency.
• emissiveTextureParameter is equal to:
  • emissiveTexture of the UnlitMaterial node, if it is not NULL.
  • Otherwise, Appearance.texture, if the UnlitMaterial has emissiveTexture equal NULL, but Appearance.texture is not NULL. See 12.2.5 Coexistence of textures specified in material nodes with the "Appearance.texture" field.
  • Otherwise (if both the UnlitMaterial.emissiveTexture and Appearance.texture are NULL) then emissiveTextureParameter is NULL. In other words, the mixTexture(...) function used above simply returns the unmodified applyColorPerVertex(emissiveParameter).

17.2.2.5 Phong lighting model

The Shape node is lit with a Phong lighting model if the Appearance node is specified for the Shape, and the material field contains a Material node.

NOTE   This node is simply called Material for historical reasons. Conceptually, you should think about it now as a PhongMaterial.

The rendered fragment (pixel) color is determined by these equations:

fragmentColor = applyFog(emissiveParameter + occlusion(sumOverAllLights(lightContribution_i)))

lightContribution_i= on_i × shadowTest_i × lightColor_i × attenuation_i × spot_i × (ambient_i+ diffuse_i+ specular_i)

An ideal X3D implementation will evaluate the following lighting equation at each point on a lit surface. The means that we advise using Phong shading and assume it when writing equations below. For implementations that perform Gouraud shading see 17.2.2.8 Gouraud shading section.

The meaning of all the terms is explained below.

Material parameters

First, the parameters whose value does not depend on the light source:

The material diffuseParameter is calculated as follows:

diffuseParameter = mixTexture(applyColorPerVertex(diffuseParameter), diffuseTextureParameter) where:

• diffuseParameter.a (RGB channels) is taken from Material.diffuseColor.
• diffuseParameter.a (alpha channel) is taken from 1 - Material.transparency.
• diffuseTextureParameter is equal to:
  • diffuseTexture of the Material node, if it is not NULL.
  • Otherwise, Appearance.texture, if the Material has diffuseTexture equal NULL, but Appearance.texture is not NULL. See 12.2.5 Coexistence of textures specified in material nodes with the "Appearance.texture" field.
  • Otherwise (if both the Material.diffuseTexture and Appearance.texture are NULL) then diffuseTextureParameter is NULL. In other words, the mixTexture(...) function used above simply returns the unmodified applyColorPerVertex(diffuseParameter).

The remaining parameters are defined below:

• ambientParameter = ambientIntensity ×diffuseParameter.rgb× textureSample(ambientTexture).rgb

• emissiveParameter = emissiveColor × textureSample(emissiveTexture).rgb

• specularParameter = specularColor × textureSample(specularTexture).rgb

• shininessParameter = shininess × textureSample(shininessTexture).a × 128

In the above equations, if the given texture is NULL then behave as if the textureSample(texture) returned a white opaque value (1, 1, 1, 1).

Light parameters

Now we can define terms that depend on the light source:

• ambient_i= lightSource.ambientIntensity × ambientParameter

• diffuse_i = lightSource.intensity × diffuseParameter × ( N· L)

• specular_i = lightSource.intensity × specularParameter × ( N· (( L + V) /| L+ V|))^{shininessParameter}

The Phong lighting equations are based on the simple illumination equations given in [FOLEY] and [OPENGL].

17.2.2.6 Physical lighting model

The Shape node is lit with a Physical lighting model if the Appearance node are specified for the Shape, and the material field contains a PhysicalMaterial node. We perform in this case a physically-based rendering.

The rendered fragment (pixel) color is determined by these equations:

fragmentColor = applyFog(emissiveParameter + occlusion(sumOverAllLights(lightContribution_i)))

lightContribution_i= on_i × shadowTest_i × lightColor_i × attenuation_i × spot_i × physicalLightContribution_i

The input values used by the physical lighting equation are as follows:

baseParameter = mixTexture(applyColorPerVertex(baseParameter), baseTextureParameter) where:

• baseParameter.a (RGB channels) is taken from PhysicalMaterial.baseColor.
• baseParameter.a (alpha channel) is taken from 1 - PhysicalMaterial.transparency.
• baseTextureParameter is equal to:
  • baseTexture of the PhysicalMaterial node, if it is not NULL.
  • Otherwise, Appearance.texture, if the PhysicalMaterial has baseTexture equal NULL, but Appearance.texture is not NULL. See 12.2.5 Coexistence of textures specified in material nodes with the "Appearance.texture" field.
  • Otherwise (if both the PhysicalMaterial.baseTexture and Appearance.texture are NULL) then baseTextureParameter is NULL. In other words, the mixTexture(...) function used above simply returns the unmodified applyColorPerVertex(baseParameter).

metallicParameter = PhysicalMaterial.metallic × textureSample(PhysicalMaterial.metallicRoughnessTexture).b

roughnessParameter = PhysicalMaterial.roughness × textureSample(PhysicalMaterial.metallicRoughnessTexture).g

If the metallicRoughnessTexture is NULL, then metallicParameter and roughnessParameter are just equal to (respectively) metallic and roughness values given by the PhysicalMaterial node.

The physical lighting model uses the baseParameter, metallicParameter and roughnessParameter to calculate the physicalLightContribution_i value in accordance with the physically based rendering equations as specified in 2.[GLTF].

X3DLightNode : X3DChildNode { 
  SFFloat [in,out] ambientIntensity 0     [0,1]
  SFColor [in,out] color            1 1 1 [0,1]
  SFBool  [in,out] global           FALSE
  SFFloat [in,out] intensity        1     [0,∞) 
  SFNode  [in,out] metadata         NULL  [X3DMetadataObject]
  SFBool  [in,out] on               TRUE
  SFBool  [in,out] shadows          FALSE
  SFFloat [in,out] shadowIntensity  1     [0,1]
}

DirectionalLight : X3DLightNode {
  SFFloat [in,out] ambientIntensity 0      [0,1]
  SFColor [in,out] color            1 1 1  [0,1]
  SFVec3f [in,out] direction        0 0 -1 (-∞,∞)
  SFBool  [in,out] global           FALSE
  SFFloat [in,out] intensity        1      [0,∞)
  SFNode  [in,out] metadata         NULL   [X3DMetadataObject]
  SFBool  [in,out] on               TRUE
  SFBool  [in,out] shadows          FALSE
  SFFloat [in,out] shadowIntensity  1     [0,1]
}

PointLight : X3DLightNode {
  SFFloat [in,out] ambientIntensity 0     [0,1]
  SFVec3f [in,out] attenuation      1 0 0 [0,∞)
  SFColor [in,out] color            1 1 1 [0,1]
  SFBool  [in,out] global           TRUE
  SFFloat [in,out] intensity        1     [0,∞)
  SFVec3f [in,out] location         0 0 0 (-∞,∞)
  SFNode  [in,out] metadata         NULL  [X3DMetadataObject]
  SFBool  [in,out] on               TRUE
  SFFloat [in,out] radius           100   [0,∞)
  SFBool  [in,out] shadows          FALSE
  SFFloat [in,out] shadowIntensity  1     [0,1]
}

SpotLight : X3DLightNode {
  SFFloat [in,out] ambientIntensity 0        [0,1]
  SFVec3f [in,out] attenuation      1 0 0    [0,∞)
  SFFloat [in,out] beamWidth        π*3/16   (0,π/2]
  SFColor [in,out] color            1 1 1    [0,1]
  SFFloat [in,out] cutOffAngle      π/2      (0,π/2]
  SFVec3f [in,out] direction        0 0 -1   (-∞,∞)
  SFBool  [in,out] global           TRUE
  SFFloat [in,out] intensity        1        [0,∞)
  SFVec3f [in,out] location         0 0 0    (-∞,∞)
  SFNode  [in,out] metadata         NULL     [X3DMetadataObject]
  SFBool  [in,out] on               TRUE
  SFFloat [in,out] radius           100      [0,∞)
  SFBool  [in,out] shadows          FALSE
  SFFloat [in,out] shadowIntensity  1        [0,1]
}

    angle = the angle between the Spotlight's direction vector and
            the vector from the Spotlight location to the point to be illuminated
    if (angle ≥ cutOffAngle):
        multiplier = 0
    else if (angle ≤ beamWidth):
        multiplier = 1
    else:
        multiplier = (angle - cutOffAngle) / (beamWidth - cutOffAngle)
    intensity(angle) = SpotLight.intensity × multiplier