In the physical lighting model (see 17.2.2.6 Physical lighting model) the intensity value should correspond to:

• luminous intensity in candela (lm/sr) in case of PointLight and SpotLight.

• illuminance in lux (lm/m²) in case of DirectionalLight.

In the physical lighting model, the ambientIntensity value is unused. Future specification versions may introduce a use for it, therefore we recommend leaving it at 0 (default) in case of physical rendering, to avoid future changes.

In case of the unlit lighting model all lights are ignored. See the 17.2.2.4 Unlit lighting model.

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.

Backward compatibility note: The lighting equations in X3D 4.0 are backward compatible with X3D 3.3. If you take a combination of X3D 3.3 material and light nodes, and simply use them in X3D 4.0 (leaving the new X3D 4.0 fields at their default values) then the rendering result will be equivalent. The only exception to this statement is differentiating between grayscale and RGB textures, which is discussed in section below in 17.2.2.2 Texture sampling.

17.2.2.2 Texture sampling

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

When sampling any texture, the texture without an alpha channel is exactly equivalent to using a texture with an alpha channel filled with 1 (indicating opaque).

These rules make treatment of the textures simple, and consistent with other 3D authoring software. They are also consistent with how the graphic APIs and GPU shaders query the textures.

The browsers are encouraged to optimize loading of the textures, to not load all textures as 4 channels (RGBA) to the GPU. Intensity texture can be loaded as just 1 channel, intensity + alpha is only 2 channels, RGB texture without alpha is 3 channels. Optimizing this loading is useful to keep GPU memory usage low, and to keep texture loading time smaller. However, this is just an optimization. Performing it is optional, and the rendering result should be the same as if all textures were loaded as full RGBA textures.

Backward compatibility note: In X3D version 3, the treatment of grayscale and RGB textures was not consistent. In some cases (using ImageTexture node, but not inside MultiTexture) grayscale texture resulted in a different rendering result than the equivalent RGB texture (with all red, green, blue components equal). As this was inconsistent (within X3D, and with other software and model formats), uneasy to implement (browsers needed to investigate the image header), needlessly limiting to authors, and the implementation was inconsistent across the existing browsers — in X3D 4.0 it was streamlined.

17.2.2.3 Common definitions for all lighting models

The declarations and definitions below are presented using a pseudo-code similar to the usual shading language code.

• The function declarations look like this: functionName(typeOfParameter1 parameter1, typeOfParameter2 parameter2, ...). 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(vector4 color, X3DTextureNode texture) 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) will result in the pure color of the texture,
  • color.rgb = black = (0, 0, 0) will result in a black output, regardless of the texture.

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

  • color.a equal 1 (transparency equal 0) will result in an alpha equal to that of the texture,
  • color.a equal 0 (transparency equal 1) will result 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(float factor, vectorAny x, vectorAny y) 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(vector4 color) 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(vector4 color) 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 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 doesn't.

  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.

• 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(vector4 color) is used to change the color using the fog. 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 current fog node.

• fogColor is the currently bound fog's color.

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 × 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 doesn't 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 × diffuseColor × 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}

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 × 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.

Using the baseParameter, metallicParameter and roughnessParameter, the physical lighting model performs the exact same computations as the recommended glTF lighting model, to calculate physicalLightContribution_i value. See glTF 2.0 specification section about lighting equations and glTF-Sample-Viewer implementation of it. Future revisions of this draft will contain the final recommended equations.

The physical lighting equations are based on the glTF 2.0 specification.

17.2.2.8 Gouraud shading

An ideal X3D implementation will evaluate the lighting equation at each point on a lit surface. The lighting equations in previous sections assume that you use Phong shading (not to be confused with Phong lighting model). In case of Phong shading, lighting is calculated at each fragment (pixel of the screen).

However, some implementations perform Gouraud shading, either by default, or as an option for the user (for efficiency), or as a fallback for an older GPUs. In such case, the lighting equations given above cannot be reproduced precisely. In Gouraud shading, you calculate lighting per-vertex, which means that it doesn't make sense to use texture information to modify material parameters.

In case when Gouraud shading is used we recommend this algorithm:

• The vertex shader calculates lighting equations, ignoring any texture information (as if all the textures were NULL).

• The fragment shader multiplies the resulting interpolated color by the main texture. The main texture is:

  • Material.diffuseTexture, if Phong Material node is used.
  • UnlitMaterial.emissiveTexture, if UnlitMaterial node is used.
  • PhysicalMaterial.baseTexture, if PhysicalMaterial node is used.

  If the given texture is NULL, then use the Appearance.texture. If the Appearance.texture is also NULL, no texture is used.

  All channels (RGB and alpha) are affected by the main texture.

  This method of determining the main texture is deliberately 100% consistent with:

  1. The way how the Appearance.texture cooperates with textures inside the materials, following section 12.2.5 Coexistence of textures specified in material nodes with the "Appearance.texture" field. Appearance.texture may be used in place of Material.diffuseTexture, or UnlitMaterial.emissiveTexture, or PhysicalMaterial.baseTexture.

  2. The determination which texture contains the alpha channel that is multiplied by material transparency. We take it from alpha channel of Material.diffuseTexture, or UnlitMaterial.emissiveTexture, or PhysicalMaterial.baseTexture.

This recommendation tries to preserve the intended look as much as possible in Gouraud shading.

Note: This recommendation actually doesn't change anything in case of UnlitMaterial. And this is correct, Gouraud shading actually doesn't change how the UnlitMaterial can be implemented.

Note: When using PhysicalMaterial on older hardware, some implementations may fall back to the Phong lighting model. If this is necessary, we recommend using PhysicalMaterial.baseColor as the Phong diffuse factor, and PhysicalMaterial.baseTexture as the texture to multiply the resulting color.

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,1]
  SFFloat [in,out] intensity        1     [0,∞]
  SFNode  [in,out] metadata         NULL  [X3DMetadataObject]
  SFBool  [in,out] on               TRUE
}

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,1]
  SFFloat [in,out] intensity        1      [0,∞]
  SFNode  [in,out] metadata         NULL   [X3DMetadataObject]
  SFBool  [in,out] on               TRUE
}

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,1]
  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,∞)
}

SpotLight : X3DLightNode {
  SFFloat [in,out] ambientIntensity 0        [0,1]
  SFVec3f [in,out] attenuation      1 0 0    [0,∞)
  SFFloat [in,out] beamWidth        π/4      (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,1]
  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,∞)
}

    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