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