Khronos Forums - Latest topics https://community.khronos.org/latest Latest topics Sun, 07 Jun 2026 03:53:45 +0000 Accessing array using number index causes strange crash in my HLSL shader Vulkan Hi all,

So I have been implementing my toy Vulkan renderer for a while now, but recently ran into a really strange bug

In one of my fragment shader (using HLSL, if that matters), if I access some data with an explicit number index (i.e. 0), then my program crashes on startup:
printf("L %v3f", normalize(-lightUBO.dirLights[0].direction));

However, if I access it inside a for loop like this, then it’s fine:
for (uint j = 0; j < lightUBO.dirLightNum; j++)
printf(“L %v3f”, normalize(-lightUBO.dirLights[j].direction));
(using printf only for illustration here, the actual light direction is used to calculate bias for shadow PCF)

I can confirm that:

  • dirLightNum is exactly 1 (verified on the CPU side, and on GPU side with RenderDoc and debug printf)
  • lightUBO.dirLights[j].direction (j = 0) holds the correct data (verified on the CPU side, and on GPU side with RenderDoc and debug printf)
  • After countless tests on the shader side, the culprit can only be this line of code

I have tried:

  • Hardcoding the light direction on shader side, works fine
  • (Shown above) Accessing the data in a for loop, works fine
  • Integrating Nsight Aftermath, no minidump generated
  • Integrating the shader printf feature, the program crashes during drawing so no output
  • Changing things around in other parts of my shader code, no effect

Other relevant info:

  • The VS debugger throws an exception at the first drawIndexed call of the first frame (so first invocation of the fragment shader). Message is Exception thrown at 0x00007FFC5089522D (nvoglv64.dll) in utah.exe: 0xC0000005: Access violation reading location 0xFFFFFFFFFFFFFFFF.
  • Using Nsight Graphics to run my program somehow will not trigger the crash. But using VS/.exe/RenderDoc will
  • My project: GitHub Repo (Pretty messy code I know)
    . The shader is /shaders/blinn_phong_frag.hlsl. LightUBO definition is in /src/Render/GPUTypes.h.

Even though I know the final version of my shader will still use a for loop, but this bug is just too strange for me to wrap my head around. I have spent the past two days trying to figure this one out, and I would appreciate any insight or pointers anyone can share!

3 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/accessing-array-using-number-index-causes-strange-crash-in-my-hlsl-shader/112567 Sun, 07 Jun 2026 03:53:45 +0000 No No No community.khronos.org-topic-112567 Accessing array using number index causes strange crash in my HLSL shader Algorithms behind `workGroupFunctions` OpenCL From what it seems the usage of workGroupFunctions in OpenCL kernels, e.g. work_group_scan_exclusive_add pushes the implementation of the underlying algorithm onto the device (if it does indeed support __opencl_c_work_group_collective_functions).

Could someone please verify whether my understanding is correct? Thank you

1 post - 1 participant

Read full topic

]]> https://community.khronos.org/t/algorithms-behind-workgroupfunctions/112565 Sat, 06 Jun 2026 19:58:02 +0000 No No No community.khronos.org-topic-112565 Algorithms behind `workGroupFunctions` Whether modern GPUs support full source-level debugging of OpenCL kernels, what tools provide it, and how GPU debuggers handle GPU-specific execution concepts such as wavefronts, warps, and work-items. OpenCL I am trying to understand the current state of source-level debugging for OpenCL kernels running on GPUs.

For CPU OpenCL implementations, source-level debugging is generally possible using standard debuggers. However, I am specifically interested in debugging OpenCL kernels executing on actual GPU hardware.

My questions are:

  1. Is there currently a full-fledged debugger that supports source-level debugging of OpenCL kernels on GPUs?

  2. Can such a debugger:

    • Set breakpoints inside kernels?

    • Single-step kernel instructions?

    • Inspect kernel variables (private, local, and global memory)?

    • Inspect work-item and work-group state?

    • Switch between individual work-items and inspect each work-item’s execution state independently?

    • View call stacks and source line mappings?

  3. Are there vendor-specific solutions (AMD, Intel, NVIDIA) that provide this functionality?

  4. How is this typically implemented under the hood, given that GPU execution is based on wavefronts/warps rather than independently scheduled threads?

  5. If true source-level debugging is not generally available, what are the main technical limitations that make it difficult?

I would also appreciate references to any open-source or commercial tools that support OpenCL kernel debugging, as well as any papers, documentation, or presentations describing the current state of GPU debugging.

My goal is to understand whether OpenCL kernel debugging on GPUs has reached a level comparable to CPU debugging with GDB/LLDB, or whether developers still primarily rely on printf-style debugging, simulators, and profiling tools.

For context, I am particularly interested in AMD ROCm, Intel GPU runtimes, PoCL, and other modern OpenCL implementations.

2 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/whether-modern-gpus-support-full-source-level-debugging-of-opencl-kernels-what-tools-provide-it-and-how-gpu-debuggers-handle-gpu-specific-execution-concepts-such-as-wavefronts-warps-and-work-items/112559 Tue, 02 Jun 2026 17:40:00 +0000 No No No community.khronos.org-topic-112559 Whether modern GPUs support full source-level debugging of OpenCL kernels, what tools provide it, and how GPU debuggers handle GPU-specific execution concepts such as wavefronts, warps, and work-items. glTF format questions - byte order and primitive index/attribute relationship glTF Hello,

I have two questions about glTF format:

  1. What is the byte order when reading short/int/float values from the buffer? I could not find any info on this online.

  2. What is the relationship between indices (in mesh/primitive) and attributes? If I have two attributes, say POSITION and NORMAL, how many indexes per vertex will there be, and what will be the order of those?

Thanks!

6 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/gltf-format-questions-byte-order-and-primitive-index-attribute-relationship/112558 Tue, 02 Jun 2026 11:32:12 +0000 No No No community.khronos.org-topic-112558 glTF format questions - byte order and primitive index/attribute relationship Is it possible to render HDR in OpenGL 4.1 on macOS or iPadOS OpenGL I am trying to get my macOS app to render in HDR with an HDR texture. It is rendering but not in HDR. The app uses SDL3. I set {RED,GREEN,BLUE}_SIZE to 16 before creating the SDL window and the GL context. The app is rendering a textured quad using a GL_RGBA16F format texture. Is there something else I need to do? Is it even possible?

