Menangani orientasi perangkat dengan pra-rotasi Vulkan

Artikel ini menjelaskan cara menangani rotasi perangkat secara efisien di aplikasi Vulkan dengan menerapkan pra-rotasi.

Dengan Vulkan, Anda dapat menentukan lebih banyak informasi tentang status rendering daripada dengan OpenGL. Dengan Vulkan, Anda harus secara eksplisit mengimplementasikan hal-hal yang ditangani oleh driver di OpenGL, seperti orientasi perangkat dan hubungannya dengan orientasi platform render. Ada tiga cara agar Android dapat menangani rekonsiliasi platform render perangkat dengan orientasi perangkat:

1. OS Android dapat menggunakan Display Processing Unit (DPU) perangkat, yang dapat menangani rotasi platform secara efisien dalam hardware. Hanya tersedia di perangkat yang didukung.
2. OS Android dapat menangani rotasi platform dengan menambahkan penerusan compositor. Ini akan menimbulkan biaya performa, tergantung cara compositor menangani rotasi gambar output.
3. Aplikasi itu sendiri dapat menangani rotasi platform dengan merender gambar yang diputar ke platform render yang sesuai dengan orientasi tampilan saat ini.

Manakah dari metode ini yang harus Anda gunakan?

Saat ini, tidak ada cara bagi aplikasi untuk mengetahui apakah rotasi platform yang ditangani di luar aplikasi akan gratis. Meskipun ada DPU yang membantu Anda menangani masalah ini, kemungkinan masih ada penalti performa terukur yang harus dibayarkan. Jika aplikasi Anda terikat CPU, ini akan menjadi masalah daya karena meningkatnya penggunaan GPU oleh Android Compositor, yang biasanya berjalan pada frekuensi yang ditingkatkan. Jika aplikasi Anda terikat dengan GPU, Android Compositor juga dapat menghentikan pekerjaan GPU aplikasi Anda sehingga menyebabkan hilangnya performa.

Saat menjalankan judul pengiriman di Pixel 4XL, kami telah melihat bahwa SurfaceFlinger (tugas dengan prioritas lebih tinggi yang mendorong Android Compositor):

• Mencegah tugas aplikasi secara rutin, menyebabkan hit 1-3 md ke waktu render frame, dan

• Menaikkan tekanan pada memori verteks/tekstur GPU, karena Compositor harus membaca seluruh framebuffer untuk melakukan pekerjaan komposisinya.

Orientasi penanganan hampir secara total menghentikan preemption GPU oleh SurfaceFlinger, sementara frekuensi GPU turun 40% karena frekuensi yang telah dikuatkan dan digunakan oleh Android Compositor tidak diperlukan lagi.

Untuk memastikan rotasi platform ditangani dengan benar menggunakan overhead seminimal mungkin, seperti yang terlihat dalam kasus sebelumnya, Anda harus mengimplementasikan metode 3. Tindakan ini dikenal sebagai pra-rotasi. Kode ini memberi tahu Android OS bahwa aplikasi Anda menangani rotasi platform. Anda dapat melakukannya dengan meneruskan flag transformasi platform yang menentukan orientasi selama pembuatan swapchain. Tindakan ini akan menghentikan Android Compositor agar tidak melakukan rotasi itu sendiri.

Mengetahui cara menetapkan tanda transformasi platform sangat penting untuk setiap aplikasi Vulkan. Aplikasi cenderung mendukung beberapa orientasi atau mendukung satu orientasi dengan platform render berada dalam orientasi yang berbeda dengan orientasi identitasnya yang dipertimbangkan perangkat. Misalnya, aplikasi khusus lanskap pada ponsel identitas potret, atau aplikasi khusus potret pada tablet identitas lanskap.

Mengubah AndroidManifest.xml

Untuk menangani rotasi perangkat di aplikasi Anda, mulailah dengan mengubah file AndroidManifest.xml aplikasi untuk memberi tahu Android bahwa aplikasi Anda akan menangani perubahan orientasi dan ukuran layar. Hal ini akan mencegah Android menghancurkan dan membuat ulang Activity Android dan memanggil fungsi onDestroy() pada platform jendela yang ada saat terjadi perubahan orientasi. Hal ini dilakukan dengan menambahkan atribut orientation (untuk mendukung API level 13) dan screenSize ke bagian configChanges aktivitas:

<activity android:name="android.app.NativeActivity"
          android:configChanges="orientation|screenSize">

Jika aplikasi memperbaiki orientasi layarnya menggunakan atribut screenOrientation, Anda tidak perlu melakukan ini. Selain itu, jika aplikasi Anda menggunakan orientasi tetap, aplikasi hanya perlu menyiapkan swapchain satu kali saat memulai/melanjutkan aplikasi.

