update bee build & vulkan opengl texture

engine/Build.bee.cs

 using Bee.Toolchain.GNU;
 using Bee.Toolchain.IOS;
 using System.Diagnostics;
+using Bee.Toolchain.Android;
 
 enum UIWidgetsBuildTargetPlatform
 {
         return RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
     }
 }
+
+// class UserNDKLocator: AndroidNdkLocator
+// {
+//     public UserNDKLocator(): base(Architecture.Armv7) { }
+//     public AndroidNdk xx(NPath path)
+//     {
+        
+//     }
+// }
 
 //ios build helpers
 class UserIOSSdkLocator : IOSSdkLocator
     public IOSAppToolchain() : base((new UserIOSSdkLocator()).UserIOSSdk(XcodePath))
     {
     }
+
+    // public AndroidToolChain():base((new UserNDKLocator()).UserDefault()
+    //     {
+
+    // }
 }
 
 /**
             "GR_TEST_UTILS=1",
             "SKIA_IMPLEMENTATION=1",
             "SK_GL",
+            "VK_USE_PLATFORM_ANDROID_KHR",
+            "EGL_EGLEXT_PROTOTYPES",
+            "GL_GLEXT_PROTOTYPES",
             "SK_ENABLE_DUMP_GPU",
             "SK_SUPPORT_PDF",
             "SK_CODEC_DECODES_JPEG",
             "-nostdlib++",
             "-Wl,--warn-shared-textrel",
             "-nostdlib",
-            "--sysroot="+ flutterRoot+"/third_party/android_tools/ndk/platforms/android-16/arch-arm",
+            // "--sysroot="+ flutterRoot+"/third_party/android_tools/ndk/platforms/android-16/arch-arm",
+            "--sysroot="+ flutterRoot+"/third_party/android_tools/ndk/platforms/android-28/arch-arm",
             "-L"+ flutterRoot + "/third_party/android_tools/ndk/sources/cxx-stl/llvm-libc++/libs/armeabi-v7a",
             "-Wl,--build-id=sha1",
             "-g",
                 var deoployNp = buildNP.DeployTo("../com.unity.uiwidgets/Runtime/Plugins/Android");
                 dependencies.Add(buildNP.Path);
                 dependencies.Add(deoployNp.Path);
+                buildNP.DeployTo("/Users/siyao/temp/androidBuild/Vulkan28/unityLibrary/src/main/jniLibs/armeabi-v7a");
             }
             np.ValidConfigurations = validConfigurations;
         }
                 new SystemLibrary("EGL"),
                 new SystemLibrary("GLESv2"),
                 new SystemLibrary("log"),
+                new SystemLibrary("vulkan"),
             };
         });
     }

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

 
 #include "Unity/IUnityGraphics.h"
 
+#include "Unity/IUnityGraphicsVulkan.h"
+#include "include/gpu/vk/GrVkBackendContext.h"
+
 namespace uiwidgets
 {
 
     EGLContext egl_context_;
     EGLContext egl_resource_context_;
     EGLConfig egl_config_;
+    
+    IUnityGraphicsVulkan* m_UnityVulkan;
+    UnityVulkanInstance m_Instance;
+    sk_sp<GrContext> gr_context_;
+    sk_sp<SkSurface> m_SkSurface;
 
     bool initialize_succeeded_;
 

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

 
 #include <flutter/fml/logging.h>
 #include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2ext.h>
+
+#include <vulkan/vulkan.h>
+#include <vulkan/vulkan_core.h>
+#include <android/hardware_buffer.h>
+
+#define UNITY_USED_VULKAN_API_FUNCTIONS(apply) \
+  apply(vkGetDeviceProcAddr);                  \
+  apply(vkCreateInstance);                     \
+  apply(vkCmdBeginRenderPass);                 \
+  apply(vkCreateBuffer);                       \
+  apply(vkGetPhysicalDeviceMemoryProperties);  \
+  apply(vkGetBufferMemoryRequirements);        \
+  apply(vkMapMemory);                          \
+  apply(vkBindBufferMemory);                   \
+  apply(vkAllocateMemory);                     \
+  apply(vkDestroyBuffer);                      \
+  apply(vkFreeMemory);                         \
+  apply(vkUnmapMemory);                        \
+  apply(vkQueueWaitIdle);                      \
+  apply(vkDeviceWaitIdle);                     \
+  apply(vkCmdCopyBufferToImage);               \
+  apply(vkFlushMappedMemoryRanges);            \
+  apply(vkCreatePipelineLayout);               \
+  apply(vkCreateShaderModule);                 \
+  apply(vkDestroyShaderModule);                \
+  apply(vkCreateGraphicsPipelines);            \
+  apply(vkCmdBindPipeline);                    \
+  apply(vkCmdDraw);                            \
+  apply(vkCmdPushConstants);                   \
+  apply(vkCmdBindVertexBuffers);               \
+  apply(vkDestroyPipeline);                    \
+  apply(vkDestroyPipelineLayout);
+
+#define VULKAN_DEFINE_API_FUNCPTR(func) static PFN_##func my_##func
+VULKAN_DEFINE_API_FUNCPTR(vkGetInstanceProcAddr);
+UNITY_USED_VULKAN_API_FUNCTIONS(VULKAN_DEFINE_API_FUNCPTR);
+#undef VULKAN_DEFINE_API_FUNCPTR
+
+static void LoadVulkanAPI(PFN_vkGetInstanceProcAddr getInstanceProcAddr,
+                          VkInstance instance)
+{
+  if (!my_vkGetInstanceProcAddr && getInstanceProcAddr)
+    my_vkGetInstanceProcAddr = getInstanceProcAddr;
+
+  if (!my_vkCreateInstance)
+    my_vkCreateInstance = (PFN_vkCreateInstance)my_vkGetInstanceProcAddr(
+        VK_NULL_HANDLE, "vkCreateInstance");
+
+#define LOAD_VULKAN_FUNC(fn) \
+  if (!my_##fn)              \
+  my_##fn = (PFN_##fn)my_vkGetInstanceProcAddr(instance, #fn)
+  UNITY_USED_VULKAN_API_FUNCTIONS(LOAD_VULKAN_FUNC);
+#undef LOAD_VULKAN_FUNC
+}
+
 namespace uiwidgets
 {
 
 
   GLuint UnitySurfaceManager::CreateRenderSurface(void *native_texture_ptr)
   {
-    GLint old_framebuffer_binding;
-    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &old_framebuffer_binding);
+    if (m_UnityVulkan != nullptr)
+    {
+      UnityVulkanImage image;
+      m_UnityVulkan->AccessTexture(
+          native_texture_ptr, UnityVulkanWholeImage, VkImageLayout::VK_IMAGE_LAYOUT_UNDEFINED, 0,
+          0, UnityVulkanResourceAccessMode::kUnityVulkanResourceAccess_ObserveOnly,
+          &image);
-    glGenFramebuffers(1, &fbo_);
-    glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
+      GrVkImageInfo info(
+          image.image, GrVkAlloc(image.memory.memory, image.memory.offset, image.memory.size, image.memory.flags),
+          image.tiling,
+          image.layout,
+          image.format,
+          image.mipCount);
-    GLuint gltex = (GLuint)(size_t)(native_texture_ptr);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gltex, 0);
-    FML_CHECK(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
+      int width = 100;
+      int height = 100;
+      GrBackendTexture backendTex(width, height, info);
-    glBindFramebuffer(GL_FRAMEBUFFER, old_framebuffer_binding);
+      m_SkSurface = SkSurface::MakeFromBackendTexture(
+          gr_context_.get(), backendTex, kBottomLeft_GrSurfaceOrigin, 1,
+          kRGBA_8888_SkColorType, nullptr, nullptr);
+      return 0;
+    }
+    else
+    {
+      GLint old_framebuffer_binding;
+      glGetIntegerv(GL_FRAMEBUFFER_BINDING, &old_framebuffer_binding);
-    return fbo_;
+      glGenFramebuffers(1, &fbo_);
+      glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
+
+      GLuint gltex = (GLuint)(size_t)(native_texture_ptr);
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gltex, 0);
+      FML_CHECK(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
+
+      glBindFramebuffer(GL_FRAMEBUFFER, old_framebuffer_binding);
+
+      return fbo_;
+    }
   }
 
   void UnitySurfaceManager::DestroyRenderSurface()
 
   void UnitySurfaceManager::GetUnityContext()
   {
-    if(egl_unity_context_ != nullptr){
+    if (egl_unity_context_ != nullptr)
+    {
-    egl_display_ = eglGetCurrentDisplay();
-    egl_unity_context_ = eglGetCurrentContext();
-    FML_CHECK(egl_display_ != EGL_NO_DISPLAY)
-        << "Renderer type is invalid";
+    // EGLint major, minor;    
+
+    // egl_display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    // eglInitialize(egl_display_, &major, &minor);
+    // egl_unity_context_ = eglGetCurrentContext();
+    // FML_CHECK(egl_display_ != EGL_NO_DISPLAY)
+    //     << "Renderer type is invalid";
+
+  static const int DEV_W = 16, DEV_H = 16;
-    FML_CHECK(egl_display_ != EGL_NO_DISPLAY)
-        << "Renderer type is invalid";
+    auto *graphics = unity_interfaces->Get<IUnityGraphics>();
+    UnityGfxRenderer renderer = graphics->GetRenderer();
+    FML_DCHECK(renderer == kUnityGfxRendererOpenGLES30 ||
+               renderer == kUnityGfxRendererOpenGLES20 ||
+               renderer == kUnityGfxRendererVulkan);
-    // Initialize the display connection.
-    FML_CHECK(eglInitialize(egl_display_, nullptr, nullptr) == EGL_TRUE)
-        << "Renderer type is invalid";
+    if (renderer == kUnityGfxRendererVulkan)
+    {
-    auto valid_ = true;
+      m_UnityVulkan = unity_interfaces->Get<IUnityGraphicsVulkan>();
+      m_Instance = m_UnityVulkan->Instance();
+      LoadVulkanAPI(m_Instance.getInstanceProcAddr, m_Instance.instance);
-    bool success = false;
+      // // AHarewareBuffer android api >= 26
+      // AHardwareBuffer* buffer = nullptr;
-    std::tie(success, egl_config_) = ChooseEGLConfiguration(egl_display_);
-    FML_CHECK(success) << "Could not choose an EGL configuration.";
+      // AHardwareBuffer_Desc hwbDesc;
+      // hwbDesc.width = DEV_W;
+      // hwbDesc.height = DEV_H;
+      // hwbDesc.layers = 1;
-    std::tie(success, egl_context_) = CreateContext(egl_display_, egl_config_, egl_unity_context_);
+      // hwbDesc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_NEVER |
+      //                   AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER |
+      //                   AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
+      //                   AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
+      // hwbDesc.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+      // // The following three are not used in the allocate
+      // hwbDesc.stride = 0;
+      // hwbDesc.rfu0= 0;
+      // hwbDesc.rfu1= 0;
-    std::tie(success, egl_resource_context_) = CreateContext(egl_display_, egl_config_, egl_context_);
+      // if (int error = AHardwareBuffer_allocate(&hwbDesc, &buffer)) {
+      //     ERRORF(reporter, "Failed to allocated hardware buffer, error: %d", error);
+      //      AHardwareBuffer_release(buffer);
+      //     return;
+      // }
-    return success;
+      auto device = m_Instance.device;
+      auto physicalDevice = m_Instance.physicalDevice;
+      VkImage image = 0;
+      VkImageCreateInfo imageInfo{};
+      imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+      imageInfo.imageType = VK_IMAGE_TYPE_2D;
+      imageInfo.extent.width = 100;
+      imageInfo.extent.height = 100;
+      imageInfo.extent.depth = 1;
+      imageInfo.mipLevels = 1;
+      imageInfo.arrayLayers = 1;
+      imageInfo.format = VK_FORMAT_B8G8R8A8_UNORM;
+      imageInfo.tiling = VK_IMAGE_TILING_LINEAR;
+      imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+      imageInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
+      imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+      imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+      vkCreateImage(device, &imageInfo, nullptr, &image);
+      // ... // create the image as normal
+      VkMemoryRequirements memReqs; // = device->getImageMemoryRequirements(image);
+      vkGetImageMemoryRequirements(device, image, &memReqs);
+      VkMemoryAllocateInfo memAllocInfo;
+      const auto handle_type = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
+      VkExportMemoryAllocateInfoKHR exportAllocInfo{
+          VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, nullptr, handle_type};
+      memAllocInfo.pNext = &exportAllocInfo;
+      memAllocInfo.allocationSize = memReqs.size;
+
+      uint32_t memoryTypeIndex = 0;
+      bool foundHeap = false;
+      VkPhysicalDeviceMemoryProperties phyDevMemProps;
+      vkGetPhysicalDeviceMemoryProperties(physicalDevice, &phyDevMemProps);
+      for (uint32_t i = 0; i < phyDevMemProps.memoryTypeCount && !foundHeap; ++i)
+      {
+        if (VkMemoryPropertyFlagBits::VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT & (1 << i))
+        {
+          // Map host-visible memory.
+          if (phyDevMemProps.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
+          {
+            memoryTypeIndex = i;
+            foundHeap = true;
+          }
+        }
+      }
+
+      memAllocInfo.memoryTypeIndex = memoryTypeIndex;
+      // physicalDevice->set_memory_type(
+      //   memReqs.memoryTypeBits, &memAllocInfo, VkMemoryPropertyFlagBits::VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+      VkDeviceMemory memory;
+      vkAllocateMemory(device, &memAllocInfo, NULL, &memory);
+      // memory = device->allocateMemory(memAllocInfo);
+      vkBindImageMemory(device, image, memory, 0);
+
+      AHardwareBuffer *buffer;
+
+      VkMemoryGetAndroidHardwareBufferInfoANDROID meminfo;
+      meminfo.sType = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID;
+      meminfo.pNext = nullptr;
+      meminfo.memory = memory;
+      vkGetMemoryAndroidHardwareBufferANDROID(device, &meminfo, &buffer); // android api level 28
+      // HANDLE sharedMemoryHandle = device->getMemoryWin32HandleKHR({
+      //   texture.memory, VkExternalMemoryHandleTypeFlags::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID
+      // });
+      // EGLDisplay display = eglGetCurrentDisplay();
+
+      bool success = false;
+      EGLint major, minor;
+
+      egl_display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+      eglInitialize(egl_display_, &major, &minor);
+
+      std::tie(success, egl_config_) = ChooseEGLConfiguration(egl_display_);
+      FML_CHECK(success) << "Could not choose an EGL configuration.";
+      eglBindAPI(EGL_OPENGL_API);
+
+      std::tie(success, egl_context_) = CreateContext(egl_display_, egl_config_, EGL_NO_CONTEXT);
+
+      std::tie(success, egl_resource_context_) = CreateContext(egl_display_, egl_config_, egl_context_);
+      eglMakeCurrent(egl_display_, EGL_NO_SURFACE, EGL_NO_SURFACE, egl_context_);
+   
+      glGenFramebuffers(1, &fbo_);
+      auto error = eglGetError();
+      glBindFramebuffer(GL_FRAMEBUFFER, fbo_);
+      error = eglGetError();
+      GLuint mTexture = 0;
+      glGenTextures(1, &mTexture);
+
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D , mTexture, 0);
+
+    //  glewInit();
+       error = eglGetError();
+      EGLClientBuffer clientBuffer = eglGetNativeClientBufferANDROID(buffer);
+      error = eglGetError();
+      bool isProtectedContent = true;
+      EGLint attribs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,EGL_NONE};
+      error = eglGetError();
+      auto xegl = eglGetCurrentContext() ;
+       //EGLImageKHR imagekhr = eglCreateImageKHR(egl_display_, egl_context_, EGL_NATIVE_BUFFER_ANDROID, clientBuffer, attribs);
+       EGLImageKHR imagekhr = eglCreateImageKHR(egl_display_, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, clientBuffer, attribs);
+      error = eglGetError();
+      GLint old_framebuffer_binding;
+      glGetIntegerv(GL_FRAMEBUFFER_BINDING, &old_framebuffer_binding);
+      error = eglGetError();
+      glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, imagekhr);
+      error = eglGetError();
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mTexture, 0);
+      error = eglGetError();
+      auto x = glCheckFramebufferStatus(GL_FRAMEBUFFER) ;
+      FML_CHECK(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
+
+      glBindFramebuffer(GL_FRAMEBUFFER, old_framebuffer_binding);
+
+
+      //-------------------
+
+      UnityVulkanPluginEventConfig config_1;
+      config_1.graphicsQueueAccess = kUnityVulkanGraphicsQueueAccess_DontCare;
+      config_1.renderPassPrecondition = kUnityVulkanRenderPass_EnsureInside;
+      config_1.flags =
+          kUnityVulkanEventConfigFlag_EnsurePreviousFrameSubmission |
+          kUnityVulkanEventConfigFlag_ModifiesCommandBuffersState;
+      m_UnityVulkan->ConfigureEvent(1, &config_1);
+
+      GrVkBackendContext vk_backend_context;
+      vk_backend_context.fInstance = m_Instance.instance;
+      vk_backend_context.fPhysicalDevice = m_Instance.physicalDevice;
+      vk_backend_context.fDevice = m_Instance.device;
+      vk_backend_context.fQueue = m_Instance.graphicsQueue;
+      vk_backend_context.fGraphicsQueueIndex = m_Instance.queueFamilyIndex;
+      vk_backend_context.fGetProc =
+          [getInstanceProc = m_Instance.getInstanceProcAddr,
+           getDeviceProc = my_vkGetDeviceProcAddr](
+              const char *proc_name, VkInstance instance, VkDevice device) {
+            if (device != VK_NULL_HANDLE)
+            {
+              return getDeviceProc(device, proc_name);
+            }
+            return getInstanceProc(instance, proc_name);
+          };
+      gr_context_ = GrContext::MakeVulkan(vk_backend_context);
+
+      auto valid_ = true;
+
+      return success;
+    }
+    else
+    {
+      // Make sure Vulkan API functions are loaded
+
+      FML_CHECK(egl_display_ != EGL_NO_DISPLAY)
+          << "Renderer type is invalid";
+
+      // Initialize the display connection.
+      FML_CHECK(eglInitialize(egl_display_, nullptr, nullptr) == EGL_TRUE)
+          << "Renderer type is invalid";
+
+      auto valid_ = true;
+
+      bool success = false;
+
+      std::tie(success, egl_config_) = ChooseEGLConfiguration(egl_display_);
+      FML_CHECK(success) << "Could not choose an EGL configuration.";
+
+      std::tie(success, egl_context_) = CreateContext(egl_display_, egl_config_, egl_unity_context_);
+
+      std::tie(success, egl_resource_context_) = CreateContext(egl_display_, egl_config_, egl_context_);
+      return success;
+    }
   }
 
   void UnitySurfaceManager::CleanUp()