compute buffer setup - more shaders (except shadows) + refine shader folder

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;
-        struct TVertex
+        struct uiVertex
         {
             public Vector2 position;
             public Vector2 uv;
-        List<TVertex> tvertexes;
+        List<uiVertex> vertexes;
 
         ComputeBuffer indexBuffer;
         List<int> indexes;
 
-        Material material;
-
-            this.supportComputeBuffer = this._isMainCanvas && CanvasShader.supportComputeBuffer;
+            this.supportComputeBuffer = this._isMainCanvas && CanvasShader.supportComputeBuffer && false;
-            var stride = Marshal.SizeOf(typeof(TVertex));
+            var stride = Marshal.SizeOf(typeof(uiVertex));
-            this.tvertexes = new List<TVertex>();
+            this.vertexes = new List<uiVertex>();
                 
             this.indexBuffer = new ComputeBuffer(1024 * 1024, Marshal.SizeOf(typeof(int)));
             this.indexes = new List<int>();
                 this.initComputeBuffer();
             }
             
-            this.tvertexes.Clear();
+            this.vertexes.Clear();
             this.indexes.Clear();
             this.startVertex = 0;
             this.startIndex = 0;
             if (!this.supportComputeBuffer) return;
             
-            this.computeBuffer.SetData(this.tvertexes);
+            this.computeBuffer.SetData(this.vertexes);
             this.indexBuffer.SetData(this.indexes);
         }
 
-            this.startVertex = this.tvertexes.Count;
+            this.startVertex = this.vertexes.Count;
-                this.tvertexes.Add(new TVertex {
+                this.vertexes.Add(new uiVertex {
                     position = new Vector2(vertex[i].x, vertex[i].y),
                     uv = hasUv ? uv[i] : Vector2.zero
                 });
             }
         }
         
-        public void DrawBuffer(CommandBuffer cmdBuf)
+        /*public void DrawBuffer(CommandBuffer cmdBuf)
         {
             if (this.computeBuffer == null)
             {
             }
             
             this.bindComputeBuffer();
-        }
+        }*/
     }
 }

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

                             this._saveLayer_Points[2],
                             this._saveLayer_Points[3],
                             bounds);
-                        var renderDraw = CanvasShader.texRT(layer, layer.layerPaint.Value, mesh, parentLayer);
+                        var renderDraw = CanvasShader.texRT(layer, layer.layerPaint.Value, mesh, parentLayer, this.supportComputeBuffer);
-                        layer.draws.Add(CanvasShader.texRT(layer, paint, blurMesh, blurLayer));
+                        layer.draws.Add(CanvasShader.texRT(layer, paint, blurMesh, blurLayer, this.supportComputeBuffer));
                     }
                 }
                 else if (paint.backdrop is _MatrixImageFilter) {
                             this._saveLayer_Points[2],
                             this._saveLayer_Points[3],
                             bounds);
-                        var renderDraw = CanvasShader.texRT(layer, layer.layerPaint.Value, mesh, parentLayer);
+                        var renderDraw = CanvasShader.texRT(layer, layer.layerPaint.Value, mesh, parentLayer, this.supportComputeBuffer);
                         layer.draws.Add(renderDraw);
                     }
                 }
                 return;
             }
 
-            var renderDraw = CanvasShader.texRT(currentLayer, layer.layerPaint.Value, mesh, layer);
+            var renderDraw = CanvasShader.texRT(currentLayer, layer.layerPaint.Value, mesh, layer, this.supportComputeBuffer);
             currentLayer.draws.Add(renderDraw);
         }
 
                     // 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));
+                    layer.draws.Add(CanvasShader.stencilClear(layer, boundsMesh, this.supportComputeBuffer));
-                        layer.draws.Add(CanvasShader.stencil0(layer, maskElement.mesh.duplicate()));
-                        layer.draws.Add(CanvasShader.stencil1(layer, boundsMesh.duplicate()));
+                        layer.draws.Add(CanvasShader.stencil0(layer, maskElement.mesh.duplicate(), this.supportComputeBuffer));
+                        layer.draws.Add(CanvasShader.stencil1(layer, boundsMesh.duplicate(), this.supportComputeBuffer));
                     }
                 }
 
 
             blurXLayer.draws.Add(CanvasShader.maskFilter(
                 blurXLayer, blurMesh, maskLayer,
-                radiusX, new Vector2(1f / textureWidth, 0), kernelX));
+                radiusX, new Vector2(1f / textureWidth, 0), kernelX, this.supportComputeBuffer));
-                radiusY, new Vector2(0, -1f / textureHeight), kernelY));
+                radiusY, new Vector2(0, -1f / textureHeight), kernelY, this.supportComputeBuffer));
 
             return blurYLayer;
         }
                 return;
             }
 
-            layer.draws.Add(CanvasShader.texRT(layer, paint, blurMesh, blurLayer));
+            layer.draws.Add(CanvasShader.texRT(layer, paint, blurMesh, blurLayer, this.supportComputeBuffer));
         }
 
         delegate void _drawPathDrawMeshCallbackDelegate(uiPaint p, uiMeshMesh fillMesh, uiMeshMesh strokeMesh,
                 layer.draws.Add(CanvasShader.convexFill(layer, p, fillMesh, this.supportComputeBuffer));
             }
             else {
-                layer.draws.Add(CanvasShader.fill0(layer, fillMesh));
-                layer.draws.Add(CanvasShader.fill1(layer, p, fillMesh.boundsMesh));
+                layer.draws.Add(CanvasShader.fill0(layer, fillMesh, this.supportComputeBuffer));
+                layer.draws.Add(CanvasShader.fill1(layer, p, fillMesh.boundsMesh, this.supportComputeBuffer));
-                layer.draws.Add(CanvasShader.strokeAlpha(layer, p, alpha, strokeMult, strokeMesh));
-                layer.draws.Add(CanvasShader.stroke1(layer, strokeMesh.duplicate()));
+                layer.draws.Add(CanvasShader.strokeAlpha(layer, p, alpha, strokeMult, strokeMesh, this.supportComputeBuffer));
+                layer.draws.Add(CanvasShader.stroke1(layer, strokeMesh.duplicate(), this.supportComputeBuffer));
             }
         }
 
 
             var layer = this._currentLayer;
 
-            layer.draws.Add(CanvasShader.strokeAlpha(layer, p, alpha, strokeMult, strokeMesh));
-            layer.draws.Add(CanvasShader.stroke1(layer, strokeMesh.duplicate()));
+            layer.draws.Add(CanvasShader.strokeAlpha(layer, p, alpha, strokeMult, strokeMesh, this.supportComputeBuffer));
+            layer.draws.Add(CanvasShader.stroke1(layer, strokeMesh.duplicate(), this.supportComputeBuffer));
         }
 
         void _drawTextDrawMeshCallback(uiPaint p, uiMeshMesh fillMesh, uiMeshMesh strokeMesh, bool convex, float alpha,
 
             var layer = this._currentLayer;
             if (notEmoji) {
-                layer.draws.Add(CanvasShader.texAlpha(layer, p, textMesh, tex));
+                layer.draws.Add(CanvasShader.texAlpha(layer, p, textMesh, tex, this.supportComputeBuffer));
             }
             else {
                 uiPaint paintWithWhite = new uiPaint(p);
                 var raw_mesh = textMesh.resolveMesh();
                 var meshmesh = raw_mesh.duplicate();
                 ObjectPool<TextBlobMesh>.release(textMesh);
-                layer.draws.Add(CanvasShader.tex(layer, paintWithWhite, meshmesh, EmojiUtils.image));
+                layer.draws.Add(CanvasShader.tex(layer, paintWithWhite, meshmesh, EmojiUtils.image, this.supportComputeBuffer));
             }
         }
 
                 return;
             }
 
-            layer.draws.Add(CanvasShader.tex(layer, paint, mesh, image));
+            layer.draws.Add(CanvasShader.tex(layer, paint, mesh, image, this.supportComputeBuffer));
         }
 
         void _drawImageNine(Image image, uiRect? src, uiRect center, uiRect dst, uiPaint paint) {
                 return;
             }
 
-            layer.draws.Add(CanvasShader.tex(layer, paint, mesh, image));
+            layer.draws.Add(CanvasShader.tex(layer, paint, mesh, image, this.supportComputeBuffer));
         }
 
 
                         }
 
                         D.assert(mesh.vertices.Count > 0);
