compute buffer setup

Runtime/editor/surface.cs

         public Canvas getCanvas() {
             if (this._canvas == null) {
                 this._canvas = new CommandBufferCanvas(
-                    this._renderTexture, this.devicePixelRatio, this._meshPool);
+                    this._renderTexture, this.devicePixelRatio, this._meshPool, true);
             }
 
             return this._canvas;

Runtime/ui/renderer/cmdbufferCanvas/command_buffer_canvas.cs

     public class CommandBufferCanvas : uiRecorderCanvas {
         readonly PictureFlusher _flusher;
 
-        public CommandBufferCanvas(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool)
+        public CommandBufferCanvas(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool, bool isMainCanvas = false)
-            this._flusher = new PictureFlusher(renderTexture, devicePixelRatio, meshPool);
+            this._flusher = new PictureFlusher(renderTexture, devicePixelRatio, meshPool, isMainCanvas);
         }
 
         public override float getDevicePixelRatio() {

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

         readonly float _devicePixelRatio;
         readonly MeshPool _meshPool;
 
+        readonly bool _isMainCanvas;
+
         readonly List<RenderLayer> _layers = new List<RenderLayer>();
         RenderLayer _currentLayer;
         uiRect? _lastScissor;
             }
         }
 
-        public PictureFlusher(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool) {
+        public PictureFlusher(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool, bool isMainCanvas) {
             D.assert(renderTexture);
             D.assert(devicePixelRatio > 0);
             D.assert(meshPool != null);
             this._devicePixelRatio = devicePixelRatio;
             this._meshPool = meshPool;
+            this._isMainCanvas = isMainCanvas;
 
             this.___drawTextDrawMeshCallback = this._drawTextDrawMeshCallback;
             this.___drawPathDrawMeshCallback2 = this._drawPathDrawMeshCallback2;
             using (var cmdBuf = new CommandBuffer()) {
                 cmdBuf.name = "CommandBufferCanvas";
 
-                this._lastRtID = -1;
-                this._drawLayer(layer, cmdBuf);
+                //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();

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

         static readonly MaterialByBlendModeStencilComp _strokeAlphaMat;
         static readonly Material _shadowBox;
         static readonly Material _shadowRBox;
+        
+        static readonly MaterialByBlendModeStencilComp _convexFillMat_cb;
 
         static Shader GetShader(string shaderName) {
             var shader = Shader.Find(shaderName);
             return shader;
         }
 
+        public static readonly bool supportComputeBuffer;
+
         static CanvasShader() {
             var convexFillShader = GetShader("UIWidgets/canvas_convexFill");
             var fill0Shader = GetShader("UIWidgets/canvas_fill0");
             var shadowBoxShader = GetShader("UIWidgets/ShadowBox");
             var shadowRBoxShader = GetShader("UIWidgets/ShadowRBox");
             var strokeAlphaShader = GetShader("UIWidgets/canvas_strokeAlpha");
+            var convexFillShaderCompute = GetShader("UIWidgets/canvas_convexFill_cb");
 
             _convexFillMat = new MaterialByBlendModeStencilComp(convexFillShader);
             _fill0Mat = new MaterialByStencilComp(fill0Shader);
             _filterMat = new Material(filterShader) {hideFlags = HideFlags.HideAndDontSave};
             _shadowBox = new Material(shadowBoxShader) {hideFlags = HideFlags.HideAndDontSave};
             _shadowRBox = new Material(shadowRBoxShader) {hideFlags = HideFlags.HideAndDontSave};
+            
+            _convexFillMat_cb = new MaterialByBlendModeStencilComp(convexFillShaderCompute);
+
+            supportComputeBuffer = convexFillShaderCompute.isSupported;
-
-        public static Material shadowBox => _shadowBox;
 
         static readonly int _viewportId = Shader.PropertyToID("_viewport");
         static readonly int _alphaId = Shader.PropertyToID("_alpha");

Runtime/ui/renderer/compositeCanvas/flow/raster_cache.cs

             var renderTexture = new RenderTexture(desc);
             renderTexture.hideFlags = HideFlags.HideAndDontSave;
 
-            var canvas = new CommandBufferCanvas(renderTexture, devicePixelRatio, meshPool);
+            var canvas = new CommandBufferCanvas(renderTexture, devicePixelRatio, meshPool, false);
             canvas.translate(-bounds.left, -bounds.top);
             canvas.concat(transform);
             canvas.drawPicture(picture);

Runtime/Resources/UIWidgets_canvas_cb.cginc

+struct vdata
+            {
+                float2 vertex;
+                float2 uv;
+            };
+
+            struct psInput
+            {
+                float4 position : SV_POSITION;
+            };
+
+            StructuredBuffer<vdata> databuffer;
+            StructuredBuffer<int> indexbuffer;
+            float4 _viewport;
+            int _startVertex;
+            
+            psInput vert (uint vertex_id: SV_VertexID, uint instance_id: SV_InstanceID)
+            {
+                psInput o = (psInput)0;
+                o.position = float4(databuffer[indexbuffer[_startVertex + vertex_id]].vertex.x * 2.0 / _viewport.z - 1.0, databuffer[indexbuffer[_startVertex + vertex_id]].vertex.y * 2.0 / _viewport.w - 1.0, 0, 1);
+                return o;
+            }
+            
+            fixed4 frag (psInput i) : SV_Target
+            {
+                return float4(0, 1, 0, 1);
+            }

Runtime/Resources/UIWidgets_canvas_convexFill_cb.shader

+Shader "UIWidgets/canvas_convexFill_cb"
+{
+    Properties
+    {
+       _SrcBlend("_SrcBlend", Int) = 1 // One
+       _DstBlend("_DstBlend", Int) = 10 // OneMinusSrcAlpha
+       _StencilComp("_StencilComp", Float) = 3 // - Equal, 8 - Always 
+    }
+
+    SubShader
+    {   
+        Blend [_SrcBlend] [_DstBlend]
+        Pass { // 0, color
+            CGPROGRAM
+            #define UIWIDGETS_COLOR
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 1, linear
+            CGPROGRAM
+            #define UIWIDGETS_LINEAR
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 2, radial
+            CGPROGRAM
+            #define UIWIDGETS_RADIAL
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 3, sweep
+            CGPROGRAM
+            #define UIWIDGETS_SWEEP
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 4, image
+            CGPROGRAM
+            #define UIWIDGETS_IMAGE
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert
+            #pragma fragment frag
+            ENDCG
+        }
+    }
+}

Runtime/Resources/UIWidgets_canvas_convexFill_cb.shader.meta

+fileFormatVersion: 2
+guid: f33f0775754654febaf49dbb596c8927
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using UnityEngine;
+using UnityEngine.Rendering;
+using Random = System.Random;
+
+namespace Unity.UIWidgets.ui {
+    public partial class PictureFlusher {
+        
+        struct TVertex
+        {
+            public Vector2 position;
+            public Vector2 uv;
+        }
+
+        ComputeBuffer computeBuffer;
+        List<TVertex> tvertexes;
+
+        ComputeBuffer indexBuffer;
+        List<int> indexes;
+        
+        int startVertex;
+        int startIndex;
+
+        Material material;
+        
+        public void DrawBuffer(CommandBuffer cmdBuf)
+        {
+            if (this.computeBuffer == null)
+            {
+                var stride = Marshal.SizeOf(typeof(TVertex));
+                this.computeBuffer = new ComputeBuffer(1024 * 1024, stride);
+                this.tvertexes = new List<TVertex>();
+                
+                this.indexBuffer = new ComputeBuffer(1024 * 1024, Marshal.SizeOf(typeof(int)));
+                this.indexes = new List<int>();
+            }
+            
+            this.tvertexes.Clear();
+            this.indexes.Clear();
+            this.startVertex = 0;
+            this.startIndex = 0;
+
+            if (this.material == null) {
+                this.material = new Material(Shader.Find("UIWidgets/canvas_convexFill_cb"));
+                this.material.SetVector("_viewport", new Vector4(0, 0, 500, 500));
+            }
+
+            var random = new Random();
+            var num = 5;
+            var size = 30;
+            
+            for (var i = 0; i < num; i++)
+            {
+                for (var j = 0; j < num; j++)
+                {
+                        var offsetY = i * size;
+                        var offsetX = j * size;
+                        var centerX = offsetX + size / 2;
+                        var centerY = offsetY + size / 2;
+                        var width = size;
+                        var height = size;
+
+                        this.startVertex = this.tvertexes.Count;
+                        this.startIndex = this.indexes.Count;
+                        
+                    
+                        this.tvertexes.AddRange(new[]
+                        {
+                            new TVertex
+                            {
+                                position = new Vector2(centerX - width / 2, centerY - height / 2),
+                                uv = new Vector2(0, 0)
+                            },
+                            new TVertex
+                            {
+                                position = new Vector2(centerX + width / 2, centerY - height / 2),
+                                uv = new Vector2(0, 0)
+                            },
+                            new TVertex
+                            {
+                                position = new Vector2(centerX + width / 2, centerY + height / 2),
+                                uv = new Vector2(0, 0)
+                            },
+                            new TVertex
+                            {
+                                position = new Vector2(centerX - width / 2, centerY + height / 2),
+                                uv = new Vector2(0, 0)
+                            }
+                        });
+                    
+                        this.indexes.AddRange(new []
+                        {
+                            this.startVertex, this.startVertex + 1, this.startVertex + 2, this.startVertex, this.startVertex + 2, this.startVertex + 3
+                        });
+
+                        var mpb = new MaterialPropertyBlock();
+                        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);
+                }
+            }
+            
+            this.computeBuffer.SetData(this.tvertexes);
+            this.indexBuffer.SetData(this.indexes);
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 88f2ad2c8ab504c5d95b1f70539f8d86
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: