API Docs for: 1.0.0

SpecularMaterial

Extends Material
Module: materials
Parent Module: xeogl

A SpecularMaterial is a physically-based Material that defines the surface appearance of Entities using the specular-glossiness workflow.

Examples

glTF models with PBR materials Sample materials Texturing spec/gloss channels Specular Vs. glossiness

Overview

  • SpecularMaterial is usually used for insulators, such as ceramic, wood and plastic.
  • MetallicMaterial is usually used for conductive materials, such as metal.
  • PhongMaterial is usually used for non-realistic objects.

For an introduction to PBR concepts, try these articles:

The following table summarizes SpecularMaterial properties:

Property Type Range Default Value Space Description
diffuse Array [0, 1] for all components [1,1,1,1] linear The RGB components of the diffuse color of the material.
specular Array [0, 1] for all components [1,1,1,1] linear The RGB components of the specular color of the material.
glossiness Number [0, 1] 1 linear The glossiness the material.
specularF0 Number [0, 1] 1 linear The specularF0 of the material surface.
emissive Array [0, 1] for all components [0,0,0] linear The RGB components of the emissive color of the material.
alpha Number [0, 1] 1 linear The transparency of the material surface (0 fully transparent, 1 fully opaque).
diffuseMap Texture null sRGB Texture RGB components multiplying by diffuse. If the fourth component (A) is present, it multiplies by alpha.
specularMap Texture null sRGB Texture RGB components multiplying by specular. If the fourth component (A) is present, it multiplies by alpha.
glossinessMap Texture null linear Texture with first component multiplying by glossiness.
specularGlossinessMap Texture null linear Texture with first three components multiplying by specular and fourth component multiplying by glossiness.
emissiveMap Texture null linear Texture with RGB components multiplying by emissive.
alphaMap Texture null linear Texture with first component multiplying by alpha.
occlusionMap Texture null linear Ambient occlusion texture multiplying by surface's reflected diffuse and specular light.
normalMap Texture null linear Tangent-space normal map.
alphaMode String "opaque", "blend", "mask" "blend" Alpha blend mode.
alphaCutoff Number [0..1] 0.5 Alpha cutoff value.
backfaces Boolean false Whether to render Geometry backfaces.
backfaces String "ccw", "cw" "ccw" The winding order for Geometry frontfaces - "cw" for clockwise, or "ccw" for counter-clockwise.

Usage

In the example below we'll create the plastered sphere shown in the Sample Materials example (see screenshots above).

Here's a closeup of the sphere we'll create:

Our plastered sphere Entity has:

Note that in this example we're providing separate Textures for the specular and glossiness channels, which allows us a little creative flexibility. Then, in the next example further down, we'll combine those channels within the same Texture for efficiency.

