Integrate cpp code to latest

.clang-format

@@ -6,7 +6,6 @@ AlignEscapedNewlines: true
 AlignOperands: true
 AlignTrailingComments: true
 AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortFunctionsOnASingleLine: true
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: Inline
 AllowShortIfStatementsOnASingleLine: false

CMakeLists.txt

@@ -118,6 +118,8 @@ if(${GFXRECON_ENABLE_RELEASE_ASSERTS})
     add_definitions(-DGFXRECON_ENABLE_RELEASE_ASSERTS)
 endif()
 
+option(GFXRECON_TOCPP_SUPPORT "Build ToCpp export tool as part of GFXReconstruct builds." TRUE)
+
 if(MSVC)
 
     # The host toolchain architecture (i.e. are the compiler and other tools compiled to ARM/Intel 32bit/64bit binaries):

android/framework/util/CMakeLists.txt

@@ -13,7 +13,6 @@ target_sources(gfxrecon_util
                    ${GFXRECON_SOURCE_DIR}/framework/util/file_path.h
                    ${GFXRECON_SOURCE_DIR}/framework/util/file_path.cpp
                    ${GFXRECON_SOURCE_DIR}/framework/util/hash.h
-                   ${GFXRECON_SOURCE_DIR}/framework/util/hash.cpp
                    ${GFXRECON_SOURCE_DIR}/framework/util/image_writer.h
                    ${GFXRECON_SOURCE_DIR}/framework/util/image_writer.cpp
                    ${GFXRECON_SOURCE_DIR}/framework/util/keyboard.h

external/Tocpp-Android-Template/app/CMakeLists.txt

@@ -0,0 +1,77 @@
+cmake_minimum_required(VERSION 3.4.1)
+
+function(sublist INPUT_LIST START_IDX LENGTH OUTPUT_LIST)
+    set(ENTRIES )
+    math(EXPR END_IDX "${START_IDX} + ${LENGTH}")
+
+    list(LENGTH ${INPUT_LIST} LIST_LENGTH)
+
+    foreach(IDX RANGE ${START_IDX} ${END_IDX})
+        if ((IDX GREATER LIST_LENGTH) OR (IDX EQUAL LIST_LENGTH))
+            break()
+        endif()
+
+        list(GET ${INPUT_LIST} ${IDX} ITEM)
+        list(APPEND ENTRIES ${ITEM})
+    endforeach()
+
+    set(${OUTPUT_LIST} ${ENTRIES} PARENT_SCOPE)
+
+endfunction(sublist)
+
+set(LIBNAME gfxtocpp)
+
+# build native_app_glue as a static lib
+set(APP_GLUE_DIR ${ANDROID_NDK}/sources/android/native_app_glue)
+include_directories(${APP_GLUE_DIR})
+add_library(app-glue STATIC ${APP_GLUE_DIR}/android_native_app_glue.c)
+
+# build vulkan app
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Werror")
+set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -u ANativeActivity_onCreate")
+
+set(JNI_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/main/jni)
+set(GENERATED_FRAMES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/main/assets/src)
+
+# Base lib
+add_library(${LIBNAME}-base SHARED
+            ${JNI_DIR}/ScreenOrientation.cpp
+            ${GENERATED_FRAMES_DIR}/swapchain_common.cpp
+            ${GENERATED_FRAMES_DIR}/swapchain_common.h
+            ${GENERATED_FRAMES_DIR}/global_var.cpp
+            ${GENERATED_FRAMES_DIR}/global_var.h
+            ${GENERATED_FRAMES_DIR}/loader.cpp
+            ${GENERATED_FRAMES_DIR}/loader.h
+)
+target_link_libraries(${LIBNAME}-base PUBLIC log android vulkan)
+target_include_directories(${LIBNAME}-base PUBLIC ${JNI_DIR})
+
+# Main lib
+add_library(${LIBNAME} SHARED
+            ${JNI_DIR}/VulkanMain.cpp
+            ${JNI_DIR}/AndroidMain.cpp
+)
+target_link_libraries(${LIBNAME} app-glue)
+
+target_include_directories(${LIBNAME}
+  PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src/main/assets/src/
+         ${JNI_DIR}
+)
+
+# Frame libraries
+set(FILE_LIMIT 500)
+
+file(GLOB SRC_FILES ${GENERATED_FRAMES_DIR}/frame_*.cpp)
+list(SORT SRC_FILES)
+list(LENGTH SRC_FILES FILE_COUNT)
+math(EXPR LIB_COUNT "${FILE_COUNT} / ${FILE_LIMIT}")
+
+foreach(LIB_IDX RANGE 0 ${LIB_COUNT})
+    math(EXPR START_IDX "${LIB_IDX} * ${FILE_LIMIT}")
+    sublist(SRC_FILES ${START_IDX} ${FILE_LIMIT} LIB_FILES)
+
+    set(FRAME_LIBNAME ${LIBNAME}-frames-${LIB_IDX})
+    add_library(${FRAME_LIBNAME} SHARED ${LIB_FILES})
+    target_link_libraries(${FRAME_LIBNAME} PUBLIC ${LIBNAME}-base)
+    target_link_libraries(${LIBNAME} ${FRAME_LIBNAME})
+endforeach()

external/Tocpp-Android-Template/app/build.gradle

@@ -0,0 +1,29 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 28
+
+    defaultConfig {
+        applicationId  "com.lunarg.gfxreconstruct.tocpp"
+        minSdkVersion    28
+        targetSdkVersion 28
+        versionCode 1
+        versionName "0.0.1"
+
+        externalNativeBuild {
+            cmake {
+                abiFilters 'arm64-v8a'
+                arguments '-DANDROID_TOOLCHAIN=clang', '-DANDROID_STL=c++_static'
+            }
+        }
+    }
+    aaptOptions {
+        // .spv and .bin files should not be compressed as reading compressed assets can be slow
+        noCompress 'spv', 'bin'
+    }
+    externalNativeBuild {
+        cmake {
+            path 'CMakeLists.txt'
+        }
+    }
+}

external/Tocpp-Android-Template/app/src/main/AndroidManifest.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- BEGIN_INCLUDE(manifest) -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+        package="com.lunarg.gfxreconstruct.tocpp">
+
+    <application android:label="@string/app_name"
+        android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
+
+        <!-- Our activity is the built-in NativeActivity framework class.
+             This will take care of integrating with our NDK code. -->
+        <activity android:name="android.app.NativeActivity"
+                android:label="@string/app_name"
+                android:configChanges="orientation|keyboardHidden">
+            <!-- Tell NativeActivity the name of or .so -->
+            <meta-data android:name="android.app.lib_name"
+                    android:value="gfxtocpp" />
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
+<!-- END_INCLUDE(manifest) -->

external/Tocpp-Android-Template/app/src/main/jni/AndroidLogging.hpp

@@ -0,0 +1,15 @@
+#ifndef __ANDROIDLOGGING_HPP__
+#define __ANDROIDLOGGING_HPP__
+
+#include <android/log.h>
+
+// Android log function wrappers
+static const char* kTAG = "GFXReconstruct-ToCpp";
+#define LOGI(...) \
+  ((void)__android_log_print(ANDROID_LOG_INFO, kTAG, __VA_ARGS__))
+#define LOGW(...) \
+  ((void)__android_log_print(ANDROID_LOG_WARN, kTAG, __VA_ARGS__))
+#define LOGE(...) \
+  ((void)__android_log_print(ANDROID_LOG_ERROR, kTAG, __VA_ARGS__))
+
+#endif // __ANDROIDLOGGING_HPP__

external/Tocpp-Android-Template/app/src/main/jni/AndroidMain.cpp

@@ -0,0 +1,31 @@
+#include "AndroidLogging.hpp"
+#include "VulkanMain.hpp"
+
+// Process the next main command.
+void handle_cmd(android_app* app, int32_t cmd) {
+    LOGI("event not handled: %d", cmd);
+}
+
+void android_main(struct android_app* app) {
+  // Set the callback to process system events
+  app->onAppCmd = handle_cmd;
+
+  // Used to poll the events in the main loop
+  int events;
+  android_poll_source* source;
+
+  // Main loop
+  do {
+    if (ALooper_pollAll(1, nullptr,
+                        &events, (void**)&source) >= 0) {
+      if (source != NULL) {
+        source->process(app, source);
+      }
+    }
+    if (app->window) {
+      VulkanDrawFrame(app);
+    }
+  } while (app->destroyRequested == 0);
+
+  ANativeActivity_finish(app->activity);
+}

external/Tocpp-Android-Template/app/src/main/jni/ScreenOrientation.cpp

