Merge pull request #307 from UnityTech/master

release stable version 1.5.4

Runtime/Plugins/platform/ios/DeviceScreen.mm

 #import <UIKit/UIKit.h>
+#import "UIWidgetsDevice.h"
-    int IOSDeviceScaleFactor()
+    float IOSDeviceScaleFactor()
-        return [[UIScreen mainScreen] scale];
+        float scale = [[UIScreen mainScreen] scale] * 1.0;
+        if ([UIWidgetsDevice NeedScreenDownSample]) {
+            scale *= 0.8696;
+        }
+        return scale;
     }
 }

Runtime/editor/surface.cs

 
             if (this._canvas != null) {
                 this._canvas.reset();
+                this._canvas.dispose();
                 this._canvas = null;
             }
         }

Runtime/engine/DisplayMetrics.cs

 
 #if UNITY_IOS
         [DllImport("__Internal")]
-        static extern int IOSDeviceScaleFactor();
+        static extern float IOSDeviceScaleFactor();
 
 		[DllImport("__Internal")]
 		static extern viewMetrics IOSGetViewportPadding();

Runtime/engine/UIWidgetsPanel.cs

 
         void handleMouseMovement() {
             var pos = this.getPointPosition(Input.mousePosition);
+            if (pos == null) {
+                return;
+            }
-                physicalX: pos.x,
-                physicalY: pos.y
+                physicalX: pos.Value.x,
+                physicalY: pos.Value.y
             ));
         }
 
                 var pos = this.getPointPosition(Input.mousePosition);
+                if (pos == null) {
+                    return;
+                }
-                    pos.x,
-                    pos.y,
+                    pos.Value.x,
+                    pos.Value.y,
                     InputUtils.getScrollButtonKey());
             }
         }
         }
 
         public void OnPointerDown(PointerEventData eventData) {
-            EventSystem.current.SetSelectedGameObject(this.gameObject, eventData);
+            if (position == null) {
+                return;
+            }
+            EventSystem.current.SetSelectedGameObject(this.gameObject, eventData);
-                physicalX: position.x,
-                physicalY: position.y
+                physicalX: position.Value.x,
+                physicalY: position.Value.y
+            if (position == null) {
+                return;
+            }
-                physicalX: position.x,
-                physicalY: position.y
+                physicalX: position.Value.x,
+                physicalY: position.Value.y
-        public Vector2 getPointPosition(PointerEventData eventData) {
+        public Vector2? getPointPosition(PointerEventData eventData) {
+            if (eventData.enterEventCamera == null && this.canvas.renderMode == RenderMode.ScreenSpaceCamera) {
+                return null;
+            }
+            
             Vector2 localPoint;
             RectTransformUtility.ScreenPointToLocalPointInRectangle(this.rectTransform, eventData.position,
                 eventData.enterEventCamera, out localPoint);
             return localPoint;
         }
 
-        public Vector2 getPointPosition(Vector2 position) {
+        public Vector2? getPointPosition(Vector2 position) {
             Vector2 localPoint;
             Camera eventCamera = null;
 
 
+            if (eventCamera == null && this.canvas.renderMode == RenderMode.ScreenSpaceCamera) {
+                return null;
+            }
 
             RectTransformUtility.ScreenPointToLocalPointInRectangle(this.rectTransform, position,
                 eventCamera, out localPoint);
 
         public void OnDrag(PointerEventData eventData) {
             var position = this.getPointPosition(eventData);
+            if (position == null) {
+                return;
+            }
-                physicalX: position.x,
-                physicalY: position.y
+                physicalX: position.Value.x,
+                physicalY: position.Value.y
+            var position = this.getPointPosition(eventData);
+            if (position == null) {
+                return;
+            }
-            var position = this.getPointPosition(eventData);
-                physicalX: position.x,
-                physicalY: position.y
+                physicalX: position.Value.x,
+                physicalY: position.Value.y
+            var position = this.getPointPosition(eventData);
+            if (position == null) {
+                return;
+            }
-
-            var position = this.getPointPosition(eventData);
-                physicalX: position.x,
-                physicalY: position.y
+                physicalX: position.Value.x,
+                physicalY: position.Value.y
             ));
         }
 

Runtime/material/chip.cs

         const bool _debugShowTapTargetOutlines = false;
 
         public override void debugPaint(PaintingContext context, Offset offset) {
-            D.assert(!_debugShowTapTargetOutlines);
-            D.assert(() => {
+            bool visualizeTapTargets() {
                 Paint outlinePaint = new Paint();
                 outlinePaint.color = new Color(0xff800000);
                 outlinePaint.strokeWidth = 1.0f;
                 outlinePaint.color = new Color(0xff008000);
                 context.canvas.drawRect(this.pressRect.shift(offset), outlinePaint);
                 return true;
-            });
+            }
+
+            D.assert(!_debugShowTapTargetOutlines || visualizeTapTargets());
         }
 
         protected override bool hitTestSelf(Offset position) {

Runtime/ui/painting/image.cs

             this._isDynamic = isDynamic;
         }
 
+        public bool valid {
+            get { return this._texture != null; }
+        }
+
         public int width {
             get { return this._texture != null ? this._texture.width : 0; }
         }

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

                 this._lastScissor = null;
                 this._layers.Clear();
             }
+
+            _instanceNum--;
+            _releaseComputeBuffer();
         }
 
         public PictureFlusher(RenderTexture renderTexture, float devicePixelRatio, MeshPool meshPool) {
             this.___drawTextDrawMeshCallback = this._drawTextDrawMeshCallback;
             this.___drawPathDrawMeshCallback2 = this._drawPathDrawMeshCallback2;
             this.___drawPathDrawMeshCallback = this._drawPathDrawMeshCallback;
+
+            _instanceNum++;
         }
 
         readonly _drawPathDrawMeshCallbackDelegate ___drawTextDrawMeshCallback;
             layer.clipStack.save();
         }
 
