split UIWidgetsPanelWrapper

com.unity.uiwidgets/Runtime/engine2/UIWidgetsPanel.cs

 using System;
+using System.Collections;
+using Unity.UIWidgets.editor2;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.gestures;
 using Unity.UIWidgets.services;
 using NativeBindings = Unity.UIWidgets.ui.NativeBindings;
 
 namespace Unity.UIWidgets.engine2 {
-#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
-    public partial class UIWidgetsPanel {
-        RenderTexture _renderTexture;
-        void _createRenderTexture(int width, int height, float devicePixelRatio) {
-            D.assert(_renderTexture == null);
-
-            var desc = new RenderTextureDescriptor(
-                width, height, RenderTextureFormat.ARGB32, 0) {
-                useMipMap = false,
-                autoGenerateMips = false,
-            };
-
-            _renderTexture = new RenderTexture(desc) {hideFlags = HideFlags.HideAndDontSave};
-            _renderTexture.Create();
-
-            _width = width;
-            _height = height;
-            _devicePixelRatio = devicePixelRatio;
-
-            texture = _renderTexture;
-        }
-
-        void _destroyRenderTexture() {
-            D.assert(_renderTexture != null);
-            texture = null;
-            ObjectUtils.SafeDestroy(_renderTexture);
-            _renderTexture = null;
-        }
-
-        void _enableUIWidgetsPanel(string font_settings) {
-            UIWidgetsPanel_onEnable(_ptr, _renderTexture.GetNativeTexturePtr(),
-                _width, _height, _devicePixelRatio, Application.streamingAssetsPath, font_settings);
-        }
-
-        void _resizeUIWidgetsPanel() {
-            UIWidgetsPanel_onRenderTexture(_ptr,
-                _renderTexture.GetNativeTexturePtr(),
-                _width, _height, _devicePixelRatio);
-        }
-
-        void _disableUIWidgetsPanel() {
-            _renderTexture = null;
-            texture = null;
-        }
+    public interface IUIWidgetsWindow {
+        Offset windowPosToScreenPos(Offset offset);
+        Coroutine startCoroutine(IEnumerator routing);
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_onEnable(IntPtr ptr,
-            IntPtr nativeTexturePtr, int width, int height, float dpi, string streamingAssetsPath,
-            string font_settings);
+        bool isActive();
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_onRenderTexture(
-            IntPtr ptr, IntPtr nativeTexturePtr, int width, int height, float dpi);
+        void mainEntry();
+    }
+    
+#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
+    public partial class UIWidgetsPanel : IUIWidgetsWindow{
+        UIWidgetsPanelWrapper _wrapper;
     }
 
 #elif UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
     }
 #endif
 
-    public partial class UIWidgetsPanel : RawImage {
+    public partial class UIWidgetsPanel : RawImage { 
         [Serializable]
         public struct Font {
             public string asset;
             return result;
         }
 
-        public float devicePixelRatioOverride = 1;
-
-
-        public float hardwareAntiAliasing;
-        // RectTransform rectTransform {
-        //     get { return rectTransform; }
-        // }
-
-        // Canvas canvas {
-        //     get { return canvas; }
-        // }
-
-        // Texture texture {
-        //     set { texture = value; }
-        // }
-
-        public static UIWidgetsPanel current {
-            get { return Window.instance._panel; }
-        }
-
-        public Isolate isolate { get; private set; }
-
-        IntPtr _ptr;
-        GCHandle _handle;
-
-        int _width;
-        int _height;
-        float _devicePixelRatio;
-
         int _currentWidth {
             get { return Mathf.RoundToInt(rectTransform.rect.width * canvas.scaleFactor); }
         }
 
         protected void OnEnable() {
             base.OnEnable();
-            D.assert(_renderTexture == null);
-            _recreateRenderTexture(_currentWidth, _currentHeight, _currentDevicePixelRatio);
-
-            _handle = GCHandle.Alloc(this);
-            _ptr = UIWidgetsPanel_constructor((IntPtr) _handle, UIWidgetsPanel_entrypoint);
-
-            _enableUIWidgetsPanel(JSONMessageCodec.instance.toJson(settings));
+            
+            D.assert(_wrapper == null);
+            _wrapper = new UIWidgetsPanelWrapper();
+            _wrapper.Initiate(this, _currentWidth, _currentHeight, _currentDevicePixelRatio, settings);
+            texture = _wrapper.renderTexture;
+        }
-            Input_OnEnable();
-            NativeConsole.OnEnable();
+        public void mainEntry() {
+            main();
-        void _entryPoint() {
-            try {
-                isolate = Isolate.current;
-                Window.instance._panel = this;
-
-                main();
-            }
-            catch (Exception ex) {
-                Debug.LogException(new Exception("exception in main", ex));
-            }
-        }
-
-            if (_ptr != IntPtr.Zero && _renderTexture) {
-                if (_recreateRenderTexture(_currentWidth, _currentHeight, _currentDevicePixelRatio)) {
-                    _resizeUIWidgetsPanel();
-                }
+            if (_wrapper != null) {
+                _wrapper.OnRectTransformDimensionsChange(_currentWidth, _currentHeight, _currentDevicePixelRatio);
+                texture = _wrapper.renderTexture;
-
+        
-            Input_OnDisable();
-
-            UIWidgetsPanel_onDisable(_ptr);
-            UIWidgetsPanel_dispose(_ptr);
-            _ptr = IntPtr.Zero;
-
-            _handle.Free();
-            _handle = default;
-
-            _disableUIWidgetsPanel();
-
-            D.assert(!isolate.isValid);
+            D.assert(_wrapper != null);
+            _wrapper?.Destroy();
+            _wrapper = null;
+            texture = null;
-        bool _recreateRenderTexture(int width, int height, float devicePixelRatio) {
-            if (_renderTexture != null && _width == width && _height == height &&
-                _devicePixelRatio == devicePixelRatio) {
-                return false;
-            }
-
-            if (_renderTexture) {
-                _destroyRenderTexture();
-            }
-
-            _createRenderTexture(width, height, devicePixelRatio);
-            return true;
-        }
-
         protected virtual void Update() {
             Input_Update();
         }
         }
+    }
-        public int registerTexture(Texture texture) {
-            return UIWidgetsPanel_registerTexture(_ptr, texture.GetNativeTexturePtr());
-        }
+    public partial class UIWidgetsPanel : IPointerDownHandler, IPointerUpHandler,
+        IPointerEnterHandler, IPointerExitHandler, IDragHandler {
-        public void unregisterTexture(int textureId) {
-            UIWidgetsPanel_unregisterTexture(_ptr, textureId);
-        }
+        Vector2? _getPointerPosition(Vector2 position) {
+            Camera worldCamera = canvas.worldCamera;
+            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(
+                rectTransform, position, worldCamera, out var localPoint)) {
+                var scaleFactor = canvas.scaleFactor;
+                localPoint.x = (localPoint.x - rectTransform.rect.min.x) * scaleFactor;
+                localPoint.y = (rectTransform.rect.max.y - localPoint.y) * scaleFactor;
+                return localPoint;
+            }
-        public void markNewFrameAvailable(int textureId) {
-            UIWidgetsPanel_markNewFrameAvailable(_ptr, textureId);
+            return null;
-
-        delegate void UIWidgetsPanel_EntrypointCallback(IntPtr handle);
-
-        [MonoPInvokeCallback(typeof(UIWidgetsPanel_EntrypointCallback))]
-        static void UIWidgetsPanel_entrypoint(IntPtr handle) {
-            GCHandle gcHandle = (GCHandle) handle;
-            UIWidgetsPanel panel = (UIWidgetsPanel) gcHandle.Target;
-            panel._entryPoint();
+        public bool isActive() {
+            return IsActive();
-        [DllImport(NativeBindings.dllName)]
-        static extern IntPtr UIWidgetsPanel_constructor(IntPtr handle,
-            UIWidgetsPanel_EntrypointCallback entrypointCallback);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_dispose(IntPtr ptr);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_onDisable(IntPtr ptr);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern int UIWidgetsPanel_registerTexture(IntPtr ptr, IntPtr nativeTexturePtr);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_unregisterTexture(IntPtr ptr, int textureId);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_markNewFrameAvailable(IntPtr ptr, int textureId);
-    }
+        public Coroutine startCoroutine(IEnumerator routing) {
+            return StartCoroutine(routing);
+        }
+        
+        public Offset windowPosToScreenPos(Offset offset) {
+            Camera camera = null;
+            if (canvas.renderMode != RenderMode.ScreenSpaceCamera) {
+                camera = canvas.GetComponent<GraphicRaycaster>().eventCamera;
+            }
-    public partial class UIWidgetsPanel : IPointerDownHandler, IPointerUpHandler,
-        IPointerEnterHandler, IPointerExitHandler, IDragHandler {
+            var pos = new Vector2(offset.dx, offset.dy);
+            pos = pos * _currentDevicePixelRatio / canvas.scaleFactor;
+            var rect = rectTransform.rect;
+            pos.x += rect.min.x;
+            pos.y = rect.max.y - pos.y;
+            var worldPos = rectTransform.TransformPoint(new Vector2(pos.x, pos.y));
+            var screenPos = RectTransformUtility.WorldToScreenPoint(camera, worldPos);
+            return new Offset(screenPos.x, Screen.height - screenPos.y);
+        }
+                
-        void Input_OnEnable() {
-        }
-
-        void Input_OnDisable() {
-        }
-
-        void Input_Update() {
+        public void Input_Update() {
             if (Input.touchCount == 0 && Input.mousePresent) {
                 if (_isEntered) {
                     if (!Input.GetMouseButton(0) && !Input.GetMouseButton(1) && !Input.GetMouseButton(2)) {
             }
         }
 
-        void Input_OnGUI() {
+        public void Input_OnGUI() {
-                UIWidgetsPanel_onKey(_ptr, e.keyCode, e.type == EventType.KeyDown);
-                if (e.character != 0 || e.keyCode == KeyCode.Backspace) {
-                    PointerEventConverter.KeyEvent.Enqueue(new Event(e));
-                    // TODO: add on char
-                    // UIWidgetsPanel_onChar(_ptr, e.character);
-                }
-            }
-        }
-
-        Vector2? _getPointerPosition(Vector2 position) {
-            Camera worldCamera = canvas.worldCamera;
-            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(
-                rectTransform, position, worldCamera, out var localPoint)) {
-                var scaleFactor = canvas.scaleFactor;
-                localPoint.x = (localPoint.x - rectTransform.rect.min.x) * scaleFactor;
-                localPoint.y = (rectTransform.rect.max.y - localPoint.y) * scaleFactor;
-                return localPoint;
+                _wrapper.OnKeyDown(e);
-
-            return null;
-            if (pos == null) {
-                return;
-            }
-
-            UIWidgetsPanel_onMouseMove(_ptr, pos.Value.x, pos.Value.y);
+            _wrapper.OnMouseMove(pos);
-            if (pos == null) {
-                return;
-            }
-
-            // mouse event
-            if (eventData.pointerId < 0) {
-                UIWidgetsPanel_onMouseDown(_ptr, pos.Value.x, pos.Value.y, eventData.pointerId);
-            }
+            _wrapper.OnPointerDown(pos, eventData.pointerId);
-            if (pos == null) {
-                return;
-            }
-
-            // mouse event
-            if (eventData.pointerId < 0) {
-                UIWidgetsPanel_onMouseUp(_ptr, pos.Value.x, pos.Value.y, eventData.pointerId);
-            }
+            _wrapper.OnPointerUp(pos, eventData.pointerId);
-
+        
         public void OnPointerEnter(PointerEventData eventData) {
             D.assert(eventData.pointerId < 0);
             _isEntered = true;
         public void OnPointerExit(PointerEventData eventData) {
             D.assert(eventData.pointerId < 0);
             _isEntered = false;
-            UIWidgetsPanel_onMouseLeave(_ptr);
+            _wrapper.OnPointerLeave();
-            if (pos == null) {
-                return;
-            }
-
-            // mouse event
-            if (eventData.pointerId < 0) {
-                UIWidgetsPanel_onMouseMove(_ptr, pos.Value.x, pos.Value.y);
-            }
+            _wrapper.OnDrag(pos, eventData.pointerId);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_onChar(IntPtr ptr, char c);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_onKey(IntPtr ptr, KeyCode keyCode, bool isKeyDown);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_onMouseDown(IntPtr ptr, float x, float y, int button);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_onMouseUp(IntPtr ptr, float x, float y, int button);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_onMouseMove(IntPtr ptr, float x, float y);
-
-        [DllImport(NativeBindings.dllName)]
-        static extern void UIWidgetsPanel_onMouseLeave(IntPtr ptr);
     }
 }

com.unity.uiwidgets/Runtime/foundation/debug.cs

 
         [Conditional("UNITY_ASSERTIONS")]
         public static void assert(Func<bool> result, Func<string> message = null) {
-            if (!result()) {
-                throw new AssertionError(message != null ? message() : "");
-            }
+            //if (!result()) {
+           //     throw new AssertionError(message != null ? message() : "");
+            //}
-            if (!result) {
-                throw new AssertionError(message != null ? message() : "");
-            }
+           // if (!result) {
+           //     throw new AssertionError(message != null ? message() : "");
+           // }
         }
 
         public static bool debugPrintGestureArenaDiagnostics = false;

com.unity.uiwidgets/Runtime/painting/image_provider.cs

 using System.IO;
 using System.Text;
 using Unity.UIWidgets.async2;
+using Unity.UIWidgets.editor2;
 using Unity.UIWidgets.engine2;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
         Future<Codec> _loadAsync(NetworkImage key, DecoderCallback decode) {
             var completer = Completer.create();
             var isolate = Isolate.current;
-            var panel = UIWidgetsPanel.current;
-            if (panel.IsActive()) {
-                panel.StartCoroutine(_loadCoroutine(key.url, completer, isolate));
+            var panel = UIWidgetsPanelWrapper.current.window;
+            if (panel.isActive()) {
+                panel.startCoroutine(_loadCoroutine(key.url, completer, isolate));
                 return completer.future.to<byte[]>().then_<byte[]>(data => {
                     if (data != null && data.Length > 0) {
                         return decode(data);

com.unity.uiwidgets/Runtime/services/asset_bundle.cs

 using System.Collections.Generic;
 using System.Text;
 using Unity.UIWidgets.async2;
+using Unity.UIWidgets.editor2;
 using Unity.UIWidgets.engine2;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
         public override Future<byte[]> load(string key) {
             var completer = Completer.create();
             var isolate = Isolate.current;
-            var panel = UIWidgetsPanel.current;
-            panel.StartCoroutine(_loadCoroutine(key, completer, isolate));
+            var panel =UIWidgetsPanelWrapper.current.window;
+            panel.startCoroutine(_loadCoroutine(key, completer, isolate));
             return completer.future.to<byte[]>();
         }
 

com.unity.uiwidgets/Runtime/ui2/window.cs

 using System.Runtime.InteropServices;
 using AOT;
 using Unity.UIWidgets.async2;
+using Unity.UIWidgets.editor2;
 using Unity.UIWidgets.engine2;
 using Unity.UIWidgets.foundation;
 using Unity.UIWidgets.ui;
     public class Window {
         internal IntPtr _ptr;
         internal object _binding;
-        internal UIWidgetsPanel _panel;
+        internal UIWidgetsPanelWrapper _panel;
         internal _AsyncCallbackState _asyncCallbackState;
 
         internal Window() {
         }
 
         protected float queryDevicePixelRatio() {
-            return _panel.devicePixelRatioOverride;
+            return _panel.devicePixelRatio;
-            Camera camera = null;
-            var canvas = _panel.canvas;
-            if (canvas.renderMode != RenderMode.ScreenSpaceCamera) {
-                camera = canvas.GetComponent<GraphicRaycaster>().eventCamera;
-            }
-
-            var pos = new Vector2(offset.dx, offset.dy);
-            pos = pos * queryDevicePixelRatio() / _panel.canvas.scaleFactor;
-            var rectTransform = _panel.rectTransform;
-            var rect = rectTransform.rect;
-            pos.x += rect.min.x;
-            pos.y = rect.max.y - pos.y;
-            var worldPos = rectTransform.TransformPoint(new Vector2(pos.x, pos.y));
-            var screenPos = RectTransformUtility.WorldToScreenPoint(camera, worldPos);
-            return new Offset(screenPos.x, Screen.height - screenPos.y);
-        }
-
-        public void run(Action callback) {
-            //Fixme: do nothing now
-            D.assert(false, () => "window.run is not implemented yet!");
+            return _panel.window.windowPosToScreenPos(offset);
         }
 
         public PointerDataPacketCallback onPointerDataPacket {

com.unity.uiwidgets/Runtime/engine2/UIWidgetsEditorPanel.cs

+/*using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using AOT;
+using uiwidgets;
+using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.services;
+using Unity.UIWidgets.ui;
+using Unity.UIWidgets.widgets;
+using UnityEditor;
+using UnityEngine;
+using Rect = UnityEngine.Rect;
+using ui_ = Unity.UIWidgets.widgets.ui_;
+
+namespace Unity.UIWidgets.editor2 {
+#if UNITY_EDITOR
+    
+    class MyApp : StatelessWidget
+    {
+        public override Widget build(BuildContext context)
+        {
+            return new WidgetsApp(
+                home: new Container(color: Colors.blue),
+                pageRouteBuilder: (settings, builder) =>
+                    new PageRouteBuilder(
+                        settings: settings,
+                        pageBuilder: (Buildcontext, animation, secondaryAnimation) => builder(context)
+                    )
+            );
+        }
+    }
+
+    public class UIWidgetsEditorPanel : EditorWindow, IUIWidgetsPanel {
+        RenderTexture _renderTexture;
+        
+        void _createRenderTexture(int width, int height, float devicePixelRatio) { 
+            D.assert(_renderTexture == null);
+
+            var desc = new RenderTextureDescriptor(
+                width, height, RenderTextureFormat.ARGB32, 0) {
+                useMipMap = false,
+                autoGenerateMips = false,
+            };
+
+            _renderTexture = new RenderTexture(desc) {hideFlags = HideFlags.HideAndDontSave};
+            _renderTexture.Create();
+
+            _width = width;
+            _height = height;
+            _devicePixelRatio = devicePixelRatio;
+        }
+
+        void _destroyRenderTexture() {
+            D.assert(_renderTexture != null);
+            ObjectUtils.SafeDestroy(_renderTexture);
+            _renderTexture = null;
+        }
+
+        void _enableUIWidgetsPanel(string font_settings) {
+            UIWidgetsPanel_onEnable(_ptr, _renderTexture.GetNativeTexturePtr(),
+                _width, _height, _devicePixelRatio, Application.streamingAssetsPath, font_settings);
+        }
+
+        void _resizeUIWidgetsPanel() {
+            UIWidgetsPanel_onRenderTexture(_ptr,
+                _renderTexture.GetNativeTexturePtr(),
+                _width, _height, _devicePixelRatio);
+        }
+
+        void _disableUIWidgetsPanel() {
+            _renderTexture = null;
+        }
+
+        public Isolate isolate { get; private set; }
+
+        IntPtr _ptr;
+        GCHandle _handle;
+
+        int _width;
+        int _height;
+        float _devicePixelRatio;
+
+        int _currentWidth {
+            get { return Mathf.RoundToInt(position.size.x); }
+        }
+
+        int _currentHeight {
+            get { return Mathf.RoundToInt(position.size.y); }
+        }
+
+        float _currentDevicePixelRatio {
+            get { return EditorGUIUtility.pixelsPerPoint; }
+        }
+
+        void Awake() {
+            D.assert(_renderTexture == null);
+            _recreateRenderTexture(_currentWidth, _currentHeight, _currentDevicePixelRatio);
+
+            _handle = GCHandle.Alloc(this);
+            _ptr = UIWidgetsPanel_constructor((IntPtr) _handle, UIWidgetsPanel_entrypoint);
+            var settings = new Dictionary<string, object>();
+
+            _enableUIWidgetsPanel(JSONMessageCodec.instance.toJson(settings));
+            NativeConsole.OnEnable();
+        }
+        
+        void OnGUI()
+        {
+            GUI.DrawTexture(new Rect(0.0f, 0.0f, position.width, position.height), _renderTexture);
+        }
+
+        protected virtual void main() {
+            ui_.runApp(new MyApp());
+        }
+
+        void _entryPoint() {
+            try {
+                isolate = Isolate.current;
+                Window.instance._panel = this;
+
+                main();
+            }
+            catch (Exception ex) {
+                Debug.LogException(new Exception("exception in main", ex));
+            }
+        }
+        
+        delegate void UIWidgetsPanel_EntrypointCallback(IntPtr handle);
+
+        [MonoPInvokeCallback(typeof(UIWidgetsPanel_EntrypointCallback))]
+        static void UIWidgetsPanel_entrypoint(IntPtr handle) {
+            GCHandle gcHandle = (GCHandle) handle;
+            UIWidgetsEditorPanel panel = (UIWidgetsEditorPanel) gcHandle.Target;
+            panel._entryPoint();
+        }
+        
+        bool _recreateRenderTexture(int width, int height, float devicePixelRatio) {
+            if (_renderTexture != null && _width == width && _height == height &&
+                _devicePixelRatio == devicePixelRatio) {
+                return false;
+            }
+
+            if (_renderTexture) {
+                _destroyRenderTexture();
+            }
+
+            _createRenderTexture(width, height, devicePixelRatio);
+            return true;
+        }
+        
+        [DllImport(NativeBindings.dllName)]
+        static extern IntPtr UIWidgetsPanel_constructor(IntPtr handle,
+            UIWidgetsPanel_EntrypointCallback entrypointCallback);
+
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onEnable(IntPtr ptr,
+            IntPtr nativeTexturePtr, int width, int height, float dpi, string streamingAssetsPath,
+            string font_settings);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onRenderTexture(
+            IntPtr ptr, IntPtr nativeTexturePtr, int width, int height, float dpi);
+
+        [MenuItem("UIWidgets/NewWindow")]
+        public static void OnItem() {
+            EditorWindow.CreateWindow<UIWidgetsEditorPanel>();
+        }
+
+        public float cur_devicePixelRatioOverride => _currentDevicePixelRatio;
+    }
+    
+    
+
+#endif
+
+}*/

com.unity.uiwidgets/Runtime/engine2/UIWidgetsPanelWrapper.cs

+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using AOT;
+using Unity.UIWidgets.engine2;
+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.gestures;
+using Unity.UIWidgets.services;
+using Unity.UIWidgets.ui;
+using UnityEngine;
+
+namespace Unity.UIWidgets.editor2 {
+
+    public delegate void UIWidgetsMainFunction();
+    
+    public class UIWidgetsPanelWrapper {
+        
+        RenderTexture _renderTexture;
+        
+        void _createRenderTexture(int width, int height, float devicePixelRatio) {
+            D.assert(_renderTexture == null);
+
+            var desc = new RenderTextureDescriptor(
+                width, height, RenderTextureFormat.ARGB32, 0) {
+                useMipMap = false,
+                autoGenerateMips = false,
+            };
+
+            _renderTexture = new RenderTexture(desc) {hideFlags = HideFlags.HideAndDontSave};
+            _renderTexture.Create();
+
+            _width = width;
+            _height = height;
+            _devicePixelRatio = devicePixelRatio;
+        }
+
+        void _destroyRenderTexture() {
+            D.assert(_renderTexture != null);
+            ObjectUtils.SafeDestroy(_renderTexture);
+            _renderTexture = null;
+        }
+
+        void _enableUIWidgetsPanel(string font_settings) {
+            UIWidgetsPanel_onEnable(_ptr, _renderTexture.GetNativeTexturePtr(),
+                _width, _height, _devicePixelRatio, Application.streamingAssetsPath, font_settings);
+        }
+
+        void _resizeUIWidgetsPanel() {
+            UIWidgetsPanel_onRenderTexture(_ptr,
+                _renderTexture.GetNativeTexturePtr(),
+                _width, _height, _devicePixelRatio);
+        }
+
+        void _disableUIWidgetsPanel() {
+            _renderTexture = null;
+        }
+        
+        public static UIWidgetsPanelWrapper current {
+            get { return Window.instance._panel; }
+        }
+
+        public IUIWidgetsWindow window => _host;
+
+        public Isolate isolate { get; private set; }
+
+        IntPtr _ptr;
+        GCHandle _handle;
+
+        int _width;
+        int _height;
+        float _devicePixelRatio;
+
+        public RenderTexture renderTexture => _renderTexture;
+        
+        public float devicePixelRatio => _devicePixelRatio;
+
+        IUIWidgetsWindow _host;
+
+        public void Initiate(IUIWidgetsWindow host, int width, int height, float dpr, Dictionary<string, object> settings) {
+            D.assert(_renderTexture == null);
+            _recreateRenderTexture(width, height, dpr);
+
+            _handle = GCHandle.Alloc(this);
+            _ptr = UIWidgetsPanel_constructor((IntPtr) _handle, UIWidgetsPanel_entrypoint);
+
+            _host = host;
+
+            _enableUIWidgetsPanel(JSONMessageCodec.instance.toJson(settings));
+            
+            Input_OnEnable();
+            NativeConsole.OnEnable();
+        }
+        
+        public void _entryPoint() {
+            try {
+                isolate = Isolate.current;
+                Window.instance._panel = this;
+
+                _host.mainEntry();
+            }
+            catch (Exception ex) {
+                Debug.LogException(new Exception("exception in main", ex));
+            }
+        }
+        
+        public void OnRectTransformDimensionsChange(int width, int height, float dpr) {
+            if (_ptr != IntPtr.Zero && _renderTexture) {
+                if (_recreateRenderTexture(width, height, dpr)) {
+                    _resizeUIWidgetsPanel();
+                }
+            }
+        }
+        
+        public void Destroy() {
+            Input_OnDisable();
+
+            UIWidgetsPanel_onDisable(_ptr);
+            UIWidgetsPanel_dispose(_ptr);
+            _ptr = IntPtr.Zero;
+
+            _handle.Free();
+            _handle = default;
+
+            _disableUIWidgetsPanel();
+
+            D.assert(!isolate.isValid);
+        }
+        
+        bool _recreateRenderTexture(int width, int height, float devicePixelRatio) {
+            if (_renderTexture != null && _width == width && _height == height &&
+                _devicePixelRatio == devicePixelRatio) {
+                return false;
+            }
+
+            if (_renderTexture) {
+                _destroyRenderTexture();
+            }
+
+            _createRenderTexture(width, height, devicePixelRatio);
+            return true;
+        }
+        
+        public int registerTexture(Texture texture) {
+            return UIWidgetsPanel_registerTexture(_ptr, texture.GetNativeTexturePtr());
+        }
+
+        public void unregisterTexture(int textureId) {
+            UIWidgetsPanel_unregisterTexture(_ptr, textureId);
+        }
+
+        public void markNewFrameAvailable(int textureId) {
+            UIWidgetsPanel_markNewFrameAvailable(_ptr, textureId);
+        }
+        
+        void Input_OnEnable() {
+        }
+
+        void Input_OnDisable() {
+        }
+        
+        public void OnMouseMove(Vector2? pos) {
+            if (pos == null) {
+                return;
+            }
+            UIWidgetsPanel_onMouseMove(_ptr, pos.Value.x, pos.Value.y);
+        }
+
+        public void OnPointerDown(Vector2? pos, int pointerId) {
+            if (pos == null) {
+                return;
+            }
+
+            // mouse event
+            if (pointerId < 0) {
+                UIWidgetsPanel_onMouseDown(_ptr, pos.Value.x, pos.Value.y, pointerId);
+            }
+        }
+
+        public void OnPointerUp(Vector2? pos, int pointerId) {
+            if (pos == null) {
+                return;
+            }
+
+            // mouse event
+            if (pointerId < 0) {
+                UIWidgetsPanel_onMouseUp(_ptr, pos.Value.x, pos.Value.y, pointerId);
+            }
+        }
+
+        public void OnDrag(Vector2? pos, int pointerId) {
+            if (pos == null) {
+                return;
+            }
+
+            // mouse event
+            if (pointerId < 0) {
+                UIWidgetsPanel_onMouseMove(_ptr, pos.Value.x, pos.Value.y);
+            }
+        }
+
+        public void OnPointerLeave() {
+            UIWidgetsPanel_onMouseLeave(_ptr);
+        }
+
+        public void OnKeyDown(Event e) {
+            UIWidgetsPanel_onKey(_ptr, e.keyCode, e.type == EventType.KeyDown);
+            if (e.character != 0 || e.keyCode == KeyCode.Backspace) {
+                PointerEventConverter.KeyEvent.Enqueue(new Event(e));
+                // TODO: add on char
+                // UIWidgetsPanel_onChar(_ptr, e.character);
+            }
+        }
+        
+        
+        delegate void UIWidgetsPanel_EntrypointCallback(IntPtr handle);
+
+        [MonoPInvokeCallback(typeof(UIWidgetsPanel_EntrypointCallback))]
+        static void UIWidgetsPanel_entrypoint(IntPtr handle) {
+            GCHandle gcHandle = (GCHandle) handle;
+            UIWidgetsPanelWrapper panel = (UIWidgetsPanelWrapper) gcHandle.Target;
+            panel._entryPoint();
+        }
+
+        [DllImport(NativeBindings.dllName)]
+        static extern IntPtr UIWidgetsPanel_constructor(IntPtr handle,
+            UIWidgetsPanel_EntrypointCallback entrypointCallback);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_dispose(IntPtr ptr);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onDisable(IntPtr ptr);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern int UIWidgetsPanel_registerTexture(IntPtr ptr, IntPtr nativeTexturePtr);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_unregisterTexture(IntPtr ptr, int textureId);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_markNewFrameAvailable(IntPtr ptr, int textureId);
+        
+        
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onEnable(IntPtr ptr,
+            IntPtr nativeTexturePtr, int width, int height, float dpi, string streamingAssetsPath,
+            string font_settings);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onRenderTexture(
+            IntPtr ptr, IntPtr nativeTexturePtr, int width, int height, float dpi);
+        
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onChar(IntPtr ptr, char c);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onKey(IntPtr ptr, KeyCode keyCode, bool isKeyDown);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onMouseDown(IntPtr ptr, float x, float y, int button);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onMouseUp(IntPtr ptr, float x, float y, int button);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onMouseMove(IntPtr ptr, float x, float y);
+
+        [DllImport(NativeBindings.dllName)]
+        static extern void UIWidgetsPanel_onMouseLeave(IntPtr ptr);
+    }
+    
+}