Fix native input usage for uwp

Apps/PackageTest/0.63.1/package.json

@@ -10,7 +10,7 @@
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx"
   },
   "dependencies": {
-    "@babylonjs/core": "^5.0.0-alpha.6",
+    "@babylonjs/core": "^5.0.0-alpha.9",
     "@babylonjs/react-native": "file:../../../Package/Assembled/babylonjs-react-native-0.0.1.tgz",
     "react": "16.13.1",
     "react-native": "0.63.1",

Apps/PackageTest/0.64.0-rc.0/package.json

@@ -12,7 +12,7 @@
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx"
   },
   "dependencies": {
-    "@babylonjs/core": "^5.0.0-alpha.6",
+    "@babylonjs/core": "^5.0.0-alpha.9",
     "@babylonjs/react-native": "file:../../../Package/Assembled/babylonjs-react-native-0.0.1.tgz",
     "react": "^17.0.1",
     "react-native": "^0.64.0-rc.0",

Apps/Playground/App.tsx

@@ -9,7 +9,7 @@ import React, { useState, FunctionComponent, useEffect, useCallback } from 'reac
 import { SafeAreaView, StatusBar, Button, View, Text, ViewProps, Image } from 'react-native';
 
 import { EngineView, useEngine, EngineViewCallbacks } from '@babylonjs/react-native';
-import { Scene, Vector3, ArcRotateCamera, Camera, WebXRSessionManager, SceneLoader, TransformNode, DeviceSourceManager, DeviceType, DeviceSource, PointerInput, WebXRTrackingState } from '@babylonjs/core';
+import { Scene, Vector3, ArcRotateCamera, Camera, WebXRSessionManager, SceneLoader, TransformNode, DeviceSourceManager, DeviceType, DeviceSource, PointerInput, WebXRTrackingState, Nullable } from '@babylonjs/core';
 import '@babylonjs/loaders';
 import Slider from '@react-native-community/slider';
 
@@ -40,18 +40,28 @@ const EngineScreen: FunctionComponent<ViewProps> = (props: ViewProps) => {
       setRootNode(rootNode);
 
       const deviceSourceManager = new DeviceSourceManager(engine);
+      const handlePointerInput = (inputIndex: PointerInput, previousState: Nullable<number>, currentState: Nullable<number>) => {
+        if (inputIndex === PointerInput.Horizontal &&
+          currentState && previousState) {
+          rootNode.rotate(Vector3.Down(), (currentState - previousState) * 0.005);
+        };
+      };
+
       deviceSourceManager.onDeviceConnectedObservable.add(device => {
         if (device.deviceType === DeviceType.Touch) {
           const touch: DeviceSource<DeviceType.Touch> = deviceSourceManager.getDeviceSource(device.deviceType, device.deviceSlot)!;
           touch.onInputChangedObservable.add(touchEvent => {
-            if (touchEvent.inputIndex === PointerInput.Horizontal) {
-              if (touchEvent.currentState && touchEvent.previousState) {
-                rootNode.rotate(Vector3.Down(), (touchEvent.currentState - touchEvent.previousState) * 0.005);
-              }
+            handlePointerInput(touchEvent.inputIndex, touchEvent.previousState, touchEvent.currentState);
+          });
+        } else if (device.deviceType === DeviceType.Mouse) {
+          const mouse: DeviceSource<DeviceType.Mouse> = deviceSourceManager.getDeviceSource(device.deviceType, device.deviceSlot)!;
+          mouse.onInputChangedObservable.add(mouseEvent => {
+            if (mouse.getInput(PointerInput.LeftClick)) {
+              handlePointerInput(mouseEvent.inputIndex, mouseEvent.previousState, mouseEvent.currentState);
             }
-          })
+          });
         }
-      })
+      });
 
       const transformContainer = new TransformNode("Transform Container", scene);
       transformContainer.parent = rootNode;

Apps/Playground/package.json

@@ -12,8 +12,8 @@
     "lint": "eslint . --ext .js,.jsx,.ts,.tsx"
   },
   "dependencies": {
-    "@babylonjs/core": "^5.0.0-alpha.6",
-    "@babylonjs/loaders": "^5.0.0-alpha.6",
+    "@babylonjs/core": "^5.0.0-alpha.9",
+    "@babylonjs/loaders": "^5.0.0-alpha.9",
     "@babylonjs/react-native": "file:../../Modules/@babylonjs/react-native",
     "@react-native-community/slider": "4.0.0-rc.2",
     "logkitty": "^0.7.1",

Modules/@babylonjs/react-native/android/src/main/cpp/BabylonNativeInterop.cpp

@@ -77,12 +77,12 @@ extern "C" JNIEXPORT void JNICALL Java_com_babylonreactnative_BabylonNativeInter
     Babylon::UpdateView(windowPtr, width, height);
 }
 
