make compute buffer non-static

Author: zhuxingwei

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

@@ -11,87 +11,85 @@ struct uiVertex
             public Vector2 uv;
         }
 
-        static ComputeBuffer _computeBuffer;
-        static List<uiVertex> _vertices;
+        ComputeBuffer _computeBuffer;
+        List<uiVertex> _vertices;
 
-        static ComputeBuffer _indexBuffer;
-        static List<int> _indices;
+        ComputeBuffer _indexBuffer;
+        List<int> _indices;
 
-        static int _startVertex;
-        static int _startIndex;
-
-        static int _instanceNum;
+        int _startVertex;
+        int _startIndex;
 
         public const int COMPUTE_BUFFER_MAX_ITEM_NUM = 1024 * 1024;   // maxsize = 1M vertex/index
 
-        static void _releaseComputeBuffer() {
-            if (!CanvasShader.supportComputeBuffer) {
-                return;
-            }
+        bool supportComputeBuffer {
+            get { return CanvasShader.supportComputeBuffer; }
+        }
 
-            if (_computeBuffer == null) {
+        void _releaseComputeBuffer() {
+            if (!this.supportComputeBuffer) {
                 return;
             }
 
-            if (_instanceNum != 0) {
+            if (this._computeBuffer == null) {
                 return;
             }
 
-            _computeBuffer.Dispose();
-            _indexBuffer.Dispose();
-            _vertices = null;
-            _indices = null;
-            _computeBuffer = null;
-            _indexBuffer = null;
+            this._computeBuffer.Dispose();
+            this._indexBuffer.Dispose();
+            this._vertices = null;
+            this._indices = null;
+            this._computeBuffer = null;
+            this._indexBuffer = null;
         }
 
         void _initComputeBuffer() {
             var stride = Marshal.SizeOf(typeof(uiVertex));
             var strideIndex = Marshal.SizeOf(typeof(int));
-            _computeBuffer = new ComputeBuffer(COMPUTE_BUFFER_MAX_ITEM_NUM, stride);
-            _vertices = new List<uiVertex>();
+            this._computeBuffer = new ComputeBuffer(COMPUTE_BUFFER_MAX_ITEM_NUM, stride);
+            this._vertices = new List<uiVertex>();
 
-            _indexBuffer = new ComputeBuffer(COMPUTE_BUFFER_MAX_ITEM_NUM, strideIndex);
-            _indices = new List<int>();
+            this._indexBuffer = new ComputeBuffer(COMPUTE_BUFFER_MAX_ITEM_NUM, strideIndex);
+            this._indices = new List<int>();
         }
 
         void _resetComputeBuffer() {
-            if (!CanvasShader.supportComputeBuffer) return;
+            if (!this.supportComputeBuffer) return;
 
-            if (_computeBuffer == null) {
+            if (this._computeBuffer == null) {
                 this._initComputeBuffer();
             }
 
-            _vertices.Clear();
-            _indices.Clear();
-            _startVertex = 0;
-            _startIndex = 0;
+            this._vertices.Clear();
+            this._indices.Clear();
+            this._startVertex = 0;
+            this._startIndex = 0;
         }
 
         void _bindComputeBuffer() {
-            if (!CanvasShader.supportComputeBuffer) return;
+            if (!this.supportComputeBuffer) return;
 
-            _computeBuffer.SetData(_vertices);
-            _indexBuffer.SetData(_indices);
+            this._computeBuffer.SetData(this._vertices);
+            this._indexBuffer.SetData(this._indices);
         }
 
         void _addMeshToComputeBuffer(List<Vector3> vertex, List<Vector2> uv, List<int> triangles) {
-            if (!CanvasShader.supportComputeBuffer) return;
+            if (!this.supportComputeBuffer) return;
 
-            _startVertex = _vertices.Count;
-            _startIndex = _indices.Count;
+            this._startVertex = this._vertices.Count;
+            this._startIndex = this._indices.Count;
 
             var hasUv = uv != null;
 
             for (int i = 0; i < vertex.Count; i++) {
-                _vertices.Add(new uiVertex {
+                this._vertices.Add(new uiVertex {
                     position = new Vector2(vertex[i].x, vertex[i].y),
                     uv = hasUv ? uv[i] : Vector2.zero
                 });
             }
 
             foreach (var triangleId in triangles) {
-                _indices.Add(triangleId + _startVertex);
+                this._indices.Add(triangleId + this._startVertex);
             }
         }
     }

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

@@ -42,9 +42,8 @@ public void dispose() {
                 this._lastScissor = null;
                 this._layers.Clear();
             }
-
-            _instanceNum--;
-            _releaseComputeBuffer();
+            
+            this._releaseComputeBuffer();
         }
 
         public PictureFlusher(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool) {
@@ -60,8 +59,6 @@ public PictureFlusher(RenderTexture renderTexture, float devicePixelRatio, MeshP
             this.___drawTextDrawMeshCallback = this._drawTextDrawMeshCallback;
             this.___drawPathDrawMeshCallback2 = this._drawPathDrawMeshCallback2;
             this.___drawPathDrawMeshCallback = this._drawPathDrawMeshCallback;
-
-            _instanceNum++;
         }
 
         readonly _drawPathDrawMeshCallbackDelegate ___drawTextDrawMeshCallback;
@@ -1174,11 +1171,11 @@ void _drawLayer(RenderLayer layer, CommandBuffer cmdBuf) {
                         }
 
                         D.assert(mesh.vertices.Count > 0);
-                        if (CanvasShader.supportComputeBuffer) {
+                        if (this.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, this._computeBuffer);
+                            cmd.properties.SetBuffer(CmdDraw.indexBufferId, this._indexBuffer);
+                            cmd.properties.SetInt(CmdDraw.startIndexId, this._startIndex);
                             cmdBuf.DrawProcedural(Matrix4x4.identity, cmd.material, cmd.pass, MeshTopology.Triangles, mesh.triangles.Count, 1, cmd.properties.mpb);
                         }
                         else {