Merge pull request #272 from Unity-Technologies/siyaoH/1.17/combineTouch

cache RawTouch and dispatch during Input_Update

Samples/UIWidgetsSamples_2019_4/Assets/Scene/ImageTest.unity

   m_OnCullStateChanged:
     m_PersistentCalls:
       m_Calls: []
-  m_Texture: {fileID: 0}
+  m_Texture: {fileID: 1525330782}
   m_UVRect:
     serializedVersion: 2
     x: 0
-  fonts: []
-  devicePixelRatioOverride: 0
+  fonts: []
 --- !u!222 &847097471
 CanvasRenderer:
   m_ObjectHideFlags: 0
   m_GameObject: {fileID: 847097468}
   m_CullTransparentMesh: 0
+--- !u!28 &1525330782
+Texture2D:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: 
+  m_ImageContentsHash:
+    serializedVersion: 2
+    Hash: 00000000000000000000000000000000
+  m_ForcedFallbackFormat: 4
+  m_DownscaleFallback: 0
+  serializedVersion: 2
+  m_Width: 0
+  m_Height: 0
+  m_CompleteImageSize: 0
+  m_TextureFormat: 0
+  m_MipCount: 1
+  m_IsReadable: 1
+  m_IgnoreMasterTextureLimit: 0
+  m_IsPreProcessed: 0
+  m_StreamingMipmaps: 0
+  m_StreamingMipmapsPriority: 0
+  m_AlphaIsTransparency: 0
+  m_ImageCount: 0
+  m_TextureDimension: 2
+  m_TextureSettings:
+    serializedVersion: 2
+    m_FilterMode: 1
+    m_Aniso: 1
+    m_MipBias: 0
+    m_WrapU: 0
+    m_WrapV: 0
+    m_WrapW: 0
+  m_LightmapFormat: 0
+  m_ColorSpace: 0
+  image data: 0
+  _typelessdata: 
+  m_StreamData:
+    offset: 0
+    size: 0
+    path: 
 --- !u!1 &1548023132
 GameObject:
   m_ObjectHideFlags: 0

engine/third_party/Unity/IUnityUIWidgets.h

 namespace UnityUIWidgets {
 typedef void (*VoidCallback)();
 typedef void (*VoidCallbackLong)(long);
+typedef void (*VoidCallbackDouble)(double);
-  virtual void SetVSyncCallback(VoidCallback callback) = 0;
+  virtual void SetVSyncCallback(VoidCallbackDouble callback) = 0;
   virtual void SetWaitCallback(VoidCallbackLong callback) = 0;
   virtual void SetWakeUpCallback(VoidCallback callback) = 0;
   virtual void IssuePluginEventAndData(UnityRenderingEventAndData callback,

engine/src/shell/platform/unity/android/uiwidgets_system.h

     GetInstancePtr()->Wait(std::chrono::nanoseconds(max_duration));
   }
 
-  UIWIDGETS_CALLBACK(void) _VSync() { GetInstancePtr()->VSync(); }
+  UIWIDGETS_CALLBACK(void) _VSync(double frame_duration) { GetInstancePtr()->VSync(frame_duration); }
 
   UIWIDGETS_CALLBACK(void) _WakeUp() { GetInstancePtr()->WakeUp(); }
 
 
   void Update();
   void Wait(std::chrono::nanoseconds max_duration);
-  void VSync();
+  void VSync(double frame_duration);
   void WakeUp();
   void GfxWorkerCallback(int eventId, void* data);
 

engine/src/shell/platform/unity/android/uiwidgets_system.cc

 }
 
 void UIWidgetsSystem::Wait(std::chrono::nanoseconds max_duration) {
-  Update();
-
-  std::chrono::nanoseconds wait_duration =
-      std::max(std::chrono::nanoseconds(0),
-               next_uiwidgets_event_time_ - TimePoint::clock::now());
-
-  wait_duration = std::min(max_duration, wait_duration);
-
-  //TODO: find a proper api similar to MsgWaitForMultipleObjects on Windows
-  //      which will notify os to wait for the given period of time
+  //do nothing
 }
 
 void UIWidgetsSystem::Update() {
   next_uiwidgets_event_time_ = next_event_time;
 }
 
