text: import { __decorate, __extends } from "tslib";
  import { serializeAsTexture, serialize, expandToProperty, serializeAsColor3, SerializationHelper } from "@babylonjs/core/Misc/decorators";
  import { Color3 } from "@babylonjs/core/Maths/math.color";
  import { MaterialDefines } from "@babylonjs/core/Materials/materialDefines";
  import { MaterialHelper } from "@babylonjs/core/Materials/materialHelper";
  import { PushMaterial } from "@babylonjs/core/Materials/pushMaterial";
  import { MaterialFlags } from "@babylonjs/core/Materials/materialFlags";
  import { VertexBuffer } from "@babylonjs/core/Meshes/buffer";
  import { Scene } from "@babylonjs/core/scene";
  import { _TypeStore } from '@babylonjs/core/Misc/typeStore';
  import "./normal.fragment";
  import "./normal.vertex";
  import { EffectFallbacks } from '@babylonjs/core/Materials/effectFallbacks';
  var NormalMaterialDefines = /** @class */ (function (_super) {
      __extends(NormalMaterialDefines, _super);
      function NormalMaterialDefines() {
          var _this = _super.call(this) || this;
          _this.DIFFUSE = 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.POINTSIZE = false;
          _this.FOG = false;
          _this.LIGHT0 = false;
          _this.LIGHT1 = false;
          _this.LIGHT2 = false;
          _this.LIGHT3 = false;
          _this.SPOTLIGHT0 = false;
          _this.SPOTLIGHT1 = false;
          _this.SPOTLIGHT2 = false;
          _this.SPOTLIGHT3 = false;
          _this.HEMILIGHT0 = false;
          _this.HEMILIGHT1 = false;
          _this.HEMILIGHT2 = false;
          _this.HEMILIGHT3 = false;
          _this.DIRLIGHT0 = false;
          _this.DIRLIGHT1 = false;
          _this.DIRLIGHT2 = false;
          _this.DIRLIGHT3 = false;
          _this.POINTLIGHT0 = false;
          _this.POINTLIGHT1 = false;
          _this.POINTLIGHT2 = false;
          _this.POINTLIGHT3 = false;
          _this.SHADOW0 = false;
          _this.SHADOW1 = false;
          _this.SHADOW2 = false;
          _this.SHADOW3 = false;
          _this.SHADOWS = false;
          _this.SHADOWESM0 = false;
          _this.SHADOWESM1 = false;
          _this.SHADOWESM2 = false;
          _this.SHADOWESM3 = false;
          _this.SHADOWPOISSON0 = false;
          _this.SHADOWPOISSON1 = false;
          _this.SHADOWPOISSON2 = false;
          _this.SHADOWPOISSON3 = false;
          _this.SHADOWPCF0 = false;
          _this.SHADOWPCF1 = false;
          _this.SHADOWPCF2 = false;
          _this.SHADOWPCF3 = false;
          _this.SHADOWPCSS0 = false;
          _this.SHADOWPCSS1 = false;
          _this.SHADOWPCSS2 = false;
          _this.SHADOWPCSS3 = false;
          _this.NORMAL = false;
          _this.UV1 = false;
          _this.UV2 = false;
          _this.NUM_BONE_INFLUENCERS = 0;
          _this.BonesPerMesh = 0;
          _this.INSTANCES = false;
          _this.LIGHTING = false;
          _this.IMAGEPROCESSINGPOSTPROCESS = false;
          _this.rebuild();
          return _this;
      }
      return NormalMaterialDefines;
  }(MaterialDefines));
  var NormalMaterial = /** @class */ (function (_super) {
      __extends(NormalMaterial, _super);
      function NormalMaterial(name, scene) {
          var _this = _super.call(this, name, scene) || this;
          _this.diffuseColor = new Color3(1, 1, 1);
          _this._disableLighting = false;
          _this._maxSimultaneousLights = 4;
          return _this;
      }
      NormalMaterial.prototype.needAlphaBlending = function () {
          return (this.alpha < 1.0);
      };
      NormalMaterial.prototype.needAlphaBlendingForMesh = function (mesh) {
          return this.needAlphaBlending() || (mesh.visibility < 1.0);
      };
      NormalMaterial.prototype.needAlphaTesting = function () {
          return false;
      };
      NormalMaterial.prototype.getAlphaTestTexture = function () {
          return null;
      };
      // Methods
      NormalMaterial.prototype.isReadyForSubMesh = function (mesh, subMesh, useInstances) {
          if (this.isFrozen) {
              if (subMesh.effect && subMesh.effect._wasPreviouslyReady) {
                  return true;
              }
          }
          if (!subMesh._materialDefines) {
              subMesh._materialDefines = new NormalMaterialDefines();
          }
          var defines = subMesh._materialDefines;
          var scene = this.getScene();
          if (this._isReadyForSubMesh(subMesh)) {
              return true;
          }
          var engine = scene.getEngine();
          // Textures
          if (defines._areTexturesDirty) {
              defines._needUVs = false;
              if (scene.texturesEnabled) {
                  if (this._diffuseTexture && MaterialFlags.DiffuseTextureEnabled) {
                      if (!this._diffuseTexture.isReady()) {
                          return false;
                      }
                      else {
                          defines._needUVs = true;
                          defines.DIFFUSE = true;
                      }
                  }
              }
          }
          // Misc.
          MaterialHelper.PrepareDefinesForMisc(mesh, scene, false, this.pointsCloud, this.fogEnabled, this._shouldTurnAlphaTestOn(mesh), defines);
          // Lights
          defines._needNormals = true;
          MaterialHelper.PrepareDefinesForLights(scene, mesh, defines, false, this._maxSimultaneousLights, this._disableLighting);
          // Values that need to be evaluated on every frame
          MaterialHelper.PrepareDefinesForFrameBoundValues(scene, engine, defines, useInstances ? true : false);
          defines.LIGHTING = !this._disableLighting;
          // Attribs
          MaterialHelper.PrepareDefinesForAttributes(mesh, defines, true, true);
          // Get correct effect
          if (defines.isDirty) {
              defines.markAsProcessed();
              scene.resetCachedMaterial();
              // Fallbacks
              var fallbacks = new EffectFallbacks();
              if (defines.FOG) {
                  fallbacks.addFallback(1, "FOG");
              }
              MaterialHelper.HandleFallbacksForShadows(defines, fallbacks);
              if (defines.NUM_BONE_INFLUENCERS > 0) {
                  fallbacks.addCPUSkinningFallback(0, mesh);
              }
              defines.IMAGEPROCESSINGPOSTPROCESS = scene.imageProcessingConfiguration.applyByPostProcess;
              //Attributes
              var attribs = [VertexBuffer.PositionKind];
              if (defines.NORMAL) {
                  attribs.push(VertexBuffer.NormalKind);
              }
              if (defines.UV1) {
                  attribs.push(VertexBuffer.UVKind);
              }
              if (defines.UV2) {
                  attribs.push(VertexBuffer.UV2Kind);
              }
              MaterialHelper.PrepareAttributesForBones(attribs, mesh, defines, fallbacks);
              MaterialHelper.PrepareAttributesForInstances(attribs, defines);
              var shaderName = "normal";
              var join = defines.toString();
              var uniforms = ["world", "view", "viewProjection", "vEyePosition", "vLightsType", "vDiffuseColor",
                  "vFogInfos", "vFogColor", "pointSize",
                  "vDiffuseInfos",
                  "mBones",
                  "vClipPlane", "vClipPlane2", "vClipPlane3", "vClipPlane4", "vClipPlane5", "vClipPlane6", "diffuseMatrix"
              ];
              var samplers = ["diffuseSampler"];
              var uniformBuffers = new Array();
              MaterialHelper.PrepareUniformsAndSamplersList({
                  uniformsNames: uniforms,
                  uniformBuffersNames: uniformBuffers,
                  samplers: samplers,
                  defines: defines,
                  maxSimultaneousLights: 4
              });
              subMesh.setEffect(scene.getEngine().createEffect(shaderName, {
                  attributes: attribs,
                  uniformsNames: uniforms,
                  uniformBuffersNames: uniformBuffers,
                  samplers: samplers,
                  defines: join,
                  fallbacks: fallbacks,
                  onCompiled: this.onCompiled,
                  onError: this.onError,
                  indexParameters: { maxSimultaneousLights: 4 }
              }, engine), defines);
          }
          if (!subMesh.effect || !subMesh.effect.isReady()) {
              return false;
          }
          defines._renderId = scene.getRenderId();
          subMesh.effect._wasPreviouslyReady = true;
          return true;
      };
      NormalMaterial.prototype.bindForSubMesh = function (world, mesh, subMesh) {
          var scene = this.getScene();
          var defines = subMesh._materialDefines;
          if (!defines) {
              return;
          }
          var effect = subMesh.effect;
          if (!effect) {
              return;
          }
          this._activeEffect = effect;
          // Matrices
          this.bindOnlyWorldMatrix(world);
          this._activeEffect.setMatrix("viewProjection", scene.getTransformMatrix());
          // Bones
          MaterialHelper.BindBonesParameters(mesh, this._activeEffect);
          if (this._mustRebind(scene, effect)) {
              // Textures
              if (this.diffuseTexture && MaterialFlags.DiffuseTextureEnabled) {
                  this._activeEffect.setTexture("diffuseSampler", this.diffuseTexture);
                  this._activeEffect.setFloat2("vDiffuseInfos", this.diffuseTexture.coordinatesIndex, this.diffuseTexture.level);
                  this._activeEffect.setMatrix("diffuseMatrix", this.diffuseTexture.getTextureMatrix());
              }
              // Clip plane
              MaterialHelper.BindClipPlane(this._activeEffect, scene);
              // Point size
              if (this.pointsCloud) {
                  this._activeEffect.setFloat("pointSize", this.pointSize);
              }
              MaterialHelper.BindEyePosition(effect, scene);
          }
          this._activeEffect.setColor4("vDiffuseColor", this.diffuseColor, this.alpha * mesh.visibility);
          // Lights
          if (scene.lightsEnabled && !this.disableLighting) {
              MaterialHelper.BindLights(scene, mesh, this._activeEffect, defines);
          }
          // View
          if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== Scene.FOGMODE_NONE) {
              this._activeEffect.setMatrix("view", scene.getViewMatrix());
          }
          // Fog
          MaterialHelper.BindFogParameters(scene, mesh, this._activeEffect);
          this._afterBind(mesh, this._activeEffect);
      };
      NormalMaterial.prototype.getAnimatables = function () {
          var results = [];
          if (this.diffuseTexture && this.diffuseTexture.animations && this.diffuseTexture.animations.length > 0) {
              results.push(this.diffuseTexture);
          }
          return results;
      };
      NormalMaterial.prototype.getActiveTextures = function () {
          var activeTextures = _super.prototype.getActiveTextures.call(this);
          if (this._diffuseTexture) {
              activeTextures.push(this._diffuseTexture);
          }
          return activeTextures;
      };
      NormalMaterial.prototype.hasTexture = function (texture) {
          if (_super.prototype.hasTexture.call(this, texture)) {
              return true;
          }
          if (this.diffuseTexture === texture) {
              return true;
          }
          return false;
      };
      NormalMaterial.prototype.dispose = function (forceDisposeEffect) {
          if (this.diffuseTexture) {
              this.diffuseTexture.dispose();
          }
          _super.prototype.dispose.call(this, forceDisposeEffect);
      };
      NormalMaterial.prototype.clone = function (name) {
          var _this = this;
          return SerializationHelper.Clone(function () { return new NormalMaterial(name, _this.getScene()); }, this);
      };
      NormalMaterial.prototype.serialize = function () {
          var serializationObject = SerializationHelper.Serialize(this);
          serializationObject.customType = "BABYLON.NormalMaterial";
          return serializationObject;
      };
      NormalMaterial.prototype.getClassName = function () {
          return "NormalMaterial";
      };
      // Statics
      NormalMaterial.Parse = function (source, scene, rootUrl) {
          return SerializationHelper.Parse(function () { return new NormalMaterial(source.name, scene); }, source, scene, rootUrl);
      };
      __decorate([
          serializeAsTexture("diffuseTexture")
      ], NormalMaterial.prototype, "_diffuseTexture", void 0);
      __decorate([
          expandToProperty("_markAllSubMeshesAsTexturesDirty")
      ], NormalMaterial.prototype, "diffuseTexture", void 0);
      __decorate([
          serializeAsColor3()
      ], NormalMaterial.prototype, "diffuseColor", void 0);
      __decorate([
          serialize("disableLighting")
      ], NormalMaterial.prototype, "_disableLighting", void 0);
      __decorate([
          expandToProperty("_markAllSubMeshesAsLightsDirty")
      ], NormalMaterial.prototype, "disableLighting", void 0);
      __decorate([
          serialize("maxSimultaneousLights")
      ], NormalMaterial.prototype, "_maxSimultaneousLights", void 0);
      __decorate([
          expandToProperty("_markAllSubMeshesAsLightsDirty")
      ], NormalMaterial.prototype, "maxSimultaneousLights", void 0);
      return NormalMaterial;
  }(PushMaterial));
  export { NormalMaterial };
  _TypeStore.RegisteredTypes["BABYLON.NormalMaterial"] = NormalMaterial;
  //# sourceMappingURL=normalMaterial.js.map