var plasteredSphere = new xeogl.Entity({

   geometry: new xeogl.SphereGeometry({
       center: [0,0,0],
       radius: 1.5,
       heightSegments: 60,
       widthSegments: 60
   }),

   lights: new xeogl.Lights({
       lights: [
           new xeogl.DirLight({
               dir: [0.8, -0.6, -0.8],
               color: [0.8, 0.8, 0.8],
               space: "view"
           }),
           new xeogl.DirLight({
               dir: [-0.8, -0.4, -0.4],
               color: [0.4, 0.4, 0.5],
               space: "view"
           }),
           new xeogl.DirLight({
               dir: [0.2, -0.8, 0.8],
               color: [0.8, 0.8, 0.8],
               space: "view"
           })
       ],
       lightMap: new xeogl.CubeTexture({
           src: [
               "textures/light/Uffizi_Gallery/Uffizi_Gallery_Irradiance_PX.png",
               "textures/light/Uffizi_Gallery/Uffizi_Gallery_Irradiance_NX.png",
               "textures/light/Uffizi_Gallery/Uffizi_Gallery_Irradiance_PY.png",
               "textures/light/Uffizi_Gallery/Uffizi_Gallery_Irradiance_NY.png",
               "textures/light/Uffizi_Gallery/Uffizi_Gallery_Irradiance_PZ.png",
               "textures/light/Uffizi_Gallery/Uffizi_Gallery_Irradiance_NZ.png"
           ]
       }),
       reflectionMap: new xeogl.CubeTexture({
           src: [
               "textures/reflect/Uffizi_Gallery/Uffizi_Gallery_Radiance_PX.png",
               "textures/reflect/Uffizi_Gallery/Uffizi_Gallery_Radiance_NX.png",
               "textures/reflect/Uffizi_Gallery/Uffizi_Gallery_Radiance_PY.png",
               "textures/reflect/Uffizi_Gallery/Uffizi_Gallery_Radiance_NY.png",
               "textures/reflect/Uffizi_Gallery/Uffizi_Gallery_Radiance_PZ.png",
               "textures/reflect/Uffizi_Gallery/Uffizi_Gallery_Radiance_NZ.png"
           ]
       })
   }),

   material: new xeogl.SpecularMaterial({

       // Channels with default values, just to show them

       diffuse: [1.0, 1.0, 1.0],
       specular: [1.0, 1.0, 1.0],
       glossiness: 1.0,
       emissive: [0.0, 0.0, 0.0]
       alpha: 1.0,

       // Textures to multiply some of the channels

       diffuseMap: {       // RGB components multiply by diffuse
           src: "textures/materials/poligon/Plaster07_1k/Plaster07_COL_VAR1_1K.jpg"
       },
       specularMap: {      // RGB component multiplies by specular
           src: "textures/materials/poligon/Plaster07_1k/Plaster07_REFL_1K.jpg"
       },
       glossinessMap: {    // R component multiplies by glossiness
           src: "textures/materials/poligon/Plaster07_1k/Plaster07_GLOSS_1K.jpg"
       },
       normalMap: {
           src: "textures/materials/poligon/Plaster07_1k/Plaster07_NRM_1K.jpg"
       }
   })
});

Combining channels within the same textures

In the previous example we provided separate Textures for the specular and glossiness channels, but we can combine those channels into the same Texture to reduce download time, memory footprint and rendering time (and also for glTF compatibility).

Here's our SpecularMaterial again with those channels combined in the specularGlossinessMap Texture, where the RGB component multiplies by specular and A multiplies by glossiness.

plasteredSphere.material = new xeogl.SpecularMaterial({

   // Default values
   diffuse: [1.0, 1.0, 1.0],
   specular: [1.0, 1.0, 1.0],
   glossiness: 1.0,
   emissive: [0.0, 0.0, 0.0]
   alpha: 1.0,

   diffuseMap: {
       src: "textures/materials/poligon/Plaster07_1k/Plaster07_COL_VAR1_1K.jpg"
   },
   specularGlossinessMap: { // RGB multiplies by specular, A by glossiness
       src: "textures/materials/poligon/Plaster07_1k/Plaster07_REFL_GLOSS_1K.jpg"
   },
   normalMap: {
       src: "textures/materials/poligon/Plaster07_1k/Plaster07_NRM_1K.jpg"
   }
});

Although not shown in this example, we can also texture alpha with the A component of diffuseMap's Texture, if required.

Transparency

Alpha Blending

Let's make our plastered sphere transparent. We'll update its SpecularMaterial's alpha and alphaMode, causing it to blend 50% with the background:

plasteredSphere.material.alpha = 0.5;
plasteredSphere.material.alphaMode = "blend";

TODO: Screenshot

Alpha Masking

Now let's make holes in our plastered sphere. We'll give its SpecularMaterial an alphaMap and configure alpha, alphaMode, and alphaCutoff to treat it as an alpha mask:

plasteredSphere.material.alphaMap = new xeogl.Texture({
       src: "textures/diffuse/crossGridColorMap.jpg"
   });

plasteredSphere.material.alpha = 1.0;
plasteredSphere.material.alphaMode = "mask";
plasteredSphere.material.alphaCutoff = 0.2;

TODO: Screenshot

Constructor

SpecularMaterial

(
  • [scene]
  • [cfg]
)