2 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/is-it-possible-to-render-hdr-in-opengl-4-1-on-macos-or-ipados/112551 Thu, 28 May 2026 08:39:01 +0000 No No No community.khronos.org-topic-112551 Is it possible to render HDR in OpenGL 4.1 on macOS or iPadOS How to render HDR with Vulkan on iPadOS Vulkan My Vulkan app, which uses MoltenVK for now, is happily rendering in HDR on macOS (Sequoia) but not on iPadOS (M4 iPadPro, iPadOS 26.5). Is there something additional that I have to set to enable HDR rendering for the iPad app?

The app sets the surface format to VK_FORMAT_R16G16B16A16_SFLOAT and enables and uses the VK_EXT_swapchain_color_space extension.

2 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/how-to-render-hdr-with-vulkan-on-ipados/112550 Thu, 28 May 2026 08:28:44 +0000 No No No community.khronos.org-topic-112550 How to render HDR with Vulkan on iPadOS Error in loading fragment shader from frag.glsl OpenGL: Basic Coding this is my fragment shader from shader/frag.glsl

#version 330 core
out vec4 aColor;
void main(){
aColor = vec4(1.0, 0.0, 0.0, 1.0);
}

there are no errors in program compiling but on running the “app.exe” i am getting this error

ERROR::SHADER::COMPILATION_FAILED
ERROR: 0:1: ‘’ : illegal character (0x1)
ERROR: 0:1: ‘’ : illegal non-ASCII character (0xb6)
ERROR: 0:1: ‘’ : illegal non-ASCII character (0xc4)
ERROR: 0:1: ‘’ : illegal character (0x2)
WARNING: 0:1: ‘’ : #version directive missing
ERROR: 0:1: ‘PZ’ : syntax error syntax error

This is my loadShader program:

std::string loadShader(const std::string& path){

std::string result;

std::string line;

std::ifstream myFile(path.c_str());

if (myFile.is_open()) {

    while (std::getline(myFile, line)) {

        result += line + "\\n";

    }

    myFile.close();

} else {

    std::cerr << "Could not read file " << path << ". File does not exist.\\n";

}

return result;

};

this is working fine for vert.glsl .

i also tried to load vert.glsl from file and fragemt shader using

“#version 330 core\n”

    "out vec4 aColor;\\n"

    "void main()\\n"

    "{\\n"

    "    aColor = vec4(1.0f, 0.0, 0.0, 1.0);\\n"

    "}\\0";

this combo is working file .

help me where i am wrong in loading fragment shader from frag.glsl .

4 posts - 4 participants

Read full topic

]]> https://community.khronos.org/t/error-in-loading-fragment-shader-from-frag-glsl/112549 Thu, 28 May 2026 07:55:58 +0000 No No No community.khronos.org-topic-112549 Error in loading fragment shader from frag.glsl [Noob] How should I be structuring my descriptors/sets? Vulkan Apologies ahead of time if this is way too long. I’m learning Vulkan through vkguide currently, and I stopped at around the start of chapter 4 to try and figure out how to do image samplers myself. So far I’ve been able to get by on reading documentation and examples alongside debugging with validation layer error messages. But currently I’m stuck on how to handle managing descriptors/rendering multiple objects. Right now I’m drawing a hardcoded rectangular mesh and an imported GLTF model to the screen, with both using the same vert/frag shaders. Each “frame” gets 2 descriptor sets.

Set 0 is a uniform buffer that stores a mat4 that I use to translate the output vertex

Set 1 is the texture sampler.

Set 1 gets updated once before the rendering begins, but set 0 is where I’m kind of stuck. My goal was to update set 0 after drawing the rectangle so that the model is the only thing shifting left to right.

So during the render function I tried doing

vkCmdBindPipeline();
glm::mat4 shift;
VkDescriptorBufferinfo bufferInfo{};
VkWriteDescriptorSet uboWrite = {};
uboWrite.dstSet = currentFrameObject.PipelineDescriptors[0];
vkUpdateDescriptorSets(device, 1, &uboWrite, 0, nullptr);

vkCmdBindDescriptorSets(currentFrameObject.PipelineDescriptors);

vkCmdDrawIndexed(); // Draw the rectangle

// update the mat4 shift to some other value
vkUpdateDescriptorSets(device, 1, &uboWrite, 0, nullptr);

vkCmdDrawIndexed(); // Draw the imported model

Validation layers then reported that this invalidates the command buffer since the descriptors weren’t created with the ability to UPDATE_AFTER_BIND. I assume this is a race condition problem caused by modifying values that the pipeline hasn’t fully processed yet. So I’m kind of stuck on how I should be organizing these descriptors in order to render multiple different objects possibly with different textures. Should I be giving each rendered object its own descriptor sets instead and bind them between draw calls? Or something like making one big descriptor that stores all this data for all drawn objects and update it once before drawing?

2 posts - 1 participant

Read full topic

]]> https://community.khronos.org/t/noob-how-should-i-be-structuring-my-descriptors-sets/112547 Wed, 27 May 2026 02:50:53 +0000 No No No community.khronos.org-topic-112547 [Noob] How should I be structuring my descriptors/sets? Is it able to Baching DrawCall of 2 overlapped rects? Vulkan is it able to Baching DrawCall of 2 overlapped rects?

3 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/is-it-able-to-baching-drawcall-of-2-overlapped-rects/112546 Mon, 25 May 2026 01:26:41 +0000 No No No community.khronos.org-topic-112546 Is it able to Baching DrawCall of 2 overlapped rects? Extension and Feature are very confusing Vulkan Features are very confusing in vulkan

I guess a device extension has many features inside

and VkPhysicalDeviceFeatures, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkan13Features, VkPhysicalDeviceVulkan14Features are main feature variables given by Vulkan

however, when writing vkdevicecreateinfo,

there is pNext member

according to vulkan spec documents

there are so many struct which can be connected to this pNext

such as

VkDeviceDeviceMemoryReportCreateInfoEXT

VkDeviceDiagnosticsConfigCreateInfoNV

VkDeviceGroupDeviceCreateInfo

VkPhysicalDeviceBufferDeviceAddressFeatures

VkPhysicalDeviceDeviceAddressCommandsFeaturesKHR

VkPhysicalDeviceDeviceMemoryReportFeaturesEXT etc …

These are also features given by Vulkan

Then why does Khronos not give precise definitions about Vulkan features ?

What are those so many feature structs ?

What are the rules to find which feature structs are needed for my vulkan programming ?

How do I know that?

Please help me with this issue

Thank you

