Textures from one VAO being applied to another VAO - c++

Question

I am currently trying to render text in OpenGL using bitmap files. When it's by itself, the font looks as expected.
Exhibit A:
When adding a separate texture (a picture) in a separate VAO OR more text in the same VAO, "This engine can render text!" still looks the same.
However, when adding both the texture in a separate VAO AND more text in the same VAO, the texture of "This engine can render text!" gets modified.
Exhibit B:
What's really strange to me is that the textures seem to be blended, and that it only affects a few vertices rather than the entire VBO.
Is this a problem of OpenGL/poor drivers, or is it something else? I double checked the vertices and the 'his' aren't being rendered with the picture texture active. I am using OSX which is notorious for poor OpenGL support, if it might help.
My rendering loop:
//scene is just a class that bundles all the necessary information for rendering.
//when rendering text, it is all batched inside of one scene,
//so independent textures of text characters should be impossible
glUseProgram(prgmid);
for(auto& it : scene->getTextures() )
{
//load textures
const Texture::Data* data = static_cast<const Texture::Data*>(it->getData() );
glActiveTexture(GL_TEXTURE0 + it->getID() );
glBindTexture(GL_TEXTURE_2D, it->getID() );
glUniform1i(glGetUniformLocation(prgmid, data->name), it->getID() );
}
for(auto& it : scene->getUniforms() )
{
processUniforms(scene, it, prgmid);
}
glBindVertexArray(scene->getMesh()->getVAO() );
glDrawElements(GL_TRIANGLES, scene->getMesh()->getDrawCount(), GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
Shaders of the text:
//Vertex
#version 330 core
layout (location = 0) in vec4 pos;
layout (location = 1) in vec2 fontTexCoord;
out vec2 fontTexCoords;
uniform mat4 __projection;
void main()
{
fontTexCoords = vec2(fontTexCoord.x, fontTexCoord.y);
gl_Position = __projection * pos;
}
//Frag
#version 330 core
in vec2 fontTexCoords;
out vec4 color;
uniform sampler2D fontbmp;
void main()
{
color = texture(fontbmp, fontTexCoords);
if(color.rgb == vec3(0.0, 0.0, 0.0) ) discard;
}
Shaders of the picture:
//vert
#version 330 core
layout (location = 0) in vec4 pos;
layout (location = 1) in vec2 texCoord;
out vec2 TexCoords;
uniform mat4 __projection;
uniform float __spriteFrameRatio;
uniform float __spriteFramePos;
uniform float __flipXMult;
uniform float __flipYMult;
void main()
{
TexCoords = vec2(((texCoord.x + __spriteFramePos) * __spriteFrameRatio) * __flipXMult, texCoord.y * __flipYMult);
gl_Position = __projection * pos;
}
//frag
#version 330 core
in vec2 TexCoords;
out vec4 color;
uniform sampler2D __image;
uniform vec4 __spriteColor;
uniform bool __is_texture;
void main()
{
if(__is_texture)
{
color = __spriteColor * texture(__image, TexCoords);
}
else
{
color = __spriteColor;
}
}
EDIT:
I believe the code that is causing the problem has to do with generating the buffers. It's called everytime when rendered for each scene (VAO, VBO, EBO, texture) object.
if(!REALLOCATE_BUFFER && !ATTRIBUTE_ADDED) return;
glBindVertexArray(_vao);
glBindBuffer(GL_ARRAY_BUFFER, _vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo);
if(REALLOCATE_BUFFER)
{
size_t vsize = _vert.size() * sizeof(decltype(_vert)::value_type);
size_t isize = _indc.size() * sizeof(decltype(_indc)::value_type);
if(_prevsize != vsize)
{
_prevsize = vsize;
glBufferData(GL_ARRAY_BUFFER, vsize, &_vert[0], _mode);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, isize, &_indc[0], _mode);
}
else
{
glBufferSubData(GL_ARRAY_BUFFER, 0, vsize, &_vert[0]);
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, isize, &_indc[0]);
}
}
if(ATTRIBUTE_ADDED)
{
for(auto& itt : _attrib)
{
glVertexAttribPointer(itt.index, itt.size, GL_FLOAT, itt.normalized, _currstride * sizeof(GLfloat), (GLvoid*)(itt.pointer * sizeof(GLfloat) ) );
glEnableVertexAttribArray(itt.index);
}
}
glBindVertexArray(0);
When we comment out glBufferSubData so that glBufferData is always called, the problem area flickers and iterates through all textures, including the ones in other VAOs.
EDIT 2:
For some reason, everything works as expected when the text is rendered with a different mode than the picture, say GL_STREAM_DRAW and GL_DYNAMIC_DRAW, for instance. How can this be?

Answer 1

So the thing I messed up was that getDrawCount() was returning the number of VERTICES rather than the number of indices. Astonishingly, this didn't cause OpenGL to throw any errors and fixing it solved the flickering.