@onerjs/core 8.53.4 → 8.53.6

package/Materials/PBR/openpbrMaterial.pure.d.ts

@@ -365,277 +365,277 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * Base Weight is a multiplier on the diffuse and metal lobes.
      * See OpenPBR's specs for base_weight
      */
-    baseWeight: number;
+    accessor baseWeight: number;
     private _baseWeight;
     /**
      * Base Weight is a multiplier on the diffuse and metal lobes.
      * See OpenPBR's specs for base_weight
      */
-    baseWeightTexture: Nullable<BaseTexture>;
+    accessor baseWeightTexture: Nullable<BaseTexture>;
     private _baseWeightTexture;
     /**
      * Color of the base diffuse lobe.
      * See OpenPBR's specs for base_color
      */
-    baseColor: Color3;
+    accessor baseColor: Color3;
     private _baseColor;
     /**
      * Base Color Texture property.
      * See OpenPBR's specs for base_color
      */
-    baseColorTexture: Nullable<BaseTexture>;
+    accessor baseColorTexture: Nullable<BaseTexture>;
     private _baseColorTexture;
     /**
      * Roughness of the diffuse lobe.
      * See OpenPBR's specs for base_diffuse_roughness
      */
-    baseDiffuseRoughness: number;
+    accessor baseDiffuseRoughness: number;
     private _baseDiffuseRoughness;
     /**
      * Roughness texture of the diffuse lobe.
      * See OpenPBR's specs for base_diffuse_roughness
      */
-    baseDiffuseRoughnessTexture: Nullable<BaseTexture>;
+    accessor baseDiffuseRoughnessTexture: Nullable<BaseTexture>;
     private _baseDiffuseRoughnessTexture;
     /**
      * Metalness of the base lobe.
      * See OpenPBR's specs for base_metalness
      */
-    baseMetalness: number;
+    accessor baseMetalness: number;
     private _baseMetalness;
     /**
      * Metalness texture.
      * See OpenPBR's specs for base_metalness
      */
-    baseMetalnessTexture: Nullable<BaseTexture>;
+    accessor baseMetalnessTexture: Nullable<BaseTexture>;
     private _baseMetalnessTexture;
     /**
      * Weight of the specular lobe.
      * See OpenPBR's specs for specular_weight
      */
-    specularWeight: number;
+    accessor specularWeight: number;
     private _specularWeight;
     /**
      * Weight texture of the specular lobe.
      * See OpenPBR's specs for specular_weight
      */
-    specularWeightTexture: Nullable<BaseTexture>;
+    accessor specularWeightTexture: Nullable<BaseTexture>;
     private _specularWeightTexture;
     /**
      * Color of the specular lobe.
      * See OpenPBR's specs for specular_color
      */
-    specularColor: Color3;
+    accessor specularColor: Color3;
     private _specularColor;
     /**
      * Specular Color Texture property.
      * See OpenPBR's specs for specular_color
      */
-    specularColorTexture: Nullable<BaseTexture>;
+    accessor specularColorTexture: Nullable<BaseTexture>;
     private _specularColorTexture;
     /**
      * Roughness of the specular lobe.
      * See OpenPBR's specs for specular_roughness
      */
-    specularRoughness: number;
+    accessor specularRoughness: number;
     private _specularRoughness;
     /**
      * Roughness texture of the specular lobe.
      * See OpenPBR's specs for specular_roughness
      */
-    specularRoughnessTexture: Nullable<BaseTexture>;
+    accessor specularRoughnessTexture: Nullable<BaseTexture>;
     private _specularRoughnessTexture;
     /**
      * Anisotropic roughness of the specular lobe.
      * See OpenPBR's specs for specular_roughness_anisotropy
      */
-    specularRoughnessAnisotropy: number;
+    accessor specularRoughnessAnisotropy: number;
     private _specularRoughnessAnisotropy;
     /**
      * Anisotropic Roughness texture.
      * See OpenPBR's specs for specular_roughness
      */
-    specularRoughnessAnisotropyTexture: Nullable<BaseTexture>;
+    accessor specularRoughnessAnisotropyTexture: Nullable<BaseTexture>;
     private _specularRoughnessAnisotropyTexture;
     /**
      * IOR of the specular lobe.
      * See OpenPBR's specs for specular_ior
      */
-    specularIor: number;
+    accessor specularIor: number;
     private _specularIor;
     /**
      * Transmission weight of the surface.
      * See OpenPBR's specs for transmission_weight
      */
