@galacean/engine-rhi-webgl 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/module.js

@@ -286,6 +286,14 @@ var GLBuffer = /*#__PURE__*/ function() {
             throw "Buffer is write-only on WebGL1.0 platforms.";
         }
     };
+    _proto.copyFromBuffer = function copyFromBuffer(srcBuffer, srcByteOffset, dstByteOffset, byteLength) {
+        var gl = this._gl;
+        gl.bindBuffer(gl.COPY_READ_BUFFER, srcBuffer._glBuffer);
+        gl.bindBuffer(gl.COPY_WRITE_BUFFER, this._glBuffer);
+        gl.copyBufferSubData(gl.COPY_READ_BUFFER, gl.COPY_WRITE_BUFFER, srcByteOffset, dstByteOffset, byteLength);
+        gl.bindBuffer(gl.COPY_READ_BUFFER, null);
+        gl.bindBuffer(gl.COPY_WRITE_BUFFER, null);
+    };
     _proto.destroy = function destroy() {
         this._gl.deleteBuffer(this._glBuffer);
         this._gl = null;
@@ -902,7 +910,7 @@ var GLBuffer = /*#__PURE__*/ function() {
                 return {
                     internalFormat: isSRGBColorSpace ? gl.SRGB8 : isWebGL2 ? gl.RGB8 : gl.RGB,
                     baseFormat: isSRGBColorSpace ? isWebGL2 ? gl.RGB : gl.SRGB8 : gl.RGB,
-                    readFormat: gl.RGB,
+                    readFormat: isWebGL2 ? gl.RGBA : gl.RGB,
                     dataType: gl.UNSIGNED_BYTE,
                     isCompressed: false,
                     alignment: 1
@@ -977,6 +985,7 @@ var GLBuffer = /*#__PURE__*/ function() {
                 return {
                     internalFormat: gl.R11F_G11F_B10F,
                     baseFormat: gl.RGB,
+                    readFormat: gl.RGBA,
                     dataType: gl.FLOAT,
                     isCompressed: false,
                     alignment: 4
@@ -1409,11 +1418,6 @@ var GLBuffer = /*#__PURE__*/ function() {
         })) {
             throw new Error("MRT+Cube+[,MSAA] is not supported");
         }
-        var maxAntiAliasing = rhi.capability.maxAntiAliasing;
-        if (target.antiAliasing > maxAntiAliasing) {
-            Logger.warn("MSAA antiAliasing exceeds the limit and is automatically downgraded to:" + maxAntiAliasing);
-            /** @ts-ignore */ target._antiAliasing = maxAntiAliasing;
-        }
         this._frameBuffer = this._gl.createFramebuffer();
         // bind main FBO
         this._bindMainFBO();
@@ -1503,7 +1507,7 @@ var GLBuffer = /*#__PURE__*/ function() {
     _proto._bindMainFBO = function _bindMainFBO() {
         var gl = this._gl;
         var isWebGL2 = this._isWebGL2;
-        /** @ts-ignore */ var _this__target = this._target, _depth = _this__target._depth, colorTextureCount = _this__target.colorTextureCount, width = _this__target.width, height = _this__target.height;
+        /** @ts-ignore */ var _this__target = this._target, _depth = _this__target._depth, colorTextureCount = _this__target.colorTextureCount; _this__target.width; _this__target.height;
         var drawBuffers = new Array(colorTextureCount);
         gl.bindFramebuffer(gl.FRAMEBUFFER, this._frameBuffer);
         /** color render buffer */ for(var i = 0; i < colorTextureCount; i++){
@@ -1525,11 +1529,7 @@ var GLBuffer = /*#__PURE__*/ function() {
                 gl.framebufferTexture2D(gl.FRAMEBUFFER, platformTexture._formatDetail.attachment, gl.TEXTURE_2D, platformTexture._glTexture, 0);
             } else if (this._target.antiAliasing <= 1) {
                 var _GLTexture__getRenderBufferDepthFormatDetail = GLTexture._getRenderBufferDepthFormatDetail(_depth, gl, isWebGL2), internalFormat = _GLTexture__getRenderBufferDepthFormatDetail.internalFormat, attachment1 = _GLTexture__getRenderBufferDepthFormatDetail.attachment;
-                var depthRenderBuffer = gl.createRenderbuffer();
-                this._depthRenderBuffer = depthRenderBuffer;
-                gl.bindRenderbuffer(gl.RENDERBUFFER, depthRenderBuffer);
-                gl.renderbufferStorage(gl.RENDERBUFFER, internalFormat, width, height);
-                gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment1, gl.RENDERBUFFER, depthRenderBuffer);
+                this._depthRenderBuffer = this._createRenderBuffer(internalFormat, attachment1);
             }
         }
         gl.bindFramebuffer(gl.FRAMEBUFFER, null);
@@ -1538,32 +1538,38 @@ var GLBuffer = /*#__PURE__*/ function() {
     _proto._bindMSAAFBO = function _bindMSAAFBO() {
         var gl = this._gl;
         var isWebGL2 = this._isWebGL2;
-        var MSAADepthRenderBuffer = gl.createRenderbuffer();
-        /** @ts-ignore */ var _this__target = this._target, _depth = _this__target._depth, colorTextureCount = _this__target.colorTextureCount, antiAliasing = _this__target.antiAliasing, width = _this__target.width, height = _this__target.height;
+        /** @ts-ignore */ var _this__target = this._target, _depth = _this__target._depth, colorTextureCount = _this__target.colorTextureCount;
         this._blitDrawBuffers = new Array(colorTextureCount);
-        this._MSAADepthRenderBuffer = MSAADepthRenderBuffer;
         gl.bindFramebuffer(gl.FRAMEBUFFER, this._MSAAFrameBuffer);
         // prepare MRT+MSAA color RBOs
         for(var i = 0; i < colorTextureCount; i++){
-            var MSAAColorRenderBuffer = gl.createRenderbuffer();
-            this._MSAAColorRenderBuffers[i] = MSAAColorRenderBuffer;
             this._blitDrawBuffers[i] = gl.NONE;
-            gl.bindRenderbuffer(gl.RENDERBUFFER, MSAAColorRenderBuffer);
-            gl.renderbufferStorageMultisample(gl.RENDERBUFFER, antiAliasing, /** @ts-ignore */ this._target.getColorTexture(i)._platformTexture._formatDetail.internalFormat, width, height);
-            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0 + i, gl.RENDERBUFFER, MSAAColorRenderBuffer);
+            var internalFormat = /** @ts-ignore */ this._target.getColorTexture(i)._platformTexture._formatDetail.internalFormat;
+            this._MSAAColorRenderBuffers[i] = this._createRenderBuffer(internalFormat, gl.COLOR_ATTACHMENT0 + i);
         }
         gl.drawBuffers(this._oriDrawBuffers);
         // prepare MSAA depth RBO
         if (_depth !== null) {
-            var _ref = _instanceof(_depth, Texture) ? /** @ts-ignore */ _depth._platformTexture._formatDetail : GLTexture._getRenderBufferDepthFormatDetail(_depth, gl, isWebGL2), internalFormat = _ref.internalFormat, attachment = _ref.attachment;
-            gl.bindRenderbuffer(gl.RENDERBUFFER, MSAADepthRenderBuffer);
-            gl.renderbufferStorageMultisample(gl.RENDERBUFFER, antiAliasing, internalFormat, width, height);
-            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, MSAADepthRenderBuffer);
+            var _ref = _instanceof(_depth, Texture) ? /** @ts-ignore */ _depth._platformTexture._formatDetail : GLTexture._getRenderBufferDepthFormatDetail(_depth, gl, isWebGL2), internalFormat1 = _ref.internalFormat, attachment = _ref.attachment;
+            this._MSAADepthRenderBuffer = this._createRenderBuffer(internalFormat1, attachment);
         }
         this._checkFrameBuffer();
         gl.bindFramebuffer(gl.FRAMEBUFFER, null);
         gl.bindRenderbuffer(gl.RENDERBUFFER, null);
     };
+    _proto._createRenderBuffer = function _createRenderBuffer(internalFormat, attachment) {
+        var gl = this._gl;
+        var _this__target = this._target, width = _this__target.width, height = _this__target.height, antiAliasing = _this__target.antiAliasing;
+        var renderBuffer = gl.createRenderbuffer();
+        gl.bindRenderbuffer(gl.RENDERBUFFER, renderBuffer);
+        if (antiAliasing > 1) {
+            gl.renderbufferStorageMultisample(gl.RENDERBUFFER, antiAliasing, internalFormat, width, height);
+        } else {
+            gl.renderbufferStorage(gl.RENDERBUFFER, internalFormat, width, height);
+        }
+        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, renderBuffer);
+        return renderBuffer;
+    };
     _proto._checkFrameBuffer = function _checkFrameBuffer() {
         var gl = this._gl;
         var e = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
@@ -1681,12 +1687,12 @@ var GLBuffer = /*#__PURE__*/ function() {
         height = height || Math.max(1, this._texture.height >> mipLevel) - y;
         length = length || this._texture.length;
         this._bind();
-        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 0);
-        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
-        gl.pixelStorei(gl.UNPACK_ALIGNMENT, formatDetail.alignment);
         if (isCompressed) {
             gl.compressedTexSubImage3D(target, mipLevel, x, y, offsetIndex, width, height, length, internalFormat, colorBuffer);
         } else {
+            gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 0);
+            gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
+            gl.pixelStorei(gl.UNPACK_ALIGNMENT, formatDetail.alignment);
             gl.texSubImage3D(target, mipLevel, x, y, offsetIndex, width, height, length, baseFormat, dataType, colorBuffer);
         }
     };
@@ -1761,9 +1767,6 @@ var GLBuffer = /*#__PURE__*/ function() {
         width = width || mipSize - x;
         height = height || mipSize - y;
         this._bind();
-        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 0);
-        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
-        gl.pixelStorei(gl.UNPACK_ALIGNMENT, formatDetail.alignment);
         if (isCompressed) {
             var mipBit = 1 << mipLevel;
             if (isWebGL2 || this._compressedFaceFilled[face] & mipBit) {
@@ -1773,6 +1776,9 @@ var GLBuffer = /*#__PURE__*/ function() {
                 this._compressedFaceFilled[face] |= mipBit;
             }
         } else {
+            gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 0);
+            gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
+            gl.pixelStorei(gl.UNPACK_ALIGNMENT, formatDetail.alignment);
             gl.texSubImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X + face, mipLevel, x, y, width, height, baseFormat, dataType, colorBuffer);
         }
     };
