// Create a new Standard material
var material = new pc.StandardMaterial();

// Update the material's diffuse and specular properties
material.diffuse.set(1, 0, 0);
material.specular.set(1, 1, 1);

// Notify the material that it has been modified
material.update();

// Create a new Standard material
var material = new pc.StandardMaterial();

// Assign a texture to the diffuse slot
material.diffuseMap = texture;

// Use the alpha channel of the texture for alpha testing with a reference value of 0.5
material.opacityMap = texture;
material.alphaTest = 0.5;

// Notify the material that it has been modified
material.update();

StandardMaterial() 

Create a new StandardMaterial instance.

// Create a new Standard material
var material = new pc.StandardMaterial();

// Update the material's diffuse and specular properties
material.diffuse.set(1, 0, 0);
material.specular.set(1, 1, 1);

// Notify the material that it has been modified
material.update();

// Create a new Standard material
var material = new pc.StandardMaterial();

// Assign a texture to the diffuse slot
material.diffuseMap = texture;

// Use the alpha channel of the texture for alpha testing with a reference value of 0.5
material.opacityMap = texture;
material.alphaTest = 0.5;

// Notify the material that it has been modified
material.update();

numberalphaFade 

used to fade out materials when StandardMaterial#opacityFadesSpecular is set to false.

Colorambient 

The ambient color of the material. This color value is 3-component (RGB), where each component is between 0 and 1.

booleanambientTint 

Enables scene ambient multiplication by material ambient color.

numberanisotropy 

Defines amount of anisotropy. Requires StandardMaterial#enableGGXSpecular is set to true.

• When anisotropy == 0, specular is isotropic.
• When anisotropy < 0, anisotropy direction aligns with the tangent, and specular anisotropy increases as the anisotropy value decreases to minimum of -1.
• When anisotropy > 0, anisotropy direction aligns with the bi-normal, and specular anisotropy increases as anisotropy value increases to maximum of 1.

Texture, nullaoMap 

Baked ambient occlusion (AO) map (default is null). Modulates ambient color.

stringaoMapChannel 

Color channel of the AO map to use. Can be "r", "g", "b" or "a".

Vec2aoMapOffset 

Controls the 2D offset of the AO map. Each component is between 0 and 1.

numberaoMapRotation 

Controls the 2D rotation (in degrees) of the AO map.

Vec2aoMapTiling 

Controls the 2D tiling of the AO map.

numberaoMapUv 

AO map UV channel

booleanaoVertexColor 

Use mesh vertex colors for AO. If aoMap is set, it'll be multiplied by vertex colors.

stringaoVertexColorChannel 

Vertex color channels to use for AO. Can be "r", "g", "b" or "a".

numberbumpiness 

The bumpiness of the material. This value scales the assigned main (primary) normal map. It should be normally between 0 (no bump mapping) and 1 (full bump mapping), but can be set to e.g. 2 to give even more pronounced bump effect.

{ [string]: string }chunks 

Object containing custom shader chunks that will replace default ones.

numberclearCoat 

Defines intensity of clear coat layer from 0 to 1. Clear coat layer is disabled when clearCoat == 0. Default value is 0 (disabled).

numberclearCoatBumpiness 

The bumpiness of the clear coat layer. This value scales the assigned main clear coat normal map. It should be normally between 0 (no bump mapping) and 1 (full bump mapping), but can be set to e.g. 2 to give even more pronounced bump effect.

Texture, nullclearCoatGlossMap 

Monochrome clear coat glossiness map (default is null). If specified, will be multiplied by normalized 'clearCoatGlossiness' value and/or vertex colors.

stringclearCoatGlossMapChannel 

Color channel of the clear coat gloss map to use. Can be "r", "g", "b" or "a".

Vec2clearCoatGlossMapOffset 

Controls the 2D offset of the clear coat gloss map. Each component is between 0 and 1.

numberclearCoatGlossMapRotation 

Controls the 2D rotation (in degrees) of the clear coat gloss map.

Vec2clearCoatGlossMapTiling 

Controls the 2D tiling of the clear coat gloss map.

numberclearCoatGlossMapUv 

Clear coat gloss map UV channel.

booleanclearCoatGlossVertexColor 

Use mesh vertex colors for clear coat glossiness. If clearCoatGlossMap is set, it'll be multiplied by vertex colors.

stringclearCoatGlossVertexColorChannel 

Vertex color channel to use for clear coat glossiness. Can be "r", "g", "b" or "a".

numberclearCoatGlossiness 

Defines the clear coat glossiness of the clear coat layer from 0 (rough) to 1 (mirror).

Texture, nullclearCoatMap 

Monochrome clear coat intensity map (default is null). If specified, will be multiplied by normalized 'clearCoat' value and/or vertex colors.

stringclearCoatMapChannel 

Color channel of the clear coat intensity map to use. Can be "r", "g", "b" or "a".

Vec2clearCoatMapOffset 

Controls the 2D offset of the clear coat intensity map. Each component is between 0 and 1.

numberclearCoatMapRotation 

Controls the 2D rotation (in degrees) of the clear coat intensity map.

Vec2clearCoatMapTiling 

Controls the 2D tiling of the clear coat intensity map.

numberclearCoatMapUv 

Clear coat intensity map UV channel.

Texture, nullclearCoatNormalMap 

The clear coat normal map of the material (default is null). The texture must contains normalized, tangent space normals.

Vec2clearCoatNormalMapOffset 

Controls the 2D offset of the main clear coat normal map. Each component is between 0 and 1.

numberclearCoatNormalMapRotation 

Controls the 2D rotation (in degrees) of the main clear coat map.

Vec2clearCoatNormalMapTiling 

Controls the 2D tiling of the main clear coat normal map.

numberclearCoatNormalMapUv 

Clear coat normal map UV channel.

booleanclearCoatVertexColor 

Use mesh vertex colors for clear coat intensity. If clearCoatMap is set, it'll be multiplied by vertex colors.

stringclearCoatVertexColorChannel 

Vertex color channel to use for clear coat intensity. Can be "r", "g", "b" or "a".

booleanconserveEnergy 

Defines how diffuse and specular components are combined when Fresnel is on. It is recommended that you leave this option enabled, although you may want to disable it in case when all reflection comes only from a few light sources, and you don't use an environment map, therefore having mostly black reflection.

Texture, nullcubeMap 

The cubic environment map of the material (default is null). Overrides sphereMap. Affects reflections. If cubemap is prefiltered, will also affect ambient color.

numbercubeMapProjection 

The type of projection applied to the cubeMap property:

• CUBEPROJ_NONE: The cube map is treated as if it is infinitely far away.
• CUBEPROJ_BOX: Box-projection based on a world space axis-aligned bounding box. Defaults to CUBEPROJ_NONE.

BoundingBoxcubeMapProjectionBox 

The world space axis-aligned bounding box defining the box-projection used for the cubeMap property. Only used when cubeMapProjection is set to CUBEPROJ_BOX.

Colordiffuse 

The diffuse color of the material. This color value is 3-component (RGB), where each component is between 0 and 1. Defines basic surface color (aka albedo).

Texture, nulldiffuseDetailMap 

The detail (secondary) diffuse map of the material (default is null). Will only be used if main (primary) diffuse map is non-null.

stringdiffuseDetailMapChannel 

Color channels of the detail (secondary) diffuse map to use. Can be "r", "g", "b", "a", "rgb" or any swizzled combination.

Vec2diffuseDetailMapOffset 

Controls the 2D offset of the detail (secondary) diffuse map. Each component is between 0 and 1.

numberdiffuseDetailMapRotation 

Controls the 2D rotation (in degrees) of the main (secondary) diffuse map.

Vec2diffuseDetailMapTiling 

Controls the 2D tiling of the detail (secondary) diffuse map.

numberdiffuseDetailMapUv 

Detail (secondary) diffuse map UV channel.

stringdiffuseDetailMode 

Determines how the main (primary) and detail (secondary) diffuse maps are blended together. Can be:

• DETAILMODE_MUL: Multiply together the primary and secondary colors.
• DETAILMODE_ADD: Add together the primary and secondary colors.
• DETAILMODE_SCREEN: Softer version of DETAILMODE_ADD.
• DETAILMODE_OVERLAY: Multiplies or screens the colors, depending on the primary color.
• DETAILMODE_MIN: Select whichever of the primary and secondary colors is darker, component-wise.
• DETAILMODE_MAX: Select whichever of the primary and secondary colors is lighter, component-wise.

Defaults to DETAILMODE_MUL.

Texture, nulldiffuseMap 

The main (primary) diffuse map of the material (default is null).

stringdiffuseMapChannel 

Color channels of the main (primary) diffuse map to use. Can be "r", "g", "b", "a", "rgb" or any swizzled combination.

Vec2diffuseMapOffset 

Controls the 2D offset of the main (primary) diffuse map. Each component is between 0 and 1.

numberdiffuseMapRotation 

Controls the 2D rotation (in degrees) of the main (primary) diffuse map.

Vec2diffuseMapTiling 

Controls the 2D tiling of the main (primary) diffuse map.

numberdiffuseMapUv 

Main (primary) diffuse map UV channel.

booleandiffuseTint 

Multiply main (primary) diffuse map and/or diffuse vertex color by the constant diffuse value.

booleandiffuseVertexColor 

Use mesh vertex colors for diffuse. If diffuseMap or are diffuseTint are set, they'll be multiplied by vertex colors.

stringdiffuseVertexColorChannel 

Vertex color channels to use for diffuse. Can be "r", "g", "b", "a", "rgb" or any swizzled combination.

Coloremissive 

The emissive color of the material. This color value is 3-component (RGB), where each component is between 0 and 1.

numberemissiveIntensity 

Emissive color multiplier.

Texture, nullemissiveMap 

The emissive map of the material (default is null). Can be HDR.

stringemissiveMapChannel 

Color channels of the emissive map to use. Can be "r", "g", "b", "a", "rgb" or any swizzled combination.

Vec2emissiveMapOffset 

Controls the 2D offset of the emissive map. Each component is between 0 and 1.

numberemissiveMapRotation 

Controls the 2D rotation (in degrees) of the emissive map.

Vec2emissiveMapTiling 

Controls the 2D tiling of the emissive map.

numberemissiveMapUv 

Emissive map UV channel.

booleanemissiveTint 

Multiply emissive map and/or emissive vertex color by the constant emissive value.

booleanemissiveVertexColor 

Use mesh vertex colors for emission. If emissiveMap or emissiveTint are set, they'll be multiplied by vertex colors.

stringemissiveVertexColorChannel 

Vertex color channels to use for emission. Can be "r", "g", "b", "a", "rgb" or any swizzled combination.

booleanenableGGXSpecular 

Enables GGX specular. Also enables StandardMaterial#anisotropy parameter to set material anisotropy.

numberfresnelModel 

Defines the formula used for Fresnel effect. As a side-effect, enabling any Fresnel model changes the way diffuse and reflection components are combined. When Fresnel is off, legacy non energy-conserving combining is used. When it is on, combining behavior is defined by conserveEnergy parameter.

• FRESNEL_NONE: No Fresnel.
• FRESNEL_SCHLICK: Schlick's approximation of Fresnel (recommended). Parameterized by specular color.

Texture, nullglossMap 

Glossiness map (default is null). If specified, will be multiplied by normalized 'shininess' value and/or vertex colors.

stringglossMapChannel 

Color channel of the gloss map to use. Can be "r", "g", "b" or "a".

Vec2glossMapOffset 