-    transmissionWeight: number;
+    accessor transmissionWeight: number;
     private _transmissionWeight;
     /**
      * Transmission weight texture.
      * See OpenPBR's specs for transmission_weight
      */
-    transmissionWeightTexture: Nullable<BaseTexture>;
+    accessor transmissionWeightTexture: Nullable<BaseTexture>;
     private _transmissionWeightTexture;
     /**
      * Transmission color of the surface.
      * See OpenPBR's specs for transmission_color
      */
-    transmissionColor: Color3;
+    accessor transmissionColor: Color3;
     private _transmissionColor;
     /**
      * Transmission color texture.
      * See OpenPBR's specs for transmission_color
      */
-    transmissionColorTexture: Nullable<BaseTexture>;
+    accessor transmissionColorTexture: Nullable<BaseTexture>;
     private _transmissionColorTexture;
     /**
      * Transmission depth of the volume
      * See OpenPBR's specs for transmission_depth
      */
-    transmissionDepth: number;
+    accessor transmissionDepth: number;
     private _transmissionDepth;
     /**
      * Transmission depth texture.
      * See OpenPBR's specs for transmission_depth
      */
-    transmissionDepthTexture: Nullable<BaseTexture>;
+    accessor transmissionDepthTexture: Nullable<BaseTexture>;
     private _transmissionDepthTexture;
     /**
      * Transmission scatter of the surface.
      * See OpenPBR's specs for transmission_scatter
      */
-    transmissionScatter: Color3;
+    accessor transmissionScatter: Color3;
     private _transmissionScatter;
     /**
      * Transmission scatter texture.
      * See OpenPBR's specs for transmission_scatter
      */
-    transmissionScatterTexture: Nullable<BaseTexture>;
+    accessor transmissionScatterTexture: Nullable<BaseTexture>;
     private _transmissionScatterTexture;
     /**
      * Transmission scatter anisotropy
      * See OpenPBR's specs for transmission_scatter_anisotropy
      */
-    transmissionScatterAnisotropy: number;
+    accessor transmissionScatterAnisotropy: number;
     private _transmissionScatterAnisotropy;
     /**
      * Transmission Dispersion Scale factor.
      * See OpenPBR's specs for transmission_dispersion_scale
      */
-    transmissionDispersionScale: number;
+    accessor transmissionDispersionScale: number;
     private _transmissionDispersionScale;
     /**
      * Transmission Dispersion Scale texture.
      * See OpenPBR's specs for transmission_dispersion_scale
      */
-    transmissionDispersionScaleTexture: Nullable<BaseTexture>;
+    accessor transmissionDispersionScaleTexture: Nullable<BaseTexture>;
     private _transmissionDispersionScaleTexture;
     /**
      * Transmission Dispersion Abbe number.
      * See OpenPBR's specs for transmission_dispersion_abbe_number
      */
-    transmissionDispersionAbbeNumber: number;
+    accessor transmissionDispersionAbbeNumber: number;
     private _transmissionDispersionAbbeNumber;
     /**
      * Defines the amount of subsurface scattering on the surface.
      * See OpenPBR's specs for subsurface_weight
      */
-    subsurfaceWeight: number;
+    accessor subsurfaceWeight: number;
     private _subsurfaceWeight;
     /**
      * Subsurface weight texture.
      * See OpenPBR's specs for subsurface_weight
      */
-    subsurfaceWeightTexture: Nullable<BaseTexture>;
+    accessor subsurfaceWeightTexture: Nullable<BaseTexture>;
     private _subsurfaceWeightTexture;
     /**
      * Defines the color of the subsurface scattering in the volume.
      * See OpenPBR's specs for subsurface_color
      */
-    subsurfaceColor: Color3;
+    accessor subsurfaceColor: Color3;
     private _subsurfaceColor;
     /**
      * Subsurface color texture.
      * See OpenPBR's specs for subsurface_color
      */
-    subsurfaceColorTexture: Nullable<BaseTexture>;
+    accessor subsurfaceColorTexture: Nullable<BaseTexture>;
     private _subsurfaceColorTexture;
     /**
      * Defines the radius of the subsurface scattering in the volume.
      * See OpenPBR's specs for subsurface_radius
      */
-    subsurfaceRadius: number;
+    accessor subsurfaceRadius: number;
     private _subsurfaceRadius;
     /**
      * Defines the scale factor applied to the subsurface radius.
      * See OpenPBR's specs for subsurface_radius_scale
      */
