Vulkan — ano ito, cross-platform API at rendering

Ano ang Vulkan?

Vulkan — ay isang mababang antas, cross-platform API para sa pagtatrabaho sa graphics processors, unang inilabas ng Khronos Group noong 2016. Pinalitan ng Vulkan ang OpenGL, nag-aalok ng mas mababang CPU overhead, predictable na performance at kakayahang multi-threaded command generation.

Hindi tulad ng OpenGL, kung saan ang driver ay nagsasagawa ng mga pagsusuri at synchronisation sa CPU, inililipat ng Vulkan ang pamamahala ng resources sa developer. Paglalaan ng memory, synchronisation sa pamamagitan ng semaphores at barriers, paggawa ng pipelines — lahat ay kinokontrol nang explicit. Ang approach na ito ay nagbibigay ng pagtaas ng performance hanggang 50% sa CPU-bound scenarios.

Ang Vulkan ay sinusuportahan sa Windows, Linux, Android, iOS (sa pamamagitan ng MoltenVK), macOS (MoltenVK), Nintendo Switch at consoles. Ayon sa datos ng Khronos Group (2026), gumagana ang API sa mga device na may GPU mula sa NVIDIA, AMD, Intel, Qualcomm (Adreno), ARM (Mali) at Apple (sa pamamagitan ng Metal layer). Nagdagdag ang Vulkan 1.4 (2026) ng suporta para sa Mesh Shaders at Video Encode API.

Kasaysayan ng Vulkan

Sa una, ang Vulkan ay binuo sa ilalim ng code name na “glNext” — ang kahalili ng OpenGL. Ang Vulkan 1.0 (2016) ay nagbigay ng pangunahing API na may explicit memory management, SPIR-V shaders at multi-threaded queues. Ang Vulkan 1.1 (2018) ay nagdagdag ng Subgroup Operations at suporta para sa 16-bit types. Ang Vulkan 1.2 (2020) ay nagpakilala ng Buffer Device Address at Timeline Semaphores.

Ang Vulkan 1.3 (2022) ay nag-standardize ng Dynamic Rendering at Graphics Pipeline Library. Vulkan 1.4 (2026) ay ginawang mandatory ang suporta para sa Mesh Shaders at nagdagdag ng Video Encode/Decode API para sa hardware encoding ng H.264/HEVC/AV1. Ayon sa datos ng Khronos (2026), ang Vulkan 1.4 ay sinusuportahan sa lahat ng bagong GPU NVIDIA RTX 50xx, AMD RX 9000 at Intel Arc B-series.

Arkitektura ng Vulkan: device at queues

Arkitektura ng Vulkan ay binuo sa isang hardware abstraction layer (HW layer). Ang application ay nakikipag-interact sa physical device (VkPhysicalDevice) sa pamamagitan ng logical device (VkDevice). Ang mga command ay ipinapadala sa queues (VkQueue), bawat isa ay kabilang sa isang partikular na queue family (graphics, compute, transfer).

VkInstance, VkDevice at VkQueue

VkInstance — ang root object ng Vulkan, na nag-iimbak ng impormasyon tungkol sa validation layers at extensions. VkPhysicalDevice ay kumakatawan sa physical GPU at nagpapahintulot na mag-query ng mga property nito, memory heaps at queue families. VkDevice — logical device na may explicit na hiniling na queues at extensions.

// Paglikha ng logical Vulkan device
VkDeviceCreateInfo devInfo {};
devInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
devInfo.queueCreateInfoCount = 1;
 
float queuePriority = 1.0f;
VkDeviceQueueCreateInfo queueInfo {};
queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueInfo.queueFamilyIndex = 0;
queueInfo.queueCount = 1;
queueInfo.pQueuePriorities = &queuePriority;
devInfo.pQueueCreateInfos = &queueInfo;
 
VkDevice device;
vkCreateDevice(physicalDevice, &devInfo,
    nullptr, &device);
 
VkQueue queue;
vkGetDeviceQueue(device, 0, 0, &queue);

Ang function na vkCreateDevice ay gumagawa ng logical device na may tinukoy na queues. VkQueue — isang descriptor ng queue para sa pagpapadala ng commands. Isang queue ay maaaring gamitin para sa graphics, computations at copying, kung ang mga kaukulang flag ay sinusuportahan ng queue family. Ang priority ng queue (0.0–1.0) ay nakakaapekto sa pagkakasunod-sunod ng execution kapag may kompetisyon.

VkMemory at VkBuffer — pamamahala ng memory

Sa Vulkan, ang memory ay inilalaan nang explicit sa pamamagitan ng VkDeviceMemory. Ang developer ay humihingi ng memory types (HOST_VISIBLE, DEVICE_LOCAL) sa physical device at naglalaan ng blocks. Ang mga buffer (VkBuffer) at textures (VkImage) ay walang sariling memory — sila ay nakatali sa mga inilaan na blocks sa pamamagitan ng vkBindBufferMemory.

Vulkan Memory Allocator (VMA) — isang library mula sa AMD na nagpapasimple ng pamamahala ng memory. Ang VMA ay awtomatikong nag-grupo ng maliliit na alokasyon sa malalaking blocks, namamahala ng defragmentation at pumipili ng angkop na memory type. Ayon sa datos ng AMD (2025), binabawasan ng VMA ang bilang ng memory allocations ng 50–100 beses kumpara sa manual management.

VkCommandPool at VkCommandBuffer

VkCommandPool ay namamahala ng memory para sa command buffers. Ang mga buffer (VkCommandBuffer) ay isinusulat sa CPU at ipinapadala sa GPU sa pamamagitan ng vkQueueSubmit. Sinusuportahan ng Vulkan ang primary at secondary buffers: primary ay direktang ipinapadala, secondary ay maaaring tawagin mula sa primary para sa multi-threaded command construction.

Ang pagsulat ng commands ay nagsisimula sa vkBeginCommandBuffer at nagtatapos sa vkEndCommandBuffer. Sa pagitan ng mga ito, isinusulat ang rendering commands: vkCmdDraw, vkCmdDispatch, vkCmdCopyBuffer at vkCmdPipelineBarrier para sa synchronisation. Para sa bawat frame, isang bagong command buffer ay ginagawa na may pool reset.

Rendering sa pamamagitan ng Vulkan: pipeline at commands

Rendering sa Vulkan ay organisado sa pamamagitan ng pipelines (VkPipeline). Hindi tulad ng OpenGL, kung saan ang pipeline state ay nagbabago nang global, ang Vulkan ay gumagamit ng VkPipeline — isang pre-compiled pipeline na sumasaklaw sa lahat ng stages: vertex input, shaders, rasterization, depth-stencil at blending.

VkPipeline — rendering pipeline

VkGraphicsPipelineCreateInfo ay naglalarawan ng kumpletong pipeline: vertex at fragment shaders, topology (triangle list, triangle strip), rasterizer (fill mode, cull mode), multisampling, depth-stencil tests, blending at viewport settings. Ang pipeline ay ginagawa nang isang beses at ginagamit muli — ang pagbabago ng state ay nangangailangan ng bagong pipeline o dynamic state.

// Configuration ng graphics pipeline
VkGraphicsPipelineCreateInfo pipelineInfo {};
pipelineInfo.sType =
    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipelineInfo.stageCount = 2;
pipelineInfo.pStages = shaderStages;
pipelineInfo.pVertexInputState =&;
    vertexInputState;
pipelineInfo.pRasterizationState =&;
    rasterState;
 
VkPipeline graphicsPipeline;
vkCreateGraphicsPipelines(device,
    VK_NULL_HANDLE, 1, &pipelineInfo,
    nullptr, &graphicsPipeline);

Ang Dynamic State (VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR) ay nagpapahintulot na baguhin ang mga partikular na parameter nang hindi gumagawa ng bagong pipeline. Ginawang mandatory ng Vulkan 1.4 ang suporta para sa Dynamic State 3 (VK_EXT_extended_dynamic_state_3) para sa pamamahala ng blend constants, depth bias at topology on the fly, na nagbabawas ng bilang ng pipelines sa proyekto.

Render Pass at Dynamic Rendering

VkRenderPass ay naglalarawan ng structure ng rendering passes: kung aling attachment ang ginagamit, kung paano sila nililinis at nilo-load. Ang Dynamic Rendering (VK_KHR_dynamic_rendering, mandatory mula Vulkan 1.4) ay nagpapasimple ng proseso: ang render pass ay ginagawa on the fly sa command buffer sa pamamagitan ng vkCmdBeginRendering, nang walang naunang VkRenderPass object.

Ayon sa datos ng Khronos (2026), ang Dynamic Rendering ay nagbabawas ng dami ng initialization code ng Vulkan ng 30–40% at nagpapababa ng bilang ng pipeline permutations. Para sa mga kumplikadong deferred rendering techniques (Deferred Shading), maginhawa pa ring gamitin ang klasikong VkRenderPass na may maraming subpasses para sa G-buffer at illumination.

Shaders sa Vulkan: SPIR-V at GLSL

SPIR-V — isang unibersal na binary shader format sa Vulkan, na binuo ng Khronos. Ang mga shader ay maaaring isulat sa GLSL, HLSL o Zink language at i-compile sa SPIR-V sa pamamagitan ng glslangValidator, dxc o Google Shaderc. Hindi tinatanggap ng Vulkan ang mga shader sa source code — binary SPIR-V lamang.

GLSL sa Vulkan

GLSL para sa Vulkan ay naiiba mula sa standard OpenGL GLSL. Ginagamit ang mga block (layout) na may explicit na pagtukoy ng set at binding numbers, hindi built-in variables. Ang vertex attributes ay tinutukoy sa pamamagitan ng location, uniforms — sa pamamagitan ng uniform blocks o buffers. Ang push constants (hanggang 128 bytes) ay available para sa mabilis na paglipat ng data nang walang buffers.

// Vertex shader Vulkan/GLSL
#version 460
 
layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inNormal;
 
layout(binding = 0, set = 0)
uniform UniformBufferObject {
    mat4 modelViewProjection;
} ubo;
 
layout(location = 0) out vec3 outNormal;
 
void main() {
    gl_Position = ubo.modelViewProjection *
        vec4(inPosition, 1.0);
    outNormal = inNormal;
}

Ang mga kwalipikador na layout(set = N, binding = M) — ang pangunahing pagkakaiba ng Vulkan GLSL mula sa OpenGL. Ang Set ay tumutugma sa descriptor set (VkDescriptorSet), binding — sa specific na resource (buffer, texture, sampler). Ang paghahati sa set ay nagpapahintulot ng mahusay na paglipat ng resource sets sa pagitan ng draw calls nang hindi nagbi-bind ng individual resources.

Descriptors at descriptor sets

VkDescriptorSet — isang grupo ng resources (buffers, textures, samplers) na nakatali sa shaders. Ang descriptor layout ay naglalarawan ng mga uri ng resources at kanilang binding numbers. Ang descriptor sets ay ina-update sa pamamagitan ng vkUpdateDescriptorSets at ginagamit muli sa pagitan ng draw calls. Sinusuportahan ng Vulkan 1.4 ang VK_EXT_descriptor_buffer para sa direktang access sa descriptors mula sa GPU.

Push Constants — isang mekanismo para sa mabilis na paglipat ng maliit na dami ng data (hanggang 128 bytes) sa shaders nang hindi gumagawa ng descriptors. Ang push constants ay tinutukoy sa pamamagitan ng vkCmdPushConstants sa command buffer. Ayon sa datos ng Khronos (2025), ang paggamit ng push constants sa halip na uniform buffers ay nagbabawas ng CPU overhead ng 10–15% sa frequency ng draw calls na higit sa 10 libo bawat frame.

Vulkan sa iba't ibang platform

Vulkan ay ang tanging API na gumagana sa lahat ng pangunahing platform: Windows (sa pamamagitan ng opisyal na ICD driver), Linux (RADV, AMDVLK, NVIDIA), Android (Vulkan 1.3+, mandatory mula Android 10) at sa Apple devices sa pamamagitan ng MoltenVK — ang translation layer Vulkan → Metal.

Vulkan sa Android

Sa Android, ang Vulkan ay mandatory para sa Android 10 at mas bago. Inirerekomenda ng Google ang Vulkan para sa mga bagong proyekto, lalo na sa mga high-performance games at AR applications sa pamamagitan ng ARCore. Ang Qualcomm Adreno at ARM Mali ay nagbibigay ng buong suporta para sa Vulkan 1.3 na may hardware ray tracing sa Adreno 8xx at Mali-G720.

Ayon sa datos ng Google (2026), 98% ng Android devices na may Android 10+ ay sumusuporta sa Vulkan. Para sa backward compatibility, available ang ANGLE (Almost Native Graphics Layer Engine), na nagta-translate ng OpenGL ES sa Vulkan. Ito ay nagpapahintulot na magpatakbo ng lumang OpenGL applications sa Vulkan driver na may pagtaas ng performance hanggang 20%.

Sa Android, ang Vulkan ay may mataas na priority para sa energy efficiency: ang Vulkan applications ay kumukonsumo ng 25–40% mas kaunting enerhiya kumpara sa OpenGL ES sa parehong graphics load sa mga device na may Adreno 7xx+. Ginagawa nitong ang Vulkan ang gustong API para sa mga laro sa mobile devices.

Vulkan sa Apple sa pamamagitan ng MoltenVK

MoltenVK — isang implementation ng Vulkan sa ibabaw ng Metal, na binuo ng LunarG at Valve. Isinasalin ng MoltenVK ang Vulkan API calls sa Metal, sumusuporta sa Vulkan 1.2 sa iOS at macOS. Ang performance ng MoltenVK ay malapit sa native Metal: ang translation overhead ay 5–15% depende sa scenario.

Ayon sa datos ng LunarG (2025), ang MoltenVK ay ginagamit sa CrossOver (Wine para sa Mac) para magpatakbo ng Windows games sa macOS. Ang Dota 2, Civilization VI at Baldur’s Gate 3 sa macOS ay tumatakbo sa pamamagitan ng MoltenVK na may performance na 30–60 FPS sa M3/M4. Sinusuportahan ng MoltenVK ang MetalFX upscaling para sa pagpapabuti ng performance.

Vulkan Ray Tracing

VK_KHR_ray_tracing — ang extension para sa hardware ray tracing sa Vulkan, mandatory mula Vulkan 1.4. Sinusuportahan sa GPU na may RT cores: NVIDIA RTX 20xx/30xx/40xx/50xx, AMD RX 6000+/9000, Intel Arc A/B. Ang Vulkan RT ay nagbibigay ng VkAccelerationStructure, VkRayTracingPipeline at Shader Binding Table.

Ang Vulkan Ray Tracing ay sumusuporta sa reflections, shadows, ambient occlusion at global illumination sa real-time. Ayon sa datos ng Khronos (2026), sa NVIDIA RTX 5090, ang Vulkan Ray Tracing ay nagsasagawa ng hanggang 100 Giga rays/s sa reference quality scenes. Para sa portable platforms, ang Vulkan RT ay naka-scale sa pamamagitan ng blur reduction at temporal denoising.