Followers 0

# OpenGL Forcing early Z, which extension to use?

## 12 posts in this topic

As far as my research has shown that there are two different extensions that can be used to force an early Z test in OpenGL 3.0. these are GL_ARB_conservative_depth and GL_ARB_shader_image_load_store. According to the spec they can be used to force early Z in glsl like so:

GL_ARB_conservative_depth:

layout(depth_unchanged) out float gl_FragDepth;


layout(early_fragment_tests) in;


My question is do these have the exact same effect? if so can I use them interchangeably, if not which one should I use?

0

##### Share on other sites

Does not load like image_load_store has anything to do with early depth test. So no, you should use the conservative depth.

Yeah I know that the purpose of the extension is not specifically for early z tests but it can be used to enable them as I read here:

http://www.opengl.org/wiki/Early_Depth_Test#Explicit_specification

What I was hoping was that cards that didn't support GL_ARB_conservative_depth might support GL_ARB_shader_image_load_store to be used as a fallback or vice versa.

1

##### Share on other sites

I don't know. I just read that and nothing there suggests anything you are talking about. It is talking about how one thing affects the other. It says nothing about how textures (image load store) will effect depth testing. It does however say how depth testing will affect the image load store.

FYI from that page: "Thus the first restriction on early depth tests is that they cannot happen if the fragment shader writes gl_FragDepth?. If the fragment shader modifies the depth, then the depth test must wait until after the fragment shader executes."

In GL 2.0 (and it seems it has carried on to newer versions). If you don't write the depth in the shader, early z-cull and depth writing already takes place.

0

##### Share on other sites

FYI from that page: "Thus the first restriction on early depth tests is that they cannot happen if the fragment shader writes gl_FragDepth?. If the fragment shader modifies the depth, then the depth test must wait until after the fragment shader executes."

I'm sorry but you clearly didn't read that entire article, the use of that syntax for forcing early Z requires GL_ARB_shader_image_load_store:

More recent hardware can force early depth tests, using a special fragment shader layout qualifier:

layout(early_fragment_tests) in;

This will also perform early stencil tests.

...

This feature exists to ensure proper behavior when using Image Load Store or other incoherent memory writing.

Its mentioned in the spec too:

An explicit control is provided to allow fragment shaders to enable early

fragment tests. If the fragment shader specifies the
"early_fragment_tests" layout qualifier, the per-fragment tests described
in Section 3.X will be performed prior to fragment shader execution.
Otherwise, they will be performed after fragment shader execution.
Edited by ic0de
0

##### Share on other sites

In GL 2.0 (and it seems it has carried on to newer versions). If you don't write the depth in the shader, early z-cull and depth writing already takes place.

Yep.

I don't think OpenGL 2 even has the notion of early depth test at all (much like how it doesn't specify the exact algorithm for defining the shape of triangles). It was an optimization done by the hardware and as long as it gave the expected results it could do anything it wanted, so early depth tests worked by default simply because there was nothing against it. I imagine that disabling it if you modify the depth in a pixel shader has to do with caching (it invalidates the value in the cache).

1

##### Share on other sites
I don't think OpenGL 2 even has the notion of early depth test at all (much like how it doesn't specify the exact algorithm for defining the shape of triangles). It was an optimization done by the hardware and as long as it gave the expected results it could do anything it wanted, so early depth tests worked by default simply because there was nothing against it. I imagine that disabling it if you modify the depth in a pixel shader has to do with caching (it invalidates the value in the cache)..

Using blending will also disable this hardware optimization, for PowerVR at least.  They call this feature "Tile Based Deferred Rendering" in case anyone wants to look it up.  Those little machines can handle a lot until you turn on blending, and presumably pixel shader depth writes.  Once you do this they slow to a crawl.

I haven't gone to any trouble to see if the other embedded system manufacturers have similar schemes running under the hood.

0

