Cumulative masking for Cocos2d-x - c++

Question

Let's say I have a Texture2D object. What I want to be able to do is to mask it using another Texture2D object (I already have a basic masking shader written), and then assign this new masked texture to the original Texture2D. At the next iteration, I then could be able to do this again but for another mask, and again, and again...
Drawing all the masks in a single texture using RenderTexture is not possible since 1) there would be huge performances issues 2) they are generated at runtime.
Here's what I want to do:
Does anyone else ever had this problem or know a solution? Thanks :)
EDIT:
Here's what I'm doing for now:
// Ok, so GroundLayer is a layer that setup GroundZones. GroundZones are ’slices’ of the screen that can be ‘dug’
// into, the act of digging being masking the main ground texture with another texture containing only a line.
// This is where cumulative masking come handy, since we don’t want to have to track each point where the user
// dug. We want to create a sort of mutable texture, but simpler.
void GroundLayer::digLine(Point start, Point end) {
// To dig a line, we need first to get the texture of the zone we will be digging into. Then we get the
// relative position of the start and end point in the zone's node space. Finally we use the custom shader to
// draw a mask over the existing texture.
for (auto it = _children.begin(); it != _children.end(); it++) {
GroundZone *zone = static_cast<GroundZone *>(*it); // We are sure that all the children are GroundZones
Point nodeStart = zone->convertToNodeSpace(start);
Point nodeEnd = zone->convertToNodeSpace(end);
// Now that we have our two points converted to node space, it's easy to draw a mask that contains a line
// going from the start point to the end point and that is then applied over the current texture.
Size groundZoneSize = zone->getContentSize();
RenderTexture *rt = RenderTexture::create(groundZoneSize.width, groundZoneSize.height);
rt->retain();
rt->beginWithClear(0, 0, 0, 0); {
// Draw a line going from start and going to end in the texture, the line will act as a mask over the
// existing texture
DrawNode *line = DrawNode::create();
line->drawSegment(nodeStart, nodeEnd, 20, Color4F::BLACK);
line->visit();
} rt->end();
// We mask current texture with the mask texture using a custom shader. The resulting texture will then be
// affected to the zone's texture, making a new texture that can be used again next function call.
Texture2D *currentTexture = zone->getTexture();
Texture2D *maskTexture = rt->getSprite()->getTexture();
maskTexture->setAliasTexParameters(); // Disable linear interpolation on the mask
// Setup the shader for currentTexture
// Custom shader is already loaded in the init method of GroundLayer
currentTexture->setShaderProgram(ShaderCache::getInstance()->getProgram(CustomShader_AlphaMask_frag_key));
GLProgram *shader = currentTexture->getShaderProgram();
int maskTexUniformLoc = glGetUniformLocation(shader->getProgram(), "u_alphaMaskTexture");
glUniform1i(maskTexUniformLoc, 1);
// Actually apply the shader over currentTexture
shader->use();
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, maskTexture->getName());
glActiveTexture(GL_TEXTURE0);
// [I'm at lost here :( (or sooner...)]
}
}
Here's the shader I wrote:
#ifdef GL_ES
precision mediump float;
#endif
varying vec2 v_texCoord;
uniform sampler2D u_texture;
uniform sampler2D u_alphaMaskTexture;
void main() {
// Mask the texture with the alpha of the texture
float maskAlpha = texture2D(u_alphaMaskTexture, v_texCoord).a;
float texAlpha = texture2D(u_texture, v_texCoord).a;
float blendAlpha = (1.0 - maskAlpha) * texAlpha; // Show only where mask is invisible
vec3 texColor = texture2D(u_texture, v_texCoord).rgb;
gl_FragColor = vec4(texColor, blendAlpha);
return;
}