-extern "C" JNIEXPORT void JNICALL Java_com_babylonreactnative_BabylonNativeInterop_00024BabylonNative_setPointerButtonState(JNIEnv* env, jclass obj, jint pointerId, jint buttonId, jboolean isDown, jint x, jint y)
+extern "C" JNIEXPORT void JNICALL Java_com_babylonreactnative_BabylonNativeInterop_00024BabylonNative_setTouchButtonState(JNIEnv* env, jclass obj, jint pointerId, jboolean isDown, jint x, jint y)
 {
-    Babylon::SetPointerButtonState(static_cast<uint32_t>(pointerId), static_cast<uint32_t>(buttonId), isDown, static_cast<uint32_t>(x), static_cast<uint32_t>(y));
+    Babylon::SetTouchButtonState(static_cast<uint32_t>(pointerId), isDown, static_cast<uint32_t>(x), static_cast<uint32_t>(y));
 }
 
-extern "C" JNIEXPORT void JNICALL Java_com_babylonreactnative_BabylonNativeInterop_00024BabylonNative_setPointerPosition(JNIEnv* env, jclass obj, jint pointerId, jint x, jint y)
+extern "C" JNIEXPORT void JNICALL Java_com_babylonreactnative_BabylonNativeInterop_00024BabylonNative_setTouchPosition(JNIEnv* env, jclass obj, jint pointerId, jint x, jint y)
 {
-    Babylon::SetPointerPosition(static_cast<uint32_t>(pointerId), static_cast<uint32_t>(x), static_cast<uint32_t>(y));
+    Babylon::SetTouchPosition(static_cast<uint32_t>(pointerId), static_cast<uint32_t>(x), static_cast<uint32_t>(y));
 }

Modules/@babylonjs/react-native/android/src/main/java/com/babylonreactnative/BabylonNativeInterop.java

@@ -24,8 +24,8 @@ private static class BabylonNative {
         public static native void pause();
         public static native void resume();
         public static native void updateView(Surface surface);
-        public static native void setPointerButtonState(int pointerId, int buttonId, boolean isDown, int x, int y);
-        public static native void setPointerPosition(int pointerId, int x, int y);
+        public static native void setTouchButtonState(int pointerId, boolean isDown, int x, int y);
+        public static native void setTouchPosition(int pointerId, int x, int y);
     }
 
     private static LifecycleEventListener lifeCycleEventListener;
@@ -98,13 +98,13 @@ public static void reportMotionEvent(MotionEvent motionEvent) {
             int pointerId = motionEvent.getPointerId(pointerIndex);
             int x = (int)motionEvent.getX(pointerIndex);
             int y = (int)motionEvent.getY(pointerIndex);
-            BabylonNative.setPointerButtonState(pointerId, 0, isPointerDown, x, y);
+            BabylonNative.setTouchButtonState(pointerId, isPointerDown, x, y);
         } else if (isPointerMove) {
             for (int pointerIndex = 0; pointerIndex < motionEvent.getPointerCount(); pointerIndex++) {
                 int pointerId = motionEvent.getPointerId(pointerIndex);
                 int x = (int)motionEvent.getX(pointerIndex);
                 int y = (int)motionEvent.getY(pointerIndex);
-                BabylonNative.setPointerPosition(pointerId, x, y);
+                BabylonNative.setTouchPosition(pointerId, x, y);
             }
         }
     }

Modules/@babylonjs/react-native/ios/BabylonNativeInterop.mm

@@ -79,21 +79,21 @@ + (void)reportTouchEvent:(MTKView*)mtkView touches:(NSSet<UITouch*>*)touches eve
                     } else {
                         [activeTouches replaceObjectAtIndex:pointerId withObject:touch];
                     }
-                    Babylon::SetPointerButtonState(static_cast<uint32_t>(pointerId), 0, true, x, y);
+                    Babylon::SetTouchButtonState(static_cast<uint32_t>(pointerId), true, x, y);
                     break;
                 }
 
                 case UITouchPhaseMoved: {
                     NSUInteger pointerId = [activeTouches indexOfObject:touch];
-                    Babylon::SetPointerPosition(static_cast<uint32_t>(pointerId), x, y);
+                    Babylon::SetTouchPosition(static_cast<uint32_t>(pointerId), x, y);
                     break;
                 }
 
                 case UITouchPhaseEnded:
                 case UITouchPhaseCancelled: {
                     NSUInteger pointerId = [activeTouches indexOfObject:touch];
                     [activeTouches replaceObjectAtIndex:pointerId withObject:[NSNull null]];
-                    Babylon::SetPointerButtonState(static_cast<uint32_t>(pointerId), 0, false, x, y);
+                    Babylon::SetTouchButtonState(static_cast<uint32_t>(pointerId), false, x, y);
                     break;
                 }
 

Modules/@babylonjs/react-native/package.json

@@ -28,7 +28,7 @@
     "semver": "^7.3.2"
   },
   "peerDependencies": {
-    "@babylonjs/core": "^5.0.0-alpha.6",
+    "@babylonjs/core": "^5.0.0-alpha.9",
     "react": "^16.13.1",
     "react-native": "^0.63.1",
     "react-native-permissions": "^2.1.4",

Modules/@babylonjs/react-native/shared/BabylonNative.cpp

@@ -12,13 +12,18 @@
 
 namespace Babylon
 {
+    using namespace Babylon::Plugins;
     using namespace facebook;
 
     namespace
     {
-        Dispatcher g_inlineDispatcher{[](const std::function<void()>& func) { func(); }};
+        Dispatcher g_inlineDispatcher{ [](const std::function<void()>& func) { func(); } };
     }
 
+    const uint32_t LEFT_MOUSE_BUTTON_ID{ NativeInput::LEFT_MOUSE_BUTTON_ID };
+    const uint32_t MIDDLE_MOUSE_BUTTON_ID{ NativeInput::MIDDLE_MOUSE_BUTTON_ID };
+    const uint32_t RIGHT_MOUSE_BUTTON_ID{ NativeInput::RIGHT_MOUSE_BUTTON_ID };
+
     class ReactNativeModule : public jsi::HostObject
     {
     public:
@@ -136,21 +141,38 @@ namespace Babylon
             });
         }
 
-        void SetPointerButtonState(uint32_t pointerId, uint32_t buttonId, bool isDown, uint32_t x, uint32_t y)
+        void SetMouseButtonState(uint32_t buttonId, bool isDown, uint32_t x, uint32_t y)
+        {
+            if (isDown)
+            {
+                m_nativeInput->MouseDown(buttonId, x, y);
+            }
+            else
+            {
+                m_nativeInput->MouseUp(buttonId, x, y);
+            }
+        }
+
+        void SetMousePosition(uint32_t x, uint32_t y)
+        {
+            m_nativeInput->MouseMove(x, y);
+        }
+
+        void SetTouchButtonState(uint32_t pointerId, bool isDown, uint32_t x, uint32_t y)
         {
             if (isDown)
             {
-                m_nativeInput->PointerDown(pointerId, buttonId, x, y);
+                m_nativeInput->TouchDown(pointerId, x, y);
             }
             else
             {
-                m_nativeInput->PointerUp(pointerId, buttonId, x, y);
+                m_nativeInput->TouchUp(pointerId, x, y);
             }
         }
 
-        void SetPointerPosition(uint32_t pointerId, uint32_t x, uint32_t y)
+        void SetTouchPosition(uint32_t pointerId, uint32_t x, uint32_t y)
         {
-            m_nativeInput->PointerMove(pointerId, x, y);
+            m_nativeInput->TouchMove(pointerId, x, y);
         }
 
         jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& prop) override
@@ -255,19 +277,35 @@ namespace Babylon
         }
     }
 
-    void SetPointerButtonState(uint32_t pointerId, uint32_t buttonId, bool isDown, uint32_t x, uint32_t y)
+    void SetMouseButtonState(uint32_t buttonId, bool isDown, uint32_t x, uint32_t y)
+    {
+        if (auto nativeModule{ g_nativeModule.lock() })
+        {
+            nativeModule->SetMouseButtonState(buttonId, isDown, x, y);
+        }
+    }
+
+    void SetMousePosition(uint32_t x, uint32_t y)
+    {
+        if (auto nativeModule{ g_nativeModule.lock() })
+        {
+            nativeModule->SetMousePosition(x, y);
+        }
+    }
+
+    void SetTouchButtonState(uint32_t pointerId, bool isDown, uint32_t x, uint32_t y)
     {
         if (auto nativeModule{ g_nativeModule.lock() })
         {
-            nativeModule->SetPointerButtonState(pointerId, buttonId, isDown, x, y);
+            nativeModule->SetTouchButtonState(pointerId, isDown, x, y);
         }
     }
 
-    void SetPointerPosition(uint32_t pointerId, uint32_t x, uint32_t y)
+    void SetTouchPosition(uint32_t pointerId, uint32_t x, uint32_t y)
     {
         if (auto nativeModule{ g_nativeModule.lock() })
         {
-            nativeModule->SetPointerPosition(pointerId, x, y);
+            nativeModule->SetTouchPosition(pointerId, x, y);
         }
     }
 }

Modules/@babylonjs/react-native/shared/BabylonNative.h

@@ -10,6 +10,12 @@ namespace Babylon
     void Deinitialize();
     void UpdateView(void* windowPtr, size_t width, size_t height, void* windowTypePtr = nullptr);
     void RenderView();
-    void SetPointerButtonState(uint32_t pointerId, uint32_t buttonId, bool isDown, uint32_t x, uint32_t y);
-    void SetPointerPosition(uint32_t pointerId, uint32_t x, uint32_t y);
+    void SetMouseButtonState(uint32_t buttonId, bool isDown, uint32_t x, uint32_t y);
+    void SetMousePosition(uint32_t x, uint32_t y);
+    void SetTouchButtonState(uint32_t pointerId, bool isDown, uint32_t x, uint32_t y);
+    void SetTouchPosition(uint32_t pointerId, uint32_t x, uint32_t y);
+
+    extern const uint32_t LEFT_MOUSE_BUTTON_ID;
+    extern const uint32_t MIDDLE_MOUSE_BUTTON_ID;
+    extern const uint32_t RIGHT_MOUSE_BUTTON_ID;
 }