เครื่องมือแบบเนทีฟและที่เป็นกรรมสิทธิ์

เริ่มต้นใช้งาน Vulkan บน Android

Vulkan เป็น API กราฟิกระดับต่ำหลักใน Android Vulkan มอบประสิทธิภาพสูงสุดสำหรับเกมที่ใช้เกมเอนจินและโปรแกรมแสดงผลของตนเอง

หากต้องการใช้ Vulkan ในเกมเอนจินให้สำเร็จ คุณต้องทำดังนี้

• ระบุอุปกรณ์ Android ที่จะใช้กับ Vulkan
• ทำความเข้าใจข้อดีข้อเสียของการรองรับอุปกรณ์ Android รุ่นเก่า
• เพิ่ม Vulkan ลงในเป้าหมายบิลด์ Android
• เลือกคอมไพเลอร์ Shader เพื่อสร้าง SPIR-V สำหรับ Vulkan
• กำหนดเวอร์ชัน Vulkan API ที่พร้อมใช้งานที่รันไทม์
• ดูวิธีเพิ่มประสิทธิภาพการดำเนินการแสดงผล Vulkan ด้วยโปรไฟล์ Vulkan, การกำหนดอัตราเฟรม และการหมุนล่วงหน้า
• เลือกเครื่องมือกราฟิกสำหรับการแก้ไขข้อบกพร่องและการวิเคราะห์ประสิทธิภาพ

หมายเหตุ: ดูข้อมูลเกี่ยวกับการใช้ Vulkan ใน Android กับเกมเอนจิน Unity หรือ Unreal ได้ที่หัวข้อต่อไปนี้
• Vulkan ใน Unity
• Vulkan ใน Unreal

เลือกข้อกำหนดขั้นต่ำของอุปกรณ์สำหรับ Vulkan

Vulkan พร้อมใช้งานใน Android ตั้งแต่ Android 7.0 (API ระดับ 24) เป็นต้นไป อุปกรณ์ Android บางรุ่นที่ใช้ Android 7.0 ขึ้นไปไม่รองรับ Vulkan คุณต้องพิจารณาว่าเกมของคุณรองรับอุปกรณ์ Android ที่รองรับ Vulkan รุ่นใดบ้าง

คำแนะนำ

ใช้ข้อกำหนดต่อไปนี้เป็นข้อกำหนดขั้นต่ำสำหรับการรองรับ Vulkan

• อุปกรณ์ใช้ Android 10.0 (ระดับ API 29) ขึ้นไป
• อุปกรณ์รองรับ Vulkan API เวอร์ชัน 1.1 ขึ้นไป
• อุปกรณ์มีความสามารถและฟีเจอร์ของฮาร์ดแวร์ที่เข้ากันได้กับโปรไฟล์พื้นฐานของ Android ปี 2022

หมายเหตุ: อุปกรณ์ Android 64 บิตใหม่ต้องรองรับ Vulkan 1.1 ตั้งแต่ Android 10.0 เป็นต้นไป นอกจากนี้ โปรไฟล์พื้นฐานของ Android ปี 2022 ยังกำหนดเวอร์ชัน Vulkan API ขั้นต่ำเป็น 1.1 ด้วย อุปกรณ์ที่รองรับ Vulkan 1.1 ส่วนใหญ่ (แต่ไม่ใช่ทั้งหมด) จะเข้ากันได้กับโปรไฟล์ Android Baseline ปี 2022 ดูสถิติความเข้ากันได้ได้ที่แดชบอร์ดการเผยแพร่

การรองรับอุปกรณ์รุ่นเก่า