Controls the 2D offset of the gloss map. Each component is between 0 and 1.

numberglossMapRotation 

Controls the 2D rotation (in degrees) of the gloss map.

Vec2glossMapTiling 

Controls the 2D tiling of the gloss map.

numberglossMapUv 

Gloss map UV channel.

booleanglossVertexColor 

Use mesh vertex colors for glossiness. If glossMap is set, it'll be multiplied by vertex colors.

stringglossVertexColorChannel 

Vertex color channel to use for glossiness. Can be "r", "g", "b" or "a".

Texture, nullheightMap 

The height map of the material (default is null). Used for a view-dependent parallax effect. The texture must represent the height of the surface where darker pixels are lower and lighter pixels are higher. It is recommended to use it together with a normal map.

stringheightMapChannel 

Color channel of the height map to use. Can be "r", "g", "b" or "a".

numberheightMapFactor 

Height map multiplier. Affects the strength of the parallax effect.

Vec2heightMapOffset 

Controls the 2D offset of the height map. Each component is between 0 and 1.

numberheightMapRotation 

Controls the 2D rotation (in degrees) of the height map.

Vec2heightMapTiling 

Controls the 2D tiling of the height map.

numberheightMapUv 

Height map UV channel.

Texture, nulllightMap 

A custom lightmap of the material (default is null). Lightmaps are textures that contain pre-rendered lighting. Can be HDR.

stringlightMapChannel 

Color channels of the lightmap to use. Can be "r", "g", "b", "a", "rgb" or any swizzled combination.

Vec2lightMapOffset 

Controls the 2D offset of the lightmap. Each component is between 0 and 1.

numberlightMapRotation 

Controls the 2D rotation (in degrees) of the lightmap.

Vec2lightMapTiling 

Controls the 2D tiling of the lightmap.

numberlightMapUv 

Lightmap UV channel

booleanlightVertexColor 

Use baked vertex lighting. If lightMap is set, it'll be multiplied by vertex colors.

stringlightVertexColorChannel 

Vertex color channels to use for baked lighting. Can be "r", "g", "b", "a", "rgb" or any swizzled combination.

numbermetalness 

Defines how much the surface is metallic. From 0 (dielectric) to 1 (metal).

Texture, nullmetalnessMap 

Monochrome metalness map (default is null).

stringmetalnessMapChannel 

Color channel of the metalness map to use. Can be "r", "g", "b" or "a".

Vec2metalnessMapOffset 

Controls the 2D offset of the metalness map. Each component is between 0 and 1.

numbermetalnessMapRotation 

Controls the 2D rotation (in degrees) of the metalness map.

Vec2metalnessMapTiling 

Controls the 2D tiling of the metalness map.

numbermetalnessMapUv 

Metalness map UV channel.

booleanmetalnessVertexColor 

Use mesh vertex colors for metalness. If metalnessMap is set, it'll be multiplied by vertex colors.

stringmetalnessVertexColorChannel 

Vertex color channel to use for metalness. Can be "r", "g", "b" or "a".

Texture, nullnormalDetailMap 

The detail (secondary) normal map of the material (default is null). Will only be used if main (primary) normal map is non-null.

numbernormalDetailMapBumpiness 

The bumpiness of the material. This value scales the assigned detail (secondary) normal map. It should be normally between 0 (no bump mapping) and 1 (full bump mapping), but can be set to e.g. 2 to give even more pronounced bump effect.

Vec2normalDetailMapOffset 

Controls the 2D offset of the detail (secondary) normal map. Each component is between 0 and 1.

numbernormalDetailMapRotation 

Controls the 2D rotation (in degrees) of the detail (secondary) normal map.

Vec2normalDetailMapTiling 

Controls the 2D tiling of the detail (secondary) normal map.

numbernormalDetailMapUv 

Detail (secondary) normal map UV channel.

Texture, nullnormalMap 

The main (primary) normal map of the material (default is null). The texture must contains normalized, tangent space normals.