##### Share on other sites
Well as this article (which I didn't initially read) suggests, some cards support this and they use the word "explicitly" which implies that there is an "implicit" case.
ATI and NVIDIA are going to be supporting this early optimization. I don't know anything that suggests otherwise and have read some internal docs.

This extension also provides the capability to explicitly enable "early"
per-fragment tests, where operations like depth and stencil testing are
performed prior to fragment shader execution.  In unextended OpenGL,
fragment shaders never have any side effects and implementations can
sometimes perform per-fragment tests and discard some fragments prior to
executing the fragment shader.
0

##### Share on other sites

http://gamedev.stackexchange.com/questions/16588/computing-gl-fragdepth

It has been existing for a long time. Also its not just early z-cull, its hierarchical early z-cull.  Look up hierarchical occlusion culling. Graphics cards support this on a per-triangle level, which would not be possible if the shader executed first.

I believe the extension is explicitly able to perform the depth test by reading the depth buffer. Look up "discard".  You can discard any fragment in GL, to explicitly discard if (z < depthBuffer.z), you were not allowed direct access to the depth buffer. I don't know but am assuming that you are now allowed to read it. This may only be if you are using an FBO though........

0

##### Share on other sites

Using blending will also disable this hardware optimization, for PowerVR at least.  They call this feature "Tile Based Deferred Rendering" in case anyone wants to look it up.  Those little machines can handle a lot until you turn on blending, and presumably pixel shader depth writes.  Once you do this they slow to a crawl.

Is this tested? Have you tried enabling and then disabling depth test on enough blended fragments to test the performance is actually different? Seems strange this would happen since GL is a state machine.
0

##### Share on other sites

Using blending will also disable this hardware optimization, for PowerVR at least.  They call this feature "Tile Based Deferred Rendering" in case anyone wants to look it up.  Those little machines can handle a lot until you turn on blending, and presumably pixel shader depth writes.  Once you do this they slow to a crawl.

That would explain how they got OpenGL ES to work on that hardware in the first place.

I know what the algorithm does, it was used in the Dreamcast too, it's basically like an extremely simplified version of raytracing more or less. The more obvious issue, as you can imagine, is that such a thing doesn't even need the depth buffer at all, it processes all triangles and sorts them together (which is also how the Dreamcast got sort-independent alpha blending). I imagine the main reason Sega went with it back then is that it allowed for many more triangles at a much smaller fillrate.

I don't know how different is the current TBDR compared to the one from back then, but I presume that to get the same performance gains it must cheat a lot to work with OpenGL ES.

0

##### Share on other sites
Well as this article (which I didn't initially read) suggests, some cards support this and they use the word "explicitly" which implies that there is an "implicit" case.
ATI and NVIDIA are going to be supporting this early optimization. I don't know anything that suggests otherwise and have read some internal docs.

This extension also provides the capability to explicitly enable "early"
per-fragment tests, where operations like depth and stencil testing are
performed prior to fragment shader execution.  In unextended OpenGL,
fragment shaders never have any side effects and implementations can
sometimes perform per-fragment tests and discard some fragments prior to
executing the fragment shader.

I think this extension is worded in a way that may be somewhat misleading, though at least they've put "early" in quotes. The same goes for the (wiki, by the way, so caveat emptor) page on opengl.org that you've dug up.

There is no "forcing early z" in OpenGL. OpenGL does not have any such thing as an "early z" at all, so you cannot enforce it. The specification is very clear about when the z test happens, and it is not "early", it is after the fragment shader has run. Still, implementations are allowed to do something different as long as the observable result is exactly identical, and most modern implementations in fact do something different.

If you search the OpenGL specification for "early", you find 3 occurrences of "linearly" and two occurrences of "clearly" (because Adobe Reader has no notion of searching for whole words), but "early" has no appearance at all. In particular, the additions to chapter 3 in above extension spec are funny because for example section 3.12.2 does not even exist in my copy of the specification (it stops at 3.11). They must be using a different copy

A better wording would be that you can give a strong hint to the implementation which effectively forces early z test on implementations that do an early z test (or, on most mainstream implementations).

The thing is, a modern implementation would of course always like to do the z test early, because this saves shader work. Insofar there is no need to "force" it. It's trying hard to do it anyway. However, the implementation must still guarantee that the result is the same, which it can only do with some very harsh constraints (for example if the shader does not modify z, so it is already known what the value will be long before the shader runs).

Now, by using a qualifier that tells the implementation so-and-so, you give a promise (for example "depth will not change" for "depth will always be greater"), or in the second example that you've given, you ask for a specific behaviour.

By doing so, you give a promise to the implementation that you know what you're doing, and that you guarantee that whatever you do will not cause the results to be wrong if it performs the early z optimization. You can of course break your promise or do something that will not work with the behaviour that you request, but this is very unwise -- that'd be welcome to the land of undefined behaviour.

Taking your word on that promise, the implementation will of course do the optimization (that's pretty much guaranteeed). In a way, you could maybe interprete this as "force on", but it really isn't. It's more "enabling" or "allowing" the implementation to do something outside the specification.

Edited by samoth
0

##### Share on other sites
This feature exists to ensure proper behavior when using Image Load Store or other incoherent memory writing.

To me, the part where it says, 'when using' seems fairly explicit.

"...this ensures that image load/store operations will only happen on fragments that pass the depth test."

I would say from what is written in that document that GL_ARB_conservative_depth is a filter for  GL_ARB_shader_image_load_store.

It states that GL_ARB_conservative_depth is meant to prevent operations on  GL_ARB_shader_image_load_store from being executed when the fragment fails the depth test.

I don't see anything that says they can be interchangeable replacements or substitutes for one another.

0

##### Share on other sites

ic0de, I think the summary is openGL may or may not allow this, but the hardware for great graphics cards (AMD/NVIDIA ...Intel should as well), requires heavy optimization to make powerful cards. They will take care of it whether openGL does or not.

0

## Create an account

Register a new account

Followers 0

• ### Similar Content

• So it's been a while since I took a break from my whole creating a planet in DX11. Last time around I got stuck on fixing a nice LOD.
A week back or so I got help to find this:
https://github.com/sp4cerat/Planet-LOD
In general this is what I'm trying to recreate in DX11, he that made that planet LOD uses OpenGL but that is a minor issue and something I can solve. But I have a question regarding the code
He gets the position using this row
vec4d pos = b.var.vec4d["position"]; Which is then used further down when he sends the variable "center" into the drawing function:
if (pos.len() < 1) pos.norm(); world::draw(vec3d(pos.x, pos.y, pos.z));
Inside the draw function this happens:
draw_recursive(p3[0], p3[1], p3[2], center); Basically the 3 vertices of the triangle and the center of details that he sent as a parameter earlier: vec3d(pos.x, pos.y, pos.z)
Now onto my real question, he does vec3d edge_center[3] = { (p1 + p2) / 2, (p2 + p3) / 2, (p3 + p1) / 2 }; to get the edge center of each edge, nothing weird there.
But this is used later on with:
vec3d d = center + edge_center[i]; edge_test[i] = d.len() > ratio_size; edge_test is then used to evaluate if there should be a triangle drawn or if it should be split up into 3 new triangles instead. Why is it working for him? shouldn't it be like center - edge_center or something like that? Why adding them togheter? I asume here that the center is the center of details for the LOD. the position of the camera if stood on the ground of the planet and not up int he air like it is now.

Full code can be seen here:
https://github.com/sp4cerat/Planet-LOD/blob/master/src.simple/Main.cpp
If anyone would like to take a look and try to help me understand this code I would love this person. I'm running out of ideas on how to solve this in my own head, most likely twisted it one time to many up in my head
Toastmastern

• I googled around but are unable to find source code or details of implementation.
What keywords should I search for this topic?
Things I would like to know:
A. How to ensure that partially covered pixels are rasterized?
Apparently by expanding each triangle by 1 pixel or so, rasterization problem is almost solved.
But it will result in an unindexable triangle list without tons of overlaps. Will it incur a large performance penalty?
How to ensure proper synchronizations in GLSL?
GLSL seems to only allow int32 atomics on image.
C. Is there some simple ways to estimate coverage on-the-fly?
In case I am to draw 2D shapes onto an exisitng target:
1. A multi-pass whatever-buffer seems overkill.
2. Multisampling could cost a lot memory though all I need is better coverage.
Besides, I have to blit twice, if draw target is not multisampled.

• By mapra99
Hello

I am working on a recent project and I have been learning how to code in C# using OpenGL libraries for some graphics. I have achieved some quite interesting things using TAO Framework writing in Console Applications, creating a GLUT Window. But my problem now is that I need to incorporate the Graphics in a Windows Form so I can relate the objects that I render with some .NET Controls.

To deal with this problem, I have seen in some forums that it's better to use OpenTK instead of TAO Framework, so I can use the glControl that OpenTK libraries offer. However, I haven't found complete articles, tutorials or source codes that help using the glControl or that may insert me into de OpenTK functions. Would somebody please share in this forum some links or files where I can find good documentation about this topic? Or may I use another library different of OpenTK?

Thanks!

• Hello, I have been working on SH Irradiance map rendering, and I have been using a GLSL pixel shader to render SH irradiance to 2D irradiance maps for my static objects. I already have it working with 9 3D textures so far for the first 9 SH functions.
In my GLSL shader, I have to send in 9 SH Coefficient 3D Texures that use RGBA8 as a pixel format. RGB being used for the coefficients for red, green, and blue, and the A for checking if the voxel is in use (for the 3D texture solidification shader to prevent bleeding).
My problem is, I want to knock this number of textures down to something like 4 or 5. Getting even lower would be a godsend. This is because I eventually plan on adding more SH Coefficient 3D Textures for other parts of the game map (such as inside rooms, as opposed to the outside), to circumvent irradiance probe bleeding between rooms separated by walls. I don't want to reach the 32 texture limit too soon. Also, I figure that it would be a LOT faster.
Is there a way I could, say, store 2 sets of SH Coefficients for 2 SH functions inside a texture with RGBA16 pixels? If so, how would I extract them from inside GLSL? Let me know if you have any suggestions ^^.
• By KarimIO
EDIT: I thought this was restricted to Attribute-Created GL contexts, but it isn't, so I rewrote the post.
Hey guys, whenever I call SwapBuffers(hDC), I get a crash, and I get a "Too many posts were made to a semaphore." from Windows as I call SwapBuffers. What could be the cause of this?
Update: No crash occurs if I don't draw, just clear and swap.
static PIXELFORMATDESCRIPTOR pfd = // pfd Tells Windows How We Want Things To Be { sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor 1, // Version Number PFD_DRAW_TO_WINDOW | // Format Must Support Window PFD_SUPPORT_OPENGL | // Format Must Support OpenGL PFD_DOUBLEBUFFER, // Must Support Double Buffering PFD_TYPE_RGBA, // Request An RGBA Format 32, // Select Our Color Depth 0, 0, 0, 0, 0, 0, // Color Bits Ignored 0, // No Alpha Buffer 0, // Shift Bit Ignored 0, // No Accumulation Buffer 0, 0, 0, 0, // Accumulation Bits Ignored 24, // 24Bit Z-Buffer (Depth Buffer) 0, // No Stencil Buffer 0, // No Auxiliary Buffer PFD_MAIN_PLANE, // Main Drawing Layer 0, // Reserved 0, 0, 0 // Layer Masks Ignored }; if (!(hDC = GetDC(windowHandle))) return false; unsigned int PixelFormat; if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd))) return false; if (!SetPixelFormat(hDC, PixelFormat, &pfd)) return false; hRC = wglCreateContext(hDC); if (!hRC) { std::cout << "wglCreateContext Failed!\n"; return false; } if (wglMakeCurrent(hDC, hRC) == NULL) { std::cout << "Make Context Current Second Failed!\n"; return false; } ... // OGL Buffer Initialization glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); glBindVertexArray(vao); glUseProgram(myprogram); glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, (void *)indexStart); SwapBuffers(GetDC(window_handle));

• 10
• 11
• 19
• 14
• 23