Factor out shared parts of the playground (#1593)

Author: bghgary

Apps/Playground/Android/BabylonNative/CMakeLists.txt

@@ -10,12 +10,12 @@ get_filename_component(REPO_ROOT_DIR "${PLAYGROUND_DIR}/../.." ABSOLUTE)
 
 add_subdirectory(${REPO_ROOT_DIR} "${CMAKE_CURRENT_BINARY_DIR}/BabylonNative")
 
-
 add_library(BabylonNativeJNI SHARED
-    src/main/cpp/BabylonNativeJNI.cpp)
+    src/main/cpp/BabylonNativeJNI.cpp
+    ${PLAYGROUND_DIR}/Shared/AppContext.cpp)
 
 target_include_directories(BabylonNativeJNI
-    PRIVATE ${PLAYGROUND_DIR}/Shared)
+    PRIVATE ${PLAYGROUND_DIR})
 
 target_link_libraries(BabylonNativeJNI
     GLESv3
@@ -30,11 +30,14 @@ target_link_libraries(BabylonNativeJNI
     Console
     GraphicsDevice
     NativeCamera
+    NativeCapture
     NativeEncoding
     NativeEngine
     NativeInput
     NativeOptimizations
+    NativeTracing
     NativeXr
     ScriptLoader
-    XMLHttpRequest
-    Window)
+    TestUtils
+    Window
+    XMLHttpRequest)

Apps/Playground/Android/BabylonNative/src/main/cpp/BabylonNativeJNI.cpp

@@ -3,38 +3,18 @@
 #include <android/native_window_jni.h> // requires ndk r5 or newer
 #include <android/log.h>
 
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-#include <time.h>
 #include <optional>
+#include <string>
+#include <vector>
 
+#include <Shared/AppContext.h>
 #include <AndroidExtensions/Globals.h>
-#include <Babylon/AppRuntime.h>
-#include <Babylon/Graphics/Device.h>
-#include <Babylon/ScriptLoader.h>
-#include <Babylon/Plugins/NativeEncoding.h>
-#include <Babylon/Plugins/NativeEngine.h>
-#include <Babylon/Plugins/NativeInput.h>
 #include <Babylon/Plugins/NativeXr.h>
-#include <Babylon/Plugins/NativeCamera.h>
-#include <Babylon/Plugins/NativeOptimizations.h>
-#include <Babylon/Polyfills/Blob.h>
-#include <Babylon/Polyfills/Console.h>
-#include <Babylon/Polyfills/Window.h>
-#include <Babylon/Polyfills/XMLHttpRequest.h>
-#include <Babylon/Polyfills/Canvas.h>
-#include <Babylon/DebugTrace.h>
 
 namespace
 {
-    std::optional<Babylon::Graphics::Device> device{};
-    std::optional<Babylon::Graphics::DeviceUpdate> deviceUpdate{};
-    std::optional<Babylon::AppRuntime> runtime{};
+    std::optional<AppContext> appContext{};
     std::optional<Babylon::Plugins::NativeXr> nativeXr{};
-    Babylon::Plugins::NativeInput* nativeInput{};
-    std::optional<Babylon::Polyfills::Canvas> nativeCanvas{};
-    std::optional<Babylon::ScriptLoader> scriptLoader{};
     bool isXrActive{};
 }
 
@@ -48,112 +28,52 @@ extern "C"
     JNIEXPORT void JNICALL
     Java_com_library_babylonnative_Wrapper_finishEngine(JNIEnv* env, jclass clazz)
     {
-        if (device)
-        {
-            deviceUpdate->Finish();
-            device->FinishRenderingCurrentFrame();
-        }
-
         isXrActive = false;
 
-        scriptLoader.reset();
-
-        nativeInput = {};
         nativeXr.reset();
-        scriptLoader.reset();
-        runtime.reset();
-        device.reset();
+        appContext.reset();
     }
 
     JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_surfaceCreated(JNIEnv* env, jclass clazz, jobject surface, jobject context)
+    Java_com_library_babylonnative_Wrapper_surfaceCreated(JNIEnv* env, jclass clazz, jobject surface, jobject jniContext)
     {
-        if (!runtime)
+        if (!appContext)
         {
             JavaVM* javaVM{};
             if (env->GetJavaVM(&javaVM) != JNI_OK)
             {
                 throw std::runtime_error("Failed to get Java VM");
             }
 
-            android::global::Initialize(javaVM, context);
-
-            Babylon::DebugTrace::EnableDebugTrace(true);
-            Babylon::DebugTrace::SetTraceOutput([](const char* trace) { printf("%s\n", trace); fflush(stdout); });
+            android::global::Initialize(javaVM, jniContext);
 
             ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
             int32_t width  = ANativeWindow_getWidth(window);
             int32_t height = ANativeWindow_getHeight(window);
 
-            Babylon::Graphics::Configuration graphicsConfig{};
-            graphicsConfig.Window = window;
-            graphicsConfig.Width = static_cast<size_t>(width);
-            graphicsConfig.Height = static_cast<size_t>(height);
-            device.emplace(graphicsConfig);
-            deviceUpdate.emplace(device->GetUpdate("update"));
-            device->StartRenderingCurrentFrame();
-            deviceUpdate->Start();
-
-            runtime.emplace();
-
-            runtime->Dispatch([](Napi::Env env)
-            {
-                device->AddToJavaScript(env);
-
-                Babylon::Polyfills::Blob::Initialize(env);
-
-                Babylon::Polyfills::Console::Initialize(env, [](const char* message, Babylon::Polyfills::Console::LogLevel level)
-                {
-                    switch (level)
-                    {
-                    case Babylon::Polyfills::Console::LogLevel::Log:
-                        __android_log_write(ANDROID_LOG_INFO, "BabylonNative", message);
-                        break;
-                    case Babylon::Polyfills::Console::LogLevel::Warn:
-                        __android_log_write(ANDROID_LOG_WARN, "BabylonNative", message);
-                        break;
-                    case Babylon::Polyfills::Console::LogLevel::Error:
-                        __android_log_write(ANDROID_LOG_ERROR, "BabylonNative", message);
-                        break;
-                    }
+            appContext.emplace(
+                window,
+                static_cast<size_t>(width),
+                static_cast<size_t>(height),
+                [](const char* message) {
+                    __android_log_write(ANDROID_LOG_INFO, "BabylonNative", message);
+                },
+                [](Napi::Env env) {
+                    nativeXr.emplace(Babylon::Plugins::NativeXr::Initialize(env));
+                    nativeXr->SetSessionStateChangedCallback([](bool isXrActive){ ::isXrActive = isXrActive; });
                 });
-
-                Babylon::Plugins::NativeEncoding::Initialize(env);
-                Babylon::Plugins::NativeEngine::Initialize(env);
-                Babylon::Plugins::NativeOptimizations::Initialize(env);
-
-                nativeXr.emplace(Babylon::Plugins::NativeXr::Initialize(env));
-                nativeXr->SetSessionStateChangedCallback([](bool isXrActive){ ::isXrActive = isXrActive; });
-                
-                nativeInput = &Babylon::Plugins::NativeInput::CreateForJavaScript(env);
-
-                Babylon::Plugins::NativeCamera::Initialize(env);
-                Babylon::Polyfills::Window::Initialize(env);
-
-                Babylon::Polyfills::XMLHttpRequest::Initialize(env);
-                nativeCanvas.emplace(Babylon::Polyfills::Canvas::Initialize(env));
-            });
-
-            scriptLoader.emplace(*runtime);
-            scriptLoader->LoadScript("app:///Scripts/ammo.js");
-            scriptLoader->LoadScript("app:///Scripts/recast.js");
-            scriptLoader->LoadScript("app:///Scripts/babylon.max.js");
-            scriptLoader->LoadScript("app:///Scripts/babylonjs.loaders.js");
-            scriptLoader->LoadScript("app:///Scripts/babylonjs.materials.js");
-            scriptLoader->LoadScript("app:///Scripts/babylon.gui.js");
-            scriptLoader->LoadScript("app:///Scripts/babylonjs.serializers.js");
         }
     }
 
     JNIEXPORT void JNICALL
     Java_com_library_babylonnative_Wrapper_surfaceChanged(JNIEnv* env, jclass clazz, jint width, jint height, jobject surface)
     {
-        if (runtime)
+        if (appContext)
         {
             ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
-            runtime->Dispatch([window, width = static_cast<size_t>(width), height = static_cast<size_t>(height)](auto) {
-                device->UpdateWindow(window);
-                device->UpdateSize(width, height);
+            appContext->Runtime().Dispatch([window, width = static_cast<size_t>(width), height = static_cast<size_t>(height)](auto) {
+                appContext->Device().UpdateWindow(window);
+                appContext->Device().UpdateSize(width, height);
             });
         }
     }
@@ -168,18 +88,18 @@ extern "C"
     Java_com_library_babylonnative_Wrapper_activityOnPause(JNIEnv* env, jclass clazz)
     {
         android::global::Pause();
-        if (runtime)
+        if (appContext)
         {
-            runtime->Suspend();
+            appContext->Runtime().Suspend();
         }
     }
 
     JNIEXPORT void JNICALL
     Java_com_library_babylonnative_Wrapper_activityOnResume(JNIEnv* env, jclass clazz)
     {
-        if (runtime)
+        if (appContext)
         {
-            runtime->Resume();
+            appContext->Runtime().Resume();
         }
         android::global::Resume();
     }
@@ -207,50 +127,50 @@ extern "C"
     JNIEXPORT void JNICALL
     Java_com_library_babylonnative_Wrapper_loadScript(JNIEnv* env, jclass clazz, jstring path)
     {
-        if (scriptLoader)
+        if (appContext)
         {
-            scriptLoader->LoadScript(env->GetStringUTFChars(path, nullptr));
+            appContext->ScriptLoader().LoadScript(env->GetStringUTFChars(path, nullptr));
         }
     }
 
     JNIEXPORT void JNICALL
     Java_com_library_babylonnative_Wrapper_eval(JNIEnv* env, jclass clazz, jstring source, jstring sourceURL)
     {
-        if (runtime)
+        if (appContext)
         {
             std::string url = env->GetStringUTFChars(sourceURL, nullptr);
             std::string src = env->GetStringUTFChars(source, nullptr);
-            scriptLoader->Eval(std::move(src), std::move(url));
+            appContext->ScriptLoader().Eval(std::move(src), std::move(url));
         }
     }
 
     JNIEXPORT void JNICALL
     Java_com_library_babylonnative_Wrapper_setTouchInfo(JNIEnv* env, jclass clazz, jint pointerId, jfloat x, jfloat y, jboolean buttonAction, jint buttonValue)
     {
-        if (nativeInput != nullptr)
+        if (appContext && appContext->Input())
         {
             if (buttonAction)
             {
                 if (buttonValue == 1)
-                    nativeInput->TouchDown(pointerId, x, y);
+                    appContext->Input()->TouchDown(pointerId, x, y);
                 else
-                    nativeInput->TouchUp(pointerId, x, y);
+                    appContext->Input()->TouchUp(pointerId, x, y);
             }
             else {
-                nativeInput->TouchMove(pointerId, x, y);
+                appContext->Input()->TouchMove(pointerId, x, y);
             }
         }
     }
 
     JNIEXPORT void JNICALL
     Java_com_library_babylonnative_Wrapper_renderFrame(JNIEnv* env, jclass clazz)
     {
-        if (device)
+        if (appContext)
         {
-            deviceUpdate->Finish();
-            device->FinishRenderingCurrentFrame();
-            device->StartRenderingCurrentFrame();
-            deviceUpdate->Start();
+            appContext->DeviceUpdate().Finish();
+            appContext->Device().FinishRenderingCurrentFrame();
+            appContext->Device().StartRenderingCurrentFrame();
+            appContext->DeviceUpdate().Start();
         }
     }
 

Apps/Playground/CMakeLists.txt

@@ -18,6 +18,10 @@ set(SCRIPTS
     "Scripts/validation_native.js"
     "Scripts/config.json")
 
+set(SOURCES
+    "Shared/AppContext.cpp"
+    "Shared/AppContext.h")
+
 if(APPLE)
     find_library(JAVASCRIPTCORE_LIBRARY JavaScriptCore)
     if(IOS)
@@ -28,8 +32,7 @@ if(APPLE)
             "${CMAKE_CURRENT_LIST_DIR}/iOS/Base.lproj/LaunchScreen.storyboard")
         set(RESOURCE_FILES ${STORYBOARD} ${SCRIPTS})
         set(ADDITIONAL_LIBRARIES PRIVATE z NativeXr)
-        set(SOURCES
-            ${SOURCES}
+        set(SOURCES ${SOURCES}
             "iOS/AppDelegate.swift"
             "iOS/ViewController.swift"
             "iOS/LibNativeBridge.h"
@@ -42,8 +45,7 @@ if(APPLE)
         set(PLIST_FILE
             "${CMAKE_CURRENT_LIST_DIR}/visionOS/Info.plist")
         set(RESOURCE_FILES ${SCRIPTS})
-        set(SOURCES
-            ${SOURCES}
+        set(SOURCES ${SOURCES}
             "visionOS/App.swift"
             "visionOS/LibNativeBridge.mm"
             "visionOS/LibNativeBridge.h"
@@ -55,8 +57,7 @@ if(APPLE)
         set(STORYBOARD "${CMAKE_CURRENT_LIST_DIR}/macOS/Base.lproj/Main.storyboard")
         set(ADDITIONAL_LIBRARIES ${ADDITIONAL_LIBRARIES} PRIVATE NativeCamera)
         set(RESOURCE_FILES ${STORYBOARD})
-        set(SOURCES
-            ${SOURCES}
+        set(SOURCES ${SOURCES}
             "macOS/main.m"
             "macOS/AppDelegate.m"
             "macOS/AppDelegate.h"
@@ -72,8 +73,7 @@ if(APPLE)
     string(REPLACE "-Wall" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
     string(REPLACE "-Werror" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
 elseif(UNIX)
-    set(SOURCES
-        ${SOURCES}
+    set(SOURCES ${SOURCES}
         "X11/App.cpp")
 elseif(WINDOWS_STORE)
     set(APPX_FILES "UWP/Package.appxmanifest" "UWP/TemporaryKey.pfx")
@@ -88,15 +88,13 @@ elseif(WINDOWS_STORE)
         "UWP/Assets/Wide310x150Logo.scale-200.png")
     set_property(SOURCE ${APPX_ASSETS} PROPERTY VS_DEPLOYMENT_CONTENT 1)
     set_property(SOURCE ${APPX_ASSETS} PROPERTY VS_DEPLOYMENT_LOCATION "Assets")
-    set(SOURCES
-        ${SOURCES}
+    set(SOURCES ${SOURCES}
         ${APPX_FILES}
         ${APPX_ASSETS}
         "UWP/App.cpp"
         "UWP/App.h")
 elseif(WIN32)
-    set(SOURCES
-        ${SOURCES}
+    set(SOURCES ${SOURCES}
         "Win32/App.cpp"
         "Win32/App.h"
         "Win32/App.ico"
@@ -123,7 +121,7 @@ if(WINDOWS_STORE)
     target_compile_options(Playground PRIVATE /await)
 endif()
 
-target_include_directories(Playground PRIVATE "Source" ".")
+target_include_directories(Playground PRIVATE ".")
 
 target_link_libraries(Playground
     PRIVATE AppRuntime
@@ -132,16 +130,17 @@ target_link_libraries(Playground
     PRIVATE Console
     PRIVATE ExternalTexture
     PRIVATE GraphicsDevice
-    PRIVATE NativeTracing
+    PRIVATE NativeCamera
     PRIVATE NativeCapture
     PRIVATE NativeEncoding
     PRIVATE NativeEngine
     PRIVATE NativeInput
     PRIVATE NativeOptimizations
+    PRIVATE NativeTracing
     PRIVATE ScriptLoader
+    PRIVATE TestUtils
     PRIVATE Window
     PRIVATE XMLHttpRequest
-    PRIVATE TestUtils
     ${ADDITIONAL_LIBRARIES}
     ${BABYLON_NATIVE_PLAYGROUND_EXTENSION_LIBRARIES})