fix canvas in OpenGL/WebGL.

Runtime/Resources/UIWidgets_canvas.shader

         v2f o;
         o.ftcoord = v.tcoord;
         o.fpos = v.vertex;
+        
+    #if UNITY_UV_STARTS_AT_TOP
+    #else
+        o.vertex = float4(2.0 * v.vertex.x / _viewSize.x - 1.0, 1.0 - 2.0 * v.vertex.y / _viewSize.y, 0, 1);
+    #endif
+
         return o;
     }
     

Runtime/editor/surface.cs

 
     public class EditorWindowSurface : Surface {
         static Material _guiTextureMat;
+        static Material _uiDefaultMat;
+
         public delegate void DrawToTargetFunc(Rect screenRect, Texture texture, Material mat);
         
         internal static Material _getGUITextureMat() {
             _guiTextureMat.hideFlags = HideFlags.HideAndDontSave;
             return _guiTextureMat;
         }
+        
+        internal static Material _getUIDefaultMat() {
+            if (_uiDefaultMat) {
+                return _uiDefaultMat;
+            }
+
+            var uiDefaultShader = Shader.Find("UIWidgets/UIDefault");
+            if (uiDefaultShader == null) {
+                throw new Exception("UIWidgets/UIDefault not found");
+            }
+
+            _uiDefaultMat = new Material(uiDefaultShader);
+            _uiDefaultMat.hideFlags = HideFlags.HideAndDontSave;
+            return _uiDefaultMat;
+        }
+
 
         GrSurface _surface;
         private DrawToTargetFunc _drawToTargetFunc;
                 (float) (this._surface.size.width / this._surface.devicePixelRatio),
                 (float) (this._surface.size.height / this._surface.devicePixelRatio));
 
-            if (_drawToTargetFunc == null)
-            {
+            if (this._drawToTargetFunc == null) {
-            }
-            else
-            {
-                _drawToTargetFunc(screenRect, this._surface.getRenderTexture(), _getGUITextureMat());
+            } else {
+                this._drawToTargetFunc(screenRect, this._surface.getRenderTexture(), _getUIDefaultMat());
             }
             return true;
         }

Runtime/engine/WidgetCanvas.cs

-using System;
-using Unity.UIWidgets.async;
+using Unity.UIWidgets.async;
-using Unity.UIWidgets.painting;
+using Unity.UIWidgets.foundation;
+using RawImage = UnityEngine.UI.RawImage;
 using Rect = UnityEngine.Rect;
 
 namespace Unity.UIWidgets.engine
     }
 
     [RequireComponent(typeof(RectTransform))]
-    public abstract class WidgetCanvas : MaskableGraphic, IPointerDownHandler, IPointerUpHandler, IDragHandler,
+    public abstract class WidgetCanvas : RawImage, IPointerDownHandler, IPointerUpHandler, IDragHandler,
+        private static Event _repaintEvent;
+        
-        private static Event _repaintEvent;
+        
+
-                _repaintEvent = new Event() { type = EventType.Repaint };
+                _repaintEvent = new Event {type = EventType.Repaint};
-            if (_windowAdapter == null)
-            {
-                _windowAdapter = new UIWidgetWindowAdapter(this);
-            }
+            D.assert(this._windowAdapter == null);
+            _windowAdapter = new UIWidgetWindowAdapter(this);
             
             _windowAdapter.OnEnable();
             var root = new WidgetsApp(home: getWidget(), window: _windowAdapter);
 
-        private void OnDisable()
+        protected override void OnDisable()
+            D.assert(this._windowAdapter != null);
+            this._windowAdapter = null;
-        public override Texture mainTexture
-        {
-            get { return _texture; }
-        }
-
-        internal void applyRenderTexture(Rect screenRect, Texture texture, Material mat)
-        {
-            _texture = texture;
-            SetMaterialDirty();
-        }
-
-        private void OnDestroy()
-        {
-            base.OnDestroy();
+        internal void applyRenderTexture(Rect screenRect, Texture texture, Material mat) {
+            this.texture = texture;
+            this.material = mat;
         }
 
         private void Update()
             }
 
             _lastMouseMove = Input.mousePosition;
-            if (this._windowAdapter != null)
-            {
-                this._windowAdapter.Update();
-            }
+            
+            D.assert(this._windowAdapter != null);
+            this._windowAdapter.Update();
-         private void OnGUI()
+        private void OnGUI()
         {
             if (Event.current.type == EventType.KeyDown || Event.current.type == EventType.KeyUp)
             {
 
         public Vector2 getPointPosition(Vector2 position)
         { 
-            // Debug.Log("mouse posse " + position.x + " " + position.y);
             Vector2 localPoint;
             Camera eventCamera = null;
 

Runtime/Resources/UIWidgets_UIDefault.shader

+Shader "UIWidgets/UIDefault"
+{
+    Properties
+    {
+        [PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+        _Color ("Tint", Color) = (1,1,1,1)
+
+        _StencilComp ("Stencil Comparison", Float) = 8
+        _Stencil ("Stencil ID", Float) = 0
+        _StencilOp ("Stencil Operation", Float) = 0
+        _StencilWriteMask ("Stencil Write Mask", Float) = 255
+        _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+        _ColorMask ("Color Mask", Float) = 15
+
+        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "Queue"="Transparent"
+            "IgnoreProjector"="True"
+            "RenderType"="Transparent"
+            "PreviewType"="Plane"
+            "CanUseSpriteAtlas"="True"
+        }
+
+        Stencil
+        {
+            Ref [_Stencil]
+            Comp [_StencilComp]
+            Pass [_StencilOp]
+            ReadMask [_StencilReadMask]
+            WriteMask [_StencilWriteMask]
+        }
+
+        Cull Off
+        Lighting Off
+        ZWrite Off
+        ZTest [unity_GUIZTestMode]
+        Blend One OneMinusSrcAlpha
+        ColorMask [_ColorMask]
+
+        Pass
+        {
+            Name "Default"
+        CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma target 2.0
+
+            #include "UnityCG.cginc"
+            #include "UnityUI.cginc"
+
+            #pragma multi_compile __ UNITY_UI_CLIP_RECT
+            #pragma multi_compile __ UNITY_UI_ALPHACLIP
+
+            struct appdata_t
+            {
+                float4 vertex   : POSITION;
+                float4 color    : COLOR;
+                float2 texcoord : TEXCOORD0;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct v2f
+            {
+                float4 vertex   : SV_POSITION;
+                fixed4 color    : COLOR;
+                float2 texcoord  : TEXCOORD0;
+                float4 worldPosition : TEXCOORD1;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            sampler2D _MainTex;
+            fixed4 _Color;
+            fixed4 _TextureSampleAdd;
+            float4 _ClipRect;
+            float4 _MainTex_ST;
+
+            v2f vert(appdata_t v)
+            {
+                v2f OUT;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
+                OUT.worldPosition = v.vertex;
+                OUT.vertex = UnityObjectToClipPos(OUT.worldPosition);
+
+                OUT.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);
+
+                OUT.color = v.color * _Color;
+                return OUT;
+            }
+
+            fixed4 frag(v2f IN) : SV_Target
+            {
+                half4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color;
+
+                #ifdef UNITY_UI_CLIP_RECT
+                color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
+                #endif
+
+                #ifdef UNITY_UI_ALPHACLIP
+                clip (color.a - 0.001);
+                #endif
+
+                return color;
+            }
+        ENDCG
+        }
+    }
+}

Runtime/Resources/UIWidgets_UIDefault.shader.meta

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