-void UIWidgetsSystem::VSync() {
+void UIWidgetsSystem::VSync(double frame_duration) {
+  //use default frame_duration if undefined in Unity engine
+  if (frame_duration <= 0)
+  {
+    frame_duration = 1.0 / 60;
+  }
+
-    uiwidgets_panel->ProcessVSync();
+    uiwidgets_panel->ProcessVSync(frame_duration);
   }
 }
 

engine/src/shell/platform/unity/android/uiwidgets_panel.cc

     ProcessMessages();
 
     // drain pending vsync batons
-    ProcessVSync();
+    ProcessVSync(0);
 
     process_events_ = false;
 
     return std::chrono::nanoseconds(task_runner_->ProcessTasks().count());
   }
 
-  void UIWidgetsPanel::ProcessVSync()
+  void UIWidgetsPanel::ProcessVSync(double frame_duration)
   {
     std::vector<intptr_t> batons;
     vsync_batons_.swap(batons);
       reinterpret_cast<EmbedderEngine *>(engine_)->OnVsyncEvent(
           baton, fml::TimePoint::Now(),
           fml::TimePoint::Now() +
-              fml::TimeDelta::FromNanoseconds(1000000000 / 60));
+              fml::TimeDelta::FromNanoseconds(1000000000 * frame_duration));
     }
   }
 

engine/src/shell/platform/unity/android/uiwidgets_panel.h

 
   std::chrono::nanoseconds ProcessMessages();
 
-  void ProcessVSync();
+  void ProcessVSync(double frame_duration);
 
   void VSyncCallback(intptr_t baton);
   

engine/src/shell/platform/unity/darwin/ios/uiwidgets_system.h

     GetInstancePtr()->Wait(std::chrono::nanoseconds(max_duration));
   }
 
-  UIWIDGETS_CALLBACK(void) _VSync() { GetInstancePtr()->VSync(); }
+  UIWIDGETS_CALLBACK(void) _VSync(double frame_duration) { GetInstancePtr()->VSync(frame_duration); }
 
   UIWIDGETS_CALLBACK(void) _WakeUp() { GetInstancePtr()->WakeUp(); }
 
 
   void Update();
   void Wait(std::chrono::nanoseconds max_duration);
-  void VSync();
+  void VSync(double frame_duration);
   void WakeUp();
   void GfxWorkerCallback(int eventId, void* data);
 

engine/src/shell/platform/unity/darwin/ios/uiwidgets_system.mm

 }
 
 void UIWidgetsSystem::Wait(std::chrono::nanoseconds max_duration) {
-  Update();
-
-  std::chrono::nanoseconds wait_duration =
-      std::max(std::chrono::nanoseconds(0),
-               next_uiwidgets_event_time_ - TimePoint::clock::now());
-
-  wait_duration = std::min(max_duration, wait_duration);
-
-  //TODO: find a proper api similar to MsgWaitForMultipleObjects on Windows
-  //      which will notify os to wait for the given period of time
+  //do nothing
 }
 
 void UIWidgetsSystem::Update() {
   next_uiwidgets_event_time_ = next_event_time;
 }
 
-void UIWidgetsSystem::VSync() {
+void UIWidgetsSystem::VSync(double frame_duration) {
+  //use default frame_duration if undefined in Unity engine
+  if (frame_duration <= 0)
+  {
+    frame_duration = 1.0 / 60;
+  }
+  
-    uiwidgets_panel->ProcessVSync();
+    uiwidgets_panel->ProcessVSync(frame_duration);
   }
 }
 

engine/src/shell/platform/unity/darwin/ios/uiwidgets_panel.h

 
   std::chrono::nanoseconds ProcessMessages();
 
-  void ProcessVSync();
+  void ProcessVSync(double frame_duration);
 
   void VSyncCallback(intptr_t baton);
 

engine/src/shell/platform/unity/darwin/ios/uiwidgets_panel.mm

   ProcessMessages();
 
   // drain pending vsync batons
-  ProcessVSync();
+  ProcessVSync(0);
 
   process_events_ = false;
 
   return std::chrono::nanoseconds(task_runner_->ProcessTasks().count());
 }
 
