@predy-js/render-interface 0.1.61-beta.7 → 0.1.61-beta.8

package/dist/index.js

@@ -2,7 +2,7 @@
  * Name: @predy-js/render-interface
  * Description: undefined
  * Author: undefined
- * Version: v0.1.61-beta.7
+ * Version: v0.1.61-beta.8
  */
 
 'use strict';
@@ -470,7 +470,7 @@ function renderMeshes(renderer, state) {
         else if (!mesh.hide) {
             delegate.willRenderMesh && delegate.willRenderMesh(mesh, state);
             renderMesh(renderer, mesh, state);
-            delegate.didiRenderMesh && delegate.didiRenderMesh(mesh, state);
+            delegate.didRenderMesh && delegate.didRenderMesh(mesh, state);
         }
     }
     for (var i = 0; i < sortedMeshes.length; i++) {
@@ -1794,65 +1794,77 @@ var GLProgram = /** @class */ (function () {
             renderer.state.useProgram(this.glHandle);
         }
     };
+    GLProgram.prototype.getSemanticValue = function (state, semanticName) {
+        var renderPassSemantics = state.currentPass.semantics;
+        var renderFrameSemantics = state.currentFrame.semantics;
+        if (renderPassSemantics.hasSemanticValue(semanticName)) {
+            return renderPassSemantics.getSemanticValue(semanticName, state);
+        }
+        else if (renderFrameSemantics.hasSemanticValue(semanticName)) {
+            return renderFrameSemantics.getSemanticValue(semanticName, state);
+        }
+    };
     GLProgram.prototype.setupUniforms = function (state) {
         var _this = this;
         this.bind();
-        var frame = state.currentFrame;
         var material = state.currentMesh.material;
         var gl = this.renderer.gl;
         var blocks = material._dataBlocks;
         var shared = this.shared;
-        var uniformSemantics = material.uniformSemantics;
-        var renderPassSemantics = state.currentPass.semantics;
-        var renderFrameSemantics = frame.semantics;
-        // semantic {uModel:'MODEL'}
         temArr.clear();
         forEach(this.uniformBlockMap, function (uboInfo, name) {
             if (uboInfo) {
-                for (var i = 0; i < blocks.length; i++) {
-                    var block = blocks[i];
-                    var uboBuffer = block.createUboBuffer(uboInfo);
+                var block_1 = material.getDataBlockByName(uboInfo.name);
+                if (block_1) {
+                    forEach(block_1.uniformSemantics, function (semanticName, uniformName) {
+                        if (uniformName in uboInfo.uniforms && !block_1.hasUniformValue(uniformName)) {
+                            var val = _this.getSemanticValue(state, semanticName);
+                            if (val || val === 0) {
+                                block_1.setUniformValue(uniformName, val, true);
+                            }
+                        }
+                    });
+                    var uboBuffer = block_1.createUboBuffer(uboInfo);
                     if (uboBuffer) {
-                        block.setUboBuffer(uboBuffer);
-                        temArr.add(block);
+                        block_1.setUboBuffer(uboBuffer);
+                        temArr.add(block_1);
                         return uboBuffer.bind(gl, _this.glHandle, uboInfo.index);
                     }
                 }
             }
         });
         forEach(this.uniformInfoMap, function (info, name) {
-            var val, hasUniformValue;
+            var val;
             for (var i = 0; i < blocks.length; i++) {
                 var block = blocks[i];
-                if (temArr.has(block)) {
+                var semanticName = block.uniformSemantics[name];
+                if (info.isTexture) {
+                    if (block.hasUniformValue(name)) {
+                        val = block.getUniformTexture(name);
+                    }
+                    else if (semanticName) {
+                        val = _this.getSemanticValue(state, semanticName);
+                    }
+                }
+                else if (temArr.has(block)) {
                     continue;
                 }
-                if (block.hasUniformValue(name)) {
+                else if (block.hasUniformValue(name)) {
                     if (!shared && !block._uniformFlags[name] && info.textureIndex === -1) {
                         //not dirty, don't assign
                         return;
                     }
                     val = block.getUniformValue(name);
-                    hasUniformValue = true;
-                    break;
                 }
-            }
-            if (!hasUniformValue) {
-                var semanticName = uniformSemantics[name];
-                if (semanticName) {
-                    if (renderPassSemantics.hasSemanticValue(semanticName)) {
-                        val = renderPassSemantics.getSemanticValue(semanticName, state);
-                    }
-                    else if (renderFrameSemantics.hasSemanticValue(semanticName)) {
-                        val = renderFrameSemantics.getSemanticValue(semanticName, state);
-                    }
+                else if (semanticName) {
+                    val = _this.getSemanticValue(state, semanticName);
+                }
+                if (val !== undefined && val !== null) {
+                    _this.setGLUniformValue(name, val, info, gl);
+                }
+                else if (!info.isTexture) {
+                    consoleWarn("mesh ".concat(state.currentMesh.name, " uniform ").concat(name, " value unset"));
                 }
-            }
-            if (val !== undefined && val !== null) {
-                _this.setGLUniformValue(name, val, info, gl);
-            }
-            else if (!info.isTexture) {
-                consoleWarn("mesh ".concat(state.currentMesh.name, " uniform ").concat(name, " value unset"));
             }
         });
     };
@@ -4456,25 +4468,29 @@ var GLMaterial = /** @class */ (function () {
 }());
 
 function isUniformStruct(value) {
-    return (isObj(value)) && (value.length === undefined) && value.assignRenderer === undefined;
+    return (isObj(value)) && (value.length === undefined);
 }
 function isUniformStructArray(value) {
     return (value) && (value.length !== undefined) && isUniformStruct(value[0]);
 }
 var MarsMaterialDataBlock = /** @class */ (function () {
     function MarsMaterialDataBlock(props, renderer) {
+        var _this = this;
         this._isDestroyed = false;
         this._isDestroyed = false;
         this.name = props.name || 'defDataBlock';
         this._uniformValues = {};
         this._uniformFlags = {};
         this.uboBufferMap = {};
+        this._uniformTextures = {};
         this._uniformValueRanges = {};
         this._keepUboData = !!props.keepUboData;
-        this.uniformSemantics = props.uniformSemantics;
+        this.uniformSemantics = props.uniformSemantics || {};
+        this._uniformPrivate = {};
         if (props.uniformValues) {
             this.setUniformValues(props.uniformValues);
         }
+        forEach(props.uniformTextures, function (tex, name) { return _this.setUniformTexture(name, tex); });
         if (renderer) {
             this.assignRenderer(renderer);
         }
@@ -4512,6 +4528,20 @@ var MarsMaterialDataBlock = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    MarsMaterialDataBlock.prototype.setUniformTexture = function (uniformName, texture) {
+        if (texture) {
+            this._uniformTextures[uniformName] = texture;
+            this._assignUniformValueRenderer(texture, this.renderer);
+            this._uniformPrivate[uniformName] = true;
+        }
+        else {
+            delete this._uniformTextures[uniformName];
+            delete this._uniformPrivate[uniformName];
+        }
+    };
+    MarsMaterialDataBlock.prototype.getUniformTexture = function (uniformName) {
+        return this._uniformTextures[uniformName];
+    };
     MarsMaterialDataBlock.prototype.assignRenderer = function (renderer) {
         var _this = this;
         if (this.renderer && renderer !== this.renderer) {
@@ -4520,7 +4550,7 @@ var MarsMaterialDataBlock = /** @class */ (function () {
         if (renderer && !this.renderer) {
             // @ts-expect-error safe to assign
             this.renderer = renderer;
-            forEach(this._uniformValues, function (value) {
+            forEach(this._uniformTextures, function (value) {
                 _this._assignUniformValueRenderer(value, renderer);
             });
         }
@@ -4549,11 +4579,11 @@ var MarsMaterialDataBlock = /** @class */ (function () {
         this._uniformFlags[name] = true;
     };
     MarsMaterialDataBlock.prototype.hasUniformValue = function (name) {
-        return name in this._uniformValues;
+        return !!this._uniformPrivate[name];
     };
     MarsMaterialDataBlock.prototype.destroy = function (options) {
         if ((options === null || options === void 0 ? void 0 : options.textures) !== exports.DestroyOptions.keep) {
-            forEach(this._uniformValues, function (uniform) {
+            forEach(this._uniformTextures, function (uniform) {
                 if (uniform instanceof MarsTexture) {
                     uniform.destroy();
                 }
@@ -4566,10 +4596,13 @@ var MarsMaterialDataBlock = /** @class */ (function () {
         });
         // @ts-expect-error safe to assign
         this.uboBufferMap = {};
+        this._uniformPrivate = {};
         // @ts-expect-error safe to assign
         this._uniformFlags = {};
         // @ts-expect-error safe to assign
         this._uniformValues = {};
+        // @ts-expect-error safe to assign
+        this._uniformTextures = {};
         this.assignRenderer = throwDestroyedError;
         this._isDestroyed = true;
     };
@@ -4579,20 +4612,39 @@ var MarsMaterialDataBlock = /** @class */ (function () {
     MarsMaterialDataBlock.prototype.getUniformValues = function () {
         return this._uniformValues;
     };
-    MarsMaterialDataBlock.prototype.setUniformValue = function (name, value) {
+    MarsMaterialDataBlock.prototype.setUniformValue = function (name, value, isSemantic) {
         var _this = this;
         if (value === undefined) {
+            var originValue = this._uniformValues[name];
+            if (isUniformStruct(originValue)) {
+                forEach(originValue, function (data, key) {
+                    var nameInStruct = name + '.' + key;
+                    delete _this._uniformPrivate[nameInStruct];
+                });
+            }
+            else if (isUniformStructArray(originValue)) {
+                originValue.forEach(function (valueData, i) {
+                    forEach(valueData, function (valueInStruct, key) {
+                        var nameInStruct = name + '[' + i + ']' + '.' + key;
+                        delete _this._uniformPrivate[nameInStruct];
+                    });
+                });
+            }
             delete this._uniformValues[name];
             this._uniformFlags[name] = false;
+            delete this._uniformPrivate[name];
+        }
+        else if (value instanceof MarsTexture) {
+            throw Error('setUniformValue not accept texture:' + name);
         }
         else {
+            this._uniformPrivate[name] = !isSemantic;
             if (isUniformStruct(value)) {
                 forEach(value, function (data, key) {
                     var nameInStruct = name + '.' + key;
-                    var valueInStruct = data;
-                    _this._uniformValues[nameInStruct] = valueInStruct;
+                    _this._uniformValues[nameInStruct] = data;
                     _this._uniformFlags[nameInStruct] = true;
-                    _this._assignUniformValueRenderer(valueInStruct, _this.renderer);
+                    _this._uniformPrivate[nameInStruct] = true;
                 });
                 // 只是用来保存结构体对象
                 this._uniformValues[name] = value;
@@ -4604,7 +4656,7 @@ var MarsMaterialDataBlock = /** @class */ (function () {
                         var nameInStruct = name + '[' + i + ']' + '.' + key;
                         _this._uniformValues[nameInStruct] = valueInStruct;
                         _this._uniformFlags[nameInStruct] = true;
-                        _this._assignUniformValueRenderer(valueInStruct, _this.renderer);
+                        _this._uniformPrivate[nameInStruct] = true;
                     });
                 });
                 // 只是用来保存结构体对象
@@ -4614,7 +4666,6 @@ var MarsMaterialDataBlock = /** @class */ (function () {
             else {
                 this._uniformValues[name] = value;
                 this._uniformFlags[name] = true;
-                this._assignUniformValueRenderer(value, this.renderer);
             }
         }
         return true;
@@ -4625,6 +4676,14 @@ var MarsMaterialDataBlock = /** @class */ (function () {
             _this.setUniformValue(key, val);
         });
     };
+    MarsMaterialDataBlock.prototype.setUniformSemantic = function (name, semantic) {
+        if (semantic) {
+            this.uniformSemantics[name] = semantic;
+        }
+        else {
+            delete this.uniformSemantics[name];
+        }
+    };
     MarsMaterialDataBlock.prototype.clone = function (name) {
         return new MarsMaterialDataBlock({
             name: name,
@@ -4643,13 +4702,10 @@ var MarsMaterial = /** @class */ (function () {
         this.renderType = 0 /* MaterialRenderType.normal */;
         this.states = this.createMaterialStates(options.states);
         this.options = options;
+        this._dbMap = {};
         if (!this._dataBlocks.length) {
-            this._dataBlocks[0] = new MarsMaterialDataBlock({ name: '' });
-        }
-        if (options.uniformValues) {
-            this.defaultDataBlock.setUniformValues(options.uniformValues);
+            this._dataBlocks[0] = new MarsMaterialDataBlock({ name: 'main' });
         }
-        this.uniformSemantics = Object.assign({}, options.uniformSemantics);
     }
     Object.defineProperty(MarsMaterial.prototype, "isDestroyed", {
         get: function () {
@@ -4660,7 +4716,7 @@ var MarsMaterial = /** @class */ (function () {
     });
     Object.defineProperty(MarsMaterial.prototype, "dataBlocks", {
         get: function () {
-            return this._dataBlocks.slice();
+            return this._dataBlocks;
         },
         enumerable: false,
         configurable: true
@@ -4732,6 +4788,9 @@ var MarsMaterial = /** @class */ (function () {
         return Object.freeze(ret);
     };
     MarsMaterial.prototype.addDataBlock = function (b) {
+        if (this.getDataBlockByName(b.name)) {
+            throw Error('dataBlock with same name:' + b.name);
+        }
         if (arrAdd(this._dataBlocks, b)) {
             b.invalidAllFlags();
             var r = this.renderer;
@@ -4740,17 +4799,19 @@ var MarsMaterial = /** @class */ (function () {
             }
         }
     };
+    MarsMaterial.prototype.getDataBlockByName = function (name) {
+        var cache = this._dbMap[name];
+        if (!cache) {
+            var db = this._dataBlocks.find(function (db) { return db.name === name; });
+            if (db) {
+                return this._dbMap[name] = db;
+            }
+        }
+        return cache;
+    };
     MarsMaterial.prototype.removeDataBlock = function (b) {
         arrRemove(this._dataBlocks, b);
     };
-    MarsMaterial.prototype.setUniformSemantic = function (uniformName, semantic) {
-        if (semantic === undefined) {
-            delete this.uniformSemantics[uniformName];
-        }
-        else {
-            this.uniformSemantics[uniformName] = semantic;
-        }
-    };
     MarsMaterial.prototype.assignRenderer = function (renderer) {
         if (!this.materialInternal) {
             var shader = this.options.shader;
@@ -5520,7 +5581,7 @@ var MarsExtWrap = /** @class */ (function () {
                 fb.viewport[3] = target.height || source.height;
                 renderer.internal.resetColorAttachments(fb, [target.internal]);
                 var mesh = rp.meshes[0];
-                mesh.material.defaultDataBlock.setUniformValue('uTex', source);
+                mesh.material.defaultDataBlock.setUniformTexture('uTex', source);
                 RenderFrameInternal.renderRenderPass(renderer, rp, { currentFrame: {} });
             }
         }
@@ -5665,6 +5726,20 @@ var MarsRenderer = /** @class */ (function () {
             }
         }
     };
+    MarsRenderer.prototype.cancelAnimationFrame = function (id) {
+        return window.cancelAnimationFrame(id);
+    };
+    MarsRenderer.prototype.getErrors = function () {
+        var gl = this.internal.gl;
+        var err = gl.getError();
+        if (err) {
+            return ['webgl error:' + err];
+        }
+        return [];
+    };
+    MarsRenderer.prototype.requestAnimationFrame = function (cb) {
+        return window.requestAnimationFrame(cb);
+    };
     return MarsRenderer;
 }());
 
@@ -5731,7 +5806,7 @@ var MarsSharedGeometry = /** @class */ (function (_super) {
     return MarsSharedGeometry;
 }(MarsGeometry));
 
-consoleLog('version: ' + "0.1.61-beta.7");
+consoleLog('version: ' + "0.1.61-beta.8");
 
 exports.Geometry = MarsGeometry;
 exports.InstancedMesh = MarsInstancedMesh;