@babylonjs/core
Version:
Getting started? Play directly with the Babylon.js API using our [playground](https://playground.babylonjs.com/). It also contains a lot of samples to learn how to use it.
690 lines (689 loc) • 156 kB
JavaScript
/** This file must only contain pure code and pure imports */
import { __classPrivateFieldGet, __classPrivateFieldSet, __esDecorate, __runInitializers } from "../tslib.es6.js";
import { serialize, serializeAsColor3, expandToProperty, serializeAsFresnelParameters, serializeAsTexture } from "../Misc/decorators.js";
import { SmartArray } from "../Misc/smartArray.js";
import { Scene } from "../scene.pure.js";
import { Color3, TmpColors } from "../Maths/math.color.pure.js";
import { VertexBuffer } from "../Buffers/buffer.pure.js";
import { PrePassConfiguration } from "./prePassConfiguration.js";
import { ImageProcessingDefinesMixin } from "./imageProcessingConfiguration.defines.js";
import { ImageProcessingConfiguration, RegisterImageProcessingConfiguration } from "./imageProcessingConfiguration.pure.js";
import { Material } from "../Materials/material.pure.js";
import { MaterialDefines } from "../Materials/materialDefines.js";
import { PushMaterial } from "./pushMaterial.js";
import { MaterialFlags } from "./materialFlags.js";
import { EffectFallbacks } from "./effectFallbacks.js";
import { DetailMapConfiguration } from "./material.detailMapConfiguration.js";
import { AddClipPlaneUniforms, BindClipPlane } from "./clipPlaneMaterialHelper.js";
import { PrepareVertexPullingUniforms, BindVertexPullingUniforms } from "./vertexPullingHelper.functions.js";
import { BindBonesParameters, BindFogParameters, BindLights, BindLogDepth, BindMorphTargetParameters, BindTextureMatrix, BindIBLParameters, HandleFallbacksForShadows, PrepareAttributesForBakedVertexAnimation, PrepareAttributesForBones, PrepareAttributesForInstances, PrepareAttributesForMorphTargets, PrepareDefinesForAttributes, PrepareDefinesForFrameBoundValues, PrepareDefinesForLights, PrepareDefinesForIBL, PrepareDefinesForMergedUV, PrepareDefinesForMisc, PrepareDefinesForMultiview, PrepareDefinesForOIT, PrepareDefinesForPrePass, PrepareUniformsAndSamplersForIBL, PrepareUniformsAndSamplersList, PrepareUniformLayoutForIBL, AreLightsTexturesReady, } from "./materialHelper.functions.js";
import { SerializationHelper } from "../Misc/decorators.serialization.js";
import { MaterialHelperGeometryRendering } from "./materialHelper.geometryrendering.js";
import { UVDefinesMixin } from "./uv.defines.js";
import { PrepassDefinesMixin } from "./prepass.defines.js";
import { ImageProcessingMixin } from "./imageProcessing.js";
import { RegisterClass } from "../Misc/typeStore.js";
/* eslint-disable @typescript-eslint/naming-convention */
const onCreatedEffectParameters = { effect: null, subMesh: null };
class StandardMaterialDefinesBase extends PrepassDefinesMixin(UVDefinesMixin(MaterialDefines)) {
}
/** @internal */
export class StandardMaterialDefines extends ImageProcessingDefinesMixin(StandardMaterialDefinesBase) {
/**
* Initializes the Standard Material defines.
* @param externalProperties The external properties
*/
constructor(externalProperties) {
super(externalProperties);
this.DIFFUSE = false;
this.DIFFUSEDIRECTUV = 0;
this.BAKED_VERTEX_ANIMATION_TEXTURE = false;
this.AMBIENT = false;
this.AMBIENTDIRECTUV = 0;
this.OPACITY = false;
this.OPACITYDIRECTUV = 0;
this.OPACITYRGB = false;
this.REFLECTION = false;
this.EMISSIVE = false;
this.EMISSIVEDIRECTUV = 0;
this.SPECULAR = false;
this.SPECULARDIRECTUV = 0;
this.BUMP = false;
this.BUMPDIRECTUV = 0;
this.PARALLAX = false;
this.PARALLAX_RHS = false;
this.PARALLAXOCCLUSION = false;
this.SPECULAROVERALPHA = false;
this.CLIPPLANE = false;
this.CLIPPLANE2 = false;
this.CLIPPLANE3 = false;
this.CLIPPLANE4 = false;
this.CLIPPLANE5 = false;
this.CLIPPLANE6 = false;
this.ALPHATEST = false;
this.DEPTHPREPASS = false;
this.ALPHAFROMDIFFUSE = false;
this.POINTSIZE = false;
this.FOG = false;
this.SPECULARTERM = false;
this.DIFFUSEFRESNEL = false;
this.OPACITYFRESNEL = false;
this.REFLECTIONFRESNEL = false;
this.REFRACTIONFRESNEL = false;
this.EMISSIVEFRESNEL = false;
this.FRESNEL = false;
this.NORMAL = false;
this.TANGENT = false;
this.VERTEXCOLOR = false;
this.VERTEXALPHA = false;
this.NUM_BONE_INFLUENCERS = 0;
this.BonesPerMesh = 0;
this.BONETEXTURE = false;
this.BONES_VELOCITY_ENABLED = false;
this.INSTANCES = false;
this.THIN_INSTANCES = false;
this.INSTANCESCOLOR = false;
this.GLOSSINESS = false;
this.ROUGHNESS = false;
this.EMISSIVEASILLUMINATION = false;
this.LINKEMISSIVEWITHDIFFUSE = false;
this.REFLECTIONFRESNELFROMSPECULAR = false;
this.LIGHTMAP = false;
this.LIGHTMAPDIRECTUV = 0;
this.OBJECTSPACE_NORMALMAP = false;
this.USELIGHTMAPASSHADOWMAP = false;
this.REFLECTIONMAP_3D = false;
this.REFLECTIONMAP_SPHERICAL = false;
this.REFLECTIONMAP_PLANAR = false;
this.REFLECTIONMAP_CUBIC = false;
this.USE_LOCAL_REFLECTIONMAP_CUBIC = false;
this.USE_LOCAL_REFRACTIONMAP_CUBIC = false;
this.REFLECTIONMAP_PROJECTION = false;
this.REFLECTIONMAP_SKYBOX = false;
this.REFLECTIONMAP_EXPLICIT = false;
this.REFLECTIONMAP_EQUIRECTANGULAR = false;
this.REFLECTIONMAP_EQUIRECTANGULAR_FIXED = false;
this.REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED = false;
this.REFLECTIONMAP_OPPOSITEZ = false;
this.INVERTCUBICMAP = false;
this.LOGARITHMICDEPTH = false;
this.REFRACTION = false;
this.REFRACTIONMAP_3D = false;
this.REFLECTIONOVERALPHA = false;
this.TWOSIDEDLIGHTING = false;
this.SHADOWFLOAT = false;
this.MORPHTARGETS = false;
this.MORPHTARGETS_POSITION = false;
this.MORPHTARGETS_NORMAL = false;
this.MORPHTARGETS_TANGENT = false;
this.MORPHTARGETS_UV = false;
this.MORPHTARGETS_UV2 = false;
this.MORPHTARGETS_COLOR = false;
this.MORPHTARGETTEXTURE_HASPOSITIONS = false;
this.MORPHTARGETTEXTURE_HASNORMALS = false;
this.MORPHTARGETTEXTURE_HASTANGENTS = false;
this.MORPHTARGETTEXTURE_HASUVS = false;
this.MORPHTARGETTEXTURE_HASUV2S = false;
this.MORPHTARGETTEXTURE_HASCOLORS = false;
this.NUM_MORPH_INFLUENCERS = 0;
this.MORPHTARGETS_TEXTURE = false;
this.NONUNIFORMSCALING = false; // https://playground.babylonjs.com#V6DWIH
this.PREMULTIPLYALPHA = false; // https://playground.babylonjs.com#LNVJJ7
this.ALPHATEST_AFTERALLALPHACOMPUTATIONS = false;
this.ALPHABLEND = true;
this.RGBDLIGHTMAP = false;
this.RGBDREFLECTION = false;
this.RGBDREFRACTION = false;
this.MULTIVIEW = false;
this.ORDER_INDEPENDENT_TRANSPARENCY = false;
this.ORDER_INDEPENDENT_TRANSPARENCY_16BITS = false;
this.CAMERA_ORTHOGRAPHIC = false;
this.CAMERA_PERSPECTIVE = false;
this.AREALIGHTSUPPORTED = true;
this.USE_VERTEX_PULLING = false;
this.VERTEX_PULLING_USE_INDEX_BUFFER = false;
this.VERTEX_PULLING_INDEX_BUFFER_32BITS = false;
this.RIGHT_HANDED = false;
this.CLUSTLIGHT_SLICES = 0;
this.CLUSTLIGHT_BATCH = 0;
/**
* If the reflection texture on this material is in linear color space
* @internal
*/
this.IS_REFLECTION_LINEAR = false;
/**
* If the refraction texture on this material is in linear color space
* @internal
*/
this.IS_REFRACTION_LINEAR = false;
this.DECAL_AFTER_DETAIL = false;
this.TEXTURE_REPETITION_MODE = 0;
this.rebuild();
}
}
class StandardMaterialBase extends ImageProcessingMixin(PushMaterial) {
}
/**
* This is the default material used in Babylon. It is the best trade off between quality
* and performances.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/materials_introduction
*/
let StandardMaterial = (() => {
var _a, _StandardMaterial_diffuseTexture_accessor_storage, _StandardMaterial_ambientTexture_accessor_storage, _StandardMaterial_opacityTexture_accessor_storage, _StandardMaterial_reflectionTexture_accessor_storage, _StandardMaterial_emissiveTexture_accessor_storage, _StandardMaterial_specularTexture_accessor_storage, _StandardMaterial_bumpTexture_accessor_storage, _StandardMaterial_lightmapTexture_accessor_storage, _StandardMaterial_refractionTexture_accessor_storage, _StandardMaterial_useAlphaFromDiffuseTexture_accessor_storage, _StandardMaterial_useEmissiveAsIllumination_accessor_storage, _StandardMaterial_linkEmissiveWithDiffuse_accessor_storage, _StandardMaterial_useSpecularOverAlpha_accessor_storage, _StandardMaterial_useReflectionOverAlpha_accessor_storage, _StandardMaterial_disableLighting_accessor_storage, _StandardMaterial_useObjectSpaceNormalMap_accessor_storage, _StandardMaterial_useParallax_accessor_storage, _StandardMaterial_useParallaxOcclusion_accessor_storage, _StandardMaterial_roughness_accessor_storage, _StandardMaterial_useLightmapAsShadowmap_accessor_storage, _StandardMaterial_diffuseFresnelParameters_accessor_storage, _StandardMaterial_opacityFresnelParameters_accessor_storage, _StandardMaterial_reflectionFresnelParameters_accessor_storage, _StandardMaterial_refractionFresnelParameters_accessor_storage, _StandardMaterial_emissiveFresnelParameters_accessor_storage, _StandardMaterial_useReflectionFresnelFromSpecular_accessor_storage, _StandardMaterial_useGlossinessFromSpecularMapAlpha_accessor_storage, _StandardMaterial_maxSimultaneousLights_accessor_storage, _StandardMaterial_invertNormalMapX_accessor_storage, _StandardMaterial_invertNormalMapY_accessor_storage, _StandardMaterial_twoSidedLighting_accessor_storage, _StandardMaterial_applyDecalMapAfterDetailMap_accessor_storage;
let _classSuper = StandardMaterialBase;
let __diffuseTexture_decorators;
let __diffuseTexture_initializers = [];
let __diffuseTexture_extraInitializers = [];
let _diffuseTexture_decorators;
let _diffuseTexture_initializers = [];
let _diffuseTexture_extraInitializers = [];
let __ambientTexture_decorators;
let __ambientTexture_initializers = [];
let __ambientTexture_extraInitializers = [];
let _ambientTexture_decorators;
let _ambientTexture_initializers = [];
let _ambientTexture_extraInitializers = [];
let __opacityTexture_decorators;
let __opacityTexture_initializers = [];
let __opacityTexture_extraInitializers = [];
let _opacityTexture_decorators;
let _opacityTexture_initializers = [];
let _opacityTexture_extraInitializers = [];
let __reflectionTexture_decorators;
let __reflectionTexture_initializers = [];
let __reflectionTexture_extraInitializers = [];
let _reflectionTexture_decorators;
let _reflectionTexture_initializers = [];
let _reflectionTexture_extraInitializers = [];
let __emissiveTexture_decorators;
let __emissiveTexture_initializers = [];
let __emissiveTexture_extraInitializers = [];
let _emissiveTexture_decorators;
let _emissiveTexture_initializers = [];
let _emissiveTexture_extraInitializers = [];
let __specularTexture_decorators;
let __specularTexture_initializers = [];
let __specularTexture_extraInitializers = [];
let _specularTexture_decorators;
let _specularTexture_initializers = [];
let _specularTexture_extraInitializers = [];
let __bumpTexture_decorators;
let __bumpTexture_initializers = [];
let __bumpTexture_extraInitializers = [];
let _bumpTexture_decorators;
let _bumpTexture_initializers = [];
let _bumpTexture_extraInitializers = [];
let __lightmapTexture_decorators;
let __lightmapTexture_initializers = [];
let __lightmapTexture_extraInitializers = [];
let _lightmapTexture_decorators;
let _lightmapTexture_initializers = [];
let _lightmapTexture_extraInitializers = [];
let __refractionTexture_decorators;
let __refractionTexture_initializers = [];
let __refractionTexture_extraInitializers = [];
let _refractionTexture_decorators;
let _refractionTexture_initializers = [];
let _refractionTexture_extraInitializers = [];
let _ambientColor_decorators;
let _ambientColor_initializers = [];
let _ambientColor_extraInitializers = [];
let _diffuseColor_decorators;
let _diffuseColor_initializers = [];
let _diffuseColor_extraInitializers = [];
let _specularColor_decorators;
let _specularColor_initializers = [];
let _specularColor_extraInitializers = [];
let _emissiveColor_decorators;
let _emissiveColor_initializers = [];
let _emissiveColor_extraInitializers = [];
let _specularPower_decorators;
let _specularPower_initializers = [];
let _specularPower_extraInitializers = [];
let __useAlphaFromDiffuseTexture_decorators;
let __useAlphaFromDiffuseTexture_initializers = [];
let __useAlphaFromDiffuseTexture_extraInitializers = [];
let _useAlphaFromDiffuseTexture_decorators;
let _useAlphaFromDiffuseTexture_initializers = [];
let _useAlphaFromDiffuseTexture_extraInitializers = [];
let __useEmissiveAsIllumination_decorators;
let __useEmissiveAsIllumination_initializers = [];
let __useEmissiveAsIllumination_extraInitializers = [];
let _useEmissiveAsIllumination_decorators;
let _useEmissiveAsIllumination_initializers = [];
let _useEmissiveAsIllumination_extraInitializers = [];
let __linkEmissiveWithDiffuse_decorators;
let __linkEmissiveWithDiffuse_initializers = [];
let __linkEmissiveWithDiffuse_extraInitializers = [];
let _linkEmissiveWithDiffuse_decorators;
let _linkEmissiveWithDiffuse_initializers = [];
let _linkEmissiveWithDiffuse_extraInitializers = [];
let __useSpecularOverAlpha_decorators;
let __useSpecularOverAlpha_initializers = [];
let __useSpecularOverAlpha_extraInitializers = [];
let _useSpecularOverAlpha_decorators;
let _useSpecularOverAlpha_initializers = [];
let _useSpecularOverAlpha_extraInitializers = [];
let __useReflectionOverAlpha_decorators;
let __useReflectionOverAlpha_initializers = [];
let __useReflectionOverAlpha_extraInitializers = [];
let _useReflectionOverAlpha_decorators;
let _useReflectionOverAlpha_initializers = [];
let _useReflectionOverAlpha_extraInitializers = [];
let __disableLighting_decorators;
let __disableLighting_initializers = [];
let __disableLighting_extraInitializers = [];
let _disableLighting_decorators;
let _disableLighting_initializers = [];
let _disableLighting_extraInitializers = [];
let __useObjectSpaceNormalMap_decorators;
let __useObjectSpaceNormalMap_initializers = [];
let __useObjectSpaceNormalMap_extraInitializers = [];
let _useObjectSpaceNormalMap_decorators;
let _useObjectSpaceNormalMap_initializers = [];
let _useObjectSpaceNormalMap_extraInitializers = [];
let __useParallax_decorators;
let __useParallax_initializers = [];
let __useParallax_extraInitializers = [];
let _useParallax_decorators;
let _useParallax_initializers = [];
let _useParallax_extraInitializers = [];
let __useParallaxOcclusion_decorators;
let __useParallaxOcclusion_initializers = [];
let __useParallaxOcclusion_extraInitializers = [];
let _useParallaxOcclusion_decorators;
let _useParallaxOcclusion_initializers = [];
let _useParallaxOcclusion_extraInitializers = [];
let _parallaxScaleBias_decorators;
let _parallaxScaleBias_initializers = [];
let _parallaxScaleBias_extraInitializers = [];
let __roughness_decorators;
let __roughness_initializers = [];
let __roughness_extraInitializers = [];
let _roughness_decorators;
let _roughness_initializers = [];
let _roughness_extraInitializers = [];
let _indexOfRefraction_decorators;
let _indexOfRefraction_initializers = [];
let _indexOfRefraction_extraInitializers = [];
let _invertRefractionY_decorators;
let _invertRefractionY_initializers = [];
let _invertRefractionY_extraInitializers = [];
let _alphaCutOff_decorators;
let _alphaCutOff_initializers = [];
let _alphaCutOff_extraInitializers = [];
let __useLightmapAsShadowmap_decorators;
let __useLightmapAsShadowmap_initializers = [];
let __useLightmapAsShadowmap_extraInitializers = [];
let _useLightmapAsShadowmap_decorators;
let _useLightmapAsShadowmap_initializers = [];
let _useLightmapAsShadowmap_extraInitializers = [];
let __diffuseFresnelParameters_decorators;
let __diffuseFresnelParameters_initializers = [];
let __diffuseFresnelParameters_extraInitializers = [];
let _diffuseFresnelParameters_decorators;
let _diffuseFresnelParameters_initializers = [];
let _diffuseFresnelParameters_extraInitializers = [];
let __opacityFresnelParameters_decorators;
let __opacityFresnelParameters_initializers = [];
let __opacityFresnelParameters_extraInitializers = [];
let _opacityFresnelParameters_decorators;
let _opacityFresnelParameters_initializers = [];
let _opacityFresnelParameters_extraInitializers = [];
let __reflectionFresnelParameters_decorators;
let __reflectionFresnelParameters_initializers = [];
let __reflectionFresnelParameters_extraInitializers = [];
let _reflectionFresnelParameters_decorators;
let _reflectionFresnelParameters_initializers = [];
let _reflectionFresnelParameters_extraInitializers = [];
let __refractionFresnelParameters_decorators;
let __refractionFresnelParameters_initializers = [];
let __refractionFresnelParameters_extraInitializers = [];
let _refractionFresnelParameters_decorators;
let _refractionFresnelParameters_initializers = [];
let _refractionFresnelParameters_extraInitializers = [];
let __emissiveFresnelParameters_decorators;
let __emissiveFresnelParameters_initializers = [];
let __emissiveFresnelParameters_extraInitializers = [];
let _emissiveFresnelParameters_decorators;
let _emissiveFresnelParameters_initializers = [];
let _emissiveFresnelParameters_extraInitializers = [];
let __useReflectionFresnelFromSpecular_decorators;
let __useReflectionFresnelFromSpecular_initializers = [];
let __useReflectionFresnelFromSpecular_extraInitializers = [];
let _useReflectionFresnelFromSpecular_decorators;
let _useReflectionFresnelFromSpecular_initializers = [];
let _useReflectionFresnelFromSpecular_extraInitializers = [];
let __useGlossinessFromSpecularMapAlpha_decorators;
let __useGlossinessFromSpecularMapAlpha_initializers = [];
let __useGlossinessFromSpecularMapAlpha_extraInitializers = [];
let _useGlossinessFromSpecularMapAlpha_decorators;
let _useGlossinessFromSpecularMapAlpha_initializers = [];
let _useGlossinessFromSpecularMapAlpha_extraInitializers = [];
let __maxSimultaneousLights_decorators;
let __maxSimultaneousLights_initializers = [];
let __maxSimultaneousLights_extraInitializers = [];
let _maxSimultaneousLights_decorators;
let _maxSimultaneousLights_initializers = [];
let _maxSimultaneousLights_extraInitializers = [];
let __invertNormalMapX_decorators;
let __invertNormalMapX_initializers = [];
let __invertNormalMapX_extraInitializers = [];
let _invertNormalMapX_decorators;
let _invertNormalMapX_initializers = [];
let _invertNormalMapX_extraInitializers = [];
let __invertNormalMapY_decorators;
let __invertNormalMapY_initializers = [];
let __invertNormalMapY_extraInitializers = [];
let _invertNormalMapY_decorators;
let _invertNormalMapY_initializers = [];
let _invertNormalMapY_extraInitializers = [];
let __twoSidedLighting_decorators;
let __twoSidedLighting_initializers = [];
let __twoSidedLighting_extraInitializers = [];
let _twoSidedLighting_decorators;
let _twoSidedLighting_initializers = [];
let _twoSidedLighting_extraInitializers = [];
let __applyDecalMapAfterDetailMap_decorators;
let __applyDecalMapAfterDetailMap_initializers = [];
let __applyDecalMapAfterDetailMap_extraInitializers = [];
let _applyDecalMapAfterDetailMap_decorators;
let _applyDecalMapAfterDetailMap_initializers = [];
let _applyDecalMapAfterDetailMap_extraInitializers = [];
return _a = class StandardMaterial extends _classSuper {
/**
* The basic texture of the material as viewed under a light.
*/
get diffuseTexture() { return __classPrivateFieldGet(this, _StandardMaterial_diffuseTexture_accessor_storage, "f"); }
set diffuseTexture(value) { __classPrivateFieldSet(this, _StandardMaterial_diffuseTexture_accessor_storage, value, "f"); }
/**
* AKA Occlusion Texture in other nomenclature, it helps adding baked shadows into your material.
*/
get ambientTexture() { return __classPrivateFieldGet(this, _StandardMaterial_ambientTexture_accessor_storage, "f"); }
set ambientTexture(value) { __classPrivateFieldSet(this, _StandardMaterial_ambientTexture_accessor_storage, value, "f"); }
/**
* Define the transparency of the material from a texture.
* The final alpha value can be read either from the red channel (if texture.getAlphaFromRGB is false)
* or from the luminance or the current texel (if texture.getAlphaFromRGB is true)
*/
get opacityTexture() { return __classPrivateFieldGet(this, _StandardMaterial_opacityTexture_accessor_storage, "f"); }
set opacityTexture(value) { __classPrivateFieldSet(this, _StandardMaterial_opacityTexture_accessor_storage, value, "f"); }
/**
* Define the texture used to display the reflection.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#how-to-obtain-reflections-and-refractions
*/
get reflectionTexture() { return __classPrivateFieldGet(this, _StandardMaterial_reflectionTexture_accessor_storage, "f"); }
set reflectionTexture(value) { __classPrivateFieldSet(this, _StandardMaterial_reflectionTexture_accessor_storage, value, "f"); }
/**
* Define texture of the material as if self lit.
* This will be mixed in the final result even in the absence of light.
*/
get emissiveTexture() { return __classPrivateFieldGet(this, _StandardMaterial_emissiveTexture_accessor_storage, "f"); }
set emissiveTexture(value) { __classPrivateFieldSet(this, _StandardMaterial_emissiveTexture_accessor_storage, value, "f"); }
/**
* Define how the color and intensity of the highlight given by the light in the material.
*/
get specularTexture() { return __classPrivateFieldGet(this, _StandardMaterial_specularTexture_accessor_storage, "f"); }
set specularTexture(value) { __classPrivateFieldSet(this, _StandardMaterial_specularTexture_accessor_storage, value, "f"); }
/**
* Bump mapping is a technique to simulate bump and dents on a rendered surface.
* These are made by creating a normal map from an image. The means to do this can be found on the web, a search for 'normal map generator' will bring up free and paid for methods of doing this.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/moreMaterials#bump-map
*/
get bumpTexture() { return __classPrivateFieldGet(this, _StandardMaterial_bumpTexture_accessor_storage, "f"); }
set bumpTexture(value) { __classPrivateFieldSet(this, _StandardMaterial_bumpTexture_accessor_storage, value, "f"); }
/**
* Complex lighting can be computationally expensive to compute at runtime.
* To save on computation, lightmaps may be used to store calculated lighting in a texture which will be applied to a given mesh.
* @see https://doc.babylonjs.com/features/featuresDeepDive/lights/lights_introduction#lightmaps
*/
get lightmapTexture() { return __classPrivateFieldGet(this, _StandardMaterial_lightmapTexture_accessor_storage, "f"); }
set lightmapTexture(value) { __classPrivateFieldSet(this, _StandardMaterial_lightmapTexture_accessor_storage, value, "f"); }
/**
* Define the texture used to display the refraction.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#how-to-obtain-reflections-and-refractions
*/
get refractionTexture() { return __classPrivateFieldGet(this, _StandardMaterial_refractionTexture_accessor_storage, "f"); }
set refractionTexture(value) { __classPrivateFieldSet(this, _StandardMaterial_refractionTexture_accessor_storage, value, "f"); }
/**
* Does the transparency come from the diffuse texture alpha channel.
*/
get useAlphaFromDiffuseTexture() { return __classPrivateFieldGet(this, _StandardMaterial_useAlphaFromDiffuseTexture_accessor_storage, "f"); }
set useAlphaFromDiffuseTexture(value) { __classPrivateFieldSet(this, _StandardMaterial_useAlphaFromDiffuseTexture_accessor_storage, value, "f"); }
/**
* If true, the emissive value is added into the end result, otherwise it is multiplied in.
*/
get useEmissiveAsIllumination() { return __classPrivateFieldGet(this, _StandardMaterial_useEmissiveAsIllumination_accessor_storage, "f"); }
set useEmissiveAsIllumination(value) { __classPrivateFieldSet(this, _StandardMaterial_useEmissiveAsIllumination_accessor_storage, value, "f"); }
/**
* If true, some kind of energy conservation will prevent the end result to be more than 1 by reducing
* the emissive level when the final color is close to one.
*/
get linkEmissiveWithDiffuse() { return __classPrivateFieldGet(this, _StandardMaterial_linkEmissiveWithDiffuse_accessor_storage, "f"); }
set linkEmissiveWithDiffuse(value) { __classPrivateFieldSet(this, _StandardMaterial_linkEmissiveWithDiffuse_accessor_storage, value, "f"); }
/**
* Specifies that the material will keep the specular highlights over a transparent surface (only the most luminous ones).
* A car glass is a good exemple of that. When sun reflects on it you can not see what is behind.
*/
get useSpecularOverAlpha() { return __classPrivateFieldGet(this, _StandardMaterial_useSpecularOverAlpha_accessor_storage, "f"); }
set useSpecularOverAlpha(value) { __classPrivateFieldSet(this, _StandardMaterial_useSpecularOverAlpha_accessor_storage, value, "f"); }
/**
* Specifies that the material will keeps the reflection highlights over a transparent surface (only the most luminous ones).
* A car glass is a good exemple of that. When the street lights reflects on it you can not see what is behind.
*/
get useReflectionOverAlpha() { return __classPrivateFieldGet(this, _StandardMaterial_useReflectionOverAlpha_accessor_storage, "f"); }
set useReflectionOverAlpha(value) { __classPrivateFieldSet(this, _StandardMaterial_useReflectionOverAlpha_accessor_storage, value, "f"); }
/**
* Does lights from the scene impacts this material.
* It can be a nice trick for performance to disable lighting on a fully emissive material.
*/
get disableLighting() { return __classPrivateFieldGet(this, _StandardMaterial_disableLighting_accessor_storage, "f"); }
set disableLighting(value) { __classPrivateFieldSet(this, _StandardMaterial_disableLighting_accessor_storage, value, "f"); }
/**
* Allows using an object space normal map (instead of tangent space).
*/
get useObjectSpaceNormalMap() { return __classPrivateFieldGet(this, _StandardMaterial_useObjectSpaceNormalMap_accessor_storage, "f"); }
set useObjectSpaceNormalMap(value) { __classPrivateFieldSet(this, _StandardMaterial_useObjectSpaceNormalMap_accessor_storage, value, "f"); }
/**
* Is parallax enabled or not.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/parallaxMapping
*/
get useParallax() { return __classPrivateFieldGet(this, _StandardMaterial_useParallax_accessor_storage, "f"); }
set useParallax(value) { __classPrivateFieldSet(this, _StandardMaterial_useParallax_accessor_storage, value, "f"); }
/**
* Is parallax occlusion enabled or not.
* If true, the outcome is way more realistic than traditional Parallax but you can expect a performance hit that worthes consideration.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/parallaxMapping
*/
get useParallaxOcclusion() { return __classPrivateFieldGet(this, _StandardMaterial_useParallaxOcclusion_accessor_storage, "f"); }
set useParallaxOcclusion(value) { __classPrivateFieldSet(this, _StandardMaterial_useParallaxOcclusion_accessor_storage, value, "f"); }
/**
* Helps to define how blurry the reflections should appears in the material.
*/
get roughness() { return __classPrivateFieldGet(this, _StandardMaterial_roughness_accessor_storage, "f"); }
set roughness(value) { __classPrivateFieldSet(this, _StandardMaterial_roughness_accessor_storage, value, "f"); }
/**
* In case of light mapping, define whether the map contains light or shadow informations.
*/
get useLightmapAsShadowmap() { return __classPrivateFieldGet(this, _StandardMaterial_useLightmapAsShadowmap_accessor_storage, "f"); }
set useLightmapAsShadowmap(value) { __classPrivateFieldSet(this, _StandardMaterial_useLightmapAsShadowmap_accessor_storage, value, "f"); }
/**
* Define the diffuse fresnel parameters of the material.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/fresnelParameters
*/
get diffuseFresnelParameters() { return __classPrivateFieldGet(this, _StandardMaterial_diffuseFresnelParameters_accessor_storage, "f"); }
set diffuseFresnelParameters(value) { __classPrivateFieldSet(this, _StandardMaterial_diffuseFresnelParameters_accessor_storage, value, "f"); }
/**
* Define the opacity fresnel parameters of the material.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/fresnelParameters
*/
get opacityFresnelParameters() { return __classPrivateFieldGet(this, _StandardMaterial_opacityFresnelParameters_accessor_storage, "f"); }
set opacityFresnelParameters(value) { __classPrivateFieldSet(this, _StandardMaterial_opacityFresnelParameters_accessor_storage, value, "f"); }
/**
* Define the reflection fresnel parameters of the material.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/fresnelParameters
*/
get reflectionFresnelParameters() { return __classPrivateFieldGet(this, _StandardMaterial_reflectionFresnelParameters_accessor_storage, "f"); }
set reflectionFresnelParameters(value) { __classPrivateFieldSet(this, _StandardMaterial_reflectionFresnelParameters_accessor_storage, value, "f"); }
/**
* Define the refraction fresnel parameters of the material.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/fresnelParameters
*/
get refractionFresnelParameters() { return __classPrivateFieldGet(this, _StandardMaterial_refractionFresnelParameters_accessor_storage, "f"); }
set refractionFresnelParameters(value) { __classPrivateFieldSet(this, _StandardMaterial_refractionFresnelParameters_accessor_storage, value, "f"); }
/**
* Define the emissive fresnel parameters of the material.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/fresnelParameters
*/
get emissiveFresnelParameters() { return __classPrivateFieldGet(this, _StandardMaterial_emissiveFresnelParameters_accessor_storage, "f"); }
set emissiveFresnelParameters(value) { __classPrivateFieldSet(this, _StandardMaterial_emissiveFresnelParameters_accessor_storage, value, "f"); }
/**
* If true automatically deducts the fresnels values from the material specularity.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/fresnelParameters
*/
get useReflectionFresnelFromSpecular() { return __classPrivateFieldGet(this, _StandardMaterial_useReflectionFresnelFromSpecular_accessor_storage, "f"); }
set useReflectionFresnelFromSpecular(value) { __classPrivateFieldSet(this, _StandardMaterial_useReflectionFresnelFromSpecular_accessor_storage, value, "f"); }
/**
* Defines if the glossiness/roughness of the material should be read from the specular map alpha channel
*/
get useGlossinessFromSpecularMapAlpha() { return __classPrivateFieldGet(this, _StandardMaterial_useGlossinessFromSpecularMapAlpha_accessor_storage, "f"); }
set useGlossinessFromSpecularMapAlpha(value) { __classPrivateFieldSet(this, _StandardMaterial_useGlossinessFromSpecularMapAlpha_accessor_storage, value, "f"); }
/**
* Defines the maximum number of lights that can be used in the material
*/
get maxSimultaneousLights() { return __classPrivateFieldGet(this, _StandardMaterial_maxSimultaneousLights_accessor_storage, "f"); }
set maxSimultaneousLights(value) { __classPrivateFieldSet(this, _StandardMaterial_maxSimultaneousLights_accessor_storage, value, "f"); }
/**
* If sets to true, x component of normal map value will invert (x = 1.0 - x).
*/
get invertNormalMapX() { return __classPrivateFieldGet(this, _StandardMaterial_invertNormalMapX_accessor_storage, "f"); }
set invertNormalMapX(value) { __classPrivateFieldSet(this, _StandardMaterial_invertNormalMapX_accessor_storage, value, "f"); }
/**
* If sets to true, y component of normal map value will invert (y = 1.0 - y).
*/
get invertNormalMapY() { return __classPrivateFieldGet(this, _StandardMaterial_invertNormalMapY_accessor_storage, "f"); }
set invertNormalMapY(value) { __classPrivateFieldSet(this, _StandardMaterial_invertNormalMapY_accessor_storage, value, "f"); }
/**
* If sets to true and backfaceCulling is false, normals will be flipped on the backside.
*/
get twoSidedLighting() { return __classPrivateFieldGet(this, _StandardMaterial_twoSidedLighting_accessor_storage, "f"); }
set twoSidedLighting(value) { __classPrivateFieldSet(this, _StandardMaterial_twoSidedLighting_accessor_storage, value, "f"); }
/**
* If sets to true, the decal map will be applied after the detail map. Else, it is applied before (default: false)
*/
get applyDecalMapAfterDetailMap() { return __classPrivateFieldGet(this, _StandardMaterial_applyDecalMapAfterDetailMap_accessor_storage, "f"); }
set applyDecalMapAfterDetailMap(value) { __classPrivateFieldSet(this, _StandardMaterial_applyDecalMapAfterDetailMap_accessor_storage, value, "f"); }
/**
* Can this material render to prepass
*/
get isPrePassCapable() {
return !this.disableDepthWrite;
}
/**
* Can this material render to several textures at once
*/
get canRenderToMRT() {
return true;
}
/**
* Instantiates a new standard material.
* This is the default material used in Babylon. It is the best trade off between quality
* and performances.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/materials_introduction
* @param name Define the name of the material in the scene
* @param scene Define the scene the material belong to
* @param forceGLSL Use the GLSL code generation for the shader (even on WebGPU). Default is false
*/
constructor(name, scene, forceGLSL = false) {
super(name, scene, undefined, forceGLSL || _a.ForceGLSL);
this._diffuseTexture = __runInitializers(this, __diffuseTexture_initializers, null);
_StandardMaterial_diffuseTexture_accessor_storage.set(this, (__runInitializers(this, __diffuseTexture_extraInitializers), __runInitializers(this, _diffuseTexture_initializers, void 0)));
this._ambientTexture = (__runInitializers(this, _diffuseTexture_extraInitializers), __runInitializers(this, __ambientTexture_initializers, null));
_StandardMaterial_ambientTexture_accessor_storage.set(this, (__runInitializers(this, __ambientTexture_extraInitializers), __runInitializers(this, _ambientTexture_initializers, void 0)));
this._opacityTexture = (__runInitializers(this, _ambientTexture_extraInitializers), __runInitializers(this, __opacityTexture_initializers, null));
_StandardMaterial_opacityTexture_accessor_storage.set(this, (__runInitializers(this, __opacityTexture_extraInitializers), __runInitializers(this, _opacityTexture_initializers, void 0)));
this._reflectionTexture = (__runInitializers(this, _opacityTexture_extraInitializers), __runInitializers(this, __reflectionTexture_initializers, null));
_StandardMaterial_reflectionTexture_accessor_storage.set(this, (__runInitializers(this, __reflectionTexture_extraInitializers), __runInitializers(this, _reflectionTexture_initializers, void 0)));
this._emissiveTexture = (__runInitializers(this, _reflectionTexture_extraInitializers), __runInitializers(this, __emissiveTexture_initializers, null));
_StandardMaterial_emissiveTexture_accessor_storage.set(this, (__runInitializers(this, __emissiveTexture_extraInitializers), __runInitializers(this, _emissiveTexture_initializers, void 0)));
this._specularTexture = (__runInitializers(this, _emissiveTexture_extraInitializers), __runInitializers(this, __specularTexture_initializers, null));
_StandardMaterial_specularTexture_accessor_storage.set(this, (__runInitializers(this, __specularTexture_extraInitializers), __runInitializers(this, _specularTexture_initializers, void 0)));
this._bumpTexture = (__runInitializers(this, _specularTexture_extraInitializers), __runInitializers(this, __bumpTexture_initializers, null));
_StandardMaterial_bumpTexture_accessor_storage.set(this, (__runInitializers(this, __bumpTexture_extraInitializers), __runInitializers(this, _bumpTexture_initializers, void 0)));
this._lightmapTexture = (__runInitializers(this, _bumpTexture_extraInitializers), __runInitializers(this, __lightmapTexture_initializers, null));
_StandardMaterial_lightmapTexture_accessor_storage.set(this, (__runInitializers(this, __lightmapTexture_extraInitializers), __runInitializers(this, _lightmapTexture_initializers, void 0)));
this._refractionTexture = (__runInitializers(this, _lightmapTexture_extraInitializers), __runInitializers(this, __refractionTexture_initializers, null));
_StandardMaterial_refractionTexture_accessor_storage.set(this, (__runInitializers(this, __refractionTexture_extraInitializers), __runInitializers(this, _refractionTexture_initializers, void 0)));
/**
* The color of the material lit by the environmental background lighting.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/materials_introduction#ambient-color-example
*/
this.ambientColor = (__runInitializers(this, _refractionTexture_extraInitializers), __runInitializers(this, _ambientColor_initializers, new Color3(0, 0, 0)));
/**
* The basic color of the material as viewed under a light.
*/
this.diffuseColor = (__runInitializers(this, _ambientColor_extraInitializers), __runInitializers(this, _diffuseColor_initializers, new Color3(1, 1, 1)));
/**
* Define how the color and intensity of the highlight given by the light in the material.
*/
this.specularColor = (__runInitializers(this, _diffuseColor_extraInitializers), __runInitializers(this, _specularColor_initializers, new Color3(1, 1, 1)));
/**
* Define the color of the material as if self lit.
* This will be mixed in the final result even in the absence of light.
*/
this.emissiveColor = (__runInitializers(this, _specularColor_extraInitializers), __runInitializers(this, _emissiveColor_initializers, new Color3(0, 0, 0)));
/**
* Defines how sharp are the highlights in the material.
* The bigger the value the sharper giving a more glossy feeling to the result.
* Reversely, the smaller the value the blurrier giving a more rough feeling to the result.
*/
this.specularPower = (__runInitializers(this, _emissiveColor_extraInitializers), __runInitializers(this, _specularPower_initializers, 64));
this._useAlphaFromDiffuseTexture = (__runInitializers(this, _specularPower_extraInitializers), __runInitializers(this, __useAlphaFromDiffuseTexture_initializers, false));
_StandardMaterial_useAlphaFromDiffuseTexture_accessor_storage.set(this, (__runInitializers(this, __useAlphaFromDiffuseTexture_extraInitializers), __runInitializers(this, _useAlphaFromDiffuseTexture_initializers, void 0)));
this._useEmissiveAsIllumination = (__runInitializers(this, _useAlphaFromDiffuseTexture_extraInitializers), __runInitializers(this, __useEmissiveAsIllumination_initializers, false));
_StandardMaterial_useEmissiveAsIllumination_accessor_storage.set(this, (__runInitializers(this, __useEmissiveAsIllumination_extraInitializers), __runInitializers(this, _useEmissiveAsIllumination_initializers, void 0)));
this._linkEmissiveWithDiffuse = (__runInitializers(this, _useEmissiveAsIllumination_extraInitializers), __runInitializers(this, __linkEmissiveWithDiffuse_initializers, false));
_StandardMaterial_linkEmissiveWithDiffuse_accessor_storage.set(this, (__runInitializers(this, __linkEmissiveWithDiffuse_extraInitializers), __runInitializers(this, _linkEmissiveWithDiffuse_initializers, void 0)));
this._useSpecularOverAlpha = (__runInitializers(this, _linkEmissiveWithDiffuse_extraInitializers), __runInitializers(this, __useSpecularOverAlpha_initializers, false));
_StandardMaterial_useSpecularOverAlpha_accessor_storage.set(this, (__runInitializers(this, __useSpecularOverAlpha_extraInitializers), __runInitializers(this, _useSpecularOverAlpha_initializers, void 0)));
this._useReflectionOverAlpha = (__runInitializers(this, _useSpecularOverAlpha_extraInitializers), __runInitializers(this, __useReflectionOverAlpha_initializers, false));
_StandardMaterial_useReflectionOverAlpha_accessor_storage.set(this, (__runInitializers(this, __useReflectionOverAlpha_extraInitializers), __runInitializers(this, _useReflectionOverAlpha_initializers, void 0)));
this._disableLighting = (__runInitializers(this, _useReflectionOverAlpha_extraInitializers), __runInitializers(this, __disableLighting_initializers, false));
_StandardMaterial_disableLighting_accessor_storage.set(this, (__runInitializers(this, __disableLighting_extraInitializers), __runInitializers(this, _disableLighting_initializers, void 0)));
this._useObjectSpaceNormalMap = (__runInitializers(this, _disableLighting_extraInitializers), __runInitializers(this, __useObjectSpaceNormalMap_initializers, false));
_StandardMaterial_useObjectSpaceNormalMap_accessor_storage.set(this, (__runInitializers(this, __useObjectSpaceNormalMap_extraInitializers), __runInitializers(this, _useObjectSpaceNormalMap_initializers, void 0)));
this._useParallax = (__runInitializers(this, _useObjectSpaceNormalMap_extraInitializers), __runInitializers(this, __useParallax_initializers, false));
_StandardMaterial_useParallax_accessor_storage.set(this, (__runInitializers(this, __useParallax_extraInitializers), __runInitializers(this, _useParallax_initializers, void 0)));
this._useParallaxOcclusion = (__runInitializers(this, _useParallax_extraInitializers), __runInitializers(this, __useParallaxOcclusion_initializers, false));
_StandardMaterial_useParallaxOcclusion_accessor_storage.set(this, (__runInitializers(this, __useParallaxOcclusion_extraInitializers), __runInitializers(this, _useParallaxOcclusion_initializers, void 0)));
/**
* Apply a scaling factor that determine which "depth" the height map should reprensent. A value between 0.05 and 0.1 is reasonnable in Parallax, you can reach 0.2 using Parallax Occlusion.
*/
this.parallaxScaleBias = (__runInitializers(this, _useParallaxOcclusion_extraInitializers), __runInitializers(this, _parallaxScaleBias_initializers, 0.05));
this._roughness = (__runInitializers(this, _parallaxScaleBias_extraInitializers), __runInitializers(this, __roughness_initializers, 0));
_StandardMaterial_roughness_accessor_storage.set(this, (__runInitializers(this, __roughness_extraInitializers), __runInitializers(this, _roughness_initializers, void 0)));
/**
* In case of refraction, define the value of the index of refraction.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#how-to-obtain-reflections-and-refractions
*/
this.indexOfRefraction = (__runInitializers(this, _roughness_extraInitializers), __runInitializers(this, _indexOfRefraction_initializers, 0.98));
/**
* Invert the refraction texture alongside the y axis.
* It can be useful with procedural textures or probe for instance.
* @see https://doc.babylonjs.com/features/featuresDeepDive/materials/using/reflectionTexture#how-to-obtain-reflections-and-refractions
*/
this.invertRefractionY = (__runInitializers(this, _indexOfRefraction_extraInitializers), __runInitializers(this, _invertRefractionY_initializers, true));
/**
* Defines the alpha limits in alpha test mode.
*/
this.alphaCutOff = (__runInitializers(this, _invertRefractionY_extraInitializers), __runInitializers(this, _alphaCutOff_initializers, 0.4));
this._useLightmapAsShadowmap = (__runInitializers(this, _alphaCutOff_extraInitializers), __runInitializers(this, __useLightmapAsShadowmap_initializers, false));
_StandardMaterial_useLightmapAsShadowmap_accessor_storage.set(this, (__runInitializers(this, __useLightmapAsShadowmap_extraInitializers), __runInitializers(this, _useLightmapAsShadowmap_initializers, void 0)));
// Fresnel
this._diffuseFresnelParameters = (__runInitializers(this, _useLightmapAsShadowmap_extraInitializers), __runInitializers(this, __diffuseFresnelParameters_initializers, void 0));
_StandardMaterial_diffuseFresnelParameters_accessor_storage.set(this, (__runInitializers(this, __diffuseFresnelParameters_extraInitializers), __runInitializers(this, _diffuseFresnelParameters_initializers, void 0)));
this._opacityFresnelParameters = (__runInitializers(this, _diffuseFresnelParameters_extraInitializers), __runInitializers(this, __opacityFresnelParameters_initializers, void 0));
_StandardMaterial_opacityFresnelParameters_accessor_storage.set(this, (__runInitializers(this, __opacityFresnelParameters_extraInitializers), __runInitializers(this, _opacityFresnelParameters_initializers, void 0)));
this._reflectionFresnelParameters = (__runInitializers(this, _opacityFresnelParameters_extraInitializers), __runInitializers(this, __reflectionFresnelParameters_initializers, void 0));
_StandardMaterial_reflectionFresnelParameters_accessor_storage.set(this, (__runInitializers(this, __reflectionFresnelParameters_extraInitializers), __runInitializers(this, _reflectionFresnelParameters_initializers, void 0)));
this._refractionFresnelParameters = (__runInitializers(this, _reflectionFresnelParameters_extraInitialize