-    subsurfaceRadiusScale: Color3;
+    accessor subsurfaceRadiusScale: Color3;
     private _subsurfaceRadiusScale;
     /**
      * Subsurface radius scale texture.
      * See OpenPBR's specs for subsurface_radius_scale
      */
-    subsurfaceRadiusScaleTexture: Nullable<BaseTexture>;
+    accessor subsurfaceRadiusScaleTexture: Nullable<BaseTexture>;
     private _subsurfaceRadiusScaleTexture;
     /**
      * Defines the anisotropy of the subsurface scattering in the volume.
      * See OpenPBR's specs for subsurface_scatter_anisotropy
      */
-    subsurfaceScatterAnisotropy: number;
+    accessor subsurfaceScatterAnisotropy: number;
     private _subsurfaceScatterAnisotropy;
     /**
      * Defines the amount of clear coat on the surface.
      * See OpenPBR's specs for coat_weight
      */
-    coatWeight: number;
+    accessor coatWeight: number;
     private _coatWeight;
     /**
      * Coat weight texture.
      * See OpenPBR's specs for coat_weight
      */
-    coatWeightTexture: Nullable<BaseTexture>;
+    accessor coatWeightTexture: Nullable<BaseTexture>;
     private _coatWeightTexture;
     /**
      * Defines the color of the clear coat on the surface.
      * See OpenPBR's specs for coat_color
      */
-    coatColor: Color3;
+    accessor coatColor: Color3;
     private _coatColor;
     /**
      * Color texture of the clear coat.
      * See OpenPBR's specs for coat_color
      */
-    coatColorTexture: Nullable<BaseTexture>;
+    accessor coatColorTexture: Nullable<BaseTexture>;
     private _coatColorTexture;
     /**
      * Defines the roughness of the clear coat on the surface.
      * See OpenPBR's specs for coat_roughness
      */
-    coatRoughness: number;
+    accessor coatRoughness: number;
     private _coatRoughness;
     /**
      * Roughness texture of the clear coat.
      * See OpenPBR's specs for coat_roughness
      */
-    coatRoughnessTexture: Nullable<BaseTexture>;
+    accessor coatRoughnessTexture: Nullable<BaseTexture>;
     private _coatRoughnessTexture;
     /**
      * Defines the anisotropy of the clear coat on the surface.
      * See OpenPBR's specs for coat_roughness_anisotropy
      */
-    coatRoughnessAnisotropy: number;
+    accessor coatRoughnessAnisotropy: number;
     private _coatRoughnessAnisotropy;
     /**
      * Anisotropic Roughness texture of the clear coat.
      * See OpenPBR's specs for coat_roughness_anisotropy
      */
-    coatRoughnessAnisotropyTexture: Nullable<BaseTexture>;
+    accessor coatRoughnessAnisotropyTexture: Nullable<BaseTexture>;
     private _coatRoughnessAnisotropyTexture;
     /**
      * Defines the IOR of the clear coat on the surface.
      * See OpenPBR's specs for coat_ior
      */
-    coatIor: number;
+    accessor coatIor: number;
     private _coatIor;
     /**
      * Defines the amount that interreflections within the coat allow the underlying surface
@@ -643,7 +643,7 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * is applied, while a value of 0.0 means that no darkening is applied.
      * See OpenPBR's specs for coat_darkening
      */
-    coatDarkening: number;
+    accessor coatDarkening: number;
     private _coatDarkening;
     /**
      * Defines the amount that interreflections within the coat allow the underlying surface
@@ -651,7 +651,7 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * is applied, while a value of 0.0 means that no darkening is applied.
      * See OpenPBR's specs for coat_darkening
      */
-    coatDarkeningTexture: Nullable<BaseTexture>;
+    accessor coatDarkeningTexture: Nullable<BaseTexture>;
     private _coatDarkeningTexture;
     /**
      * Specifies whether the coat roughness is taken from the
@@ -662,55 +662,55 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * Defines the weight of the fuzz layer on the surface.
      * See OpenPBR's specs for fuzz_weight
      */
-    fuzzWeight: number;
+    accessor fuzzWeight: number;
     private _fuzzWeight;
     /**
      * Weight texture of the fuzz layer.
      * See OpenPBR's specs for fuzz_weight
      */
-    fuzzWeightTexture: Nullable<BaseTexture>;
+    accessor fuzzWeightTexture: Nullable<BaseTexture>;
     private _fuzzWeightTexture;
     /**
      * Defines the color of the fuzz layer on the surface.
      * See OpenPBR's specs for fuzz_color
      */
-    fuzzColor: Color3;
+    accessor fuzzColor: Color3;
     private _fuzzColor;
     /**
      * Color texture of the fuzz layer.
      * See OpenPBR's specs for fuzz_color
      */
-    fuzzColorTexture: Nullable<BaseTexture>;
+    accessor fuzzColorTexture: Nullable<BaseTexture>;
     private _fuzzColorTexture;
     /**
      * Defines the roughness of the fuzz layer on the surface.
      * See OpenPBR's specs for fuzz_roughness
      */
-    fuzzRoughness: number;
+    accessor fuzzRoughness: number;
     private _fuzzRoughness;
     /**
      * Roughness texture of the fuzz layer.
      * See OpenPBR's specs for fuzz_roughness
      */
-    fuzzRoughnessTexture: Nullable<BaseTexture>;
+    accessor fuzzRoughnessTexture: Nullable<BaseTexture>;
     private _fuzzRoughnessTexture;
     /**
      * Defines whether the geometry is thin-walled (like a sheet of paper) or not.
      * See OpenPBR's specs for geometry_thin_walled
      */
-    geometryThinWalled: number;
+    accessor geometryThinWalled: number;
     private _geometryThinWalled;
     /**
      * Defines the normal of the material's geometry.
      * See OpenPBR's specs for geometry_normal
      */
-    geometryNormalTexture: Nullable<BaseTexture>;
+    accessor geometryNormalTexture: Nullable<BaseTexture>;
     private _geometryNormalTexture;
     /**
      * Defines the tangent of the material's geometry. Used only for anisotropic reflections.
      * See OpenPBR's specs for geometry_tangent
      */
-    geometryTangent: Vector2;
+    accessor geometryTangent: Vector2;
     private _geometryTangent;
     /**
      * Defines the angle of the tangent of the material's geometry. Used only for anisotropic reflections.
@@ -722,19 +722,19 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * Defines the tangent of the material's geometry. Used only for anisotropic reflections.
      * See OpenPBR's specs for geometry_tangent
      */
-    geometryTangentTexture: Nullable<BaseTexture>;
+    accessor geometryTangentTexture: Nullable<BaseTexture>;
     private _geometryTangentTexture;
     /**
      * Defines the normal of the material's coat layer.
      * See OpenPBR's specs for geometry_coat_normal
      */
-    geometryCoatNormalTexture: Nullable<BaseTexture>;
+    accessor geometryCoatNormalTexture: Nullable<BaseTexture>;
     private _geometryCoatNormalTexture;
     /**
      * Defines the tangent of the material's coat layer. Used only for anisotropic reflections.
      * See OpenPBR's specs for geometry_coat_tangent
      */
-    geometryCoatTangent: Vector2;
+    accessor geometryCoatTangent: Vector2;
     private _geometryCoatTangent;
     /**
      * Defines the angle of the tangent of the material's coat layer.
@@ -748,86 +748,86 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * Defines the tangent of the material's coat layer. Used only for anisotropic reflections.
      * See OpenPBR's specs for geometry_coat_tangent
      */
-    geometryCoatTangentTexture: Nullable<BaseTexture>;
+    accessor geometryCoatTangentTexture: Nullable<BaseTexture>;
     private _geometryCoatTangentTexture;
     /**
      * Defines the opacity of the material's geometry.
      * See OpenPBR's specs for geometry_opacity
      */
-    geometryOpacity: number;
+    accessor geometryOpacity: number;
     private _geometryOpacity;
     /**
      * Defines the opacity texture of the material's geometry.
      * See OpenPBR's specs for geometry_opacity
      */
-    geometryOpacityTexture: Nullable<BaseTexture>;
+    accessor geometryOpacityTexture: Nullable<BaseTexture>;
     private _geometryOpacityTexture;
     /**
      * Defines the thickness of the material's geometry.
      * Not part of OpenPBR's specs but useful for rasterization approximations of volume.
      */
-    geometryThickness: number;
+    accessor geometryThickness: number;
     private _geometryThickness;
     /**
      * Defines the thickness of the material's geometry.
      * Not part of OpenPBR's specs but useful for rasterization approximations of volume.
      */
