radiotonga

This is a big problem, having already spent almost a month to solve. I'm trying to setup a feedback system for 9 videoplanes in 9 different layers, each having its own .PNG alpha mask that obscures certain areas and accumulates the blending from each preceding layer (blend mode 2 7 or 11 7).

This is fairly simple, yet I would appreciate if someone offers me a better way to do it.

Now, the real trouble begins when I want to pass each layer onto a jit.gl.texture object. Currently, I'm using a g.asyncread mechanism, projecting each layer onto a different texture via counter/gate.

This method doesn't work good in real-time, because it refreshes slowly.

However, If I used 9 gl.asyncreads, my patch begins to suffer enormously.

Please, to the experts, help me find an efficient and elegant alternative please!!!

Below is the simplified patch and attachment with .PNG's.

This is a big problem, having already spent almost a month to solve. I'm trying to setup a feedback system for 9 videoplanes in 9 different layers, each having its own .PNG alpha mask that obscures certain areas and accumulates the blending from each preceding layer (blend mode 2 7 or 11 7).   

This is fairly simple, yet I would appreciate if someone offers me a better way to do it. 

This method doesn't work good in real-time, because it refreshes slowly.
However, If I used 9 gl.asyncreads, my patch begins to suffer enormously.

Please, to the experts, help me find an efficient and elegant alternative please!!! 

Below is the simplified patch and attachment with .PNG's. 

videoplane-alpha-feedback-w-gl-asyncread

there is no need to use asyncread for this. you are going from CPU (the original matrix) to GPU (the videoplane) back to CPU (the asyncread) back to GPU (the gl.texture).

just stay on the GPU. set the @capture attribute on each of your videoplanes to the corresponding named texture.

search the forum for more information, or post back here if you need more help.

I have already tried this concept with no success, perhaps I'm doing it wrong...

(I should point out that I'm not working with slabs because I was informed by some posts that alpha blending was most efficiently done with videoplanes or meshes: this is for a large patch and I need the most natural and respectful blending.)

If I set @capture on my videoplanes, the accumulative alpha blending is cut because any further videoplane will not be receiving the information. This could be bypassed with a texture for every videoplane, in the manner:

videoplane 2 (texture tex1, capture tex2)

videoplane 3 (texture tex2, capture tex3)

However, this doesn't happen. Add to this the fact that my videoplanes were supposed to foster a .PNG file which would be alpha blended with the preceding plane. With this method, I would probably need 2 textures per videoplane: "tex#" for receiving the preceding videoplane and "png#" for blending the .PNG with "tex#".

Below is the patch, because a "picture" is worth a thousand words. In it, the only videoplane that is displayed is the one that isn't set for @capture.

videoplane 1 (capture tex1)
|
tex1
|
videoplane 2 (texture tex1, capture tex2)
|
tex 2
|
videoplane 3 (texture tex2, capture tex3)
|
etc.

i'm still not sure of your desired end result, however it sounds to me like your best bet would be to create a custom shader to blend your textures using whatever method you like.

here is a basic example which combines (additive) the alpha values of the four png masks you've provided in a single shader, applies this as the alpha channel for a fifth texture before outputting to a videoplane.

also, there is no blend_mode 11 7. the highest source blend_mode is 10.

I'm working with gl.model, where each group (9) needs a different texture with a different alpha composite image. So, I need the same number of unique videoplanes than textures, like a slab chain but with the more efficient videoplanes.

I have done two examples in order to further illustrate this, one consists of a slab chain feeding 4 different results to 4 different textures with a modified shader. The other consists of an obtuse videoplane/capture method to 4 different textures, which however don't render as should.

Please take the time to see and recommend me the best solution. The reason I'm stubborn is because I'm working with a modest computer that it's already tolled with MSP and computer vision processing, so any economic/efficient workaround is needed.

I have done two examples in order to further illustrate this, one consists of a slab chain feeding 4 different results to 4 different textures with a modified shader. The other consists of an obtuse videoplane/capture method to 4 different textures, which however don't render as should.
Both are detailed and commented.

videoplane alpha feedback (w/ gl.asyncread)