-void UIWidgetsPanel::ProcessVSync() {
+void UIWidgetsPanel::ProcessVSync(double frame_duration) {
   std::vector<intptr_t> batons;
   vsync_batons_.swap(batons);
 
         fml::TimePoint::Now() +
-            fml::TimeDelta::FromNanoseconds(1000000000 / 60));
+            fml::TimeDelta::FromNanoseconds(1000000000 * frame_duration));
   }
 }
 
   panel->ProcessMessages();
 
   //_ProcessVSync
-  panel->ProcessVSync();
+  panel->ProcessVSync(0);
 
   //_Wait
   panel->ProcessMessages();

engine/src/shell/platform/unity/darwin/macos/uiwidgets_system.h

     GetInstancePtr()->Wait(std::chrono::nanoseconds(max_duration));
   }
 
-  UIWIDGETS_CALLBACK(void) _VSync() { GetInstancePtr()->VSync(); }
+  UIWIDGETS_CALLBACK(void) _VSync(double frame_duration) { GetInstancePtr()->VSync(frame_duration); }
 
   UIWIDGETS_CALLBACK(void) _WakeUp() { GetInstancePtr()->WakeUp(); }
 
 
   void Update();
   void Wait(std::chrono::nanoseconds max_duration);
-  void VSync();
+  void VSync(double frame_duration);
   void WakeUp();
   void GfxWorkerCallback(int eventId, void* data);
 

engine/src/shell/platform/unity/darwin/macos/uiwidgets_system.mm

 }
 
 void UIWidgetsSystem::Wait(std::chrono::nanoseconds max_duration) {
-  Update();
-
-  std::chrono::nanoseconds wait_duration =
-      std::max(std::chrono::nanoseconds(0),
-               next_uiwidgets_event_time_ - TimePoint::clock::now());
-
-  wait_duration = std::min(max_duration, wait_duration);
-
-  //TODO: find a proper api similar to MsgWaitForMultipleObjects on Windows
-  //      which will notify os to wait for the given period of time
+  //do nothing
 }
 
 void UIWidgetsSystem::Update() {
   next_uiwidgets_event_time_ = next_event_time;
 }
 
-void UIWidgetsSystem::VSync() {
+void UIWidgetsSystem::VSync(double frame_duration) {
+  //use default frame_duration if undefined in Unity engine
+  if (frame_duration <= 0)
+  {
+    frame_duration = 1.0 / 60;
+  }
+  
-    uiwidgets_panel->ProcessVSync();
+    uiwidgets_panel->ProcessVSync(frame_duration);
   }
 }
 

engine/src/shell/platform/unity/darwin/macos/uiwidgets_panel.h

 
   std::chrono::nanoseconds ProcessMessages();
 
-  void ProcessVSync();
+  void ProcessVSync(double frame_duration);
 
   void VSyncCallback(intptr_t baton);
 

engine/src/shell/platform/unity/darwin/macos/uiwidgets_panel.mm

   ProcessMessages();
 
   // drain pending vsync batons
-  ProcessVSync();
+  ProcessVSync(0);
 
   process_events_ = false;
 
   return std::chrono::nanoseconds(task_runner_->ProcessTasks().count());
 }
 
-void UIWidgetsPanel::ProcessVSync() {
+void UIWidgetsPanel::ProcessVSync(double frame_duration) {
   std::vector<intptr_t> batons;
   vsync_batons_.swap(batons);
 
         fml::TimePoint::Now() +
-            fml::TimeDelta::FromNanoseconds(1000000000 / 60));
+            fml::TimeDelta::FromNanoseconds(1000000000 * frame_duration));
   }
 }
 
   panel->ProcessMessages();
 
   //_ProcessVSync
-  panel->ProcessVSync();
+  panel->ProcessVSync(0);
 
   //_Wait
   panel->ProcessMessages();