@@ -0,0 +1,99 @@
+#include "ScreenOrientation.hpp"
+
+#include "AndroidLogging.hpp"
+
+#include <array>
+
+AndroidScreen::AndroidScreen(android_app* application)
+{
+    m_application = application;
+
+    if (m_application != nullptr && m_application->window != nullptr) {
+        m_width  = ANativeWindow_getWidth(m_application->window);
+        m_height = ANativeWindow_getHeight(m_application->window);
+    } else {
+        m_width  = -1;
+        m_height = -1;
+    }
+
+    m_pretransform = 0;
+}
+
+// NOTE: This function is the same with AndroidApplication::SetOrientation().
+void AndroidScreen::windowSetOrientation(ScreenOrientation orientation)
+{
+    JavaVM* jni_vm       = nullptr;
+    jobject jni_activity = nullptr;
+    JNIEnv* env          = nullptr;
+
+    if ((m_application != nullptr) && (m_application->activity != nullptr))
+    {
+        jni_vm       = m_application->activity->vm;
+        jni_activity = m_application->activity->clazz;
+    }
+
+    if ((jni_vm != nullptr) && (jni_activity != 0) && (jni_vm->AttachCurrentThread(&env, nullptr) == JNI_OK))
+    {
+        jclass    object_class    = env->GetObjectClass(jni_activity);
+        jmethodID set_orientation = env->GetMethodID(object_class, "setRequestedOrientation", "(I)V");
+
+        env->CallVoidMethod(jni_activity, set_orientation, orientation);
+
+        jni_vm->DetachCurrentThread();
+    }
+}
+
+// NOTE: This function is the same with AndroidWindow::SetSizePreTransform().
+void AndroidScreen::windowSetSizePreTransform(const uint32_t width, const uint32_t height, const uint32_t pre_transform)
+{
+    if ((width != m_width) || (height != m_height) || (pre_transform != m_pretransform))
+    {
+        m_width         = width;
+        m_height        = height;
+        m_pretransform  = pre_transform;
+
+        if ((m_application == nullptr) || (m_application->window == nullptr))
+        {
+            LOGE("Failed to resize the window!");
+            return;
+        }
+
+        // For Android, we adjust the screen orientation based on requested width and height.
+        int32_t pixel_width  = ANativeWindow_getWidth(m_application->window);
+        int32_t pixel_height = ANativeWindow_getHeight(m_application->window);
+
+        // We don't change the current orientation if width == height or if the requested orientation matches the
+        // current orientation, unless a pre-transform has been applied to the swapchain, in which case the orientation
+        // will be adjusted to match the pre-transform.
+        if (((width != height) && ((width < height) != (pixel_width < pixel_height))) ||
+            (pre_transform != ResizeWindowPreTransform::kPreTransform0))
+        {
+            const std::array<ScreenOrientation, 2> kOrientations{
+                ScreenOrientation::kLandscape,
+                ScreenOrientation::kPortrait
+            };
+
+            uint32_t orientation_index = 0;
+
+            if (height > width)
+            {
+                orientation_index = 1;
+            }
+
+            // Toggle orientation between landscape and portrait for 90 and 270 degree pre-transform values.
+            if ((pre_transform == ResizeWindowPreTransform::kPreTransform90) ||
+                (pre_transform == ResizeWindowPreTransform::kPreTransform270))
+            {
+                orientation_index ^= 1;
+            }
+
+            windowSetOrientation(kOrientations[orientation_index]);
+        }
+
+        int32_t result = ANativeWindow_setBuffersGeometry(m_application->window, width, height, ANativeWindow_getFormat(m_application->window));
+        if (result != 0)
+        {
+            LOGE("Failed to change native window geometry: ANativeWindow_setBuffersGeometry returned %d", result);
+        }
+    }
+}

external/Tocpp-Android-Template/app/src/main/jni/ScreenOrientation.hpp

@@ -0,0 +1,35 @@
+#ifndef __SCREENORIENTATION_HPP__
+#define __SCREENORIENTATION_HPP__
+
+#include <android_native_app_glue.h>
+
+class AndroidScreen {
+public:
+    enum ScreenOrientation : int32_t
+    {
+        kLandscape = 0,
+        kPortrait  = 1
+    };
+
+    enum ResizeWindowPreTransform : uint32_t
+    {
+        kPreTransform0   = 0,
+        kPreTransform90  = 1,
+        kPreTransform180 = 2,
+        kPreTransform270 = 3
+    };
+
+    AndroidScreen() {};
+    AndroidScreen(android_app* application);
+    void windowSetSizePreTransform(const uint32_t width, const uint32_t height, const uint32_t pre_transform);
+
+private:
+    android_app* m_application;
+    int32_t m_width;
+    int32_t m_height;
+    int32_t m_pretransform;
+
+    void windowSetOrientation(ScreenOrientation orientation);
+};
+
+#endif // __SCREENORIENTATION_HPP__

external/Tocpp-Android-Template/app/src/main/jni/VulkanMain.cpp

@@ -0,0 +1,35 @@
+#include "VulkanMain.hpp"
+
+#include <string>
+#include <vulkan/vulkan.h>
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+void OverrideVkAndroidSurfaceCreateInfoKHR(VkAndroidSurfaceCreateInfoKHR* createInfo, struct ANativeWindow* window);
+#endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+void FuncCallCheck(VkResult returnValue);
+
+
+void VulkanDrawFrame(android_app* app) {
+// ---- The generated source is placed below. -----
+
+// VkInstanceCreateInfo...
+
+// ---- The generated source is ended. -----
+}
+
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+void OverrideVkAndroidSurfaceCreateInfoKHR(VkAndroidSurfaceCreateInfoKHR* createInfo, struct ANativeWindow* window) {
+    createInfo->sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
+    createInfo->pNext = nullptr;
+    createInfo->flags = 0;
+    createInfo->window = window;
+}
+#endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
+void FuncCallCheck(VkResult returnValue)
+{
+    if (returnValue != VK_SUCCESS) {
+        throw std::runtime_error("Command failed!");
+    }
+}

external/Tocpp-Android-Template/app/src/main/jni/VulkanMain.hpp

@@ -0,0 +1,8 @@
+#ifndef __VULKANMAIN_HPP__
+#define __VULKANMAIN_HPP__
+
+#include <android_native_app_glue.h>
+
+void VulkanDrawFrame(android_app* app);
+
+#endif // __VULKANMAIN_HPP__

external/Tocpp-Android-Template/app/src/main/res/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">GFXReconstruct-ToCpp</string>
+</resources>