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 informasi status rendering lebih lanjut dibandingkan dengan OpenGL. Dengan Vulkan, Anda harus menerapkan hal-hal yang ditangani oleh driver di OpenGL secara eksplisit, seperti orientasi perangkat dan hubungannya dengan orientasi platform render. Ada tiga cara yang dapat dilakukan Android untuk menangani rekonsiliasi platform render pada perangkat dengan orientasi perangkat:

1. OS Android dapat menggunakan Display Processing Unit (DPU) perangkat yang dapat menangani rotasi permukaan secara efisien di hardware. Hanya tersedia di perangkat yang didukung.
2. OS Android dapat menangani rotasi permukaan dengan menambahkan compositor pass. Hal ini akan memiliki biaya performa, bergantung pada cara compositor menangani rotasi gambar output.
3. Aplikasi itu sendiri dapat menangani rotasi platform dengan merender gambar yang diputar ke platform render yang cocok dengan orientasi layar saat ini.

Manakah dari metode berikut 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 dengan CPU, ini akan menyebabkan masalah daya karena peningkatan penggunaan GPU oleh Android Compositor, yang biasanya berjalan pada frekuensi yang dikuatkan. 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):

• Secara rutin menggantikan pekerjaan aplikasi, sehingga menyebabkan hit 1-3 md ke frametime, dan

• Meningkatkan tekanan pada memori verteks/tekstur GPU, karena Compositor harus membaca seluruh framebuffer untuk melakukan tugas 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 pada kasus sebelumnya, Anda harus menerapkan 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.

Sangat penting untuk mengetahui cara menyetel flag transformasi platform untuk setiap aplikasi Vulkan. Aplikasi cenderung mendukung beberapa orientasi atau mendukung satu orientasi dengan platform render berada dalam orientasi lain yang dipertimbangkan oleh objek perangkat sebagai orientasi identitasnya. 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">

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

Catatan: Untuk mempelajari perubahan konfigurasi lebih lanjut, cara membatasi pembuatan ulang Aktivitas jika diperlukan, dan cara menanggapi perubahan konfigurasi tersebut dari sistem View dan Jetpack Compose, lihat halaman Menangani perubahan konfigurasi.

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 terbaik untuk memperoleh ini adalah dengan melakukan panggilan ke vkGetPhysicalDeviceSurfaceCapabilitiesKHR() saat memulai aplikasi, dan menyimpan extent yang ditampilkan. Ganti 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, diperlukan implementasi yang berbeda, karena VK_SUBOPTIMAL_KHR tidak didukung.

Menggunakan Polling

Di perangkat pra-Android 10, Anda dapat mengkueri perubahan perangkat saat ini setiap frame pollingInterval, 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 kompositor Android harus melakukan flip untuk 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 instance Framebuffer dan ImageView yang ada,

2. Buat ulang swapchain saat menghancurkan swapchain lama (yang akan dibahas berikutnya), dan

3. Buat ulang Framebuffer dengan DisplayImages swapchain baru. Catatan: Gambar lampiran (misalnya, gambar kedalaman/stensil) biasanya tidak perlu dibuat ulang karena gambar tersebut 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.

Catatan: Kolom surfaceCapabilities.currentTransform dan kolom swapchainCreateInfo.preTransform harus cocok karena dengan begitu Android dapat mengetahui bahwa kami menangani sendiri perubahan orientasi untuk menghindari Compositor Android.

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 scissor, 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 bahwa selama pembuatan atau pembuatan ulang swapchain, flag pra-transformasi ditetapkan agar cocok dengan flag yang ditampilkan oleh sistem operasi Android. Tindakan ini akan menghindari overhead kompositor.
• Ukuran swapchain harus tetap sesuai dengan resolusi identitas platform jendela aplikasi dalam orientasi alami layar.
• Memutar matriks MVP di ruang klip untuk memperhitungkan orientasi perangkat, karena resolusi/extent swapchain tidak lagi diperbarui dengan orientasi layar.
• Perbarui persegi panjang area pandang dan gunting sesuai kebutuhan aplikasi Anda.

Contoh Aplikasi: Pra-rotasi minimal Android