@@ -1797,6 +1803,159 @@ var GLBuffer = /*#__PURE__*/ function() {
     return GLTextureCube;
 }(GLTexture);
 
+/**
+ * @internal
+ * WebGL2 implementation of Transform Feedback.
+ */ var GLTransformFeedback = /*#__PURE__*/ function() {
+    function GLTransformFeedback(rhi) {
+        var gl = rhi.gl;
+        this._gl = gl;
+        this._glTransformFeedback = gl.createTransformFeedback();
+    }
+    var _proto = GLTransformFeedback.prototype;
+    _proto.bindBufferRange = function bindBufferRange(index, buffer, byteOffset, byteSize) {
+        var gl = this._gl;
+        gl.bindBufferRange(gl.TRANSFORM_FEEDBACK_BUFFER, index, buffer._glBuffer, byteOffset, byteSize);
+    };
+    _proto.unbindBuffer = function unbindBuffer(index) {
+        var gl = this._gl;
+        gl.bindBufferBase(gl.TRANSFORM_FEEDBACK_BUFFER, index, null);
+    };
+    _proto.begin = function begin(primitiveMode) {
+        this._gl.beginTransformFeedback(primitiveMode);
+    };
+    _proto.end = function end() {
+        this._gl.endTransformFeedback();
+    };
+    _proto.bind = function bind() {
+        var gl = this._gl;
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, this._glTransformFeedback);
+    };
+    _proto.unbind = function unbind() {
+        var gl = this._gl;
+        gl.bindTransformFeedback(gl.TRANSFORM_FEEDBACK, null);
+    };
+    _proto.destroy = function destroy() {
+        if (this._glTransformFeedback) {
+            this._gl.deleteTransformFeedback(this._glTransformFeedback);
+            this._glTransformFeedback = null;
+        }
+    };
+    return GLTransformFeedback;
+}();
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+}
+
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+
+        var i = 0;
+
+        return function() {
+            if (i >= o.length) return { done: true };
+
+            return { done: false, value: o[i++] };
+        };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+/**
+ * @internal
+ * WebGL2 implementation of Transform Feedback primitive.
+ * Maintains two VAOs (one per read direction), auto-rebuilds when program changes.
+ */ var GLTransformFeedbackPrimitive = /*#__PURE__*/ function() {
+    function GLTransformFeedbackPrimitive(gl) {
+        this._lastProgramId = -1;
+        this._gl = gl;
+    }
+    var _proto = GLTransformFeedbackPrimitive.prototype;
+    _proto.updateVertexLayout = function updateVertexLayout(program, readBinding, writeBinding, feedbackElements, inputBinding, inputElements) {
+        if (program.id === this._lastProgramId) return;
+        this._deleteVAOs();
+        var attribs = program.attributeLocation;
+        this._vaoA = this._createVAO(attribs, readBinding, feedbackElements, inputBinding, inputElements);
+        this._vaoB = this._createVAO(attribs, writeBinding, feedbackElements, inputBinding, inputElements);
+        this._lastProgramId = program.id;
+        this._gl.bindVertexArray(null);
+    };
+    _proto.bind = function bind(readIsA) {
+        this._gl.bindVertexArray(readIsA ? this._vaoA : this._vaoB);
+    };
+    _proto.unbind = function unbind() {
+        this._gl.bindVertexArray(null);
+    };
+    _proto.draw = function draw(mode, first, count) {
+        this._gl.drawArrays(mode, first, count);
+    };
+    _proto.invalidate = function invalidate() {
+        this._deleteVAOs();
+    };
+    _proto.destroy = function destroy() {
+        this._deleteVAOs();
+    };
+    _proto._deleteVAOs = function _deleteVAOs() {
+        var gl = this._gl;
+        if (this._vaoA) {
+            gl.deleteVertexArray(this._vaoA);
+            this._vaoA = null;
+        }
+        if (this._vaoB) {
+            gl.deleteVertexArray(this._vaoB);
+            this._vaoB = null;
+        }
+        this._lastProgramId = -1;
+    };
+    _proto._createVAO = function _createVAO(attribs, feedbackBinding, feedbackElements, inputBinding, inputElements) {
+        var gl = this._gl;
+        var vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        // @ts-ignore: Access internal _platformBuffer across packages
+        gl.bindBuffer(gl.ARRAY_BUFFER, feedbackBinding.buffer._platformBuffer._glBuffer);
+        this._bindElements(gl, attribs, feedbackElements, feedbackBinding.stride);
+        // @ts-ignore: Access internal _platformBuffer across packages
+        gl.bindBuffer(gl.ARRAY_BUFFER, inputBinding.buffer._platformBuffer._glBuffer);
+        this._bindElements(gl, attribs, inputElements, inputBinding.stride);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    };
+    _proto._bindElements = function _bindElements(gl, attribs, elements, stride) {
+        for(var _iterator = _create_for_of_iterator_helper_loose(elements), _step; !(_step = _iterator()).done;){
+            var element = _step.value;
+            var loc = attribs[element.attribute];
+            if (loc !== undefined && loc !== -1) {
+                var info = element._formatMetaInfo;
+                gl.enableVertexAttribArray(loc);
+                gl.vertexAttribPointer(loc, info.size, info.type, info.normalized, stride, element.offset);
+            }
+        }
+    };
+    return GLTransformFeedbackPrimitive;
+}();
+
 /**
  * WebGL mode.
  */ var WebGLMode = /*#__PURE__*/ function(WebGLMode) {
@@ -1918,6 +2077,37 @@ var GLBuffer = /*#__PURE__*/ function() {
         if (bufferUsage === void 0) bufferUsage = BufferUsage.Static;
         return new GLBuffer(this, type, byteLength, bufferUsage, data);
     };
+    _proto.createPlatformTransformFeedback = function createPlatformTransformFeedback() {
+        return new GLTransformFeedback(this);
+    };
+    _proto.createPlatformTransformFeedbackPrimitive = function createPlatformTransformFeedbackPrimitive() {
+        return new GLTransformFeedbackPrimitive(this._gl);
+    };
+    /**
+   * Enable GL_RASTERIZER_DISCARD (WebGL2 only).
+   */ _proto.enableRasterizerDiscard = function enableRasterizerDiscard() {
+        if (this._isWebGL2) {
+            var gl = this._gl;
+            gl.enable(gl.RASTERIZER_DISCARD);
+        }
+    };
+    /**
+   * Disable GL_RASTERIZER_DISCARD (WebGL2 only).
+   */ _proto.disableRasterizerDiscard = function disableRasterizerDiscard() {
+        if (this._isWebGL2) {
+            var gl = this._gl;
+            gl.disable(gl.RASTERIZER_DISCARD);
+        }
+    };
+    /**
+   * Invalidate the cached shader program state.
+   * Call this after using a custom program (e.g., Transform Feedback) outside the engine's pipeline.
+   */ _proto.invalidateShaderProgramState = function invalidateShaderProgramState() {
+        if (this._currentBindShaderProgram) {
+            this._gl.useProgram(null);
+            this._currentBindShaderProgram = null;
+        }
+    };
     _proto.requireExtension = function requireExtension(ext) {
         return this._extensions.requireExtension(ext);
     };