@galacean/engine-core 2.0.0-alpha.54 → 2.0.0-alpha.56

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() {
@@ -7123,10 +7162,8 @@ ShaderBlockProperty._nameMap = Object.create(null);
7123
7162
  mrtIndexSet.forEach(function(index) {
7124
7163
  declaration += "layout(location=" + index + ") out vec4 fragOutColor" + index + ";\n";
7125
7164
  });
7126
- declaration += "void main(";
7127
7165
  shader = shader.replace(/\bgl_FragData\[(.+?)\]/g, "fragOutColor$1");
7128
- shader = shader.replace(/void\s+?main\s*\(/g, declaration);
7129
- return shader;
7166
+ return declaration + shader;
7130
7167
  };
7131
7168
  return ShaderFactory;
7132
7169
  }();
@@ -8014,45 +8051,6 @@ ShaderTagKey._nameMap = Object.create(null);
8014
8051
  }();
8015
8052
  ShaderProgram._counter = 0;
8016
8053
 
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
8054
  /**
8057
8055
  * @internal
8058
8056
  */ var ShaderMacroProcessor = /*#__PURE__*/ function() {
@@ -9015,7 +9013,7 @@ var precisionStr = "\n #ifdef GL_FRAGMENT_PRECISION_HIGH\n precision hig
9015
9013
  * Shader pass containing vertex and fragment source.
9016
9014
  */ var ShaderPass = /*#__PURE__*/ function(ShaderPart) {
9017
9015
  _inherits(ShaderPass, ShaderPart);
9018
- function ShaderPass(name, vertexShaderInstructions, fragmentShaderInstructions, platformTarget, tags) {
9016
+ function ShaderPass(name, vertexShaderInstructions, fragmentShaderInstructions, platformTarget, tags, vertexOutputNames) {
9019
9017
  var _this;
9020
9018
  _this = ShaderPart.call(this) || this, /** @internal */ _this._shaderPassId = 0, /** @internal Pass-level render state — always present, populated from ShaderLab declarations. */ _this._renderState = new RenderState(), /** @internal */ _this._renderStateDataMap = {}, /** @internal */ _this._shaderProgramMaps = [];
9021
9019
  _this._shaderPassId = ShaderPass._shaderPassCounter++;
@@ -9023,6 +9021,7 @@ var precisionStr = "\n #ifdef GL_FRAGMENT_PRECISION_HIGH\n precision hig
9023
9021
  _this._vertexShaderInstructions = vertexShaderInstructions;
9024
9022
  _this._fragmentShaderInstructions = fragmentShaderInstructions;
9025
9023
  _this._platformTarget = platformTarget;
9024
+ _this._vertexOutputNames = vertexOutputNames;
9026
9025
  var mergedTags = _extends({
9027
9026
  pipelineStage: PipelineStage.Forward
9028
9027
  }, tags);
@@ -9058,6 +9057,12 @@ var precisionStr = "\n #ifdef GL_FRAGMENT_PRECISION_HIGH\n precision hig
9058
9057
  /**
9059
9058
  * @internal
9060
9059
  */ _proto._compileShaderProgram = function _compileShaderProgram(engine, macroCollection, feedbackVaryings) {
9060
+ var names = this._vertexOutputNames;
9061
+ if (names && (feedbackVaryings == null ? void 0 : feedbackVaryings.length)) {
9062
+ feedbackVaryings = feedbackVaryings.map(function(name) {
9063
+ return Object.prototype.hasOwnProperty.call(names, name) ? names[name] : name;
9064
+ });
9065
+ }
9061
9066
  var isGPUInstance = macroCollection.isEnable(InstanceBuffer.gpuInstanceMacro);
9062
9067
  var _this__compileShaderSource = this._compileShaderSource(engine, macroCollection, isGPUInstance), vertexSource = _this__compileShaderSource.vertexSource, fragmentSource = _this__compileShaderSource.fragmentSource, instanceLayout = _this__compileShaderSource.instanceLayout;
9063
9068
  var program = new ShaderProgram(engine, vertexSource, fragmentSource, feedbackVaryings);
@@ -9144,11 +9149,13 @@ ShaderPass._macroMap = new Map();
9144
9149
  * Shader for rendering.
9145
9150
  */ var Shader = /*#__PURE__*/ function() {
9146
9151
  function Shader(name, subShaders) {
9152
+ var _Shader__shaderMap, _name;
9147
9153
  this.name = name;
9148
9154
  this._refCount = 0;
9149
9155
  this._destroyed = false;
9150
- this.name = name;
9151
9156
  this._subShaders = subShaders;
9157
+ var _;
9158
+ ((_ = (_Shader__shaderMap = Shader._shaderMap)[_name = name]) != null ? _ : _Shader__shaderMap[_name] = []).push(this);
9152
9159
  }
9153
9160
  var _proto = Shader.prototype;
9154
9161
  /**
@@ -9185,11 +9192,12 @@ ShaderPass._macroMap = new Map();
9185
9192
  return isValid;
9186
9193
  };
9187
9194
  /**
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.
9195
+ * Destroy this shader and remove it from name lookup.
9196
+ * @param force - Whether to destroy the shader even while it is in use
9197
+ * @returns Whether the shader was destroyed or had already been destroyed.
9191
9198
  */ _proto.destroy = function destroy(force) {
9192
9199
  if (force === void 0) force = false;
9200
+ if (this._destroyed) return true;
9193
9201
  if (!force && this._refCount !== 0) {
9194
9202
  return false;
9195
9203
  }
@@ -9200,7 +9208,9 @@ ShaderPass._macroMap = new Map();
9200
9208
  passes[j]._destroy();
9201
9209
  }
9202
9210
  }
9203
- delete Shader._shaderMap[this.name];
9211
+ var shaders = Shader._shaderMap[this.name];
9212
+ shaders.splice(shaders.indexOf(this), 1);
9213
+ if (shaders.length === 0) delete Shader._shaderMap[this.name];
9204
9214
  this._destroyed = true;
9205
9215
  return true;
9206
9216
  };
@@ -9219,32 +9229,22 @@ ShaderPass._macroMap = new Map();
9219
9229
  var platformTarget = typeof shaderPassesOrSubShadersOrPlatformTarget === "number" ? shaderPassesOrSubShadersOrPlatformTarget : ShaderLanguage.GLSLES100;
9220
9230
  return Shader._createFromSource(nameOrShaderSource, platformTarget);
9221
9231
  }
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 {
9232
+ if (shaderPassesOrSubShadersOrPlatformTarget.length === 0) {
9237
9233
  throw "SubShader or ShaderPass count must large than 0.";
9238
9234
  }
9239
- shaderMap[nameOrShaderSource] = shader;
9240
- return shader;
9235
+ if (shaderPassesOrSubShadersOrPlatformTarget[0].constructor === ShaderPass) {
9236
+ return new Shader(nameOrShaderSource, [
9237
+ new SubShader("Default", shaderPassesOrSubShadersOrPlatformTarget)
9238
+ ]);
9239
+ }
9240
+ return new Shader(nameOrShaderSource, shaderPassesOrSubShadersOrPlatformTarget.slice());
9241
9241
  };
9242
9242
  /**
9243
9243
  * Creates a shader while retaining loader-owned source location metadata for relative includes.
9244
9244
  * @param shaderSource - Complete ShaderLab source.
9245
9245
  * @param platformTarget - Shader backend target.
9246
9246
  * @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.
9247
+ * @returns A new shader.
9248
9248
  * @throws When the shader compiler is unavailable or a pass cannot be compiled.
9249
9249
  * @internal
9250
9250
  */ Shader._createFromSource = function _createFromSource(shaderSource, platformTarget, sourceFile) {
@@ -9254,11 +9254,6 @@ ShaderPass._macroMap = new Map();
9254
9254
  throw "ShaderCompiler has not been set up yet.";
9255
9255
  }
9256
9256
  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
9257
  var subShaderList = parsedSource.subShaders.map(function(subShaderSource) {
9263
9258
  var passList = subShaderSource.passes.map(function(passSource) {
9264
9259
  if (passSource.isUsePass) {
@@ -9268,62 +9263,60 @@ ShaderPass._macroMap = new Map();
9268
9263
  if (!shaderPassSource) {
9269
9264
  throw 'Shader pass "' + parsedSource.name + "." + subShaderSource.name + "." + passSource.name + '" parse failed, please check the shader source code.';
9270
9265
  }
9271
- var shaderPass = new ShaderPass(passSource.name, shaderPassSource.vertexShaderInstructions, shaderPassSource.fragmentShaderInstructions, platformTarget, passSource.tags);
9266
+ var shaderPass = new ShaderPass(passSource.name, shaderPassSource.vertexShaderInstructions, shaderPassSource.fragmentShaderInstructions, platformTarget, passSource.tags, shaderPassSource.vertexOutputNames);
9272
9267
  Shader._applyRenderStates(shaderPass, passSource.renderStates.constantMap, passSource.renderStates.variableMap, false);
9273
9268
  return shaderPass;
9274
9269
  });
9275
9270
  return new SubShader(subShaderSource.name, passList, subShaderSource.tags);
9276
9271
  });
9277
- var shader = new Shader(parsedSource.name, subShaderList);
9278
- shaderMap[parsedSource.name] = shader;
9279
- return shader;
9272
+ return new Shader(parsedSource.name, subShaderList);
9280
9273
  };
9281
9274
  /**
9282
9275
  * Find a shader by name.
9283
9276
  * @param name - Name of the shader
9277
+ * @returns The most recently registered live shader with this name, or `undefined` if none exists.
9278
+ * @remarks Retain the shader object when a material must use a specific shader among namesakes.
9284
9279
  */ Shader.find = function find(name) {
9285
- return Shader._shaderMap[name];
9280
+ var shaders = Shader._shaderMap[name];
9281
+ return shaders == null ? void 0 : shaders[shaders.length - 1];
9286
9282
  };
9287
9283
  /**
9284
+ * Create a shader from precompiled instructions.
9285
+ * @param data - Precompiled shader data
9288
9286
  * @internal
9289
9287
  */ 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
9288
  var subShaderList = data.subShaders.map(function(subData) {
9296
9289
  var passList = subData.passes.map(function(passData) {
9297
9290
  if (passData.isUsePass) {
9298
9291
  return Shader._resolveUsePass(passData.name);
9299
9292
  }
9300
- var shaderPass = new ShaderPass(passData.name, passData.vertexShaderInstructions, passData.fragmentShaderInstructions, data.platformTarget, passData.tags);
9293
+ var shaderPass = new ShaderPass(passData.name, passData.vertexShaderInstructions, passData.fragmentShaderInstructions, data.platformTarget, passData.tags, passData.vertexOutputNames);
9301
9294
  Shader._applyRenderStates(shaderPass, passData.renderStates.constantMap, passData.renderStates.variableMap, true);
9302
9295
  return shaderPass;
9303
9296
  });
9304
9297
  return new SubShader(subData.name, passList, subData.tags);
9305
9298
  });
9306
- var shader = new Shader(data.name, subShaderList);
9307
- shaderMap[data.name] = shader;
9308
- return shader;
9299
+ return new Shader(data.name, subShaderList);
9309
9300
  };
9310
9301
  /**
9311
9302
  * @internal
9312
9303
  */ Shader._clear = function _clear(engine) {
9313
9304
  var shaderMap = Shader._shaderMap;
9314
9305
  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);
9306
+ for(var _iterator = _create_for_of_iterator_helper_loose(shaderMap[key]), _step; !(_step = _iterator()).done;){
9307
+ var shader = _step.value;
9308
+ var subShaders = shader._subShaders;
9309
+ for(var i = 0, n = subShaders.length; i < n; i++){
9310
+ var passes = subShaders[i].passes;
9311
+ for(var j = 0, m = passes.length; j < m; j++){
9312
+ var pass = passes[j];
9313
+ var passShaderProgramMaps = pass._shaderProgramMaps;
9314
+ for(var k = passShaderProgramMaps.length - 1; k >= 0; k--){
9315
+ var map = passShaderProgramMaps[k];
9316
+ if (map.engine !== engine) continue;
9317
+ map.destroy();
9318
+ passShaderProgramMaps.splice(k, 1);
9319
+ }
9327
9320
  }
9328
9321
  }
9329
9322
  }