Parameters:

  • [scene] Scene optional

    Parent Scene, creates this SpecularMaterial within the default Scene when omitted

  • [cfg] optional

    The SpecularMaterial configuration

    • [id] String optional

      Optional ID, unique among all components in the parent Scene, generated automatically when omitted.

    • [meta=null] String:Object optional

      Metadata to attach to this SpecularMaterial.

    • [diffuse=[1,1,1]] Float32Array optional

      RGB diffuse color of this SpecularMaterial. Multiplies by the RGB components of diffuseMap.

    • [diffuseMap=undefined] Texture optional

      RGBA Texture containing the diffuse color of this SpecularMaterial, with optional A component for alpha. The RGB components multiply by the diffuse property, while the A component, if present, multiplies by the alpha property.

    • [specular=[1,1,1]] Number optional

      RGB specular color of this SpecularMaterial. Multiplies by the specularMap and the RGB components of specularGlossinessMap.

    • [specularMap=undefined] Texture optional

      RGB texture containing the specular color of this SpecularMaterial. Multiplies by the specular property. Must be within the same Scene as this SpecularMaterial.

    • [glossiness=1.0] Factor in the range [0..1] Number optional

      indicating how glossy this SpecularMaterial is. 0 is no glossiness, 1 is full glossiness. Multiplies by the R component of glossinessMap and the A component of specularGlossinessMap.

    • [specularGlossinessMap=undefined] Texture optional

      RGBA Texture containing this SpecularMaterial's specular color in its RGB component and glossiness in its A component. Its RGB components multiply by the specular property, while its A component multiplies by the glossiness property. Must be within the same Scene as this SpecularMaterial.

    • [specularF0=0.0] Number optional

      Factor in the range 0..1 indicating how reflective this SpecularMaterial is.

    • [emissive=[0,0,0]] Float32Array optional

      RGB emissive color of this SpecularMaterial. Multiplies by the RGB components of emissiveMap.

    • [emissiveMap=undefined] Texture optional

      RGB Texture containing the emissive color of this SpecularMaterial. Multiplies by the emissive property. Must be within the same Scene as this SpecularMaterial.

    • [occlusionMap=undefined] Texture optional

      RGB ambient occlusion Texture. Within shaders, multiplies by the specular and diffuse light reflected by surfaces. Must be within the same Scene as this SpecularMaterial.

    • [normalMap=undefined] Texture optional

      RGB tangent-space normal Texture. Must be within the same Scene as this SpecularMaterial.

    • [alpha=1.0] Number optional

      Factor in the range 0..1 indicating how transparent this SpecularMaterial is. A value of 0.0 indicates fully transparent, 1.0 is fully opaque. Multiplies by the R component of alphaMap and the A component, if present, of diffuseMap.

    • [alphaMap=undefined] Texture optional

      RGB Texture containing this SpecularMaterial's alpha in its R component. The R component multiplies by the alpha property. Must be within the same Scene as this SpecularMaterial.

    • [alphaMode="opaque"] String optional

      The alpha blend mode - accepted values are "opaque", "blend" and "mask". See the alphaMode property for more info.

    • [alphaCutoff=0.5] Number optional

      The alpha cutoff value. See the alphaCutoff property for more info.

    • [backfaces=false] Boolean optional

      Whether to render Geometry backfaces.

    • [frontface="ccw"] Boolean optional

      The winding order for Geometry front faces - "cw" for clockwise, or "ccw" for counter-clockwise.

Methods

create

(
  • [cfg]
  • [instanceId]
)

Convenience method for creating a Component within this Component's Scene.

You would typically use this method to conveniently instantiate components that you'd want to share (ie. "instance") among your Entities.

The method is given a component type, configuration and optional instance ID, like so:

var material = myComponent.create({
     type: "xeogl.PhongMaterial",
     diffuse: [1,0,0],
     specular: [1,1,0]
}, "myMaterial");

The first time you call this method for the given type and instanceId, this method will create the PhongMaterial, passing the given attributes to the component's constructor.

If you call this method again, specifying the same type and instanceId, the method will return the same component instance that it returned the first time, and will ignore the new configuration:

var material2 = component.create({ type: "xeogl.PhongMaterial", specular: [1,1,0] }, "myMaterial");

So in this example, our PhongMaterial will continue to have the red specular and diffuse color that we specified the first time.

Each time you call this method with the same type and instanceId, the Scene will internally increment a reference count for the component instance.

Parameters:

  • [cfg] optional

    Configuration for the component instance - only used if this is the first time you are getting the component, ignored when reusing an existing instance.

  • [instanceId] String | Number optional

    Identifies the shared component instance. Note that this is not used as the ID of the component - you can specify the component ID in the cfg parameter.

Returns:

:

destroy

()

Destroys this component.

Fires a destroyed event on this Component.

Automatically disassociates this component from other components, causing them to fall back on any defaults that this component overrode on them.

TODO: describe effect with respect to #create

error

(
  • message
)

Logs an error for this component to the JavaScript console.

The console message will have this format: [ERROR] [<component type> =<component id>: <message>

Also fires the message as an error event on the parent Scene.

Parameters:

  • message String

    The message to log

fire

(
  • event
  • value
  • [forget=false]
)

Fires an event on this component.

Notifies existing subscribers to the event, optionally retains the event to give to any subsequent notifications on the event as they are made.

Parameters:

  • event String

    The event type name

  • value Object

    The event parameters

  • [forget=false] Boolean optional

    When true, does not retain for subsequent subscribers

hasSubs

(
  • event
)
Boolean

Returns true if there are any subscribers to the given event on this component.

Parameters:

  • event String

    The event

Returns:

Boolean:

True if there are any subscribers to the given event on this component.

isType

(
  • type
)
Boolean

Tests if this component is of the given type, or is a subclass of the given type.

The type may be given as either a string or a component constructor.

This method works by walking up the inheritance type chain, which this component provides in property superTypes, returning true as soon as one of the type strings in the chain matches the given type, of false if none match.

Examples:

var myRotate = new xeogl.Rotate({ ... });

myRotate.isType(xeogl.Component); // Returns true for all xeogl components
myRotate.isType("xeogl.Component"); // Returns true for all xeogl components
myRotate.isType(xeogl.Rotate); // Returns true
myRotate.isType(xeogl.Transform); // Returns true
myRotate.isType("xeogl.Transform"); // Returns true
myRotate.isType(xeogl.Entity); // Returns false, because xeogl.Rotate does not (even indirectly) extend xeogl.Entity

Parameters:

  • type String | Function

    Component type to compare with, eg "xeogl.PhongMaterial", or a xeogl component constructor.

Returns:

Boolean:

True if this component is of given type or is subclass of the given type.

log

(
  • message
)

Logs a console debugging message for this component.

The console message will have this format: [LOG] [<component type> <component id>: <message>

Also fires the message as a log event on the parent Scene.

Parameters:

  • message String

    The message to log

off

(
  • handle
)

Cancels an event subscription that was previously made with on or once.

Parameters:

  • handle String

    Publication handle

on

(
  • event
  • callback
  • [scope=this]
)
String

Subscribes to an event on this component.

The callback is be called with this component as scope.

Parameters:

  • event String

    The event

  • callback Function

    Called fired on the event

  • [scope=this] Object optional

    Scope for the callback

Returns:

String:

Handle to the subscription, which may be used to unsubscribe with {@link #off}.

once

(
  • event
  • callback
  • [scope=this]
)

Subscribes to the next occurrence of the given event, then un-subscribes as soon as the event is handled.

This is equivalent to calling on, and then calling off inside the callback function.

Parameters:

  • event String

    Data event to listen to

  • callback Function(data)

    Called when fresh data is available at the event

  • [scope=this] Object optional

    Scope for the callback

warn

(
  • message
)

Logs a warning for this component to the JavaScript console.

The console message will have this format: [WARN] [<component type> =<component id>: <message>

Also fires the message as a warn event on the parent Scene.

Parameters:

  • message String

    The message to log

Properties

alpha

Number

Factor in the range [0..1] indicating how transparent this SpecularMaterial is.

A value of 0.0 is fully transparent, while 1.0 is fully opaque.

Multiplies by the R component of alphaMap and the A component, if present, of diffuseMap.

Fires an alpha event on change.

Default: 1.0

alphaCutoff

Number

The alpha cutoff value.

Specifies the cutoff threshold when alphaMode equals "mask". If the alpha is greater than or equal to this value then it is rendered as fully opaque, otherwise, it is rendered as fully transparent. A value greater than 1.0 will render the entire material as fully transparent. This value is ignored for other modes.

Alpha is the combined result of the alpha and alphaMap properties.

Fires an alphaCutoff event on change.

Default: 0.5

alphaMap

Texture

RGB Texture with alpha in its R component.

The R component multiplies by the alpha property.

Must be within the same Scene as this SpecularMaterial.

Fires an alphaMap event on change.

Default: undefined

alphaMode

String

The alpha rendering mode.

This governs how alpha is treated. Alpha is the combined result of the alpha and alphaMap properties.

  • "opaque" - The alpha value is ignored and the rendered output is fully opaque.
  • "mask" - The rendered output is either fully opaque or fully transparent depending on the alpha value and the specified alpha cutoff value.
  • "blend" - The alpha value is used to composite the source and destination areas. The rendered output is combined with the background using the normal painting operation (i.e. the Porter and Duff over operator).

Fires an alphaMode event on change.

Default: "opaque"

backfaces

Boolean

Whether backfaces are visible on attached Entities.

The backfaces will belong to Geometry compoents that are also attached to the Entities.

Fires a backfaces event on change.

Default: false

destroyed

Boolean

True as soon as this Component has been destroyed

diffuse

Float32Array

RGB diffuse color of this SpecularMaterial.

Multiplies by the RGB components of diffuseMap.

Fires a diffuse event on change.

Default: [1.0, 1.0, 1.0]

diffuseMap

Texture

RGB Texture containing the diffuse color of this SpecularMaterial, with optional A component for alpha.

The RGB components multiply by the diffuse property, while the A component, if present, multiplies by the alpha property.

Must be within the same Scene as this SpecularMaterial.

Fires a diffuseMap event on change.

Default: undefined

emissive

Float32Array

RGB emissive color of this SpecularMaterial.

Multiplies by emissiveMap.

Fires a emissive event on change.

Default: [0.0, 0.0, 0.0]

emissiveMap

Texture

RGB texture containing the emissive color of this SpecularMaterial.

Multiplies by the emissive property.

Must be within the same Scene as this SpecularMaterial.

Fires a emissiveMap event on change.

Default: undefined

frontface

String

Indicates the winding direction of front faces on attached Entities.

The faces will belong to Geometry components that are also attached to the Entities.

Fires a frontface event on change.

Default: "ccw"

glossiness

Number

Factor in the range [0..1] indicating how glossy this SpecularMaterial is.

0 is no glossiness, 1 is full glossiness.

Multiplies by the R component of glossinessMap and the A component of specularGlossinessMap.

Fires a glossiness event on change.

Default: 1.0

glossinessMap

Texture

RGB texture containing this SpecularMaterial's glossiness in its R component.

The R component multiplies by the glossiness property.

Must be within the same Scene as this SpecularMaterial.

Fires a glossinessMap event on change.

Default: undefined

id

String final

Unique ID for this Component within its parent Scene.

isDefault

Boolean

Indicates whether this is one of the Scene's built-in Components.

json

JSON final

JSON object containing the state of this Component.

metadata

Object

Arbitrary, user-defined metadata on this component.

normalMap

Texture

RGB tangent-space normal Texture attached to this SpecularMaterial.

Must be within the same Scene as this SpecularMaterial.

Fires a normalMap event on change.

Default: undefined

occlusionMap

Texture

RGB ambient occlusion Texture attached to this SpecularMaterial.

Within shaders, multiplies by the specular and diffuse light reflected by surfaces.

Must be within the same Scene as this SpecularMaterial.

Fires a occlusionMap event on change.

Default: undefined

scene

Scene final

The parent Scene that contains this Component.

specular

Float32Array

RGB specular color of this SpecularMaterial.

Multiplies by the specularMap and the A component of specularGlossinessMap.

Fires a specular event on change.

Default: [1.0, 1.0, 1.0]

specularF0

Number

Factor in the range [0..1] indicating amount of specular Fresnel.

Fires a specularF0 event on change.

Default: 0.0

specularGlossinessMap

Texture

RGBA texture containing this SpecularMaterial's specular color in its RGB components and glossiness in its A component.

The RGB components multiply by the specular property, while the A component multiplies by the glossiness property.

Must be within the same Scene as this SpecularMaterial.

Fires a specularGlossinessMap event on change.

Default: undefined

specularMap

Texture

RGB texture containing the specular color of this SpecularMaterial.

Multiplies by the specular property.

Must be within the same Scene as this SpecularMaterial.

Fires a specularMap event on change.

Default: undefined

string

String final

Inherited from Component but overwritten in src/component.js:1065

String containing the serialized JSON state of this Component.

superTypes

Array of String final

An array of strings that indicates the chain of super-types within this component's inheritance hierarchy.

For example, if this component is a Rotate, which extends Transform, which in turn extends Component, then this property will have the value:

["xeogl.Component", "xeogl.Transform"]
                    

Note that the chain is ordered downwards in the hierarchy, ie. from super-class down towards sub-class.

type

String final

JavaScript class name for this Component.

This is used when loading Scenes from JSON, and is included in the JSON representation of this Component, so that this class may be instantiated when loading it from the JSON representation.

For example: "xeogl.AmbientLight", "xeogl.ColorTarget", "xeogl.Lights" etc.

Events

alpha

Fired whenever this SpecularMaterial's alpha property changes.

Event Payload:

  • value Number

    The property's new value

alphaCutoff

Fired whenever this SpecularMaterial's SpecularMaterial/look:property property changes.

Event Payload:

  • value Number

    The property's new value

alphaMap

Fired whenever this SpecularMaterial's alphaMap property changes.

Event Payload:

  • value Object

    Number The property's new value

alphaMode

Fired whenever this SpecularMaterial's alphaMode property changes.

Event Payload:

  • value Number

    The property's new value

backfaces

Fired whenever this SpecularMaterial's backfaces property changes.

Event Payload:

  • value Object

    The property's new value

destroyed

Fired when this Component is destroyed.

diffuse

Fired whenever this SpecularMaterial's diffuse property changes.

Event Payload:

  • value Float32Array

    The property's new value

diffuseMap

Fired whenever this SpecularMaterial's diffuseMap property changes.

Event Payload:

  • value Object

    Number The property's new value

emissive

Fired whenever this SpecularMaterial's emissive property changes.

Event Payload:

  • value Float32Array

    The property's new value

emissiveMap

Fired whenever this SpecularMaterial's emissiveMap property changes.

Event Payload:

  • value Object

    Number The property's new value

frontface

Fired whenever this SpecularMaterial's frontface property changes.

Event Payload:

  • value Object

    The property's new value

glossiness

Fired whenever this SpecularMaterial's glossiness property changes.

Event Payload:

  • value Number

    The property's new value

glossinessMap

Fired whenever this SpecularMaterial's glossinessMap property changes.

Event Payload:

  • value Object

    Number The property's new value

normalMap

Fired whenever this PhongMaterial's normalMap property changes.

Event Payload:

  • value Object

    Number The property's new value

occlusionMap

Fired whenever this SpecularMaterial's occlusionMap property changes.

Event Payload:

  • value Object

    Number The property's new value

specular

Fired whenever this SpecularMaterial's specular property changes.

Event Payload:

  • value Float32Array

    The property's new value

specularF0

Fired whenever this SpecularMaterial's specularF0 property changes.

Event Payload:

  • value Float32Array

    The property's new value

specularGlossinessMap

Fired whenever this SpecularMaterial's specularGlossinessMap property changes.

Event Payload:

  • value Object

    Number The property's new value

specularMap

Fired whenever this SpecularMaterial's specularGlossinessMap property changes.

Event Payload:

  • value Object

    Number The property's new value