as i'm a complete noob with shaders i've got some problems while trying to get to work a 2D lighting system that basically covers the screen with a 2D black texture with transparent holes where the lighten areas are.
As i'm using only one texture I guess that i must do this in the fragment shader, right?
Fragment shader:
[source lang="cpp"] #ifdef GL_ES
precision mediump float;
#endif

// Texture, coordinates and size
uniform sampler2D u_texture;
varying vec2 v_texCoord;
uniform vec2 textureSize;

uniform int lightCount;

struct LightSource
{
vec2 position;
float radius;
float strength;
};

uniform LightSource lights[10];

void main()
{
float alpha = 1.0;

vec2 pos = vec2(v_texCoord.x * textureSize.x, v_texCoord.y * textureSize.y);

int i;
for (i = 0; i < lightCount; i++)
{
LightSource source = lights;

float distance = distance(source.position, pos);

if (distance < source.radius)
{
alpha -= mix(source.strength, 0.0, distance/source.radius);
}
}

gl_FragColor = vec4(0.0, 0.0, 0.0, alpha);
}
[/source]
The problem is that the performance is really terrible (cannot run at 60fps with 2 lights and nothing else on screen), any suggestions to make it better or even different ways to approach this problem?
By the way, i'm doing this from cocos2d-x, so if anyone has any idea that uses cocos2d elements it will be welcome as well

Then what is the alternative?
I thought that it would avoid redundant computations to have one texture on top of the other and light every pixel of them.
I've also though that vertex lighting would not be easy to apply as a big texture is represented by a simple quad...

Sorry about the bad spelling, i've corrected every mistake that i've found.

I don't know about cocos2d-x or IPhone development. So my answer is purely shader oriented.
Because the shader does not seem complicated, and only evaluated once per pixel, is it really the shader that limits the application? (60fps are quite fast isnt it? Maybe it will drop down anyway later on)


- For the shader: You could try to use the squared distance, which maybe calculates faster than taking the root for calculating the distance.
The Lightsource can also directly save the squared radius instead of radius.
But be aware that using the squared values for the (adapted) mixfunction will change the lighting into some kind of quadratic attenuation (maybe a benefit ;-))
Still I dont think this will help alot.

- vec2 pos could be calculated within the vertex shader and interpolated as varying to the fragment shader, maybe this is minimal faster (or slower :-))

- Does the speed vary when you use 1 light compared to when you use 10 ? (In order to test if the uniform is valid for the loop condition)

- You could try to make a full screen mesh grid (for example 20x20) instead of one quad and evaluate distances in vertex shader -> interpolate in fragment shader (quality depends on your light source radii)

- If the lights are small you could render multiple smaller quads, one quad per light at the position of the lights (one quad per light) (But this would most probably need an extra pass)


These are just some fast thoughts, not sure if it helps. Still I think, the shader and the task does not seem like a real performance hitter.

Eeasiest and fastest way is render lights to FBO with one draw call with circle meshes using additive blending. Then draw this texture as fullscreen quad with custom shader that draw black where there are no light using gl20.glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);

I have made library for this and it can easily give 50lights with cheap andoid phones.
http://code.google.com/p/box2dlights/

i've tried optimizing this shader with squared distances and so and i haven't got much better results, so i'm going to change all this shader-based lighting for something similar to what kalle_h said, but have to take a look at the additive blending and see if it's what i'm looking for.

Thanks for all your replies.