如何获取各图元深度测试前的片元（像素）数量？OpenGL查询过慢

Hey there! I've dealt with similar problems before, so let's break down the best approaches here—since you already have access to each primitive's ID (thanks to no shared vertices), we can leverage GPU-side operations to avoid the slow OpenGL query overhead.

为什么OpenGL内置查询慢？ #

First off, you're right about OpenGL's glBeginQuery/glEndQuery being too slow for per-primitive counting. Those queries require frequent CPU-GPU synchronization and per-primitive state changes, which kills performance when you're dealing with large numbers of triangles.

方案1：原子计数器（Atomic Counters） #

This is the most straightforward approach for your use case, as it directly maps each primitive to a counter that increments for every rasterized fragment (before depth testing).

步骤： #

• 创建原子计数器缓冲区：
  Allocate a buffer large enough to hold a uint for each primitive (size = number_of_primitives * sizeof(uint)), initialized to 0. Bind it to an atomic counter buffer binding point (e.g., binding 0) with glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, buffer_id).
• 片元着色器实现：
  Declare the atomic counter array, then increment the counter corresponding to the current primitive ID:

  #version 430 core
  
  // Bind to the same binding point as the CPU-side buffer
  layout(binding = 0) uniform atomic_uint primitivePixelCounts[];
  
  void main() {
      // Increment the counter for this primitive (gl_PrimitiveID works since no shared vertices)
      atomicIncrement(primitivePixelCounts[gl_PrimitiveID]);
  }
  

• 绘制与结果读取：
  • Disable depth testing (or set glDepthFunc(GL_ALWAYS)) to ensure every rasterized fragment executes the fragment shader (we want to count all fragments before depth test).
  • Draw your primitives as usual.
  • After drawing, insert a memory barrier to ensure all atomic operations are complete: glMemoryBarrier(GL_ATOMIC_COUNTER_BARRIER_BIT).
  • Map the atomic counter buffer to CPU memory and read the values—each index corresponds to a primitive's pre-depth-test fragment count.

方案2：图像存储（Image Storage） #

If atomic counters feel restrictive, you can use a 1D image texture to store counts instead. The logic is nearly identical, but this might be more flexible if you need to combine counting with other image operations later.

步骤： #

• 创建图像纹理：
  Create a 1D texture with format GL_R32UI, sized to match your number of primitives, initialized to 0. Bind it to an image unit (e.g., unit 0) with glBindImageTexture(0, texture_id, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32UI).
• 片元着色器实现：
  Use imageAtomicAdd to increment the corresponding pixel in the image:

  #version 430 core
  
  layout(binding = 0, r32ui) uniform uimage1D primitivePixelImage;
  
  void main() {
      imageAtomicAdd(primitivePixelImage, gl_PrimitiveID, 1u);
  }
  

• 绘制与结果读取：
  Same as the atomic counter approach: disable depth testing, draw, add a memory barrier (glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT)), then read back the texture data to CPU.

性能优化与注意事项 #

• Depth test handling: Make sure to disable depth testing or set GL_ALWAYS as the depth function—otherwise, fragments that fail the depth test might be discarded before executing the fragment shader, leading to undercounts.
• Atomic operation overhead: While atomic operations have some cost, they're vastly faster than per-primitive OpenGL queries because all work stays on the GPU, with only one final CPU-GPU sync to read results.
• Memory barriers: Don't skip these! They ensure the GPU has finished all atomic operations before you read the data back to the CPU.
• Hardware limits: Check your GPU's limits (e.g., GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE or GL_MAX_IMAGE_UNITS) if you have an extremely large number of primitives. You might need to split counting into batches if you hit limits.

Both of these methods should give you the per-primitive pre-depth fragment counts you need without the performance hit of OpenGL's built-in queries.

内容的提问来源于stack exchange，提问作者Noxitu