-        readonly uiOffset[] _saveLayer_Points = new uiOffset[4];
+        static uiOffset[] _cachedPoints = new uiOffset[4];
 
         void _saveLayer(uiRect bounds, uiPaint paint) {
             D.assert(bounds.width > 0);
             this._currentLayer = layer;
 
             if (paint.backdrop != null) {
-                if (paint.backdrop is _BlurImageFilter) {
-                    var filter = (_BlurImageFilter) paint.backdrop;
+                
+                if (paint.backdrop is _uiBlurImageFilter) {
+                    var filter = (_uiBlurImageFilter) paint.backdrop;
-                        this._saveLayer_Points[0] = bounds.topLeft;
-                        this._saveLayer_Points[1] = bounds.bottomLeft;
-                        this._saveLayer_Points[2] = bounds.bottomRight;
-                        this._saveLayer_Points[3] = bounds.topRight;
+                        _cachedPoints[0] = bounds.topLeft;
+                        _cachedPoints[1] = bounds.bottomLeft;
+                        _cachedPoints[2] = bounds.bottomRight;
+                        _cachedPoints[3] = bounds.topRight;
-                        state.matrix.Value.mapPoints(this._saveLayer_Points);
+                        state.matrix.Value.mapPoints(ref _cachedPoints);
-                            this._saveLayer_Points[i] = new uiOffset(
-                                (this._saveLayer_Points[i].dx - parentBounds.left) / parentBounds.width,
-                                (this._saveLayer_Points[i].dy - parentBounds.top) / parentBounds.height
+                            _cachedPoints[i] = new uiOffset(
+                                (_cachedPoints[i].dx - parentBounds.left) / parentBounds.width,
+                                (_cachedPoints[i].dy - parentBounds.top) / parentBounds.height
-                            this._saveLayer_Points[0],
-                            this._saveLayer_Points[1],
-                            this._saveLayer_Points[2],
-                            this._saveLayer_Points[3],
+                            _cachedPoints[0],
+                            _cachedPoints[1],
+                            _cachedPoints[2],
+                            _cachedPoints[3],
                             bounds);
                         var renderDraw = CanvasShader.texRT(layer, layer.layerPaint.Value, mesh, parentLayer);
                         layer.draws.Add(renderDraw);
                         layer.draws.Add(CanvasShader.texRT(layer, paint, blurMesh, blurLayer));
                     }
                 }
-                else if (paint.backdrop is _MatrixImageFilter) {
-                    var filter = (_MatrixImageFilter) paint.backdrop;
+                else if (paint.backdrop is _uiMatrixImageFilter) {
+                    var filter = (_uiMatrixImageFilter) paint.backdrop;
-                        this._saveLayer_Points[0] = bounds.topLeft;
-                        this._saveLayer_Points[1] = bounds.bottomLeft;
-                        this._saveLayer_Points[2] = bounds.bottomRight;
-                        this._saveLayer_Points[3] = bounds.topRight;
-                        state.matrix.Value.mapPoints(this._saveLayer_Points);
+                        _cachedPoints[0] = bounds.topLeft;
+                        _cachedPoints[1] = bounds.bottomLeft;
+                        _cachedPoints[2] = bounds.bottomRight;
+                        _cachedPoints[3] = bounds.topRight;
+                        
+                        state.matrix.Value.mapPoints(ref _cachedPoints);
-                            this._saveLayer_Points[i] = new uiOffset(
-                                (this._saveLayer_Points[i].dx - parentBounds.left) / parentBounds.width,
-                                (this._saveLayer_Points[i].dy - parentBounds.top) / parentBounds.height
+                            _cachedPoints[i] = new uiOffset(
+                                (_cachedPoints[i].dx - parentBounds.left) / parentBounds.width,
+                                (_cachedPoints[i].dy - parentBounds.top) / parentBounds.height
-                        matrix.postConcat(uiMatrix3.fromMatrix3(filter.transform));
+                        matrix.postConcat(filter.transform);
-                            this._saveLayer_Points[0],
-                            this._saveLayer_Points[1],
-                            this._saveLayer_Points[2],
-                            this._saveLayer_Points[3],
+                            _cachedPoints[0],
+                            _cachedPoints[1],
+                            _cachedPoints[2],
+                            _cachedPoints[3],
                             bounds);
                         var renderDraw = CanvasShader.texRT(layer, layer.layerPaint.Value, mesh, parentLayer);
                         layer.draws.Add(renderDraw);
         }
 
         void _drawImage(Image image, uiOffset offset, uiPaint paint) {
-            D.assert(image != null);
+            D.assert(image != null && image.valid);
+
+            if (image == null || !image.valid) {
+                return;
+            }
 
             this._drawImageRect(image,
                 null,
         }
 
         void _drawImageRect(Image image, uiRect? src, uiRect dst, uiPaint paint) {
-            D.assert(image != null);
+            D.assert(image != null && image.valid);
+
+            if (image == null || !image.valid) {
+                return;
+            }
 
             if (src == null) {
                 src = uiRectHelper.one;
         }
 
         void _drawImageNine(Image image, uiRect? src, uiRect center, uiRect dst, uiPaint paint) {
-            D.assert(image != null);
+            D.assert(image != null && image.valid);
+
+            if (image == null || !image.valid) {
+                return;
+            }
 
             var scaleX = 1f / image.width;
             var scaleY = 1f / image.height;
         }
 
         public void flush(uiPicture picture) {
+            if (!CanvasShader.isReady()) {
+                return;
+            }
+            
+            this._resetComputeBuffer();
 
             this._drawUIPicture(picture, false);
 
                 // this is necessary for webgl2. not sure why... just to be safe to disable the scissor.
                 cmdBuf.DisableScissorRect();
 
+                this._bindComputeBuffer();
                 Graphics.ExecuteCommandBuffer(cmdBuf);
             }
 
                         if (mesh == null) {
                             continue;
                         }
-
-                        D.assert(mesh.vertices.Count > 0);
-                        cmd.meshObj.SetVertices(mesh.vertices?.data);
-                        cmd.meshObj.SetTriangles(mesh.triangles?.data, 0, false);
-                        cmd.meshObj.SetUVs(0, mesh.uv?.data);
-
+                        
                         if (mesh.matrix == null) {
                             cmd.properties.SetFloatArray(CmdDraw.matId, CmdDraw.idMat3.fMat);
                         }
                             cmd.properties.SetFloatArray(CmdDraw.matId, this._drawLayer_matArray);
                         }
 
-                        cmdBuf.DrawMesh(cmd.meshObj, CmdDraw.idMat, cmd.material, 0, cmd.pass, cmd.properties.mpb);
+                        D.assert(mesh.vertices.Count > 0);
+                        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);
+                            cmd.properties.SetInt(CmdDraw.startIndexId, _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);
+                            cmd.meshObj.SetTriangles(mesh.triangles?.data, 0, false);
+                            cmd.meshObj.SetUVs(0, mesh.uv?.data);
+
+                            cmdBuf.DrawMesh(cmd.meshObj, CmdDraw.idMat, cmd.material, 0, cmd.pass, cmd.properties.mpb);
+                        }
+
                         if (cmd.layerId != null) {
                             cmdBuf.SetGlobalTexture(CmdDraw.texId, BuiltinRenderTextureType.None);
                         }

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

         }
     }
 
-    static class CanvasShader {
-        static readonly MaterialByBlendModeStencilComp _convexFillMat;
-        static readonly MaterialByStencilComp _fill0Mat;
-        static readonly MaterialByBlendMode _fill1Mat;
-        static readonly MaterialByBlendModeStencilComp _stroke0Mat;
-        static readonly Material _stroke1Mat;
-        static readonly MaterialByBlendModeStencilComp _texMat;
-        static readonly Material _stencilMat;
-        static readonly Material _filterMat;
-        static readonly MaterialByBlendModeStencilComp _strokeAlphaMat;
-        static readonly Material _shadowBox;
-        static readonly Material _shadowRBox;
+    static partial class CanvasShader {
+        static MaterialByBlendModeStencilComp _convexFillMat;
+        static MaterialByStencilComp _fill0Mat;
+        static MaterialByBlendMode _fill1Mat;
+        static MaterialByBlendModeStencilComp _stroke0Mat;
+        static Material _stroke1Mat;
+        static MaterialByBlendModeStencilComp _texMat;
+        static Material _stencilMat;
+        static Material _filterMat;
+        static MaterialByBlendModeStencilComp _strokeAlphaMat;
+        static Material _shadowBox;
+        static Material _shadowRBox;
 
         static Shader GetShader(string shaderName) {
             var shader = Shader.Find(shaderName);
             return shader;
         }
 
-        static CanvasShader() {
-            var convexFillShader = GetShader("UIWidgets/canvas_convexFill");
-            var fill0Shader = GetShader("UIWidgets/canvas_fill0");
-            var fill1Shader = GetShader("UIWidgets/canvas_fill1");
-            var stroke0Shader = GetShader("UIWidgets/canvas_stroke0");
-            var stroke1Shader = GetShader("UIWidgets/canvas_stroke1");
-            var texShader = GetShader("UIWidgets/canvas_tex");
-            var stencilShader = GetShader("UIWidgets/canvas_stencil");
-            var filterShader = GetShader("UIWidgets/canvas_filter");
-            var shadowBoxShader = GetShader("UIWidgets/ShadowBox");
-            var shadowRBoxShader = GetShader("UIWidgets/ShadowRBox");
-            var strokeAlphaShader = GetShader("UIWidgets/canvas_strokeAlpha");
+        public static bool enableComputeBuffer = true;
+
+        public static bool supportComputeBuffer;
-            _convexFillMat = new MaterialByBlendModeStencilComp(convexFillShader);
-            _fill0Mat = new MaterialByStencilComp(fill0Shader);
-            _fill1Mat = new MaterialByBlendMode(fill1Shader);
-            _stroke0Mat = new MaterialByBlendModeStencilComp(stroke0Shader);
-            _stroke1Mat = new Material(stroke1Shader) {hideFlags = HideFlags.HideAndDontSave};
-            _strokeAlphaMat = new MaterialByBlendModeStencilComp(strokeAlphaShader);
-            _texMat = new MaterialByBlendModeStencilComp(texShader);
-            _stencilMat = new Material(stencilShader) {hideFlags = HideFlags.HideAndDontSave};
-            _filterMat = new Material(filterShader) {hideFlags = HideFlags.HideAndDontSave};
-            _shadowBox = new Material(shadowBoxShader) {hideFlags = HideFlags.HideAndDontSave};
-            _shadowRBox = new Material(shadowRBoxShader) {hideFlags = HideFlags.HideAndDontSave};
+        static CanvasShader() {
+            
-
-        public static Material shadowBox => _shadowBox;
 
         static readonly int _viewportId = Shader.PropertyToID("_viewport");
         static readonly int _alphaId = Shader.PropertyToID("_alpha");
         public static PictureFlusher.CmdDraw convexFill(PictureFlusher.RenderLayer layer, uiPaint paint,
             uiMeshMesh mesh) {
             var mat = _convexFillMat.getMaterial(paint.blendMode, layer.ignoreClip);
+            
             _getShaderPassAndProps(layer, paint, mesh.matrix, 1.0f, 0.0f, out var pass, out var props);
 
             return PictureFlusher.CmdDraw.create(

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/canvas_shadow_utils.cs

             }
 
             var bound =  path.getBounds();
-            var sigma = state.scale * paint.maskFilter.Value.sigma;
+            var sigma = state.scale * paint.maskFilter.Value.sigma / 3f;
             
             var vertices = ObjectPool<uiList<Vector3>>.alloc();
             vertices.SetCapacity(4);
             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));
+            var shadowColor = paint.color.withAlpha(128);
+            layer.draws.Add(CanvasShader.fastShadow(layer, mesh, sigma, path.isRect, path.isCircle, path.rRectCorner, new Vector4(bound.left, bound.top, bound.right, bound.bottom), shadowColor));
         }
 
     }

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/ui/renderer/common/geometry/matrix/ui_matrix_utils.cs

 
 namespace Unity.UIWidgets.ui {
     public partial struct uiMatrix3 {
-        public void mapPoints(uiOffset[] dst, uiOffset[] src) {
+        public void mapPoints(ref uiOffset[] dst, ref uiOffset[] src) {
-            this._getMapPtsProc()(this, dst, src, src.Length);
+            this._getMapPtsProc()(this, ref dst, ref src, src.Length);
-        public void mapPoints(uiOffset[] pts) {
-            this.mapPoints(pts, pts);
+        public void mapPoints(ref uiOffset[] pts) {
+            this.mapPoints(ref pts, ref pts);
-        delegate void MapPtsProc(uiMatrix3 mat, uiOffset[] dst, uiOffset[] src, int count);
+        delegate void MapPtsProc(uiMatrix3 mat, ref uiOffset[] dst, ref uiOffset[] src, int count);
 
         static readonly MapPtsProc[] gMapPtsProcs = {
             Identity_pts, Trans_pts,
             return GetMapPtsProc(this._getType());
         }
 
-        static void Identity_pts(uiMatrix3 m, uiOffset[] dst, uiOffset[] src, int count) {
+        static void Identity_pts(uiMatrix3 m, ref uiOffset[] dst, ref uiOffset[] src, int count) {
             D.assert(m._getType() == 0);
 
             if (dst != src && count > 0) {
 
-        static void Trans_pts(uiMatrix3 m, uiOffset[] dst, uiOffset[] src, int count) {
+        static void Trans_pts(uiMatrix3 m, ref uiOffset[] dst, ref uiOffset[] src, int count) {
             D.assert(m._getType() <= TypeMask.kTranslate_Mask);
             if (count > 0) {
                 var tx = m.getTranslateX();
             }
         }
 
-        static void Scale_pts(uiMatrix3 m, uiOffset[] dst, uiOffset[] src, int count) {
+        static void Scale_pts(uiMatrix3 m, ref uiOffset[] dst, ref uiOffset[] src, int count) {
             D.assert(m._getType() <= (TypeMask.kScale_Mask | TypeMask.kTranslate_Mask));
             if (count > 0) {
                 var tx = m.getTranslateX();
             }
         }
 
-        static void Persp_pts(uiMatrix3 m, uiOffset[] dst, uiOffset[] src, int count) {
+        static void Persp_pts(uiMatrix3 m, ref uiOffset[] dst, ref uiOffset[] src, int count) {
             D.assert(m._hasPerspective());
 
             if (count > 0) {
             }
         }
 
-        static void Affine_pts(uiMatrix3 m, uiOffset[] dst, uiOffset[] src, int count) {
+        static void Affine_pts(uiMatrix3 m, ref uiOffset[] dst, ref uiOffset[] src, int count) {
             D.assert(m._getType() != TypeMask.kPerspective_Mask);
             if (count > 0) {
                 var tx = m.getTranslateX();

Runtime/widgets/page_view.cs

         public readonly float viewportFraction;
 
 
-        public float page {
+        public virtual float page {
             get {
                 D.assert(this.positions.isNotEmpty(),
                     () => "PageController.page cannot be accessed before a PageView is built with it."

Runtime/widgets/scroll_position.cs

 
         float? _maxScrollExtent;
 
+        public bool hasMinScrollExtent {
+            get { return this._minScrollExtent != null; }
+        }
+
+        public bool hasMaxScrollExtent {
+            get { return this._maxScrollExtent != null; }
+        }
+
         public override float pixels {
             get {
                 D.assert(this._pixels != null);

Runtime/Resources/shaders/UIWidgets_canvas_shadowBox.shader

     //originally from http://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
     Properties
     {
-        _SrcBlend("_SrcBlend", Int) = 1 // One
-        _DstBlend("_DstBlend", Int) = 10 // OneMinusSrcAlpha
         _StencilComp("_StencilComp", Float) = 8 // - Equal, 8 - Always 
     }
     SubShader
-        Blend [_SrcBlend] [_DstBlend]
+        Blend SrcAlpha OneMinusSrcAlpha
         
         Stencil {
             Ref 128

Runtime/Resources/shaders/UIWidgets_canvas_shadowRBox.shader

     //originally from http://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
     Properties
     {
-        _SrcBlend("_SrcBlend", Int) = 1 // One
-        _DstBlend("_DstBlend", Int) = 10 // OneMinusSrcAlpha
         _StencilComp("_StencilComp", Float) = 8 // - Equal, 8 - Always 
     }
     SubShader
-        Blend [_SrcBlend] [_DstBlend]
+        Blend SrcAlpha OneMinusSrcAlpha
         
         Stencil {
             Ref 128

Runtime/Resources/shaders.meta

+fileFormatVersion: 2
+guid: db2eb33ed6fce4c999c8481059ee7e6c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using UnityEngine;
+
+namespace Unity.UIWidgets.ui {
+    public partial class PictureFlusher {
+        
+        struct uiVertex
+        {
+            public Vector2 position;
+            public Vector2 uv;
+        }
+
+        static ComputeBuffer _computeBuffer;
+        static List<uiVertex> _vertices;
+
+        static ComputeBuffer _indexBuffer;
+        static List<int> _indices;
+        
+        static int _startVertex;
+        static int _startIndex;
+
+        static int _instanceNum;
+
+        public const int COMPUTE_BUFFER_MAX_ITEM_NUM = 1024 * 1024;   // maxsize = 1M vertex/index
+
+        static void _releaseComputeBuffer() {
+            if (!CanvasShader.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));
+            var strideIndex = Marshal.SizeOf(typeof(int));
+            _computeBuffer = new ComputeBuffer(COMPUTE_BUFFER_MAX_ITEM_NUM, stride);
+            _vertices = new List<uiVertex>();
+                
+            _indexBuffer = new ComputeBuffer(COMPUTE_BUFFER_MAX_ITEM_NUM, strideIndex);
+            _indices = new List<int>();
+        }
+
+        void _resetComputeBuffer() {
+            if (!CanvasShader.supportComputeBuffer) return;
+
+            if (_computeBuffer == null) {
+                this._initComputeBuffer();
+            }
+            
+            _vertices.Clear();
+            _indices.Clear();
+            _startVertex = 0;
+            _startIndex = 0;
+        }
+
+        void _bindComputeBuffer() {
+            if (!CanvasShader.supportComputeBuffer) return;
+            
+            _computeBuffer.SetData(_vertices);
+            _indexBuffer.SetData(_indices);
+        }
+
+        void _addMeshToComputeBuffer(List<Vector3> vertex, List<Vector2> uv, List<int> triangles) {
+            if (!CanvasShader.supportComputeBuffer) return;
+            
+            _startVertex = _vertices.Count;
+            _startIndex = _indices.Count;
+
+            var hasUv = uv != null;
+
+            for (int i = 0; i < vertex.Count; i++) {
+                _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);
+            }
+        }
+    }
+}

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: 

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

+using System;
+using Unity.UIWidgets.foundation;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace Unity.UIWidgets.ui {
+    enum InitStage {
+        NotPrepared,
+        Prepared,
+        Ready
+    }
+
+    static partial class CanvasShader {
+        static InitStage initStage = InitStage.NotPrepared;
+        static int initialFrameCount;
+        static Shader testShader;
+        const string testShaderName = "UIWidgets/canvas_convexFill_cb";
+
+        static bool OnNotPrepared() {
+            initStage = InitStage.Prepared;
+
+            initialFrameCount = Time.frameCount;
+            testShader = GetShader(testShaderName);
+            var material = new Material(testShader);
+            //for Unity 2018 or below, shader is compiled after Shader.Find() call immediately,
+            //therefore we can just skip the manually preload if the compilation fails
+            if (!material.shader.isSupported) {
+                ObjectUtils.SafeDestroy(material);
+                return OnPrepared(true);
+            }
+
+            using (var cmdBuf = new CommandBuffer()) {
+                var renderTarget = new RenderTexture(1, 1, 1);
+                cmdBuf.SetRenderTarget(renderTarget);
+
+                var mesh = new Mesh {
+                    vertices = new[] {new Vector3(0, 0, 0), new Vector3(0, 1, 0), new Vector3(1, 1, 0)},
+                    uv = new[] {new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1)},
+                    triangles = new[] {0, 1, 2}
+                };
+                cmdBuf.DrawMesh(mesh, Matrix4x4.identity, material);
+                cmdBuf.DisableScissorRect();
+                Graphics.ExecuteCommandBuffer(cmdBuf);
+
+                ObjectUtils.SafeDestroy(renderTarget);
+                ObjectUtils.SafeDestroy(mesh);
+            }
+
+            ObjectUtils.SafeDestroy(material);
+
+            return false;
+        }
+
+        static bool OnPrepared(bool forceReady = false) {
+            D.assert(initStage == InitStage.Prepared);
+            if (!forceReady && initialFrameCount >= Time.frameCount) {
+                return false;
+            }
+
+            initStage = InitStage.Ready;
+            DoPrepare();
+            return true;
+        }
+
+        static void DoPrepare() {
+            D.assert(testShader != null);
+            var isShaderSupported = testShader.isSupported;
+            testShader = null;
+            supportComputeBuffer = enableComputeBuffer && SystemInfo.supportsComputeShaders && isShaderSupported;
+
+            if (!supportComputeBuffer) {
+                var convexFillShader = GetShader("UIWidgets/canvas_convexFill");
+                var fill0Shader = GetShader("UIWidgets/canvas_fill0");
+                var fill1Shader = GetShader("UIWidgets/canvas_fill1");
+                var stroke0Shader = GetShader("UIWidgets/canvas_stroke0");
+                var stroke1Shader = GetShader("UIWidgets/canvas_stroke1");
+                var texShader = GetShader("UIWidgets/canvas_tex");
+                var stencilShader = GetShader("UIWidgets/canvas_stencil");
+                var filterShader = GetShader("UIWidgets/canvas_filter");
+                var shadowBoxShader = GetShader("UIWidgets/ShadowBox");
+                var shadowRBoxShader = GetShader("UIWidgets/ShadowRBox");
+                var strokeAlphaShader = GetShader("UIWidgets/canvas_strokeAlpha");
+
+                _convexFillMat = new MaterialByBlendModeStencilComp(convexFillShader);
+                _fill0Mat = new MaterialByStencilComp(fill0Shader);
+                _fill1Mat = new MaterialByBlendMode(fill1Shader);
+                _stroke0Mat = new MaterialByBlendModeStencilComp(stroke0Shader);
+                _stroke1Mat = new Material(stroke1Shader) {hideFlags = HideFlags.HideAndDontSave};
+                _strokeAlphaMat = new MaterialByBlendModeStencilComp(strokeAlphaShader);
+                _texMat = new MaterialByBlendModeStencilComp(texShader);
+                _stencilMat = new Material(stencilShader) {hideFlags = HideFlags.HideAndDontSave};
+                _filterMat = new Material(filterShader) {hideFlags = HideFlags.HideAndDontSave};
+                _shadowBox = new Material(shadowBoxShader) {hideFlags = HideFlags.HideAndDontSave};
+                _shadowRBox = new Material(shadowRBoxShader) {hideFlags = HideFlags.HideAndDontSave};
+            }
+            else {
+                var convexFillShaderCompute = GetShader("UIWidgets/canvas_convexFill_cb");
+                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 shadowBoxShaderCompute = GetShader("UIWidgets/ShadowBox_cb");
+                var shadowRBoxShaderCompute = GetShader("UIWidgets/ShadowRBox_cb");
+                var strokeAlphaShaderCompute = GetShader("UIWidgets/canvas_strokeAlpha_cb");
+
+                _convexFillMat = new MaterialByBlendModeStencilComp(convexFillShaderCompute);
+                _fill0Mat = new MaterialByStencilComp(fill0ShaderCompute);
+                _fill1Mat = new MaterialByBlendMode(fill1ShaderCompute);
+                _stroke0Mat = new MaterialByBlendModeStencilComp(stroke0ShaderCompute);
+                _stroke1Mat = new Material(stroke1ShaderCompute) {hideFlags = HideFlags.HideAndDontSave};
+                _strokeAlphaMat = new MaterialByBlendModeStencilComp(strokeAlphaShaderCompute);
+                _texMat = new MaterialByBlendModeStencilComp(texShaderCompute);
+                _stencilMat = new Material(stencilShaderCompute) {hideFlags = HideFlags.HideAndDontSave};
+                _filterMat = new Material(filterShaderCompute) {hideFlags = HideFlags.HideAndDontSave};
+                _shadowBox = new Material(shadowBoxShaderCompute) {hideFlags = HideFlags.HideAndDontSave};
+                _shadowRBox = new Material(shadowRBoxShaderCompute) {hideFlags = HideFlags.HideAndDontSave};
+            }
+        }
+
+        public static bool isReady() {
+            switch (initStage) {
+                case InitStage.NotPrepared:
+                    return OnNotPrepared();
+                case InitStage.Prepared:
+                    return OnPrepared();
+                case InitStage.Ready:
+                    return true;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+    }
+}

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

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

Runtime/Resources/shaders/UIWidgets_GUITexture.shader.meta

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

Runtime/Resources/shaders/UIWidgets_UIDefault.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas.cginc.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_convexFill.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_fill0.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_fill1.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_filter.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_shadowBox.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_shadowRBox.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_stencil.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_stroke0.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_stroke1.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_strokeAlpha.shader.meta

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

Runtime/Resources/shaders/UIWidgets_canvas_tex.shader.meta

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

Runtime/Resources/shaders/computebuffer.meta

+fileFormatVersion: 2
+guid: ad6fc8c9236144ca78ce73afd7a87833
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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)
+{
+    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
+            #pragma require compute
+            #define UIWIDGETS_COLOR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 1, linear
+            CGPROGRAM
+            #pragma require compute
+            #define UIWIDGETS_LINEAR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 2, radial
+            CGPROGRAM
+            #pragma require compute
+            #define UIWIDGETS_RADIAL
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 3, sweep
+            CGPROGRAM
+            #pragma require compute
+            #define UIWIDGETS_SWEEP
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 4, image
+            CGPROGRAM
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #define UIWIDGETS_COLOR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 1, linear
+            CGPROGRAM
+            #pragma require compute
+            #define UIWIDGETS_LINEAR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 2, radial
+            CGPROGRAM
+            #pragma require compute
+            #define UIWIDGETS_RADIAL
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 3, sweep
+            CGPROGRAM
+            #pragma require compute
+            #define UIWIDGETS_SWEEP
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 4, image
+            CGPROGRAM
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #define UIWIDGETS_COLOR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 1, linear
+            CGPROGRAM
+            #pragma require compute
+            #define UIWIDGETS_LINEAR
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 2, radial
+            CGPROGRAM
+            #pragma require compute
+            #define UIWIDGETS_RADIAL
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+
+        Pass { // 3, sweep
+            CGPROGRAM
+            #pragma require compute
+            #define UIWIDGETS_SWEEP
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag
+            ENDCG
+        }
+        
+        Pass { // 4, image
+            CGPROGRAM
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #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
+            #pragma require compute
+            #define UIWIDGETS_IMAGE
+            #include "../UIWidgets_canvas.cginc"
+            #include "UIWidgets_canvas_cb.cginc"
+            #pragma vertex vert_compute
+            #pragma fragment frag_tex
+            ENDCG
+        }     
+    }
+}

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_cb.cginc.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_convexFill_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_fill0_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_fill1_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_filter_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_stencil_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_stroke0_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_stroke1_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_strokeAlpha_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_tex_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_shadowBox_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_shadowRBox_cb.shader.meta

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

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_shadowBox_cb.shader

+Shader "UIWidgets/ShadowBox_cb"
+{
+    //originally from http://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
+    Properties
+    {
+        _StencilComp("_StencilComp", Float) = 8 // - Equal, 8 - Always 
+    }
+    SubShader
+    {
+        ZTest Always
+        ZWrite Off
+        Blend SrcAlpha OneMinusSrcAlpha
+        
+        Stencil {
+            Ref 128
+            Comp [_StencilComp]
+        }
+        
+        Pass {
+            CGPROGRAM
+            #pragma require compute
+            
+            float4 _sb_box;
+            float4 _viewport;
+            float _sb_sigma;
+            float4 _sb_color;
+            float _mat[9];
+            
+            struct vdata
+            {
+                float2 vertex;
+                float2 uv;
+            };
+
+            StructuredBuffer<vdata> databuffer;
+            StructuredBuffer<int> indexbuffer;
+            int _startVertex;
+
+            struct v2f
+            {
+                float4 vertex : SV_POSITION;
+                float2 coord : TEXCOORD0;
+            };
+            
+            float4 erf(float4 x) 
+            {
+                float4 s = sign(x);
+                float4 a = abs(x);
+                x = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
+                x = x * x;
+                return s - s / (x * x);
+                return s;
+            }
+            
+            float boxShadow(float2 lower, float2 upper, float2 pnt, float sigma)
+            {
+                float4 query = float4(pnt - lower, pnt - upper);
+                float4 integral = 0.5 + 0.5 * erf(query * (sqrt(0.5) / sigma));
+                return (integral.z - integral.x) * (integral.w - integral.y);
+            }
+            
+            v2f vert(uint vertex_id: SV_VertexID){
+                v2f o;
+                vdata v = databuffer[indexbuffer[_startVertex + vertex_id]];
+                float padding = 3.0 * _sb_sigma;
+                o.coord = lerp(_sb_box.xy - padding, _sb_box.zw + padding, v.vertex.xy);
+                float3x3 mat = float3x3(_mat[0], _mat[1], _mat[2], _mat[3], _mat[4], _mat[5], 0, 0, 1);
+                float2 p = mul(mat, float3(o.coord.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;
+            }
+            
+            float4 frag(v2f i) : SV_TARGET {
+                float4 fragColor = _sb_color;
+                fragColor.a = fragColor.a * boxShadow(_sb_box.xy, _sb_box.zw, i.coord, _sb_sigma);
+                return fragColor;
+            }
+            
+            #pragma vertex vert
+            #pragma fragment frag
+            
+            ENDCG
+        }
+    }
+}

Runtime/Resources/shaders/computebuffer/UIWidgets_canvas_shadowRBox_cb.shader

+Shader "UIWidgets/ShadowRBox_cb"
+{
+    //originally from http://madebyevan.com/shaders/fast-rounded-rectangle-shadows/
+    Properties
+    {
+        _StencilComp("_StencilComp", Float) = 8 // - Equal, 8 - Always 
+    }
+    SubShader
+    {
+        ZTest Always
+        ZWrite Off
+        Blend SrcAlpha OneMinusSrcAlpha
+        
+        Stencil {
+            Ref 128
+            Comp [_StencilComp]
+        }
+        
+        Pass {
+            CGPROGRAM
+            
+            #pragma require compute
+            
+            float4 _sb_box;
+            float4 _viewport;
+            float _sb_sigma;
+            float4 _sb_color;
+            float _sb_corner;
+            float _mat[9];
+            
+            struct vdata
+            {
+                float2 vertex;
+                float2 uv;
+            };
+
+            StructuredBuffer<vdata> databuffer;
+            StructuredBuffer<int> indexbuffer;
+            int _startVertex;
+
+            struct v2f
+            {
+                float4 vertex : SV_POSITION;
+                float2 coord : TEXCOORD0;
+            };
+            
+            float gaussian(float x, float sigma)
+            {
+                float pi = 3.141592653589793;
+                return exp(-(x*x) / (2.0 * sigma * sigma)) / (sqrt(2.0 * pi) * sigma);
+            }
+            
+            float2 erf(float2 x) 
+            {
+                float2 s = sign(x);
+                float2 a = abs(x);
+                x = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
+                x = x * x;
+                return s - s / (x * x);
+                return s;
+            }
+            
+            float roundedBoxShadowX(float x, float y, float sigma, float corner, float2 halfSize)
+            {
+                float delta = min(halfSize.y - corner - abs(y), 0.0);
+                float curved = halfSize.x - corner + sqrt(max(0.0, corner * corner - delta * delta));
+                float2 integral = 0.5 + 0.5 * erf((x + float2(-curved, curved)) * (sqrt(0.5)/sigma));
+                return integral.y - integral.x;
+            }
+            
+            float roundedBoxShadow(float2 lower, float2 upper, float2 pnt, float sigma, float corner)
+            {
+                float2 center = (lower + upper) * 0.5;
+                float2 halfSize = (upper - lower) * 0.5;
+                pnt -= center;
+                
+                float low = pnt.y - halfSize.y;
+                float high = pnt.y + halfSize.y;
+                float start = clamp(-3.0 * sigma, low, high);
+                float end = clamp(3.0 * sigma, low, high);
+                
+                float step = (end - start) / 4.0;
+                float y = start + step * 0.5;
+                float value = 0.0;
+                
+                for(int i=0; i<4;i++)
+                {
+                    value += roundedBoxShadowX(pnt.x, pnt.y - y, sigma, corner, halfSize) * gaussian(y, sigma) * step;
+                    y += step;
+                }
+                
+                return value;
+            }
+            
+            v2f vert(uint vertex_id: SV_VertexID){
+                v2f o;
+                vdata v = databuffer[indexbuffer[_startVertex + vertex_id]];
+                float padding = 3.0 * _sb_sigma;
+                o.coord = lerp(_sb_box.xy - padding, _sb_box.zw + padding, v.vertex.xy);
+                float3x3 mat = float3x3(_mat[0], _mat[1], _mat[2], _mat[3], _mat[4], _mat[5], 0, 0, 1);
+                float2 p = mul(mat, float3(o.coord.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;
+            }
+            
+            float4 frag(v2f i) : SV_TARGET {
+                float4 fragColor = _sb_color;
+                fragColor.a = fragColor.a * roundedBoxShadow(_sb_box.xy, _sb_box.zw, i.coord, _sb_sigma, _sb_corner);
+                return fragColor;
+            }
+            
+            #pragma vertex vert
+            #pragma fragment frag
+            
+            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: