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