7 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/extension-and-feature-are-very-confusing/112545 Fri, 22 May 2026 04:26:11 +0000 No No No community.khronos.org-topic-112545 Extension and Feature are very confusing Tile Based Rendering Best Practices Vulkan Are you optimizing Vulkan applications for mobile or tile-based GPUs? The Vulkan Guide has a dedicated section on Tile Based Rendering (TBR) best practices worth bookmarking.

Unlike traditional immediate-mode GPUs, tile-based architectures process the framebuffer in small screen regions, keeping work on fast on-chip memory before writing results to main system memory. For Vulkan developers, this means memory bandwidth is often the dominant performance factor.

Key takeaways from the guide:

Use load/store ops intentionally. Render pass attachment configuration is your primary tool for controlling bandwidth. Setting the right loadOp and storeOp values tells the driver whether to clear, load, or discard data, directly impacting whether data has to travel off-chip.

Keep depth and stencil transient. If depth and stencil buffers are not needed after a render pass, mark them with LOAD_OP_CLEAR and STORE_OP_DONT_CARE. This allows the driver to keep them entirely on-chip and avoid the cost of writing them back to external memory.

Favor compact pixel formats. On-chip tile memory is fixed in size. Smaller bit-depth formats allow the hardware to fit more data per tile, reducing spills to external memory and improving efficiency.

Optimize for the binning pass. Tilers process geometry twice: once to bin triangles into tiles, then again to shade pixels. Separating vertex positions from other attributes like UVs and normals lets the GPU read only what it needs during binning, cutting unnecessary bandwidth.

Provide clear intent to the driver. Because Vulkan abstracts hardware details like tile size, the best way to optimize is to use correct render pass configurations and memory flags so the driver can make informed decisions on your behalf.

The full guide covers these topics in depth, including guidance on MSAA, transient attachments, and dynamic rendering:

1 post - 1 participant

Read full topic

]]> https://community.khronos.org/t/tile-based-rendering-best-practices/112538 Tue, 12 May 2026 14:40:00 +0000 No No No community.khronos.org-topic-112538 Tile Based Rendering Best Practices How to find out why Vulkan app crash on android? Vulkan how to find out why Vulkan app crash on android?

2 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/how-to-find-out-why-vulkan-app-crash-on-android/112537 Mon, 11 May 2026 01:43:28 +0000 No No No community.khronos.org-topic-112537 How to find out why Vulkan app crash on android? Open-source 3D Gaussian Splatting 3D Tiles Toolchain glTF: Showcase Hi everyone,

I’d like to share a open-source toolchain I’ve been working on for using 3D Gaussian Splatting data in 3D Tiles / WebGIS workflows:

The goal is to make 3D Gaussian Splatting data easier to convert, stream, inspect, align, and use in browser-based 3D scenes.

https://i.redd.it/y445xpxdbwzg1.png(image larger than 4 MB)

3DGS PLY to 3D Tiles Converter

This is a Node.js CLI / library for converting 3D Gaussian Splatting PLY models into explicit 3D Tiles tilesets.

Key features include:

Converts 3DGS PLY to hierarchical 3D Tiles

Uses SPZ-compressed GLB tile content

Supports large PLY processing with limited memory

Supports WGS84 placement or custom root transforms

Generates simplified parent LOD tiles for progressive loading and smoother LOD transitions

3D Tiles RendererJS 3DGS Plugin

This plugin adds support for loading Gaussian Splatting tile content in 3D Tiles RendererJS / Three.js workflows.

Key features include:

Loads 3D Tiles tilesets containing Gaussian Splatting GLB content

Parses Gaussian Splatting glTF extensions

Supports SPZ-compressed splat data

Enables tile-based loading and rendering of Gaussian Splatting scenes

Works with hierarchical 3D Tiles generated from large 3DGS models

3DTiles Inspector

The inspector is a local browser-based workflow for checking and adjusting 3D Tiles tilesets.

Key features include:

Open local 3D Tiles tilesets in a browser inspector

Adjust root transform for geospatial alignment

Tune geometric error and LOD behaviour

Inspect tile loading and tileset structure

Crop Gaussian Splatting tilesets and save the result back to disk

Together, these projects provide a workflow from conversion to runtime loading and local inspection:

3DGS PLY → 3D Tiles → inspect / align / crop → load in Three.js / WebGIS workflows

I’m still improving the projects and would be very interested in feedback from the community.

Any suggestions, testing results, or discussion would be very welcome.

1 post - 1 participant

Read full topic

]]> https://community.khronos.org/t/open-source-3d-gaussian-splatting-3d-tiles-toolchain/112535 Sun, 10 May 2026 15:24:49 +0000 No No No community.khronos.org-topic-112535 Open-source 3D Gaussian Splatting 3D Tiles Toolchain [OpenXR Specification] - Typo in the XrFovf(3) Manual Page OpenXR Hello,

I noticed perhaps a typo or something that needs clarifications in the OpenXR Specification in the XrFovf(3) Manual Page in the “Member Descriptions” we have :

  • angleLeft is the angle of the left side of the field of view. For a symmetric field of view this value is negative.
  • angleDown is the angle of the bottom part of the field of view. For a symmetric field of view this value is negative.

but that should be the contrary, for an asymmetric fov the value of the angles are negative and not for a symmetric one, a contradiction stated just bellow : “For a symmetric FoV, angleRight and angleUp will have positive values”, as i understand things, there is a typo in the member descriptions it should be “for an asymmetric fov” instead of “for a symmetric fov”.

ofc you can correct me if i’m wrong. Also, is there a way to contribute to the specification doc ?

3 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/openxr-specification-typo-in-the-xrfovf-3-manual-page/112528 Tue, 05 May 2026 17:07:15 +0000 No No No community.khronos.org-topic-112528 [OpenXR Specification] - Typo in the XrFovf(3) Manual Page OpenCL 3.1 is here OpenCL The Khronos Group is pushing more consistency into the spec by promoting several features from optional to core.

Including:

  • SPIR-V kernel ingestion is now required
  • Subgroups + integer dot products are core
  • New queries for work-group sizing and device UUID (aligned with Vulkan)
  • Spec cleanups around memory model, sync, and printf

Vendors + open source stacks are already working on support, including: Intel, Arm, Qualcomm, Mesa, Rusticl, PoCL, CLVK.

Find the full post here: OpenCL 3.1 is Here

Comment and share feedback on the OpenCL specification GitHub or the Khronos Discord.

1 post - 1 participant

Read full topic

]]> https://community.khronos.org/t/opencl-3-1-is-here/112527 Tue, 05 May 2026 13:13:56 +0000 No No No community.khronos.org-topic-112527 OpenCL 3.1 is here Hardware development and openxr OpenXR Why is everything so complicated? I’m currently working on a tracking device, and here’s what’s bothering me. Why can’t OpenXR simply listen to ports for data transfer regardless of the runtime environment? It turns out that to use the hardware in stimvr, you need a stimvr driver, and to use it in a different runtime environment, you also need to initialize the hardware differently… Basically, OpenXR currently doesn’t allow hardware developers to unify drivers. And that’s sad.

4 posts - 4 participants

Read full topic

]]> https://community.khronos.org/t/hardware-development-and-openxr/112525 Thu, 30 Apr 2026 12:15:24 +0000 No No No community.khronos.org-topic-112525 Hardware development and openxr How to set opengl up on linux manuelly (no ide) with clang? OpenGL Hi,

I have installed opengl with arch linus’s packages via AUR and pacman repos but still get linker errors trying to compile some examples like below:

$ clang -v dials.c 
clang version 22.1.2
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-pc-linux-gnu/15.2.1
Found candidate GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1
Selected GCC installation: /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1
Candidate multilib: .;@m64
Candidate multilib: 32;@m32
Selected multilib: .;@m64
Found HIP installation: /opt/rocm, version 7.2.53211
 "/usr/bin/clang-22" -cc1 -triple x86_64-pc-linux-gnu -emit-obj -dumpdir a- -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name dials.c -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/home/alek/Downloads/examples/examples -v -fcoverage-compilation-dir=/home/alek/Downloads/examples/examples -resource-dir /usr/lib/clang/22 -internal-isystem /usr/lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../x86_64-pc-linux-gnu/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fmessage-length=190 -stack-protector 2 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -faddrsig -fdwarf2-cfi-asm -o /tmp/dials-08e501.o -x c dials.c
clang -cc1 version 22.1.2 based upon LLVM 22.1.2 default target x86_64-pc-linux-gnu
ignoring nonexistent directory "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../x86_64-pc-linux-gnu/include"
ignoring nonexistent directory "/include"
#include "..." search starts here:
#include <...> search starts here:
 /usr/lib/clang/22/include
 /usr/local/include
 /usr/include
End of search list.
 "/usr/bin/ld" --hash-style=gnu --build-id --eh-frame-hdr -m elf_x86_64 -pie -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o a.out /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib64/Scrt1.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib64/crti.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/crtbeginS.o -L/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1 -L/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib64 -L/lib/../lib64 -L/usr/lib64 -L/lib -L/usr/lib /tmp/dials-08e501.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/crtendS.o /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/15.2.1/../../../../lib64/crtn.o
