@galacean/engine-core 2.0.0-alpha.53 → 2.0.0-alpha.55

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/module.js CHANGED
@@ -4449,6 +4449,45 @@ var RenderStateElementKey = /*#__PURE__*/ function(RenderStateElementKey) {
4449
4449
  return StencilOperation;
4450
4450
  }({});
4451
4451
 
4452
+ function _array_like_to_array(arr, len) {
4453
+ if (len == null || len > arr.length) len = arr.length;
4454
+
4455
+ for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
4456
+
4457
+ return arr2;
4458
+ }
4459
+
4460
+ function _unsupported_iterable_to_array(o, minLen) {
4461
+ if (!o) return;
4462
+ if (typeof o === "string") return _array_like_to_array(o, minLen);
4463
+
4464
+ var n = Object.prototype.toString.call(o).slice(8, -1);
4465
+
4466
+ if (n === "Object" && o.constructor) n = o.constructor.name;
4467
+ if (n === "Map" || n === "Set") return Array.from(n);
4468
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
4469
+ }
4470
+
4471
+ function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
4472
+ var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
4473
+
4474
+ if (it) return (it = it.call(o)).next.bind(it);
4475
+ // Fallback for engines without symbol support
4476
+ if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
4477
+ if (it) o = it;
4478
+
4479
+ var i = 0;
4480
+
4481
+ return function() {
4482
+ if (i >= o.length) return { done: true };
4483
+
4484
+ return { done: false, value: o[i++] };
4485
+ };
4486
+ }
4487
+
4488
+ throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
4489
+ }
4490
+
4452
4491
  /**
4453
4492
  * Shader macro。
4454
4493
  */ var ShaderMacro = /*#__PURE__*/ function() {
@@ -8014,45 +8053,6 @@ ShaderTagKey._nameMap = Object.create(null);
8014
8053
  }();
8015
8054
  ShaderProgram._counter = 0;
8016
8055
 
8017
- function _array_like_to_array(arr, len) {
8018
- if (len == null || len > arr.length) len = arr.length;
8019
-
8020
- for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
8021
-
8022
- return arr2;
8023
- }
8024
-
8025
- function _unsupported_iterable_to_array(o, minLen) {
8026
- if (!o) return;
8027
- if (typeof o === "string") return _array_like_to_array(o, minLen);
8028
-
8029
- var n = Object.prototype.toString.call(o).slice(8, -1);
8030
-
8031
- if (n === "Object" && o.constructor) n = o.constructor.name;
8032
- if (n === "Map" || n === "Set") return Array.from(n);
8033
- if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
8034
- }
8035
-
8036
- function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
8037
- var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
8038
-
8039
- if (it) return (it = it.call(o)).next.bind(it);
8040
- // Fallback for engines without symbol support
8041
- if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
8042
- if (it) o = it;
8043
-
8044
- var i = 0;
8045
-
8046
- return function() {
8047
- if (i >= o.length) return { done: true };
8048
-
8049
- return { done: false, value: o[i++] };
8050
- };
8051
- }
8052
-
8053
- throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
8054
- }
8055
-
8056
8056
  /**
8057
8057
  * @internal
8058
8058
  */ var ShaderMacroProcessor = /*#__PURE__*/ function() {
@@ -9144,11 +9144,13 @@ ShaderPass._macroMap = new Map();
9144
9144
  * Shader for rendering.
9145
9145
  */ var Shader = /*#__PURE__*/ function() {
9146
9146
  function Shader(name, subShaders) {
9147
+ var _Shader__shaderMap, _name;
9147
9148
  this.name = name;
9148
9149
  this._refCount = 0;
9149
9150
  this._destroyed = false;
9150
- this.name = name;
9151
9151
  this._subShaders = subShaders;
9152
+ var _;
9153
+ ((_ = (_Shader__shaderMap = Shader._shaderMap)[_name = name]) != null ? _ : _Shader__shaderMap[_name] = []).push(this);
9152
9154
  }
9153
9155
  var _proto = Shader.prototype;
9154
9156
  /**
@@ -9185,11 +9187,12 @@ ShaderPass._macroMap = new Map();
9185
9187
  return isValid;
9186
9188
  };
9187
9189
  /**
9188
- * Destroy the shader.
9189
- * @param force - Whether to force the destruction, if it is false, refCount = 0 can be released successfully.
9190
- * @returns Whether the release was successful.
9190
+ * Destroy this shader and remove it from name lookup.
9191
+ * @param force - Whether to destroy the shader even while it is in use
9192
+ * @returns Whether the shader was destroyed or had already been destroyed.
9191
9193
  */ _proto.destroy = function destroy(force) {
9192
9194
  if (force === void 0) force = false;
9195
+ if (this._destroyed) return true;
9193
9196
  if (!force && this._refCount !== 0) {
9194
9197
  return false;
9195
9198
  }
@@ -9200,7 +9203,9 @@ ShaderPass._macroMap = new Map();
9200
9203
  passes[j]._destroy();
9201
9204
  }
9202
9205
  }
9203
- delete Shader._shaderMap[this.name];
9206
+ var shaders = Shader._shaderMap[this.name];
9207
+ shaders.splice(shaders.indexOf(this), 1);
9208
+ if (shaders.length === 0) delete Shader._shaderMap[this.name];
9204
9209
  this._destroyed = true;
9205
9210
  return true;
9206
9211
  };
@@ -9219,32 +9224,22 @@ ShaderPass._macroMap = new Map();
9219
9224
  var platformTarget = typeof shaderPassesOrSubShadersOrPlatformTarget === "number" ? shaderPassesOrSubShadersOrPlatformTarget : ShaderLanguage.GLSLES100;
9220
9225
  return Shader._createFromSource(nameOrShaderSource, platformTarget);
9221
9226
  }
9222
- var shader;
9223
- var shaderMap = Shader._shaderMap;
9224
- if (shaderMap[nameOrShaderSource]) {
9225
- console.error('Shader named "' + nameOrShaderSource + '" already exists.');
9226
- return;
9227
- }
9228
- if (shaderPassesOrSubShadersOrPlatformTarget.length > 0) {
9229
- if (shaderPassesOrSubShadersOrPlatformTarget[0].constructor === ShaderPass) {
9230
- shader = new Shader(nameOrShaderSource, [
9231
- new SubShader("Default", shaderPassesOrSubShadersOrPlatformTarget)
9232
- ]);
9233
- } else {
9234
- shader = new Shader(nameOrShaderSource, shaderPassesOrSubShadersOrPlatformTarget.slice());
9235
- }
9236
- } else {
9227
+ if (shaderPassesOrSubShadersOrPlatformTarget.length === 0) {
9237
9228
  throw "SubShader or ShaderPass count must large than 0.";
9238
9229
  }
9239
- shaderMap[nameOrShaderSource] = shader;
9240
- return shader;
9230
+ if (shaderPassesOrSubShadersOrPlatformTarget[0].constructor === ShaderPass) {
9231
+ return new Shader(nameOrShaderSource, [
9232
+ new SubShader("Default", shaderPassesOrSubShadersOrPlatformTarget)
9233
+ ]);
9234
+ }
9235
+ return new Shader(nameOrShaderSource, shaderPassesOrSubShadersOrPlatformTarget.slice());
9241
9236
  };
9242
9237
  /**
9243
9238
  * Creates a shader while retaining loader-owned source location metadata for relative includes.
9244
9239
  * @param shaderSource - Complete ShaderLab source.
9245
9240
  * @param platformTarget - Shader backend target.
9246
9241
  * @param sourceFile - Canonical source location supplied by an asset loader or authoring tool.
9247
- * @returns The compiled shader, or `undefined` if its name already exists.
9242
+ * @returns A new shader.
9248
9243
  * @throws When the shader compiler is unavailable or a pass cannot be compiled.
9249
9244
  * @internal
9250
9245
  */ Shader._createFromSource = function _createFromSource(shaderSource, platformTarget, sourceFile) {
@@ -9254,11 +9249,6 @@ ShaderPass._macroMap = new Map();
9254
9249
  throw "ShaderCompiler has not been set up yet.";
9255
9250
  }
9256
9251
  var parsedSource = shaderCompiler._parseShaderSource(shaderSource);