หากเกมของคุณออกแบบมาให้ทำงานบนอุปกรณ์หลากหลายประเภทที่มีความสามารถด้านกราฟิกในระดับต่างๆ คุณอาจต้องรองรับอุปกรณ์ที่เก่ากว่าที่แนะนำในหัวข้อเลือกข้อกำหนดขั้นต่ำของอุปกรณ์สำหรับ Vulkan ก่อนที่จะสร้างการรองรับอุปกรณ์รุ่นเก่า ให้ประเมินว่า Vulkan มีประโยชน์ต่อเกมของคุณหรือไม่ เกมที่มีคำสั่งประมวลผลจำนวนมากและใช้ OpenGL ES อาจพบโอเวอร์เฮดของไดรเวอร์จำนวนมากเนื่องจากต้นทุนที่สูงในการสร้างคำสั่งประมวลผลภายใน OpenGL ES เกมเหล่านี้อาจถูกจำกัดด้วย CPU จากการใช้เวลาที่ใช้ในการแสดงผลเฟรมส่วนใหญ่ในไดรเวอร์กราฟิก นอกจากนี้ เกมยังลดการใช้ CPU และพลังงานได้อย่างมากด้วยการเปลี่ยนจาก OpenGL ES เป็น Vulkan วิธีนี้ใช้ได้ผลเป็นพิเศษหากเกมมีฉากที่ซับซ้อนซึ่งไม่สามารถใช้การสร้างอินสแตนซ์เพื่อลดคำสั่งประมวลผลได้อย่างมีประสิทธิภาพ เมื่อกำหนดเป้าหมายเป็นอุปกรณ์รุ่นเก่า ให้รวมการรองรับการแสดงผล OpenGL ES เป็นทางเลือกสำรอง เนื่องจากอุปกรณ์บางเครื่องในรายการอุปกรณ์เป้าหมายอาจมีการติดตั้งใช้งาน Vulkan ที่ไม่สามารถเรียกใช้เกมได้อย่างเสถียร

คุณอาจไม่ต้องการรองรับอุปกรณ์รุ่นเก่าที่รองรับ Vulkan เนื่องจากอุปกรณ์เหล่านั้นมีประสิทธิภาพและฟีเจอร์ไม่เพียงพอ หรือมีปัญหาด้านความเสถียร

ประสิทธิภาพและฟีเจอร์

อุปกรณ์ Android รุ่นเก่าที่รองรับ Vulkan อาจไม่มีประสิทธิภาพการแสดงผลหรือการรองรับฮาร์ดแวร์สำหรับฟีเจอร์ที่จำเป็นต่อการรันเกม กรณีนี้มีแนวโน้มที่จะเกิดขึ้นหากเกมของคุณมีกราฟิกความละเอียดสูงและ Vulkan เป็น API เดียวที่คุณกำหนดเป้าหมายใน Android อุปกรณ์รุ่นเก่าจำนวนมากถูกจำกัดให้ใช้ Vulkan API เวอร์ชัน 1.0.3 และมักไม่มีส่วนขยาย Vulkan ที่ใช้กันอย่างแพร่หลายซึ่งมีอยู่ในฮาร์ดแวร์ที่ทันสมัยกว่า

ความเสถียร

อุปกรณ์ Android รุ่นเก่าอาจใช้ไดรเวอร์ Vulkan ที่ล้าสมัย ไดรเวอร์เวอร์ชันเหล่านี้อาจมีข้อบกพร่องที่ส่งผลต่อความเสถียรของเกม การแก้ไขข้อบกพร่องของไดรเวอร์อาจต้องใช้เวลาในการทดสอบและวิศวกรรมเป็นจำนวนมาก

เพิ่ม Vulkan ลงในโปรเจ็กต์

หากต้องการเพิ่ม Vulkan ลงในโปรเจ็กต์ คุณต้องทำดังนี้

• รวมส่วนหัว Vulkan API
• คอมไพล์โค้ด Shader เป็น SPIR-V
• เรียก Vulkan API ขณะรันไทม์

รวมส่วนหัว Vulkan API

เกมของคุณต้องมีไฟล์ส่วนหัวของ Vulkan API เพื่อคอมไพล์โค้ดที่ใช้ Vulkan คุณดูสำเนาของส่วนหัว Vulkan ได้ใน Android NDK หรือที่รวมอยู่ในรุ่น Vulkan SDK NDK เวอร์ชันใดก็ตามจะมีเฉพาะส่วนหัว Vulkan ที่พร้อมใช้งาน ณ เวลาที่เปิดตัว NDK เท่านั้น หากคุณใช้ส่วนหัว Vulkan จาก NDK ให้ใช้ NDK เวอร์ชัน 25 ขึ้นไป ซึ่งมีไฟล์ส่วนหัวที่รองรับ Vulkan เวอร์ชัน 1.3 Vulkan SDK มีส่วนหัวเวอร์ชันล่าสุด

คอมไพล์โค้ด Shader เป็น SPIR-V

Vulkan API คาดหวังให้โปรแกรม Shader อยู่ในรูปแบบสื่อกลางไบนารี SPIR-V ซึ่งแตกต่างจาก OpenGL ES ที่คุณสามารถส่งซอร์สโค้ดที่เขียนด้วย OpenGL Shading Language (GLSL) เป็นสตริงข้อความได้ ใช้คอมไพเลอร์ตัวปรับเฉดสีเพื่อนำโค้ดที่เขียนในภาษาตัวปรับเฉดสี เช่น GLSL หรือ High-level Shader Language (HLSL) และคอมไพล์เป็นโมดูล SPIR-V เพื่อใช้กับ Vulkan

คุณสามารถใช้คอมไพเลอร์ shaderc เพื่อคอมไพล์โปรแกรมเฉดสีที่เขียนใน GLSL เป็น SPIR-V ได้ หากเกมของคุณใช้ HLSL DirectXShaderCompiler จะรองรับเอาต์พุต SPIR-V โดยปกติแล้ว คุณจะคอมไพล์โปรแกรมเฉดเดอร์แบบออฟไลน์เป็นส่วนหนึ่งของกระบวนการสร้างชิ้นงานสำหรับเกม และรวมโมดูล SPIR-V ไว้เป็นส่วนหนึ่งของชิ้นงานรันไทม์

เรียก Vulkan API ขณะรันไทม์

หากต้องการเรียกใช้ Vulkan API เกมของคุณต้องได้รับตัวชี้ฟังก์ชันไปยังการเรียก Vulkan API วิธีที่ตรงไปตรงมาที่สุดคือการลิงก์กับไลบรารีที่ใช้ร่วมกัน libvulkan.so ซึ่งรวมอยู่ใน Android NDK การลิงก์กับไลบรารีมีข้อเสีย 2 ประการ ได้แก่ ค่าใช้จ่ายเพิ่มเติมในการส่งฟังก์ชันและข้อจำกัดเกี่ยวกับตัวชี้ฟังก์ชัน Vulkan API ที่ได้รับการแก้ไขโดยอัตโนมัติ

เมื่อคุณเรียกใช้ฟังก์ชัน Vulkan API ระบบจะส่งผ่านการควบคุมผ่านตารางการส่งที่จัดการโดยโครงสร้างที่เรียกว่า Vulkan Loader Android ใช้การติดตั้งใช้งาน Vulkan loader ของตัวเอง ไม่ใช่ LunarG loader ระบบตัวโหลดนี้เป็นส่วนหนึ่งของสถาปัตยกรรมเลเยอร์ของ Vulkan API การลิงก์ไปยังไลบรารีของระบบ ณ เวลาที่สร้างจะส่งผลให้มีระดับการส่งเพิ่มเติมสำหรับการเรียก API หนึ่งๆ แม้ว่าค่าใช้จ่ายเพิ่มเติมจะน้อย แต่ก็อาจสังเกตเห็นได้สำหรับเกมที่เรียกใช้ Vulkan จำนวนมาก

โดยทั่วไปแล้ว ไลบรารีระบบจะแก้ไขเฉพาะพอยเตอร์ไปยังฟังก์ชัน Vulkan ที่ถือว่าเป็นส่วนหนึ่งของ Core API Vulkan มีส่วนขยายจำนวนมากซึ่งกำหนดฟังก์ชัน Vulkan เพิ่มเติม โดยส่วนใหญ่ไลบรารีของระบบจะไม่แก้ไขโดยอัตโนมัติ คุณต้องแก้ไขพอยน์เตอร์ไปยังฟังก์ชัน Vulkan เหล่านี้ด้วยตนเองก่อนใช้งาน