Mendapatkan Resolusi Layar Identitas dan Parameter Kamera

Selanjutnya, deteksi resolusi layar perangkat yang terkait dengan nilai VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR. Resolusi ini berkaitan dengan orientasi identitas perangkat sehingga resolusi tersebut harus selalu disetel ke swapchain. Cara yang paling andal untuk mendapatkan hal ini adalah dengan melakukan panggilan ke vkGetPhysicalDeviceSurfaceCapabilitiesKHR() saat aplikasi dimulai, dan menyimpan ekstensi yang ditampilkan. Tukar lebar dan tinggi berdasarkan currentTransform yang juga ditampilkan untuk memastikan bahwa Anda menyimpan resolusi layar identitas:

VkSurfaceCapabilitiesKHR capabilities;
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physDevice, surface, &capabilities);

uint32_t width = capabilities.currentExtent.width;
uint32_t height = capabilities.currentExtent.height;
if (capabilities.currentTransform & VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR ||
    capabilities.currentTransform & VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) {
  // Swap to get identity width and height
  capabilities.currentExtent.height = width;
  capabilities.currentExtent.width = height;
}

displaySizeIdentity = capabilities.currentExtent;

displaySizeIdentity adalah struktur VkExtent2D yang digunakan untuk menyimpan resolusi identitas platform jendela aplikasi dalam orientasi layar yang alami

Mendeteksi Perubahan Orientasi Perangkat (Android 10+)

Cara terbaik untuk mendeteksi perubahan orientasi dalam aplikasi Anda adalah dengan memverifikasi apakah fungsi vkQueuePresentKHR() menampilkan VK_SUBOPTIMAL_KHR atau tidak. Contoh:

auto res = vkQueuePresentKHR(queue_, &present_info);
if (res == VK_SUBOPTIMAL_KHR){
  orientationChanged = true;
}

Catatan: Solusi ini hanya berfungsi pada perangkat yang menjalankan Android 10 dan yang lebih baru. Versi Android ini menampilkan VK_SUBOPTIMAL_KHR dari vkQueuePresentKHR(). Kami menyimpan hasil pemeriksaan ini di orientationChanged, boolean yang dapat diakses dari loop rendering utama aplikasi.

Mendeteksi Perubahan Orientasi Perangkat (Pra-Android 10)

Untuk perangkat yang menjalankan Android 10 atau yang lebih lama, implementasi yang berbeda diperlukan karena VK_SUBOPTIMAL_KHR tidak didukung.

Menggunakan Polling

Pada perangkat pra-Android 10, Anda dapat melakukan polling tentang transformasi perangkat saat ini setiap pollingInterval frame, dengan pollingInterval adalah perincian yang ditentukan oleh programmer. Cara melakukannya dengan memanggil vkGetPhysicalDeviceSurfaceCapabilitiesKHR(), lalu membandingkan kolom currentTransform yang ditampilkan dengan transformasi platform yang saat ini disimpan (dalam contoh kode ini disimpan di pretransformFlag -nya).

currFrameCount++;
if (currFrameCount >= pollInterval){
  VkSurfaceCapabilitiesKHR capabilities;
  vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physDevice, surface, &capabilities);

  if (pretransformFlag != capabilities.currentTransform) {
    window_resized = true;
  }
  currFrameCount = 0;
}

Pada Pixel 4 yang menjalankan -Android 10, polling vkGetPhysicalDeviceSurfaceCapabilitiesKHR() memerlukan waktu sekitar 120-250 md, dan pada Pixel 1XL yang menjalankan Android 8, polling memerlukan waktu sekitar 110-350 md.

Menggunakan Callback

Opsi kedua untuk perangkat yang berjalan di Android 10 ke bawah adalah mendaftarkan callback onNativeWindowResized() untuk memanggil fungsi yang menetapkan flag orientationChanged yang memberi tahu aplikasi ke orientasi jika telah terjadi perubahan:

void android_main(struct android_app *app) {
  ...
  app->activity->callbacks->onNativeWindowResized = ResizeCallback;
}

Dengan ResizeCallback didefinisikan sebagai:

void ResizeCallback(ANativeActivity *activity, ANativeWindow *window){
  orientationChanged = true;
}

Masalah dengan solusi ini adalah onNativeWindowResized() hanya dipanggil untuk perubahan orientasi 90 derajat, seperti beralih dari lanskap ke potret atau sebaliknya. Perubahan orientasi lainnya tidak akan memicu pembuatan ulang swapchain. Misalnya, perubahan dari lanskap ke lanskap terbalik tidak akan memicunya, sehingga Android compositor harus melakukan membalikkan aplikasi Anda.

Menangani Perubahan Orientasi

Untuk menangani perubahan orientasi, panggil rutinitas perubahan orientasi di bagian atas loop perenderan utama saat variabel orientationChanged disetel ke benar. Contoh:

bool VulkanDrawFrame() {
 if (orientationChanged) {
   OnOrientationChange();
}

Anda melakukan semua pekerjaan yang diperlukan untuk membuat ulang swapchain dalam fungsi OnOrientationChange(). Ini berarti Anda:

1. Hancurkan semua instance Framebuffer dan ImageView yang ada,

2. Buat ulang swapchain sambil menghancurkan swapchain lama (yang akan dibahas selanjutnya), dan

3. Membuat ulang Framebuffer dengan DisplayImages dari swapchain yang baru. Catatan: Gambar lampiran (misalnya, gambar kedalaman/stensil) biasanya tidak perlu dibuat ulang karena didasarkan pada resolusi identitas gambar swapchain yang telah dirotasi sebelumnya.

void OnOrientationChange() {
 vkDeviceWaitIdle(getDevice());

 for (int i = 0; i < getSwapchainLength(); ++i) {
   vkDestroyImageView(getDevice(), displayViews_[i], nullptr);
   vkDestroyFramebuffer(getDevice(), framebuffers_[i], nullptr);
 }

 createSwapChain(getSwapchain());
 createFrameBuffers(render_pass, depthBuffer.image_view);
 orientationChanged = false;
}

Dan di akhir fungsi, Anda akan mereset flag orientationChanged ke salah untuk menunjukkan bahwa Anda telah menangani perubahan orientasi.

Pembuatan Ulang Swapchain

Di bagian sebelumnya, kita harus membuat ulang swapchain. Langkah pertama untuk melakukannya adalah memperoleh karakteristik baru dari platform rendering:

void createSwapChain(VkSwapchainKHR oldSwapchain) {
   VkSurfaceCapabilitiesKHR capabilities;
   vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physDevice, surface, &capabilities);
   pretransformFlag = capabilities.currentTransform;

Dengan struktur VkSurfaceCapabilities yang telah diisi dengan informasi baru, Anda sekarang dapat memeriksa kolom currentTransform untuk melihat apakah perubahan orientasi telah terjadi atau belum. Anda akan menyimpannya nanti di kolom pretransformFlag karena Anda akan memerlukannya untuk nanti saat melakukan penyesuaian pada matriks MVP.

Untuk melakukannya, tentukan atribut berikut di struktur VkSwapchainCreateInfo:

VkSwapchainCreateInfoKHR swapchainCreateInfo{
  ...
  .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
  .imageExtent = displaySizeIdentity,
  .preTransform = pretransformFlag,
  .oldSwapchain = oldSwapchain,
};

vkCreateSwapchainKHR(device_, &swapchainCreateInfo, nullptr, &swapchain_));

if (oldSwapchain != VK_NULL_HANDLE) {
  vkDestroySwapchainKHR(device_, oldSwapchain, nullptr);
}

Kolom imageExtent akan diisi dengan extent displaySizeIdentity yang Anda simpan saat aplikasi dimulai. Kolom preTransform akan diisi dengan variabel pretransformFlag (yang ditetapkan ke kolom currentTransform pada surfaceCapabilities). Anda juga menyetel kolom oldSwapchain ke swapchain yang akan dihancurkan.

Penyesuaian Matriks MVP

Hal terakhir yang harus Anda lakukan adalah menerapkan pra-transformasi dengan menerapkan matriks rotasi ke matriks MVP. Pada dasarnya yang dilakukan ialah menerapkan rotasi dalam ruang klip sehingga gambar yang dihasilkan diputar ke orientasi perangkat saat ini. Kemudian Anda dapat meneruskan matriks MVP yang telah diperbarui ini ke dalam shader vertex dan menggunakannya seperti biasa tanpa perlu mengubah shader.

glm::mat4 pre_rotate_mat = glm::mat4(1.0f);
glm::vec3 rotation_axis = glm::vec3(0.0f, 0.0f, 1.0f);

if (pretransformFlag & VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR) {
  pre_rotate_mat = glm::rotate(pre_rotate_mat, glm::radians(90.0f), rotation_axis);
}

else if (pretransformFlag & VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) {
  pre_rotate_mat = glm::rotate(pre_rotate_mat, glm::radians(270.0f), rotation_axis);
}

else if (pretransformFlag & VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR) {
  pre_rotate_mat = glm::rotate(pre_rotate_mat, glm::radians(180.0f), rotation_axis);
}

MVP = pre_rotate_mat * MVP;

Pertimbangan - Area Pandang dan Tampilan Layar yang Tidak Penuh Layar

Jika aplikasi Anda menggunakan region scissor/viewport layar tidak penuh, aplikasi tersebut harus diperbarui sesuai dengan orientasi perangkat. Hal ini mengharuskan Anda mengaktifkan opsi Viewport dan Scissor dinamis selama pembuatan pipeline Vulkan:

VkDynamicState dynamicStates[2] = {
  VK_DYNAMIC_STATE_VIEWPORT,
  VK_DYNAMIC_STATE_SCISSOR,
};

VkPipelineDynamicStateCreateInfo dynamicInfo = {
  .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
  .pNext = nullptr,
  .flags = 0,
  .dynamicStateCount = 2,
  .pDynamicStates = dynamicStates,
};

VkGraphicsPipelineCreateInfo pipelineCreateInfo = {
  .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
  ...
  .pDynamicState = &dynamicInfo,
  ...
};

VkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineCreateInfo, nullptr, &mPipeline);

Komputasi aktual area extent viewport selama perekaman buffering perintah terlihat seperti ini:

int x = 0, y = 0, w = 500, h = 400;

glm::vec4 viewportData;

switch (device->GetPretransformFlag()) {
  case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
    viewportData = {bufferWidth - h - y, x, h, w};
    break;
  case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
    viewportData = {bufferWidth - w - x, bufferHeight - h - y, w, h};
    break;
  case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
    viewportData = {y, bufferHeight - w - x, h, w};
    break;
  default:
    viewportData = {x, y, w, h};
    break;
}

const VkViewport viewport = {
    .x = viewportData.x,
    .y = viewportData.y,
    .width = viewportData.z,
    .height = viewportData.w,
    .minDepth = 0.0F,
    .maxDepth = 1.0F,
};

vkCmdSetViewport(renderer->GetCurrentCommandBuffer(), 0, 1, &viewport);

Variabel x dan y menentukan koordinat sudut kiri atas viewport sedangkan w dan h masing-masing menentukan lebar dan tinggi viewport. Komputasi yang sama juga dapat digunakan untuk menetapkan pengujian gunting, dan disertakan di sini untuk kelengkapan:

int x = 0, y = 0, w = 500, h = 400;
glm::vec4 scissorData;

switch (device->GetPretransformFlag()) {
  case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
    scissorData = {bufferWidth - h - y, x, h, w};
    break;
  case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
    scissorData = {bufferWidth - w - x, bufferHeight - h - y, w, h};
    break;
  case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
    scissorData = {y, bufferHeight - w - x, h, w};
    break;
  default:
    scissorData = {x, y, w, h};
    break;
}

const VkRect2D scissor = {
    .offset =
        {
            .x = (int32_t)viewportData.x,
            .y = (int32_t)viewportData.y,
        },
    .extent =
        {
            .width = (uint32_t)viewportData.z,
            .height = (uint32_t)viewportData.w,
        },
};

vkCmdSetScissor(renderer->GetCurrentCommandBuffer(), 0, 1, &scissor);

Pertimbangan - Derivatif Shader Fragmen

Jika aplikasi Anda menggunakan komputasi turunan seperti dFdx dan dFdy, transformasi tambahan mungkin diperlukan untuk memperhitungkan sistem koordinat yang dirotasi karena komputasi ini dieksekusi di ruang piksel. Aplikasi harus meneruskan beberapa indikasi preTransform ke dalam shader fragmen (seperti integer yang mewakili orientasi perangkat saat ini) dan menggunakannya untuk memetakan komputasi turunan dengan benar:

• Untuk frame yang telah diputar sebelumnya sebesar 90 derajat
  • dFdx harus dipetakan ke dFdy
  • dFdy harus dipetakan ke -dFdx
• Untuk frame yang telah diputar sebelumnya sebesar 270 derajat
  • dFdx harus dipetakan ke -dFdy
  • dFdy harus dipetakan ke dFdx
• Untuk frame yang telah diputar sebelumnya sebesar 180 derajat
  • dFdx harus dipetakan ke -dFdx
  • dFdy harus dipetakan ke -dFdy

Kesimpulan

Agar aplikasi dapat memaksimalkan Vulkan di Android, Anda harus menerapkan pra-rotasi. Hal yang paling penting dari artikel ini adalah:

• Pastikan selama pembuatan atau pembuatan ulang swapchain, tanda pra-transformasi ditetapkan agar cocok dengan tanda yang ditampilkan oleh sistem operasi Android. Ini akan menghindari overhead compositor.
• Pastikan ukuran swapchain tetap sesuai dengan resolusi identitas platform jendela aplikasi dalam orientasi alami layar.
• Putar matriks MVP di ruang klip untuk memperhitungkan orientasi perangkat, karena resolusi/eksten swapchain tidak lagi diperbarui dengan orientasi layar.
• Perbarui area pandang dan gunting sesuai kebutuhan aplikasi Anda.

Contoh Aplikasi: Pra-rotasi minimal Android