release compute buffer when reference is none

Author: zhuxingwei

Runtime/editor/surface.cs

@@ -224,6 +224,7 @@ public void Dispose() {
 
             if (this._canvas != null) {
                 this._canvas.reset();
+                this._canvas.dispose();
                 this._canvas = null;
             }
         }

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

@@ -11,71 +11,101 @@ struct uiVertex
             public Vector2 uv;
         }
 
-        static ComputeBuffer computeBuffer;
-        static List<uiVertex> vertexes;
+        static ComputeBuffer _computeBuffer;
+        static List<uiVertex> _vertices;
 
-        static ComputeBuffer indexBuffer;
-        static List<int> indexes;
+        static ComputeBuffer _indexBuffer;
+        static List<int> _indices;
 
-        static int startVertex;
-        static int startIndex;
+        static int _startVertex;
+        static int _startIndex;
+
+        static int _instanceNum;
+
+        public static bool enableComputeBuffer = true;
+
+        public const int COMPUTE_BUFFER_MAX_ITEM_NUM = 1024 * 1024;   // maxsize = 1M vertex/index
 
         static bool supportComputeBuffer {
-            get { return CanvasShader.supportComputeBuffer; }
+            get { return SystemInfo.supportsComputeShaders && CanvasShader.supportComputeBuffer && enableComputeBuffer; }
+        }
+
+        static void tryReleaseComputeBuffer() {
+            _instanceNum--;
+
+            if (!supportComputeBuffer) {
+                return;
+            }
+
+            if (_computeBuffer == null) {
+                return;
+            }
+
+            if (_instanceNum != 0) {
+                return;
+            }
+
+            _computeBuffer.Dispose();
+            _indexBuffer.Dispose();
+            _vertices = null;
+            _indices = null;
+            _computeBuffer = null;
+            _indexBuffer = null;
         }
 
         void initComputeBuffer() {
             var stride = Marshal.SizeOf(typeof(uiVertex));
-            computeBuffer = new ComputeBuffer(1024 * 1024, stride);
-            vertexes = new List<uiVertex>();
+            var strideIndex = Marshal.SizeOf(typeof(int));
+            _computeBuffer = new ComputeBuffer(COMPUTE_BUFFER_MAX_ITEM_NUM, stride);
+            _vertices = new List<uiVertex>();
 
-            indexBuffer = new ComputeBuffer(1024 * 1024, Marshal.SizeOf(typeof(int)));
-            indexes = new List<int>();
+            _indexBuffer = new ComputeBuffer(COMPUTE_BUFFER_MAX_ITEM_NUM, strideIndex);
+            _indices = new List<int>();
         }
 
         void resetComputeBuffer() {
             if (!supportComputeBuffer) return;
 
-            if (computeBuffer == null) {
+            if (_computeBuffer == null) {
                 this.initComputeBuffer();
             }
 
-            vertexes.Clear();
-            indexes.Clear();
-            startVertex = 0;
-            startIndex = 0;
+            _vertices.Clear();
+            _indices.Clear();
+            _startVertex = 0;
+            _startIndex = 0;
         }
 
         void bindComputeBuffer() {
             if (!supportComputeBuffer) return;
 
-            computeBuffer.SetData(vertexes);
-            indexBuffer.SetData(indexes);
+            _computeBuffer.SetData(_vertices);
+            _indexBuffer.SetData(_indices);
         }
 
         void addMeshToComputeBuffer(List<Vector3> vertex, List<Vector2> uv, List<int> triangles) {
             if (!supportComputeBuffer) return;
 
-            startVertex = vertexes.Count;
-            startIndex = indexes.Count;
+            _startVertex = _vertices.Count;
+            _startIndex = _indices.Count;
 
             var hasUv = uv != null;
 
             for (int i = 0; i < vertex.Count; i++) {
-                vertexes.Add(new uiVertex {
+                _vertices.Add(new uiVertex {
                     position = new Vector2(vertex[i].x, vertex[i].y),
                     uv = hasUv ? uv[i] : Vector2.zero
                 });
             }
 
             foreach (var triangleId in triangles) {
-                indexes.Add(triangleId + startVertex);
+                _indices.Add(triangleId + _startVertex);
             }
         }
 
         /*public void DrawBuffer(CommandBuffer cmdBuf)
         {
-            if (this.computeBuffer == null)
+            if (this._computeBuffer == null)
             {
                 this.initComputeBuffer();
             }
@@ -116,9 +146,9 @@ void addMeshToComputeBuffer(List<Vector3> vertex, List<Vector2> uv, List<int> tr
                         this.addMeshToComputeBuffer(vert, null, index);
 
                         var mpb = new MaterialPropertyBlock();
-                        mpb.SetBuffer("databuffer", this.computeBuffer);
-                        mpb.SetBuffer("indexbuffer", this.indexBuffer);
-                        mpb.SetInt("_startVertex", this.startIndex);
+                        mpb.SetBuffer("databuffer", this._computeBuffer);
+                        mpb.SetBuffer("indexbuffer", this._indexBuffer);
+                        mpb.SetInt("_startVertex", this._startIndex);
                         cmdBuf.DrawProcedural(Matrix4x4.identity, this.material, 0, MeshTopology.Triangles, 6, 1, mpb);
                 }
             }

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

@@ -42,6 +42,8 @@ public void dispose() {
                 this._lastScissor = null;
                 this._layers.Clear();
             }
+
+            tryReleaseComputeBuffer();
         }
 
         public PictureFlusher(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool) {
@@ -57,6 +59,8 @@ public PictureFlusher(RenderTexture renderTexture, float devicePixelRatio, MeshP
             this.___drawTextDrawMeshCallback = this._drawTextDrawMeshCallback;
             this.___drawPathDrawMeshCallback2 = this._drawPathDrawMeshCallback2;
             this.___drawPathDrawMeshCallback = this._drawPathDrawMeshCallback;
+
+            _instanceNum++;
         }
 
         readonly _drawPathDrawMeshCallbackDelegate ___drawTextDrawMeshCallback;
@@ -1045,9 +1049,6 @@ public void flush(uiPicture picture) {
 
                 this._lastRtID = -1;
                 this._drawLayer(layer, cmdBuf);
-                //cmdBuf.SetRenderTarget(this._renderTexture);
-                //cmdBuf.ClearRenderTarget(true, true, UnityEngine.Color.grey);
-                //this.DrawBuffer(cmdBuf);
 
                 // this is necessary for webgl2. not sure why... just to be safe to disable the scissor.
                 cmdBuf.DisableScissorRect();
@@ -1163,9 +1164,9 @@ void _drawLayer(RenderLayer layer, CommandBuffer cmdBuf) {
                         D.assert(mesh.vertices.Count > 0);
                         if (supportComputeBuffer) {
                             this.addMeshToComputeBuffer(mesh.vertices?.data, mesh.uv?.data, mesh.triangles?.data);
-                            cmd.properties.SetBuffer(CmdDraw.vertexBufferId, computeBuffer);
-                            cmd.properties.SetBuffer(CmdDraw.indexBufferId, indexBuffer);
-                            cmd.properties.SetInt(CmdDraw.startIndexId, startIndex);
+                            cmd.properties.SetBuffer(CmdDraw.vertexBufferId, _computeBuffer);
+                            cmd.properties.SetBuffer(CmdDraw.indexBufferId, _indexBuffer);
+                            cmd.properties.SetInt(CmdDraw.startIndexId, _startIndex);
                             cmdBuf.DrawProcedural(Matrix4x4.identity, cmd.material, cmd.pass, MeshTopology.Triangles, mesh.triangles.Count, 1, cmd.properties.mpb);
                         }
                         else {