เพื่อลดปัญหาเหล่านี้ ให้แก้ไขพอยน์เตอร์ไปยังฟังก์ชัน Vulkan ทั้งหมดที่คุณต้องการใช้ขณะรันไทม์แบบไดนามิก วิธีหนึ่งในการดำเนินการนี้คือการใช้ไลบรารี Meta-Loader แบบโอเพนซอร์ส เช่น volk เกมตัวอย่าง AGDKTunnel ผสานรวม volk เพื่อวัตถุประสงค์นี้ หากคุณใช้ไลบรารี Meta-loader อย่าลิงก์กับคลังที่ใช้ร่วมกัน libvulkan.so ในสคริปต์บิลด์

ระบุเวอร์ชัน Vulkan API ที่พร้อมใช้งาน

Android รองรับ Vulkan API เวอร์ชันต่อไปนี้

• 1.0.3
• 1.1
• 1.3

หมายเลขเวอร์ชัน Vulkan API สูงสุดที่ใช้ได้ในอุปกรณ์หนึ่งๆ จะกำหนดโดยเวอร์ชัน Android และการรองรับไดรเวอร์ Vulkan

เวอร์ชัน Android

การรองรับแพลตฟอร์มสำหรับเวอร์ชัน Vulkan API ขึ้นอยู่กับเวอร์ชัน Android ขั้นต่ำ (ระดับ API) ดังนี้

• 1.3 — Android 13.0 (ระดับ API 33) ขึ้นไป
• 1.1 — Android 10.0 (ระดับ API 29) ขึ้นไป
• 1.0.3 — Android 7.0 (ระดับ API 24) ขึ้นไป

การรองรับไดรเวอร์ Vulkan

การรองรับเวอร์ชัน Vulkan API ของแพลตฟอร์ม Android ไม่ได้รับประกันว่าไดรเวอร์ Vulkan ของอุปกรณ์จะรองรับ API เวอร์ชันดังกล่าว อุปกรณ์ที่ใช้ Android 13 อาจรองรับเฉพาะ Vulkan API เวอร์ชัน 1.1

เมื่อเริ่มต้น Vulkan อย่าขอ API เวอร์ชันที่สูงกว่า:

• เวอร์ชัน Vulkan API สูงสุดสำหรับเวอร์ชัน Android ที่ทำงานบนอุปกรณ์
• เวอร์ชัน Vulkan API ที่รายงานโดย vkEnumerateInstanceVersion
• เวอร์ชัน Vulkan API ที่รายงานโดยพร็อพเพอร์ตี้ apiVersion ของโครงสร้าง VkPhysicalDeviceProperties

ตัวอย่างการระบุเวอร์ชัน Vulkan API สูงสุดที่รองรับมีดังนี้

// Minimum Android API levels for Vulkan 1.3/1.1 version support
static constexpr int kMinimum_vk13_api_level = 33;
static constexpr int kMinimum_vk11_api_level = 29;

uint32_t GetHighestSupportedVulkanVersion(VkPhysicalDevice physical_device) {
  uint32_t instance_api_version = 0;
  vkEnumerateInstanceVersion(&instance_api_version);

  VkPhysicalDeviceProperties device_properties;
  vkGetPhysicalDeviceProperties(physical_device, &device_properties);

  // Instance and device versions don't have to match, use the lowest version
  // number for API support if they don't.
  const uint32_t driver_api_version =
      (instance_api_version < device_properties.apiVersion) ?
      instance_api_version : device_properties.apiVersion;

  const int device_api_level = android_get_device_api_level();
  if (device_api_level >= kMinimum_vk13_api_level &&
      driver_api_version >= VK_API_VERSION_1_3) {
    return VK_API_VERSION_1_3;
  } else if (device_api_level >= kMinimum_vk11_api_level &&
             driver_api_version >= VK_API_VERSION_1_1) {
    return VK_API_VERSION_1_1;
  }
  return VK_API_VERSION_1_0;
}

ตรวจสอบความเข้ากันได้ของโปรไฟล์ Vulkan

โปรไฟล์ Vulkan คือไฟล์ JSON ที่กำหนดชุดฟีเจอร์ ส่วนขยาย ความสามารถ และขีดจำกัดพารามิเตอร์ขั้นต่ำที่จำเป็นซึ่งอุปกรณ์ Vulkan ต้องรองรับเพื่อให้เข้ากันได้กับโปรไฟล์ หากต้องการตรวจสอบว่าอุปกรณ์เข้ากันได้กับโปรไฟล์ Vulkan ที่เฉพาะเจาะจงหรือไม่ เช่น โปรไฟล์พื้นฐานของ Android ปี 2022 ให้ใช้ไลบรารี Vulkan Profiles API แบบโอเพนซอร์ส นอกจากนี้ คุณยังแยกวิเคราะห์ไฟล์ JSON ของโปรไฟล์ด้วยตนเองและค้นหาความสามารถของอุปกรณ์โดยใช้ Vulkan API ที่เกี่ยวข้องเพื่อพิจารณาความเข้ากันได้ของโปรไฟล์ได้ด้วย

โปรไฟล์ Vulkan

Android ใช้ Vulkan Profiles ซึ่งกำหนดฟีเจอร์และส่วนขยายที่พร้อมใช้งานสำหรับอุปกรณ์แต่ละเครื่องที่ใช้ Android

Android Baseline Profile (ABP) เป็นความพยายามครั้งแรกในการสร้างโปรไฟล์ Vulkan ABP2021 และ ABP2022 เป็นโปรไฟล์ที่มองย้อนกลับไปซึ่งมีเป้าหมายเพื่อครอบคลุมอุปกรณ์ที่ใช้งานอยู่มากกว่า 85% ในขณะนั้น จะไม่มี ABP ใหม่ในอนาคต

Vulkan Profiles for Android (VPA) เป็นโปรไฟล์ใหม่ที่มองการณ์ไกลซึ่งมีจุดมุ่งหมายเพื่อตอบสนองความต้องการของนักพัฒนาซอฟต์แวร์และขับเคลื่อนฟีเจอร์ที่สอดคล้องกันทันทีที่นักพัฒนาฮาร์ดแวร์สามารถนำเสนอได้ VPA15_minimums เป็นโปรไฟล์แรกสำหรับ Android 15 และจะมี VPA ใหม่ทุกปีเพื่อครอบคลุม Android เวอร์ชันหลักแต่ละเวอร์ชัน

ใช้การกำหนดอัตราเฟรม

การกำหนดอัตราเฟรมที่เหมาะสมเป็นส่วนสำคัญในการมอบประสบการณ์การเล่นเกมคุณภาพสูง Android Game Development Kit มีไลบรารี Frame Pacing เพื่อช่วยให้เกมของคุณมี Frame Pacing ที่เหมาะสมที่สุด ดูรายละเอียดเพิ่มเติมเกี่ยวกับการติดตั้งใช้งานได้ที่ผสานรวม Android Frame Pacing เข้ากับโปรแกรมแสดงผล Vulkan

อย่าพึ่งพาการซิงค์โดยนัยและจังหวะเฟรม

vkAcquireNextImageKHR และ vkQueuePresentKHR ใช้เพื่อจัดการ Swapchain หลีกเลี่ยงการพึ่งพาพฤติกรรมการบล็อกที่อาจเกิดขึ้นสำหรับการซิงค์แอปพลิเคชันทั่วไปหรือ GPU

ลักษณะการบล็อกที่แน่นอนของฟังก์ชันเหล่านี้อาจแตกต่างกันอย่างมากในแต่ละกรณีต่อไปนี้

• อุปกรณ์ Android
• ไดรเวอร์ GPU
• สถานะเครื่องมือการนำเสนอ (VkPresentModeKHR)

วัตถุประสงค์เดียวของ vkAcquireNextImageKHR คือการรับรูปภาพที่แสดงได้ซึ่งพร้อมใช้งาน และอาจบล็อกหรือไม่บล็อกก็ได้ ในทำนองเดียวกัน vkQueuePresentKHR จะจัดคิวคำขอเพื่อแสดงรูปภาพ และอาจบล็อกหรือไม่บล็อกก็ได้

ทั้ง 2 ฟังก์ชันไม่ได้ให้การรับประกันที่เชื่อถือได้สำหรับการซิงค์งาน CPU หรือการดำเนินการ GPU ที่ไม่เกี่ยวข้อง

เพื่อการซิงค์ที่มีประสิทธิภาพ ให้ใช้ Vulkan Primitive ที่ชัดเจนเสมอ เช่น เซมาฟอร์สำหรับทรัพยากร Dependency ของ GPU-GPU (เช่น การแสดงผลเพื่อนำเสนอ) เฟนซ์สำหรับการซิงค์ GPU-CPU (เช่น การทราบเมื่อการแสดงผลเสร็จสิ้นใน CPU) และไปป์ไลน์แบริเออร์หรือเหตุการณ์สำหรับการดำเนินการ GPU และทรัพยากร Dependency ของหน่วยความจำที่ละเอียดยิ่งขึ้น การใช้การซิงค์ที่ชัดเจนช่วยให้มั่นใจได้ว่าลักษณะการทำงานจะคาดการณ์ได้ และหลีกเลี่ยงข้อบกพร่องเล็กๆ น้อยๆ ที่เกิดจากความผันแปรของเวลาที่เฉพาะเจาะจงสำหรับการติดตั้งใช้งาน ซึ่งมีอยู่ในระบบนิเวศฮาร์ดแวร์ที่หลากหลายของ Android

ใช้การหมุนล่วงหน้า

อุปกรณ์ Android สามารถแสดงผลได้หลายแนว การวางแนวอุปกรณ์อาจแตกต่างจากการวางแนวของพื้นผิวการแสดงผล Vulkan ไม่จัดการความคลาดเคลื่อนระหว่างทั้ง 2 อย่างนี้ ซึ่งต่างจาก OpenGL ES บน Android หากต้องการทำความเข้าใจวิธีการทำงานของกระบวนการปรับการวางแนวและวิธีที่เหมาะสมที่สุดในการจัดการความแตกต่างของการวางแนวเมื่อใช้ Vulkan โปรดดูจัดการการหมุนอุปกรณ์ด้วยการหมุนล่วงหน้าของ Vulkan

แก้ปัญหาและทำโปรไฟล์การแสดงผล Vulkan

มีเครื่องมือหลายอย่างที่ช่วยคุณวิเคราะห์ปัญหาการแสดงผลและปัญหาด้านประสิทธิภาพเกี่ยวกับโค้ดการแสดงผล Vulkan ได้

ดูข้อมูลเพิ่มเติมเกี่ยวกับเครื่องมือแก้ไขข้อบกพร่องและการทำโปรไฟล์ของ Vulkan ได้ที่ส่วนเครื่องมือและฟีเจอร์ขั้นสูง

ชั้นการตรวจสอบ Vulkan

ชั้นการตรวจสอบ Vulkan เป็นไลบรารีรันไทม์ที่เปิดใช้เพื่อตรวจสอบการเรียกใช้ Vulkan API และแสดงคำเตือนหรือข้อผิดพลาดเกี่ยวกับการใช้งานที่ไม่ถูกต้องหรือไม่เหมาะสม ชั้นการตรวจสอบเหล่านี้ไม่ได้ทำงานโดยค่าเริ่มต้น เนื่องจากกระบวนการตรวจสอบจะเพิ่มโอเวอร์เฮดของรันไทม์และส่งผลต่อประสิทธิภาพของเกม ดูข้อมูลเกี่ยวกับวิธีใช้ชั้นการตรวจสอบกับเกมได้ที่การแก้ไขข้อบกพร่องด้วยชั้นการตรวจสอบ

หมายเหตุ: ผู้ให้บริการ GPU บางรายมีไลบรารีชั้นการตรวจสอบที่เฉพาะเจาะจงสำหรับ GPU ของตน นอกเหนือจากชั้นการตรวจสอบ Vulkan มาตรฐาน ใช้ชั้นการตรวจสอบเฉพาะ GPU เพื่อรับความคิดเห็นที่ตรงเป้าหมายเกี่ยวกับ GPU ที่เฉพาะเจาะจง เลเยอร์เหล่านี้สามารถดาวน์โหลดได้จากเว็บไซต์นักพัฒนาซอฟต์แวร์ของผู้ให้บริการ GPU

เครื่องมือจับภาพเฟรม