engine/src/shell/platform/unity/windows/uiwidgets_system.cc

 }
 
 void UIWidgetsSystem::Wait(std::chrono::nanoseconds max_duration) {
-  Update();
-	
-  std::chrono::nanoseconds wait_duration =
-      std::max(std::chrono::nanoseconds(0),
-               next_uiwidgets_event_time_ - TimePoint::clock::now());
-
-  wait_duration = std::min(max_duration, wait_duration);
-  wait_duration = std::max(std::chrono::nanoseconds(0), wait_duration);
-
-  ::MsgWaitForMultipleObjects(0, nullptr, FALSE,
-                              static_cast<DWORD>(wait_duration.count() / 1000000),
-                              QS_ALLINPUT);
+  //do nothing
 }
 
 void UIWidgetsSystem::Update() {
   next_uiwidgets_event_time_ = next_event_time;
 }
 
-void UIWidgetsSystem::VSync() {
+void UIWidgetsSystem::VSync(double frame_duration) {
+  //use default frame_duration if undefined in Unity engine
+  if (frame_duration <= 0)
+  {
+    frame_duration = 1.0 / 60;
+  }
+
-    uiwidgets_panel->ProcessVSync();
+    uiwidgets_panel->ProcessVSync(frame_duration);
   }
 }
 

engine/src/shell/platform/unity/windows/uiwidgets_system.h

     GetInstancePtr()->Wait(std::chrono::nanoseconds(max_duration));
   }
 
-  UIWIDGETS_CALLBACK(void) _VSync() { GetInstancePtr()->VSync(); }
+  UIWIDGETS_CALLBACK(void) _VSync(double frame_duration) { GetInstancePtr()->VSync(frame_duration); }
 
   UIWIDGETS_CALLBACK(void) _WakeUp() { GetInstancePtr()->WakeUp(); }
 
 
   void Update();
   void Wait(std::chrono::nanoseconds max_duration);
-  void VSync();
+  void VSync(double frame_duration);
   void WakeUp();
   void GfxWorkerCallback(int eventId, void* data);
 

engine/src/shell/platform/unity/windows/uiwidgets_panel.cc

   ProcessMessages();
 
   // drain pending vsync batons
-  ProcessVSync();
+  ProcessVSync(0);
 
   process_events_ = false;
 
   return std::chrono::nanoseconds(task_runner_->ProcessTasks().count());
 }
 
-void UIWidgetsPanel::ProcessVSync() {
+void UIWidgetsPanel::ProcessVSync(double frame_duration) {
   std::vector<intptr_t> batons;
   vsync_batons_.swap(batons);
 
         fml::TimePoint::Now() +
-            fml::TimeDelta::FromNanoseconds(1000000000 / 60));
+            fml::TimeDelta::FromNanoseconds(1000000000 * frame_duration));
   }
 }
 
   panel->ProcessMessages();
 
   //_ProcessVSync
-  panel->ProcessVSync();
+  panel->ProcessVSync(0);
 
   //_Wait
   panel->ProcessMessages();

engine/src/shell/platform/unity/windows/uiwidgets_panel.h

 
   std::chrono::nanoseconds ProcessMessages();
 
-  void ProcessVSync();
+  void ProcessVSync(double frame_duration);
 
   void VSyncCallback(intptr_t baton);
   

com.unity.uiwidgets/package.json

 	"unity": "2019.4",
 	"description": "UIWidgets allows you to build beautiful cross-platform apps through Unity",
 	"dependencies": {
+		"com.unity.modules.uiwidgets": "1.0.0"
 	}
 }

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

 
         UIWidgetsWindowType getWindowType();
     }
+
     public class Configurations {
         private Dictionary<string, TextFont> _textFonts = new Dictionary<string, TextFont>();
 
+
+
         public object fontsToObject() {
             Dictionary<string, TextFont> settings = _textFonts;
             if (settings == null || settings.Count == 0) {
 #else
                         if (!File.Exists(assetAbsolutePath)) {
 #endif
-                            Debug.LogError($"The font asset (family: \"{setting.Key}\", path: \"{assetPath}\") is not found");
+                            Debug.LogError(
+                                $"The font asset (family: \"{setting.Key}\", path: \"{assetPath}\") is not found");
+
                         fontDic.Add("asset", value: setting.Value.fonts[j].asset);
                     }
 
             CollectGarbageOnDemand();
 #endif
 
+
+
 #if !UNITY_EDITOR
         // 8 MB
         const long kCollectAfterAllocating = 8 * 1024 * 1024;
             lastFrameMemory = mem;
         }
 #endif
+
         #endregion
 
         IEnumerator ReEnableUIWidgetsNextFrame() {
                     AddFont(family: font.family, font: font);
                 }
             }
+
             _wrapper.Initiate(this, width: _currentWidth, height: _currentHeight, dpr: _currentDevicePixelRatio,
                 _configurations: _configurations);
             _configurations.Clear();
         }
     }
 
