When generating textures you have no guarantee the ids will start with zero or increment by 1. So you may not expect the values will be [0, 1, 2,...] and can not use the active texture as GL_TEXTURE0 + textureID. You will need to create your own auto-incremental system which is best by creating some kind of texture object which will be able to generate the texture, assign both of the IDs and so forth.
To increment the internal ID all you need to do is use a static integer value which increases for every texture you generate. This is the most basic system where you will only load a few textures at some time and then reuse them assuming none of them should be freed and reused. Other systems would need to include some sort of tracing for the released textures and be able to reuse an empty slot.
So for the basics you would have an object/class such as:
static GLint currentActiveTextureID = GL_TEXTURE0;
class ActiveTextureObject {
GLuint textureID;
GLenum activeTextureID;
void generateNew() {
activeTextureID = currentActiveTextureID++;
useActive();
glGenTextures(1, &activeTextureID);
}
void useActive() {
glActiveTexture(activeTextureID);
}
void bind() {
glBindTexture(GL_TEXTURE_2D, textureID);
}
void bindAndUseActive() {
useActive();
bind();
}
};
This now holds all the functionality you posted in your snippet. A method generateNew can also be called in constructor if you so wish. As you can see the object binds together the texture and the active texture so you may simply call bindAndUseActive to do both.
For a more complex system you may use an array of elements which would represent the slots for the active textures. You may then loop through the array to find an empty slot.
class ActiveTexturePool {
static const GLint maximumActiveTextures = 16; // number of maximum units
GLint currentActiveTextureID[maximumActiveTextures]; // have the container
ActiveTexturePool() { // a constructor is needed to reset the data
memset(currentActiveTextureID, 0, sizeof(currentActiveTextureID)); // sets all to zero
}
class ActiveTextureObject {
public:
GLuint textureID;
GLenum activeTextureID;
void generateNew() {
useActive();
glGenTextures(1, &activeTextureID);
}
void useActive() {
glActiveTexture(activeTextureID);
}
void bind() {
glBindTexture(GL_TEXTURE_2D, textureID);
}
void bindAndUseActive() {
useActive();
bind();
}
};
ActiveTextureObject getNewTextureObject() {
ActiveTextureObject toReturn;
for(GLint i=0; i<maximumActiveTextures; i++) {
if(currentActiveTextureID[i] == 0) {
GLenum activeTexture = GL_TEXTURE0 + i;
currentActiveTextureID[i] = activeTexture;
toReturn.activeTextureID = activeTexture;
return toReturn;;
}
}
return NULL; // the pool is full, you may not create another active texture!
}
void recycleTexture(ActiveTextureObject texture) { // remove from the pool
for(GLint i=0; i<maximumActiveTextures; i++) {
if(currentActiveTextureID[i] == texture.activeTextureID) {
currentActiveTextureID[i] = 0;
texture.activeTextureID = 0;
// you may also delete the data here but that should most likely be handled by the ActiveTextureObject
break;
}
}
}
};
Now in this case you would rather create a pool somewhere to handle the textures. You may easily have one or more pools which can be useful for multiple contexts. In the end it might be best to create a class that holds your main context and has a texture pool. The context object may then also create shared context for each of the texture you are generating and also be responsible for removing, recycling the textures and contexts.