Vec2normalMapOffset 

Controls the 2D offset of the main (primary) normal map. Each component is between 0 and 1.

numbernormalMapRotation 

Controls the 2D rotation (in degrees) of the main (primary) normal map.

Vec2normalMapTiling 

Controls the 2D tiling of the main (primary) normal map.

numbernormalMapUv 

Main (primary) normal map UV channel.

booleanoccludeDirect 

Tells if AO should darken directional lighting. Defaults to false.

numberoccludeSpecular 

Uses ambient occlusion to darken specular/reflection. It's a hack, because real specular occlusion is view-dependent. However, it can be better than nothing.

• SPECOCC_NONE: No specular occlusion
• SPECOCC_AO: Use AO directly to occlude specular.
• SPECOCC_GLOSSDEPENDENT: Modify AO based on material glossiness/view angle to occlude specular.

numberoccludeSpecularIntensity 

Controls visibility of specular occlusion.

UpdateShaderCallbackonUpdateShader 

A custom function that will be called after all shader generator properties are collected and before shader code is generated. This function will receive an object with shader generator settings (based on current material and scene properties), that you can change and then return. Returned value will be used instead. This is mostly useful when rendering the same set of objects, but with different shader variations based on the same material. For example, you may wish to render a depth or normal pass using textures assigned to the material, a reflection pass with simpler shaders and so on. Properties of the object passed into this function are:

• pass: value of Layer#shaderPass of the Layer being rendered.
• chunks: Object containing custom shader chunks that will replace default ones.
• customFragmentShader: Completely replace fragment shader with this code.
• forceUv1: if UV1 (second set of texture coordinates) is required in the shader. Will be declared as "vUv1" and passed to the fragment shader.
• fog: the type of fog being applied in the shader. See Scene#fog for the list of possible values.
• gamma: the type of gamma correction being applied in the shader. See Scene#gammaCorrection for the list of possible values.
• toneMap: the type of tone mapping being applied in the shader. See Scene#toneMapping for the list of possible values.
• ambientTint: the value of StandardMaterial#ambientTint.
• specularAntialias: the value of StandardMaterial#specularAntialias.
• conserveEnergy: the value of StandardMaterial#conserveEnergy.
• occludeSpecular: the value of StandardMaterial#occludeSpecular.
• occludeDirect: the value of StandardMaterial#occludeDirect.
• shadingModel: the value of StandardMaterial#shadingModel.
• fresnelModel: the value of StandardMaterial#fresnelModel.
• cubeMapProjection: the value of StandardMaterial#cubeMapProjection.
• useMetalness: the value of StandardMaterial#useMetalness.
• blendType: the value of Material#blendType.
• twoSidedLighting: the value of Material#twoSidedLighting.
• diffuseTint: defines if StandardMaterial#diffuse constant should affect diffuse color.
• specularTint: defines if StandardMaterial#specular constant should affect specular color.
• metalnessTint: defines if StandardMaterial#metalness constant should affect metalness value.
• glossTint: defines if StandardMaterial#shininess constant should affect glossiness value.
• emissiveTint: defines if StandardMaterial#emissive constant should affect emission value.
• opacityTint: defines if StandardMaterial#opacity constant should affect opacity value.
• occludeSpecularFloat: defines if StandardMaterial#occludeSpecularIntensity constant should affect specular occlusion.
• alphaTest: enable alpha testing. See Material#alphaTest.
• alphaToCoverage: enable alpha to coverage. See Material#alphaToCoverage.
• opacityFadesSpecular: enable specular fade. See Material#opacityFadesSpecular.
• alphaFade: fade value. See Material#alphaFade.
• sphereMap: if StandardMaterial#sphereMap is used.
• cubeMap: if StandardMaterial#cubeMap is used.
• ambientSH: if ambient spherical harmonics are used. Ambient SH replace prefiltered cubemap ambient on certain platform (mostly Android) for performance reasons.
• useSpecular: if any specular or reflections are needed at all.
• fixSeams: if cubemaps require seam fixing (see Texture#options.fixCubemapSeams).
• emissiveFormat: how emissiveMap must be sampled. This value is based on Texture#options.rgbm and Texture#options.format. Possible values are:
  • 0: sRGB texture
  • 1: RGBM-encoded HDR texture
  • 2: Simple read (no conversion from sRGB)
• lightMapFormat: how lightMap must be sampled. This value is based on Texture#options.rgbm and Texture#options.format. Possible values are:
  • 0: sRGB texture
  • 1: RGBM-encoded HDR texture
  • 2: Simple read (no conversion from sRGB)
• useRgbm: if decodeRGBM() function is needed in the shader at all.
• packedNormal: if normal map contains X in RGB, Y in Alpha, and Z must be reconstructed.
• forceFragmentPrecision: Override fragment shader numeric precision. Can be "lowp", "mediump", "highp" or null to use default.
• fastTbn: Use slightly cheaper normal mapping code (skip tangent space normalization). Can look buggy sometimes.
• refraction: if refraction is used.
• skyboxIntensity: if reflected skybox intensity should be modulated.
• useCubeMapRotation: if cube map rotation is enabled.
• useInstancing: if hardware instancing compatible shader should be generated. Transform is read from per-instance VertexBuffer instead of shader's uniforms.
• useMorphPosition: if morphing code should be generated to morph positions.
• useMorphNormal: if morphing code should be generated to morph normals.
• reflectionSource: one of "envAtlas", "cubeMap", "sphereMap"
• reflectionEncoding: one of null, "rgbm", "rgbe", "linear", "srgb"
• ambientSource: one of "ambientSH", "envAtlas", "constant"
• ambientEncoding: one of null, "rgbm", "rgbe", "linear", "srgb"

numberopacity 

The opacity of the material. This value can be between 0 and 1, where 0 is fully transparent and 1 is fully opaque. If you want the material to be semi-transparent you also need to set the Material#blendType to BLEND_NORMAL, BLEND_ADDITIVE or any other mode. Also note that for most semi-transparent objects you want Material#depthWrite to be false, otherwise they can fully occlude objects behind them.

booleanopacityFadesSpecular 

used to specify whether specular and reflections are faded out using StandardMaterial#opacity. Default is true. When set to false use Material#alphaFade to fade out materials.

Texture, nullopacityMap 

The opacity map of the material (default is null).

stringopacityMapChannel 

Color channel of the opacity map to use. Can be "r", "g", "b" or "a".

Vec2opacityMapOffset 

Controls the 2D offset of the opacity map. Each component is between 0 and 1.

numberopacityMapRotation 

Controls the 2D rotation (in degrees) of the opacity map.

Vec2opacityMapTiling 

Controls the 2D tiling of the opacity map.

numberopacityMapUv 

Opacity map UV channel.

booleanopacityVertexColor 

Use mesh vertex colors for opacity. If opacityMap is set, it'll be multiplied by vertex colors.

stringopacityVertexColorChannel 

Vertex color channels to use for opacity. Can be "r", "g", "b" or "a".

booleanpixelSnap 

Align vertices to pixel coordinates when rendering. Useful for pixel perfect 2D graphics.

numberreflectivity 

Environment map intensity.

numberrefraction 

Defines the visibility of refraction. Material can refract the same cube map as used for reflections.

numberrefractionIndex 

Defines the index of refraction, i.e. The amount of distortion. The value is calculated as (outerIor / surfaceIor), where inputs are measured indices of refraction, the one around the object and the one of its own surface. In most situations outer medium is air, so outerIor will be approximately 1. Then you only need to do (1.0 / surfaceIor).

numbershadingModel 

Defines the shading model.

• SPECULAR_PHONG: Phong without energy conservation. You should only use it as a backwards compatibility with older projects.
• SPECULAR_BLINN: Energy-conserving Blinn-Phong.

numbershininess 

Defines glossiness of the material from 0 (rough) to 100 (shiny mirror). A higher shininess value results in a more focused specular highlight. Glossiness map/ vertex colors are always multiplied by this value (normalized to 0 - 1 range), or it is used directly as constant output.

Colorspecular 

The specular color of the material. This color value is 3-component (RGB), where each component is between 0 and 1. Defines surface reflection/specular color. Affects specular intensity and tint.

booleanspecularAntialias 

Enables Toksvig AA for mipmapped normal maps with specular.

Texture, nullspecularMap 

The specular map of the material (default is null).

stringspecularMapChannel 

Color channels of the specular map to use. Can be "r", "g", "b", "a", "rgb" or any swizzled combination.

Vec2specularMapOffset 

Controls the 2D offset of the specular map. Each component is between 0 and 1.

numberspecularMapRotation 

Controls the 2D rotation (in degrees) of the specular map.

Vec2specularMapTiling 

Controls the 2D tiling of the specular map.

numberspecularMapUv 

Specular map UV channel.

booleanspecularTint 

Multiply specular map and/or specular vertex color by the constant specular value.

booleanspecularVertexColor 

Use mesh vertex colors for specular. If specularMap or are specularTint are set, they'll be multiplied by vertex colors.

stringspecularVertexColorChannel 

Vertex color channels to use for specular. Can be "r", "g", "b", "a", "rgb" or any swizzled combination.

Texture, nullsphereMap 

The spherical environment map of the material (default is null). Affects reflections.

booleantwoSidedLighting 

Calculate proper normals (and therefore lighting) on backfaces.

booleanuseFog 

Apply fogging (as configured in scene settings)

booleanuseGammaTonemap 

Apply gamma correction and tonemapping (as configured in scene settings).

booleanuseLighting 

Apply lighting

booleanuseMetalness 

Use metalness properties instead of specular. When enabled, diffuse colors also affect specular instead of the dedicated specular map. This can be used as alternative to specular color to save space. With metaless == 0, the pixel is assumed to be dielectric, and diffuse color is used as normal. With metaless == 1, the pixel is fully metallic, and diffuse color is used as specular color instead.

booleanuseSkybox 

Apply scene skybox as prefiltered environment map

copy(source) 

Copy a StandardMaterial.

Parameters

source

StandardMaterial

The material to copy from.

Returns

StandardMaterial

The destination material.

destroy() 

Removes this material from the scene and possibly frees up memory from its shaders (if there are no other materials using it).

numberalphaTest 

The alpha test reference value to control which fragments are written to the currently active render target based on alpha value. All fragments with an alpha value of less than the alphaTest reference value will be discarded. alphaTest defaults to 0 (all fragments pass).

booleanalphaToCoverage 

Enables or disables alpha to coverage (WebGL2 only). When enabled, and if hardware anti-aliasing is on, limited order-independent transparency can be achieved. Quality depends on the number of MSAA samples of the current render target. It can nicely soften edges of otherwise sharp alpha cutouts, but isn't recommended for large area semi-transparent surfaces. Note, that you don't need to enable blending to make alpha to coverage work. It will work without it, just like alphaTest.

booleanalphaWrite 

If true, the alpha component of fragments generated by the shader of this material is written to the color buffer of the currently active render target. If false, the alpha component will not be written. Defaults to true.

numberblendType 

Controls how primitives are blended when being written to the currently active render target. Can be:

• BLEND_SUBTRACTIVE: Subtract the color of the source fragment from the destination fragment and write the result to the frame buffer.
• BLEND_ADDITIVE: Add the color of the source fragment to the destination fragment and write the result to the frame buffer.
• BLEND_NORMAL: Enable simple translucency for materials such as glass. This is equivalent to enabling a source blend mode of BLENDMODE_SRC_ALPHA and a destination blend mode of BLENDMODE_ONE_MINUS_SRC_ALPHA.
• BLEND_NONE: Disable blending.
• BLEND_PREMULTIPLIED: Similar to BLEND_NORMAL expect the source fragment is assumed to have already been multiplied by the source alpha value.
• BLEND_MULTIPLICATIVE: Multiply the color of the source fragment by the color of the destination fragment and write the result to the frame buffer.
• BLEND_ADDITIVEALPHA: Same as BLEND_ADDITIVE except the source RGB is multiplied by the source alpha.
• BLEND_MULTIPLICATIVE2X: Multiplies colors and doubles the result.
• BLEND_SCREEN: Softer version of additive.
• BLEND_MIN: Minimum color. Check app.graphicsDevice.extBlendMinmax for support.
• BLEND_MAX: Maximum color. Check app.graphicsDevice.extBlendMinmax for support.

Defaults to BLEND_NONE.

booleanblueWrite 

If true, the blue component of fragments generated by the shader of this material is written to the color buffer of the currently active render target. If false, the blue component will not be written. Defaults to true.

numbercull 

Controls how triangles are culled based on their face direction with respect to the viewpoint. Can be:

• CULLFACE_NONE: Do not cull triangles based on face direction.
• CULLFACE_BACK: Cull the back faces of triangles (do not render triangles facing away from the view point).
• CULLFACE_FRONT: Cull the front faces of triangles (do not render triangles facing towards the view point).
• CULLFACE_FRONTANDBACK: Cull both front and back faces (triangles will not be rendered).

Defaults to CULLFACE_BACK.

numberdepthBias 

Offsets the output depth buffer value. Useful for decals to prevent z-fighting.

numberdepthFunc 

Controls how the depth of new fragments is compared against the current depth contained in the depth buffer. Can be:

• FUNC_NEVER: don't draw
• FUNC_LESS: draw if new depth < depth buffer
• FUNC_EQUAL: draw if new depth == depth buffer
• FUNC_LESSEQUAL: draw if new depth <= depth buffer
• FUNC_GREATER: draw if new depth > depth buffer
• FUNC_NOTEQUAL: draw if new depth != depth buffer
• FUNC_GREATEREQUAL: draw if new depth >= depth buffer
• FUNC_ALWAYS: always draw

Defaults to FUNC_LESSEQUAL.

booleandepthTest 

If true, fragments generated by the shader of this material are only written to the current render target if they pass the depth test. If false, fragments generated by the shader of this material are written to the current render target regardless of what is in the depth buffer. Defaults to true.

booleandepthWrite 

If true, fragments generated by the shader of this material write a depth value to the depth buffer of the currently active render target. If false, no depth value is written. Defaults to true.

booleangreenWrite 

If true, the green component of fragments generated by the shader of this material is written to the color buffer of the currently active render target. If false, the green component will not be written. Defaults to true.

stringname 

The name of the material.

booleanredWrite 

If true, the red component of fragments generated by the shader of this material is written to the color buffer of the currently active render target. If false, the red component will not be written. Defaults to true.

Shader, nullshader 

The shader used by this material to render mesh instances (default is null).

numberslopeDepthBias 

Same as Material#depthBias, but also depends on the slope of the triangle relative to the camera.

StencilParameters, nullstencilBack 

Stencil parameters for back faces (default is null).

StencilParameters, nullstencilFront 

Stencil parameters for front faces (default is null).

clone() 

Clone a material.

Returns

this

A newly cloned material.

deleteParameter(name) 

Deletes a shader parameter on a material.

Parameters

name

string

The name of the parameter to delete.

getParameter(name) 

Retrieves the specified shader parameter from a material.

Parameters

name

string

The name of the parameter to query.

Returns

object

The named parameter.

setParameter(name, data) 

Sets a shader parameter on a material.

Parameters

name	string	The name of the parameter to set.
data	number, number[], Float32Array, Texture	The value for the specified parameter.

update() 

Applies any changes made to the material's properties.