-    geometryThicknessTexture: Nullable<BaseTexture>;
+    accessor geometryThicknessTexture: Nullable<BaseTexture>;
     private _geometryThicknessTexture;
     /**
      * Defines the luminance of the material's emission.
      * See OpenPBR's specs for emission_luminance
      */
-    emissionLuminance: number;
+    accessor emissionLuminance: number;
     private _emissionLuminance;
     /**
      * Defines the color of the material's emission.
      * See OpenPBR's specs for emission_color
      */
-    emissionColor: Color3;
+    accessor emissionColor: Color3;
     private _emissionColor;
     /**
      * Defines the texture of the material's emission color.
      * See OpenPBR's specs for emission_color
      */
-    emissionColorTexture: Nullable<BaseTexture>;
+    accessor emissionColorTexture: Nullable<BaseTexture>;
     private _emissionColorTexture;
     /**
      * Defines the weight of the thin film layer on top of the base layer for iridescent effects.
      */
-    thinFilmWeight: number;
+    accessor thinFilmWeight: number;
     private _thinFilmWeight;
     /**
      * Thin film weight texture.
      */
-    thinFilmWeightTexture: Nullable<BaseTexture>;
+    accessor thinFilmWeightTexture: Nullable<BaseTexture>;
     private _thinFilmWeightTexture;
     /**
      * Defines the thickness of the thin film layer in μm. If a texture is provided for thinFilmWeightTexture,
      * this value will act as a multiplier to the texture values.
      * See OpenPBR's specs for thin_film_thickness
      */
-    thinFilmThickness: number;
+    accessor thinFilmThickness: number;
     private _thinFilmThickness;
     /**
      * Defines the minimum thickness of the thin film layer in μm.
      */
-    thinFilmThicknessMin: number;
+    accessor thinFilmThicknessMin: number;
     private _thinFilmThicknessMin;
     /**
      * Defines the maximum thickness of the thin film layer in μm.
      */
-    thinFilmThicknessTexture: Nullable<BaseTexture>;
+    accessor thinFilmThicknessTexture: Nullable<BaseTexture>;
     private _thinFilmThicknessTexture;
     /**
      * Defines the index of refraction of the thin film layer.
      */
-    thinFilmIor: number;
+    accessor thinFilmIor: number;
     private _thinFilmIor;
     /**
      * Defines the ambient occlusion texture.
      */
-    ambientOcclusionTexture: Nullable<BaseTexture>;
+    accessor ambientOcclusionTexture: Nullable<BaseTexture>;
     private _ambientOcclusionTexture;
     /** SSS convolution uses 8 samples. */
     static readonly SSS_QUALITY_LOW = 0;
@@ -878,32 +878,32 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * Intensity of the direct lights e.g. the four lights available in your scene.
      * This impacts both the direct diffuse and specular highlights.
      */
-    directIntensity: number;
+    accessor directIntensity: number;
     /**
      * Intensity of the environment e.g. how much the environment will light the object
      * either through harmonics for rough material or through the reflection for shiny ones.
      */
-    environmentIntensity: number;
+    accessor environmentIntensity: number;
     /**
      * Specifies that the specular weight is stored in the alpha channel of the specular weight texture.
      */
-    useSpecularWeightFromTextureAlpha: boolean;
+    accessor useSpecularWeightFromTextureAlpha: boolean;
     /**
      * Enforces alpha test in opaque or blend mode in order to improve the performances of some situations.
      */
-    forceAlphaTest: boolean;
+    accessor forceAlphaTest: boolean;
     /**
      * Defines the alpha limits in alpha test mode.
      */
-    alphaCutOff: number;
+    accessor alphaCutOff: number;
     /**
      * Specifies if the metallic texture contains the ambient occlusion information in its red channel.
      */
-    useAmbientOcclusionFromMetallicTextureRed: boolean;
+    accessor useAmbientOcclusionFromMetallicTextureRed: boolean;
     /**
      * Specifies if the ambient texture contains the ambient occlusion information in its red channel only.
      */
-    useAmbientInGrayScale: boolean;
+    accessor useAmbientInGrayScale: boolean;
     /**
      * Specifies if we can see through the surface of the material due to subsurface scattering or transmission.
      */
@@ -935,53 +935,53 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
     /**
      * Allows using an object space normal map (instead of tangent space).
      */
-    useObjectSpaceNormalMap: boolean;
+    accessor useObjectSpaceNormalMap: boolean;
     /**
      * Allows using the normal map in parallax mode.
      */