9257
- var shaderMap = Shader._shaderMap;
9258
- if (shaderMap[parsedSource.name]) {
9259
- console.error('Shader named "' + parsedSource.name + '" already exists.');
9260
- return;
9261
- }
9262
9252
  var subShaderList = parsedSource.subShaders.map(function(subShaderSource) {
9263
9253
  var passList = subShaderSource.passes.map(function(passSource) {
9264
9254
  if (passSource.isUsePass) {
@@ -9274,24 +9264,22 @@ ShaderPass._macroMap = new Map();
9274
9264
  });
9275
9265
  return new SubShader(subShaderSource.name, passList, subShaderSource.tags);
9276
9266
  });
9277
- var shader = new Shader(parsedSource.name, subShaderList);
9278
- shaderMap[parsedSource.name] = shader;
9279
- return shader;
9267
+ return new Shader(parsedSource.name, subShaderList);
9280
9268
  };
9281
9269
  /**
9282
9270
  * Find a shader by name.
9283
9271
  * @param name - Name of the shader
9272
+ * @returns The most recently registered live shader with this name, or `undefined` if none exists.
9273
+ * @remarks Retain the shader object when a material must use a specific shader among namesakes.
9284
9274
  */ Shader.find = function find(name) {
9285
- return Shader._shaderMap[name];
9275
+ var shaders = Shader._shaderMap[name];
9276
+ return shaders == null ? void 0 : shaders[shaders.length - 1];
9286
9277
  };
9287
9278
  /**
9279
+ * Create a shader from precompiled instructions.
9280
+ * @param data - Precompiled shader data
9288
9281
  * @internal
9289
9282
  */ Shader._createFromPrecompiled = function _createFromPrecompiled(data) {
9290
- var shaderMap = Shader._shaderMap;
9291
- if (shaderMap[data.name]) {
9292
- console.error('Shader named "' + data.name + '" already exists.');
9293
- return;
9294
- }
9295
9283
  var subShaderList = data.subShaders.map(function(subData) {
9296
9284
  var passList = subData.passes.map(function(passData) {
9297
9285
  if (passData.isUsePass) {
@@ -9303,27 +9291,27 @@ ShaderPass._macroMap = new Map();
9303
9291
  });
9304
9292
  return new SubShader(subData.name, passList, subData.tags);
9305
9293
  });
9306
- var shader = new Shader(data.name, subShaderList);
9307
- shaderMap[data.name] = shader;
9308
- return shader;
9294
+ return new Shader(data.name, subShaderList);
9309
9295
  };
9310
9296
  /**
9311
9297
  * @internal
9312
9298
  */ Shader._clear = function _clear(engine) {
9313
9299
  var shaderMap = Shader._shaderMap;
9314
9300
  for(var key in shaderMap){
9315
- var shader = shaderMap[key];
9316
- var subShaders = shader._subShaders;
9317
- for(var i = 0, n = subShaders.length; i < n; i++){
9318
- var passes = subShaders[i].passes;
9319
- for(var j = 0, m = passes.length; j < m; j++){
9320
- var pass = passes[j];
9321
- var passShaderProgramMaps = pass._shaderProgramMaps;
9322
- for(var k = passShaderProgramMaps.length - 1; k >= 0; k--){
9323
- var map = passShaderProgramMaps[k];
9324
- if (map.engine !== engine) continue;
9325
- map.destroy();
9326
- passShaderProgramMaps.splice(k, 1);
9301
+ for(var _iterator = _create_for_of_iterator_helper_loose(shaderMap[key]), _step; !(_step = _iterator()).done;){
9302
+ var shader = _step.value;
9303
+ var subShaders = shader._subShaders;
9304
+ for(var i = 0, n = subShaders.length; i < n; i++){
9305
+ var passes = subShaders[i].passes;
9306
+ for(var j = 0, m = passes.length; j < m; j++){
9307
+ var pass = passes[j];
9308
+ var passShaderProgramMaps = pass._shaderProgramMaps;
9309
+ for(var k = passShaderProgramMaps.length - 1; k >= 0; k--){
9310
+ var map = passShaderProgramMaps[k];
9311
+ if (map.engine !== engine) continue;
9312
+ map.destroy();
9313
+ passShaderProgramMaps.splice(k, 1);
9314
+ }
9327
9315
  }
9328
9316
  }
9329
9317
  }