OpenGL | OpenGL support library so you can just dive in and write | Graphics library

You currently are using glEnable(GL_DEPTH_TEST) withglDepthFunc(GL_LESS), which means only fragments having a smaller z (or depth) component are rendered when rendering overlapped triangles. Since your vertex positions are defined with the back-face having a smaller z coordinate than the front-face, all front-face fragments are ignored (since their z coordinate is larger).

Solutions are:

• Using glDepthFunc(GL_GREATER) instead of glDepthFunc(GL_LESS) (which may not work in your case, considering your vertices have z <= 0.0 and the depth buffer is cleared to 0.0)
• Modify your vertex positions to give front-face triangles a smaller z component than back-face triangles.

I believe that when using matrix transforms, a smaller z component normally indicates the fragment is closer to the camera, which is why glDepthFunc(GL_LESS) is often used.

Alpha test is a (since ages deprecated) method to only draw fragments when they match some alpha function. Nowadays this can easily be done inside a shader by just discarding the fragments. Alpha testing in itself is also very limited, because it can only decide to draw a fragment or not.

In general, enabling GL_ALPHA_TEST without setting a proper glAlphaFunc will do nothing since the default comparison function is GL_ALWAYS which means that all fragments will pass the test.

Your code doesn't seem to rely on alpha testing, but on blending (I assume that since you are setting the glBlendFunc). Somewhere in your code there's probably also a glEnable(GL_BLEND).

Issue was successfully fixed in Android Emulator revision 31.2.7. Just go to Android SDK Manager and update it!

According to android emulator release notes:

You're in a special case where your fragments are either fully opaque or fully transparent, so it's possible to get depth-testing and blending to work at the same time. The actual problem is, that for depth testing even a fully transparent fragment will store it's depth value. You can prevent the writing by explicitly discarding the fragment in the shader. Something like:

There is glClearTexImage, but it was introduced in OpenGL 4.4; see if it's available to you with the ARB_clear_texture extension.

If you're absolutely restricted to the core OpenGL 2.1, allocating client memory and issuing a glTexImage2D call is the only way of doing that. In particular you cannot even render to a texture with unextended OpenGL 2.1, so tricks like binding the texture to a framebuffer (OpenGL 3.0+) and calling glClearColor aren't applicable. However, a one-time allocation and initialization of a 1-16MB texture isn't that big of a problem, even if it feels 'stupid'.

Also note that a newly created texture image is undetermined; you cannot rely on it being all zeros, thus you have to initialize it one way or another.

In tutorial 1 of the link in the comment, the author introduces

See glVertexAttribPointer Each byte is a single component of the attribute and converted to a floating point value. If the argument normalized is set to GL_TRUE, GL_UNSIGNED_BYTE components are treated as unsigned normalized values and mapped from the range [0, 255] to [0.0, 1.0].

If you want to use integer attributes (int, ivec2, ivec3, ivec4) you must use glVertexAttribIPointer (focus on I) to load attributes from arrays with integral component values. glVertexAttribIPointer keeps the integral numbers and does not convert them to floating point numbers.

Note that the type argument does not say anything about the type of the shader attribute. It only specifies the type of source data in the array.

Not possible. SDL2 does not include a full-fledged rendering engine.

Some options:

• You could adopt Skia (the graphics library used in Chrome, among ohters) and then either stick with a software renderer, or instantiate an OpenGL context and use the hardware backend.

• You could use another 2D drawing library such as Raylib

• Or just bite the bullet and draw your triangles using OpenGL.

Instead of passing a texture handle to glUniform1i(glGetUniformLocation(ID, "textureSampler"), ...), you need to pass a texture slot index.

E.g. if you did glActiveTexture(GL_TEXTUREn) before binding the texture, pass n.