refine the logic on supportComputeBuffer check

Author: zhuxingwei

Runtime/ui/renderer/cmdbufferCanvas/rendering/canvas_computebuffer_utils.cs

@@ -22,16 +22,10 @@ struct uiVertex
 
         static int _instanceNum;
 
-        public static bool enableComputeBuffer = true;
-
         public const int COMPUTE_BUFFER_MAX_ITEM_NUM = 1024 * 1024;   // maxsize = 1M vertex/index
 
-        public static bool supportComputeBuffer {
-            get { return SystemInfo.supportsComputeShaders && CanvasShader.supportComputeBuffer && enableComputeBuffer; }
-        }
-
         static void tryReleaseComputeBuffer() {
-            if (!supportComputeBuffer) {
+            if (!CanvasShader.supportComputeBuffer) {
                 return;
             }
 
@@ -63,7 +57,7 @@ void initComputeBuffer() {
         }
 
         void resetComputeBuffer() {
-            if (!supportComputeBuffer) return;
+            if (!CanvasShader.supportComputeBuffer) return;
 
             if (_computeBuffer == null) {
                 this.initComputeBuffer();
@@ -76,14 +70,14 @@ void resetComputeBuffer() {
         }
 
         void bindComputeBuffer() {
-            if (!supportComputeBuffer) return;
+            if (!CanvasShader.supportComputeBuffer) return;
 
             _computeBuffer.SetData(_vertices);
             _indexBuffer.SetData(_indices);
         }
 
         void addMeshToComputeBuffer(List<Vector3> vertex, List<Vector2> uv, List<int> triangles) {
-            if (!supportComputeBuffer) return;
+            if (!CanvasShader.supportComputeBuffer) return;
 
             _startVertex = _vertices.Count;
             _startIndex = _indices.Count;

Runtime/ui/renderer/cmdbufferCanvas/rendering/canvas_impl.cs

@@ -157,12 +157,12 @@ void _saveLayer(uiRect bounds, uiPaint paint) {
                             this._saveLayer_Points[2],
                             this._saveLayer_Points[3],
                             bounds);
-                        var renderDraw = CanvasShader.texRT(layer, layer.layerPaint.Value, mesh, parentLayer, supportComputeBuffer);
+                        var renderDraw = CanvasShader.texRT(layer, layer.layerPaint.Value, mesh, parentLayer);
                         layer.draws.Add(renderDraw);
 
                         var blurLayer = this._createBlurLayer(layer, filter.sigmaX, filter.sigmaY, layer);
                         var blurMesh = ImageMeshGenerator.imageMesh(null, uiRectHelper.one, bounds);
-                        layer.draws.Add(CanvasShader.texRT(layer, paint, blurMesh, blurLayer, supportComputeBuffer));
+                        layer.draws.Add(CanvasShader.texRT(layer, paint, blurMesh, blurLayer));
                     }
                 }
                 else if (paint.backdrop is _MatrixImageFilter) {
@@ -195,7 +195,7 @@ void _saveLayer(uiRect bounds, uiPaint paint) {
                             this._saveLayer_Points[2],
                             this._saveLayer_Points[3],
                             bounds);
-                        var renderDraw = CanvasShader.texRT(layer, layer.layerPaint.Value, mesh, parentLayer, supportComputeBuffer);
+                        var renderDraw = CanvasShader.texRT(layer, layer.layerPaint.Value, mesh, parentLayer);
                         layer.draws.Add(renderDraw);
                     }
                 }
@@ -224,7 +224,7 @@ void _restore() {
                 return;
             }
 
-            var renderDraw = CanvasShader.texRT(currentLayer, layer.layerPaint.Value, mesh, layer, supportComputeBuffer);
+            var renderDraw = CanvasShader.texRT(currentLayer, layer.layerPaint.Value, mesh, layer);
             currentLayer.draws.Add(renderDraw);
         }
 
@@ -366,11 +366,11 @@ bool _applyClip(uiRect? queryBounds) {
                     // need to inflate a bit to make sure all area is cleared.
                     var inflatedScissor = uiRectHelper.inflate(reducedClip.scissor.Value, this._fringeWidth);
                     var boundsMesh = uiMeshMesh.create(inflatedScissor);
-                    layer.draws.Add(CanvasShader.stencilClear(layer, boundsMesh, supportComputeBuffer));
+                    layer.draws.Add(CanvasShader.stencilClear(layer, boundsMesh));
 
                     foreach (var maskElement in reducedClip.maskElements) {
-                        layer.draws.Add(CanvasShader.stencil0(layer, maskElement.mesh.duplicate(), supportComputeBuffer));
-                        layer.draws.Add(CanvasShader.stencil1(layer, boundsMesh.duplicate(), supportComputeBuffer));
+                        layer.draws.Add(CanvasShader.stencil0(layer, maskElement.mesh.duplicate()));
+                        layer.draws.Add(CanvasShader.stencil1(layer, boundsMesh.duplicate()));
                     }
                 }
 
@@ -478,11 +478,11 @@ RenderLayer _createBlurLayer(RenderLayer maskLayer, float sigmaX, float sigmaY,
 
             blurXLayer.draws.Add(CanvasShader.maskFilter(
                 blurXLayer, blurMesh, maskLayer,
-                radiusX, new Vector2(1f / textureWidth, 0), kernelX, supportComputeBuffer));
+                radiusX, new Vector2(1f / textureWidth, 0), kernelX));
 
             blurYLayer.draws.Add(CanvasShader.maskFilter(
                 blurYLayer, blurMesh.duplicate(), blurXLayer,
-                radiusY, new Vector2(0, -1f / textureHeight), kernelY, supportComputeBuffer));
+                radiusY, new Vector2(0, -1f / textureHeight), kernelY));
 
             return blurYLayer;
         }