/usr/bin/ld: /tmp/dials-08e501.o: in function `drawCircle':
dials.c:(.text+0x15): undefined reference to `glPushMatrix'
/usr/bin/ld: dials.c:(.text+0x27): undefined reference to `glTranslatef'
/usr/bin/ld: dials.c:(.text+0x31): undefined reference to `glBegin'
/usr/bin/ld: dials.c:(.text+0x3c): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x72): undefined reference to `cos'
/usr/bin/ld: dials.c:(.text+0x9f): undefined reference to `sin'
/usr/bin/ld: dials.c:(.text+0xb9): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0xe1): undefined reference to `glEnd'
/usr/bin/ld: dials.c:(.text+0xf4): undefined reference to `glColor3f'
/usr/bin/ld: dials.c:(.text+0xfe): undefined reference to `glBegin'
/usr/bin/ld: dials.c:(.text+0x109): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x135): undefined reference to `cos'
/usr/bin/ld: dials.c:(.text+0x176): undefined reference to `sin'
/usr/bin/ld: dials.c:(.text+0x190): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x195): undefined reference to `glEnd'
/usr/bin/ld: dials.c:(.text+0x19a): undefined reference to `glPopMatrix'
/usr/bin/ld: /tmp/dials-08e501.o: in function `displayDials':
dials.c:(.text+0x1be): undefined reference to `glClear'
/usr/bin/ld: dials.c:(.text+0x1e3): undefined reference to `glColor3f'
/usr/bin/ld: dials.c:(.text+0x232): undefined reference to `glutSwapBuffers'
/usr/bin/ld: /tmp/dials-08e501.o: in function `displayButtons':
dials.c:(.text+0x24e): undefined reference to `glClear'
/usr/bin/ld: dials.c:(.text+0x258): undefined reference to `glBegin'
/usr/bin/ld: dials.c:(.text+0x2bd): undefined reference to `glColor3f'
/usr/bin/ld: dials.c:(.text+0x2d2): undefined reference to `glColor3f'
/usr/bin/ld: dials.c:(.text+0x301): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x330): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x35f): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x38e): undefined reference to `glVertex2f'
/usr/bin/ld: dials.c:(.text+0x3aa): undefined reference to `glEnd'
/usr/bin/ld: dials.c:(.text+0x3af): undefined reference to `glutSwapBuffers'
/usr/bin/ld: /tmp/dials-08e501.o: in function `reshape':
dials.c:(.text+0x3d9): undefined reference to `glViewport'
/usr/bin/ld: dials.c:(.text+0x3e3): undefined reference to `glMatrixMode'
/usr/bin/ld: dials.c:(.text+0x3e8): undefined reference to `glLoadIdentity'
/usr/bin/ld: dials.c:(.text+0x3fd): undefined reference to `gluOrtho2D'
/usr/bin/ld: dials.c:(.text+0x402): undefined reference to `glutGetWindow'
/usr/bin/ld: dials.c:(.text+0x422): undefined reference to `glScalef'
/usr/bin/ld: dials.c:(.text+0x436): undefined reference to `glTranslatef'
/usr/bin/ld: dials.c:(.text+0x440): undefined reference to `glMatrixMode'
/usr/bin/ld: /tmp/dials-08e501.o: in function `dodial':
dials.c:(.text+0x483): undefined reference to `glutSetWindow'
/usr/bin/ld: dials.c:(.text+0x488): undefined reference to `glutPostRedisplay'
/usr/bin/ld: /tmp/dials-08e501.o: in function `dobutton':
dials.c:(.text+0x4df): undefined reference to `glutSetWindow'
/usr/bin/ld: dials.c:(.text+0x4e4): undefined reference to `glutPostRedisplay'
/usr/bin/ld: /tmp/dials-08e501.o: in function `main':
dials.c:(.text+0x51c): undefined reference to `glutInit'
/usr/bin/ld: dials.c:(.text+0x526): undefined reference to `glutDeviceGet'
/usr/bin/ld: dials.c:(.text+0x561): undefined reference to `glutDeviceGet'
/usr/bin/ld: dials.c:(.text+0x5a4): undefined reference to `glutInitDisplayMode'
/usr/bin/ld: dials.c:(.text+0x5cb): undefined reference to `glutInitWindowSize'
/usr/bin/ld: dials.c:(.text+0x5d7): undefined reference to `glutCreateWindow'
/usr/bin/ld: dials.c:(.text+0x602): undefined reference to `glClearColor'
/usr/bin/ld: dials.c:(.text+0x60f): undefined reference to `glLineWidth'
/usr/bin/ld: dials.c:(.text+0x61f): undefined reference to `glutDialsFunc'
/usr/bin/ld: dials.c:(.text+0x62f): undefined reference to `glutButtonBoxFunc'
/usr/bin/ld: dials.c:(.text+0x63b): undefined reference to `glutDisplayFunc'
/usr/bin/ld: dials.c:(.text+0x64b): undefined reference to `glutReshapeFunc'
/usr/bin/ld: dials.c:(.text+0x657): undefined reference to `glutInitWindowSize'
/usr/bin/ld: dials.c:(.text+0x663): undefined reference to `glutCreateWindow'
/usr/bin/ld: dials.c:(.text+0x67e): undefined reference to `glClearColor'
/usr/bin/ld: dials.c:(.text+0x68a): undefined reference to `glutDisplayFunc'
/usr/bin/ld: dials.c:(.text+0x693): undefined reference to `glutReshapeFunc'
/usr/bin/ld: dials.c:(.text+0x69c): undefined reference to `glutDialsFunc'
/usr/bin/ld: dials.c:(.text+0x6a5): undefined reference to `glutButtonBoxFunc'
/usr/bin/ld: dials.c:(.text+0x6aa): undefined reference to `glutMainLoop'
clang: error: linker command failed with exit code 1 (use -v to see invocation)

4 posts - 3 participants

Read full topic

]]> https://community.khronos.org/t/how-to-set-opengl-up-on-linux-manuelly-no-ide-with-clang/112519 Sat, 25 Apr 2026 19:41:12 +0000 No No No community.khronos.org-topic-112519 How to set opengl up on linux manuelly (no ide) with clang? Looking for old version of glslangvalidater OpenGL: Advanced Coding I am looking for an old version of the glslangvalidater tool, as newer versions are focused on Vulkan. I want the best version for support of OpenGL 4.5. The ones on Khronos Github are all too new.
I have a really old copy of it, but OpenGL 4.5 support is listed as “experimental”.

Usage: glslangValidator [option]... [file]...

Where: each 'file' ends in
    .conf to provide an optional config file that replaces the default configuration
          (see -c option below for generating a template)
    .vert for a vertex shader
    .tesc for a tessellation control shader
    .tese for a tessellation evaluation shader
    .geom for a geometry shader
    .frag for a fragment shader
    .comp for a compute shader

Compilation warnings and errors will be printed to stdout.

To get other information, use one of the following options:
(Each option must be specified separately, but can go anywhere in the command line.)
  -c  configuration dump; use to create default configuration file (redirect to a .conf file)
  -i  intermediate tree (glslang AST) is printed out
  -l  link validation of all input files
  -m  memory leak mode
  -q  dump reflection query database
  -r  relaxed semantic error-checking mode
  -s  silent mode
  -t  multi-threaded mode
  -v  print version strings
  -w  suppress warnings (except as required by #extension : warn)

3 posts - 1 participant

Read full topic

]]> https://community.khronos.org/t/looking-for-old-version-of-glslangvalidater/112509 Sat, 18 Apr 2026 02:00:34 +0000 No No No community.khronos.org-topic-112509 Looking for old version of glslangvalidater Vendor extension ratification OpenXR Hi,

[Please redirect me if this is not the right forum/appropriate way to talk about this.]

Is there a way to follow what’s happening for a proposed vendor extension? I mean, how can we know if the extension will be accepted or cancelled, if discussions are still ongoing, etc.

Namely, I would like to know what’s happening with Magic Leap’s XR_ML_pixel_sensor extension. It seems to me that most Magic Leap’s extensions have been added in OpenXR 1.1.41 and then XR_ML_facial_expression in OpenXR 1.1.43. To date, I didn’t found XR_ML_pixel_sensor in any OpenXR release.

I have source code waiting for this extension for months (years?) and because of Magic Leap’s current situation, I’m wondering it this will ever happen…

Thanks!

4 posts - 3 participants

Read full topic

]]> https://community.khronos.org/t/vendor-extension-ratification/112507 Thu, 16 Apr 2026 13:37:17 +0000 No No No community.khronos.org-topic-112507 Vendor extension ratification OpenGL not displaying rectangle OpenGL I have checked the entire codebase and have not been able to recognize the problem.

Here’s the main part where I hypothesize it lies:

unsigned int vertexShader;

if(compileVertexShader(&vertexShader, vertexShaderSource) == FAIL)
{
    return FAIL;
}

unsigned int fragmentShader;

if(compileFragmentShader(&fragmentShader, fragmentShaderSource) == FAIL)
{
    return FAIL;
}

unsigned int shaderProgram;
shaderProgram = glCreateProgram();

glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);

if(checkShaderProgramSuccess(shaderProgram) == FAIL)
{
    return FAIL;
}

glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);

unsigned int VBO;
unsigned int VAO;
unsigned int EBO;

glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);

glBindVertexArray(VAO);

glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(rectangle.vertices), rectangle.vertices, GL_STATIC_DRAW);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(rectangle.indices), rectangle.indices, GL_STATIC_DRAW);

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);

glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);

while(!glfwWindowShouldClose(window))
{
    windowRender(window, shaderProgram, VBO, EBO);

    glfwPollEvents();
}

printf("Program closing due to user input. The program ran successfully without error.\n");

cleanup();

return SUCCESS;

And here’s the entire codebase

main.c

#include "main.h"

#include "window.h"
#include "display.h"
#include "shaders.h"

// gcc Assets/Code/main.c Assets/Code/window.c Assets/Code/display.c Assets/Code/shaders.c -lGLEW -lGL -lglfw -o "Game" -Wall

const char* vertexShaderSource = "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
    "}\0";

const char* fragmentShaderSource = "#version 330 core\n"
    "out vec4 FragColor;\n"
    "void main()\n"
    "{\n"
    "FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
    "}\0";

GLFWwindow* window;

float test_rectangle_vertices[] = {
        0.5f,  0.5f, 0.0f,  // top right
        0.5f, -0.5f, 0.0f,  // bottom right
        -0.5f, -0.5f, 0.0f,  // bottom left
        -0.5f,  0.5f, 0.0f   // top left
    };

unsigned int test_rectangle_indices[] = {
    0, 1, 3,
    1, 2, 3
};

void cleanup()
{
    if(window)
    {
        glfwDestroyWindow(window);
    }

    glfwTerminate();
}

void print_glfw_error()
{
    const char* error_ptr;
    glfwGetError(&error_ptr);

    printf("%s\n", error_ptr);
}

void print_glew_error(GLenum error)
{
    printf("%s\n", glewGetErrorString(error));
}

bool initialize_glew()
{
    // GLAD is not very glad, GLEW is what makes me glad

    GLenum glewinit_return_value = glewInit();

    if(glewinit_return_value != GLEW_OK)
    {
        print_glew_error(glewinit_return_value);
        handle_error(true, true); // clean up, and the error was fatal

        return FAIL;
    }

    return SUCCESS;
}

void handle_error(bool is_cleanup, bool is_fatal)
{
    if(is_fatal)
    {
        printf("Fatal error. Program aborted.\n");
    }

    if(is_cleanup)
    {
        cleanup();
    }
}

void createShape(Shape* rectangle, float* shape_vertices, unsigned int*  shape_indices)
{
    printf("Creating shape...\n");

    rectangle->vertices = shape_vertices;
    rectangle->indices = shape_indices;

    printf("Shape created.\n");
}

int main()
{
    if(!glfwInit())
    {
        print_glfw_error();
        handle_error(false, true); // do not clean up, and the error was fatal
        return FAIL;
    }

    window = createWindow();

    if(window == NULL)
    {
        return FAIL;
    }

    if(initialize_glew() == FAIL)
    {
        return FAIL;
    }

    glViewport(0, 0, 1920, 1080);

    Shape rectangle;

    createShape(&rectangle, test_rectangle_vertices, test_rectangle_indices);

    unsigned int vertexShader;

    if(compileVertexShader(&vertexShader, vertexShaderSource) == FAIL)
    {
        return FAIL;
    }

    unsigned int fragmentShader;

    if(compileFragmentShader(&fragmentShader, fragmentShaderSource) == FAIL)
    {
        return FAIL;
    }

    unsigned int shaderProgram;
    shaderProgram = glCreateProgram();

    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);

    if(checkShaderProgramSuccess(shaderProgram) == FAIL)
    {
        return FAIL;
    }

    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    unsigned int VBO;
    unsigned int VAO;
    unsigned int EBO;

    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);

    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(rectangle.vertices), rectangle.vertices, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(rectangle.indices), rectangle.indices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    while(!glfwWindowShouldClose(window))
    {
        windowRender(window, shaderProgram, VBO, EBO);

        glfwPollEvents();
    }

    printf("Program closing due to user input. The program ran successfully without error.\n");

    cleanup();

    return SUCCESS;
}

display.c

#include "main.h"

// Rectangle's gone. This is depressing.

void windowRender(GLFWwindow* window, unsigned int shaderProgram, unsigned int VAO, unsigned int EBO)
{
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(shaderProgram);
    glBindVertexArray(VAO);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

    glfwSwapBuffers(window);
}

#include "main.h"

// Please stop

bool compileVertexShader(unsigned int* vertexShaderInput, const char* vertexShaderSourceInput)
{
    *vertexShaderInput = glCreateShader(GL_VERTEX_SHADER);

    glShaderSource(*vertexShaderInput, 1, &vertexShaderSourceInput, NULL);
    glCompileShader(*vertexShaderInput);

    int is_successful;
    char infoLog[512];

    glGetShaderiv(*vertexShaderInput, GL_COMPILE_STATUS, &is_successful);

    if(!is_successful)
    {
        glGetShaderInfoLog(*vertexShaderInput, 512, NULL, infoLog);
        printf("Vertex shader compilation failed. Error log is as follows:\n%s", infoLog);

        handle_error(true, true); // clean up, and the error was fatal

        return FAIL;
    }

    return SUCCESS;
}

bool compileFragmentShader(unsigned int* fragmentShaderInput, const char* fragmentShaderSourceInput)
{
    *fragmentShaderInput = glCreateShader(GL_FRAGMENT_SHADER);

    glShaderSource(*fragmentShaderInput, 1, &fragmentShaderSourceInput, NULL);
    glCompileShader(*fragmentShaderInput);

    int is_successful;
    char infoLog[512];

    glGetShaderiv(*fragmentShaderInput, GL_COMPILE_STATUS, &is_successful);

    if(!is_successful)
    {
        glGetShaderInfoLog(*fragmentShaderInput, 512, NULL, infoLog);
        printf("Fragment shader compilation failed. Error log is as follows:\n%s", infoLog);

        handle_error(true, true); // clean up, and the error was fatal

        return FAIL;
    }

    return SUCCESS;
}

bool checkShaderProgramSuccess(unsigned int shaderProgram)
{
    int is_successful;
    char infoLog[512];

    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &is_successful);

    if(!is_successful)
    {
        glGetShaderInfoLog(shaderProgram, 512, NULL, infoLog);
        printf("Shader program compilation failed. Error log is as follows:\n%s", infoLog);

        handle_error(true, true); // clean up, and the error was fatal

        return FAIL;
    }

    return SUCCESS;
}

window.c

#include "main.h"

// Hours that the rectangle has been gone. It's just black. Darkness.

GLFWwindow* createWindow()
{
    GLFWwindow* window = glfwCreateWindow(1920, 1080, "Badpa", NULL, NULL);

    if(!window)
    {
        print_glfw_error();
        handle_error(true, true); // clean up, and the error was fatal

        return NULL;
    }

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    glfwMakeContextCurrent(window);

    return window;
}

main.h

#pragma once

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#define SUCCESS 0
#define FAIL 1

void cleanup();
void handle_error(bool is_cleanup, bool is_fatal);
void print_glfw_error();
void print_glew_error(GLenum error);
bool initialize_glew();

typedef struct{
    float* vertices;
    unsigned int* indices;
} Shape;

window.h

#pragma once

GLFWwindow* createWindow();

shaders.h

#pragma once

bool compileVertexShader(unsigned int* vertexShaderInput, const char* vertexShaderSourceInput);
bool compileFragmentShader(unsigned int* fragmentShaderInput, const char* fragmentShaderSourceInput);
bool checkShaderProgramSuccess(unsigned int shaderProgram);

display.h

#pragma once

bool windowRender(GLFWwindow* window, unsigned int shaderProgram, unsigned int VAO, unsigned int EBO);

2 posts - 1 participant

Read full topic

]]> https://community.khronos.org/t/opengl-not-displaying-rectangle/112504 Wed, 15 Apr 2026 09:51:14 +0000 No No No community.khronos.org-topic-112504 OpenGL not displaying rectangle How to use SDL2/GLES2 to test if the window is occluded? OpenGL: User Software This discussion with Solar-Pro-2 lists some platform-specific solutions, but the software is supposed to function portable across all popular platforms (such as Windows or Unix derivatives).
Wish to know how to use portable (SDL2/GLES2) functions to test if the java window is occluded (does not require maximized forefront window, just requires that the whole java window is occluded, which suggests compositors have improved), so that the physics loop is more course (less granular) when the contents are not shown.
What prompted this was: noticed that top shows xwayland + gnome-shell CPU usage drops to ~0% when the java window is occluded, plus java’s CPU usage drops from 22% to 6% when occluded: the goal is that if the contents are not shown, to have 4x less physics steps, but 4x larger physics steps, which should lower java CPU usage down to 2%.
Since Linux does this, guess Windows does too, so wish to know the most portable functions to use.

Source code for the java software is at SusuJava (FLOSS Java sim) now uses Khronos' GLES2 (includes JNI for SDL2) - #2 by SwuduSusuwu , but guess this “occlusion mode” is not java-specific

1 post - 1 participant

Read full topic

]]> https://community.khronos.org/t/how-to-use-sdl2-gles2-to-test-if-the-window-is-occluded/112501 Fri, 10 Apr 2026 01:58:58 +0000 No No No community.khronos.org-topic-112501 How to use SDL2/GLES2 to test if the window is occluded? SusuJava (FLOSS Java sim) now uses Khronos' GLES2 (includes JNI for SDL2) Self Promotion Discussion

SusuJava is a simple group of java classes (produced to encourage more java uses), but which does include some simple demos (FishSim.java shows how to use the included java classes to produce a simple artificial ocean with a thousand small fish which swim around).
The copilot/replace-javafx-with-sdl2-opengles branch includes:

The other files of source code are generic java classes (not included in this post since those do not use Khronos tools such as GLES2, but are also published FLOSS (usable through GPLv2 or Apache 2)).

Current plans: merge the copilot/replace-javafx-with-sdl2-opengles branch into the new branch plus into the pos2 branch, as soon as susuwu/sdl_gles2_jni.c is removed (the goal of SusuJava is to use pure java.)

Problems: no regressions on Ubuntu (from the switch from javafx to GLES2 ), but still can not execute on Termux due to:

~/SusuJava $ ./build.sh
MESA: error: ZINK: failed to choose pdev
libEGL warning: egl: failed to create dri2 screen

If you wish this to continue (to have more new versions published), then give suggestions for how Termux should execute the new GLES2 version of SusuJava .

2 posts - 1 participant

Read full topic

]]> https://community.khronos.org/t/susujava-floss-java-sim-now-uses-khronos-gles2-includes-jni-for-sdl2/112496 Mon, 06 Apr 2026 01:55:53 +0000 No No No community.khronos.org-topic-112496 SusuJava (FLOSS Java sim) now uses Khronos' GLES2 (includes JNI for SDL2) Hypothesis on how to produce close-to-human intelligences for avatars in procedural worlds Self Promotion Google Assistant discusses how to produce synthetic neural tissue with attributes similar to the “Yakumo Ran supercomputer”. Notice: the first few messages are whimsical narrative analysis, but most of the discussion is about which tools to use to produce such systems.
This would use Khronos’ OpenGL, GLES, or Vulkan to render the avatars + procedural worlds.
This would use Khronos’ OpenCL for execution of the synthetic neural tissues (such as the Open Compute version of TensorFlow inference)
If you continue the discussion with Google Assistant, you can ask for more specifics on how to do this: guess Google Assistant can produce most of the source code for you, but supercomputers are required to process the “base-level” connectome, so can not do this alone. Once all suitable public datasets are autoencoded into the “base-level” connectome, such should allow to “transfer learn” on consumer devices to produce personalized intelligences which best suit the current user’s specific values.

If encouraged, will do best to produce this on own, but do not have much disk storage, plus just own a few consumer-class processors, so the “close-to-human intelligence” would get lowered to “animal-Plus intelligence” if must do this on own: Google Assistant suggests you must purchase access to server clusters with tens of thousands of GPUs for months of continuous use (which costs millions of US$) to produce connectomes for synthetic neural systems such as Grok-2, due to the “exponential explosion” of solutions required to autoencode compressed human intelligence into coefficients for simple architectures such as TensorFlow, plus shows pseudocode for TensorFlow architectures which include zones as the hippocampus, neocortex, thalamus, basal ganglia, prefrontal cortex, visual cortices, plus numerous other zones relevent to avatars in sims.

1 post - 1 participant

Read full topic

]]> https://community.khronos.org/t/hypothesis-on-how-to-produce-close-to-human-intelligences-for-avatars-in-procedural-worlds/112492 Mon, 30 Mar 2026 20:15:57 +0000 No No No community.khronos.org-topic-112492 Hypothesis on how to produce close-to-human intelligences for avatars in procedural worlds Suggesting Vulkan for UI Community Talk Hello,
these days, UI really sucks (sorry)
I mean, UI for applications

I used MFC long time ago, but that is no more
I don’t want to use Qt nor QML

These days, all UI are focusing on Web style

So, I am looking for UI which is web based and cross-platform (Windows, Linux, Android)
also, I want to develop UI using C++

Therefore, how about Vulkan for UI ?

This Vulkan for UI offers
Web based (HTML, CSS) UI Design (Button, Combo, Slider, Edit Control, Tab Control, Tool Bar etc)
also 3D UI Style Feature using Vulkan Graphics API (Cube-like Button, for example)
Cross-Platform (Windows, Linux, Android)
Unicode Text, Multi-Language Support
Works well with Vulkan Rendering, Vulkan Compute etc
using Modern C++

So can Khronos create new UI API (Vulkan for UI) as above, in near future?

I really want this happen and want to suggest my idea to Khronos

Thank you

2 posts - 1 participant

Read full topic

]]> https://community.khronos.org/t/suggesting-vulkan-for-ui/112489 Sat, 28 Mar 2026 08:10:57 +0000 No No No community.khronos.org-topic-112489 Suggesting Vulkan for UI What's the best way to deal with pipelineCache, eps. cache miss at runtime Vulkan what’s the best way to deal with pipelineCache, eps. cache miss at runtime

2 posts - 1 participant

Read full topic

]]> https://community.khronos.org/t/whats-the-best-way-to-deal-with-pipelinecache-eps-cache-miss-at-runtime/112487 Thu, 26 Mar 2026 04:53:30 +0000 No No No community.khronos.org-topic-112487 What's the best way to deal with pipelineCache, eps. cache miss at runtime I can only use one vkfence per submit Vulkan In my code I have 2 command buffers(A and B). I submit them together and I want to know on the host when A is finished and to know when B is finished. For that I have a vkfence to put in vksubmit but I can only put one vkfence. this is weird for me because i can use multiple semaphores but only one fence. is there a right way to deal with it without calling vkQueueSubmit more than once?

2 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/i-can-only-use-one-vkfence-per-submit/112486 Tue, 24 Mar 2026 03:39:38 +0000 No No No community.khronos.org-topic-112486 I can only use one vkfence per submit Resolving a multisample stencil texture OpenGL A “resolved” multisample depth texture is not particularly useful, but the stencil component of a Depth24/Stencil8 texture could be, if the resolve step includes all bit values of each subpixel.

For example, a 4x multisample pixel with stencil values like this could be resolved into a single value 1|2|4.

1|2  4
 0   1

Is this a supported feature?

2 posts - 1 participant

Read full topic

]]> https://community.khronos.org/t/resolving-a-multisample-stencil-texture/112485 Sun, 22 Mar 2026 07:36:05 +0000 No No No community.khronos.org-topic-112485 Resolving a multisample stencil texture Using the stencil buffer for the first time OpenGL: Advanced Coding I want to use the stencil buffer to mask out my background in a deferred renderer, so the full-screen directional light pass only draws to pixels that have had something drawn to them, and for other things. So far it is not working in a predictable way.

The stencil buffer is cleared like this:

glStencilMask(0xFF);
glClearNamedFramebufferfi(fbo, GL_DEPTH_STENCIL, 0, 1.0f, 0);
glStencilMask(0x1);

I prepare to draw objects like this:

glEnable(GL_STENCIL_TEST);
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
glStencilFunc(GL_ALWAYS, 1, 0xFF);
glStencilMask(0x1);

Now I get ready to draw the full-screen pass for directional lights:

glEnable(GL_STENCIL_TEST);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilFunc(GL_EQUAL, 0, 0xFF);// Background pixels get drawn to
//glStencilFunc(GL_EQUAL, 1, 0xFF);// Nothing gets drawn
glStencilMask(0);

If I use glStencilFunc(GL_EQUAL, 0, 0xFF) then the full-screen pass draws to the background pixels (where nothing has been drawn).

image

This indicates that the FBO is correctly set up with an active stencil buffer attached.

However, calling glStencilFunc(GL_EQUAL, 1, 0xFF) does not draw lighting on my foreground pixels (where objects have been drawn). I just get a black screen instead.

image

What am I doing wrong?

7 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/using-the-stencil-buffer-for-the-first-time/112484 Sat, 21 Mar 2026 22:50:35 +0000 No No No community.khronos.org-topic-112484 Using the stencil buffer for the first time Reverse Z Depth Buffer OpenGL Hello,

I am trying to get Reverse Z working for my application but am not quite getting there. I managed to get the scene rendering again (except the skybox but I think that’s just a shader issue) but all my models are inside out and the front objects are being rendered behind the back objects. My setup is +Z forward and matrices should be column major.

I can’t quite figure it out!

I wonder if anyone would be kind enough to take a glance at some of my matrices? And setup?

I change the OpenGL stuff like this at app startup.

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_GREATER);
glClearDepth(0.0f);
glDepthRange(1.0, 0.0);

And then my perspective matrix is changed to this.

void dMat4::SetIdentity() {
    for (int i = 0; i < 16; i++) {
        data[i] = (i % 5 == 0) ? 1.0 : 0.0;
    }
}

void dMat4::SetPerspective(double fov, double aspect, double near, double far) {

    auto tanHalfFov = std::tan(fov * 0.5);

    SetIdentity();

    data[0] = 1.0 / (aspect * tanHalfFov);
    data[5] = 1.0 / tanHalfFov;

    data[10] = 0.0;
    data[11] = 1.0;

    data[14] = near;
    data[15] = 0.0;
}

I also have an GL_DEPTH_COMPONENT32 depth buffer.

Does my perspective matrix look okay? Thanks for any insight you might have. :slight_smile:

10 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/reverse-z-depth-buffer/112483 Sat, 21 Mar 2026 19:46:23 +0000 No No No community.khronos.org-topic-112483 Reverse Z Depth Buffer How should I manage resources used in multiple queue families? Vulkan I’ve been using Vulkan for about 7 months now and I’ve decided to start building a render graph. I was working on barrier generation when I realized I knew nothing about cross queue transfers and release/acquire barrier pairs. Most of what I know has been through AI, so forgive me if anything I say is flawed. I have a handful of questions regarding this matter that I would love help from a real person from though.

1: I noticed on this website this note:

  • VkSharingMode is ignored by the driver, so VK_SHARING_MODE_CONCURRENT incurs no overhead relative to VK_SHARING_MODE_EXCLUSIVE.

Is that really true? Can I still write relatively simple barriers for no cost?

2: If I have a release barrier at the end of a frame that should send a resource from Queue A to Queue B, but my render graph is recompiled and barriers are re-generated, can I treat the orphaned release barrier as if it never existed, or do I have to place an acquire on Queue B before I can do anything meaningful with the resource again?

3: I’m assuming the answer is yes, but is queue family ownership static? For example, if a resource is used on Queue B, I assume I can’t use it Queue A even if I want a couple frames.

Any help would be appreciated on all of these.

5 posts - 2 participants

Read full topic

]]> https://community.khronos.org/t/how-should-i-manage-resources-used-in-multiple-queue-families/112481 Sat, 21 Mar 2026 14:55:34 +0000 No No No community.khronos.org-topic-112481 How should I manage resources used in multiple queue families?