-    useParallax: boolean;
+    accessor useParallax: boolean;
     /**
      * Allows using the normal map in parallax occlusion mode.
      */
-    useParallaxOcclusion: boolean;
+    accessor useParallaxOcclusion: boolean;
     /**
      * Controls the scale bias of the parallax mode.
      */
-    parallaxScaleBias: number;
+    accessor parallaxScaleBias: number;
     /**
      * If sets to true, disables all the lights affecting the material.
      */
-    disableLighting: boolean;
+    accessor disableLighting: boolean;
     /**
      * Force the shader to compute irradiance in the fragment shader in order to take normal mapping into account.
      */
-    forceIrradianceInFragment: boolean;
+    accessor forceIrradianceInFragment: boolean;
     /**
      * Number of Simultaneous lights allowed on the material.
      */
-    maxSimultaneousLights: number;
+    accessor maxSimultaneousLights: number;
     /**
      * If sets to true, x component of normal map value will invert (x = 1.0 - x).
      */
-    invertNormalMapX: boolean;
+    accessor invertNormalMapX: boolean;
     /**
      * If sets to true, y component of normal map value will invert (y = 1.0 - y).
      */
-    invertNormalMapY: boolean;
+    accessor invertNormalMapY: boolean;
     /**
      * If sets to true and backfaceCulling is false, normals will be flipped on the backside.
      */
-    twoSidedLighting: boolean;
+    accessor twoSidedLighting: boolean;
     /**
      * A fresnel is applied to the alpha of the model to ensure grazing angles edges are not alpha tested.
      * And/Or occlude the blended part. (alpha is converted to gamma to compute the fresnel)
      */
-    useAlphaFresnel: boolean;
+    accessor useAlphaFresnel: boolean;
     /**
      * A fresnel is applied to the alpha of the model to ensure grazing angles edges are not alpha tested.
      * And/Or occlude the blended part. (alpha stays linear to compute the fresnel)
      */
-    useLinearAlphaFresnel: boolean;
+    accessor useLinearAlphaFresnel: boolean;
     /**
      * Let user defines the brdf lookup texture used for IBL.
      * A default 8bit version is embedded but you could point at :
@@ -990,35 +990,35 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * * LEGACY Default None correlated https://assets.babylonjs.com/environments/uncorrelatedBRDF_RGBD.png
      * * LEGACY Default None correlated 16bit pixel depth https://assets.babylonjs.com/environments/uncorrelatedBRDF.dds
      */
-    environmentBRDFTexture: Nullable<BaseTexture>;
+    accessor environmentBRDFTexture: Nullable<BaseTexture>;
     /**
      * Force normal to face away from face.
      */
-    forceNormalForward: boolean;
+    accessor forceNormalForward: boolean;
     /**
      * Enables specular anti aliasing in the PBR shader.
      * It will both interacts on the Geometry for analytical and IBL lighting.
      * It also prefilter the roughness map based on the normalmap values.
      */
-    enableSpecularAntiAliasing: boolean;
+    accessor enableSpecularAntiAliasing: boolean;
     /**
      * This parameters will enable/disable Horizon occlusion to prevent normal maps to look shiny when the normal
      * makes the reflect vector face the model (under horizon).
      */
-    useHorizonOcclusion: boolean;
+    accessor useHorizonOcclusion: boolean;
     /**
      * This parameters will enable/disable radiance occlusion by preventing the radiance to lit
      * too much the area relying on ambient texture to define their ambient occlusion.
      */
-    useRadianceOcclusion: boolean;
+    accessor useRadianceOcclusion: boolean;
     /**
      * If set to true, no lighting calculations will be applied.
      */
-    unlit: boolean;
+    accessor unlit: boolean;
     /**
      * If sets to true, the decal map will be applied after the detail map. Else, it is applied before (default: false)
      */
-    applyDecalMapAfterDetailMap: boolean;
+    accessor applyDecalMapAfterDetailMap: boolean;
     /**
      * Force all the PBR materials to compile to glsl even on WebGPU engines.
      * False by default. This is mostly meant for backward compatibility.
@@ -1287,7 +1287,7 @@ export declare class OpenPBRMaterial extends OpenPBRMaterialBase {
      * Defines the material debug mode.
      * It helps seeing only some components of the material while troubleshooting.
      */
-    debugMode: number;
+    accessor debugMode: number;
     /**
      * @internal
      * This is reserved for the inspector.