How to dynamically keep track of texture units in OpenGL? - c++

Question

I currently creating a texture class for a project I am working on and I am trying to create things well from the start to prevent future headaches.
Currently the way I would load a texture's information to the GPU would be as follows:
void Texture::load_to_GPU(GLuint program)
{
if(program == Rendering_Handler->shading_programs[1].programID)
exit(EXIT_FAILURE);
glUseProgram(program);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureID);
GLint loc = glGetUniformLocation(program, "text");
if(loc == GL_INVALID_VALUE || loc==GL_INVALID_OPERATION)
{
cerr << "Error returned when trying to find texture uniform."
<< "\nuniform: text"
<< "Error num: " << loc
<< endl;
return;
}
glUniform1i(loc,0);
}
I however would like to be able to determine the texture unit dynamically.
For example, rather than hard coding the uniform name "text", I would like to pass the string as an argument, and do something similar to glGetUniformLocation() but for texture units.
In other words I want to select the texture unit to which the texture is to be bound dynamically rather than hard coding it.
For this I need to find a texture unit that is not currently in use, ideally from smallest to largest texture unit.
What set of OpenGL functions could I use to achieve this behaviour?
EDIT:
An important tool I need to achieve the behaviour I want, which I believe is not clear from the original post is:
Once a texture unit is bound to a sampler uniform, I'd like to be able to get the texture unit bound to the uniform.
So if texture unit 5 is bound to the uniform "sampler2d texture_5"
I want a function that takes the uniform label and returns the texture unit bound to that label.

Answer 1

I assume you have all texture binding/unbinding wrapped.
If so, you can use following approach to allocate and free texture units in O(1) time, using O(n) memory.
(I've not seen this approach anywhere else and don't know the name of this data structure. If anyone knows what's it called, I'd appreciate the information.)
constexpr int capacity = 64; // A total number of units.
int size = 0; // Amount of allocated units.
std::vector<int> pool, indices;
void init()
{
pool.resize(capacity);
std::iota(pool.begin(), pool.end(), 0);
indices.resize(capacity);
std::iota(indices.begin(), indices.end(), 0);
}
int alloc()
{
if (size >= capacity)
return -1; // No more texture units.
return pool[size++];
}
void free(int unit)
{
// assert(indices[unit] < size) - if this fails, then you have a double free
size--;
int last_unit = pool[size];
std::swap(pool[indices[unit]], pool[size]);
std::swap(indices[unit], indices[last_unit]);
}