Crash when rendering

[laurent7601]

Error of my part sorry, problem explained on the next post.

[laurent7601]

Hi! I’m trying to use some mesa extensions to use modern opengl features but I got a crash while rendering : ../src/gallium/drivers/r600/evergreend_state.c:4933: evergreen_atimic_buffer_setup: Assertion 'resource' failed.

Here is the source code I’m trying to make it simple because I’m starting with those new functionnalities, si I simply want to increment the counter each time a fragment is draw and write the value to texture.

So, here is the code

I created the atomic buffers first

            GLuint atomicsBuffer;
            glGenBuffers(1, &atomicsBuffer);
            // bind the buffer and define its initial storage capacity
            glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomicsBuffer);
            glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), NULL, GL_DYNAMIC_DRAW);
            // unbind the buffer
            glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0);

Then I clear the buffer at each draw call

                glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, atomicsBuffer);
                GLuint a[1] = {0};
                glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0 , sizeof(GLuint), a);
                glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, 0);

and finally I draw the scene

                currentStates.shader = &countNbLayers;
                std::map<physic::BoundingBox, std::pair<unsigned int, std::vector<Instance>>>::iterator it;
                for (it = m_newInstances.begin(); it != m_newInstances.end(); it++) {
                    for (unsigned int i = 0; i < it->second.second.size(); i++) {
                        nbLayersCount.draw(it->second.second[i].getAllVertices(),currentStates);
                    }
                }
                nbLayersCount.display();

Why does it crash ?

[Alfonse_Reinheart]

FYI: If you want to add more to a post, you can just edit the post and add more to it. You shouldn’t make posts in sequence like this just to add more details. The edit button is the pencil icon in the ... menu.

Also, you can use fenced ``` back-ticks to put code inside code-blocks. That would make your code a lot more legible.

All that being said, there’s really not enough of your code to know why it crashes.

[laurent7601]

I tried the edit button but it didn’t worked.

and how to put code inside blocks ?

I tried to bind the atomic counter buffer location but it didn’t solved the crash, if you want more source code, I can upload it on git because there is a lot of code.

It seems that, when the atomicCounterIncrement function is called in the fragment shader, the uniform variable passed to the function is null, so, the binding is not set in the shader, so, the resource (the buffer) is null.
Even if I bind the buffer here with this function
glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, atomicsBuffer);

PS : I have a question, bindings needs to create a VAO or not ?

[laurent7601]

Er, actually, when I create the atomic buffer in the constructor, the buffer size is one, but when I want to use it in the render loop its size is 0.
And I use several openGL context. (one by FBO)
Uh, the atomic buffer is not shared between different opengl contexts or what?

@Translated from

Heu, en fait, lorsque je crée l’atomic buffer dans le constructeur, la taille du buffer est de un, mais lorsque je veux l’utiliser dans la boucle de rendu sa taille est de 0.
Et j’utilise plusieurs contexte openGL. (une par FBO)
Heu, les atomic buffer ne sont pas partagé entre les différent contextes opengl ou quoi ?

[laurent7601]

It’s good I resolved the crash in fact I initialized the buffer to 0 in the constructor and not in the rendering function, it looks like the counter resets itself and the buffer this empty so …

@Translated from:

C’est bon j’ai résolu le crash en fait j’ai initialisé le buffer à 0 dans le constructeur et non pas dans la fonction de rendu, on dirait que le compteur se réinitialise de lui même et le buffer ce vide donc…

[khronos]

Edited your code with code tags. Please checkout our Forum Posting Guidelines for more information.

Forum Posting Guidelines

The best way to get help in this forum is to ask your questions in a way that makes it easiest for us to give you help. Consider the following to be a series of informal guidelines for posting questions. Before you post Before you ask questions of others, it is respectful to put forth some effort in solving the issue yourself. It is generally faster for you (if your question has already been answered) and it keeps down the number of redundant or simple questions the forums receive. To this end…

[laurent7601]

Ha but mashed I’m stupid I removed the identifier of the buffer, in the manufacturer and not in the class so necessarily at the end of the constructor it is destroyed.

@Translated from

Ha mais purée je suis bête j’ai délcaré l’identifiant du buffer, dans le constructeur et pas dans la classe donc forcément à la fin du constructeur il est détruit.

[Dark_Photon]

@laurent7601, to increase the chance of your getting useful feedback, please post your comments in English.

@laurent7601

the atomic buffer is not shared between different opengl contexts or what?

For details, see section 5 in the OpenGL 4.6 Spec (linked to OpenGL Registry). In particular, the mention of atomics and how changes to shared objects are propagated betweeen contexts.

Also, for useful background info, see the ARB_shader_atomic_counters extension and mentions of shared contexts. For example, in the Q&A:

@ARB_shader_atomic_counters

12 - Can the atomic counters be shared between contexts?

 Resolved:  Not directly, but they may be shared indirectly by sharing the
 buffer objects that back them.

13 - Should we be able to write atomic counters to a buffer object?

 Resolved.  Yes.  (Note that buffer objects can be shared.
 The result of updating atomic counters in multiple contexts
 backed with the same buffer object is undefined.)

…
17 - What happens to shared buffer objects that are updated in
more than one context by data-setting commands, including
the built-in atomic counter functions?

 Resolved:  They should follow the same rules as other shared
 buffer objects.  (That is, care must be taken when updating
 atomic counters in one context and using them in another
 context.)  Further, the atomic built-in functions are
 atomic in a single context, but there is no guarantee that
 they are atomic across contexts.