-    enum UIWidgetsInputMode 
-    {
+    enum UIWidgetsInputMode {
         Mouse,
         Touch
     }
         }
 
         void Input_OnEnable() {
+#if !UNITY_EDITOR && (UNITY_IOS || UNITY_ANDROID)       
+            UnityEngine.UIWidgets.InitUIWidgets.Init();
+            UnityEngine.UIWidgets.RawTouchEvent += CacheRawTouch;
+#endif
+#if !UNITY_EDITOR && (UNITY_IOS || UNITY_ANDROID)       
+        enum TouchPhase {
+            Began = 0,
+            Moved = 1,
+            Stationary = 2,
+            Ended = 3,
+            Canceled = 4
+        }
+
+        void CacheRawTouch(UnityEngine.UIWidgets.RawTouchEventParam param) {
+            rawTouchEventParams.Enqueue(param);
+        }
+
+        void ProcessRawTouch(UnityEngine.UIWidgets.RawTouchEventParam param) {
+            var position = _getPointerPosition(new Vector2(param.x, param.y));
+            var pointerId = -1 - param.pointerId;
+            switch ((TouchPhase)param.phase) {
+                case TouchPhase.Began:
+                    _wrapper.OnPointerDown(position, pointerId);
+                    break;
+                case TouchPhase.Moved:
+                    _wrapper.OnDrag(position, pointerId);
+                    break;
+
+                case TouchPhase.Ended:
+                    _wrapper.OnPointerUp(position, pointerId);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        Queue<UnityEngine.UIWidgets.RawTouchEventParam> rawTouchEventParams =
+            new Queue<UnityEngine.UIWidgets.RawTouchEventParam>(); 
+#endif
+
+#if !UNITY_EDITOR && (UNITY_IOS || UNITY_ANDROID)
+            UnityEngine.UIWidgets.RawTouchEvent -= CacheRawTouch;
+#endif
+#if !UNITY_EDITOR && (UNITY_IOS || UNITY_ANDROID)
+            while (rawTouchEventParams.isNotEmpty()) {
+                ProcessRawTouch(rawTouchEventParams.Dequeue());
+            }
+#endif
             //we only process hover events for desktop applications
             if (_inputMode == UIWidgetsInputMode.Mouse) {
                 if (_isEntered) {
             if (_inputMode != UIWidgetsInputMode.Mouse) {
                 return;
             }
+
             var pos = _getPointerPosition(Input.mousePosition);
             _wrapper.OnMouseMove(pos);
         }
                 return;
             }
+
             var pos = _getPointerPosition(Input.mousePosition);
             _wrapper.OnMouseScroll(Input.mouseScrollDelta, pos);
         }
                 return;
             }
+
             D.assert(eventData.pointerId < 0);
             _isEntered = true;
             _lastMousePosition = Input.mousePosition;
             if (_inputMode != UIWidgetsInputMode.Mouse) {
                 return;
             }
+
-
+        
+#if UNITY_EDITOR || (!UNITY_IOS && !UNITY_ANDROID)
         public void OnPointerDown(PointerEventData eventData) {
             _convertPointerData(eventData, out var pos, out var pointerId);
             _wrapper.OnPointerDown(pos, pointerId);
             _convertPointerData(eventData, out var pos, out var pointerId);
             _wrapper.OnDrag(pos, pointerId);
         }
+#else
+        public void OnPointerDown(PointerEventData eventData) {
+        }
+
+        public void OnPointerUp(PointerEventData eventData) {
+        }
+
+        public void OnDrag(PointerEventData eventData) {
+        }
+#endif
     }
 }

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/MobileTouchSample.cs.meta

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

Samples/UIWidgetsSamples_2019_4/Assets/WidgetsSample/MobileTouchSample.cs.meta

-fileFormatVersion: 2
-guid: 925efb3da7848c24a84e0306cdd8de3c
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: