VulkanCompute
| English | 日本語 |
VulkanCompute is a minimal, compute-only Vulkan application written in Delphi (FireMonkey): an interactive Mandelbrot set renderer in which every pixel is evaluated by a GLSL compute shader on the GPU and colored through a 1D palette texture. The result is copied into a TBitmap and displayed on the form — no swapchain, no device context, no graphics pipeline at all.

利用ライブラリ
- LUX :The foundation math library of LUXOPHIA.
- LUX.Vulkan :A wrapper library for the Vulkan API.
1. Overview
- Compute-only Vulkan: the GPU is used purely as a parallel computer. The rendered image travels back to the host and is shown as an ordinary FMX bitmap.
- Runtime GLSL → SPIR-V compilation: the kernel (
_DATA/Execut.comp) is compiled at runtime by the bundled glslang DLL [4] — no offline step, no Vulkan SDK, no CMake. Edit the shader and restart the application. - SPIR-V reflection: shader bindings are discovered from the compiled binary, so host arguments are connected by name (
_Kernel.Parames['Buffer'] := _Buffer;). - In-memory
#include: the complex-number library (_DATA/Librar.glsl) is registered withTVkLibrarand resolved by name viaGL_GOOGLE_include_directive, without touching the file system. - Interactive: spin the mouse wheel over the image to zoom in and out around the cursor, with smooth animation toward the target view.
- Thin application layer: all Vulkan plumbing is delegated to the LUX.Vulkan library, vendored as a Git subtree under
_LIBRARY/LUXOPHIA/LUX.Vulkan.Main.pasdoes little more than construct objects and connect them.
2. Technical Background
2.1. The Vulkan compute model
A compute dispatch launches a 3D grid of workgroups, each containing a fixed block of invocations whose size is declared in the shader [1][3]. The kernel declares
layout( local_size_x = 16, local_size_y = 16 ) in;
i.e. a local size $s = (16, 16, 1)$. TVkKernel.Run derives the workgroup count from the requested global size $G$ (here $500 \times 500$, the output image) by ceiling division:
D_k = \left\lceil \frac{G_k}{L_k} \right\rceil, \qquad k \in \{x, y, z\}
so vkCmdDispatch receives $\lceil 500/16 \rceil = 32$ groups per axis — $512 \times 512$ invocations in total, and the shader discards the excess with a bounds guard (if ( P.x >= S.x ) ... return;). Each invocation identifies its pixel through gl_GlobalInvocationID, the global invocation ID $g = w \cdot s + l$, where $w$ is the workgroup ID and $l$ the local invocation ID [3].
2.2. Descriptor sets and resource binding
The shader’s four descriptor bindings correspond one-to-one to the four host-side arguments:
layout( std430, binding = 0 ) buffer TBuffer { TSingleC Cent; TSingleC Size; } Buffer;
layout( binding = 1 ) uniform texture1D Textur;
layout( binding = 2 ) uniform sampler Samplr;
layout( binding = 3, rgba8 ) writeonly uniform image2D Imager;
TVkShader compiles the GLSL through glslang [4] and then reflects the generated SPIR-V (entry points, OpExecutionMode local size, and the named bindings). TVkKernel uses this reflection to build the VkDescriptorSetLayout and VkPipeline, and to let arguments be assigned by name:
_Kernel.Parames['Buffer'] := _Buffer; // storage buffer : view center & size
_Kernel.Parames['Textur'] := _Textur; // 1D texture : color palette
_Kernel.Parames['Samplr'] := _Samplr; // sampler : palette interpolation
_Kernel.Parames['Imager'] := _Imager; // storage image : 500 × 500 output
2.3. Command submission and synchronization
Each _Kernel.Run records and submits one primary command buffer:
PreRunof every argument inserts image memory barriers (vkCmdPipelineBarrier) that transition the palette texture into a sampleable layout and the output into a storage-image layout [1];vkCmdBindPipelineandvkCmdBindDescriptorSetsbind the compute pipeline and its single descriptor set;vkCmdDispatchlaunches the grid of Section 2.1;TVkQueuer.EndCommandsubmits the buffer and blocks onvkQueueWaitIdle, making execution synchronous — the simplest correct scheme for a per-frame kernel.
2.4. The Mandelbrot kernel
Each invocation first maps its pixel $P$ of the $S_x \times S_y$ image to a point of the complex plane, using the view center and half-extent stored in the buffer:
c = \left( \mathrm{Cent}_R + \mathrm{Size}_R \left( \frac{2 \left( P_x + 0.5 \right)}{S_x} - 1 \right) \right) + i \left( \mathrm{Cent}_I - \mathrm{Size}_I \left( \frac{2 \left( P_y + 0.5 \right)}{S_y} - 1 \right) \right)
It then iterates the quadratic map
z_0 = 0, \qquad z_{n+1} = z_n^2 + c
up to $N_{\max} = 1000$ steps, using the complex operations (Add, Mul, Pow2, Abs) #included from Librar.glsl. When the orbit escapes ($ |
z_n | > 2$), the escape time is smoothed into a continuous value to avoid color banding: |
\nu = n + 1 - \log \left( \log_2 |z_n| \right)
Finally the palette is sampled at the gamma-compressed coordinate
t = \sqrt{ \nu / N_{\max} }
via texture( sampler1D( Textur, Samplr ), t ), and the color is written with imageStore.
On the host, a wheel notch scales the view by $1.1^{\Delta/120}$ with the cursor’s complex coordinate as fixed point, and every timer tick interpolates the current view a quarter of the way toward the target before rewriting the mapped buffer — producing the smooth zoom animation.
3. Architecture
Ownership graph of the actual wrapper classes (all from LUX.Vulkan):
・TVulkan ・・・ instance / physical-device enumeration
┗・Devices[0] :TVkDevice ・・・ selected physical GPU
┗・TVkContex ・・・ logical device — owns everything below
┣・TVkQueuer ・・・ compute queue + command buffers
┣・TVkBuffer<TSingleC> ・・・ binding 0 : view Cent / Size (SSBO)
┣・TVkImager1DxBGRAxUFix8 ・・・ binding 1 : 1D palette texture
┃ ┗・TVkStream1D..._FMX ・・・ Textur.png → staging → image
┣・TVkSamplr ・・・ binding 2 : palette sampler
┣・TVkImager2DxBGRAxUFix8 ・・・ binding 3 : 500 × 500 output image
┃ ┗・TVkStream2D..._FMX ・・・ image → staging → TBitmap
┣・TVkLibrar ・・・ Librar.glsl, resolved by #include name
┗・TVkShader ・・・ glslang → SPIR-V → reflection
┗・TVkKernel ・・・ VkPipeline + descriptor set (named args)
Per-frame data flow:
[ Per-frame data flow — nesting shows the sequence inside Timer1 ]
・Timer1
┣・_Buffer.Data
┃ ┣・Map
┃ ┣・write Cent, Size
┃ ┗・Unmap
┣・_Kernel.Run
┃ ┣・PreRun :vkCmdPipelineBarrier ・・・ (image layout transitions)
┃ ┣・vkCmdBindPipeline / vkCmdBindDescriptorSets
┃ ┣・vkCmdDispatch( ⌈500/16⌉, ⌈500/16⌉, 1 )
┃ ┗・vkQueueWaitIdle ・・・ (synchronous)
┗・_ImaFMX.CopyTo( ImageR.Bitmap )
┗・GPU image
┗・TBitmap
┗・screen
Repository layout:
・VulkanCompute/
┣・VulkanCompute.dpr ・・・ Project source (unit list)
┣・VulkanCompute.dproj ・・・ RAD Studio project (Win32 / Win64)
┣・Main.pas / Main.fmx ・・・ Main form: object construction + render loop
┣・_DATA/
┃ ┣・Execut.comp ・・・ Compute shader (Mandelbrot kernel, GLSL)
┃ ┣・Librar.glsl ・・・ Complex-number library (#include'd by name)
┃ ┗・Textur.png ・・・ 1D palette texture
┣・_LIBRARY/
┃ ┗・LUXOPHIA/
┃ ┣・LUX/ ・・・ Base library (TSingleC complex type, lists, …)
┃ ┗・LUX.Vulkan/ ・・・ Vulkan wrapper library (Git subtree)
┗・--------/_SCREENSHOT/ ・・・ Screenshot
4. Usage
| Input | Action |
|---|---|
| Mouse wheel over the result image | Zoom in / out around the cursor (× 1.1 per notch, smoothly animated) |
| UI element | Contents |
|---|---|
System tab |
Vulkan instance / device information (saved to System.txt on exit) |
Program › Librar tab |
Source of Librar.glsl |
Program › Execut tab |
Source of Execut.comp |
Program › Build tab |
Compile log, SPIR-V size, entry points, local size, and reflected bindings |
Result tab |
The rendered Mandelbrot set (saved to Imager.png on exit) |
If GLSL compilation fails, the application automatically switches to the Build tab and shows the glslang error log.
5. Building
- Open
VulkanCompute.dprojin RAD Studio (Delphi / FireMonkey). - Select a target platform — Win32 or Win64 — and build.
- Run from the default output directory (e.g.
Win64\Debug): the shader sources are loaded from the relative path..\..\_DATA\.
Requirements:
- A Vulkan-capable GPU and driver providing the
vulkan-1.dllruntime. The Vulkan SDK is not required. - glslang.dll next to the executable, for runtime GLSL compilation. Prebuilt binaries are bundled in the library at
_LIBRARY/LUXOPHIA/LUX.Vulkan/_DLL/Win32and.../Win64.
There is no offline shader-compilation step: TVkShader compiles _DATA/Execut.comp to SPIR-V every time the application starts (Section 2.2).
6. References
- Khronos Group, Vulkan Specification.
- Khronos Group, Vulkan Guide.
- Khronos Group, The OpenGL Shading Language 4.60 Specification — Compute Shaders.
- KhronosGroup, glslang — Khronos-reference GLSL → SPIR-V compiler.
💖 Embarcadero Delphi
Integrated Development Environment (IDE) for Creating Native Cross-Platform Apps.