@@ -534,7 +534,7 @@ void _drawWithMaskFilter(uiRect meshBounds, uiPaint paint, uiMaskFilter maskFilt
                 return;
             }
 
-            layer.draws.Add(CanvasShader.texRT(layer, paint, blurMesh, blurLayer, supportComputeBuffer));
+            layer.draws.Add(CanvasShader.texRT(layer, paint, blurMesh, blurLayer));
         }
 
         delegate void _drawPathDrawMeshCallbackDelegate(uiPaint p, uiMeshMesh fillMesh, uiMeshMesh strokeMesh,
@@ -552,16 +552,16 @@ void _drawPathDrawMeshCallback(uiPaint p, uiMeshMesh fillMesh, uiMeshMesh stroke
 
             var layer = this._currentLayer;
             if (convex) {
-                layer.draws.Add(CanvasShader.convexFill(layer, p, fillMesh, supportComputeBuffer));
+                layer.draws.Add(CanvasShader.convexFill(layer, p, fillMesh));
             }
             else {
-                layer.draws.Add(CanvasShader.fill0(layer, fillMesh, supportComputeBuffer));
-                layer.draws.Add(CanvasShader.fill1(layer, p, fillMesh.boundsMesh, supportComputeBuffer));
+                layer.draws.Add(CanvasShader.fill0(layer, fillMesh));
+                layer.draws.Add(CanvasShader.fill1(layer, p, fillMesh.boundsMesh));
             }
 
             if (strokeMesh != null) {
-                layer.draws.Add(CanvasShader.strokeAlpha(layer, p, alpha, strokeMult, strokeMesh, supportComputeBuffer));
-                layer.draws.Add(CanvasShader.stroke1(layer, strokeMesh.duplicate(), supportComputeBuffer));
+                layer.draws.Add(CanvasShader.strokeAlpha(layer, p, alpha, strokeMult, strokeMesh));
+                layer.draws.Add(CanvasShader.stroke1(layer, strokeMesh.duplicate()));
             }
         }
 
@@ -575,8 +575,8 @@ void _drawPathDrawMeshCallback2(uiPaint p, uiMeshMesh fillMesh, uiMeshMesh strok
 
             var layer = this._currentLayer;
 
-            layer.draws.Add(CanvasShader.strokeAlpha(layer, p, alpha, strokeMult, strokeMesh, supportComputeBuffer));
-            layer.draws.Add(CanvasShader.stroke1(layer, strokeMesh.duplicate(), supportComputeBuffer));
+            layer.draws.Add(CanvasShader.strokeAlpha(layer, p, alpha, strokeMult, strokeMesh));
+            layer.draws.Add(CanvasShader.stroke1(layer, strokeMesh.duplicate()));
         }
 
         void _drawTextDrawMeshCallback(uiPaint p, uiMeshMesh fillMesh, uiMeshMesh strokeMesh, bool convex, float alpha,
@@ -589,7 +589,7 @@ void _drawTextDrawMeshCallback(uiPaint p, uiMeshMesh fillMesh, uiMeshMesh stroke
 
             var layer = this._currentLayer;
             if (notEmoji) {
-                layer.draws.Add(CanvasShader.texAlpha(layer, p, textMesh, tex, supportComputeBuffer));
+                layer.draws.Add(CanvasShader.texAlpha(layer, p, textMesh, tex));
             }
             else {
                 uiPaint paintWithWhite = new uiPaint(p);
@@ -602,7 +602,7 @@ void _drawTextDrawMeshCallback(uiPaint p, uiMeshMesh fillMesh, uiMeshMesh stroke
                 var raw_mesh = textMesh.resolveMesh();
                 var meshmesh = raw_mesh.duplicate();
                 ObjectPool<TextBlobMesh>.release(textMesh);
-                layer.draws.Add(CanvasShader.tex(layer, paintWithWhite, meshmesh, EmojiUtils.image, supportComputeBuffer));
+                layer.draws.Add(CanvasShader.tex(layer, paintWithWhite, meshmesh, EmojiUtils.image));
             }
         }
 
@@ -716,7 +716,7 @@ void _drawImageRect(Image image, uiRect? src, uiRect dst, uiPaint paint) {
                 return;
             }
 
-            layer.draws.Add(CanvasShader.tex(layer, paint, mesh, image, supportComputeBuffer));
+            layer.draws.Add(CanvasShader.tex(layer, paint, mesh, image));
         }
 
         void _drawImageNine(Image image, uiRect? src, uiRect center, uiRect dst, uiPaint paint) {
@@ -743,7 +743,7 @@ void _drawImageNine(Image image, uiRect? src, uiRect center, uiRect dst, uiPaint
                 return;
             }
 
-            layer.draws.Add(CanvasShader.tex(layer, paint, mesh, image, supportComputeBuffer));
+            layer.draws.Add(CanvasShader.tex(layer, paint, mesh, image));
         }
 
 
@@ -1163,7 +1163,7 @@ void _drawLayer(RenderLayer layer, CommandBuffer cmdBuf) {
                         }
 
                         D.assert(mesh.vertices.Count > 0);
-                        if (supportComputeBuffer) {
+                        if (CanvasShader.supportComputeBuffer) {
                             this.addMeshToComputeBuffer(mesh.vertices?.data, mesh.uv?.data, mesh.triangles?.data);
                             cmd.properties.SetBuffer(CmdDraw.vertexBufferId, _computeBuffer);
                             cmd.properties.SetBuffer(CmdDraw.indexBufferId, _indexBuffer);

Runtime/ui/renderer/cmdbufferCanvas/rendering/canvas_shader.cs

@@ -177,14 +177,16 @@ static Shader GetShader(string shaderName) {
             return shader;
         }
 
+        public static bool enableComputeBuffer = true;
+
         public static readonly bool supportComputeBuffer;
 
         static CanvasShader() {
             var convexFillShaderCompute = GetShader("UIWidgets/canvas_convexFill_cb");
-            supportComputeBuffer = convexFillShaderCompute.isSupported;
+            supportComputeBuffer = enableComputeBuffer && SystemInfo.supportsComputeShaders && convexFillShaderCompute.isSupported;
 
-            //if compute buffer is not supported, load normal shaders
-            if (!PictureFlusher.supportComputeBuffer) {
+            //if compute buffer is not supported, load normal shader
+            if (!supportComputeBuffer) {
                 var convexFillShader = GetShader("UIWidgets/canvas_convexFill");
                 var fill0Shader = GetShader("UIWidgets/canvas_fill0");
                 var fill1Shader = GetShader("UIWidgets/canvas_fill1");
@@ -345,7 +347,7 @@ static void _getShaderPassAndProps(
         }
 
         public static PictureFlusher.CmdDraw convexFill(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh, bool supportComputeBuffer) {
+            uiMeshMesh mesh) {
             var mat = supportComputeBuffer ? _convexFillMat_cb.getMaterial(paint.blendMode, layer.ignoreClip) : _convexFillMat.getMaterial(paint.blendMode, layer.ignoreClip);
 
             _getShaderPassAndProps(layer, paint, mesh.matrix, 1.0f, 0.0f, out var pass, out var props);
@@ -358,7 +360,7 @@ public static PictureFlusher.CmdDraw convexFill(PictureFlusher.RenderLayer layer
             );
         }
 
-        public static PictureFlusher.CmdDraw fill0(PictureFlusher.RenderLayer layer, uiMeshMesh mesh, bool supportComputeBuffer) {
+        public static PictureFlusher.CmdDraw fill0(PictureFlusher.RenderLayer layer, uiMeshMesh mesh) {
             Vector4 viewport = layer.viewport;
             var mat = supportComputeBuffer ? _fill0Mat_cb.getMaterial(layer.ignoreClip) : _fill0Mat.getMaterial(layer.ignoreClip);
 
@@ -375,7 +377,7 @@ public static PictureFlusher.CmdDraw fill0(PictureFlusher.RenderLayer layer, uiM
         }
 
         public static PictureFlusher.CmdDraw fill1(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh, bool supportComputeBuffer) {
+            uiMeshMesh mesh) {
             var mat = supportComputeBuffer
                 ? _fill1Mat_cb.getMaterial(paint.blendMode)
                 : _fill1Mat.getMaterial(paint.blendMode);
@@ -393,7 +395,7 @@ public static PictureFlusher.CmdDraw fill1(PictureFlusher.RenderLayer layer, uiP
         }
 
         public static PictureFlusher.CmdDraw stroke0(PictureFlusher.RenderLayer layer, uiPaint paint,
-            float alpha, uiMeshMesh mesh, bool supportComputeBuffer) {
+            float alpha, uiMeshMesh mesh) {
             var mat = supportComputeBuffer 
                 ? _stroke0Mat_cb.getMaterial(paint.blendMode, layer.ignoreClip) 
                 : _stroke0Mat.getMaterial(paint.blendMode, layer.ignoreClip);
@@ -407,7 +409,7 @@ public static PictureFlusher.CmdDraw stroke0(PictureFlusher.RenderLayer layer, u
             );
         }
 
-        public static PictureFlusher.CmdDraw stroke1(PictureFlusher.RenderLayer layer, uiMeshMesh mesh, bool supportComputeBuffer) {
+        public static PictureFlusher.CmdDraw stroke1(PictureFlusher.RenderLayer layer, uiMeshMesh mesh) {
             Vector4 viewport = layer.viewport;
             var mat = supportComputeBuffer ? _stroke1Mat_cb : _stroke1Mat;
 
@@ -423,7 +425,7 @@ public static PictureFlusher.CmdDraw stroke1(PictureFlusher.RenderLayer layer, u
             );
         }
 
-        public static PictureFlusher.CmdDraw strokeAlpha(PictureFlusher.RenderLayer layer, uiPaint paint, float alpha, float strokeMult, uiMeshMesh mesh, bool supportComputeBuffer) {
+        public static PictureFlusher.CmdDraw strokeAlpha(PictureFlusher.RenderLayer layer, uiPaint paint, float alpha, float strokeMult, uiMeshMesh mesh) {
             var mat = supportComputeBuffer 
                 ? _strokeAlphaMat_cb.getMaterial(paint.blendMode, layer.ignoreClip) 
                 : _strokeAlphaMat.getMaterial(paint.blendMode, layer.ignoreClip);
@@ -438,7 +440,7 @@ public static PictureFlusher.CmdDraw strokeAlpha(PictureFlusher.RenderLayer laye
         }
 
         public static PictureFlusher.CmdDraw stencilClear(
-            PictureFlusher.RenderLayer layer, uiMeshMesh mesh, bool supportComputeBuffer) {
+            PictureFlusher.RenderLayer layer, uiMeshMesh mesh) {
             Vector4 viewport = layer.viewport;
             var mat = supportComputeBuffer ? _stencilMat_cb : _stencilMat;
 
@@ -454,7 +456,7 @@ public static PictureFlusher.CmdDraw stencilClear(
             );
         }
 
-        public static PictureFlusher.CmdDraw stencil0(PictureFlusher.RenderLayer layer, uiMeshMesh mesh, bool supportComputeBuffer) {
+        public static PictureFlusher.CmdDraw stencil0(PictureFlusher.RenderLayer layer, uiMeshMesh mesh) {
             Vector4 viewport = layer.viewport;
             var mat = supportComputeBuffer ? _stencilMat_cb : _stencilMat;
 
@@ -470,7 +472,7 @@ public static PictureFlusher.CmdDraw stencil0(PictureFlusher.RenderLayer layer,
             );
         }
 
-        public static PictureFlusher.CmdDraw stencil1(PictureFlusher.RenderLayer layer, uiMeshMesh mesh, bool supportComputeBuffer) {
+        public static PictureFlusher.CmdDraw stencil1(PictureFlusher.RenderLayer layer, uiMeshMesh mesh) {
             Vector4 viewport = layer.viewport;
             var mat = supportComputeBuffer ? _stencilMat_cb : _stencilMat;
 
@@ -487,7 +489,7 @@ public static PictureFlusher.CmdDraw stencil1(PictureFlusher.RenderLayer layer,
         }
 
         public static PictureFlusher.CmdDraw tex(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh, Image image, bool supportComputeBuffer) {
+            uiMeshMesh mesh, Image image) {
             var mat = supportComputeBuffer 
                 ? _texMat_cb.getMaterial(paint.blendMode, layer.ignoreClip) 
                 : _texMat.getMaterial(paint.blendMode, layer.ignoreClip);
@@ -507,7 +509,7 @@ public static PictureFlusher.CmdDraw tex(PictureFlusher.RenderLayer layer, uiPai
         }
 
         public static PictureFlusher.CmdDraw texRT(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh, PictureFlusher.RenderLayer renderLayer, bool supportComputeBuffer) {
+            uiMeshMesh mesh, PictureFlusher.RenderLayer renderLayer) {
             var mat = supportComputeBuffer 
                 ? _texMat_cb.getMaterial(paint.blendMode, layer.ignoreClip) 
                 : _texMat.getMaterial(paint.blendMode, layer.ignoreClip);
@@ -524,17 +526,17 @@ public static PictureFlusher.CmdDraw texRT(PictureFlusher.RenderLayer layer, uiP
         }
 
         public static PictureFlusher.CmdDraw texAlpha(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh, Texture tex, bool supportComputeBuffer) {
-            return texAlpha(layer, paint, mesh, null, tex, supportComputeBuffer);
+            uiMeshMesh mesh, Texture tex) {
+            return texAlpha(layer, paint, mesh, null, tex);
         }
 
         public static PictureFlusher.CmdDraw texAlpha(PictureFlusher.RenderLayer layer, uiPaint paint,
-            TextBlobMesh textMesh, Texture tex, bool supportComputeBuffer) {
-            return texAlpha(layer, paint, null, textMesh, tex, supportComputeBuffer);
+            TextBlobMesh textMesh, Texture tex) {
+            return texAlpha(layer, paint, null, textMesh, tex);
         }
 
         public static PictureFlusher.CmdDraw texAlpha(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh, TextBlobMesh textMesh, Texture tex, bool supportComputeBuffer) {
+            uiMeshMesh mesh, TextBlobMesh textMesh, Texture tex) {
             var mat = supportComputeBuffer 
                 ?_texMat_cb.getMaterial(paint.blendMode, layer.ignoreClip) 
                 :_texMat.getMaterial(paint.blendMode, layer.ignoreClip);
@@ -554,7 +556,7 @@ public static PictureFlusher.CmdDraw texAlpha(PictureFlusher.RenderLayer layer,
         }
 
         public static PictureFlusher.CmdDraw maskFilter(PictureFlusher.RenderLayer layer, uiMeshMesh mesh,
-            PictureFlusher.RenderLayer renderLayer, float radius, Vector2 imgInc, float[] kernel, bool supportComputeBuffer) {
+            PictureFlusher.RenderLayer renderLayer, float radius, Vector2 imgInc, float[] kernel) {
             Vector4 viewport = layer.viewport;
             var mat = supportComputeBuffer ? _filterMat_cb : _filterMat;
 
@@ -576,7 +578,7 @@ public static PictureFlusher.CmdDraw maskFilter(PictureFlusher.RenderLayer layer
         }
 
         public static PictureFlusher.CmdDraw fastShadow(PictureFlusher.RenderLayer layer, uiMeshMesh mesh, float sigma,
-            bool isRect, bool isCircle, float corner, Vector4 bound, uiColor color, bool supportComputeBuffer) {
+            bool isRect, bool isCircle, float corner, Vector4 bound, uiColor color) {
             Vector4 viewport = layer.viewport;
             var mat = supportComputeBuffer ? _shadowBox_cb : _shadowBox;
             if (!isRect) {

Runtime/ui/renderer/cmdbufferCanvas/rendering/canvas_shadow_utils.cs

@@ -67,7 +67,7 @@ void _drawRRectShadow(uiPath path, uiPaint paint) {
             ObjectPool<uiMeshMesh>.release(meshBounds);
             ObjectPool<uiMeshMesh>.release(blurMesh);
             var mesh = uiMeshMesh.create(state.matrix, vertices, _triangles);
-            layer.draws.Add(CanvasShader.fastShadow(layer, mesh, sigma, path.isRect, path.isCircle, path.rRectCorner, new Vector4(bound.left, bound.top, bound.right, bound.bottom), paint.color, supportComputeBuffer));
+            layer.draws.Add(CanvasShader.fastShadow(layer, mesh, sigma, path.isRect, path.isCircle, path.rRectCorner, new Vector4(bound.left, bound.top, bound.right, bound.bottom), paint.color));
         }
 
     }