ใช้เครื่องมือจับภาพเฟรมเพื่อบันทึกและเล่นการเรียก Vulkan API ซ้ำระหว่างเฟรมเกม เครื่องมือเหล่านี้ช่วยให้คุณทำสิ่งต่อไปนี้ได้

• ดูข้อมูลและการแสดงภาพของทรัพยากรกราฟิกที่ใช้งานอยู่
• ดูลำดับการเรียก API ที่เกมของคุณทำและดูพารามิเตอร์ API
• สำรวจสถานะของไปป์ไลน์กราฟิก ณ เวลาที่มีคำสั่งประมวลผล
• แสดงผลลัพธ์ของการแสดงผลจนถึงคำสั่งประมวลผลที่เฉพาะเจาะจงในเฟรม

ใช้เครื่องมือ RenderDoc แบบโอเพนซอร์สเพื่อจับภาพเฟรมจากเกมที่ทำงานบน Android RenderDoc รองรับการจับภาพเฟรมของทั้ง Vulkan และ OpenGL ES

นอกจากนี้ คุณยังใช้ Android GPU Inspector (AGI) เพื่อจับภาพเฟรม Vulkan ได้ด้วย

เครื่องมือวิเคราะห์ประสิทธิภาพ

ใช้เครื่องมือวิเคราะห์ประสิทธิภาพเพื่อตรวจสอบปัญหาการแสดงผลในเกมที่ทำให้อัตราเฟรมต่ำกว่ามาตรฐาน ผู้ให้บริการ GPU แต่ละรายมีเครื่องมือที่ออกแบบมาเพื่อสร้างโปรไฟล์เกมและให้ข้อมูลประสิทธิภาพที่เจาะจงสำหรับสถาปัตยกรรม GPU ของตน ลักษณะประสิทธิภาพและคอขวดของเกมอาจแตกต่างกันอย่างมากเมื่อแสดงผลใน GPU จากผู้ให้บริการรายต่างๆ หรือแม้แต่ใน GPU รุ่นต่างๆ จากผู้ให้บริการรายเดียวกัน

นอกจากนี้ คุณยังใช้ Android GPU Inspector เพื่อรวบรวมและวิเคราะห์ข้อมูลประสิทธิภาพได้ด้วย Android GPU Inspector ต่างจากเครื่องมือของผู้ให้บริการตรงที่ใช้ได้กับ GPU หลายตัวจากผู้ให้บริการหลายราย อย่างไรก็ตาม Android GPU Inspector ไม่รองรับอุปกรณ์ Android รุ่นเก่าและอาจใช้ร่วมกับอุปกรณ์ใหม่บางรุ่นไม่ได้

ปรับปรุงการทดสอบ Vulkan ด้วย CTS-D

ผู้ผลิตอุปกรณ์ที่ใช้ Android ใช้ชุดเครื่องมือทดสอบความเข้ากันได้ (CTS) เพื่อช่วยตรวจสอบว่าอุปกรณ์ของตนเข้ากันได้ CTS ที่ขับเคลื่อนโดยนักพัฒนาแอป (CTS-D) คือการทดสอบที่ส่งโดยนักพัฒนาแอปพลิเคชัน Android เพื่อให้มั่นใจว่าอุปกรณ์ Android ในอนาคตจะตอบสนอง Use Case ของตน และสามารถเรียกใช้แอปพลิเคชันได้อย่างราบรื่นและไม่มีข้อบกพร่อง

หากคุณพบข้อบกพร่องใหม่ในแอปพลิเคชัน Vulkan ซึ่งส่งผลต่ออุปกรณ์ที่ทำงานด้วยระบบ Android บางรุ่น คุณสามารถส่งข้อเสนอการทดสอบใหม่ที่อธิบายปัญหาและวิธีตรวจสอบได้ ซึ่งจะช่วยให้มั่นใจได้ว่าปัญหาจะได้รับการแก้ไขในการอัปเดตอุปกรณ์ในอนาคต และยังช่วยให้มั่นใจได้ว่าข้อบกพร่องเดียวกันนี้จะไม่เกิดขึ้นกับอุปกรณ์อื่นๆ

ดูกระบวนการส่ง CTS เพื่อดูวิธีการทีละขั้นตอนในการส่งข้อเสนอการทดสอบ