-                        if (this.supportComputeBuffer && CanvasShader.computeShader == cmd.material.shader) {
+                        if (this.supportComputeBuffer && CanvasShader.rshadowShader != cmd.material.shader && CanvasShader.rrshadowShader != cmd.material.shader) {
-                            cmd.properties.mpb.SetBuffer("databuffer", this.computeBuffer);
-                            cmd.properties.mpb.SetBuffer("indexbuffer", this.indexBuffer);
-                            cmd.properties.mpb.SetInt("_startVertex", this.startIndex);
-                            cmdBuf.DrawProcedural(Matrix4x4.identity, cmd.material, 0, MeshTopology.Triangles, mesh.triangles.Count, 1, cmd.properties.mpb);
+                            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 {
                             cmd.meshObj.SetVertices(mesh.vertices?.data);

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

         static readonly Material _shadowRBox;
         
         static readonly MaterialByBlendModeStencilComp _convexFillMat_cb;
+        static readonly MaterialByStencilComp _fill0Mat_cb;
+        static readonly MaterialByBlendMode _fill1Mat_cb;
+        static readonly MaterialByBlendModeStencilComp _stroke0Mat_cb;
+        static readonly Material _stroke1Mat_cb;
+        static readonly MaterialByBlendModeStencilComp _texMat_cb;
+        static readonly Material _stencilMat_cb;
+        static readonly Material _filterMat_cb;
+        static readonly MaterialByBlendModeStencilComp _strokeAlphaMat_cb;
 
         static Shader GetShader(string shaderName) {
             var shader = Shader.Find(shaderName);
 
         public static readonly bool supportComputeBuffer;
 
-        public static Shader computeShader;
+        public static Shader rshadowShader;
+        public static Shader rrshadowShader;
 
         static CanvasShader() {
             var convexFillShader = GetShader("UIWidgets/canvas_convexFill");
             var shadowBoxShader = GetShader("UIWidgets/ShadowBox");
             var shadowRBoxShader = GetShader("UIWidgets/ShadowRBox");
             var strokeAlphaShader = GetShader("UIWidgets/canvas_strokeAlpha");
+            
+            var fill0ShaderCompute = GetShader("UIWidgets/canvas_fill0_cb");
+            var fill1ShaderCompute = GetShader("UIWidgets/canvas_fill1_cb");
+            var stroke0ShaderCompute = GetShader("UIWidgets/canvas_stroke0_cb");
+            var stroke1ShaderCompute = GetShader("UIWidgets/canvas_stroke1_cb");
+            var texShaderCompute = GetShader("UIWidgets/canvas_tex_cb");
+            var stencilShaderCompute = GetShader("UIWidgets/canvas_stencil_cb");
+            var filterShaderCompute = GetShader("UIWidgets/canvas_filter_cb");
+            var strokeAlphaShaderCompute = GetShader("UIWidgets/canvas_strokeAlpha_cb");
-            computeShader = convexFillShaderCompute;
+            rshadowShader = shadowBoxShader;
+            rrshadowShader = shadowRBoxShader;
 
             _convexFillMat = new MaterialByBlendModeStencilComp(convexFillShader);
             _fill0Mat = new MaterialByStencilComp(fill0Shader);
             _shadowRBox = new Material(shadowRBoxShader) {hideFlags = HideFlags.HideAndDontSave};
             
             _convexFillMat_cb = new MaterialByBlendModeStencilComp(convexFillShaderCompute);
+            _fill0Mat_cb = new MaterialByStencilComp(fill0ShaderCompute);
+            _fill1Mat_cb = new MaterialByBlendMode(fill1ShaderCompute);
+            _stroke0Mat_cb = new MaterialByBlendModeStencilComp(stroke0ShaderCompute);
+            _stroke1Mat_cb = new Material(stroke1ShaderCompute) {hideFlags = HideFlags.HideAndDontSave};
+            _strokeAlphaMat_cb = new MaterialByBlendModeStencilComp(strokeAlphaShaderCompute);
+            _texMat_cb = new MaterialByBlendModeStencilComp(texShaderCompute);
+            _stencilMat_cb = new Material(stencilShaderCompute) {hideFlags = HideFlags.HideAndDontSave};
+            _filterMat_cb = new Material(filterShaderCompute) {hideFlags = HideFlags.HideAndDontSave};
 
             supportComputeBuffer = convexFillShaderCompute.isSupported;
         }
         }
 
         public static PictureFlusher.CmdDraw convexFill(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh, bool supportComputeBuffer = false) {
+            uiMeshMesh mesh, bool supportComputeBuffer) {
             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);
             );
         }
 
-        public static PictureFlusher.CmdDraw fill0(PictureFlusher.RenderLayer layer, uiMeshMesh mesh) {
+        public static PictureFlusher.CmdDraw fill0(PictureFlusher.RenderLayer layer, uiMeshMesh mesh, bool supportComputeBuffer) {
-            var mat = _fill0Mat.getMaterial(layer.ignoreClip);
+            var mat = supportComputeBuffer ? _fill0Mat_cb.getMaterial(layer.ignoreClip) : _fill0Mat.getMaterial(layer.ignoreClip);
 
             var pass = 0;
             var props = ObjectPool<MaterialPropertyBlockWrapper>.alloc();
         }
 
         public static PictureFlusher.CmdDraw fill1(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh) {
-            var mat = _fill1Mat.getMaterial(paint.blendMode);
+            uiMeshMesh mesh, bool supportComputeBuffer) {
+            var mat = supportComputeBuffer
+                ? _fill1Mat_cb.getMaterial(paint.blendMode)
+                : _fill1Mat.getMaterial(paint.blendMode);
             _getShaderPassAndProps(layer, paint, mesh.matrix, 1.0f, 0.0f, out var pass, out var props);
 
             var ret = PictureFlusher.CmdDraw.create(
         }
 
         public static PictureFlusher.CmdDraw stroke0(PictureFlusher.RenderLayer layer, uiPaint paint,
-            float alpha, uiMeshMesh mesh) {
-            var mat = _stroke0Mat.getMaterial(paint.blendMode, layer.ignoreClip);
+            float alpha, uiMeshMesh mesh, bool supportComputeBuffer) {
+            var mat = supportComputeBuffer 
+                ? _stroke0Mat_cb.getMaterial(paint.blendMode, layer.ignoreClip) 
+                : _stroke0Mat.getMaterial(paint.blendMode, layer.ignoreClip);
             _getShaderPassAndProps(layer, paint, mesh.matrix, alpha, 0.0f, out var pass, out var props);
 
             return PictureFlusher.CmdDraw.create(
             );
         }
 
-        public static PictureFlusher.CmdDraw stroke1(PictureFlusher.RenderLayer layer, uiMeshMesh mesh) {
+        public static PictureFlusher.CmdDraw stroke1(PictureFlusher.RenderLayer layer, uiMeshMesh mesh, bool supportComputeBuffer) {
-            var mat = _stroke1Mat;
+            var mat = supportComputeBuffer ? _stroke1Mat_cb : _stroke1Mat;
 
             var pass = 0;
             var props = ObjectPool<MaterialPropertyBlockWrapper>.alloc();
             );
         }
 
-        public static PictureFlusher.CmdDraw strokeAlpha(PictureFlusher.RenderLayer layer, uiPaint paint, float alpha, float strokeMult, uiMeshMesh mesh) {
-            var mat = _strokeAlphaMat.getMaterial(paint.blendMode, layer.ignoreClip);
+        public static PictureFlusher.CmdDraw strokeAlpha(PictureFlusher.RenderLayer layer, uiPaint paint, float alpha, float strokeMult, uiMeshMesh mesh, bool supportComputeBuffer) {
+            var mat = supportComputeBuffer 
+                ? _strokeAlphaMat_cb.getMaterial(paint.blendMode, layer.ignoreClip) 
+                : _strokeAlphaMat.getMaterial(paint.blendMode, layer.ignoreClip);
             _getShaderPassAndProps(layer, paint, mesh.matrix, alpha, strokeMult, out var pass, out var props);
 
             return PictureFlusher.CmdDraw.create(
         }
 
         public static PictureFlusher.CmdDraw stencilClear(
-            PictureFlusher.RenderLayer layer, uiMeshMesh mesh) {
+            PictureFlusher.RenderLayer layer, uiMeshMesh mesh, bool supportComputeBuffer) {
-            var mat = _stencilMat;
+            var mat = supportComputeBuffer ? _stencilMat_cb : _stencilMat;
 
             var pass = 0;
             var props = ObjectPool<MaterialPropertyBlockWrapper>.alloc();
             );
         }
 
-        public static PictureFlusher.CmdDraw stencil0(PictureFlusher.RenderLayer layer, uiMeshMesh mesh) {
+        public static PictureFlusher.CmdDraw stencil0(PictureFlusher.RenderLayer layer, uiMeshMesh mesh, bool supportComputeBuffer) {
-            var mat = _stencilMat;
+            var mat = supportComputeBuffer ? _stencilMat_cb : _stencilMat;
 
             var pass = 1;
             var props = ObjectPool<MaterialPropertyBlockWrapper>.alloc();
             );
         }
 
-        public static PictureFlusher.CmdDraw stencil1(PictureFlusher.RenderLayer layer, uiMeshMesh mesh) {
+        public static PictureFlusher.CmdDraw stencil1(PictureFlusher.RenderLayer layer, uiMeshMesh mesh, bool supportComputeBuffer) {
-            var mat = _stencilMat;
+            var mat = supportComputeBuffer ? _stencilMat_cb : _stencilMat;
 
             var pass = 2;
             var props = ObjectPool<MaterialPropertyBlockWrapper>.alloc();
         }
 
         public static PictureFlusher.CmdDraw tex(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh, Image image) {
-            var mat = _texMat.getMaterial(paint.blendMode, layer.ignoreClip);
+            uiMeshMesh mesh, Image image, bool supportComputeBuffer) {
+            var mat = supportComputeBuffer 
+                ? _texMat_cb.getMaterial(paint.blendMode, layer.ignoreClip) 
+                : _texMat.getMaterial(paint.blendMode, layer.ignoreClip);
             _getShaderPassAndProps(layer, paint, mesh.matrix, 1.0f, 0.0f, out var pass, out var props);
 
             image.texture.filterMode = paint.filterMode;
         }
 
         public static PictureFlusher.CmdDraw texRT(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh, PictureFlusher.RenderLayer renderLayer) {
-            var mat = _texMat.getMaterial(paint.blendMode, layer.ignoreClip);
+            uiMeshMesh mesh, PictureFlusher.RenderLayer renderLayer, bool supportComputeBuffer) {
+            var mat = supportComputeBuffer 
+                ? _texMat_cb.getMaterial(paint.blendMode, layer.ignoreClip) 
+                : _texMat.getMaterial(paint.blendMode, layer.ignoreClip);
             _getShaderPassAndProps(layer, paint, mesh.matrix, 1.0f, 0.0f, out var pass, out var props);
             props.SetInt(_texModeId, 1); // pre alpha
 
         }
 
         public static PictureFlusher.CmdDraw texAlpha(PictureFlusher.RenderLayer layer, uiPaint paint,
-            uiMeshMesh mesh, Texture tex) {
-            return texAlpha(layer, paint, mesh, null, tex);
+            uiMeshMesh mesh, Texture tex, bool supportComputeBuffer) {
+            return texAlpha(layer, paint, mesh, null, tex, supportComputeBuffer);
-            TextBlobMesh textMesh, Texture tex) {
-            return texAlpha(layer, paint, null, textMesh, tex);
+            TextBlobMesh textMesh, Texture tex, bool supportComputeBuffer) {
+            return texAlpha(layer, paint, null, textMesh, tex, supportComputeBuffer);
-            uiMeshMesh mesh, TextBlobMesh textMesh, Texture tex) {
-            var mat = _texMat.getMaterial(paint.blendMode, layer.ignoreClip);
+            uiMeshMesh mesh, TextBlobMesh textMesh, Texture tex, bool supportComputeBuffer) {
+            var mat = supportComputeBuffer 
+                ?_texMat_cb.getMaterial(paint.blendMode, layer.ignoreClip) 
+                :_texMat.getMaterial(paint.blendMode, layer.ignoreClip);
             var meshMatrix = mesh != null ? mesh.matrix : textMesh.matrix;
             _getShaderPassAndProps(layer, paint, meshMatrix, 1.0f, 0.0f, out var pass, out var props);
             tex.filterMode = paint.filterMode;
         }
 
         public static PictureFlusher.CmdDraw maskFilter(PictureFlusher.RenderLayer layer, uiMeshMesh mesh,
-            PictureFlusher.RenderLayer renderLayer, float radius, Vector2 imgInc, float[] kernel) {
+            PictureFlusher.RenderLayer renderLayer, float radius, Vector2 imgInc, float[] kernel, bool supportComputeBuffer) {
-            var mat = _filterMat;
+            var mat = supportComputeBuffer ? _filterMat_cb : _filterMat;
 
             var pass = 0;
             var props = ObjectPool<MaterialPropertyBlockWrapper>.alloc();

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

         public void SetFloatArray(int mid, float[] array) {
             this.mpb.SetFloatArray(mid, array);
         }
+
+        public void SetBuffer(int mid, ComputeBuffer buffer) {
+            this.mpb.SetBuffer(mid, buffer);
+        }
     }
 }

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

             public static readonly Matrix3 idMat3 = Matrix3.I();
             public static readonly int texId = Shader.PropertyToID("_tex");
             public static readonly int matId = Shader.PropertyToID("_mat");
+            public static readonly int vertexBufferId = Shader.PropertyToID("databuffer");
+            public static readonly int indexBufferId = Shader.PropertyToID("indexbuffer");
+            public static readonly int startIndexId = Shader.PropertyToID("_startVertex");
 
 
             public override void clear() {

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_cb.cginc

+struct vdata
+{
+    float2 vertex;
+    float2 uv;
+};
+
+StructuredBuffer<vdata> databuffer;
+StructuredBuffer<int> indexbuffer;
+int _startVertex;
+
+v2f vert_compute (uint vertex_id: SV_VertexID, uint instance_id: SV_InstanceID)
+{
+    v2f o = (v2f)0;
+    vdata v = databuffer[indexbuffer[_startVertex + vertex_id]];
+    o.ftcoord = v.uv;
+    o.fpos = v.vertex;
+              
+    float3x3 mat = float3x3(_mat[0], _mat[1], _mat[2], _mat[3], _mat[4], _mat[5], 0, 0, 1);
+    float2 p = mul(mat, float3(v.vertex.xy, 1.0)).xy - _viewport.xy;
+    
+#if UNITY_UV_STARTS_AT_TOP
+    o.vertex = float4(2.0 * p.x / _viewport.z - 1.0, 2.0 * p.y / _viewport.w - 1.0, 0, 1);
+#else
+    o.vertex = float4(2.0 * p.x / _viewport.z - 1.0, 1.0 - 2.0 * p.y / _viewport.w, 0, 1);
+#endif
+    return o;
+}

Runtime/Resources/shaders/computebuffer/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
+    {   
+        ZTest Always
+        ZWrite Off
+        Blend [_SrcBlend] [_DstBlend]
+        
+        Stencil {
+            Ref 128
+            Comp [_StencilComp]
+        }
+        
+        Pass { // 0, color
+            CGPROGRAM
+            #define UIWIDGETS_COLOR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 1, linear
+            CGPROGRAM
+            #define UIWIDGETS_LINEAR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 2, radial
+            CGPROGRAM
+            #define UIWIDGETS_RADIAL
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 3, sweep
+            CGPROGRAM
+            #define UIWIDGETS_SWEEP
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 4, image
+            CGPROGRAM
+            #define UIWIDGETS_IMAGE
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+    }
+}

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_fill0_cb.shader

+Shader "UIWidgets/canvas_fill0_cb"
+{
+    Properties {
+        _StencilComp("_StencilComp", Float) = 3 // - Equal, 8 - Always 
+    }
+   
+    SubShader {
+        ZTest Always
+        ZWrite Off
+        
+        Cull Off        
+        ColorMask 0
+        Stencil {
+            Ref 128
+            CompFront [_StencilComp]
+            CompBack [_StencilComp]
+            ReadMask 128
+            WriteMask 127
+            PassFront IncrWrap
+            PassBack DecrWrap
+        }
+            
+        Pass {
+            CGPROGRAM
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_stencil
+            ENDCG
+        }
+    }
+}

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_fill1_cb.shader

+Shader "UIWidgets/canvas_fill1_cb"
+{
+    Properties {
+       _SrcBlend("_SrcBlend", Int) = 1 // One
+       _DstBlend("_DstBlend", Int) = 10 // OneMinusSrcAlpha
+    }
+   
+    SubShader {
+        ZTest Always
+        ZWrite Off
+        Blend [_SrcBlend] [_DstBlend]
+
+        Stencil {
+            Ref 0
+            Comp NotEqual
+            ReadMask 127
+            WriteMask 127
+            Pass Zero
+        }
+        
+        Pass { // 0, color
+            CGPROGRAM
+            #define UIWIDGETS_COLOR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 1, linear
+            CGPROGRAM
+            #define UIWIDGETS_LINEAR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 2, radial
+            CGPROGRAM
+            #define UIWIDGETS_RADIAL
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 3, sweep
+            CGPROGRAM
+            #define UIWIDGETS_SWEEP
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 4, image
+            CGPROGRAM
+            #define UIWIDGETS_IMAGE
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+    }
+}

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_filter_cb.shader

+Shader "UIWidgets/canvas_filter_cb"
+{
+    Properties {
+    }
+   
+    SubShader {
+        ZTest Always
+        ZWrite Off
+        
+        Pass { // 0, mask filter 
+            CGPROGRAM
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_mf
+            ENDCG
+        }
+    }
+}

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_stencil_cb.shader

+Shader "UIWidgets/canvas_stencil_cb"
+{
+    Properties {
+    }
+   
+    SubShader {
+        ZTest Always
+        ZWrite Off
+        
+        Pass { // 0, stencil clear
+            ColorMask 0
+            Stencil {
+                Ref 128
+                Pass Replace
+            }
+
+            CGPROGRAM
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_stencil
+            ENDCG
+        }
+
+        Pass { // 1, stencil intersect 0
+            Cull Off
+            ColorMask 0
+            Stencil {
+                WriteMask 127
+                PassFront IncrWrap
+                PassBack DecrWrap
+            }
+
+            CGPROGRAM
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_stencil
+            ENDCG
+        }
+        
+        Pass { // 2, stencil intersect 1
+            ColorMask 0
+            Stencil {
+                Ref 128
+                Comp Less
+                Pass Replace
+                Fail Zero
+            }
+
+            CGPROGRAM
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_stencil
+            ENDCG
+        }
+    }
+}

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_stroke0_cb.shader

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_stroke1_cb.shader

+Shader "UIWidgets/canvas_stroke1_cb"
+{
+    Properties {
+    }
+   
+    SubShader {
+        ZTest Always
+        ZWrite Off
+
+        ColorMask 0
+        Stencil {
+            Ref 0
+            Comp NotEqual
+            ReadMask 127
+            WriteMask 127
+            Pass Zero
+        }
+        
+        Pass {        
+            CGPROGRAM
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_stencil
+            ENDCG
+        }
+    }
+}

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_strokeAlpha_cb.shader

+Shader "UIWidgets/canvas_strokeAlpha_cb"
+{
+    Properties {
+       _SrcBlend("_SrcBlend", Int) = 1 // One
+       _DstBlend("_DstBlend", Int) = 10 // OneMinusSrcAlpha
+       _StencilComp("_StencilComp", Float) = 3 // - Equal, 8 - Always 
+    }
+   
+    SubShader {
+        ZTest Always
+        ZWrite Off
+        Blend [_SrcBlend] [_DstBlend]
+        
+        Stencil {
+            Ref 128
+            Comp [_StencilComp]
+            Pass IncrSat
+        }
+
+        Pass { // 0, color
+            CGPROGRAM
+            #define UIWIDGETS_COLOR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_stroke_alpha
+            ENDCG
+        }
+        
+        Pass { // 1, linear
+            CGPROGRAM
+            #define UIWIDGETS_LINEAR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_stroke_alpha
+            ENDCG
+        }
+
+        Pass { // 2, radial
+            CGPROGRAM
+            #define UIWIDGETS_RADIAL
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_stroke_alpha
+            ENDCG
+        }
+
+        Pass { // 3, sweep
+            CGPROGRAM
+            #define UIWIDGETS_SWEEP
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_stroke_alpha
+            ENDCG
+        }
+        
+        Pass { // 4, image
+            CGPROGRAM
+            #define UIWIDGETS_IMAGE
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_stroke_alpha
+            ENDCG
+        }
+    }
+}

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_tex_cb.shader

+Shader "UIWidgets/canvas_tex_cb"
+{
+    Properties {
+       _SrcBlend("_SrcBlend", Int) = 1 // One
+       _DstBlend("_DstBlend", Int) = 10 // OneMinusSrcAlpha
+       _StencilComp("_StencilComp", Float) = 3 // - Equal, 8 - Always 
+    }
+   
+    SubShader {
+        ZTest Always
+        ZWrite Off
+        Blend [_SrcBlend] [_DstBlend]
+                
+        Stencil {
+            Ref 128
+            Comp [_StencilComp]
+        }
+
+        Pass { // 0, color
+            CGPROGRAM
+            #define UIWIDGETS_COLOR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_tex
+            ENDCG
+        }
+        
+        Pass { // 1, linear
+            CGPROGRAM
+            #define UIWIDGETS_LINEAR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_tex
+            ENDCG
+        }
+
+        Pass { // 2, radial
+            CGPROGRAM
+            #define UIWIDGETS_RADIAL
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_tex
+            ENDCG
+        }
+
+        Pass { // 3, sweep
+            CGPROGRAM
+            #define UIWIDGETS_SWEEP
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_tex
+            ENDCG
+        }
+        
+        Pass { // 4, image
+            CGPROGRAM
+            #define UIWIDGETS_IMAGE
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_tex
+            ENDCG
+        }     
+    }
+}

Runtime/Resources/UIWidgets_GUITexture.shader.meta

-fileFormatVersion: 2
-guid: ea02b3553b38477c85b9ca45949cc85c
-timeCreated: 1544158153

Runtime/Resources/UIWidgets_UIDefault.shader.meta

-fileFormatVersion: 2
-guid: 43b4ae1d316ca415589f96e49cc0fcab
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas.cginc.meta

-fileFormatVersion: 2
-guid: 6565922d18a5e4ee29fa183d2600eccc
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_fill0.shader.meta

-fileFormatVersion: 2
-guid: e75e9debfc1ad4e1687365932de72aa0
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_fill1.shader.meta

-fileFormatVersion: 2
-guid: 7dbfb4eecc7a84ddc90c53891aa77e0b
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_filter.shader.meta

-fileFormatVersion: 2
-guid: 756de2a3eb91745ba853728245a033d9
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_stencil.shader.meta

-fileFormatVersion: 2
-guid: b4673a8cf87214fdb8643b32e0ec3316
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_stroke0.shader.meta

-fileFormatVersion: 2
-guid: 7e33032771e1e46a6b5eda923148503f
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_stroke1.shader.meta

-fileFormatVersion: 2
-guid: ee8a29ca6a09f4510bbf6e3b70922edc
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_tex.shader.meta

-fileFormatVersion: 2
-guid: 1702a648d08de40d9aacd9bbab1188b3
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_convexFill.shader.meta

-fileFormatVersion: 2
-guid: da4e74e0b377e41699f5c3ed2c7c69e4
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_shadowBox.shader.meta

-fileFormatVersion: 2
-guid: 105f52491741049d88708e718c749e34
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_shadowRBox.shader.meta

-fileFormatVersion: 2
-guid: 77c8565b9b449434490473ef8f7f0e91
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_strokeAlpha.shader.meta

-fileFormatVersion: 2
-guid: c57ed8e638931f946a7b5e26a54725d8
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Runtime/Resources/UIWidgets_canvas_convexFill_cb.shader.meta

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

Runtime/Resources/UIWidgets_canvas_cb.cginc

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

Runtime/Resources/UIWidgets_canvas_cb.cginc.meta

-fileFormatVersion: 2
-guid: 1f1fccf97e9184468a5eba95bd74f2e5
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

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
-    {   
-        ZTest Always
-        ZWrite Off
-        Blend [_SrcBlend] [_DstBlend]
-        
-        Stencil {
-            Ref 128
-            Comp [_StencilComp]
-        }
-        
-        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
-        }
-    }
-}